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

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