single2.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

/*
 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice including the dates of first publication and
 * either this permission notice or a reference to
 * http://oss.sgi.com/projects/FreeB/
 * shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * Except as contained in this notice, the name of Silicon Graphics, Inc.
 * shall not be used in advertising or otherwise to promote the sale, use or
 * other dealings in this Software without prior written authorization from
 * Silicon Graphics, Inc.
 */

#include <stdio.h>
#include <assert.h>
#include "glxclient.h"
#include "packsingle.h"
#include "glxextensions.h"
#include "indirect.h"
#include "indirect_vertex_array.h"

/* Used for GL_ARB_transpose_matrix */
static void TransposeMatrixf(GLfloat m[16])
{
    int i, j;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < i; j++) {
            GLfloat tmp = m[i*4+j];
            m[i*4+j] = m[j*4+i];
            m[j*4+i] = tmp;
        }
    }
}

/* Used for GL_ARB_transpose_matrix */
static void TransposeMatrixb(GLboolean m[16])
{
    int i, j;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < i; j++) {
            GLboolean tmp = m[i*4+j];
            m[i*4+j] = m[j*4+i];
            m[j*4+i] = tmp;
        }
    }
}

/* Used for GL_ARB_transpose_matrix */
static void TransposeMatrixd(GLdouble m[16])
{
    int i, j;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < i; j++) {
            GLdouble tmp = m[i*4+j];
            m[i*4+j] = m[j*4+i];
            m[j*4+i] = tmp;
        }
    }
}

/* Used for GL_ARB_transpose_matrix */
static void TransposeMatrixi(GLint m[16])
{
    int i, j;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < i; j++) {
            GLint tmp = m[i*4+j];
            m[i*4+j] = m[j*4+i];
            m[j*4+i] = tmp;
        }
    }
}


/**
 * Remap a transpose-matrix enum to a non-transpose-matrix enum.  Enums
 * that are not transpose-matrix enums are unaffected.
 */
static GLenum
RemapTransposeEnum( GLenum e )
{
    switch( e ) {
    case GL_TRANSPOSE_MODELVIEW_MATRIX:
    case GL_TRANSPOSE_PROJECTION_MATRIX:
    case GL_TRANSPOSE_TEXTURE_MATRIX:
	return e - (GL_TRANSPOSE_MODELVIEW_MATRIX - GL_MODELVIEW_MATRIX);
    case GL_TRANSPOSE_COLOR_MATRIX:
	return GL_COLOR_MATRIX;
    default:
	return e;
    };
}


GLenum __indirect_glGetError(void)
{
    __GLX_SINGLE_DECLARE_VARIABLES();
    GLuint retval = GL_NO_ERROR;
    xGLXGetErrorReply reply;

    if (gc->error) {
	/* Use internal error first */
	retval = gc->error;
	gc->error = GL_NO_ERROR;
	return retval;
    }

    __GLX_SINGLE_LOAD_VARIABLES();
    __GLX_SINGLE_BEGIN(X_GLsop_GetError,0);
    __GLX_SINGLE_READ_XREPLY();
    retval = reply.error;
    __GLX_SINGLE_END();

    return retval;
}


/**
 * Get the selected attribute from the client state.
 * 
 * \returns
 * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
 */
static GLboolean
get_client_data( __GLXcontext * gc, GLenum cap, GLintptr * data )
{
    GLboolean retval = GL_TRUE;
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    const GLint tex_unit = __glXGetActiveTextureUnit( state );


    switch( cap ) {
    case GL_VERTEX_ARRAY:
    case GL_NORMAL_ARRAY:
    case GL_COLOR_ARRAY:
    case GL_INDEX_ARRAY:
    case GL_EDGE_FLAG_ARRAY:
    case GL_SECONDARY_COLOR_ARRAY:
    case GL_FOG_COORD_ARRAY:
	retval = __glXGetArrayEnable( state, cap, 0, data );
	break;

    case GL_VERTEX_ARRAY_SIZE:
	retval = __glXGetArraySize( state, GL_VERTEX_ARRAY, 0, data );
	break;
    case GL_COLOR_ARRAY_SIZE:
	retval = __glXGetArraySize( state, GL_COLOR_ARRAY, 0, data );
	break;
    case GL_SECONDARY_COLOR_ARRAY_SIZE:
	retval = __glXGetArraySize( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
	break;

    case GL_VERTEX_ARRAY_TYPE:
	retval = __glXGetArrayType( state, GL_VERTEX_ARRAY, 0, data );
	break;
    case GL_NORMAL_ARRAY_TYPE:
	retval = __glXGetArrayType( state, GL_NORMAL_ARRAY, 0, data );
	break;
    case GL_INDEX_ARRAY_TYPE:
	retval = __glXGetArrayType( state, GL_INDEX_ARRAY, 0, data );
	break;
    case GL_COLOR_ARRAY_TYPE:
	retval = __glXGetArrayType( state, GL_COLOR_ARRAY, 0, data );
	break;
    case GL_SECONDARY_COLOR_ARRAY_TYPE:
	retval = __glXGetArrayType( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
	break;
    case GL_FOG_COORD_ARRAY_TYPE:
	retval = __glXGetArrayType( state, GL_FOG_COORD_ARRAY, 0, data );
	break;

    case GL_VERTEX_ARRAY_STRIDE:
	retval = __glXGetArrayStride( state, GL_VERTEX_ARRAY, 0, data );
	break;
    case GL_NORMAL_ARRAY_STRIDE:
	retval = __glXGetArrayStride( state, GL_NORMAL_ARRAY, 0, data );
	break;
    case GL_INDEX_ARRAY_STRIDE:
	retval = __glXGetArrayStride( state, GL_INDEX_ARRAY, 0, data );
	break;
    case GL_EDGE_FLAG_ARRAY_STRIDE:
	retval = __glXGetArrayStride( state, GL_EDGE_FLAG_ARRAY, 0, data );
	break;
    case GL_COLOR_ARRAY_STRIDE:
	retval = __glXGetArrayStride( state, GL_COLOR_ARRAY, 0, data );
	break;
    case GL_SECONDARY_COLOR_ARRAY_STRIDE:
	retval = __glXGetArrayStride( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
	break;
    case GL_FOG_COORD_ARRAY_STRIDE:
	retval = __glXGetArrayStride( state, GL_FOG_COORD_ARRAY, 0, data );
	break;

    case GL_TEXTURE_COORD_ARRAY:
	retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
	break;
    case GL_TEXTURE_COORD_ARRAY_SIZE:
	retval = __glXGetArraySize( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
	break;
    case GL_TEXTURE_COORD_ARRAY_TYPE:
	retval = __glXGetArrayType( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
	break;
    case GL_TEXTURE_COORD_ARRAY_STRIDE:
	retval = __glXGetArrayStride( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
	break;

    case GL_MAX_ELEMENTS_VERTICES:
    case GL_MAX_ELEMENTS_INDICES:
	retval = GL_TRUE;
	*data = ~0UL;
	break;

    
    case GL_PACK_ROW_LENGTH:
	*data = (GLintptr)state->storePack.rowLength;
	break;
    case GL_PACK_IMAGE_HEIGHT:
	*data = (GLintptr)state->storePack.imageHeight;
	break;
    case GL_PACK_SKIP_ROWS:
	*data = (GLintptr)state->storePack.skipRows;
	break;
    case GL_PACK_SKIP_PIXELS:
	*data = (GLintptr)state->storePack.skipPixels;
	break;
    case GL_PACK_SKIP_IMAGES:
	*data = (GLintptr)state->storePack.skipImages;
	break;
    case GL_PACK_ALIGNMENT:
	*data = (GLintptr)state->storePack.alignment;
	break;
    case GL_PACK_SWAP_BYTES:
	*data = (GLintptr)state->storePack.swapEndian;
	break;
    case GL_PACK_LSB_FIRST:
	*data = (GLintptr)state->storePack.lsbFirst;
	break;
    case GL_UNPACK_ROW_LENGTH:
	*data = (GLintptr)state->storeUnpack.rowLength;
	break;
    case GL_UNPACK_IMAGE_HEIGHT:
	*data = (GLintptr)state->storeUnpack.imageHeight;
	break;
    case GL_UNPACK_SKIP_ROWS:
	*data = (GLintptr)state->storeUnpack.skipRows;
	break;
    case GL_UNPACK_SKIP_PIXELS:
	*data = (GLintptr)state->storeUnpack.skipPixels;
	break;
    case GL_UNPACK_SKIP_IMAGES:
	*data = (GLintptr)state->storeUnpack.skipImages;
	break;
    case GL_UNPACK_ALIGNMENT:
	*data = (GLintptr)state->storeUnpack.alignment;
	break;
    case GL_UNPACK_SWAP_BYTES:
	*data = (GLintptr)state->storeUnpack.swapEndian;
	break;
    case GL_UNPACK_LSB_FIRST:
	*data = (GLintptr)state->storeUnpack.lsbFirst;
	break;
    case GL_CLIENT_ATTRIB_STACK_DEPTH:
        *data = (GLintptr)(gc->attributes.stackPointer - gc->attributes.stack);
	break;
    case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
	*data = (GLintptr)__GL_CLIENT_ATTRIB_STACK_DEPTH;
	break;
    case GL_CLIENT_ACTIVE_TEXTURE:
	*data = (GLintptr)(tex_unit + GL_TEXTURE0);
	break;

    default:
	retval = GL_FALSE;
	break;
    }


    return retval;
}


void __indirect_glGetBooleanv(GLenum val, GLboolean *b)
{
    const GLenum origVal = val;
    __GLX_SINGLE_DECLARE_VARIABLES();
    xGLXSingleReply reply;

    val = RemapTransposeEnum( val );

    __GLX_SINGLE_LOAD_VARIABLES();
    __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv,4);
    __GLX_SINGLE_PUT_LONG(0,val);
    __GLX_SINGLE_READ_XREPLY();
    __GLX_SINGLE_GET_SIZE(compsize);

    if (compsize == 0) {
	/*
	** Error occured; don't modify user's buffer.
	*/
    } else {
	GLintptr data;

	/*
	** We still needed to send the request to the server in order to
	** find out whether it was legal to make a query (it's illegal,
	** for example, to call a query between glBegin() and glEnd()).
	*/

	if ( get_client_data( gc, val, & data ) ) {
	    *b = (GLboolean) data;
	}
	else {
	    /*
	     ** Not a local value, so use what we got from the server.
	     */
	    if (compsize == 1) {
		__GLX_SINGLE_GET_CHAR(b);
	    } else {
		__GLX_SINGLE_GET_CHAR_ARRAY(b,compsize);
		if (val != origVal) {
		    /* matrix transpose */
		    TransposeMatrixb(b);
                }
	    }
	}
    }
    __GLX_SINGLE_END();
}

void __indirect_glGetDoublev(GLenum val, GLdouble *d)
{
    const GLenum origVal = val;
    __GLX_SINGLE_DECLARE_VARIABLES();
    xGLXSingleReply reply;

    val = RemapTransposeEnum( val );

    __GLX_SINGLE_LOAD_VARIABLES();
    __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev,4);
    __GLX_SINGLE_PUT_LONG(0,val);
    __GLX_SINGLE_READ_XREPLY();
    __GLX_SINGLE_GET_SIZE(compsize);

    if (compsize == 0) {
	/*
	** Error occured; don't modify user's buffer.
	*/
    } else {
	GLintptr data;

	/*
	** We still needed to send the request to the server in order to
	** find out whether it was legal to make a query (it's illegal,
	** for example, to call a query between glBegin() and glEnd()).
	*/

	if ( get_client_data( gc, val, & data ) ) {
	    *d = (GLdouble) data;
	}
	else {
	    /*
	     ** Not a local value, so use what we got from the server.
	     */
	    if (compsize == 1) {
		__GLX_SINGLE_GET_DOUBLE(d);
	    } else {
		__GLX_SINGLE_GET_DOUBLE_ARRAY(d,compsize);
		if (val != origVal) {
		    /* matrix transpose */
		    TransposeMatrixd(d);
		}
	    }
	}
    }
    __GLX_SINGLE_END();
}

void __indirect_glGetFloatv(GLenum val, GLfloat *f)
{
    const GLenum origVal = val;
    __GLX_SINGLE_DECLARE_VARIABLES();
    xGLXSingleReply reply;

    val = RemapTransposeEnum( val );

    __GLX_SINGLE_LOAD_VARIABLES();
    __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv,4);
    __GLX_SINGLE_PUT_LONG(0,val);
    __GLX_SINGLE_READ_XREPLY();
    __GLX_SINGLE_GET_SIZE(compsize);

    if (compsize == 0) {
	/*
	** Error occured; don't modify user's buffer.
	*/
    } else {
	GLintptr data;