1/*
2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. 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, sublicense,
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 including the dates of first publication and
13 * either this permission notice or a reference to
14 * http://oss.sgi.com/projects/FreeB/
15 * shall be included in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * SILICON GRAPHICS, INC. 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 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26 * shall not be used in advertising or otherwise to promote the sale, use or
27 * other dealings in this Software without prior written authorization from
28 * Silicon Graphics, Inc.
29 */
30
31#ifdef HAVE_DIX_CONFIG_H
32#include <dix-config.h>
33#endif
34
35#include <glxserver.h>
36#include "unpack.h"
37#include "indirect_size.h"
38#include "indirect_dispatch.h"
39
40void
41__glXDisp_Map1f(GLbyte * pc)
42{
43    GLint order, k;
44    GLfloat u1, u2, *points;
45    GLenum target;
46
47    target = *(GLenum *) (pc + 0);
48    order = *(GLint *) (pc + 12);
49    u1 = *(GLfloat *) (pc + 4);
50    u2 = *(GLfloat *) (pc + 8);
51    points = (GLfloat *) (pc + 16);
52    k = __glMap1f_size(target);
53
54    glMap1f(target, u1, u2, k, order, points);
55}
56
57void
58__glXDisp_Map2f(GLbyte * pc)
59{
60    GLint uorder, vorder, ustride, vstride, k;
61    GLfloat u1, u2, v1, v2, *points;
62    GLenum target;
63
64    target = *(GLenum *) (pc + 0);
65    uorder = *(GLint *) (pc + 12);
66    vorder = *(GLint *) (pc + 24);
67    u1 = *(GLfloat *) (pc + 4);
68    u2 = *(GLfloat *) (pc + 8);
69    v1 = *(GLfloat *) (pc + 16);
70    v2 = *(GLfloat *) (pc + 20);
71    points = (GLfloat *) (pc + 28);
72
73    k = __glMap2f_size(target);
74    ustride = vorder * k;
75    vstride = k;
76
77    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
78}
79
80void
81__glXDisp_Map1d(GLbyte * pc)
82{
83    GLint order, k;
84
85#ifdef __GLX_ALIGN64
86    GLint compsize;
87#endif
88    GLenum target;
89    GLdouble u1, u2, *points;
90
91    target = *(GLenum *) (pc + 16);
92    order = *(GLint *) (pc + 20);
93    k = __glMap1d_size(target);
94
95#ifdef __GLX_ALIGN64
96    if (order < 0 || k < 0) {
97        compsize = 0;
98    }
99    else {
100        compsize = order * k;
101    }
102#endif
103
104    __GLX_GET_DOUBLE(u1, pc);
105    __GLX_GET_DOUBLE(u2, pc + 8);
106    pc += 24;
107
108#ifdef __GLX_ALIGN64
109    if (((unsigned long) pc) & 7) {
110        /*
111         ** Copy the doubles up 4 bytes, trashing the command but aligning
112         ** the data in the process
113         */
114        __GLX_MEM_COPY(pc - 4, pc, compsize * 8);
115        points = (GLdouble *) (pc - 4);
116    }
117    else {
118        points = (GLdouble *) pc;
119    }
120#else
121    points = (GLdouble *) pc;
122#endif
123    glMap1d(target, u1, u2, k, order, points);
124}
125
126void
127__glXDisp_Map2d(GLbyte * pc)
128{
129    GLdouble u1, u2, v1, v2, *points;
130    GLint uorder, vorder, ustride, vstride, k;
131
132#ifdef __GLX_ALIGN64
133    GLint compsize;
134#endif
135    GLenum target;
136
137    target = *(GLenum *) (pc + 32);
138    uorder = *(GLint *) (pc + 36);
139    vorder = *(GLint *) (pc + 40);
140    k = __glMap2d_size(target);
141
142#ifdef __GLX_ALIGN64
143    if (vorder < 0 || uorder < 0 || k < 0) {
144        compsize = 0;
145    }
146    else {
147        compsize = uorder * vorder * k;
148    }
149#endif
150
151    __GLX_GET_DOUBLE(u1, pc);
152    __GLX_GET_DOUBLE(u2, pc + 8);
153    __GLX_GET_DOUBLE(v1, pc + 16);
154    __GLX_GET_DOUBLE(v2, pc + 24);
155    pc += 44;
156
157    ustride = vorder * k;
158    vstride = k;
159
160#ifdef __GLX_ALIGN64
161    if (((unsigned long) pc) & 7) {
162        /*
163         ** Copy the doubles up 4 bytes, trashing the command but aligning
164         ** the data in the process
165         */
166        __GLX_MEM_COPY(pc - 4, pc, compsize * 8);
167        points = (GLdouble *) (pc - 4);
168    }
169    else {
170        points = (GLdouble *) pc;
171    }
172#else
173    points = (GLdouble *) pc;
174#endif
175    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
176}
177
178void
179__glXDisp_DrawArrays(GLbyte * pc)
180{
181    __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
182    __GLXdispatchDrawArraysComponentHeader *compHeader;
183    GLint numVertexes = hdr->numVertexes;
184    GLint numComponents = hdr->numComponents;
185    GLenum primType = hdr->primType;
186    GLint stride = 0;
187    int i;
188
189    pc += sizeof(__GLXdispatchDrawArraysHeader);
190    compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
191
192    /* compute stride (same for all component arrays) */
193    for (i = 0; i < numComponents; i++) {
194        GLenum datatype = compHeader[i].datatype;
195        GLint numVals = compHeader[i].numVals;
196
197        stride += __GLX_PAD(numVals * __glXTypeSize(datatype));
198    }
199
200    pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader);
201
202    /* set up component arrays */
203    for (i = 0; i < numComponents; i++) {
204        GLenum datatype = compHeader[i].datatype;
205        GLint numVals = compHeader[i].numVals;
206        GLenum component = compHeader[i].component;
207
208        switch (component) {
209        case GL_VERTEX_ARRAY:
210            glEnableClientState(GL_VERTEX_ARRAY);
211            glVertexPointer(numVals, datatype, stride, pc);
212            break;
213        case GL_NORMAL_ARRAY:
214            glEnableClientState(GL_NORMAL_ARRAY);
215            glNormalPointer(datatype, stride, pc);
216            break;
217        case GL_COLOR_ARRAY:
218            glEnableClientState(GL_COLOR_ARRAY);
219            glColorPointer(numVals, datatype, stride, pc);
220            break;
221        case GL_INDEX_ARRAY:
222            glEnableClientState(GL_INDEX_ARRAY);
223            glIndexPointer(datatype, stride, pc);
224            break;
225        case GL_TEXTURE_COORD_ARRAY:
226            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
227            glTexCoordPointer(numVals, datatype, stride, pc);
228            break;
229        case GL_EDGE_FLAG_ARRAY:
230            glEnableClientState(GL_EDGE_FLAG_ARRAY);
231            glEdgeFlagPointer(stride, (const GLboolean *) pc);
232            break;
233        case GL_SECONDARY_COLOR_ARRAY:
234        {
235            PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT =
236                __glGetProcAddress("glSecondaryColorPointerEXT");
237            glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
238            SecondaryColorPointerEXT(numVals, datatype, stride, pc);
239            break;
240        }
241        case GL_FOG_COORD_ARRAY:
242        {
243            PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT =
244                __glGetProcAddress("glFogCoordPointerEXT");
245            glEnableClientState(GL_FOG_COORD_ARRAY);
246            FogCoordPointerEXT(datatype, stride, pc);
247            break;
248        }
249        default:
250            break;
251        }
252
253        pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
254    }
255
256    glDrawArrays(primType, 0, numVertexes);
257
258    /* turn off anything we might have turned on */
259    glDisableClientState(GL_VERTEX_ARRAY);
260    glDisableClientState(GL_NORMAL_ARRAY);
261    glDisableClientState(GL_COLOR_ARRAY);
262    glDisableClientState(GL_INDEX_ARRAY);
263    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
264    glDisableClientState(GL_EDGE_FLAG_ARRAY);
265    glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
266    glDisableClientState(GL_FOG_COORD_ARRAY);
267}
268