indirect_vertex_program.c revision c356f5867f2c1fad7155df538b9affa8dbdcf869 
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#if !defined(__GNUC__)
34#  define __builtin_expect(x, y) x
35#endif
36
37static void
38do_vertex_attrib_enable(GLuint index, GLboolean val)
39{
40   struct glx_context *gc = __glXGetCurrentContext();
41   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
42
43   if (!__glXSetArrayEnable(state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
44                            index, val)) {
45      __glXSetError(gc, GL_INVALID_ENUM);
46   }
47}
48
49
50void
51__indirect_glEnableVertexAttribArrayARB(GLuint index)
52{
53   do_vertex_attrib_enable(index, GL_TRUE);
54}
55
56
57void
58__indirect_glDisableVertexAttribArrayARB(GLuint index)
59{
60   do_vertex_attrib_enable(index, GL_FALSE);
61}
62
63
64static void
65get_parameter(unsigned opcode, unsigned size, GLenum target, GLuint index,
66              void *params)
67{
68   struct glx_context *const gc = __glXGetCurrentContext();
69   Display *const dpy = gc->currentDpy;
70   const GLuint cmdlen = 12;
71
72   if (__builtin_expect(dpy != NULL, 1)) {
73      GLubyte const *pc = __glXSetupVendorRequest(gc,
74                                                  X_GLXVendorPrivateWithReply,
75                                                  opcode, cmdlen);
76
77      *((GLenum *) (pc + 0)) = target;
78      *((GLuint *) (pc + 4)) = index;
79      *((GLuint *) (pc + 8)) = 0;
80
81      (void) __glXReadReply(dpy, size, params, GL_FALSE);
82      UnlockDisplay(dpy);
83      SyncHandle();
84   }
85   return;
86}
87
88
89void
90__indirect_glGetProgramEnvParameterfvARB(GLenum target, GLuint index,
91                                         GLfloat * params)
92{
93   get_parameter(1296, 4, target, index, params);
94}
95
96
97void
98__indirect_glGetProgramEnvParameterdvARB(GLenum target, GLuint index,
99                                         GLdouble * params)
100{
101   get_parameter(1297, 8, target, index, params);
102}
103
104
105void
106__indirect_glGetProgramLocalParameterfvARB(GLenum target, GLuint index,
107                                           GLfloat * params)
108{
109   get_parameter(1305, 4, target, index, params);
110}
111
112
113void
114__indirect_glGetProgramLocalParameterdvARB(GLenum target, GLuint index,
115                                           GLdouble * params)
116{
117   get_parameter(1306, 8, target, index, params);
118}
119
120
121void
122__indirect_glGetVertexAttribPointervNV(GLuint index, GLenum pname,
123                                       GLvoid ** pointer)
124{
125   struct glx_context *const gc = __glXGetCurrentContext();
126   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
127
128   if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB) {
129      __glXSetError(gc, GL_INVALID_ENUM);
130   }
131
132   if (!__glXGetArrayPointer(state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
133                             index, pointer)) {
134      __glXSetError(gc, GL_INVALID_VALUE);
135   }
136}
137
138
139/**
140 * Get the selected attribute from the vertex array state vector.
141 *
142 * \returns
143 * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
144 */
145static GLboolean
146get_attrib_array_data(__GLXattribute * state, GLuint index, GLenum cap,
147                      GLintptr * data)
148{
149   GLboolean retval = GL_FALSE;
150   const GLenum attrib = GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB;
151
152   switch (cap) {
153   case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
154      retval = __glXGetArrayEnable(state, attrib, index, data);
155      break;
156
157   case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
158      retval = __glXGetArraySize(state, attrib, index, data);
159      break;
160
161   case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
162      retval = __glXGetArrayStride(state, attrib, index, data);
163      break;
164
165   case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
166      retval = __glXGetArrayType(state, attrib, index, data);
167      break;
168
169   case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
170      retval = __glXGetArrayNormalized(state, attrib, index, data);
171      break;
172   }
173
174
175   return retval;
176}
177
178
179static void
180get_vertex_attrib(struct glx_context * gc, unsigned vop,
181                  GLuint index, GLenum pname, xReply * reply)
182{
183   Display *const dpy = gc->currentDpy;
184   GLubyte *const pc = __glXSetupVendorRequest(gc,
185                                               X_GLXVendorPrivateWithReply,
186                                               vop, 8);
187
188   *((uint32_t *) (pc + 0)) = index;
189   *((uint32_t *) (pc + 4)) = pname;
190
191   (void) _XReply(dpy, reply, 0, False);
192}
193
194
195void
196__indirect_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params)
197{
198   struct glx_context *const gc = __glXGetCurrentContext();
199   Display *const dpy = gc->currentDpy;
200   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
201   xGLXSingleReply reply;
202
203
204   get_vertex_attrib(gc, 1303, index, pname, (xReply *) & reply);
205
206   if (reply.size != 0) {
207      GLintptr data;
208
209
210      if (get_attrib_array_data(state, index, pname, &data)) {
211         *params = (GLint) data;
212      }
213      else {
214         if (reply.size == 1) {
215            *params = (GLint) reply.pad3;
216         }
217         else {
218            _XRead(dpy, (void *) params, 4 * reply.size);
219         }
220      }
221   }
222
223   UnlockDisplay(dpy);
224   SyncHandle();
225}
226
227
228void
229__indirect_glGetVertexAttribfvARB(GLuint index, GLenum pname,
230                                  GLfloat * params)
231{
232   struct glx_context *const gc = __glXGetCurrentContext();
233   Display *const dpy = gc->currentDpy;
234   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
235   xGLXSingleReply reply;
236
237
238   get_vertex_attrib(gc, 1302, index, pname, (xReply *) & reply);
239
240   if (reply.size != 0) {
241      GLintptr data;
242
243
244      if (get_attrib_array_data(state, index, pname, &data)) {
245         *params = (GLfloat) data;
246      }
247      else {
248         if (reply.size == 1) {
249            (void) memcpy(params, &reply.pad3, sizeof(GLfloat));
250         }
251         else {
252            _XRead(dpy, (void *) params, 4 * reply.size);
253         }
254      }
255   }
256
257   UnlockDisplay(dpy);
258   SyncHandle();
259}
260
261
262void
263__indirect_glGetVertexAttribdvARB(GLuint index, GLenum pname,
264                                  GLdouble * params)
265{
266   struct glx_context *const gc = __glXGetCurrentContext();
267   Display *const dpy = gc->currentDpy;
268   __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
269   xGLXSingleReply reply;
270
271
272   get_vertex_attrib(gc, 1301, index, pname, (xReply *) & reply);
273
274   if (reply.size != 0) {
275      GLintptr data;
276
277
278      if (get_attrib_array_data(state, index, pname, &data)) {
279         *params = (GLdouble) data;
280      }
281      else {
282         if (reply.size == 1) {
283            (void) memcpy(params, &reply.pad3, sizeof(GLdouble));
284         }
285         else {
286            _XRead(dpy, (void *) params, 8 * reply.size);
287         }
288      }
289   }
290
291   UnlockDisplay(dpy);
292   SyncHandle();
293}
294