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 "os.hpp"
  38 #include "glimports.hpp"
  39
  40
  41 static inline size_t
  42 __gl_type_size(GLenum type)
  43 {
  44     switch (type) {
  45     case GL_BOOL:
  46     case GL_BYTE:
  47     case GL_UNSIGNED_BYTE:
  48         return 1;
  49     case GL_SHORT:
  50     case GL_UNSIGNED_SHORT:
  51     case GL_2_BYTES:
  52     case GL_HALF_FLOAT:
  53         return 2;
  54     case GL_3_BYTES:
  55         return 3;
  56     case GL_INT:
  57     case GL_UNSIGNED_INT:
  58     case GL_FLOAT:
  59     case GL_4_BYTES:
  60         return 4;
  61     case GL_DOUBLE:
  62         return 8;
  63     default:
  64         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
  65         return 0;
  66     }
  67 }
  68
  69 static inline size_t
  70 __glArrayPointer_size(GLint size, GLenum type, GLsizei stride, GLsizei maxIndex)
  71 {
  72     size_t elementSize = size*__gl_type_size(type);
  73     if (!stride) {
  74         stride = (GLsizei)elementSize;
  75     }
  76     return stride*maxIndex + elementSize;
  77 }
  78
  79 #define __glVertexPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
  80 #define __glNormalPointer_size(type, stride, maxIndex) __glArrayPointer_size(3, type, stride, maxIndex)
  81 #define __glColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
  82 #define __glIndexPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex)
  83 #define __glTexCoordPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
  84 #define __glEdgeFlagPointer_size(stride, maxIndex) __glArrayPointer_size(1, GL_BOOL, stride, maxIndex)
  85 #define __glFogCoordPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex)
  86 #define __glSecondaryColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
  87 #define __glVertexAttribPointer_size(size, type, normalized, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
  88
  89 static inline GLuint
  90 __glDrawArrays_maxindex(GLint first, GLsizei count)
  91 {
  92     if (!count) {
  93         return 0;
  94     }
  95     return first + count - 1;
  96 }
  97
  98 static inline GLuint
  99 __glDrawElements_maxindex(GLsizei count, GLenum type, const GLvoid *indices)
 100 {
 101     GLvoid *temp = 0;
 102     GLint __element_array_buffer = 0;
 103
 104     if (!count) {
 105         return 0;
 106     }
 107     __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);
 108     if (__element_array_buffer) {
 109         // Read indices from index buffer object
 110         GLintptr offset = (GLintptr)indices;
 111         GLsizeiptr size = count*__gl_type_size(type);
 112         GLvoid *temp = malloc(size);
 113         if (!temp) {
 114             return 0;
 115         }
 116         memset(temp, 0, size);
 117         __glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, temp);
 118         indices = temp;
 119     } else {
 120         if (!indices) {
 121             return 0;
 122         }
 123     }
 124
 125     GLuint maxindex = 0;
 126     GLsizei i;
 127     if (type == GL_UNSIGNED_BYTE) {
 128         const GLubyte *p = (const GLubyte *)indices;
 129         for (i = 0; i < count; ++i) {
 130             if (p[i] > maxindex) {
 131                 maxindex = p[i];
 132             }
 133         }
 134     } else if (type == GL_UNSIGNED_SHORT) {
 135         const GLushort *p = (const GLushort *)indices;
 136         for (i = 0; i < count; ++i) {
 137             if (p[i] > maxindex) {
 138                 maxindex = p[i];
 139             }
 140         }
 141     } else if (type == GL_UNSIGNED_INT) {
 142         const GLuint *p = (const GLuint *)indices;
 143         for (i = 0; i < count; ++i) {
 144             if (p[i] > maxindex) {
 145                 maxindex = p[i];
 146             }
 147         }
 148     } else {
 149         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
 150     }
 151
 152     if (__element_array_buffer) {
 153         free(temp);
 154     }
 155
 156     return maxindex;
 157 }
 158
 159 static inline GLuint
 160 __glDrawRangeElements_maxindex(GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)
 161 {
 162     (void)start;
 163     (void)end;
 164     return __glDrawElements_maxindex(count, type, indices);
 165 }
 166
 167 static inline size_t
 168 __glCallLists_size(GLsizei n, GLenum type)
 169 {
 170     return n*__gl_type_size(type);
 171 }
 172
 173 #define __glFogfv_size pname_size
 174 #define __glFogiv_size pname_size
 175
 176 #define __glLightfv_size pname_size
 177 #define __glLightiv_size pname_size
 178
 179 #define __glLightModelfv_size pname_size
 180 #define __glLightModeliv_size __glLightModelfv_size
 181
 182 #define __glMaterialfv_size pname_size
 183 #define __glMaterialiv_size __glMaterialfv_size
 184
 185 #define __glTexParameterfv_size pname_size
 186 #define __glTexParameteriv_size __glTexParameterfv_size
 187
 188 #define __glTexEnvfv_size pname_size
 189 #define __glTexEnviv_size __glTexEnvfv_size
 190
 191 #define __glTexGendv_size pname_size
 192 #define __glTexGenfv_size __glTexGendv_size
 193 #define __glTexGeniv_size __glTexGendv_size
 194
 195 static inline size_t
 196 __glMap1d_size(GLenum pname)
 197 {
 198     switch (pname) {
 199     case GL_MAP1_INDEX:
 200     case GL_MAP1_TEXTURE_COORD_1:
 201         return 1;
 202     case GL_MAP1_TEXTURE_COORD_2:
 203         return 2;
 204     case GL_MAP1_NORMAL:
 205     case GL_MAP1_TEXTURE_COORD_3:
 206     case GL_MAP1_VERTEX_3:
 207         return 3;
 208     case GL_MAP1_COLOR_4:
 209     case GL_MAP1_TEXTURE_COORD_4:
 210     case GL_MAP1_VERTEX_4:
 211         return 4;
 212     default:
 213         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);
 214         return 1;
 215     }
 216 }
 217
 218 #define __glMap1f_size __glMap1d_size
 219
 220 static inline size_t
 221 __glMap2d_size(GLenum pname)
 222 {
 223     switch (pname) {
 224     case GL_MAP2_INDEX:
 225     case GL_MAP2_TEXTURE_COORD_1:
 226         return 1;
 227     case GL_MAP2_TEXTURE_COORD_2:
 228         return 2;
 229     case GL_MAP2_NORMAL:
 230     case GL_MAP2_TEXTURE_COORD_3:
 231     case GL_MAP2_VERTEX_3:
 232         return 3;
 233     case GL_MAP2_COLOR_4:
 234     case GL_MAP2_TEXTURE_COORD_4:
 235     case GL_MAP2_VERTEX_4:
 236         return 4;
 237     default:
 238         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);
 239         return 1;
 240     }
 241 }
 242
 243 #define __glMap2f_size __glMap2d_size
 244
 245 #define __glGetBooleanv_size pname_size
 246 #define __glGetDoublev_size __glGetBooleanv_size
 247 #define __glGetFloatv_size __glGetBooleanv_size
 248 #define __glGetIntegerv_size __glGetBooleanv_size
 249 #define __glGetInteger64v_size __glGetBooleanv_size
 250
 251 #define __glGetLightfv_size __glLightfv_size
 252 #define __glGetLightiv_size __glLightfv_size
 253
 254 #define __glGetMaterialfv_size __glMaterialfv_size
 255 #define __glGetMaterialiv_size __glMaterialfv_size
 256
 257 #define __glGetTexEnvfv_size __glTexEnvfv_size
 258 #define __glGetTexEnviv_size __glTexEnvfv_size
 259
 260 #define __glGetTexGendv_size __glTexGendv_size
 261 #define __glGetTexGenfv_size __glTexGendv_size
 262 #define __glGetTexGeniv_size __glTexGendv_size
 263
 264 static inline size_t
 265 __glGetTexParameterfv_size(GLenum pname)
 266 {
 267     switch (pname) {
 268     case GL_TEXTURE_MAG_FILTER:
 269     case GL_TEXTURE_MIN_FILTER:
 270     case GL_TEXTURE_WRAP_S:
 271     case GL_TEXTURE_WRAP_T:
 272     case GL_TEXTURE_PRIORITY:
 273     case GL_TEXTURE_RESIDENT:
 274     case GL_TEXTURE_WRAP_R:
 275     case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
 276 /*  case GL_SHADOW_AMBIENT_SGIX:*/
 277     case GL_TEXTURE_MIN_LOD:
 278     case GL_TEXTURE_MAX_LOD:
 279     case GL_TEXTURE_BASE_LEVEL:
 280     case GL_TEXTURE_MAX_LEVEL:
 281     case GL_TEXTURE_CLIPMAP_FRAME_SGIX:
 282     case GL_TEXTURE_LOD_BIAS_S_SGIX:
 283     case GL_TEXTURE_LOD_BIAS_T_SGIX:
 284     case GL_TEXTURE_LOD_BIAS_R_SGIX:
 285     case GL_GENERATE_MIPMAP:
 286 /*  case GL_GENERATE_MIPMAP_SGIS:*/
 287     case GL_TEXTURE_COMPARE_SGIX:
 288     case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
 289     case GL_TEXTURE_MAX_CLAMP_S_SGIX:
 290     case GL_TEXTURE_MAX_CLAMP_T_SGIX:
 291     case GL_TEXTURE_MAX_CLAMP_R_SGIX:
 292     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
 293     case GL_TEXTURE_LOD_BIAS:
 294 /*  case GL_TEXTURE_LOD_BIAS_EXT:*/
 295     case GL_TEXTURE_RANGE_LENGTH_APPLE:
 296     case GL_TEXTURE_STORAGE_HINT_APPLE:
 297     case GL_DEPTH_TEXTURE_MODE:
 298 /*  case GL_DEPTH_TEXTURE_MODE_ARB:*/
 299     case GL_TEXTURE_COMPARE_MODE:
 300 /*  case GL_TEXTURE_COMPARE_MODE_ARB:*/
 301     case GL_TEXTURE_COMPARE_FUNC:
 302 /*  case GL_TEXTURE_COMPARE_FUNC_ARB:*/
 303     case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
 304         return 1;
 305     case GL_TEXTURE_CLIPMAP_CENTER_SGIX:
 306     case GL_TEXTURE_CLIPMAP_OFFSET_SGIX:
 307         return 2;
 308     case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX:
 309         return 3;
 310     case GL_TEXTURE_BORDER_COLOR:
 311     case GL_POST_TEXTURE_FILTER_BIAS_SGIX:
 312     case GL_POST_TEXTURE_FILTER_SCALE_SGIX:
 313         return 4;
 314     default:
 315         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);
 316         return 1;
 317     }
 318 }
 319
 320 #define __glGetTexParameterfv_size pname_size
 321 #define __glGetTexParameteriv_size __glGetTexParameterfv_size
 322
 323 #define __glGetTexLevelParameterfv_size pname_size
 324 #define __glGetTexLevelParameteriv_size __glGetTexLevelParameterfv_size
 325
 326 #define __glColorTableParameterfv_size pname_size
 327 #define __glColorTableParameteriv_size pname_size
 328 #define __glGetColorTableParameterfv_size pname_size
 329 #define __glGetColorTableParameteriv_size pname_size
 330
 331 #define __glConvolutionParameterfv_size pname_size
 332 #define __glConvolutionParameteriv_size pname_size
 333 #define __glGetConvolutionParameterfv_size pname_size
 334 #define __glGetConvolutionParameteriv_size pname_size
 335
 336 #define __glGetHistogramParameterfv_size pname_size
 337 #define __glGetHistogramParameteriv_size pname_size
 338
 339 #define __glGetMinmaxParameterfv_size pname_size
 340 #define __glGetMinmaxParameteriv_size pname_size
 341
 342 #define __glGetProgramivARB_size pname_size
 343 #define __glGetProgramivNV_size pname_size
 344
 345 #define __glGetVertexAttribdvARB_size pname_size
 346 #define __glGetVertexAttribfvARB_size pname_size
 347 #define __glGetVertexAttribivARB_size pname_size
 348 #define __glGetVertexAttribdvNV_size pname_size
 349 #define __glGetVertexAttribfvNV_size pname_size
 350 #define __glGetVertexAttribivNV_size pname_size
 351
 352 #define __glGetQueryObjectivARB_size pname_size
 353 #define __glGetQueryObjectuivARB_size __glGetQueryObjectivARB_size
 354 #define __glGetQueryivARB_size pname_size
 355
 356 #define __glPointParameterfv_size __glPointParameterfvEXT_size
 357 #define __glPointParameteriv_size __glPointParameterfvEXT_size
 358 #define __glPointParameterfvARB_size __glPointParameterfvEXT_size
 359 #define __glPointParameterfvEXT_size pname_size
 360 #define __glPointParameterivNV_size __glPointParameterfvEXT_size
 361
 362 #define __glGetFramebufferAttachmentParameteriv_size pname_size
 363 #define __glGetFramebufferAttachmentParameterivEXT_size pname_size
 364
 365 static inline size_t
 366 __gl_format_channels(GLenum format) {
 367     switch (format) {
 368     case GL_COLOR_INDEX:
 369     case GL_RED:
 370     case GL_GREEN:
 371     case GL_BLUE:
 372     case GL_ALPHA:
 373     case GL_INTENSITY:
 374     case GL_LUMINANCE:
 375     case GL_DEPTH_COMPONENT:
 376     case GL_STENCIL_INDEX:
 377         return 1;
 378     case GL_DEPTH_STENCIL:
 379     case GL_LUMINANCE_ALPHA:
 380     case GL_RG:
 381         return 2;
 382     case GL_RGB:
 383     case GL_BGR:
 384         return 3;
 385     case GL_RGBA:
 386     case GL_BGRA:
 387         return 4;
 388     default:
 389         OS::DebugMessage("warning: %s: unexpected format GLenum 0x%04X\n", __FUNCTION__, format);
 390         return 0;
 391     }
 392 }
 393
 394 static inline size_t
 395 __glTexImage3D_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth, GLint border) {
 396     size_t num_channels = __gl_format_channels(format);
 397
 398     size_t bits_per_pixel;
 399     switch (type) {
 400     case GL_BITMAP:
 401         bits_per_pixel = 1;
 402         break;
 403     case GL_BYTE:
 404     case GL_UNSIGNED_BYTE:
 405         bits_per_pixel = 8 * num_channels;
 406         break;
 407     case GL_SHORT:
 408     case GL_UNSIGNED_SHORT:
 409     case GL_HALF_FLOAT:
 410         bits_per_pixel = 16 * num_channels;
 411         break;
 412     case GL_INT:
 413     case GL_UNSIGNED_INT:
 414     case GL_FLOAT:
 415         bits_per_pixel = 32 * num_channels;
 416         break;
 417     case GL_UNSIGNED_BYTE_3_3_2:
 418     case GL_UNSIGNED_BYTE_2_3_3_REV:
 419         bits_per_pixel = 8;
 420         break;
 421     case GL_UNSIGNED_SHORT_4_4_4_4:
 422     case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 423     case GL_UNSIGNED_SHORT_5_5_5_1:
 424     case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 425     case GL_UNSIGNED_SHORT_5_6_5:
 426     case GL_UNSIGNED_SHORT_5_6_5_REV:
 427     case GL_UNSIGNED_SHORT_8_8_MESA:
 428     case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 429         bits_per_pixel = 16;
 430         break;
 431     case GL_UNSIGNED_INT_8_8_8_8:
 432     case GL_UNSIGNED_INT_8_8_8_8_REV:
 433     case GL_UNSIGNED_INT_10_10_10_2:
 434     case GL_UNSIGNED_INT_2_10_10_10_REV:
 435     case GL_UNSIGNED_INT_24_8:
 436     case GL_UNSIGNED_INT_10F_11F_11F_REV:
 437     case GL_UNSIGNED_INT_5_9_9_9_REV:
 438     case GL_UNSIGNED_INT_S8_S8_8_8_NV:
 439     case GL_UNSIGNED_INT_8_8_S8_S8_REV_NV:
 440         bits_per_pixel = 32;
 441         break;
 442     case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 443         bits_per_pixel = 64;
 444         break;
 445     default:
 446         OS::DebugMessage("warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type);
 447         bits_per_pixel = 0;
 448         break;
 449     }
 450
 451     /* FIXME: consider glPixelStore settings */
 452
 453     size_t row_stride = (width*bits_per_pixel + 7)/8;
 454
 455     size_t slice_stride = height*row_stride;
 456
 457     return depth*slice_stride;
 458 }
 459
 460 #define __glTexImage2D_size(format, type, width, height, border) __glTexImage3D_size(format, type, width, height, 1, border)
 461 #define __glTexImage1D_size(format, type, width, border)         __glTexImage3D_size(format, type, width, 1, 1, border)
 462
 463 #define __glTexSubImage3D_size(format, type, width, height, depth) __glTexImage3D_size(format, type, width, height, depth, 0)
 464 #define __glTexSubImage2D_size(format, type, width, height)        __glTexImage2D_size(format, type, width, height, 0)
 465 #define __glTexSubImage1D_size(format, type, width)                __glTexImage1D_size(format, type, width, 0)
 466
 467 #define __glTexImage3DEXT_size __glTexImage3D_size
 468 #define __glTexImage2DEXT_size __glTexImage2D_size
 469 #define __glTexImage1DEXT_size __glTexImage1D_size
 470 #define __glTexSubImage3DEXT_size __glTexSubImage3D_size
 471 #define __glTexSubImage2DEXT_size __glTexSubImage2D_size
 472 #define __glTexSubImage1DEXT_size __glTexSubImage1D_size
 473
 474 #define __glDrawPixels_size(format, type, width, height) __glTexImage2D_size(format, type, width, height, 0)
 475
 476 #define __glBitmap_size(width, height) __glTexImage2D_size(GL_COLOR_INDEX, GL_BITMAP, width, height, 0)
 477 #define __glPolygonStipple_size() __glBitmap_size(32, 32)
 478
 479
 480 /*
 481  * 0 terminated integer/float attribute list.
 482  */
 483 template<class T>
 484 static inline size_t
 485 __AttribList_size(const T *pAttribList)
 486 {
 487     size_t size = 0;
 488
 489     if (pAttribList) {
 490         do {
 491             ++size;
 492         } while (*pAttribList++);
 493     }
 494
 495     return size;
 496 }
 497
 498
 499 #endif /* _GL_SIZE_HPP_ */