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 #include "packrender.h" 32 #include "indirect.h" 33 #include "indirect_size.h" 34 35 /* 36 ** This file contains routines that might need to be transported as 37 ** GLXRender or GLXRenderLarge commands, and these commands don't 38 ** use the pixel header. See renderpix.c for those routines. 39 */ 40 41 void 42 __indirect_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, 43 GLint order, const GLdouble * pnts) 44 { 45 __GLX_DECLARE_VARIABLES(); 46 GLint k; 47 48 __GLX_LOAD_VARIABLES(); 49 k = __glMap1d_size(target); 50 if (k == 0) { 51 __glXSetError(gc, GL_INVALID_ENUM); 52 return; 53 } 54 else if (stride < k || order <= 0) { 55 __glXSetError(gc, GL_INVALID_VALUE); 56 return; 57 } 58 compsize = k * order * __GLX_SIZE_FLOAT64; 59 cmdlen = 28 + compsize; 60 if (!gc->currentDpy) 61 return; 62 63 if (cmdlen <= gc->maxSmallRenderCommandSize) { 64 /* Use GLXRender protocol to send small command */ 65 __GLX_BEGIN_VARIABLE(X_GLrop_Map1d, cmdlen); 66 __GLX_PUT_DOUBLE(4, u1); 67 __GLX_PUT_DOUBLE(12, u2); 68 __GLX_PUT_LONG(20, target); 69 __GLX_PUT_LONG(24, order); 70 /* 71 ** NOTE: the doubles that follow are not aligned because of 3 72 ** longs preceeding 73 */ 74 __glFillMap1d(k, order, stride, pnts, (pc + 28)); 75 __GLX_END(cmdlen); 76 } 77 else { 78 /* Use GLXRenderLarge protocol to send command */ 79 __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1d, cmdlen + 4); 80 __GLX_PUT_DOUBLE(8, u1); 81 __GLX_PUT_DOUBLE(16, u2); 82 __GLX_PUT_LONG(24, target); 83 __GLX_PUT_LONG(28, order); 84 85 /* 86 ** NOTE: the doubles that follow are not aligned because of 3 87 ** longs preceeding 88 */ 89 if (stride != k) { 90 GLubyte *buf; 91 92 buf = (GLubyte *) Xmalloc(compsize); 93 if (!buf) { 94 __glXSetError(gc, GL_OUT_OF_MEMORY); 95 return; 96 } 97 __glFillMap1d(k, order, stride, pnts, buf); 98 __glXSendLargeCommand(gc, pc, 32, buf, compsize); 99 Xfree((char *) buf); 100 } 101 else { 102 /* Data is already packed. Just send it out */ 103 __glXSendLargeCommand(gc, pc, 32, pnts, compsize); 104 } 105 } 106 } 107 108 void 109 __indirect_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, 110 GLint order, const GLfloat * pnts) 111 { 112 __GLX_DECLARE_VARIABLES(); 113 GLint k; 114 115 __GLX_LOAD_VARIABLES(); 116 k = __glMap1f_size(target); 117 if (k == 0) { 118 __glXSetError(gc, GL_INVALID_ENUM); 119 return; 120 } 121 else if (stride < k || order <= 0) { 122 __glXSetError(gc, GL_INVALID_VALUE); 123 return; 124 } 125 compsize = k * order * __GLX_SIZE_FLOAT32; 126 cmdlen = 20 + compsize; 127 if (!gc->currentDpy) 128 return; 129 130 /* 131 ** The order that arguments are packed is different from the order 132 ** for glMap1d. 133 */ 134 if (cmdlen <= gc->maxSmallRenderCommandSize) { 135 /* Use GLXRender protocol to send small command */ 136 __GLX_BEGIN_VARIABLE(X_GLrop_Map1f, cmdlen); 137 __GLX_PUT_LONG(4, target); 138 __GLX_PUT_FLOAT(8, u1); 139 __GLX_PUT_FLOAT(12, u2); 140 __GLX_PUT_LONG(16, order); 141 __glFillMap1f(k, order, stride, pnts, (GLubyte *) (pc + 20)); 142 __GLX_END(cmdlen); 143 } 144 else { 145 /* Use GLXRenderLarge protocol to send command */ 146 __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1f, cmdlen + 4); 147 __GLX_PUT_LONG(8, target); 148 __GLX_PUT_FLOAT(12, u1); 149 __GLX_PUT_FLOAT(16, u2); 150 __GLX_PUT_LONG(20, order); 151 152 if (stride != k) { 153 GLubyte *buf; 154 155 buf = (GLubyte *) Xmalloc(compsize); 156 if (!buf) { 157 __glXSetError(gc, GL_OUT_OF_MEMORY); 158 return; 159 } 160 __glFillMap1f(k, order, stride, pnts, buf); 161 __glXSendLargeCommand(gc, pc, 24, buf, compsize); 162 Xfree((char *) buf); 163 } 164 else { 165 /* Data is already packed. Just send it out */ 166 __glXSendLargeCommand(gc, pc, 24, pnts, compsize); 167 } 168 } 169 } 170 171 void 172 __indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustr, 173 GLint uord, GLdouble v1, GLdouble v2, GLint vstr, 174 GLint vord, const GLdouble * pnts) 175 { 176 __GLX_DECLARE_VARIABLES(); 177 GLint k; 178 179 __GLX_LOAD_VARIABLES(); 180 k = __glMap2d_size(target); 181 if (k == 0) { 182 __glXSetError(gc, GL_INVALID_ENUM); 183 return; 184 } 185 else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) { 186 __glXSetError(gc, GL_INVALID_VALUE); 187 return; 188 } 189 compsize = k * uord * vord * __GLX_SIZE_FLOAT64; 190 cmdlen = 48 + compsize; 191 if (!gc->currentDpy) 192 return; 193 194 if (cmdlen <= gc->maxSmallRenderCommandSize) { 195 /* Use GLXRender protocol to send small command */ 196 __GLX_BEGIN_VARIABLE(X_GLrop_Map2d, cmdlen); 197 __GLX_PUT_DOUBLE(4, u1); 198 __GLX_PUT_DOUBLE(12, u2); 199 __GLX_PUT_DOUBLE(20, v1); 200 __GLX_PUT_DOUBLE(28, v2); 201 __GLX_PUT_LONG(36, target); 202 __GLX_PUT_LONG(40, uord); 203 __GLX_PUT_LONG(44, vord); 204 /* 205 ** Pack into a u-major ordering. 206 ** NOTE: the doubles that follow are not aligned because of 5 207 ** longs preceeding 208 */ 209 __glFillMap2d(k, uord, vord, ustr, vstr, pnts, (GLdouble *) (pc + 48)); 210 __GLX_END(cmdlen); 211 } 212 else { 213 /* Use GLXRenderLarge protocol to send command */ 214 __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2d, cmdlen + 4); 215 __GLX_PUT_DOUBLE(8, u1); 216 __GLX_PUT_DOUBLE(16, u2); 217 __GLX_PUT_DOUBLE(24, v1); 218 __GLX_PUT_DOUBLE(32, v2); 219 __GLX_PUT_LONG(40, target); 220 __GLX_PUT_LONG(44, uord); 221 __GLX_PUT_LONG(48, vord); 222 223 /* 224 ** NOTE: the doubles that follow are not aligned because of 5 225 ** longs preceeding 226 */ 227 if ((vstr != k) || (ustr != k * vord)) { 228 GLdouble *buf; 229 230 buf = (GLdouble *) Xmalloc(compsize); 231 if (!buf) { 232 __glXSetError(gc, GL_OUT_OF_MEMORY); 233 return; 234 } 235 /* 236 ** Pack into a u-major ordering. 237 */ 238 __glFillMap2d(k, uord, vord, ustr, vstr, pnts, buf); 239 __glXSendLargeCommand(gc, pc, 52, buf, compsize); 240 Xfree((char *) buf); 241 } 242 else { 243 /* Data is already packed. Just send it out */ 244 __glXSendLargeCommand(gc, pc, 52, pnts, compsize); 245 } 246 } 247 } 248 249 void 250 __indirect_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustr, 251 GLint uord, GLfloat v1, GLfloat v2, GLint vstr, GLint vord, 252 const GLfloat * pnts) 253 { 254 __GLX_DECLARE_VARIABLES(); 255 GLint k; 256 257 __GLX_LOAD_VARIABLES(); 258 k = __glMap2f_size(target); 259 if (k == 0) { 260 __glXSetError(gc, GL_INVALID_ENUM); 261 return; 262 } 263 else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) { 264 __glXSetError(gc, GL_INVALID_VALUE); 265 return; 266 } 267 compsize = k * uord * vord * __GLX_SIZE_FLOAT32; 268 cmdlen = 32 + compsize; 269 if (!gc->currentDpy) 270 return; 271 272 /* 273 ** The order that arguments are packed is different from the order 274 ** for glMap2d. 275 */ 276 if (cmdlen <= gc->maxSmallRenderCommandSize) { 277 /* Use GLXRender protocol to send small command */ 278 __GLX_BEGIN_VARIABLE(X_GLrop_Map2f, cmdlen); 279 __GLX_PUT_LONG(4, target); 280 __GLX_PUT_FLOAT(8, u1); 281 __GLX_PUT_FLOAT(12, u2); 282 __GLX_PUT_LONG(16, uord); 283 __GLX_PUT_FLOAT(20, v1); 284 __GLX_PUT_FLOAT(24, v2); 285 __GLX_PUT_LONG(28, vord); 286 /* 287 ** Pack into a u-major ordering. 288 */ 289 __glFillMap2f(k, uord, vord, ustr, vstr, pnts, (GLfloat *) (pc + 32)); 290 __GLX_END(cmdlen); 291 } 292 else { 293 /* Use GLXRenderLarge protocol to send command */ 294 __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2f, cmdlen + 4); 295 __GLX_PUT_LONG(8, target); 296 __GLX_PUT_FLOAT(12, u1); 297 __GLX_PUT_FLOAT(16, u2); 298 __GLX_PUT_LONG(20, uord); 299 __GLX_PUT_FLOAT(24, v1); 300 __GLX_PUT_FLOAT(28, v2); 301 __GLX_PUT_LONG(32, vord); 302 303 if ((vstr != k) || (ustr != k * vord)) { 304 GLfloat *buf; 305 306 buf = (GLfloat *) Xmalloc(compsize); 307 if (!buf) { 308 __glXSetError(gc, GL_OUT_OF_MEMORY); 309 return; 310 } 311 /* 312 ** Pack into a u-major ordering. 313 */ 314 __glFillMap2f(k, uord, vord, ustr, vstr, pnts, buf); 315 __glXSendLargeCommand(gc, pc, 36, buf, compsize); 316 Xfree((char *) buf); 317 } 318 else { 319 /* Data is already packed. Just send it out */ 320 __glXSendLargeCommand(gc, pc, 36, pnts, compsize); 321 } 322 } 323 } 324 325 void 326 __indirect_glEnable(GLenum cap) 327 { 328 __GLX_DECLARE_VARIABLES(); 329 330 __GLX_LOAD_VARIABLES(); 331 if (!gc->currentDpy) 332 return; 333 334 switch (cap) { 335 case GL_COLOR_ARRAY: 336 case GL_EDGE_FLAG_ARRAY: 337 case GL_INDEX_ARRAY: 338 case GL_NORMAL_ARRAY: 339 case GL_TEXTURE_COORD_ARRAY: 340 case GL_VERTEX_ARRAY: 341 case GL_SECONDARY_COLOR_ARRAY: 342 case GL_FOG_COORD_ARRAY: 343 __indirect_glEnableClientState(cap); 344 return; 345 default: 346 break; 347 } 348 349 __GLX_BEGIN(X_GLrop_Enable, 8); 350 __GLX_PUT_LONG(4, cap); 351 __GLX_END(8); 352 } 353 354 void 355 __indirect_glDisable(GLenum cap) 356 { 357 __GLX_DECLARE_VARIABLES(); 358 359 __GLX_LOAD_VARIABLES(); 360 if (!gc->currentDpy) 361 return; 362 363 switch (cap) { 364 case GL_COLOR_ARRAY: 365 case GL_EDGE_FLAG_ARRAY: 366 case GL_INDEX_ARRAY: 367 case GL_NORMAL_ARRAY: 368 case GL_TEXTURE_COORD_ARRAY: 369 case GL_VERTEX_ARRAY: 370 case GL_SECONDARY_COLOR_ARRAY: 371 case GL_FOG_COORD_ARRAY: 372 __indirect_glDisableClientState(cap); 373 return; 374 default: 375 break; 376 } 377 378 __GLX_BEGIN(X_GLrop_Disable, 8); 379 __GLX_PUT_LONG(4, cap); 380 __GLX_END(8); 381 } 382
