src/glx/x11/indirect_vertex_program.c

   1 /*
   2  * (C) Copyright IBM Corporation 2005
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sub license,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  19  * IBM,
  20  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  */
  25
  26 #include <inttypes.h>
  27 #include <GL/gl.h>
  28 #include "indirect.h"
  29 #include "glxclient.h"
  30 #include "indirect_vertex_array.h"
  31 #include <GL/glxproto.h>
  32
  33 static void
  34 do_vertex_attrib_enable( GLuint index, GLboolean val )
  35 {
  36     __GLXcontext *gc = __glXGetCurrentContext();
  37     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
  38
  39     if ( ! __glXSetArrayEnable( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
  40                                 index, val ) ) {
  41         __glXSetError(gc, GL_INVALID_ENUM);
  42     }
  43 }
  44
  45
  46 void __indirect_glEnableVertexAttribArrayARB( GLuint index )
  47 {
  48     do_vertex_attrib_enable( index, GL_TRUE );
  49 }
  50
  51
  52 void __indirect_glDisableVertexAttribArrayARB( GLuint index )
  53 {
  54     do_vertex_attrib_enable( index, GL_FALSE );
  55 }
  56
  57
  58 static void
  59 get_parameter( unsigned opcode, unsigned size, GLenum target, GLuint index,
  60                void * params )
  61 {
  62     __GLXcontext * const gc = __glXGetCurrentContext();
  63     Display * const dpy = gc->currentDpy;
  64     const GLuint cmdlen = 12;
  65
  66     if (__builtin_expect(dpy != NULL, 1)) {
  67         GLubyte const * pc = __glXSetupVendorRequest(gc,
  68                                                      X_GLXVendorPrivateWithReply,
  69                                                      opcode, cmdlen);
  70
  71         *((GLenum *)(pc +  0)) = target;
  72         *((GLuint *)(pc +  4)) = index;
  73         *((GLuint *)(pc +  8)) = 0;
  74
  75         (void) __glXReadReply(dpy, size, params, GL_FALSE);
  76         UnlockDisplay(dpy); SyncHandle();
  77     }
  78     return;
  79 }
  80
  81
  82 void __indirect_glGetProgramEnvParameterfvARB( GLenum target, GLuint index,
  83                                                GLfloat * params )
  84 {
  85     get_parameter( 1296, 4, target, index, params );
  86 }
  87
  88
  89 void __indirect_glGetProgramEnvParameterdvARB( GLenum target, GLuint index,
  90                                                GLdouble * params )
  91 {
  92     get_parameter( 1297, 8, target, index, params );
  93 }
  94
  95
  96 void __indirect_glGetProgramLocalParameterfvARB( GLenum target, GLuint index,
  97                                                  GLfloat * params )
  98 {
  99     get_parameter( 1305, 4, target, index, params );
 100 }
 101
 102
 103 void __indirect_glGetProgramLocalParameterdvARB( GLenum target, GLuint index,
 104                                                  GLdouble * params )
 105 {
 106     get_parameter( 1306, 8, target, index, params );
 107 }
 108
 109
 110 void __indirect_glGetVertexAttribPointervNV( GLuint index, GLenum pname,
 111                                              GLvoid ** pointer )
 112 {
 113     __GLXcontext * const gc = __glXGetCurrentContext();
 114     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 115
 116     if ( pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB ) {
 117         __glXSetError( gc, GL_INVALID_ENUM );
 118     }
 119
 120     if ( ! __glXGetArrayPointer( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
 121                                  index, pointer ) ) {
 122         __glXSetError( gc, GL_INVALID_VALUE );
 123     }
 124 }
 125
 126
 127 /**
 128  * Get the selected attribute from the vertex array state vector.
 129  *
 130  * \returns
 131  * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
 132  */
 133 static GLboolean
 134 get_attrib_array_data( __GLXattribute * state, GLuint index, GLenum cap,
 135                        GLintptr * data )
 136 {
 137     GLboolean retval = GL_FALSE;
 138     const GLenum attrib = GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB;
 139
 140     switch( cap ) {
 141     case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
 142         retval = __glXGetArrayEnable( state, attrib, index, data );
 143         break;
 144
 145     case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
 146         retval = __glXGetArraySize( state, attrib, index, data );
 147         break;
 148
 149     case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
 150         retval = __glXGetArrayStride( state, attrib, index, data );
 151         break;
 152
 153     case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
 154         retval = __glXGetArrayType( state, attrib, index, data );
 155         break;
 156
 157     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
 158         retval = __glXGetArrayNormalized( state, attrib, index, data );
 159         break;
 160     }
 161
 162
 163     return retval;
 164 }
 165
 166
 167 static void get_vertex_attrib( __GLXcontext * gc, unsigned vop,
 168                                GLuint index, GLenum pname,
 169                                xReply * reply )
 170 {
 171     Display * const dpy = gc->currentDpy;
 172     GLubyte * const pc = __glXSetupVendorRequest(gc,
 173                                                  X_GLXVendorPrivateWithReply,
 174                                                  vop, 8);
 175
 176     *((uint32_t *)(pc +  0)) = index;
 177     *((uint32_t *)(pc +  4)) = pname;
 178
 179     (void) _XReply( dpy, reply, 0, False );
 180 }
 181
 182
 183 void __indirect_glGetVertexAttribivARB( GLuint index, GLenum pname,
 184                                         GLint * params )
 185 {
 186     __GLXcontext * const gc = __glXGetCurrentContext();
 187     Display * const dpy = gc->currentDpy;
 188     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 189     xGLXSingleReply reply;
 190
 191
 192     get_vertex_attrib( gc, 1303, index, pname, (xReply *) & reply );
 193
 194     if ( reply.size != 0 ) {
 195         if ( ! get_attrib_array_data( state, index, pname, params ) ) {
 196             if (reply.size == 1) {
 197                 *params = (GLint) reply.pad3;
 198             }
 199             else {
 200                 _XRead(dpy, (void *) params, 4 * reply.size);
 201             }
 202         }
 203     }
 204
 205     UnlockDisplay(dpy);
 206     SyncHandle();
 207 }
 208
 209
 210 void __indirect_glGetVertexAttribfvARB( GLuint index, GLenum pname,
 211                                         GLfloat * params )
 212 {
 213     __GLXcontext * const gc = __glXGetCurrentContext();
 214     Display * const dpy = gc->currentDpy;
 215     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 216     xGLXSingleReply reply;
 217
 218
 219     get_vertex_attrib( gc, 1302, index, pname, (xReply *) & reply );
 220
 221     if ( reply.size != 0 ) {
 222         GLintptr data;
 223
 224
 225         if ( get_attrib_array_data( state, index, pname, & data ) ) {
 226             *params = (GLfloat) data;
 227         }
 228         else {
 229             if (reply.size == 1) {
 230                 (void) memcpy( params, & reply.pad3, sizeof( GLfloat ) );
 231             }
 232             else {
 233                 _XRead(dpy, (void *) params, 4 * reply.size);
 234             }
 235         }
 236     }
 237
 238     UnlockDisplay(dpy);
 239     SyncHandle();
 240 }
 241
 242
 243 void __indirect_glGetVertexAttribdvARB( GLuint index, GLenum pname,
 244                                         GLdouble * params )
 245 {
 246     __GLXcontext * const gc = __glXGetCurrentContext();
 247     Display * const dpy = gc->currentDpy;
 248     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
 249     xGLXSingleReply reply;
 250
 251
 252     get_vertex_attrib( gc, 1301, index, pname, (xReply *) & reply );
 253
 254     if ( reply.size != 0 ) {
 255         GLintptr data;
 256
 257
 258         if ( get_attrib_array_data( state, index, pname, & data ) ) {
 259             *params = (GLdouble) data;
 260         }
 261         else {
 262             if (reply.size == 1) {
 263                 (void) memcpy( params, & reply.pad3, sizeof( GLdouble ) );
 264             }
 265             else {
 266                 _XRead(dpy, (void *) params, 8 * reply.size);
 267             }
 268         }
 269     }
 270
 271     UnlockDisplay(dpy);
 272     SyncHandle();
 273 }