diff options
Diffstat (limited to 'xorg-server/hw/dmx/dmx_glxvisuals.c')
| -rw-r--r-- | xorg-server/hw/dmx/dmx_glxvisuals.c | 606 |
1 files changed, 606 insertions, 0 deletions
diff --git a/xorg-server/hw/dmx/dmx_glxvisuals.c b/xorg-server/hw/dmx/dmx_glxvisuals.c new file mode 100644 index 000000000..1e0cbbc1b --- /dev/null +++ b/xorg-server/hw/dmx/dmx_glxvisuals.c @@ -0,0 +1,606 @@ +/* +** 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. +** +*/ + +#ifdef HAVE_DMX_CONFIG_H +#include <dmx-config.h> +#endif + +#include "dmx.h" +#include <GL/glx.h> +#include <GL/glxproto.h> +#include <X11/extensions/Xext.h> +#include <X11/extensions/extutil.h> + +#include "dmx_glxvisuals.h" + +__GLXvisualConfig *GetGLXVisualConfigs(Display *dpy, int screen, int *nconfigs) +{ + xGLXGetVisualConfigsReq *req; + xGLXGetVisualConfigsReply reply; + __GLXvisualConfig *config, *configs; + GLint i, j, nvisuals, nprops; + INT32 *props, *p; + int majorOpcode, dummy; + int num_good_visuals; + + if (!XQueryExtension(dpy, "GLX", &majorOpcode, &dummy, &dummy)) { + return(NULL); + } + + /* Send the glXGetVisualConfigs request */ + LockDisplay(dpy); + GetReq(GLXGetVisualConfigs,req); + req->reqType = majorOpcode; + req->glxCode = X_GLXGetVisualConfigs; + req->screen = screen; + if (!_XReply(dpy, (xReply*) &reply, 0, False)) { + /* Something is busted. Punt. */ + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + + nvisuals = (int)reply.numVisuals; + if (!nvisuals) { + /* This screen does not support GL rendering */ + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + + /* Check number of properties per visual */ + nprops = (int)reply.numProps; + if (nprops < __GLX_MIN_CONFIG_PROPS) { + /* Huh? Not in protocol defined limits. Punt */ + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + props = (INT32*) Xmalloc(nprops * __GLX_SIZE_CARD32); + if (!props) { + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + + /* Allocate memory for our config structure */ + config = (__GLXvisualConfig*) + Xmalloc(nvisuals * sizeof(__GLXvisualConfig)); + if (!config) { + Xfree(props); + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + memset(config, 0, nvisuals * sizeof(__GLXvisualConfig)); + configs = config; + num_good_visuals = 0; + + /* Convert config structure into our format */ + for (i=0; i<nvisuals; i++) { + + /* Read config structure */ + _XRead(dpy, (char *)props, (nprops * __GLX_SIZE_CARD32)); + + /* fill in default values */ + config->visualRating = GLX_NONE_EXT; + config->transparentPixel = GLX_NONE_EXT; + + /* Copy in the first set of properties */ + config->vid = props[0]; + config->class = props[1]; + + config->rgba = (Bool) props[2]; + + config->redSize = props[3]; + config->greenSize = props[4]; + config->blueSize = props[5]; + config->alphaSize = props[6]; + + config->accumRedSize = props[7]; + config->accumGreenSize = props[8]; + config->accumBlueSize = props[9]; + config->accumAlphaSize = props[10]; + + config->doubleBuffer = (Bool) props[11]; + config->stereo = (Bool) props[12]; + + config->bufferSize = props[13]; + config->depthSize = props[14]; + config->stencilSize = props[15]; + + config->auxBuffers = props[16]; + config->level = props[17]; + + /* Process remaining properties */ + p = &props[18]; + for (j=__GLX_MIN_CONFIG_PROPS; j<nprops; j+=2) { + int property = *p++; + int value = *p++; + + switch (property) { + case GLX_SAMPLES_SGIS: + config->multiSampleSize = value; + break; + case GLX_SAMPLE_BUFFERS_SGIS: + config->nMultiSampleBuffers = value; + break; + + case GLX_TRANSPARENT_TYPE_EXT: + config->transparentPixel = value; + break; + case GLX_TRANSPARENT_INDEX_VALUE_EXT: + config->transparentIndex = value; + break; + case GLX_TRANSPARENT_RED_VALUE_EXT: + config->transparentRed = value; + break; + case GLX_TRANSPARENT_GREEN_VALUE_EXT: + config->transparentGreen = value; + break; + case GLX_TRANSPARENT_BLUE_VALUE_EXT: + config->transparentBlue = value; + break; + case GLX_TRANSPARENT_ALPHA_VALUE_EXT: + config->transparentAlpha = value; + break; + + case GLX_VISUAL_CAVEAT_EXT: + config->visualRating = value; + break; + + /* visualSelectGroup is an internal used property */ + case GLX_VISUAL_SELECT_GROUP_SGIX: + config->visualSelectGroup = value; + break; + + default : + /* Ignore properties we don't recognize */ + break; + } + } /* for j */ + + /* + // filter out overlay visuals (dmx does not support overlays) + */ + if (config->level == 0) { + config++; + num_good_visuals++; + } + + } /* for i */ + + UnlockDisplay(dpy); + + nvisuals = num_good_visuals; + + config = configs; + for (i=0; i<nvisuals; i++) { + /* XXX hack to fill-in mask info (need a better way to do this) */ + { + XVisualInfo *vis, template; + int n; + + template.screen = screen; + template.visualid = config->vid; + vis = XGetVisualInfo(dpy, VisualScreenMask|VisualIDMask, + &template, &n); + + if (vis != NULL) { + config->redMask = vis->red_mask; + config->greenMask = vis->green_mask; + config->blueMask = vis->blue_mask; + config->alphaMask = 0; /* XXX */ + free(vis); + } + } + config++; + } /* for i */ + + XFree(props); + SyncHandle(); + + *nconfigs = nvisuals; + return( configs ); +} + + +__GLXFBConfig *GetGLXFBConfigs(Display *dpy, int glxMajorOpcode, int *nconfigs) +{ + xGLXGetFBConfigsReq *req; + xGLXGetFBConfigsReply reply; + __GLXFBConfig *config, *fbconfigs; + GLint i, j, numFBConfigs, numAttribs; + INT32 *attrs, *p; + int screen = DefaultScreen( dpy ); + int numValidConfigs = 0; + + /* Send the glXGetFBConfigs request */ + LockDisplay(dpy); + GetReq(GLXGetFBConfigs, req); + req->reqType = glxMajorOpcode; + req->glxCode = X_GLXGetFBConfigs; + req->screen = screen; + + *nconfigs = 0; + + if (!_XReply(dpy, (xReply*) &reply, 0, False)) { + /* Something is busted. Punt. */ + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + + numFBConfigs = (int)reply.numFBConfigs; + if (!numFBConfigs) { + /* This screen does not support GL rendering */ + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + + numAttribs = (int)reply.numAttribs; + if (!numAttribs) { + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + + attrs = (INT32*) Xmalloc(2*numAttribs * __GLX_SIZE_CARD32); + if (!attrs) { + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + + /* Allocate memory for our config structure */ + config = (__GLXFBConfig*) + Xmalloc(numFBConfigs * sizeof(__GLXFBConfig)); + if (!config) { + Xfree(attrs); + UnlockDisplay(dpy); + SyncHandle(); + return NULL; + } + memset(config, 0, numFBConfigs * sizeof(__GLXFBConfig)); + fbconfigs = config; + + /* Convert attribute list into our format */ + for (i=0; i<numFBConfigs; i++) { + + /* Fill in default properties */ + config->transparentType = GLX_NONE_EXT; + config->visualCaveat = GLX_NONE_EXT; + config->minRed = 0.; + config->maxRed = 1.; + config->minGreen = 0.; + config->maxGreen = 1.; + config->minBlue = 0.; + config->maxBlue = 1.; + config->minAlpha = 0.; + config->maxAlpha = 1.; + + /* Read attribute list */ + _XRead(dpy, (char *)attrs, (2*numAttribs * __GLX_SIZE_CARD32)); + + p = attrs; + for (j=0; j<numAttribs; j++) { + int attribute = *p++; + int value = *p++; + + switch (attribute) { + /* core attributes */ + case GLX_FBCONFIG_ID: + config->id = value; + break; + case GLX_BUFFER_SIZE: + config->indexBits = value; + break; + case GLX_LEVEL: + config->level = value; + break; + case GLX_DOUBLEBUFFER: + config->doubleBufferMode = value; + break; + case GLX_STEREO: + config->stereoMode = value; + break; + case GLX_AUX_BUFFERS: + config->maxAuxBuffers = value; + break; + case GLX_RED_SIZE: + config->redBits = value; + break; + case GLX_GREEN_SIZE: + config->greenBits = value; + break; + case GLX_BLUE_SIZE: + config->blueBits = value; + break; + case GLX_ALPHA_SIZE: + config->alphaBits = value; + break; + case GLX_DEPTH_SIZE: + config->depthBits = value; + break; + case GLX_STENCIL_SIZE: + config->stencilBits = value; + break; + case GLX_ACCUM_RED_SIZE: + config->accumRedBits = value; + break; + case GLX_ACCUM_GREEN_SIZE: + config->accumGreenBits = value; + break; + case GLX_ACCUM_BLUE_SIZE: + config->accumBlueBits = value; + break; + case GLX_ACCUM_ALPHA_SIZE: + config->accumAlphaBits = value; + break; + case GLX_RENDER_TYPE: + config->renderType = value; + break; + case GLX_DRAWABLE_TYPE: + config->drawableType = value; + break; + case GLX_X_VISUAL_TYPE: + config->visualType = value; + break; + case GLX_CONFIG_CAVEAT: + config->visualCaveat = value; + break; + case GLX_TRANSPARENT_TYPE: + config->transparentType = value; + break; + case GLX_TRANSPARENT_INDEX_VALUE: + config->transparentIndex = value; + break; + case GLX_TRANSPARENT_RED_VALUE: + config->transparentRed = value; + break; + case GLX_TRANSPARENT_GREEN_VALUE: + config->transparentGreen = value; + break; + case GLX_TRANSPARENT_BLUE_VALUE: + config->transparentBlue = value; + break; + case GLX_TRANSPARENT_ALPHA_VALUE: + config->transparentAlpha = value; + break; + case GLX_MAX_PBUFFER_WIDTH: + config->maxPbufferWidth = value; + break; + case GLX_MAX_PBUFFER_HEIGHT: + config->maxPbufferHeight = value; + break; + case GLX_MAX_PBUFFER_PIXELS: + config->maxPbufferPixels = value; + break; + case GLX_VISUAL_ID: + config->associatedVisualId = value; + break; + + /* visualSelectGroup is an internal used property */ + case GLX_VISUAL_SELECT_GROUP_SGIX: + config->visualSelectGroup = value; + break; + + /* SGIS_multisample attributes */ + case GLX_SAMPLES_SGIS: + config->multiSampleSize = value; + break; + case GLX_SAMPLE_BUFFERS_SGIS: + config->nMultiSampleBuffers = value; + break; + + /* SGIX_pbuffer specific attributes */ + case GLX_OPTIMAL_PBUFFER_WIDTH_SGIX: + config->optimalPbufferWidth = value; + break; + case GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX: + config->optimalPbufferHeight = value; + break; + + default: + /* Ignore attributes we don't recognize */ + break; + } + } /* for j */ + + /* Fill in derived values */ + config->screen = screen; + + config->rgbMode = config->renderType & GLX_RGBA_BIT; + config->colorIndexMode = !config->rgbMode; + + config->haveAccumBuffer = + config->accumRedBits > 0 || + config->accumGreenBits > 0 || + config->accumBlueBits > 0; + /* Can't have alpha without color */ + + config->haveDepthBuffer = config->depthBits > 0; + config->haveStencilBuffer = config->stencilBits > 0; + + /* overlay visuals are not valid for now */ + if (!config->level) { + config++; + numValidConfigs++; + } + + } /* for i */ + UnlockDisplay(dpy); + + config = fbconfigs; + for (i=0; i<numValidConfigs; i++) { + + /* XXX hack to fill-in mask info (need a better way to do this) */ + if (config->associatedVisualId != 0) { + XVisualInfo *vis, template; + int n; + + template.screen = screen; + template.visualid = config->associatedVisualId; + vis = XGetVisualInfo(dpy, VisualScreenMask|VisualIDMask, + &template, &n); + + if (vis != NULL) { + config->redMask = (GLuint)vis->red_mask; + config->greenMask = (GLuint)vis->green_mask; + config->blueMask = (GLuint)vis->blue_mask; + config->alphaMask = 0; /* XXX */ + free(vis); + } + } + + config++; + } /* for i */ + + XFree(attrs); + SyncHandle(); + + *nconfigs = numValidConfigs; + return fbconfigs; +} + +__GLXvisualConfig * +GetGLXVisualConfigsFromFBConfigs(__GLXFBConfig *fbconfigs, int nfbconfigs, + XVisualInfo *visuals, int nvisuals, + __GLXvisualConfig *glxConfigs, int nGlxConfigs, + int *nconfigs) +{ + __GLXvisualConfig *configs = NULL; + int i; + + if (!fbconfigs || !nfbconfigs || !nconfigs) return(NULL); + *nconfigs = 0; + + /* Allocate memory for our config structure */ + configs = (__GLXvisualConfig*) + Xmalloc(nfbconfigs * sizeof(__GLXvisualConfig)); + if (!configs) { + return NULL; + } + memset(configs, 0, nfbconfigs * sizeof(__GLXvisualConfig)); + + for (i=0; i<nfbconfigs; i++) { + __GLXFBConfig *fbcfg = &fbconfigs[i]; + + if (fbcfg->associatedVisualId > 0) { + __GLXvisualConfig *cfg = configs + (*nconfigs); + int j; + XVisualInfo *vinfo = NULL; + + for (j=0; j<nvisuals; j++) { + if (visuals[j].visualid == fbcfg->associatedVisualId) { + vinfo = &visuals[j]; + break; + } + } + if (!vinfo) continue; + + /* skip 16 bit colormap visuals */ + if (vinfo->depth == 16 && + vinfo->class != TrueColor && + vinfo->class != DirectColor ) { + continue; + } + + (*nconfigs)++; + + /* + * if the same visualid exists in the glx configs, + * copy the glx attributes from the glx config + */ + for (j=0; j<nGlxConfigs; j++) { + if (glxConfigs[j].vid == vinfo->visualid) + break; + } + if (j < nGlxConfigs) { + memcpy(cfg, &glxConfigs[j], sizeof(__GLXvisualConfig) ); + continue; + } + + /* + * make glx attributes from the FB config attributes + */ + cfg->vid = fbcfg->associatedVisualId; + cfg->class = vinfo->class; + cfg->rgba = !(fbcfg->renderType & GLX_COLOR_INDEX_BIT_SGIX); + cfg->redSize = fbcfg->redBits; + cfg->greenSize = fbcfg->greenBits; + cfg->blueSize = fbcfg->blueBits; + cfg->alphaSize = fbcfg->alphaBits; + cfg->redMask = fbcfg->redMask; + cfg->greenMask = fbcfg->greenMask; + cfg->blueMask = fbcfg->blueMask; + cfg->alphaMask = fbcfg->alphaMask; + cfg->accumRedSize = fbcfg->accumRedBits; + cfg->accumGreenSize = fbcfg->accumGreenBits; + cfg->accumBlueSize = fbcfg->accumBlueBits; + cfg->accumAlphaSize = fbcfg->accumAlphaBits; + cfg->doubleBuffer = fbcfg->doubleBufferMode; + cfg->stereo = fbcfg->stereoMode; + if (vinfo->class == TrueColor || vinfo->class == DirectColor) { + cfg->bufferSize = (fbcfg->rgbMode ? (fbcfg->redBits + + fbcfg->greenBits + + fbcfg->blueBits + + fbcfg->alphaBits) + : fbcfg->indexBits ); + } + else { + cfg->bufferSize = vinfo->depth; + } + cfg->depthSize = fbcfg->depthBits; + cfg->stencilSize = fbcfg->stencilBits; + cfg->auxBuffers = fbcfg->maxAuxBuffers; + cfg->level = fbcfg->level; + cfg->visualRating = fbcfg->visualCaveat; + cfg->transparentPixel = fbcfg->transparentType; + cfg->transparentRed = fbcfg->transparentRed; + cfg->transparentGreen = fbcfg->transparentGreen; + cfg->transparentBlue = fbcfg->transparentBlue; + cfg->transparentAlpha = fbcfg->transparentAlpha; + cfg->transparentIndex = fbcfg->transparentIndex; + cfg->multiSampleSize = fbcfg->multiSampleSize; + cfg->nMultiSampleBuffers = fbcfg->nMultiSampleBuffers; + cfg->visualSelectGroup = fbcfg->visualSelectGroup; + } + } + + return( configs ); +} + |