X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=glsize.hpp;h=d81cdf1fe6071db14ac6853b6d4a3a5fa3405d62;hb=0ac5c0605a089790c33dfb3924edf04df39c5412;hp=a897c464b6671e79ea2176661567d0237c07c79a;hpb=f4aca5d5fa2785bef21f75faa0be08b51bd1d183;p=apitrace diff --git a/glsize.hpp b/glsize.hpp index a897c46..d81cdf1 100644 --- a/glsize.hpp +++ b/glsize.hpp @@ -1,5 +1,6 @@ /************************************************************************** * + * Copyright 2011 Jose Fonseca * Copyright 2010 VMware, Inc. * Copyright 2004 IBM Corporation * All Rights Reserved. @@ -34,6 +35,8 @@ #define _GL_SIZE_HPP_ +#include + #include "os.hpp" #include "glimports.hpp" @@ -57,15 +60,222 @@ __gl_type_size(GLenum type) case GL_UNSIGNED_INT: case GL_FLOAT: case GL_4_BYTES: + case GL_FIXED: return 4; case GL_DOUBLE: return 8; default: - OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type); + os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type); return 0; } } +static inline void +__gl_uniform_size(GLenum type, GLenum &elemType, GLint &numElems) { + switch (type) { + case GL_FLOAT: + elemType = GL_FLOAT; + numElems = 1; + break; + case GL_FLOAT_VEC2: + elemType = GL_FLOAT; + numElems = 2; + break; + case GL_FLOAT_VEC3: + elemType = GL_FLOAT; + numElems = 3; + break; + case GL_FLOAT_VEC4: + elemType = GL_FLOAT; + numElems = 4; + break; + case GL_DOUBLE: + elemType = GL_DOUBLE; + numElems = 1; + break; + case GL_DOUBLE_VEC2: + elemType = GL_DOUBLE; + numElems = 2; + break; + case GL_DOUBLE_VEC3: + elemType = GL_DOUBLE; + numElems = 3; + break; + case GL_DOUBLE_VEC4: + elemType = GL_DOUBLE; + numElems = 4; + break; + case GL_INT: + elemType = GL_INT; + numElems = 1; + break; + case GL_INT_VEC2: + elemType = GL_INT; + numElems = 2; + break; + case GL_INT_VEC3: + elemType = GL_INT; + numElems = 3; + break; + case GL_INT_VEC4: + elemType = GL_INT; + numElems = 4; + break; + case GL_UNSIGNED_INT: + elemType = GL_UNSIGNED_INT; + numElems = 1; + break; + case GL_UNSIGNED_INT_VEC2: + elemType = GL_UNSIGNED_INT; + numElems = 2; + break; + case GL_UNSIGNED_INT_VEC3: + elemType = GL_UNSIGNED_INT; + numElems = 3; + break; + case GL_UNSIGNED_INT_VEC4: + elemType = GL_UNSIGNED_INT; + numElems = 4; + break; + case GL_BOOL: + elemType = GL_BOOL; + numElems = 1; + break; + case GL_BOOL_VEC2: + elemType = GL_BOOL; + numElems = 2; + break; + case GL_BOOL_VEC3: + elemType = GL_BOOL; + numElems = 3; + break; + case GL_BOOL_VEC4: + elemType = GL_BOOL; + numElems = 4; + break; + case GL_FLOAT_MAT2: + elemType = GL_FLOAT; + numElems = 2*2; + break; + case GL_FLOAT_MAT3: + elemType = GL_FLOAT; + numElems = 3*3; + break; + case GL_FLOAT_MAT4: + elemType = GL_FLOAT; + numElems = 4*4; + break; + case GL_FLOAT_MAT2x3: + elemType = GL_FLOAT; + numElems = 2*3; + break; + case GL_FLOAT_MAT2x4: + elemType = GL_FLOAT; + numElems = 2*4; + break; + case GL_FLOAT_MAT3x2: + elemType = GL_FLOAT; + numElems = 3*2; + break; + case GL_FLOAT_MAT3x4: + elemType = GL_FLOAT; + numElems = 3*4; + break; + case GL_FLOAT_MAT4x2: + elemType = GL_FLOAT; + numElems = 4*2; + break; + case GL_FLOAT_MAT4x3: + elemType = GL_FLOAT; + numElems = 4*3; + break; + case GL_DOUBLE_MAT2: + elemType = GL_DOUBLE; + numElems = 2*2; + break; + case GL_DOUBLE_MAT3: + elemType = GL_DOUBLE; + numElems = 3*3; + break; + case GL_DOUBLE_MAT4: + elemType = GL_DOUBLE; + numElems = 4*4; + break; + case GL_DOUBLE_MAT2x3: + elemType = GL_DOUBLE; + numElems = 2*3; + break; + case GL_DOUBLE_MAT2x4: + elemType = GL_DOUBLE; + numElems = 2*4; + break; + case GL_DOUBLE_MAT3x2: + elemType = GL_DOUBLE; + numElems = 3*2; + break; + case GL_DOUBLE_MAT3x4: + elemType = GL_DOUBLE; + numElems = 3*4; + break; + case GL_DOUBLE_MAT4x2: + elemType = GL_DOUBLE; + numElems = 4*2; + break; + case GL_DOUBLE_MAT4x3: + elemType = GL_DOUBLE; + numElems = 4*3; + break; + case GL_SAMPLER_1D: + case GL_SAMPLER_2D: + case GL_SAMPLER_3D: + case GL_SAMPLER_CUBE: + case GL_SAMPLER_1D_SHADOW: + case GL_SAMPLER_2D_SHADOW: + case GL_SAMPLER_1D_ARRAY: + case GL_SAMPLER_2D_ARRAY: + case GL_SAMPLER_CUBE_MAP_ARRAY: + case GL_SAMPLER_1D_ARRAY_SHADOW: + case GL_SAMPLER_2D_ARRAY_SHADOW: + case GL_SAMPLER_2D_MULTISAMPLE: + case GL_SAMPLER_2D_MULTISAMPLE_ARRAY: + case GL_SAMPLER_CUBE_SHADOW: + case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW: + case GL_SAMPLER_BUFFER: + case GL_SAMPLER_2D_RECT: + case GL_SAMPLER_2D_RECT_SHADOW: + case GL_INT_SAMPLER_1D: + case GL_INT_SAMPLER_2D: + case GL_INT_SAMPLER_3D: + case GL_INT_SAMPLER_CUBE: + case GL_INT_SAMPLER_1D_ARRAY: + case GL_INT_SAMPLER_2D_ARRAY: + case GL_INT_SAMPLER_CUBE_MAP_ARRAY: + case GL_INT_SAMPLER_2D_MULTISAMPLE: + case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: + case GL_INT_SAMPLER_BUFFER: + case GL_INT_SAMPLER_2D_RECT: + case GL_UNSIGNED_INT_SAMPLER_1D: + case GL_UNSIGNED_INT_SAMPLER_2D: + case GL_UNSIGNED_INT_SAMPLER_3D: + case GL_UNSIGNED_INT_SAMPLER_CUBE: + case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: + case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: + case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: + case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: + case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: + case GL_UNSIGNED_INT_SAMPLER_BUFFER: + case GL_UNSIGNED_INT_SAMPLER_2D_RECT: + elemType = GL_INT; + numElems = 1; + break; + default: + os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type); + elemType = GL_NONE; + numElems = 0; + return; + } +} + static inline size_t __glArrayPointer_size(GLint size, GLenum type, GLsizei stride, GLsizei maxIndex) { @@ -85,6 +295,8 @@ __glArrayPointer_size(GLint size, GLenum type, GLsizei stride, GLsizei maxIndex) #define __glFogCoordPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex) #define __glSecondaryColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex) #define __glVertexAttribPointer_size(size, type, normalized, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex) +#define __glVertexAttribPointerARB_size(size, type, normalized, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex) +#define __glVertexAttribPointerNV_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex) static inline GLuint __glDrawArrays_maxindex(GLint first, GLsizei count) @@ -98,7 +310,7 @@ __glDrawArrays_maxindex(GLint first, GLsizei count) #define __glDrawArraysEXT_maxindex __glDrawArrays_maxindex static inline GLuint -__glDrawElements_maxindex(GLsizei count, GLenum type, const GLvoid *indices) +__glDrawElementsBaseVertex_maxindex(GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex) { GLvoid *temp = 0; GLint __element_array_buffer = 0; @@ -106,6 +318,7 @@ __glDrawElements_maxindex(GLsizei count, GLenum type, const GLvoid *indices) if (!count) { return 0; } + __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer); if (__element_array_buffer) { // Read indices from index buffer object @@ -148,148 +361,178 @@ __glDrawElements_maxindex(GLsizei count, GLenum type, const GLvoid *indices) } } } else { - OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type); + os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type); } if (__element_array_buffer) { free(temp); } + maxindex += basevertex; + return maxindex; } +#define __glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex) + +#define __glDrawElements_maxindex(count, type, indices) __glDrawElementsBaseVertex_maxindex(count, type, indices, 0); +#define __glDrawRangeElements_maxindex(start, end, count, type, indices) __glDrawElements_maxindex(count, type, indices) +#define __glDrawRangeElementsEXT_maxindex __glDrawRangeElements_maxindex + +/* FIXME take in consideration instancing */ +#define __glDrawArraysInstanced_maxindex(first, count, primcount) __glDrawArrays_maxindex(first, count) +#define __glDrawElementsInstanced_maxindex(count, type, indices, primcount) __glDrawElements_maxindex(count, type, indices) +#define __glDrawElementsInstancedBaseVertex_maxindex(count, type, indices, primcount, basevertex) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex) +#define __glDrawRangeElementsInstanced_maxindex(start, end, count, type, indices, primcount) __glDrawRangeElements_maxindex(start, end, count, type, indices) +#define __glDrawRangeElementsInstancedBaseVertex_maxindex(start, end, count, type, indices, primcount, basevertex) __glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex) + +#define __glDrawArraysInstancedBaseInstance_maxindex(first, count, primcount, baseinstance) __glDrawArrays_maxindex(first, count) +#define __glDrawElementsInstancedBaseInstance_maxindex(count, type, indices, primcount, baseinstance) __glDrawElements_maxindex(count, type, indices) +#define __glDrawElementsInstancedBaseVertexBaseInstance_maxindex(count, type, indices, primcount, basevertex, baseinstance) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex) + +#define __glDrawArraysInstancedARB_maxindex __glDrawArraysInstanced_maxindex +#define __glDrawElementsInstancedARB_maxindex __glDrawElementsInstanced_maxindex +#define __glDrawArraysInstancedEXT_maxindex __glDrawArraysInstanced_maxindex +#define __glDrawElementsInstancedEXT_maxindex __glDrawElementsInstanced_maxindex + static inline GLuint -__glDrawRangeElements_maxindex(GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices) -{ - (void)start; - (void)end; - return __glDrawElements_maxindex(count, type, indices); +__glDrawArraysIndirect_maxindex(const GLvoid *indirect) { + os::log("apitrace: warning: %s: unsupported\n", __FUNCTION__); + return 0; } -#define __glDrawRangeElementsEXT_maxindex __glDrawRangeElements_maxindex +static inline GLuint +__glDrawElementsIndirect_maxindex(GLenum type, const GLvoid *indirect) { + os::log("apitrace: warning: %s: unsupported\n", __FUNCTION__); + return 0; +} -static inline size_t -__glCallLists_size(GLsizei n, GLenum type) -{ - return n*__gl_type_size(type); +static inline GLuint +__glMultiDrawArrays_maxindex(const GLint *first, const GLsizei *count, GLsizei primcount) { + GLuint maxindex = 0; + for (GLsizei prim = 0; prim < primcount; ++prim) { + GLuint maxindex_prim = __glDrawArrays_maxindex(first[prim], count[prim]); + maxindex = std::max(maxindex, maxindex_prim); + } + return maxindex; } -#define __glFogfv_size __gl_param_size -#define __glFogiv_size __gl_param_size +static inline GLuint +__glMultiDrawElements_maxindex(const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) { + GLuint maxindex = 0; + for (GLsizei prim = 0; prim < primcount; ++prim) { + GLuint maxindex_prim = __glDrawElements_maxindex(count[prim], type, indices[prim]); + maxindex = std::max(maxindex, maxindex_prim); + } + return maxindex; +} -#define __glLightfv_size __gl_param_size -#define __glLightiv_size __gl_param_size +static inline GLuint +__glMultiDrawElementsBaseVertex_maxindex(const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, const GLint * basevertex) { + GLuint maxindex = 0; + for (GLsizei prim = 0; prim < primcount; ++prim) { + GLuint maxindex_prim = __glDrawElementsBaseVertex_maxindex(count[prim], type, indices[prim], basevertex[prim]); + maxindex = std::max(maxindex, maxindex_prim); + } + return maxindex; +} -#define __glLightModelfv_size __gl_param_size -#define __glLightModeliv_size __glLightModelfv_size +#define __glMultiDrawArraysEXT_maxindex __glMultiDrawArrays_maxindex +#define __glMultiDrawElementsEXT_maxindex __glMultiDrawElements_maxindex -#define __glMaterialfv_size __gl_param_size -#define __glMaterialiv_size __glMaterialfv_size +#define __glMultiModeDrawArraysIBM_maxindex(first, count, primcount, modestride) __glMultiDrawArrays_maxindex(first, count, primcount) +#define __glMultiModeDrawElementsIBM_maxindex(count, type, indices, primcount, modestride) __glMultiDrawElements_maxindex(count, type, (const GLvoid **)indices, primcount) static inline size_t -__glMap1d_size(GLenum pname) +__glCallLists_size(GLsizei n, GLenum type) +{ + return n*__gl_type_size(type); +} + +static inline size_t +__glMap1d_size(GLenum target, GLint stride, GLint order) { - switch (pname) { + if (order < 1) { + return 0; + } + + GLint channels; + switch (target) { case GL_MAP1_INDEX: case GL_MAP1_TEXTURE_COORD_1: - return 1; + channels = 1; + break; case GL_MAP1_TEXTURE_COORD_2: - return 2; + channels = 2; + break; case GL_MAP1_NORMAL: case GL_MAP1_TEXTURE_COORD_3: case GL_MAP1_VERTEX_3: - return 3; + channels = 3; + break; case GL_MAP1_COLOR_4: case GL_MAP1_TEXTURE_COORD_4: case GL_MAP1_VERTEX_4: - return 4; + channels = 4; + break; default: - OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname); - return 1; + os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target); + return 0; + } + + if (stride < channels) { + return 0; } + + return channels + stride * (order - 1); } #define __glMap1f_size __glMap1d_size static inline size_t -__glMap2d_size(GLenum pname) +__glMap2d_size(GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder) { - switch (pname) { + if (uorder < 1 || vorder < 1) { + return 0; + } + + GLint channels; + switch (target) { case GL_MAP2_INDEX: case GL_MAP2_TEXTURE_COORD_1: - return 1; + channels = 1; + break; case GL_MAP2_TEXTURE_COORD_2: - return 2; + channels = 2; + break; case GL_MAP2_NORMAL: case GL_MAP2_TEXTURE_COORD_3: case GL_MAP2_VERTEX_3: - return 3; + channels = 3; + break; case GL_MAP2_COLOR_4: case GL_MAP2_TEXTURE_COORD_4: case GL_MAP2_VERTEX_4: - return 4; + channels = 4; + break; default: - OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname); - return 1; + os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target); + return 0; } -} - -#define __glMap2f_size __glMap2d_size - -#define __glGetBooleanv_size __gl_param_size -#define __glGetDoublev_size __glGetBooleanv_size -#define __glGetFloatv_size __glGetBooleanv_size -#define __glGetIntegerv_size __glGetBooleanv_size -#define __glGetInteger64v_size __glGetBooleanv_size -#define __glGetLightfv_size __glLightfv_size -#define __glGetLightiv_size __glLightfv_size - -#define __glGetMaterialfv_size __glMaterialfv_size -#define __glGetMaterialiv_size __glMaterialfv_size - - -#define __glColorTableParameterfv_size __gl_param_size -#define __glColorTableParameteriv_size __gl_param_size -#define __glGetColorTableParameterfv_size __gl_param_size -#define __glGetColorTableParameteriv_size __gl_param_size - -#define __glConvolutionParameterfv_size __gl_param_size -#define __glConvolutionParameteriv_size __gl_param_size -#define __glGetConvolutionParameterfv_size __gl_param_size -#define __glGetConvolutionParameteriv_size __gl_param_size - -#define __glGetHistogramParameterfv_size __gl_param_size -#define __glGetHistogramParameteriv_size __gl_param_size - -#define __glGetMinmaxParameterfv_size __gl_param_size -#define __glGetMinmaxParameteriv_size __gl_param_size - -#define __glGetProgramivARB_size __gl_param_size -#define __glGetProgramivNV_size __gl_param_size - -#define __glGetVertexAttribdvARB_size __gl_param_size -#define __glGetVertexAttribfvARB_size __gl_param_size -#define __glGetVertexAttribivARB_size __gl_param_size -#define __glGetVertexAttribdvNV_size __gl_param_size -#define __glGetVertexAttribfvNV_size __gl_param_size -#define __glGetVertexAttribivNV_size __gl_param_size - -#define __glGetQueryObjectivARB_size __gl_param_size -#define __glGetQueryObjectuivARB_size __glGetQueryObjectivARB_size -#define __glGetQueryivARB_size __gl_param_size + if (ustride < channels || vstride < channels) { + return 0; + } -#define __glPointParameterfv_size __glPointParameterfvEXT_size -#define __glPointParameteriv_size __glPointParameterfvEXT_size -#define __glPointParameterfvARB_size __glPointParameterfvEXT_size -#define __glPointParameterfvEXT_size __gl_param_size -#define __glPointParameterivNV_size __glPointParameterfvEXT_size + return channels + + ustride * (uorder - 1) + + vstride * (vorder - 1); +} -#define __glGetFramebufferAttachmentParameteriv_size __gl_param_size -#define __glGetFramebufferAttachmentParameterivEXT_size __gl_param_size +#define __glMap2f_size __glMap2d_size -static inline size_t +static inline unsigned __gl_format_channels(GLenum format) { switch (format) { case GL_COLOR_INDEX: @@ -305,24 +548,44 @@ __gl_format_channels(GLenum format) { case GL_DEPTH_STENCIL: case GL_LUMINANCE_ALPHA: case GL_RG: + case GL_HILO_NV: + case GL_DSDT_NV: return 2; case GL_RGB: case GL_BGR: + case GL_DSDT_MAG_NV: return 3; case GL_RGBA: case GL_BGRA: + case GL_ABGR_EXT: + case GL_CMYK_EXT: + case GL_DSDT_MAG_VIB_NV: return 4; + case GL_CMYKA_EXT: + return 5; default: - OS::DebugMessage("warning: %s: unexpected format GLenum 0x%04X\n", __FUNCTION__, format); + os::log("apitrace: warning: %s: unexpected format GLenum 0x%04X\n", __FUNCTION__, format); return 0; } } +template +static inline bool +_is_pot(X x) { + return (x & (x - 1)) == 0; +} + +template +static inline X +_align(X x, Y y) { + return (x + (y - 1)) & ~(y - 1); +} + static inline size_t -__gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth) { - size_t num_channels = __gl_format_channels(format); +__gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth, GLboolean has_unpack_subimage) { + unsigned num_channels = __gl_format_channels(format); - size_t bits_per_pixel; + unsigned bits_per_pixel; switch (type) { case GL_BITMAP: bits_per_pixel = 1; @@ -370,42 +633,61 @@ __gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsiz bits_per_pixel = 64; break; default: - OS::DebugMessage("warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type); + os::log("apitrace: warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type); bits_per_pixel = 0; break; } - /* FIXME: consider glPixelStore settings */ + GLint alignment = 4; + GLint row_length = 0; + GLint image_height = 0; + GLint skip_rows = 0; + GLint skip_pixels = 0; + GLint skip_images = 0; + + __glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment); + if (has_unpack_subimage) { + __glGetIntegerv(GL_UNPACK_ROW_LENGTH, &row_length); + __glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &image_height); + __glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skip_rows); + __glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skip_pixels); + __glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &skip_images); + } - size_t row_stride = (width*bits_per_pixel + 7)/8; + if (row_length <= 0) { + row_length = width; + } - size_t slice_stride = height*row_stride; + size_t row_stride = (row_length*bits_per_pixel + 7)/8; - return depth*slice_stride; + if ((GLint)bits_per_pixel < alignment*8 && + (bits_per_pixel & 7) == 0 && + _is_pot(bits_per_pixel)) { + row_stride = _align(row_stride, alignment); + } + + if (image_height <= 0) { + image_height = height; + } + + /* XXX: GL_UNPACK_IMAGE_HEIGHT and GL_UNPACK_SKIP_IMAGES should probably + * not be considered for pixel rectangles. */ + + size_t image_stride = image_height*row_stride; + + size_t size = depth*image_stride; + + size += (skip_pixels*bits_per_pixel + 7)/8; + size += skip_rows*row_stride; + size += skip_images*image_stride; + + return size; } -#define __glTexParameterfv_size __gl_param_size -#define __glTexParameteriv_size __gl_param_size -#define __glGetTexParameterfv_size __gl_param_size -#define __glGetTexParameteriv_size __gl_param_size -#define __glGetTexLevelParameterfv_size __gl_param_size -#define __glGetTexLevelParameteriv_size __gl_param_size - -#define __glTexEnvfv_size __gl_param_size -#define __glTexEnviv_size __gl_param_size -#define __glGetTexEnvfv_size __gl_param_size -#define __glGetTexEnviv_size __gl_param_size - -#define __glTexGendv_size __gl_param_size -#define __glTexGenfv_size __gl_param_size -#define __glTexGeniv_size __gl_param_size -#define __glGetTexGendv_size __gl_param_size -#define __glGetTexGenfv_size __gl_param_size -#define __glGetTexGeniv_size __gl_param_size - -#define __glTexImage3D_size(format, type, width, height, depth) __gl_image_size(format, type, width, height, depth) -#define __glTexImage2D_size(format, type, width, height) __gl_image_size(format, type, width, height, 1) -#define __glTexImage1D_size(format, type, width) __gl_image_size(format, type, width, 1, 1) +// note that can_unpack_subimage() is generated by gltrace.py +#define __glTexImage3D_size(format, type, width, height, depth) __gl_image_size(format, type, width, height, depth, can_unpack_subimage()) +#define __glTexImage2D_size(format, type, width, height) __gl_image_size(format, type, width, height, 1, can_unpack_subimage()) +#define __glTexImage1D_size(format, type, width) __gl_image_size(format, type, width, 1, 1, can_unpack_subimage()) #define __glTexSubImage3D_size(format, type, width, height, depth) __glTexImage3D_size(format, type, width, height, depth) #define __glTexSubImage2D_size(format, type, width, height) __glTexImage2D_size(format, type, width, height) @@ -433,24 +715,68 @@ __gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsiz #define __glMultiTexSubImage1DEXT_size __glTexSubImage1D_size #define __glDrawPixels_size(format, type, width, height) __glTexImage2D_size(format, type, width, height) +#define __glConvolutionFilter1D_size(format, type, width) __glTexImage1D_size(format, type, width) +#define __glConvolutionFilter2D_size(format, type, width, height) __glTexImage2D_size(format, type, width, height) +#define __glColorTable_size(format, type, width) __glTexImage1D_size(format, type, width) +#define __glColorSubTable_size(format, type, count) __glColorTable_size(format, type, count) #define __glBitmap_size(width, height) __glTexImage2D_size(GL_COLOR_INDEX, GL_BITMAP, width, height) #define __glPolygonStipple_size() __glBitmap_size(32, 32) +static inline size_t +__glClearBuffer_size(GLenum buffer) +{ + switch (buffer) { + case GL_COLOR: + case GL_FRONT: + case GL_BACK: + case GL_LEFT: + case GL_RIGHT: + case GL_FRONT_AND_BACK: + return 4; + case GL_DEPTH: + case GL_STENCIL: + return 1; + default: + os::log("apitrace: warning: %s: unexpected buffer GLenum 0x%04X\n", __FUNCTION__, buffer); + return 0; + } +} /* - * 0 terminated integer/float attribute list. + * attribute list, terminated by the given terminator. */ template static inline size_t -__AttribList_size(const T *pAttribList) +__AttribList_size(const T *pAttribList, const T terminator = static_cast(0)) { size_t size = 0; if (pAttribList) { do { ++size; - } while (*pAttribList++); + } while (*pAttribList++ != terminator); + } + + return size; +} + + +/* + * (key, value) attribute list, terminated by the given terminator. + */ +template +static inline size_t +__AttribPairList_size(const T *pAttribList, const T terminator = static_cast(0)) +{ + size_t size = 0; + + if (pAttribList) { + while (pAttribList[size] != terminator) { + size += 2; + } + // terminator also counts + ++size; } return size;