git.cworth.org Git - apitrace/blob - glsize.hpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 VMware, Inc.
   4  * Copyright 2004 IBM Corporation
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sub license,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the next
  15  * paragraph) shall be included in all copies or substantial portions of the
  16  * Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  21  * AUTHORS,
  22  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  24  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 /*
  30  * Auxiliary functions to compute the size of array/blob arguments, depending.
  31  */
  32
  33 #ifndef _GL_SIZE_HPP_
  34 #define _GL_SIZE_HPP_
  35
  36
  37 #include <string.h>
  38
  39 #include "os.hpp"
  40 #include "glimports.hpp"
  41
  42
  43 static inline size_t
  44 __gl_type_size(GLenum type)
  45 {
  46     switch (type) {
  47     case GL_BOOL:
  48     case GL_BYTE:
  49     case GL_UNSIGNED_BYTE:
  50         return 1;
  51     case GL_SHORT:
  52     case GL_UNSIGNED_SHORT:
  53     case GL_2_BYTES:
  54     case GL_HALF_FLOAT:
  55         return 2;
  56     case GL_3_BYTES:
  57         return 3;
  58     case GL_INT:
  59     case GL_UNSIGNED_INT:
  60     case GL_FLOAT:
  61     case GL_4_BYTES:
  62         return 4;
  63     case GL_DOUBLE:
  64         return 8;
  65     default:
  66         OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
  67         return 0;
  68     }
  69 }
  70
  71 static inline void
  72 __gl_uniform_size(GLenum type, GLenum &elemType, GLint &numElems) {
  73     switch (type) {
  74     case GL_FLOAT:
  75         elemType = GL_FLOAT;
  76         numElems = 1;
  77         break;
  78     case GL_FLOAT_VEC2:
  79         elemType = GL_FLOAT;
  80         numElems = 2;
  81         break;
  82     case GL_FLOAT_VEC3:
  83         elemType = GL_FLOAT;
  84         numElems = 3;
  85         break;
  86     case GL_FLOAT_VEC4:
  87         elemType = GL_FLOAT;
  88         numElems = 4;
  89         break;
  90     case GL_DOUBLE:
  91         elemType = GL_DOUBLE;
  92         numElems = 1;
  93         break;
  94     case GL_DOUBLE_VEC2:
  95         elemType = GL_DOUBLE;
  96         numElems = 2;
  97         break;
  98     case GL_DOUBLE_VEC3:
  99         elemType = GL_DOUBLE;
 100         numElems = 3;
 101         break;
 102     case GL_DOUBLE_VEC4:
 103         elemType = GL_DOUBLE;
 104         numElems = 4;
 105         break;
 106     case GL_INT:
 107         elemType = GL_INT;
 108         numElems = 1;
 109         break;
 110     case GL_INT_VEC2:
 111         elemType = GL_INT;
 112         numElems = 2;
 113         break;
 114     case GL_INT_VEC3:
 115         elemType = GL_INT;
 116         numElems = 3;
 117         break;
 118     case GL_INT_VEC4:
 119         elemType = GL_INT;
 120         numElems = 4;
 121         break;
 122     case GL_UNSIGNED_INT:
 123         elemType = GL_UNSIGNED_INT;
 124         numElems = 1;
 125         break;
 126     case GL_UNSIGNED_INT_VEC2:
 127         elemType = GL_UNSIGNED_INT;
 128         numElems = 2;
 129         break;
 130     case GL_UNSIGNED_INT_VEC3:
 131         elemType = GL_UNSIGNED_INT;
 132         numElems = 3;
 133         break;
 134     case GL_UNSIGNED_INT_VEC4:
 135         elemType = GL_UNSIGNED_INT;
 136         numElems = 4;
 137         break;
 138     case GL_BOOL:
 139         elemType = GL_BOOL;
 140         numElems = 1;
 141         break;
 142     case GL_BOOL_VEC2:
 143         elemType = GL_BOOL;
 144         numElems = 2;
 145         break;
 146     case GL_BOOL_VEC3:
 147         elemType = GL_BOOL;
 148         numElems = 3;
 149         break;
 150     case GL_BOOL_VEC4:
 151         elemType = GL_BOOL;
 152         numElems = 4;
 153         break;
 154     case GL_FLOAT_MAT2:
 155         elemType = GL_FLOAT;
 156         numElems = 2*2;
 157         break;
 158     case GL_FLOAT_MAT3:
 159         elemType = GL_FLOAT;
 160         numElems = 3*3;
 161         break;
 162     case GL_FLOAT_MAT4:
 163         elemType = GL_FLOAT;
 164         numElems = 4*4;
 165         break;
 166     case GL_FLOAT_MAT2x3:
 167         elemType = GL_FLOAT;
 168         numElems = 2*3;
 169         break;
 170     case GL_FLOAT_MAT2x4:
 171         elemType = GL_FLOAT;
 172         numElems = 2*4;
 173         break;
 174     case GL_FLOAT_MAT3x2:
 175         elemType = GL_FLOAT;
 176         numElems = 3*2;
 177         break;
 178     case GL_FLOAT_MAT3x4:
 179         elemType = GL_FLOAT;
 180         numElems = 3*4;
 181         break;
 182     case GL_FLOAT_MAT4x2:
 183         elemType = GL_FLOAT;
 184         numElems = 4*2;
 185         break;
 186     case GL_FLOAT_MAT4x3:
 187         elemType = GL_FLOAT;
 188         numElems = 4*3;
 189         break;
 190     case GL_DOUBLE_MAT2:
 191         elemType = GL_DOUBLE;
 192         numElems = 2*2;
 193         break;
 194     case GL_DOUBLE_MAT3:
 195         elemType = GL_DOUBLE;
 196         numElems = 3*3;
 197         break;
 198     case GL_DOUBLE_MAT4:
 199         elemType = GL_DOUBLE;
 200         numElems = 4*4;
 201         break;
 202     case GL_DOUBLE_MAT2x3:
 203         elemType = GL_DOUBLE;
 204         numElems = 2*3;
 205         break;
 206     case GL_DOUBLE_MAT2x4:
 207         elemType = GL_DOUBLE;
 208         numElems = 2*4;
 209         break;
 210     case GL_DOUBLE_MAT3x2:
 211         elemType = GL_DOUBLE;
 212         numElems = 3*2;
 213         break;
 214     case GL_DOUBLE_MAT3x4:
 215         elemType = GL_DOUBLE;
 216         numElems = 3*4;
 217         break;
 218     case GL_DOUBLE_MAT4x2:
 219         elemType = GL_DOUBLE;
 220         numElems = 4*2;
 221         break;
 222     case GL_DOUBLE_MAT4x3:
 223         elemType = GL_DOUBLE;
 224         numElems = 4*3;
 225         break;
 226     case GL_SAMPLER_1D:
 227     case GL_SAMPLER_2D:
 228     case GL_SAMPLER_3D:
 229     case GL_SAMPLER_CUBE:
 230     case GL_SAMPLER_1D_SHADOW:
 231     case GL_SAMPLER_2D_SHADOW:
 232     case GL_SAMPLER_1D_ARRAY:
 233     case GL_SAMPLER_2D_ARRAY:
 234     case GL_SAMPLER_CUBE_MAP_ARRAY:
 235     case GL_SAMPLER_1D_ARRAY_SHADOW:
 236     case GL_SAMPLER_2D_ARRAY_SHADOW:
 237     case GL_SAMPLER_2D_MULTISAMPLE:
 238     case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
 239     case GL_SAMPLER_CUBE_SHADOW:
 240     case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
 241     case GL_SAMPLER_BUFFER:
 242     case GL_SAMPLER_2D_RECT:
 243     case GL_SAMPLER_2D_RECT_SHADOW:
 244     case GL_INT_SAMPLER_1D:
 245     case GL_INT_SAMPLER_2D:
 246     case GL_INT_SAMPLER_3D:
 247     case GL_INT_SAMPLER_CUBE:
 248     case GL_INT_SAMPLER_1D_ARRAY:
 249     case GL_INT_SAMPLER_2D_ARRAY:
 250     case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
 251     case GL_INT_SAMPLER_2D_MULTISAMPLE:
 252     case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
 253     case GL_INT_SAMPLER_BUFFER:
 254     case GL_INT_SAMPLER_2D_RECT:
 255     case GL_UNSIGNED_INT_SAMPLER_1D:
 256     case GL_UNSIGNED_INT_SAMPLER_2D:
 257     case GL_UNSIGNED_INT_SAMPLER_3D:
 258     case GL_UNSIGNED_INT_SAMPLER_CUBE:
 259     case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
 260     case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
 261     case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
 262     case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
 263     case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
 264     case GL_UNSIGNED_INT_SAMPLER_BUFFER:
 265     case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
 266         elemType = GL_INT;
 267         numElems = 1;
 268         break;
 269     default:
 270         OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
 271         elemType = GL_NONE;
 272         numElems = 0;
 273         return;
 274     }
 275 }
 276
 277 static inline size_t
 278 __glArrayPointer_size(GLint size, GLenum type, GLsizei stride, GLsizei maxIndex)
 279 {
 280     size_t elementSize = size*__gl_type_size(type);
 281     if (!stride) {
 282         stride = (GLsizei)elementSize;
 283     }
 284     return stride*maxIndex + elementSize;
 285 }
 286
 287 #define __glVertexPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 288 #define __glNormalPointer_size(type, stride, maxIndex) __glArrayPointer_size(3, type, stride, maxIndex)
 289 #define __glColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 290 #define __glIndexPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex)
 291 #define __glTexCoordPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 292 #define __glEdgeFlagPointer_size(stride, maxIndex) __glArrayPointer_size(1, GL_BOOL, stride, maxIndex)
 293 #define __glFogCoordPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex)
 294 #define __glSecondaryColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 295 #define __glVertexAttribPointer_size(size, type, normalized, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 296 #define __glVertexAttribPointerARB_size(size, type, normalized, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 297 #define __glVertexAttribPointerNV_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 298
 299 static inline GLuint
 300 __glDrawArrays_maxindex(GLint first, GLsizei count)
 301 {
 302     if (!count) {
 303         return 0;
 304     }
 305     return first + count - 1;
 306 }
 307
 308 #define __glDrawArraysEXT_maxindex __glDrawArrays_maxindex
 309
 310 static inline GLuint
 311 __glDrawElementsBaseVertex_maxindex(GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 312 {
 313     GLvoid *temp = 0;
 314     GLint __element_array_buffer = 0;
 315
 316     if (!count) {
 317         return 0;
 318     }
 319     __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);
 320     if (__element_array_buffer) {
 321         // Read indices from index buffer object
 322         GLintptr offset = (GLintptr)indices;
 323         GLsizeiptr size = count*__gl_type_size(type);
 324         GLvoid *temp = malloc(size);
 325         if (!temp) {
 326             return 0;
 327         }
 328         memset(temp, 0, size);
 329         __glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, temp);
 330         indices = temp;
 331     } else {
 332         if (!indices) {
 333             return 0;
 334         }
 335     }
 336
 337     GLuint maxindex = 0;
 338     GLsizei i;
 339     if (type == GL_UNSIGNED_BYTE) {
 340         const GLubyte *p = (const GLubyte *)indices;
 341         for (i = 0; i < count; ++i) {
 342             if (p[i] > maxindex) {
 343                 maxindex = p[i];
 344             }
 345         }
 346     } else if (type == GL_UNSIGNED_SHORT) {
 347         const GLushort *p = (const GLushort *)indices;
 348         for (i = 0; i < count; ++i) {
 349             if (p[i] > maxindex) {
 350                 maxindex = p[i];
 351             }
 352         }
 353     } else if (type == GL_UNSIGNED_INT) {
 354         const GLuint *p = (const GLuint *)indices;
 355         for (i = 0; i < count; ++i) {
 356             if (p[i] > maxindex) {
 357                 maxindex = p[i];
 358             }
 359         }
 360     } else {
 361         OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
 362     }
 363
 364     if (__element_array_buffer) {
 365         free(temp);
 366     }
 367
 368     maxindex += basevertex;
 369
 370     return maxindex;
 371 }
 372
 373 #define __glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex)
 374
 375 #define __glDrawElements_maxindex(count, type, indices) __glDrawElementsBaseVertex_maxindex(count, type, indices, 0);
 376 #define __glDrawRangeElements_maxindex(start, end, count, type, indices) __glDrawElements_maxindex(count, type, indices)
 377 #define __glDrawRangeElementsEXT_maxindex __glDrawRangeElements_maxindex
 378
 379 #define __glDrawArraysInstanced_maxindex(first, count, primcount) __glDrawArrays_maxindex(first, count)
 380 #define __glDrawElementsInstanced_maxindex(count, type, indices, primcount) __glDrawElements_maxindex(count, type, indices)
 381 #define __glDrawElementsInstancedBaseVertex_maxindex(count, type, indices, primcount, basevertex) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex)
 382 #define __glDrawRangeElementsInstanced_maxindex(start, end, count, type, indices, primcount) __glDrawRangeElements_maxindex(start, end, count, type, indices)
 383 #define __glDrawRangeElementsInstancedBaseVertex_maxindex(start, end, count, type, indices, primcount, basevertex) __glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex)
 384
 385 #define __glDrawArraysInstancedARB_maxindex __glDrawArraysInstanced_maxindex
 386 #define __glDrawElementsInstancedARB_maxindex __glDrawElementsInstanced_maxindex
 387 #define __glDrawArraysInstancedEXT_maxindex __glDrawArraysInstanced_maxindex
 388 #define __glDrawElementsInstancedEXT_maxindex __glDrawElementsInstanced_maxindex
 389
 390 static inline GLuint
 391 __glDrawArraysIndirect_maxindex(const GLvoid *indirect) {
 392     OS::DebugMessage("apitrace: warning: %s: unsupported\n", __FUNCTION__);
 393     return 0;
 394 }
 395
 396 static inline GLuint
 397 __glDrawElementsIndirect_maxindex(GLenum type, const GLvoid *indirect) {
 398     OS::DebugMessage("apitrace: warning: %s: unsupported\n", __FUNCTION__);
 399     return 0;
 400 }
 401
 402 static inline GLuint
 403 __glMultiDrawArrays_maxindex(const GLint *first, const GLsizei *count, GLsizei primcount) {
 404     GLuint maxindex = 0;
 405     for (GLsizei prim = 0; prim < primcount; ++prim) {
 406         GLuint maxindex_prim = __glDrawArrays_maxindex(first[prim], count[prim]);
 407         maxindex = std::max(maxindex, maxindex_prim);
 408     }
 409     return maxindex;
 410 }
 411
 412 static inline GLuint
 413 __glMultiDrawElements_maxindex(const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) {
 414     GLuint maxindex = 0;
 415     for (GLsizei prim = 0; prim < primcount; ++prim) {
 416         GLuint maxindex_prim = __glDrawElements_maxindex(count[prim], type, indices[prim]);
 417         maxindex = std::max(maxindex, maxindex_prim);
 418     }
 419     return maxindex;
 420 }
 421
 422 static inline GLuint
 423 __glMultiDrawElementsBaseVertex_maxindex(const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, const GLint * basevertex) {
 424     GLuint maxindex = 0;
 425     for (GLsizei prim = 0; prim < primcount; ++prim) {
 426         GLuint maxindex_prim = __glDrawElementsBaseVertex_maxindex(count[prim], type, indices[prim], basevertex[prim]);
 427         maxindex = std::max(maxindex, maxindex_prim);
 428     }
 429     return maxindex;
 430 }
 431
 432 #define __glMultiDrawArraysEXT_maxindex __glMultiDrawArrays_maxindex
 433 #define __glMultiDrawElementsEXT_maxindex __glMultiDrawElements_maxindex
 434
 435 #define __glMultiModeDrawArraysIBM_maxindex(first, count, primcount, modestride) __glMultiDrawArrays_maxindex(first, count, primcount)
 436 #define __glMultiModeDrawElementsIBM_maxindex(count, type, indices, primcount, modestride) __glMultiDrawElements_maxindex(count, type, (const GLvoid **)indices, primcount)
 437
 438
 439 static inline size_t
 440 __glCallLists_size(GLsizei n, GLenum type)
 441 {
 442     return n*__gl_type_size(type);
 443 }
 444
 445 #define __glFogfv_size __gl_param_size
 446 #define __glFogiv_size __gl_param_size
 447
 448 #define __glLightfv_size __gl_param_size
 449 #define __glLightiv_size __gl_param_size
 450
 451 #define __glLightModelfv_size __gl_param_size
 452 #define __glLightModeliv_size __glLightModelfv_size
 453
 454 #define __glMaterialfv_size __gl_param_size
 455 #define __glMaterialiv_size __glMaterialfv_size
 456
 457
 458 static inline size_t
 459 __glMap1d_size(GLenum target, GLint stride, GLint order)
 460 {
 461     if (order < 1) {
 462         return 0;
 463     }
 464
 465     GLint channels;
 466     switch (target) {
 467     case GL_MAP1_INDEX:
 468     case GL_MAP1_TEXTURE_COORD_1:
 469         channels = 1;
 470         break;
 471     case GL_MAP1_TEXTURE_COORD_2:
 472         channels = 2;
 473         break;
 474     case GL_MAP1_NORMAL:
 475     case GL_MAP1_TEXTURE_COORD_3:
 476     case GL_MAP1_VERTEX_3:
 477         channels = 3;
 478         break;
 479     case GL_MAP1_COLOR_4:
 480     case GL_MAP1_TEXTURE_COORD_4:
 481     case GL_MAP1_VERTEX_4:
 482         channels = 4;
 483         break;
 484     default:
 485         OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target);
 486         return 0;
 487     }
 488
 489     if (stride < channels) {
 490         return 0;
 491     }
 492
 493     return channels + stride * (order - 1);
 494 }
 495
 496 #define __glMap1f_size __glMap1d_size
 497
 498 static inline size_t
 499 __glMap2d_size(GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder)
 500 {
 501     if (uorder < 1 || vorder < 1) {
 502         return 0;
 503     }
 504
 505     GLint channels;
 506     switch (target) {
 507     case GL_MAP2_INDEX:
 508     case GL_MAP2_TEXTURE_COORD_1:
 509         channels = 1;
 510         break;
 511     case GL_MAP2_TEXTURE_COORD_2:
 512         channels = 2;
 513         break;
 514     case GL_MAP2_NORMAL:
 515     case GL_MAP2_TEXTURE_COORD_3:
 516     case GL_MAP2_VERTEX_3:
 517         channels = 3;
 518         break;
 519     case GL_MAP2_COLOR_4:
 520     case GL_MAP2_TEXTURE_COORD_4:
 521     case GL_MAP2_VERTEX_4:
 522         channels = 4;
 523         break;
 524     default:
 525         OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target);
 526         return 0;
 527     }
 528
 529     if (ustride < channels || vstride < channels) {
 530         return 0;
 531     }
 532
 533     return channels +
 534            ustride * (uorder - 1) +
 535            vstride * (vorder - 1);
 536 }
 537
 538 #define __glMap2f_size __glMap2d_size
 539
 540 #define __glGetBooleanv_size __gl_param_size
 541 #define __glGetDoublev_size __glGetBooleanv_size
 542 #define __glGetFloatv_size __glGetBooleanv_size
 543 #define __glGetIntegerv_size __glGetBooleanv_size
 544 #define __glGetInteger64v_size __glGetBooleanv_size
 545 #define __glGetBooleani_v_size __gl_param_size
 546 #define __glGetDoublei_v_size __glGetBooleanv_size
 547 #define __glGetFloati_v_size __glGetBooleanv_size
 548 #define __glGetIntegeri_v_size __glGetBooleani_v_size
 549 #define __glGetInteger64i_v_size __glGetBooleani_v_size
 550
 551 #define __glGetLightfv_size __glLightfv_size
 552 #define __glGetLightiv_size __glLightfv_size
 553
 554 #define __glGetMaterialfv_size __glMaterialfv_size
 555 #define __glGetMaterialiv_size __glMaterialfv_size
 556
 557
 558 #define __glColorTableParameterfv_size __gl_param_size
 559 #define __glColorTableParameteriv_size __gl_param_size
 560 #define __glGetColorTableParameterfv_size __gl_param_size
 561 #define __glGetColorTableParameteriv_size __gl_param_size
 562
 563 #define __glConvolutionParameterfv_size __gl_param_size
 564 #define __glConvolutionParameteriv_size __gl_param_size
 565 #define __glGetConvolutionParameterfv_size __gl_param_size
 566 #define __glGetConvolutionParameteriv_size __gl_param_size
 567
 568 #define __glGetHistogramParameterfv_size __gl_param_size
 569 #define __glGetHistogramParameteriv_size __gl_param_size
 570
 571 #define __glGetMinmaxParameterfv_size __gl_param_size
 572 #define __glGetMinmaxParameteriv_size __gl_param_size
 573
 574 #define __glGetProgramivARB_size __gl_param_size
 575 #define __glGetProgramivNV_size __gl_param_size
 576
 577 #define __glGetVertexAttribdvARB_size __gl_param_size
 578 #define __glGetVertexAttribfvARB_size __gl_param_size
 579 #define __glGetVertexAttribivARB_size __gl_param_size
 580 #define __glGetVertexAttribdvNV_size __gl_param_size
 581 #define __glGetVertexAttribfvNV_size __gl_param_size
 582 #define __glGetVertexAttribivNV_size __gl_param_size
 583
 584 #define __glGetQueryObjectivARB_size __gl_param_size
 585 #define __glGetQueryObjectuivARB_size __glGetQueryObjectivARB_size
 586 #define __glGetQueryivARB_size __gl_param_size
 587
 588 #define __glPointParameterfv_size __glPointParameterfvEXT_size
 589 #define __glPointParameteriv_size __glPointParameterfvEXT_size
 590 #define __glPointParameterfvARB_size __glPointParameterfvEXT_size
 591 #define __glPointParameterfvEXT_size __gl_param_size
 592 #define __glPointParameterivNV_size __glPointParameterfvEXT_size
 593
 594 #define __glGetFramebufferAttachmentParameteriv_size __gl_param_size
 595 #define __glGetFramebufferAttachmentParameterivEXT_size __gl_param_size
 596
 597 static inline unsigned
 598 __gl_format_channels(GLenum format) {
 599     switch (format) {
 600     case GL_COLOR_INDEX:
 601     case GL_RED:
 602     case GL_GREEN:
 603     case GL_BLUE:
 604     case GL_ALPHA:
 605     case GL_INTENSITY:
 606     case GL_LUMINANCE:
 607     case GL_DEPTH_COMPONENT:
 608     case GL_STENCIL_INDEX:
 609         return 1;
 610     case GL_DEPTH_STENCIL:
 611     case GL_LUMINANCE_ALPHA:
 612     case GL_RG:
 613     case GL_HILO_NV:
 614     case GL_DSDT_NV:
 615         return 2;
 616     case GL_RGB:
 617     case GL_BGR:
 618     case GL_DSDT_MAG_NV:
 619         return 3;
 620     case GL_RGBA:
 621     case GL_BGRA:
 622     case GL_ABGR_EXT:
 623     case GL_CMYK_EXT:
 624     case GL_DSDT_MAG_VIB_NV:
 625         return 4;
 626     case GL_CMYKA_EXT:
 627         return 5;
 628     default:
 629         OS::DebugMessage("apitrace: warning: %s: unexpected format GLenum 0x%04X\n", __FUNCTION__, format);
 630         return 0;
 631     }
 632 }
 633
 634 template<class X>
 635 static inline bool
 636 _is_pot(X x) {
 637     return (x & (x - 1)) == 0;
 638 }
 639
 640 template<class X, class Y>
 641 static inline X
 642 _align(X x, Y y) {
 643     return (x + (y - 1)) & ~(y - 1);
 644 }
 645
 646 static inline size_t
 647 __gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth) {
 648     unsigned num_channels = __gl_format_channels(format);
 649
 650     unsigned bits_per_pixel;
 651     switch (type) {
 652     case GL_BITMAP:
 653         bits_per_pixel = 1;
 654         break;
 655     case GL_BYTE:
 656     case GL_UNSIGNED_BYTE:
 657         bits_per_pixel = 8 * num_channels;
 658         break;
 659     case GL_SHORT:
 660     case GL_UNSIGNED_SHORT:
 661     case GL_HALF_FLOAT:
 662         bits_per_pixel = 16 * num_channels;
 663         break;
 664     case GL_INT:
 665     case GL_UNSIGNED_INT:
 666     case GL_FLOAT:
 667         bits_per_pixel = 32 * num_channels;
 668         break;
 669     case GL_UNSIGNED_BYTE_3_3_2:
 670     case GL_UNSIGNED_BYTE_2_3_3_REV:
 671         bits_per_pixel = 8;
 672         break;
 673     case GL_UNSIGNED_SHORT_4_4_4_4:
 674     case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 675     case GL_UNSIGNED_SHORT_5_5_5_1:
 676     case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 677     case GL_UNSIGNED_SHORT_5_6_5:
 678     case GL_UNSIGNED_SHORT_5_6_5_REV:
 679     case GL_UNSIGNED_SHORT_8_8_MESA:
 680     case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 681         bits_per_pixel = 16;
 682         break;
 683     case GL_UNSIGNED_INT_8_8_8_8:
 684     case GL_UNSIGNED_INT_8_8_8_8_REV:
 685     case GL_UNSIGNED_INT_10_10_10_2:
 686     case GL_UNSIGNED_INT_2_10_10_10_REV:
 687     case GL_UNSIGNED_INT_24_8:
 688     case GL_UNSIGNED_INT_10F_11F_11F_REV:
 689     case GL_UNSIGNED_INT_5_9_9_9_REV:
 690     case GL_UNSIGNED_INT_S8_S8_8_8_NV:
 691     case GL_UNSIGNED_INT_8_8_S8_S8_REV_NV:
 692         bits_per_pixel = 32;
 693         break;
 694     case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 695         bits_per_pixel = 64;
 696         break;
 697     default:
 698         OS::DebugMessage("apitrace: warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type);
 699         bits_per_pixel = 0;
 700         break;
 701     }
 702
 703     GLint alignment = 4;
 704     GLint row_length = 0;
 705     GLint image_height = 0;
 706     GLint skip_rows = 0;
 707     GLint skip_pixels = 0;
 708     GLint skip_images = 0;
 709
 710     __glGetIntegerv(GL_UNPACK_ALIGNMENT,    &alignment);
 711     __glGetIntegerv(GL_UNPACK_ROW_LENGTH,   &row_length);
 712     __glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &image_height);
 713     __glGetIntegerv(GL_UNPACK_SKIP_ROWS,    &skip_rows);
 714     __glGetIntegerv(GL_UNPACK_SKIP_PIXELS,  &skip_pixels);
 715     __glGetIntegerv(GL_UNPACK_SKIP_IMAGES,  &skip_images);
 716
 717     if (row_length <= 0) {
 718         row_length = width;
 719     }
 720
 721     size_t row_stride = (row_length*bits_per_pixel + 7)/8;
 722
 723     if ((GLint)bits_per_pixel < alignment*8 &&
 724         (bits_per_pixel & 7) == 0 &&
 725         _is_pot(bits_per_pixel)) {
 726         row_stride = _align(row_stride, alignment);
 727     }
 728
 729     if (image_height <= 0) {
 730         image_height = height;
 731     }
 732
 733     /* XXX: GL_UNPACK_IMAGE_HEIGHT and GL_UNPACK_SKIP_IMAGES should probably
 734      * not be considered for pixel rectangles. */
 735
 736     size_t image_stride = image_height*row_stride;
 737
 738     size_t size = depth*image_stride;
 739
 740     size += (skip_pixels*bits_per_pixel + 7)/8;
 741     size += skip_rows*row_stride;
 742     size += skip_images*image_stride;
 743
 744     return size;
 745 }
 746
 747 #define __glTexParameterfv_size __gl_param_size
 748 #define __glTexParameteriv_size __gl_param_size
 749 #define __glGetTexParameterfv_size __gl_param_size
 750 #define __glGetTexParameteriv_size __gl_param_size
 751 #define __glGetTexLevelParameterfv_size __gl_param_size
 752 #define __glGetTexLevelParameteriv_size __gl_param_size
 753 #define __glTexParameterIiv_size __gl_param_size
 754 #define __glTexParameterIuiv_size __gl_param_size
 755 #define __glGetTexParameterIiv_size __gl_param_size
 756 #define __glGetTexParameterIuiv_size __gl_param_size
 757
 758 #define __glTexEnvfv_size __gl_param_size
 759 #define __glTexEnviv_size __gl_param_size
 760 #define __glGetTexEnvfv_size __gl_param_size
 761 #define __glGetTexEnviv_size __gl_param_size
 762
 763 #define __glTexGendv_size __gl_param_size
 764 #define __glTexGenfv_size __gl_param_size
 765 #define __glTexGeniv_size __gl_param_size
 766 #define __glGetTexGendv_size __gl_param_size
 767 #define __glGetTexGenfv_size __gl_param_size
 768 #define __glGetTexGeniv_size __gl_param_size
 769
 770 #define __glTexImage3D_size(format, type, width, height, depth) __gl_image_size(format, type, width, height, depth)
 771 #define __glTexImage2D_size(format, type, width, height)        __gl_image_size(format, type, width, height, 1)
 772 #define __glTexImage1D_size(format, type, width)                __gl_image_size(format, type, width, 1, 1)
 773
 774 #define __glTexSubImage3D_size(format, type, width, height, depth) __glTexImage3D_size(format, type, width, height, depth)
 775 #define __glTexSubImage2D_size(format, type, width, height)        __glTexImage2D_size(format, type, width, height)
 776 #define __glTexSubImage1D_size(format, type, width)                __glTexImage1D_size(format, type, width)
 777
 778 #define __glTexImage3DEXT_size __glTexImage3D_size
 779 #define __glTexImage2DEXT_size __glTexImage2D_size
 780 #define __glTexImage1DEXT_size __glTexImage1D_size
 781 #define __glTexSubImage3DEXT_size __glTexSubImage3D_size
 782 #define __glTexSubImage2DEXT_size __glTexSubImage2D_size
 783 #define __glTexSubImage1DEXT_size __glTexSubImage1D_size
 784
 785 #define __glTextureImage3DEXT_size __glTexImage3D_size
 786 #define __glTextureImage2DEXT_size __glTexImage2D_size
 787 #define __glTextureImage1DEXT_size __glTexImage1D_size
 788 #define __glTextureSubImage3DEXT_size __glTexSubImage3D_size
 789 #define __glTextureSubImage2DEXT_size __glTexSubImage2D_size
 790 #define __glTextureSubImage1DEXT_size __glTexSubImage1D_size
 791
 792 #define __glMultiTexImage3DEXT_size __glTexImage3D_size
 793 #define __glMultiTexImage2DEXT_size __glTexImage2D_size
 794 #define __glMultiTexImage1DEXT_size __glTexImage1D_size
 795 #define __glMultiTexSubImage3DEXT_size __glTexSubImage3D_size
 796 #define __glMultiTexSubImage2DEXT_size __glTexSubImage2D_size
 797 #define __glMultiTexSubImage1DEXT_size __glTexSubImage1D_size
 798
 799 #define __glDrawPixels_size(format, type, width, height) __glTexImage2D_size(format, type, width, height)
 800 #define __glConvolutionFilter1D_size(format, type, width) __glTexImage1D_size(format, type, width)
 801 #define __glConvolutionFilter2D_size(format, type, width, height) __glTexImage2D_size(format, type, width, height)
 802 #define __glColorTable_size(format, type, width) __glTexImage1D_size(format, type, width)
 803 #define __glColorSubTable_size(format, type, count) __glColorTable_size(format, type, count)
 804
 805 #define __glBitmap_size(width, height) __glTexImage2D_size(GL_COLOR_INDEX, GL_BITMAP, width, height)
 806 #define __glPolygonStipple_size() __glBitmap_size(32, 32)
 807
 808 static inline size_t
 809 __glClearBuffer_size(GLenum buffer)
 810 {
 811     switch (buffer) {
 812     case GL_COLOR:
 813     case GL_FRONT:
 814     case GL_BACK:
 815     case GL_LEFT:
 816     case GL_RIGHT:
 817     case GL_FRONT_AND_BACK:
 818         return 4;
 819     case GL_DEPTH:
 820     case GL_STENCIL:
 821         return 1;
 822     default:
 823         OS::DebugMessage("apitrace: warning: %s: unexpected buffer GLenum 0x%04X\n", __FUNCTION__, buffer);
 824         return 0;
 825     }
 826 }
 827
 828 /*
 829  * 0 terminated integer/float attribute list.
 830  */
 831 template<class T>
 832 static inline size_t
 833 __AttribList_size(const T *pAttribList)
 834 {
 835     size_t size = 0;
 836
 837     if (pAttribList) {
 838         do {
 839             ++size;
 840         } while (*pAttribList++);
 841     }
 842
 843     return size;
 844 }
 845
 846
 847 #endif /* _GL_SIZE_HPP_ */