/*
 * (C) Copyright IBM Corporation 2005
 * 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, sub license,
 * 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 and this permission notice (including the next
 * paragraph) 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 NON-INFRINGEMENT.  IN NO EVENT SHALL
 * IBM,
 * AND/OR THEIR SUPPLIERS 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.
 */

#include <inttypes.h>
#include <GL/gl.h>
#include "indirect.h"
#include "glxclient.h"
#include "indirect_vertex_array.h"
#include <GL/glxproto.h>

void do_vertex_attrib_enable( GLuint index, GLboolean val )
{
    __GLXcontext *gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);

    if ( ! __glXSetArrayEnable( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
				index, val ) ) {
	__glXSetError(gc, GL_INVALID_ENUM);
    }
}


void __indirect_glEnableVertexAttribArrayARB( GLuint index )
{
    do_vertex_attrib_enable( index, GL_TRUE );
}


void __indirect_glDisableVertexAttribArrayARB( GLuint index )
{
    do_vertex_attrib_enable( index, GL_FALSE );
}


static void
get_parameter( unsigned opcode, unsigned size, GLenum target, GLuint index,
		  GLfloat * params )
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    Display * const dpy = gc->currentDpy;
    const GLuint cmdlen = 12;

    if (__builtin_expect(dpy != NULL, 1)) {
        GLubyte const * pc = __glXSetupVendorRequest(gc,
						     X_GLXVendorPrivateWithReply,
						     opcode, cmdlen);

	*((GLenum *)(pc +  0)) = target;
	*((GLuint *)(pc +  4)) = index;
	*((GLuint *)(pc +  8)) = 0;

        (void) __glXReadReply(dpy, size, params, GL_FALSE);
        UnlockDisplay(dpy); SyncHandle();
    }
    return;
}


void __indirect_glGetProgramEnvParameterfvARB( GLenum target, GLuint index,
					       GLfloat * params )
{
    get_parameter( 1296, 4, target, index, params );
}


void __indirect_glGetProgramEnvParameterdvARB( GLenum target, GLuint index,
					       GLdouble * params )
{
    get_parameter( 1297, 8, target, index, params );
}


void __indirect_glGetProgramLocalParameterfvARB( GLenum target, GLuint index,
						 GLfloat * params )
{
    get_parameter( 1305, 4, target, index, params );
}


void __indirect_glGetProgramLocalParameterdvARB( GLenum target, GLuint index,
						 GLdouble * params )
{
    get_parameter( 1306, 8, target, index, params );
}


void __indirect_glGetVertexAttribPointervNV( GLuint index, GLenum pname,
					     GLvoid ** pointer )
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 
    if ( pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB ) {
	__glXSetError( gc, GL_INVALID_ENUM );
    }
    
    if ( ! __glXGetArrayPointer( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
				 index, pointer ) ) {
	__glXSetError( gc, GL_INVALID_VALUE );
    }
}


/**
 * Get the selected attribute from the vertex array state vector.
 * 
 * \returns
 * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
 */
static GLboolean
get_attrib_array_data( __GLXattribute * state, GLuint index, GLenum cap,
		       GLintptr * data )
{
    GLboolean retval = GL_FALSE;
    const GLenum attrib = GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB;

    switch( cap ) {
    case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
	retval = __glXGetArrayEnable( state, attrib, index, data );
	break;

    case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
	retval = __glXGetArraySize( state, attrib, index, data );
	break;

    case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
	retval = __glXGetArrayStride( state, attrib, index, data );
	break;

    case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
	retval = __glXGetArrayType( state, attrib, index, data );
	break;

    case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
	retval = __glXGetArrayNormalized( state, attrib, index, data );
	break;
    }

    
    return retval;
}


static void get_vertex_attrib( __GLXcontext * gc, unsigned vop,
			       GLuint index, GLenum pname,
			       xReply * reply )
{
    Display * const dpy = gc->currentDpy;
    GLubyte * const pc = __glXSetupVendorRequest(gc,
						 X_GLXVendorPrivateWithReply,
						 vop, 8);
						     
    *((uint32_t *)(pc +  0)) = index;
    *((uint32_t *)(pc +  4)) = pname;

    (void) _XReply( dpy, reply, 0, False );
}


void __indirect_glGetVertexAttribivARB( GLuint index, GLenum pname,
					GLint * params )
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    Display * const dpy = gc->currentDpy;
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    xGLXSingleReply reply;


    get_vertex_attrib( gc, 1303, index, pname, (xReply *) & reply );

    if ( reply.size != 0 ) {
	if ( ! get_attrib_array_data( state, index, pname, params ) ) {
	    if (reply.size == 1) {
		*params = (GLint) reply.pad3;
	    } 
	    else {
		_XRead(dpy, (void *) params, 4 * reply.size);
	    }
	}
    }

    UnlockDisplay(dpy);
    SyncHandle();
}


void __indirect_glGetVertexAttribfvARB( GLuint index, GLenum pname,
					GLfloat * params )
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    Display * const dpy = gc->currentDpy;
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    xGLXSingleReply reply;


    get_vertex_attrib( gc, 1302, index, pname, (xReply *) & reply );

    if ( reply.size != 0 ) {
	GLintptr data;


	if ( get_attrib_array_data( state, index, pname, & data ) ) {
	    *params = (GLfloat) data;
	}
	else {
	    if (reply.size == 1) {
		(void) memcpy( params, & reply.pad3, sizeof( GLfloat ) );
	    } 
	    else {
		_XRead(dpy, (void *) params, 4 * reply.size);
	    }
	}
    }

    UnlockDisplay(dpy);
    SyncHandle();
}


void __indirect_glGetVertexAttribdvARB( GLuint index, GLenum pname,
					GLdouble * params )
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    Display * const dpy = gc->currentDpy;
    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
    xGLXSingleReply reply;


    get_vertex_attrib( gc, 1301, index, pname, (xReply *) & reply );

    if ( reply.size != 0 ) {
	GLintptr data;


	if ( get_attrib_array_data( state, index, pname, & data ) ) {
	    *params = (GLdouble) data;
	}
	else {
	    if (reply.size == 1) {
		(void) memcpy( params, & reply.pad3, sizeof( GLdouble ) );
	    } 
	    else {
		_XRead(dpy, (void *) params, 8 * reply.size);
	    }
	}
    }

    UnlockDisplay(dpy);
    SyncHandle();
}