• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
37 static void
do_vertex_attrib_enable(GLuint index,GLboolean val)38 do_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 
50 void
__indirect_glEnableVertexAttribArray(GLuint index)51 __indirect_glEnableVertexAttribArray(GLuint index)
52 {
53    do_vertex_attrib_enable(index, GL_TRUE);
54 }
55 
56 
57 void
__indirect_glDisableVertexAttribArray(GLuint index)58 __indirect_glDisableVertexAttribArray(GLuint index)
59 {
60    do_vertex_attrib_enable(index, GL_FALSE);
61 }
62 
63 
64 static void
get_parameter(unsigned opcode,unsigned size,GLenum target,GLuint index,void * params)65 get_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 
89 void
__indirect_glGetProgramEnvParameterfvARB(GLenum target,GLuint index,GLfloat * params)90 __indirect_glGetProgramEnvParameterfvARB(GLenum target, GLuint index,
91                                          GLfloat * params)
92 {
93    get_parameter(1296, 4, target, index, params);
94 }
95 
96 
97 void
__indirect_glGetProgramEnvParameterdvARB(GLenum target,GLuint index,GLdouble * params)98 __indirect_glGetProgramEnvParameterdvARB(GLenum target, GLuint index,
99                                          GLdouble * params)
100 {
101    get_parameter(1297, 8, target, index, params);
102 }
103 
104 
105 void
__indirect_glGetProgramLocalParameterfvARB(GLenum target,GLuint index,GLfloat * params)106 __indirect_glGetProgramLocalParameterfvARB(GLenum target, GLuint index,
107                                            GLfloat * params)
108 {
109    get_parameter(1305, 4, target, index, params);
110 }
111 
112 
113 void
__indirect_glGetProgramLocalParameterdvARB(GLenum target,GLuint index,GLdouble * params)114 __indirect_glGetProgramLocalParameterdvARB(GLenum target, GLuint index,
115                                            GLdouble * params)
116 {
117    get_parameter(1306, 8, target, index, params);
118 }
119 
120 
121 void
__indirect_glGetVertexAttribPointerv(GLuint index,GLenum pname,GLvoid ** pointer)122 __indirect_glGetVertexAttribPointerv(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  */
145 static GLboolean
get_attrib_array_data(__GLXattribute * state,GLuint index,GLenum cap,GLintptr * data)146 get_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 
179 static void
get_vertex_attrib(struct glx_context * gc,unsigned vop,GLuint index,GLenum pname,xReply * reply)180 get_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 
195 void
__indirect_glGetVertexAttribiv(GLuint index,GLenum pname,GLint * params)196 __indirect_glGetVertexAttribiv(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 
228 void
__indirect_glGetVertexAttribfv(GLuint index,GLenum pname,GLfloat * params)229 __indirect_glGetVertexAttribfv(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 
262 void
__indirect_glGetVertexAttribdv(GLuint index,GLenum pname,GLdouble * params)263 __indirect_glGetVertexAttribdv(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