render2swap.c (11241B)
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 40 void 41 __glXDispSwap_Map1f(GLbyte * pc) 42 { 43 GLint order, k; 44 GLfloat u1, u2, *points; 45 GLenum target; 46 GLint compsize; 47 48 __GLX_DECLARE_SWAP_VARIABLES; 49 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 50 51 __GLX_SWAP_INT(pc + 0); 52 __GLX_SWAP_INT(pc + 12); 53 __GLX_SWAP_FLOAT(pc + 4); 54 __GLX_SWAP_FLOAT(pc + 8); 55 56 target = *(GLenum *) (pc + 0); 57 order = *(GLint *) (pc + 12); 58 u1 = *(GLfloat *) (pc + 4); 59 u2 = *(GLfloat *) (pc + 8); 60 points = (GLfloat *) (pc + 16); 61 k = __glMap1f_size(target); 62 63 if (order <= 0 || k < 0) { 64 /* Erroneous command. */ 65 compsize = 0; 66 } 67 else { 68 compsize = order * k; 69 } 70 __GLX_SWAP_FLOAT_ARRAY(points, compsize); 71 72 glMap1f(target, u1, u2, k, order, points); 73 } 74 75 void 76 __glXDispSwap_Map2f(GLbyte * pc) 77 { 78 GLint uorder, vorder, ustride, vstride, k; 79 GLfloat u1, u2, v1, v2, *points; 80 GLenum target; 81 GLint compsize; 82 83 __GLX_DECLARE_SWAP_VARIABLES; 84 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 85 86 __GLX_SWAP_INT(pc + 0); 87 __GLX_SWAP_INT(pc + 12); 88 __GLX_SWAP_INT(pc + 24); 89 __GLX_SWAP_FLOAT(pc + 4); 90 __GLX_SWAP_FLOAT(pc + 8); 91 __GLX_SWAP_FLOAT(pc + 16); 92 __GLX_SWAP_FLOAT(pc + 20); 93 94 target = *(GLenum *) (pc + 0); 95 uorder = *(GLint *) (pc + 12); 96 vorder = *(GLint *) (pc + 24); 97 u1 = *(GLfloat *) (pc + 4); 98 u2 = *(GLfloat *) (pc + 8); 99 v1 = *(GLfloat *) (pc + 16); 100 v2 = *(GLfloat *) (pc + 20); 101 points = (GLfloat *) (pc + 28); 102 103 k = __glMap2f_size(target); 104 ustride = vorder * k; 105 vstride = k; 106 107 if (vorder <= 0 || uorder <= 0 || k < 0) { 108 /* Erroneous command. */ 109 compsize = 0; 110 } 111 else { 112 compsize = uorder * vorder * k; 113 } 114 __GLX_SWAP_FLOAT_ARRAY(points, compsize); 115 116 glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); 117 } 118 119 void 120 __glXDispSwap_Map1d(GLbyte * pc) 121 { 122 GLint order, k, compsize; 123 GLenum target; 124 GLdouble u1, u2, *points; 125 126 __GLX_DECLARE_SWAP_VARIABLES; 127 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 128 129 __GLX_SWAP_DOUBLE(pc + 0); 130 __GLX_SWAP_DOUBLE(pc + 8); 131 __GLX_SWAP_INT(pc + 16); 132 __GLX_SWAP_INT(pc + 20); 133 134 target = *(GLenum *) (pc + 16); 135 order = *(GLint *) (pc + 20); 136 k = __glMap1d_size(target); 137 if (order <= 0 || k < 0) { 138 /* Erroneous command. */ 139 compsize = 0; 140 } 141 else { 142 compsize = order * k; 143 } 144 __GLX_GET_DOUBLE(u1, pc); 145 __GLX_GET_DOUBLE(u2, pc + 8); 146 __GLX_SWAP_DOUBLE_ARRAY(pc + 24, compsize); 147 pc += 24; 148 149 #ifdef __GLX_ALIGN64 150 if (((unsigned long) pc) & 7) { 151 /* 152 ** Copy the doubles up 4 bytes, trashing the command but aligning 153 ** the data in the process 154 */ 155 __GLX_MEM_COPY(pc - 4, pc, compsize * 8); 156 points = (GLdouble *) (pc - 4); 157 } 158 else { 159 points = (GLdouble *) pc; 160 } 161 #else 162 points = (GLdouble *) pc; 163 #endif 164 glMap1d(target, u1, u2, k, order, points); 165 } 166 167 void 168 __glXDispSwap_Map2d(GLbyte * pc) 169 { 170 GLdouble u1, u2, v1, v2, *points; 171 GLint uorder, vorder, ustride, vstride, k, compsize; 172 GLenum target; 173 174 __GLX_DECLARE_SWAP_VARIABLES; 175 __GLX_DECLARE_SWAP_ARRAY_VARIABLES; 176 177 __GLX_SWAP_DOUBLE(pc + 0); 178 __GLX_SWAP_DOUBLE(pc + 8); 179 __GLX_SWAP_DOUBLE(pc + 16); 180 __GLX_SWAP_DOUBLE(pc + 24); 181 __GLX_SWAP_INT(pc + 32); 182 __GLX_SWAP_INT(pc + 36); 183 __GLX_SWAP_INT(pc + 40); 184 185 target = *(GLenum *) (pc + 32); 186 uorder = *(GLint *) (pc + 36); 187 vorder = *(GLint *) (pc + 40); 188 k = __glMap2d_size(target); 189 if (vorder <= 0 || uorder <= 0 || k < 0) { 190 /* Erroneous command. */ 191 compsize = 0; 192 } 193 else { 194 compsize = uorder * vorder * k; 195 } 196 __GLX_GET_DOUBLE(u1, pc); 197 __GLX_GET_DOUBLE(u2, pc + 8); 198 __GLX_GET_DOUBLE(v1, pc + 16); 199 __GLX_GET_DOUBLE(v2, pc + 24); 200 __GLX_SWAP_DOUBLE_ARRAY(pc + 44, compsize); 201 pc += 44; 202 ustride = vorder * k; 203 vstride = k; 204 205 #ifdef __GLX_ALIGN64 206 if (((unsigned long) pc) & 7) { 207 /* 208 ** Copy the doubles up 4 bytes, trashing the command but aligning 209 ** the data in the process 210 */ 211 __GLX_MEM_COPY(pc - 4, pc, compsize * 8); 212 points = (GLdouble *) (pc - 4); 213 } 214 else { 215 points = (GLdouble *) pc; 216 } 217 #else 218 points = (GLdouble *) pc; 219 #endif 220 glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); 221 } 222 223 static void 224 swapArray(GLint numVals, GLenum datatype, 225 GLint stride, GLint numVertexes, GLbyte * pc) 226 { 227 int i, j; 228 229 __GLX_DECLARE_SWAP_VARIABLES; 230 231 switch (datatype) { 232 case GL_BYTE: 233 case GL_UNSIGNED_BYTE: 234 /* don't need to swap */ 235 return; 236 case GL_SHORT: 237 case GL_UNSIGNED_SHORT: 238 for (i = 0; i < numVertexes; i++) { 239 GLshort *pVal = (GLshort *) pc; 240 241 for (j = 0; j < numVals; j++) { 242 __GLX_SWAP_SHORT(&pVal[j]); 243 } 244 pc += stride; 245 } 246 break; 247 case GL_INT: 248 case GL_UNSIGNED_INT: 249 for (i = 0; i < numVertexes; i++) { 250 GLint *pVal = (GLint *) pc; 251 252 for (j = 0; j < numVals; j++) { 253 __GLX_SWAP_INT(&pVal[j]); 254 } 255 pc += stride; 256 } 257 break; 258 case GL_FLOAT: 259 for (i = 0; i < numVertexes; i++) { 260 GLfloat *pVal = (GLfloat *) pc; 261 262 for (j = 0; j < numVals; j++) { 263 __GLX_SWAP_FLOAT(&pVal[j]); 264 } 265 pc += stride; 266 } 267 break; 268 case GL_DOUBLE: 269 for (i = 0; i < numVertexes; i++) { 270 GLdouble *pVal = (GLdouble *) pc; 271 272 for (j = 0; j < numVals; j++) { 273 __GLX_SWAP_DOUBLE(&pVal[j]); 274 } 275 pc += stride; 276 } 277 break; 278 default: 279 return; 280 } 281 } 282 283 void 284 __glXDispSwap_DrawArrays(GLbyte * pc) 285 { 286 __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc; 287 __GLXdispatchDrawArraysComponentHeader *compHeader; 288 GLint numVertexes = hdr->numVertexes; 289 GLint numComponents = hdr->numComponents; 290 GLenum primType = hdr->primType; 291 GLint stride = 0; 292 int i; 293 294 __GLX_DECLARE_SWAP_VARIABLES; 295 296 __GLX_SWAP_INT(&numVertexes); 297 __GLX_SWAP_INT(&numComponents); 298 __GLX_SWAP_INT(&primType); 299 300 pc += sizeof(__GLXdispatchDrawArraysHeader); 301 compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc; 302 303 /* compute stride (same for all component arrays) */ 304 for (i = 0; i < numComponents; i++) { 305 GLenum datatype = compHeader[i].datatype; 306 GLint numVals = compHeader[i].numVals; 307 GLenum component = compHeader[i].component; 308 309 __GLX_SWAP_INT(&datatype); 310 __GLX_SWAP_INT(&numVals); 311 __GLX_SWAP_INT(&component); 312 313 stride += __GLX_PAD(numVals * __glXTypeSize(datatype)); 314 } 315 316 pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader); 317 318 /* set up component arrays */ 319 for (i = 0; i < numComponents; i++) { 320 GLenum datatype = compHeader[i].datatype; 321 GLint numVals = compHeader[i].numVals; 322 GLenum component = compHeader[i].component; 323 324 __GLX_SWAP_INT(&datatype); 325 __GLX_SWAP_INT(&numVals); 326 __GLX_SWAP_INT(&component); 327 328 swapArray(numVals, datatype, stride, numVertexes, pc); 329 330 switch (component) { 331 case GL_VERTEX_ARRAY: 332 glEnableClientState(GL_VERTEX_ARRAY); 333 glVertexPointer(numVals, datatype, stride, pc); 334 break; 335 case GL_NORMAL_ARRAY: 336 glEnableClientState(GL_NORMAL_ARRAY); 337 glNormalPointer(datatype, stride, pc); 338 break; 339 case GL_COLOR_ARRAY: 340 glEnableClientState(GL_COLOR_ARRAY); 341 glColorPointer(numVals, datatype, stride, pc); 342 break; 343 case GL_INDEX_ARRAY: 344 glEnableClientState(GL_INDEX_ARRAY); 345 glIndexPointer(datatype, stride, pc); 346 break; 347 case GL_TEXTURE_COORD_ARRAY: 348 glEnableClientState(GL_TEXTURE_COORD_ARRAY); 349 glTexCoordPointer(numVals, datatype, stride, pc); 350 break; 351 case GL_EDGE_FLAG_ARRAY: 352 glEnableClientState(GL_EDGE_FLAG_ARRAY); 353 glEdgeFlagPointer(stride, (const GLboolean *) pc); 354 break; 355 case GL_SECONDARY_COLOR_ARRAY: 356 { 357 PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT = 358 __glGetProcAddress("glSecondaryColorPointerEXT"); 359 glEnableClientState(GL_SECONDARY_COLOR_ARRAY); 360 SecondaryColorPointerEXT(numVals, datatype, stride, pc); 361 break; 362 } 363 case GL_FOG_COORD_ARRAY: 364 { 365 PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT = 366 __glGetProcAddress("glFogCoordPointerEXT"); 367 glEnableClientState(GL_FOG_COORD_ARRAY); 368 FogCoordPointerEXT(datatype, stride, pc); 369 break; 370 } 371 default: 372 break; 373 } 374 375 pc += __GLX_PAD(numVals * __glXTypeSize(datatype)); 376 } 377 378 glDrawArrays(primType, 0, numVertexes); 379 380 /* turn off anything we might have turned on */ 381 glDisableClientState(GL_VERTEX_ARRAY); 382 glDisableClientState(GL_NORMAL_ARRAY); 383 glDisableClientState(GL_COLOR_ARRAY); 384 glDisableClientState(GL_INDEX_ARRAY); 385 glDisableClientState(GL_TEXTURE_COORD_ARRAY); 386 glDisableClientState(GL_EDGE_FLAG_ARRAY); 387 glDisableClientState(GL_SECONDARY_COLOR_ARRAY); 388 glDisableClientState(GL_FOG_COORD_ARRAY); 389 }