frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/hw/dmx/glxProxy/glxcmds.c

3633 lines
98 KiB
C
Raw Blame History

/* $XFree86: xc/programs/Xserver/GL/glx/glxcmds.c,v 1.8 2001/05/02 15:06:05 dawes Exp $ */
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
*/
#include "dmx.h"
#include "dmxwindow.h"
#include "dmxpixmap.h"
#include "dmxfont.h"
#include "dmxsync.h"
#undef Xmalloc
#undef Xcalloc
#undef Xrealloc
#undef Xfree
#define NEED_REPLIES
#define FONT_PCF
#include "glxserver.h"
#include <GL/glxtokens.h>
#include "g_disptab.h"
#include <pixmapstr.h>
#include <windowstr.h>
#include "glxutil.h"
#include "glxext.h"
#include "unpack.h"
#include "GL/glx_ansic.h"
#include "GL/glxproto.h"
#include "glxvendor.h"
#include "glxvisuals.h"
#include "glxswap.h"
#ifdef PANORAMIX
#include "panoramiXsrv.h"
extern XID *PanoramiXVisualTable;
#endif
extern __GLXFBConfig **__glXFBConfigs;
extern int __glXNumFBConfigs;
extern __GLXFBConfig *glxLookupFBConfig( GLXFBConfigID id );
extern __GLXFBConfig *glxLookupFBConfigByVID( VisualID vid );
extern __GLXFBConfig *glxLookupBackEndFBConfig( GLXFBConfigID id, int screen );
extern int glxIsExtensionSupported( char *ext );
extern int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
#define BE_TO_CLIENT_ERROR(x) \
( (x) >= __glXerrorBase ? \
(x) - dmxScreen->glxErrorBase + __glXerrorBase \
: (x) )
Display *GetBackEndDisplay( __GLXclientState *cl, int s )
{
if (! cl->be_displays[s] ) {
cl->be_displays[s] = XOpenDisplay( DisplayString(dmxScreens[s].beDisplay) );
}
return( cl->be_displays[s] );
}
/*
** Create a GL context with the given properties.
*/
static int CreateContext(__GLXclientState *cl,
GLXContextID gcId,
VisualID vid, GLXFBConfigID fbconfigId,
int screen,
GLXContextID shareList,
int isDirect )
{
ClientPtr client = cl->client;
xGLXCreateContextReq *be_req;
xGLXCreateNewContextReq *be_new_req;
VisualPtr pVisual;
ScreenPtr pScreen;
__GLXcontext *glxc, *shareglxc;
__GLXvisualConfig *pGlxVisual;
__GLXscreenInfo *pGlxScreen;
VisualID visual = vid;
GLint i;
int from_screen = screen;
int to_screen = screen;
DMXScreenInfo *dmxScreen;
VisualID be_vid;
GLXFBConfigID be_fbconfigId;
int num_be_screens;
Display *dpy;
/*
** Check if screen exists.
*/
if (screen >= screenInfo.numScreens) {
client->errorValue = screen;
return BadValue;
}
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
/*
** Find the display list space that we want to share.
**
*/
if (shareList == None) {
shareglxc = NULL;
} else {
shareglxc = (__GLXcontext *) LookupIDByType(shareList, __glXContextRes);
if (!shareglxc) {
client->errorValue = shareList;
return __glXBadContext;
}
}
/*
** Allocate memory for the new context
*/
glxc = (__GLXcontext *) __glXMalloc(sizeof(__GLXcontext));
if (!glxc) {
return BadAlloc;
}
__glXMemset(glxc, 0, sizeof(__GLXcontext));
pScreen = screenInfo.screens[screen];
pGlxScreen = &__glXActiveScreens[screen];
if (fbconfigId != None) {
glxc->pFBConfig = glxLookupFBConfig( fbconfigId );
if (!glxc->pFBConfig) {
client->errorValue = fbconfigId;
__glXFree( glxc );
return BadValue;
}
visual = glxc->pFBConfig->associatedVisualId;
}
else {
glxc->pFBConfig = NULL;
}
if (visual != None) {
/*
** Check if the visual ID is valid for this screen.
*/
pVisual = pScreen->visuals;
for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
if (pVisual->vid == visual) {
break;
}
}
if (i == pScreen->numVisuals) {
client->errorValue = visual;
__glXFree( glxc );
return BadValue;
}
pGlxVisual = pGlxScreen->pGlxVisual;
for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
if (pGlxVisual->vid == visual) {
break;
}
}
if (i == pGlxScreen->numVisuals) {
/*
** Visual not support on this screen by this OpenGL implementation.
*/
client->errorValue = visual;
__glXFree( glxc );
return BadValue;
}
if ( glxc->pFBConfig == NULL ) {
glxc->pFBConfig = glxLookupFBConfigByVID( visual );
if ( glxc->pFBConfig == NULL ) {
/*
* visual does not have an FBConfig ???
client->errorValue = visual;
__glXFree( glxc );
return BadValue;
*/
}
}
}
else {
pVisual = NULL;
pGlxVisual = NULL;
}
glxc->pScreen = pScreen;
glxc->pGlxScreen = pGlxScreen;
glxc->pVisual = pVisual;
glxc->pGlxVisual = pGlxVisual;
/*
* allocate memory for back-end servers info
*/
num_be_screens = to_screen - from_screen + 1;
glxc->real_ids = (XID *)__glXMalloc(sizeof(XID) * num_be_screens);
if (!glxc->real_ids) {
return BadAlloc;
}
glxc->real_vids = (XID *)__glXMalloc(sizeof(XID) * num_be_screens);
if (!glxc->real_vids) {
return BadAlloc;
}
for (screen = from_screen; screen <= to_screen; screen++) {
int sent = 0;
pScreen = screenInfo.screens[screen];
pGlxScreen = &__glXActiveScreens[screen];
dmxScreen = &dmxScreens[screen];
if (glxc->pFBConfig) {
__GLXFBConfig *beFBConfig = glxLookupBackEndFBConfig( glxc->pFBConfig->id,
screen );
be_fbconfigId = beFBConfig->id;
}
if (pGlxVisual) {
be_vid = glxMatchGLXVisualInConfigList( pGlxVisual,
dmxScreen->glxVisuals,
dmxScreen->numGlxVisuals );
if (!be_vid) {
/* visual is not supported on the back-end server */
__glXFree( glxc->real_ids );
__glXFree( glxc->real_vids );
__glXFree( glxc );
return BadValue;
}
}
glxc->real_ids[screen-from_screen] = XAllocID(GetBackEndDisplay(cl,screen));
/* send the create context request to the back-end server */
dpy = GetBackEndDisplay(cl,screen);
if (glxc->pFBConfig) {
/*Since for a certain visual both RGB and COLOR INDEX
*can be on then the only parmeter to choose the renderType
* should be the class of the colormap since all 4 first
* classes does not support RGB mode only COLOR INDEX ,
* and so TrueColor and DirectColor does not support COLOR INDEX*/
int renderType = glxc->pFBConfig->renderType;
if ( pVisual ) {
switch ( pVisual->class ){
case PseudoColor:
case StaticColor:
case GrayScale:
case StaticGray:
renderType = GLX_COLOR_INDEX_TYPE;
break;
case TrueColor:
case DirectColor:
default:
renderType = GLX_RGBA_TYPE;
break;
}
}
if ( __GLX_IS_VERSION_SUPPORTED(1,3) ) {
LockDisplay(dpy);
GetReq(GLXCreateNewContext,be_new_req);
be_new_req->reqType = dmxScreen->glxMajorOpcode;
be_new_req->glxCode = X_GLXCreateNewContext;
be_new_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
be_new_req->fbconfig = (unsigned int)be_fbconfigId;
be_new_req->screen = DefaultScreen(dpy);
be_new_req->renderType = renderType;
be_new_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
be_new_req->isDirect = 0;
UnlockDisplay(dpy);
glxc->real_vids[screen-from_screen] = be_fbconfigId;
sent = 1;
}
else if (glxIsExtensionSupported("GLX_SGIX_fbconfig")) {
xGLXCreateContextWithConfigSGIXReq *ext_req;
xGLXVendorPrivateReq *vpreq;
LockDisplay(dpy);
GetReqExtra(GLXVendorPrivate,
sz_xGLXCreateContextWithConfigSGIXReq - sz_xGLXVendorPrivateReq,
vpreq);
ext_req = (xGLXCreateContextWithConfigSGIXReq *)vpreq;
ext_req->reqType = dmxScreen->glxMajorOpcode;
ext_req->glxCode = X_GLXVendorPrivate;
ext_req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
ext_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
ext_req->fbconfig = (unsigned int)be_fbconfigId;
ext_req->screen = DefaultScreen(dpy);
ext_req->renderType = renderType;
ext_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
ext_req->isDirect = 0;
UnlockDisplay(dpy);
glxc->real_vids[screen-from_screen] = be_fbconfigId;
sent = 1;
}
}
if (!sent) {
LockDisplay(dpy);
GetReq(GLXCreateContext,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXCreateContext;
be_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
be_req->visual = (unsigned int)be_vid;
be_req->screen = DefaultScreen(dpy);
be_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
be_req->isDirect = 0;
UnlockDisplay(dpy);
glxc->real_vids[screen-from_screen] = be_vid;
}
SyncHandle();
}
/*
** Register this context as a resource.
*/
if (!AddResource(gcId, __glXContextRes, (pointer)glxc)) {
__glXFree( glxc->real_ids );
__glXFree( glxc->real_vids );
__glXFree( glxc );
client->errorValue = gcId;
return BadAlloc;
}
/*
** Finally, now that everything is working, setup the rest of the
** context.
*/
glxc->id = gcId;
glxc->share_id = shareList;
glxc->idExists = GL_TRUE;
glxc->isCurrent = GL_FALSE;
return Success;
}
int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
return( CreateContext(cl, req->context,req->visual, None,
req->screen, req->shareList, req->isDirect) );
}
int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
return( CreateContext(cl, req->context,None, req->fbconfig,
req->screen, req->shareList, req->isDirect) );
}
int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateContextWithConfigSGIXReq *req = (xGLXCreateContextWithConfigSGIXReq *) pc;
return( CreateContext(cl, req->context, None, req->fbconfig,
req->screen, req->shareList, req->isDirect) );
}
int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryMaxSwapBarriersSGIXReq *req =
(xGLXQueryMaxSwapBarriersSGIXReq *)pc;
xGLXQueryMaxSwapBarriersSGIXReply reply;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
reply.length = 0;
reply.max = QueryMaxSwapBarriersSGIX(req->screen);
if (client->swapped) {
__glXSwapQueryMaxSwapBarriersSGIXReply(client, &reply);
} else {
WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply,
(char *)&reply);
}
return Success;
}
int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *)pc;
DrawablePtr pDraw;
__GLXpixmap *pGlxPixmap = NULL;
__glXWindow *pGlxWindow = NULL;
pDraw = (DrawablePtr) LookupDrawable(req->drawable, client);
if (!pDraw) {
pGlxPixmap = (__GLXpixmap *) LookupIDByType(req->drawable,
__glXPixmapRes);
if (pGlxPixmap) pDraw = pGlxPixmap->pDraw;
}
if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxWindow = (__glXWindow *) LookupIDByType(req->drawable,
__glXWindowRes);
if (pGlxWindow) pDraw = pGlxWindow->pDraw;
}
if (!pDraw) {
client->errorValue = req->drawable;
return __glXBadDrawable;
}
return BindSwapBarrierSGIX(pDraw, req->barrier);
}
int __glXJoinSwapGroupSGIX(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXJoinSwapGroupSGIXReq *req = (xGLXJoinSwapGroupSGIXReq *)pc;
DrawablePtr pDraw, pMember = NULL;
__GLXpixmap *pGlxPixmap = NULL;
__glXWindow *pGlxWindow = NULL;
pDraw = (DrawablePtr) LookupDrawable(req->drawable, client);
if (!pDraw) {
pGlxPixmap = (__GLXpixmap *) LookupIDByType(req->drawable,
__glXPixmapRes);
if (pGlxPixmap) pDraw = pGlxPixmap->pDraw;
}
if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxWindow = (__glXWindow *) LookupIDByType(req->drawable,
__glXWindowRes);
if (pGlxWindow) pDraw = pGlxWindow->pDraw;
}
if (!pDraw) {
client->errorValue = req->drawable;
return __glXBadDrawable;
}
if (req->member != None) {
pMember = (DrawablePtr) LookupDrawable(req->member, client);
if (!pMember) {
pGlxPixmap = (__GLXpixmap *) LookupIDByType(req->member,
__glXPixmapRes);
if (pGlxPixmap) pMember = pGlxPixmap->pDraw;
}
if (!pMember && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxWindow = (__glXWindow *) LookupIDByType(req->member,
__glXWindowRes);
if (pGlxWindow) pMember = pGlxWindow->pDraw;
}
if (!pMember) {
client->errorValue = req->member;
return __glXBadDrawable;
}
}
return JoinSwapGroupSGIX(pDraw, pMember);
}
/*
** Destroy a GL context as an X resource.
*/
int __glXDestroyContext(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
xGLXDestroyContextReq *be_req;
GLXContextID gcId = req->context;
__GLXcontext *glxc;
int from_screen = 0;
int to_screen = 0;
int s;
glxc = (__GLXcontext *) LookupIDByType(gcId, __glXContextRes);
if (glxc) {
/*
** Just free the resource; don't actually destroy the context,
** because it might be in use. The
** destroy method will be called by the resource destruction routine
** if necessary.
*/
FreeResourceByType(gcId, __glXContextRes, FALSE);
from_screen = to_screen = glxc->pScreen->myNum;
} else {
client->errorValue = gcId;
return __glXBadContext;
}
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
/*
* send DestroyContext request to all back-end servers
*/
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
LockDisplay(dpy);
GetReq(GLXDestroyContext,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXDestroyContext;
be_req->context = glxc->real_ids[s-from_screen];
UnlockDisplay(dpy);
SyncHandle();
}
return Success;
}
/*****************************************************************************/
/*
** For each client, the server keeps a table of all the contexts that are
** current for that client (each thread of a client may have its own current
** context). These routines add, change, and lookup contexts in the table.
*/
/*
** Add a current context, and return the tag that will be used to refer to it.
*/
static int AddCurrentContext(__GLXclientState *cl, __GLXcontext *glxc, DrawablePtr pDraw)
{
int i;
int num = cl->numCurrentContexts;
__GLXcontext **table = cl->currentContexts;
if (!glxc) return -1;
/*
** Try to find an empty slot and use it.
*/
for (i=0; i < num; i++) {
if (!table[i]) {
table[i] = glxc;
return i+1;
}
}
/*
** Didn't find a free slot, so we'll have to grow the table.
*/
if (!num) {
table = (__GLXcontext **) __glXMalloc(sizeof(__GLXcontext *));
cl->currentDrawables = (DrawablePtr *) __glXMalloc(sizeof(DrawablePtr));
cl->be_currentCTag = (GLXContextTag *) __glXMalloc(screenInfo.numScreens *sizeof(GLXContextTag));
} else {
table = (__GLXcontext **) __glXRealloc(table,
(num+1)*sizeof(__GLXcontext *));
cl->currentDrawables = (DrawablePtr *) __glXRealloc(
cl->currentDrawables ,
(num+1)*sizeof(DrawablePtr));
cl->be_currentCTag = (GLXContextTag *) __glXRealloc(cl->be_currentCTag,
(num+1)*screenInfo.numScreens*sizeof(GLXContextTag));
}
table[num] = glxc;
cl->currentDrawables[num] = pDraw;
cl->currentContexts = table;
cl->numCurrentContexts++;
__glXMemset(cl->be_currentCTag + num*screenInfo.numScreens, 0,
screenInfo.numScreens * sizeof(Display *));
return num+1;
}
/*
** Given a tag, change the current context for the corresponding entry.
*/
static void ChangeCurrentContext(__GLXclientState *cl, __GLXcontext *glxc,
GLXContextTag tag)
{
__GLXcontext **table = cl->currentContexts;
table[tag-1] = glxc;
}
/*
** Given a tag, and back-end screen number, retrives the current back-end
** tag.
*/
int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s)
{
if (tag >0) {
return( cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] );
}
else {
return( 0 );
}
}
/*
** Given a tag, and back-end screen number, sets the current back-end
** tag.
*/
static void SetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s, GLXContextTag be_tag)
{
if (tag >0) {
cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] = be_tag;
}
}
/*
** For this implementation we have chosen to simply use the index of the
** context's entry in the table as the context tag. A tag must be greater
** than 0.
*/
__GLXcontext *__glXLookupContextByTag(__GLXclientState *cl, GLXContextTag tag)
{
int num = cl->numCurrentContexts;
if (tag < 1 || tag > num) {
return 0;
} else {
return cl->currentContexts[tag-1];
}
}
DrawablePtr __glXLookupDrawableByTag(__GLXclientState *cl, GLXContextTag tag)
{
int num = cl->numCurrentContexts;
if (tag < 1 || tag > num) {
return 0;
} else {
return cl->currentDrawables[tag-1];
}
}
/*****************************************************************************/
static void StopUsingContext(__GLXcontext *glxc)
{
if (glxc) {
if (glxc == __glXLastContext) {
/* Tell server GL library */
__glXLastContext = 0;
}
glxc->isCurrent = GL_FALSE;
if (!glxc->idExists) {
__glXFreeContext(glxc);
}
}
}
static void StartUsingContext(__GLXclientState *cl, __GLXcontext *glxc)
{
glxc->isCurrent = GL_TRUE;
}
/*****************************************************************************/
/*
** Make an OpenGL context and drawable current.
*/
static int MakeCurrent(__GLXclientState *cl,
GLXDrawable drawable,
GLXDrawable readdrawable,
GLXContextID context,
GLXContextTag oldContextTag)
{
ClientPtr client = cl->client;
DrawablePtr pDraw = NULL;
DrawablePtr pReadDraw = NULL;
xGLXMakeCurrentReadSGIReply new_reply;
xGLXMakeCurrentReq *be_req;
xGLXMakeCurrentReply be_reply;
xGLXMakeContextCurrentReq *be_new_req;
xGLXMakeContextCurrentReply be_new_reply;
GLXDrawable drawId = drawable;
GLXDrawable readId = readdrawable;
GLXContextID contextId = context;
__GLXpixmap *pGlxPixmap = 0;
__GLXpixmap *pReadGlxPixmap = 0;
__GLXcontext *glxc, *prevglxc;
GLXContextTag tag = oldContextTag;
WindowPtr pWin = NULL;
WindowPtr pReadWin = NULL;
__glXWindow *pGlxWindow = NULL;
__glXWindow *pGlxReadWindow = NULL;
__glXPbuffer *pGlxPbuffer = NULL;
__glXPbuffer *pGlxReadPbuffer = NULL;
#ifdef PANORAMIX
PanoramiXRes *pXinDraw = NULL;
PanoramiXRes *pXinReadDraw = NULL;
#endif
int from_screen = 0;
int to_screen = 0;
int s;
/*
** If one is None and the other isn't, it's a bad match.
*/
if ((drawId == None && contextId != None) ||
(drawId != None && contextId == None)) {
return BadMatch;
}
/*
** Lookup old context. If we have one, it must be in a usable state.
*/
if (tag != 0) {
prevglxc = __glXLookupContextByTag(cl, tag);
if (!prevglxc) {
/*
** Tag for previous context is invalid.
*/
return __glXBadContextTag;
}
} else {
prevglxc = 0;
}
/*
** Lookup new context. It must not be current for someone else.
*/
if (contextId != None) {
glxc = (__GLXcontext *) LookupIDByType(contextId, __glXContextRes);
if (!glxc) {
client->errorValue = contextId;
return __glXBadContext;
}
if ((glxc != prevglxc) && glxc->isCurrent) {
/* Context is current to somebody else */
return BadAccess;
}
} else {
/* Switching to no context. Ignore new drawable. */
glxc = 0;
}
if (drawId != None) {
pDraw = (DrawablePtr) LookupDrawable(drawId, client);
if (pDraw) {
if (pDraw->type == DRAWABLE_WINDOW) {
/*
** Drawable is an X Window.
*/
VisualID vid;
pWin = (WindowPtr)pDraw;
vid = wVisual(pWin);
new_reply.writeVid = (glxc->pFBConfig ? glxc->pFBConfig->id : vid);
new_reply.writeType = GLX_WINDOW_TYPE;
/*
** Check if window and context are similar.
*/
if ((vid != glxc->pVisual->vid) ||
(pWin->drawable.pScreen != glxc->pScreen)) {
client->errorValue = drawId;
return BadMatch;
}
from_screen = to_screen = pWin->drawable.pScreen->myNum;
} else {
/*
** An X Pixmap is not allowed as a parameter (a GLX Pixmap
** is, but it must first be created with glxCreateGLXPixmap).
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
}
if (!pDraw) {
pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
__glXPixmapRes);
if (pGlxPixmap) {
/*
** Check if pixmap and context are similar.
*/
if (pGlxPixmap->pScreen != glxc->pScreen ||
pGlxPixmap->pGlxVisual != glxc->pGlxVisual) {
client->errorValue = drawId;
return BadMatch;
}
pDraw = pGlxPixmap->pDraw;
new_reply.writeVid = (glxc->pFBConfig ? glxc->pFBConfig->id :
pGlxPixmap->pGlxVisual->vid);
new_reply.writeType = GLX_PIXMAP_TYPE;
from_screen = to_screen = pGlxPixmap->pScreen->myNum;
}
}
if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
if (pGlxWindow) {
/*
** Drawable is a GLXWindow.
**
** Check if GLX window and context are similar.
*/
if (pGlxWindow->pScreen != glxc->pScreen ||
pGlxWindow->pGlxFBConfig != glxc->pFBConfig) {
client->errorValue = drawId;
return BadMatch;
}
pDraw = pGlxWindow->pDraw;
new_reply.writeVid = pGlxWindow->pGlxFBConfig->id;
new_reply.writeType = GLX_GLXWINDOW_TYPE;
}
}
if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxPbuffer = (__glXPbuffer *)LookupIDByType(drawId, __glXPbufferRes);
if (pGlxPbuffer) {
if (pGlxPbuffer->pScreen != glxc->pScreen ||
pGlxPbuffer->pFBConfig != glxc->pFBConfig) {
client->errorValue = drawId;
return BadMatch;
}
pDraw = (DrawablePtr)pGlxPbuffer;
new_reply.writeVid = pGlxPbuffer->pFBConfig->id;
new_reply.writeType = GLX_PBUFFER_TYPE;
}
}
if (!pDraw) {
/*
** Drawable is not a Window , GLXWindow or a GLXPixmap.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
} else {
pDraw = 0;
}
if (readId != None && readId != drawId ) {
pReadDraw = (DrawablePtr) LookupDrawable(readId, client);
if (pReadDraw) {
if (pReadDraw->type == DRAWABLE_WINDOW) {
/*
** Drawable is an X Window.
*/
VisualID vid;
pReadWin = (WindowPtr)pDraw;
vid = wVisual(pReadWin);
new_reply.readVid = (glxc->pFBConfig ? glxc->pFBConfig->id : vid);
new_reply.readType = GLX_WINDOW_TYPE;
/*
** Check if window and context are similar.
*/
if ((vid != glxc->pVisual->vid) ||
(pReadWin->drawable.pScreen != glxc->pScreen)) {
client->errorValue = readId;
return BadMatch;
}
} else {
/*
** An X Pixmap is not allowed as a parameter (a GLX Pixmap
** is, but it must first be created with glxCreateGLXPixmap).
*/
client->errorValue = readId;
return __glXBadDrawable;
}
}
if (!pReadDraw) {
pReadGlxPixmap = (__GLXpixmap *) LookupIDByType(readId,
__glXPixmapRes);
if (pReadGlxPixmap) {
/*
** Check if pixmap and context are similar.
*/
if (pReadGlxPixmap->pScreen != glxc->pScreen ||
pReadGlxPixmap->pGlxVisual != glxc->pGlxVisual) {
client->errorValue = readId;
return BadMatch;
}
pReadDraw = pReadGlxPixmap->pDraw;
new_reply.readVid = (glxc->pFBConfig ? glxc->pFBConfig->id :
pReadGlxPixmap->pGlxVisual->vid );
new_reply.readType = GLX_PIXMAP_TYPE;
}
}
if (!pReadDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxReadWindow = (__glXWindow *)
LookupIDByType(readId, __glXWindowRes);
if (pGlxReadWindow) {
/*
** Drawable is a GLXWindow.
**
** Check if GLX window and context are similar.
*/
if (pGlxReadWindow->pScreen != glxc->pScreen ||
pGlxReadWindow->pGlxFBConfig != glxc->pFBConfig) {
client->errorValue = readId;
return BadMatch;
}
pReadDraw = pGlxReadWindow->pDraw;
new_reply.readVid = pGlxReadWindow->pGlxFBConfig->id;
new_reply.readType = GLX_GLXWINDOW_TYPE;
}
}
if (!pReadDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxReadPbuffer = (__glXPbuffer *)LookupIDByType(readId, __glXPbufferRes);
if (pGlxReadPbuffer) {
if (pGlxReadPbuffer->pScreen != glxc->pScreen ||
pGlxReadPbuffer->pFBConfig != glxc->pFBConfig) {
client->errorValue = drawId;
return BadMatch;
}
pReadDraw = (DrawablePtr)pGlxReadPbuffer;
new_reply.readVid = pGlxReadPbuffer->pFBConfig->id;
new_reply.readType = GLX_PBUFFER_TYPE;
}
}
if (!pReadDraw) {
/*
** Drawable is neither a Window nor a GLXPixmap.
*/
client->errorValue = readId;
return __glXBadDrawable;
}
} else {
pReadDraw = pDraw;
pReadGlxPixmap = pGlxPixmap;
pReadWin = pWin;
new_reply.readVid = new_reply.writeVid;
new_reply.readType = new_reply.writeType;
}
if (prevglxc) {
if (prevglxc->pGlxPixmap) {
/*
** The previous drawable was a glx pixmap, release it.
*/
prevglxc->pGlxPixmap->refcnt--;
__glXFreeGLXPixmap( prevglxc->pGlxPixmap );
prevglxc->pGlxPixmap = 0;
}
if (prevglxc->pGlxReadPixmap &&
prevglxc->pGlxReadPixmap != prevglxc->pGlxPixmap ) {
/*
** The previous drawable was a glx pixmap, release it.
*/
prevglxc->pGlxReadPixmap->refcnt--;
__glXFreeGLXPixmap( prevglxc->pGlxReadPixmap );
prevglxc->pGlxReadPixmap = 0;
}
if (prevglxc->pGlxWindow) {
/*
** The previous drawable was a glx window, release it.
*/
prevglxc->pGlxWindow->refcnt--;
__glXFreeGLXWindow( prevglxc->pGlxWindow );
prevglxc->pGlxWindow = 0;
}
if (prevglxc->pGlxReadWindow &&
prevglxc->pGlxReadWindow != prevglxc->pGlxWindow) {
/*
** The previous drawable was a glx window, release it.
*/
prevglxc->pGlxReadWindow->refcnt--;
__glXFreeGLXWindow( prevglxc->pGlxReadWindow );
prevglxc->pGlxReadWindow = 0;
}
if (prevglxc->pGlxPbuffer) {
/*
** The previous drawable was a glx Pbuffer, release it.
*/
prevglxc->pGlxPbuffer->refcnt--;
__glXFreeGLXPbuffer( prevglxc->pGlxPbuffer );
prevglxc->pGlxPbuffer = 0;
}
if (prevglxc->pGlxReadPbuffer &&
prevglxc->pGlxReadPbuffer != prevglxc->pGlxPbuffer ) {
/*
** The previous drawable was a glx Pbuffer, release it.
*/
prevglxc->pGlxReadPbuffer->refcnt--;
__glXFreeGLXPbuffer( prevglxc->pGlxReadPbuffer );
prevglxc->pGlxReadPbuffer = 0;
}
ChangeCurrentContext(cl, glxc, tag);
ChangeCurrentContext(cl, glxc, tag);
StopUsingContext(prevglxc);
} else {
tag = AddCurrentContext(cl, glxc, pDraw);
}
if (glxc) {
glxc->pGlxPixmap = pGlxPixmap;
glxc->pGlxReadPixmap = pReadGlxPixmap;
glxc->pGlxWindow = pGlxWindow;
glxc->pGlxReadWindow = pGlxReadWindow;
glxc->pGlxPbuffer = pGlxPbuffer;
glxc->pGlxReadPbuffer = pGlxReadPbuffer;
if (pGlxPixmap) {
pGlxPixmap->refcnt++;
}
if (pReadGlxPixmap && pReadGlxPixmap != pGlxPixmap) {
pReadGlxPixmap->refcnt++;
}
if (pGlxWindow) {
pGlxWindow->refcnt++;
}
if (pGlxReadWindow && pGlxReadWindow != pGlxWindow) {
pGlxReadWindow->refcnt++;
}
if (pGlxPbuffer) {
pGlxPbuffer->refcnt++;
}
if (pGlxReadPbuffer && pGlxReadPbuffer != pGlxPbuffer) {
pGlxReadPbuffer->refcnt++;
}
StartUsingContext(cl, glxc);
new_reply.contextTag = tag;
} else {
new_reply.contextTag = 0;
}
new_reply.length = 0;
new_reply.type = X_Reply;
new_reply.sequenceNumber = client->sequence;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
if (pDraw && new_reply.writeType != GLX_PBUFFER_TYPE) {
pXinDraw = (PanoramiXRes *)
SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
}
if (pReadDraw && pReadDraw != pDraw &&
new_reply.readType != GLX_PBUFFER_TYPE) {
pXinReadDraw = (PanoramiXRes *)
SecurityLookupIDByClass(client, pReadDraw->id, XRC_DRAWABLE, SecurityReadAccess);
}
else {
pXinReadDraw = pXinDraw;
}
}
#endif
/* send the MakeCurrent request to all required
* back-end servers.
*/
for (s = from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
unsigned int be_draw = None;
unsigned int be_read_draw = None;
if (pGlxPixmap) {
be_draw = pGlxPixmap->be_xids[s];
}
else if (pGlxPbuffer) {
be_draw = pGlxPbuffer->be_xids[s];
}
#ifdef PANORAMIX
else if (pXinDraw) {
pWin = (WindowPtr)SecurityLookupWindow(pXinDraw->info[s].id,
client,
SecurityReadAccess);
}
#endif
else if (pGlxWindow) {
pWin = (WindowPtr)pGlxWindow->pDraw;
}
if (pWin && be_draw == None) {
be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
if (!be_draw) {
/* it might be that the window did not created yet on the */
/* back-end server (lazy window creation option), force */
/* creation of the window */
dmxCreateAndRealizeWindow( pWin, TRUE );
be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
}
}
/*
* Before sending the MakeCurrent request - sync the
* X11 connection to the back-end servers to make sure
* that drawable is already created
*/
dmxSync( dmxScreen, 1 );
if (drawId == readId) {
LockDisplay(dpy);
GetReq(GLXMakeCurrent, be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXMakeCurrent;
be_req->drawable = be_draw;
be_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
be_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
if (!_XReply(dpy, (xReply *) &be_reply, 0, False)) {
/* The make current failed */
UnlockDisplay(dpy);
SyncHandle();
return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
}
UnlockDisplay(dpy);
SyncHandle();
SetCurrentBackEndTag( cl, tag, s, be_reply.contextTag );
}
else {
if (pReadGlxPixmap) {
be_read_draw = pReadGlxPixmap->be_xids[s];
}
else if (pGlxReadPbuffer) {
be_read_draw = pGlxReadPbuffer->be_xids[s];
}
#ifdef PANORAMIX
else if (pXinReadDraw) {
pReadWin = (WindowPtr)SecurityLookupWindow(pXinReadDraw->info[s].id,
client,
SecurityReadAccess);
}
#endif
else if (pGlxReadWindow) {
pReadWin = (WindowPtr)pGlxReadWindow->pDraw;
}
if (pReadWin && be_read_draw == None) {
be_read_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pReadWin))->window;
if (!be_read_draw) {
/* it might be that the window did not created yet on the */
/* back-end server (lazy window creation option), force */
/* creation of the window */
dmxCreateAndRealizeWindow( pReadWin, TRUE );
be_read_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pReadWin))->window;
dmxSync( dmxScreen, 1 );
}
}
if ( __GLX_IS_VERSION_SUPPORTED(1,3) ) {
LockDisplay(dpy);
GetReq(GLXMakeContextCurrent, be_new_req);
be_new_req->reqType = dmxScreen->glxMajorOpcode;
be_new_req->glxCode = X_GLXMakeContextCurrent;
be_new_req->drawable = be_draw;
be_new_req->readdrawable = be_read_draw;
be_new_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
be_new_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
if (!_XReply(dpy, (xReply *) &be_new_reply, 0, False)) {
/* The make current failed */
UnlockDisplay(dpy);
SyncHandle();
return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
}
UnlockDisplay(dpy);
SyncHandle();
SetCurrentBackEndTag( cl, tag, s, be_new_reply.contextTag );
}
else if (glxIsExtensionSupported("GLX_SGI_make_current_read")) {
xGLXMakeCurrentReadSGIReq *ext_req;
xGLXVendorPrivateWithReplyReq *vpreq;
xGLXMakeCurrentReadSGIReply ext_reply;
LockDisplay(dpy);
GetReqExtra(GLXVendorPrivateWithReply,
sz_xGLXMakeCurrentReadSGIReq - sz_xGLXVendorPrivateWithReplyReq,
vpreq);
ext_req = (xGLXMakeCurrentReadSGIReq *)vpreq;
ext_req->reqType = dmxScreen->glxMajorOpcode;
ext_req->glxCode = X_GLXVendorPrivateWithReply;
ext_req->vendorCode = X_GLXvop_MakeCurrentReadSGI;
ext_req->drawable = be_draw;
ext_req->readable = be_read_draw;
ext_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
ext_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
if (!_XReply(dpy, (xReply *) &ext_reply, 0, False)) {
/* The make current failed */
UnlockDisplay(dpy);
SyncHandle();
return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
}
UnlockDisplay(dpy);
SyncHandle();
SetCurrentBackEndTag( cl, tag, s, ext_reply.contextTag );
}
else {
return BadMatch;
}
}
XFlush( dpy );
}
if (client->swapped) {
__glXSwapMakeCurrentReply(client, &new_reply);
} else {
WriteToClient(client, sz_xGLXMakeContextCurrentReply, (char *)&new_reply);
}
return Success;
}
int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
return( MakeCurrent(cl, req->drawable, req->drawable,
req->context, req->oldContextTag ) );
}
int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
return( MakeCurrent(cl, req->drawable, req->readdrawable,
req->context, req->oldContextTag ) );
}
int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
return( MakeCurrent(cl, req->drawable, req->readable,
req->context, req->oldContextTag ) );
}
int __glXIsDirect(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
xGLXIsDirectReply reply;
__GLXcontext *glxc;
/*
** Find the GL context.
*/
glxc = (__GLXcontext *) LookupIDByType(req->context, __glXContextRes);
if (!glxc) {
client->errorValue = req->context;
return __glXBadContext;
}
reply.isDirect = 0;
reply.length = 0;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
if (client->swapped) {
__glXSwapIsDirectReply(client, &reply);
} else {
WriteToClient(client, sz_xGLXIsDirectReply, (char *)&reply);
}
return Success;
}
int __glXQueryVersion(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
/* xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc; */
xGLXQueryVersionReply reply;
/*
** Server should take into consideration the version numbers sent by the
** client if it wants to work with older clients; however, in this
** implementation the server just returns its version number.
*/
reply.majorVersion = __glXVersionMajor;
reply.minorVersion = __glXVersionMinor;
reply.length = 0;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
if (client->swapped) {
__glXSwapQueryVersionReply(client, &reply);
} else {
WriteToClient(client, sz_xGLXQueryVersionReply, (char *)&reply);
}
return Success;
}
int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
{
xGLXWaitGLReq *req = (xGLXWaitGLReq *)pc;
xGLXWaitGLReq *be_req = (xGLXWaitGLReq *)pc;
int from_screen = 0;
int to_screen = 0;
int s;
__GLXcontext *glxc = NULL;
if (req->contextTag != 0) {
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (glxc) {
from_screen = to_screen = glxc->pScreen->myNum;
}
}
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
LockDisplay(dpy);
GetReq(GLXWaitGL,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXWaitGL;
be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
UnlockDisplay(dpy);
SyncHandle();
XSync(dpy, False);
}
return Success;
}
int __glXWaitX(__GLXclientState *cl, GLbyte *pc)
{
xGLXWaitXReq *req = (xGLXWaitXReq *)pc;
xGLXWaitXReq *be_req;
int from_screen = 0;
int to_screen = 0;
int s;
__GLXcontext *glxc = NULL;
if (req->contextTag != 0) {
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (glxc) {
from_screen = to_screen = glxc->pScreen->myNum;
}
}
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
dmxSync( dmxScreen, 1 );
LockDisplay(dpy);
GetReq(GLXWaitX,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXWaitX;
be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
UnlockDisplay(dpy);
SyncHandle();
XFlush( dpy );
}
return Success;
}
int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXCopyContextReq *be_req;
xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
GLXContextID source = req->source;
GLXContextID dest = req->dest;
GLXContextTag tag = req->contextTag;
unsigned long mask = req->mask;
__GLXcontext *src, *dst;
int s;
int from_screen = 0;
int to_screen = 0;
/*
** Check that each context exists.
*/
src = (__GLXcontext *) LookupIDByType(source, __glXContextRes);
if (!src) {
client->errorValue = source;
return __glXBadContext;
}
dst = (__GLXcontext *) LookupIDByType(dest, __glXContextRes);
if (!dst) {
client->errorValue = dest;
return __glXBadContext;
}
/*
** They must be in the same address space, and same screen.
*/
if (src->pGlxScreen != dst->pGlxScreen) {
client->errorValue = source;
return BadMatch;
}
/*
** The destination context must not be current for any client.
*/
if (dst->isCurrent) {
client->errorValue = dest;
return BadAccess;
}
if (tag) {
__GLXcontext *tagcx = __glXLookupContextByTag(cl, tag);
if (!tagcx) {
return __glXBadContextTag;
}
if (tagcx != src) {
/*
** This would be caused by a faulty implementation of the client
** library.
*/
return BadMatch;
}
}
from_screen = to_screen = src->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
LockDisplay(dpy);
GetReq(GLXCopyContext,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXCopyContext;
be_req->source = (unsigned int)src->real_ids[s-from_screen];
be_req->dest = (unsigned int)dst->real_ids[s-from_screen];
be_req->mask = mask;
be_req->contextTag = (tag ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
UnlockDisplay(dpy);
SyncHandle();
}
return Success;
}
int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
xGLXGetVisualConfigsReply reply;
__GLXscreenInfo *pGlxScreen;
__GLXvisualConfig *pGlxVisual;
CARD32 buf[__GLX_TOTAL_CONFIG];
unsigned int screen;
int i, p;
screen = req->screen;
if (screen > screenInfo.numScreens) {
/* The client library must send a valid screen number. */
client->errorValue = screen;
return BadValue;
}
pGlxScreen = &__glXActiveScreens[screen];
reply.numVisuals = pGlxScreen->numGLXVisuals;
reply.numProps = __GLX_TOTAL_CONFIG;
reply.length = (pGlxScreen->numGLXVisuals * __GLX_SIZE_CARD32 *
__GLX_TOTAL_CONFIG) >> 2;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
for (i=0; i < pGlxScreen->numVisuals; i++) {
pGlxVisual = &pGlxScreen->pGlxVisual[i];
if (!pGlxScreen->isGLXvis[i] || pGlxVisual->vid == 0) {
/* not a usable visual */
continue;
}
p = 0;
buf[p++] = pGlxVisual->vid;
buf[p++] = pGlxVisual->class;
buf[p++] = pGlxVisual->rgba;
buf[p++] = pGlxVisual->redSize;
buf[p++] = pGlxVisual->greenSize;
buf[p++] = pGlxVisual->blueSize;
buf[p++] = pGlxVisual->alphaSize;
buf[p++] = pGlxVisual->accumRedSize;
buf[p++] = pGlxVisual->accumGreenSize;
buf[p++] = pGlxVisual->accumBlueSize;
buf[p++] = pGlxVisual->accumAlphaSize;
buf[p++] = pGlxVisual->doubleBuffer;
buf[p++] = pGlxVisual->stereo;
buf[p++] = pGlxVisual->bufferSize;
buf[p++] = pGlxVisual->depthSize;
buf[p++] = pGlxVisual->stencilSize;
buf[p++] = pGlxVisual->auxBuffers;
buf[p++] = pGlxVisual->level;
/*
** Add token/value pairs for extensions.
*/
buf[p++] = GLX_VISUAL_CAVEAT_EXT;
buf[p++] = pGlxVisual->visualRating;
buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
buf[p++] = pGlxVisual->transparentPixel;
buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
buf[p++] = pGlxVisual->transparentRed;
buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
buf[p++] = pGlxVisual->transparentGreen;
buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
buf[p++] = pGlxVisual->transparentBlue;
buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
buf[p++] = pGlxVisual->transparentAlpha;
buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
buf[p++] = pGlxVisual->transparentIndex;
buf[p++] = GLX_SAMPLES_SGIS;
buf[p++] = pGlxVisual->multiSampleSize;
buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
buf[p++] = pGlxVisual->nMultiSampleBuffers;
buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
buf[p++] = pGlxVisual->visualSelectGroup;
WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG,
(char *)buf);
}
return Success;
}
/*
** Create a GLX Pixmap from an X Pixmap.
*/
static int CreateGLXPixmap(__GLXclientState *cl,
VisualID visual, GLXFBConfigID fbconfigId,
int screenNum, XID pixmapId, XID glxpixmapId )
{
ClientPtr client = cl->client;
xGLXCreateGLXPixmapReq *be_req;
xGLXCreatePixmapReq *be_new_req;
DrawablePtr pDraw;
ScreenPtr pScreen;
VisualPtr pVisual;
__GLXpixmap *pGlxPixmap;
__GLXscreenInfo *pGlxScreen;
__GLXvisualConfig *pGlxVisual;
__GLXFBConfig *pFBConfig;
int i;
int s;
int from_screen, to_screen;
#ifdef PANORAMIX
PanoramiXRes *pXinDraw = NULL;
#endif
pDraw = (DrawablePtr) LookupDrawable(pixmapId, client);
if (!pDraw || pDraw->type != DRAWABLE_PIXMAP) {
client->errorValue = pixmapId;
return BadPixmap;
}
/*
** Check if screen of visual matches screen of pixmap.
*/
pScreen = pDraw->pScreen;
if (screenNum != pScreen->myNum) {
return BadMatch;
}
if (fbconfigId == NULL && visual == NULL) {
return BadValue;
}
if (fbconfigId != None) {
pFBConfig = glxLookupFBConfig( fbconfigId );
if (!pFBConfig) {
client->errorValue = fbconfigId;
return BadValue;
}
visual = pFBConfig->associatedVisualId;
}
else {
pFBConfig = NULL;
}
if (visual != None) {
/*
** Find the VisualRec for this visual.
*/
pVisual = pScreen->visuals;
for (i=0; i < pScreen->numVisuals; i++, pVisual++) {
if (pVisual->vid == visual) {
break;
}
}
if (i == pScreen->numVisuals) {
client->errorValue = visual;
return BadValue;
}
/*
** Check if depth of visual matches depth of pixmap.
*/
if (pVisual->nplanes != pDraw->depth) {
client->errorValue = visual;
return BadMatch;
}
/*
** Get configuration of the visual.
*/
pGlxScreen = &__glXActiveScreens[screenNum];
pGlxVisual = pGlxScreen->pGlxVisual;
for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
if (pGlxVisual->vid == visual) {
break;
}
}
if (i == pGlxScreen->numVisuals) {
/*
** Visual not support on this screen by this OpenGL implementation.
*/
client->errorValue = visual;
return BadValue;
}
/* find the FBConfig for that visual (if any) */
if ( pFBConfig == NULL ) {
pFBConfig = glxLookupFBConfigByVID( visual );
if ( pFBConfig == NULL ) {
/*
* visual does not have an FBConfig ???
client->errorValue = visual;
return BadValue;
*/
}
}
}
else {
pVisual = NULL;
pGlxVisual = NULL;
}
pGlxPixmap = (__GLXpixmap *) __glXMalloc(sizeof(__GLXpixmap));
if (!pGlxPixmap) {
return BadAlloc;
}
pGlxPixmap->be_xids = (XID *) __glXMalloc(sizeof(XID) * screenInfo.numScreens);
if (!pGlxPixmap->be_xids) {
__glXFree( pGlxPixmap );
return BadAlloc;
}
pGlxPixmap->pDraw = pDraw;
pGlxPixmap->pGlxScreen = pGlxScreen;
pGlxPixmap->pGlxVisual = pGlxVisual;
pGlxPixmap->pFBConfig = pFBConfig;
pGlxPixmap->pScreen = pScreen;
pGlxPixmap->idExists = True;
pGlxPixmap->refcnt = 0;
/*
** Bump the ref count on the X pixmap so it won't disappear.
*/
((PixmapPtr) pDraw)->refcnt++;
/*
* send the request to the back-end server(s)
*/
from_screen = to_screen = screenNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
pXinDraw = (PanoramiXRes *)
SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
}
#endif
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
Pixmap be_pixmap;
DrawablePtr pRealDraw = pDraw;
#ifdef PANORAMIX
if (pXinDraw) {
pRealDraw = (DrawablePtr) LookupDrawable(pXinDraw->info[s].id,client);
}
#endif
be_pixmap = (DMX_GET_PIXMAP_PRIV((PixmapPtr)pRealDraw))->pixmap;
/* make sure pixmap already created on back-end */
dmxSync( dmxScreen, 1 );
if ( pFBConfig && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
__GLXFBConfig *be_FBConfig = glxLookupBackEndFBConfig( pFBConfig->id, s );
LockDisplay(dpy);
pGlxPixmap->be_xids[s] = XAllocID(dpy);
GetReq(GLXCreatePixmap,be_new_req);
be_new_req->reqType = dmxScreen->glxMajorOpcode;
be_new_req->glxCode = X_GLXCreatePixmap;
be_new_req->screen = DefaultScreen(dpy);
be_new_req->fbconfig = be_FBConfig->id;
be_new_req->pixmap = (unsigned int)be_pixmap;
be_new_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
be_new_req->numAttribs = 0;
UnlockDisplay(dpy);
SyncHandle();
}
else if (pFBConfig && glxIsExtensionSupported("GLX_SGIX_fbconfig")) {
__GLXFBConfig *be_FBConfig = glxLookupBackEndFBConfig( pFBConfig->id, s );
xGLXCreateGLXPixmapWithConfigSGIXReq *ext_req;
xGLXVendorPrivateReq *vpreq;
LockDisplay(dpy);
pGlxPixmap->be_xids[s] = XAllocID(dpy);
GetReqExtra(GLXVendorPrivate,
sz_xGLXCreateGLXPixmapWithConfigSGIXReq-sz_xGLXVendorPrivateReq,
vpreq);
ext_req = (xGLXCreateGLXPixmapWithConfigSGIXReq *)vpreq;
ext_req->reqType = dmxScreen->glxMajorOpcode;
ext_req->glxCode = X_GLXVendorPrivate;
ext_req->vendorCode = X_GLXvop_CreateGLXPixmapWithConfigSGIX;
ext_req->screen = DefaultScreen(dpy);
ext_req->fbconfig = be_FBConfig->id;
ext_req->pixmap = (unsigned int)be_pixmap;
ext_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
UnlockDisplay(dpy);
SyncHandle();
}
else if (pGlxVisual) {
LockDisplay(dpy);
pGlxPixmap->be_xids[s] = XAllocID(dpy);
GetReq(GLXCreateGLXPixmap,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXCreateGLXPixmap;
be_req->screen = DefaultScreen(dpy);
be_req->visual = (unsigned int)glxMatchGLXVisualInConfigList(
pGlxVisual,
dmxScreen->glxVisuals,
dmxScreen->numGlxVisuals );
be_req->pixmap = (unsigned int)be_pixmap;
be_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
UnlockDisplay(dpy);
SyncHandle();
}
else {
client->errorValue = ( visual ? visual : fbconfigId );
__glXFree( pGlxPixmap );
return BadValue;
}
XFlush( dpy );
}
if (!(AddResource(glxpixmapId, __glXPixmapRes, pGlxPixmap))) {
__glXFree( pGlxPixmap );
return BadAlloc;
}
return Success;
}
int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
return( CreateGLXPixmap(cl, req->visual, None,
req->screen, req->pixmap, req->glxpixmap) );
}
int __glXCreatePixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
return( CreateGLXPixmap(cl, None, req->fbconfig,
req->screen, req->pixmap, req->glxpixmap) );
}
int __glXDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
XID glxpixmap = req->glxpixmap;
__GLXpixmap *pGlxPixmap;
int s;
int from_screen, to_screen;
/*
** Check if it's a valid GLX pixmap.
*/
pGlxPixmap = (__GLXpixmap *)LookupIDByType(glxpixmap, __glXPixmapRes);
if (!pGlxPixmap) {
client->errorValue = glxpixmap;
return __glXBadPixmap;
}
FreeResource(glxpixmap, FALSE);
/*
* destroy the pixmap on the back-end server(s).
*/
from_screen = to_screen = pGlxPixmap->pDraw->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
/* make sure pixmap exist in back-end */
dmxSync( dmxScreen, 1 );
LockDisplay(dpy);
GetReq(GLXDestroyGLXPixmap,req);
req->reqType = dmxScreen->glxMajorOpcode;
req->glxCode = X_GLXDestroyGLXPixmap;
req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
UnlockDisplay(dpy);
SyncHandle();
}
return Success;
}
/*****************************************************************************/
/*
** NOTE: There is no portable implementation for swap buffers as of
** this time that is of value. Consequently, this code must be
** implemented by somebody other than SGI.
*/
int __glXDoSwapBuffers(__GLXclientState *cl, XID drawId, GLXContextTag tag)
{
ClientPtr client = cl->client;
DrawablePtr pDraw;
xGLXSwapBuffersReq *be_req;
WindowPtr pWin = NULL;
__GLXpixmap *pGlxPixmap = NULL;
__GLXcontext *glxc = NULL;
#ifdef PANORAMIX
PanoramiXRes *pXinDraw = NULL;
#endif
__glXWindow *pGlxWindow = NULL;
int from_screen = 0;
int to_screen = 0;
int s;
/*
** Check that the GLX drawable is valid.
*/
pDraw = (DrawablePtr) LookupDrawable(drawId, client);
if (pDraw) {
from_screen = to_screen = pDraw->pScreen->myNum;
if (pDraw->type == DRAWABLE_WINDOW) {
/*
** Drawable is an X window.
*/
pWin = (WindowPtr)pDraw;
} else {
/*
** Drawable is an X pixmap, which is not allowed.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
}
if (!pDraw) {
pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
__glXPixmapRes);
if (pGlxPixmap) {
/*
** Drawable is a GLX pixmap.
*/
pDraw = pGlxPixmap->pDraw;
from_screen = to_screen = pGlxPixmap->pScreen->myNum;
}
}
if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
if (pGlxWindow) {
/*
** Drawable is a GLXWindow.
*/
pDraw = pGlxWindow->pDraw;
from_screen = to_screen = pGlxWindow->pScreen->myNum;
}
}
if (!pDraw) {
/*
** Drawable is neither a X window nor a GLX pixmap.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
if (tag) {
glxc = __glXLookupContextByTag(cl, tag);
if (!glxc) {
return __glXBadContextTag;
}
}
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
pXinDraw = (PanoramiXRes *)
SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
}
#endif
/* If requested, send a glFinish to all back-end servers before swapping. */
if (dmxGLXFinishSwap) {
for (s=from_screen; s<=to_screen; s++) {
Display *dpy = GetBackEndDisplay(cl,s);
DMXScreenInfo *dmxScreen = &dmxScreens[s];
xGLXSingleReq *finishReq;
xGLXSingleReply reply;
#define X_GLXSingle 0 /* needed by GetReq below */
LockDisplay(dpy);
GetReq(GLXSingle,finishReq);
finishReq->reqType = dmxScreen->glxMajorOpcode;
finishReq->glxCode = X_GLsop_Finish;
finishReq->contextTag = (tag ? GetCurrentBackEndTag(cl,tag,s) : 0);
(void) _XReply(dpy, (xReply*) &reply, 0, False);
UnlockDisplay(dpy);
SyncHandle();
}
}
/* If requested, send an XSync to all back-end servers before swapping. */
if (dmxGLXSyncSwap) {
for (s=from_screen; s<=to_screen; s++)
XSync(GetBackEndDisplay(cl,s), False);
}
/* send the SwapBuffers request to all back-end servers */
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
unsigned int be_draw = 0;
if (pGlxPixmap) {
be_draw = (unsigned int)pGlxPixmap->be_xids[s];
}
#ifdef PANORAMIX
else if (pXinDraw) {
pWin = (WindowPtr)SecurityLookupWindow(pXinDraw->info[s].id,
client,
SecurityReadAccess);
}
#endif
else if (pGlxWindow) {
pWin = (WindowPtr)pGlxWindow->pDraw;
}
if (pWin && !be_draw) {
be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
if (!be_draw) {
/* it might be that the window did not created yet on the */
/* back-end server (lazy window creation option), force */
/* creation of the window */
dmxCreateAndRealizeWindow( pWin, TRUE );
be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
}
}
dmxSync( dmxScreen, 1 );
LockDisplay(dpy);
GetReq(GLXSwapBuffers,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXSwapBuffers;
be_req->drawable = be_draw;
be_req->contextTag = ( tag ? GetCurrentBackEndTag(cl,tag,s) : 0 );
UnlockDisplay(dpy);
SyncHandle();
XFlush(dpy);
}
return Success;
}
int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
DrawablePtr pDraw;
xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
GLXContextTag tag = req->contextTag;
XID drawId = req->drawable;
__GLXpixmap *pGlxPixmap = NULL;
__GLXcontext *glxc = NULL;
__glXWindow *pGlxWindow = NULL;
/*
** Check that the GLX drawable is valid.
*/
pDraw = (DrawablePtr) LookupDrawable(drawId, client);
if (pDraw) {
if (pDraw->type != DRAWABLE_WINDOW) {
/*
** Drawable is an X pixmap, which is not allowed.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
}
if (!pDraw) {
pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
__glXPixmapRes);
if (pGlxPixmap) {
/*
** Drawable is a GLX pixmap.
*/
pDraw = pGlxPixmap->pDraw;
}
}
if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
if (pGlxWindow) {
/*
** Drawable is a GLXWindow.
*/
pDraw = pGlxWindow->pDraw;
}
}
if (!pDraw) {
/*
** Drawable is neither a X window nor a GLX pixmap.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
if (tag) {
glxc = __glXLookupContextByTag(cl, tag);
if (!glxc) {
return __glXBadContextTag;
}
}
if (pDraw &&
pDraw->type == DRAWABLE_WINDOW &&
DMX_GET_WINDOW_PRIV((WindowPtr)pDraw)->swapGroup) {
return SGSwapBuffers(cl, drawId, tag, pDraw);
}
return __glXDoSwapBuffers(cl, drawId, tag);
}
/************************************************************************/
/*
** Render and Renderlarge are not in the GLX API. They are used by the GLX
** client library to send batches of GL rendering commands.
*/
/*
** Execute all the drawing commands in a request.
*/
int __glXRender(__GLXclientState *cl, GLbyte *pc)
{
xGLXRenderReq *req;
xGLXRenderReq *be_req;
int size;
__GLXcontext *glxc;
int from_screen = 0;
int to_screen = 0;
int s;
/*
** NOTE: much of this code also appears in the byteswapping version of this
** routine, __glXSwapRender(). Any changes made here should also be
** duplicated there.
*/
req = (xGLXRenderReq *) pc;
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (!glxc) {
return 0;
}
from_screen = to_screen = glxc->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
pc += sz_xGLXRenderReq;
size = (req->length << 2) - sz_xGLXRenderReq;
/*
* just forward the request to back-end server(s)
*/
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
LockDisplay(dpy);
GetReq(GLXRender,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXRender;
be_req->length = req->length;
be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
_XSend(dpy, (const char *)pc, size);
UnlockDisplay(dpy);
SyncHandle();
}
return Success;
}
/*
** Execute a large rendering request (one that spans multiple X requests).
*/
int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
{
xGLXRenderLargeReq *req;
xGLXRenderLargeReq *be_req;
__GLXcontext *glxc;
int from_screen = 0;
int to_screen = 0;
int s;
/*
** NOTE: much of this code also appears in the byteswapping version of this
** routine, __glXSwapRenderLarge(). Any changes made here should also be
** duplicated there.
*/
req = (xGLXRenderLargeReq *) pc;
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (!glxc) {
return 0;
}
from_screen = to_screen = glxc->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
pc += sz_xGLXRenderLargeReq;
/*
* just forward the request to back-end server(s)
*/
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
GetReq(GLXRenderLarge,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXRenderLarge;
be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
be_req->length = req->length;
be_req->requestNumber = req->requestNumber;
be_req->requestTotal = req->requestTotal;
be_req->dataBytes = req->dataBytes;
Data(dpy, (const char *)pc, req->dataBytes);
UnlockDisplay(dpy);
SyncHandle();
}
return Success;
}
/************************************************************************/
int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req;
req = (xGLXVendorPrivateReq *) pc;
switch( req->vendorCode ) {
case X_GLvop_DeleteTexturesEXT:
return __glXVForwardSingleReq( cl, pc );
break;
case X_GLXvop_SwapIntervalSGI:
if (glxIsExtensionSupported("SGI_swap_control")) {
return __glXVForwardSingleReq( cl, pc );
}
else {
return Success;
}
break;
#if 0 /* glx 1.3 */
case X_GLXvop_CreateGLXVideoSourceSGIX:
break;
case X_GLXvop_DestroyGLXVideoSourceSGIX:
break;
case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
break;
case X_GLXvop_DestroyGLXPbufferSGIX:
break;
case X_GLXvop_ChangeDrawableAttributesSGIX:
break;
#endif
case X_GLXvop_BindSwapBarrierSGIX:
return __glXBindSwapBarrierSGIX( cl, pc );
break;
case X_GLXvop_JoinSwapGroupSGIX:
return __glXJoinSwapGroupSGIX( cl, pc );
break;
case X_GLXvop_CreateContextWithConfigSGIX:
return __glXCreateContextWithConfigSGIX( cl, pc );
break;
default:
/*
** unsupported private request
*/
cl->client->errorValue = req->vendorCode;
return __glXUnsupportedPrivateRequest;
}
cl->client->errorValue = req->vendorCode;
return __glXUnsupportedPrivateRequest;
}
int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateWithReplyReq *req;
req = (xGLXVendorPrivateWithReplyReq *) pc;
switch( req->vendorCode ) {
case X_GLvop_GetConvolutionFilterEXT:
case X_GLvop_GetConvolutionParameterfvEXT:
case X_GLvop_GetConvolutionParameterivEXT:
case X_GLvop_GetSeparableFilterEXT:
case X_GLvop_GetHistogramEXT:
case X_GLvop_GetHistogramParameterivEXT:
case X_GLvop_GetMinmaxEXT:
case X_GLvop_GetMinmaxParameterfvEXT:
case X_GLvop_GetMinmaxParameterivEXT:
case X_GLvop_AreTexturesResidentEXT:
case X_GLvop_IsTextureEXT:
return( __glXVForwardPipe0WithReply(cl, pc) );
break;
case X_GLvop_GenTexturesEXT:
return( __glXVForwardAllWithReply(cl, pc) );
break;
#if 0 /* glx1.3 */
case X_GLvop_GetDetailTexFuncSGIS:
case X_GLvop_GetSharpenTexFuncSGIS:
case X_GLvop_GetColorTableSGI:
case X_GLvop_GetColorTableParameterfvSGI:
case X_GLvop_GetColorTableParameterivSGI:
case X_GLvop_GetTexFilterFuncSGIS:
case X_GLvop_GetInstrumentsSGIX:
case X_GLvop_InstrumentsBufferSGIX:
case X_GLvop_PollInstrumentsSGIX:
case X_GLvop_FlushRasterSGIX:
case X_GLXvop_CreateGLXPbufferSGIX:
case X_GLXvop_GetDrawableAttributesSGIX:
case X_GLXvop_QueryHyperpipeNetworkSGIX:
case X_GLXvop_QueryHyperpipeConfigSGIX:
case X_GLXvop_HyperpipeConfigSGIX:
case X_GLXvop_DestroyHyperpipeConfigSGIX:
#endif
case X_GLXvop_QueryMaxSwapBarriersSGIX:
return( __glXQueryMaxSwapBarriersSGIX(cl, pc) );
break;
case X_GLXvop_GetFBConfigsSGIX:
return( __glXGetFBConfigsSGIX(cl, pc) );
break;
case X_GLXvop_MakeCurrentReadSGI:
return( __glXMakeCurrentReadSGI(cl, pc) );
break;
case X_GLXvop_QueryContextInfoEXT:
return( __glXQueryContextInfoEXT(cl,pc) );
break;
default:
/*
** unsupported private request
*/
cl->client->errorValue = req->vendorCode;
return __glXUnsupportedPrivateRequest;
}
}
int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc;
xGLXQueryExtensionsStringReply reply;
GLint screen;
size_t length;
int len, numbytes;
char *be_buf;
#ifdef FWD_QUERY_REQ
xGLXQueryExtensionsStringReq *be_req;
xGLXQueryExtensionsStringReply be_reply;
DMXScreenInfo *dmxScreen;
Display *dpy;
int slop;
#endif
screen = req->screen;
/*
** Check if screen exists.
*/
if ((screen < 0) || (screen >= screenInfo.numScreens)) {
client->errorValue = screen;
return BadValue;
}
#ifdef FWD_QUERY_REQ
dmxScreen = &dmxScreens[screen];
/* Send the glXQueryServerString request */
dpy = GetBackEndDisplay(cl,screen);
LockDisplay(dpy);
GetReq(GLXQueryExtensionsString,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXQueryServerString;
be_req->screen = DefaultScreen(dpy);
_XReply(dpy, (xReply*) &be_reply, 0, False);
len = (int)be_reply.length;
numbytes = (int)be_reply.n;
slop = numbytes * __GLX_SIZE_INT8 & 3;
be_buf = (char *)Xalloc(numbytes);
if (!be_buf) {
/* Throw data on the floor */
_XEatData(dpy, len);
} else {
_XRead(dpy, (char *)be_buf, numbytes);
if (slop) _XEatData(dpy,4-slop);
}
UnlockDisplay(dpy);
SyncHandle();
#else
be_buf = __glXGetServerString(GLX_EXTENSIONS);
numbytes = strlen(be_buf) + 1;
len = __GLX_PAD(numbytes) >> 2;
#endif
length = len;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
reply.length = len;
reply.n = numbytes;
if (client->swapped) {
glxSwapQueryExtensionsStringReply(client, &reply, be_buf);
} else {
WriteToClient(client, sz_xGLXQueryExtensionsStringReply,(char *)&reply);
WriteToClient(client, (int)(length << 2), (char *)be_buf);
}
return Success;
}
int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
xGLXQueryServerStringReply reply;
int name;
GLint screen;
size_t length;
int len, numbytes;
char *be_buf;
#ifdef FWD_QUERY_REQ
xGLXQueryServerStringReq *be_req;
xGLXQueryServerStringReply be_reply;
DMXScreenInfo *dmxScreen;
Display *dpy;
int slop;
#endif
name = req->name;
screen = req->screen;
/*
** Check if screen exists.
*/
if ((screen < 0) || (screen >= screenInfo.numScreens)) {
client->errorValue = screen;
return BadValue;
}
#ifdef FWD_QUERY_REQ
dmxScreen = &dmxScreens[screen];
/* Send the glXQueryServerString request */
dpy = GetBackEndDisplay(cl,screen);
LockDisplay(dpy);
GetReq(GLXQueryServerString,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXQueryServerString;
be_req->screen = DefaultScreen(dpy);
be_req->name = name;
_XReply(dpy, (xReply*) &be_reply, 0, False);
len = (int)be_reply.length;
numbytes = (int)be_reply.n;
slop = numbytes * __GLX_SIZE_INT8 & 3;
be_buf = (char *)Xalloc(numbytes);
if (!be_buf) {
/* Throw data on the floor */
_XEatData(dpy, len);
} else {
_XRead(dpy, (char *)be_buf, numbytes);
if (slop) _XEatData(dpy,4-slop);
}
UnlockDisplay(dpy);
SyncHandle();
#else
be_buf = __glXGetServerString(name);
numbytes = strlen(be_buf) + 1;
len = __GLX_PAD(numbytes) >> 2;
#endif
length = len;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
reply.length = length;
reply.n = numbytes;
if (client->swapped) {
glxSwapQueryServerStringReply(client, &reply, be_buf);
} else {
WriteToClient(client, sz_xGLXQueryServerStringReply, (char *)&reply);
WriteToClient(client, (int)(length << 2), be_buf);
}
return Success;
}
int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
{
xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
xGLXClientInfoReq *be_req;
const char *buf;
int from_screen = 0;
int to_screen = 0;
int s;
cl->GLClientmajorVersion = req->major;
cl->GLClientminorVersion = req->minor;
if (cl->GLClientextensions) __glXFree(cl->GLClientextensions);
buf = (const char *)(req+1);
cl->GLClientextensions = __glXStrdup(buf);
to_screen = screenInfo.numScreens - 1;
for (s=from_screen; s<=to_screen; s++)
{
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
LockDisplay(dpy);
GetReq(GLXClientInfo,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXClientInfo;
be_req->major = req->major;
be_req->minor = req->minor;
be_req->length = req->length;
be_req->numbytes = req->numbytes;
Data(dpy, buf, req->numbytes);
UnlockDisplay(dpy);
SyncHandle();
}
return Success;
}
int __glXUseXFont(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXUseXFontReq *req;
xGLXUseXFontReq *be_req;
FontPtr pFont;
__GLXcontext *glxc = NULL;
int from_screen = 0;
int to_screen = 0;
int s;
dmxFontPrivPtr pFontPriv;
DMXScreenInfo *dmxScreen;
Display *dpy;
req = (xGLXUseXFontReq *) pc;
if (req->contextTag != 0) {
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (glxc) {
from_screen = to_screen = glxc->pScreen->myNum;
}
}
/*
** Font can actually be either the ID of a font or the ID of a GC
** containing a font.
*/
pFont = (FontPtr)LookupIDByType(req->font, RT_FONT);
if (!pFont) {
GC *pGC = (GC *)LookupIDByType(req->font, RT_GC);
if (!pGC) {
client->errorValue = req->font;
return BadFont;
}
pFont = pGC->font;
}
pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex);
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
for (s=from_screen; s<=to_screen; s++) {
dmxScreen = &dmxScreens[s];
dpy = GetBackEndDisplay(cl,s);
dmxSync( dmxScreen, 1 );
LockDisplay(dpy);
GetReq(GLXUseXFont,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXUseXFont;
be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
be_req->font = pFontPriv->font[s]->fid;
be_req->first = req->first;
be_req->count = req->count;
be_req->listBase = req->listBase;
UnlockDisplay(dpy);
SyncHandle();
XSync( dpy, False );
}
return Success;
}
/*
* start GLX 1.3 here
*/
int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
xGLXGetFBConfigsReply reply;
__GLXFBConfig *pFBConfig;
CARD32 buf[2 * __GLX_TOTAL_FBCONFIG_PROPS];
int numAttribs = __GLX_TOTAL_FBCONFIG_PROPS;
unsigned int screen = req->screen;
int numFBConfigs, i, p;
__GLXscreenInfo *pGlxScreen;
if (screen > screenInfo.numScreens) {
/* The client library must send a valid screen number. */
client->errorValue = screen;
return BadValue;
}
pGlxScreen = &__glXActiveScreens[screen];
numFBConfigs = __glXNumFBConfigs;
reply.numFBConfigs = numFBConfigs;
reply.numAttribs = numAttribs;
reply.length = (numFBConfigs * 2 * numAttribs * __GLX_SIZE_CARD32) >> 2;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
if (client->swapped) {
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&reply.sequenceNumber);
__GLX_SWAP_INT(&reply.length);
__GLX_SWAP_INT(&reply.numFBConfigs);
__GLX_SWAP_INT(&reply.numAttribs);
}
WriteToClient(client, sz_xGLXGetFBConfigsReply, (char *)&reply);
for (i=0; i < numFBConfigs; i++) {
int associatedVisualId = 0;
int drawableTypeIndex;
pFBConfig = __glXFBConfigs[ i * (screenInfo.numScreens+1) ];
p = 0;
/* core attributes */
buf[p++] = GLX_FBCONFIG_ID;
buf[p++] = pFBConfig->id;
buf[p++] = GLX_BUFFER_SIZE;
buf[p++] = pFBConfig->indexBits;
buf[p++] = GLX_LEVEL;
buf[p++] = pFBConfig->level;
buf[p++] = GLX_DOUBLEBUFFER;
buf[p++] = pFBConfig->doubleBufferMode;
buf[p++] = GLX_STEREO;
buf[p++] = pFBConfig->stereoMode;
buf[p++] = GLX_AUX_BUFFERS;
buf[p++] = pFBConfig->maxAuxBuffers;
buf[p++] = GLX_RED_SIZE;
buf[p++] = pFBConfig->redBits;
buf[p++] = GLX_GREEN_SIZE;
buf[p++] = pFBConfig->greenBits;
buf[p++] = GLX_BLUE_SIZE;
buf[p++] = pFBConfig->blueBits;
buf[p++] = GLX_ALPHA_SIZE;
buf[p++] = pFBConfig->alphaBits;
buf[p++] = GLX_DEPTH_SIZE;
buf[p++] = pFBConfig->depthBits;
buf[p++] = GLX_STENCIL_SIZE;
buf[p++] = pFBConfig->stencilBits;
buf[p++] = GLX_ACCUM_RED_SIZE;
buf[p++] = pFBConfig->accumRedBits;
buf[p++] = GLX_ACCUM_GREEN_SIZE;
buf[p++] = pFBConfig->accumGreenBits;
buf[p++] = GLX_ACCUM_BLUE_SIZE;
buf[p++] = pFBConfig->accumBlueBits;
buf[p++] = GLX_ACCUM_ALPHA_SIZE;
buf[p++] = pFBConfig->accumAlphaBits;
buf[p++] = GLX_RENDER_TYPE;
buf[p++] = pFBConfig->renderType;
buf[p++] = GLX_DRAWABLE_TYPE;
drawableTypeIndex = p;
buf[p++] = pFBConfig->drawableType;
buf[p++] = GLX_X_VISUAL_TYPE;
buf[p++] = pFBConfig->visualType;
buf[p++] = GLX_CONFIG_CAVEAT;
buf[p++] = pFBConfig->visualCaveat;
buf[p++] = GLX_TRANSPARENT_TYPE;
buf[p++] = pFBConfig->transparentType;
buf[p++] = GLX_TRANSPARENT_RED_VALUE;
buf[p++] = pFBConfig->transparentRed;
buf[p++] = GLX_TRANSPARENT_GREEN_VALUE;
buf[p++] = pFBConfig->transparentGreen;
buf[p++] = GLX_TRANSPARENT_BLUE_VALUE;
buf[p++] = pFBConfig->transparentBlue;
buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE;
buf[p++] = pFBConfig->transparentAlpha;
buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
buf[p++] = pFBConfig->transparentIndex;
buf[p++] = GLX_MAX_PBUFFER_WIDTH;
buf[p++] = pFBConfig->maxPbufferWidth;
buf[p++] = GLX_MAX_PBUFFER_HEIGHT;
buf[p++] = pFBConfig->maxPbufferHeight;
buf[p++] = GLX_MAX_PBUFFER_PIXELS;
buf[p++] = pFBConfig->maxPbufferPixels;
/*
* find the visual of the back-end server and match a visual
* on the proxy.
* do only once - if a visual is not yet associated.
*/
if (pFBConfig->associatedVisualId == (unsigned int)-1) {
DMXScreenInfo *dmxScreen = &dmxScreens[screen];
__GLXFBConfig *be_pFBConfig = __glXFBConfigs[ i * (screenInfo.numScreens+1)+screen+1 ];
__GLXvisualConfig *pGlxVisual = NULL;
int v;
int found = 0;
for (v=0; v<dmxScreen->numGlxVisuals; v++) {
if (dmxScreen->glxVisuals[v].vid == be_pFBConfig->associatedVisualId) {
pGlxVisual = &dmxScreen->glxVisuals[v];
break;
}
}
if (pGlxVisual) {
for (v=0; v<pGlxScreen->numVisuals; v++) {
if (glxVisualsMatch(&pGlxScreen->pGlxVisual[v], pGlxVisual)) {
associatedVisualId = pGlxScreen->pGlxVisual[v].vid;
found = 1;
break;
}
}
}
if (!found) {
associatedVisualId = 0;
pFBConfig->drawableType &= ~(GLX_WINDOW_BIT);
buf[drawableTypeIndex] = pFBConfig->drawableType;
}
#ifdef PANORAMIX
else if (!noPanoramiXExtension) {
/* convert the associated visualId to the panoramix one */
for (v=0; v<255; v++) {
if ( PanoramiXVisualTable[ v * MAXSCREENS + screen ] ==
associatedVisualId ) {
associatedVisualId = v;
break;
}
}
pFBConfig->associatedVisualId = associatedVisualId;
}
#endif
}
else {
associatedVisualId = pFBConfig->associatedVisualId;
}
buf[p++] = GLX_VISUAL_ID;
buf[p++] = associatedVisualId;
/* SGIS_multisample attributes */
buf[p++] = GLX_SAMPLES_SGIS;
buf[p++] = pFBConfig->multiSampleSize;
buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
buf[p++] = pFBConfig->nMultiSampleBuffers;
/* SGIX_pbuffer specific attributes */
buf[p++] = GLX_OPTIMAL_PBUFFER_WIDTH_SGIX;
buf[p++] = pFBConfig->optimalPbufferWidth;
buf[p++] = GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX;
buf[p++] = pFBConfig->optimalPbufferHeight;
buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
buf[p++] = pFBConfig->visualSelectGroup;
if (client->swapped) {
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT_ARRAY((int *)buf, 2*numAttribs);
}
WriteToClient(client, 2*numAttribs * __GLX_SIZE_CARD32, (char *)buf);
}
return Success;
}
int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)pc;
xGLXGetFBConfigsReq new_req;
new_req.reqType = req->reqType;
new_req.glxCode = req->glxCode;
new_req.length = req->length;
new_req.screen = req->screen;
return( __glXGetFBConfigs( cl, (GLbyte *)&new_req ) );
}
int __glXCreateWindow(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
int screen = req->screen;
GLXFBConfigID fbconfigId = req->fbconfig;
XID windowId = req->window;
XID glxwindowId = req->glxwindow;
DrawablePtr pDraw;
ScreenPtr pScreen;
__glXWindow *pGlxWindow;
__GLXFBConfig *pGlxFBConfig = NULL;
VisualPtr pVisual;
VisualID visId;
int i;
/*
** Check if windowId is valid
*/
pDraw = (DrawablePtr) LookupDrawable(windowId, client);
if (!pDraw || pDraw->type != DRAWABLE_WINDOW) {
client->errorValue = windowId;
return BadWindow;
}
/*
** Check if screen of window matches screen of fbconfig.
*/
pScreen = pDraw->pScreen;
if (screen != pScreen->myNum) {
return BadMatch;
}
/*
** Find the FBConfigRec for this fbconfigid.
*/
if (!(pGlxFBConfig = glxLookupFBConfig(fbconfigId))) {
client->errorValue = fbconfigId;
return __glXBadFBConfig;
}
visId = pGlxFBConfig->associatedVisualId;
/*
** Check if the fbconfig supports rendering to windows
*/
if( !(pGlxFBConfig->drawableType & GLX_WINDOW_BIT) ) {
return BadMatch;
}
if (visId != None) {
/*
** Check if the visual ID is valid for this screen.
*/
pVisual = pScreen->visuals;
for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
if (pVisual->vid == visId) {
break;
}
}
if (i == pScreen->numVisuals) {
client->errorValue = visId;
return BadValue;
}
/*
** Check if color buffer depth of fbconfig matches depth
** of window.
*/
if (pVisual->nplanes != pDraw->depth) {
return BadMatch;
}
} else
/*
** The window was created with no visual that corresponds
** to fbconfig
*/
return BadMatch;
/*
** Check if there is already a fbconfig associated with this window
*/
if ( LookupIDByType(glxwindowId, __glXWindowRes) ) {
client->errorValue = glxwindowId;
return BadAlloc;
}
pGlxWindow = (__glXWindow *) xalloc(sizeof(__glXWindow));
if (!pGlxWindow) {
return BadAlloc;
}
/*
** Register this GLX window as a resource
*/
if (!(AddResource(glxwindowId, __glXWindowRes, pGlxWindow))) {
return BadAlloc;
}
pGlxWindow->pDraw = pDraw;
pGlxWindow->type = GLX_GLXWINDOW_TYPE;
pGlxWindow->idExists = True;
pGlxWindow->refcnt = 0;
pGlxWindow->pGlxFBConfig = pGlxFBConfig;
pGlxWindow->pScreen = pScreen;
return Success;
}
int __glXDestroyWindow(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
XID glxwindow = req->glxwindow;
/*
** Check if it's a valid GLX window.
*/
if (!LookupIDByType(glxwindow, __glXWindowRes)) {
client->errorValue = glxwindow;
return __glXBadDrawable;
}
/*
** The glx window destructor will check whether it's current before
** freeing anything.
*/
FreeResource(glxwindow, RT_NONE);
return Success;
}
int __glXQueryContext(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
__GLXcontext *ctx;
xGLXQueryContextReq *req;
xGLXQueryContextReply reply;
int nProps;
int *sendBuf, *pSendBuf;
int nReplyBytes;
req = (xGLXQueryContextReq *)pc;
ctx = (__GLXcontext *) LookupIDByType(req->context, __glXContextRes);
if (!ctx) {
client->errorValue = req->context;
return __glXBadContext;
}
nProps = 3;
reply.length = nProps << 1;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
reply.n = nProps;
nReplyBytes = reply.length << 2;
sendBuf = (int *)xalloc(nReplyBytes);
pSendBuf = sendBuf;
*pSendBuf++ = GLX_FBCONFIG_ID;
*pSendBuf++ = (int)(ctx->pFBConfig->id);
*pSendBuf++ = GLX_RENDER_TYPE;
*pSendBuf++ = (int)(ctx->pFBConfig->renderType);
*pSendBuf++ = GLX_SCREEN;
*pSendBuf++ = (int)(ctx->pScreen->myNum);
if (client->swapped) {
__glXSwapQueryContextReply(client, &reply, sendBuf);
} else {
WriteToClient(client, sz_xGLXQueryContextReply, (char *)&reply);
WriteToClient(client, nReplyBytes, (char *)sendBuf);
}
xfree((char *)sendBuf);
return Success;
}
int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
__GLXcontext *ctx;
xGLXQueryContextInfoEXTReq *req;
xGLXQueryContextInfoEXTReply reply;
int nProps;
int *sendBuf, *pSendBuf;
int nReplyBytes;
req = (xGLXQueryContextInfoEXTReq *)pc;
ctx = (__GLXcontext *) SecurityLookupIDByType(client, req->context, __glXContextRes, SecurityReadAccess);
if (!ctx) {
client->errorValue = req->context;
return __glXBadContext;
}
nProps = 4;
reply.length = nProps << 1;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
reply.n = nProps;
nReplyBytes = reply.length << 2;
sendBuf = (int *)xalloc(nReplyBytes);
pSendBuf = sendBuf;
*pSendBuf++ = GLX_SHARE_CONTEXT_EXT;
*pSendBuf++ = (int)(ctx->share_id);
*pSendBuf++ = GLX_VISUAL_ID_EXT;
*pSendBuf++ = (int)(ctx->pVisual ? ctx->pVisual->vid : 0);
*pSendBuf++ = GLX_SCREEN_EXT;
*pSendBuf++ = (int)(ctx->pScreen->myNum);
*pSendBuf++ = GLX_FBCONFIG_ID;
*pSendBuf++ = (int)(ctx->pFBConfig ? ctx->pFBConfig->id : 0);
if (client->swapped) {
__glXSwapQueryContextInfoEXTReply(client, &reply, sendBuf);
} else {
WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)&reply);
WriteToClient(client, nReplyBytes, (char *)sendBuf);
}
xfree((char *)sendBuf);
return Success;
}
int __glXCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *)pc;
xGLXCreatePbufferReq *be_req;
int screen = req->screen;
GLXFBConfigID fbconfigId = req->fbconfig;
GLXPbuffer pbuffer = req->pbuffer;
__glXPbuffer *pGlxPbuffer;
int numAttribs = req->numAttribs;
int *attr;
ScreenPtr pScreen;
__GLXFBConfig *pGlxFBConfig;
__GLXFBConfig *be_pGlxFBConfig;
XID be_xid;
Display *dpy;
DMXScreenInfo *dmxScreen;
int s;
int from_screen, to_screen;
/*
** Look up screen and FBConfig.
*/
if (screen > screenInfo.numScreens) {
/* The client library must send a valid screen number. */
client->errorValue = screen;
return BadValue;
}
pScreen = screenInfo.screens[screen];
/*
** Find the FBConfigRec for this fbconfigid.
*/
if (!(pGlxFBConfig = glxLookupFBConfig(fbconfigId))) {
client->errorValue = fbconfigId;
return __glXBadFBConfig;
}
/*
** Create the GLX part of the Pbuffer.
*/
pGlxPbuffer = (__glXPbuffer *) xalloc(sizeof(__glXPbuffer));
if (!pGlxPbuffer) {
return BadAlloc;
}
pGlxPbuffer->be_xids = (XID *) xalloc( sizeof(XID) * screenInfo.numScreens );
if (!pGlxPbuffer->be_xids) {
xfree(pGlxPbuffer);
return BadAlloc;
}
/*
* Allocate an XID on the back-end server(s) and send him the request
*/
from_screen = to_screen = screen;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
for (s=from_screen; s<=to_screen; s++) {
dpy = GetBackEndDisplay(cl,s);
be_xid = XAllocID(dpy);
dmxScreen = &dmxScreens[s];
be_pGlxFBConfig = glxLookupBackEndFBConfig( pGlxFBConfig->id, s );
attr = (int *)( req+1 );
LockDisplay(dpy);
GetReqExtra(GLXCreatePbuffer, 2 * numAttribs * __GLX_SIZE_CARD32, be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXCreatePbuffer;
be_req->screen = be_pGlxFBConfig->screen;
be_req->fbconfig = be_pGlxFBConfig->id;
be_req->pbuffer = be_xid;
be_req->numAttribs = numAttribs;
/* Send attributes */
if ( attr != NULL ) {
CARD32 *pc = (CARD32 *)(be_req + 1);
while (numAttribs-- > 0) {
*pc++ = *attr++; /* token */
*pc++ = *attr++; /* value */
}
}
UnlockDisplay(dpy);
SyncHandle();
pGlxPbuffer->be_xids[s] = be_xid;
}
pGlxPbuffer->idExists = True;
pGlxPbuffer->refcnt = 0;
pGlxPbuffer->pFBConfig = pGlxFBConfig;
pGlxPbuffer->pScreen = pScreen;
/*
** Register the resource.
*/
if (!(AddResource(pbuffer, __glXPbufferRes, pGlxPbuffer))) {
return BadAlloc;
}
return Success;
}
int __glXDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
xGLXDestroyPbufferReq *be_req;
GLXPbuffer pbuffer = req->pbuffer;
Display *dpy;
int screen;
DMXScreenInfo *dmxScreen;
__glXPbuffer *pGlxPbuffer;
int s;
int from_screen, to_screen;
/*
** Check if it's a valid Pbuffer
*/
pGlxPbuffer = (__glXPbuffer *)LookupIDByType(pbuffer, __glXPbufferRes);
if (!pGlxPbuffer) {
client->errorValue = pbuffer;
return __glXBadPbuffer;
}
screen = pGlxPbuffer->pScreen->myNum;
from_screen = to_screen = screen;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
for (s=from_screen; s<=to_screen; s++) {
dpy = GetBackEndDisplay(cl,s);
dmxScreen = &dmxScreens[s];
/* send the destroy request to the back-end server */
LockDisplay(dpy);
GetReq(GLXDestroyPbuffer, be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXDestroyPbuffer;
be_req->pbuffer = pGlxPbuffer->be_xids[s];
UnlockDisplay(dpy);
SyncHandle();
}
FreeResource(pbuffer, RT_NONE);
return Success;
}
int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
xGLXGetDrawableAttributesReq *be_req;
xGLXGetDrawableAttributesReply reply;
ClientPtr client = cl->client;
GLXDrawable drawId = req->drawable;
GLXDrawable be_drawable = 0;
DrawablePtr pDraw = NULL;
Display *dpy;
int screen;
DMXScreenInfo *dmxScreen;
CARD32 *attribs = NULL;
int attribs_size;
#ifdef PANORAMIX
PanoramiXRes *pXinDraw = NULL;
#endif
if (drawId != None) {
pDraw = (DrawablePtr) LookupDrawable(drawId, client);
if (pDraw) {
if (pDraw->type == DRAWABLE_WINDOW) {
WindowPtr pWin = (WindowPtr)pDraw;
be_drawable = 0;
screen = pWin->drawable.pScreen->myNum;
}
else {
/*
** Drawable is not a Window , GLXWindow or a GLXPixmap.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
}
if (!pDraw) {
__GLXpixmap *pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
__glXPixmapRes);
if (pGlxPixmap) {
pDraw = pGlxPixmap->pDraw;
screen = pGlxPixmap->pScreen->myNum;
be_drawable = pGlxPixmap->be_xids[screen];
}
}
if (!pDraw) {
__glXWindow *pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
if (pGlxWindow) {
pDraw = pGlxWindow->pDraw;
screen = pGlxWindow->pScreen->myNum;
be_drawable = 0;
}
}
if (!pDraw) {
__glXPbuffer *pGlxPbuffer = (__glXPbuffer *)LookupIDByType(drawId, __glXPbufferRes);
if (pGlxPbuffer) {
pDraw = (DrawablePtr)pGlxPbuffer;
screen = pGlxPbuffer->pScreen->myNum;
be_drawable = pGlxPbuffer->be_xids[screen];
}
}
if (!pDraw) {
/*
** Drawable is not a Window , GLXWindow or a GLXPixmap.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
}
/* if the drawable is a window or GLXWindow -
* we need to find the base id on the back-end server
*/
if (!be_drawable) {
WindowPtr pWin = (WindowPtr)pDraw;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
pXinDraw = (PanoramiXRes *)
SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
if (!pXinDraw) {
client->errorValue = drawId;
return __glXBadDrawable;
}
pWin = (WindowPtr)SecurityLookupWindow(pXinDraw->info[screen].id,
client,
SecurityReadAccess);
}
#endif
if (pWin) {
be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
if (!be_drawable) {
/* it might be that the window did not created yet on the */
/* back-end server (lazy window creation option), force */
/* creation of the window */
dmxCreateAndRealizeWindow( pWin, TRUE );
be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
}
}
else {
client->errorValue = drawId;
return __glXBadDrawable;
}
}
/* send the request to the back-end server */
dpy = GetBackEndDisplay(cl,screen);
dmxScreen = &dmxScreens[screen];
/* make sure drawable exists on back-end */
dmxSync( dmxScreen, 1 );
LockDisplay(dpy);
GetReq(GLXGetDrawableAttributes, be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXGetDrawableAttributes;
be_req->drawable = be_drawable;
be_req->length = req->length;
if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
UnlockDisplay(dpy);
SyncHandle();
return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
}
if (reply.numAttribs) {
attribs_size = 2 * reply.numAttribs * __GLX_SIZE_CARD32;
attribs = (CARD32 *) Xalloc(attribs_size);
if (attribs == NULL) {
UnlockDisplay(dpy);
SyncHandle();
return BadAlloc;
}
_XRead(dpy, (char *) attribs, attribs_size);
}
UnlockDisplay(dpy);
SyncHandle();
/* send the reply back to the client */
reply.sequenceNumber = client->sequence;
if (client->swapped) {
__glXSwapGetDrawableAttributesReply(client, &reply, (int *)attribs);
}
else {
WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)&reply);
WriteToClient(client, attribs_size, (char *)attribs);
}
Xfree(attribs);
return Success;
}
int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *)pc;
xGLXChangeDrawableAttributesReq *be_req;
ClientPtr client = cl->client;
GLXDrawable drawId = req->drawable;
GLXDrawable be_drawable = 0;
DrawablePtr pDraw = NULL;
Display *dpy;
int screen;
DMXScreenInfo *dmxScreen;
char *attrbuf;
#ifdef PANORAMIX
PanoramiXRes *pXinDraw = NULL;
PanoramiXRes *pXinReadDraw = NULL;
#endif
if (drawId != None) {
pDraw = (DrawablePtr) LookupDrawable(drawId, client);
if (pDraw) {
if (pDraw->type == DRAWABLE_WINDOW) {
WindowPtr pWin = (WindowPtr)pDraw;
be_drawable = 0;
screen = pWin->drawable.pScreen->myNum;
}
else {
/*
** Drawable is not a Window , GLXWindow or a GLXPixmap.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
}
if (!pDraw) {
__GLXpixmap *pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
__glXPixmapRes);
if (pGlxPixmap) {
pDraw = pGlxPixmap->pDraw;
screen = pGlxPixmap->pScreen->myNum;
be_drawable = pGlxPixmap->be_xids[screen];
}
}
if (!pDraw) {
__glXWindow *pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
if (pGlxWindow) {
pDraw = pGlxWindow->pDraw;
screen = pGlxWindow->pScreen->myNum;
be_drawable = 0;
}
}
if (!pDraw) {
__glXPbuffer *pGlxPbuffer = (__glXPbuffer *)LookupIDByType(drawId, __glXPbufferRes);
if (pGlxPbuffer) {
pDraw = (DrawablePtr)pGlxPbuffer;
screen = pGlxPbuffer->pScreen->myNum;
be_drawable = pGlxPbuffer->be_xids[screen];
}
}
if (!pDraw) {
/*
** Drawable is not a Window , GLXWindow or a GLXPixmap.
*/
client->errorValue = drawId;
return __glXBadDrawable;
}
}
/* if the drawable is a window or GLXWindow -
* we need to find the base id on the back-end server
*/
if (!be_drawable) {
WindowPtr pWin = (WindowPtr)pDraw;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
pXinDraw = (PanoramiXRes *)
SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
if (!pXinDraw) {
client->errorValue = drawId;
return __glXBadDrawable;
}
pWin = (WindowPtr)SecurityLookupWindow(pXinDraw->info[screen].id,
client,
SecurityReadAccess);
}
#endif
if (pWin) {
be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
if (!be_drawable) {
/* it might be that the window did not created yet on the */
/* back-end server (lazy window creation option), force */
/* creation of the window */
dmxCreateAndRealizeWindow( pWin, TRUE );
be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
}
}
else {
client->errorValue = drawId;
return __glXBadDrawable;
}
}
/* send the request to the back-end server */
dpy = GetBackEndDisplay(cl,screen);
dmxScreen = &dmxScreens[screen];
/* make sure drawable exists on back-end */
dmxSync( dmxScreen, 1 );
LockDisplay(dpy);
GetReqExtra(GLXChangeDrawableAttributes,
2 * req->numAttribs * __GLX_SIZE_CARD32, be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = X_GLXChangeDrawableAttributes;
be_req->drawable = be_drawable;
be_req->numAttribs = req->numAttribs;
be_req->length = req->length;
UnlockDisplay(dpy);
SyncHandle();
return Success;
}
int __glXSendLargeCommand(__GLXclientState *cl, GLXContextTag contextTag)
{
ClientPtr client = cl->client;
xGLXRenderLargeReq *req;
GLint maxSize, amount;
GLint totalRequests, requestNumber;
GLint dataLen;
GLbyte *data;
__GLXcontext *glxc;
int s;
int from_screen, to_screen;
maxSize = cl->largeCmdMaxReqDataSize - (GLint)sizeof(xGLXRenderLargeReq);
dataLen = cl->largeCmdBytesTotal;
totalRequests = (dataLen / maxSize);
if (dataLen % maxSize) totalRequests++;
glxc = __glXLookupContextByTag(cl, contextTag);
if (!glxc) {
client->errorValue = contextTag;
return __glXBadContext;
}
from_screen = to_screen = glxc->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
/*
** Send enough requests until the whole array is sent.
*/
requestNumber = 1;
data = cl->largeCmdBuf;
while (dataLen > 0) {
amount = dataLen;
if (amount > maxSize) {
amount = maxSize;
}
for (s=from_screen; s<=to_screen; s++) {
Display *dpy = GetBackEndDisplay(cl,s);
DMXScreenInfo *dmxScreen = &dmxScreens[s];
LockDisplay(dpy);
GetReq(GLXRenderLarge,req);
req->reqType = dmxScreen->glxMajorOpcode;
req->glxCode = X_GLXRenderLarge;
req->contextTag = (glxc ? GetCurrentBackEndTag(cl,contextTag,s) : 0);
req->length += (amount + 3) >> 2;
req->requestNumber = requestNumber++;
req->requestTotal = totalRequests;
req->dataBytes = amount;
Data(dpy, ((const char*)data), amount);
dataLen -= amount;
data = ((GLbyte *) data) + amount;
UnlockDisplay(dpy);
SyncHandle();
}
}
return Success;
}
Reference in New Issue View Git Blame Copy Permalink