X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=helpers%2Fglsize.hpp;h=2da217f123a24ba3ce3058548f7886c9eb23640c;hb=ae423964d8b9e4cae2a180e20879205aeeeca27f;hp=7efa12e0cf92a6a01bb24adb5bfcb17c89fb8a80;hpb=0f0e6daf84ef2da21a94ff2b9b0185eb2b4500a1;p=apitrace diff --git a/helpers/glsize.hpp b/helpers/glsize.hpp index 7efa12e..2da217f 100644 --- a/helpers/glsize.hpp +++ b/helpers/glsize.hpp @@ -37,6 +37,8 @@ #include +#include + #include "os.hpp" #include "glimports.hpp" @@ -293,49 +295,81 @@ _gl_uniform_size(GLenum type, GLenum &elemType, GLint &numCols, GLint &numRows) } static inline size_t -_glArrayPointer_size(GLint size, GLenum type, GLsizei stride, GLsizei maxIndex) +_glArrayPointer_size(GLint size, GLenum type, GLsizei stride, GLsizei count) { + if (!count) { + return 0; + } + + if (size == GL_BGRA) { + size = 4; + } + + if (size > 4) { + os::log("apitrace: warning: %s: unexpected size 0x%04X\n", __FUNCTION__, size); + } + size_t elementSize = size*_gl_type_size(type); if (!stride) { stride = (GLsizei)elementSize; } - return stride*maxIndex + elementSize; + + return stride*(count - 1) + elementSize; } -#define _glVertexPointer_size(size, type, stride, maxIndex) _glArrayPointer_size(size, type, stride, maxIndex) -#define _glNormalPointer_size(type, stride, maxIndex) _glArrayPointer_size(3, type, stride, maxIndex) -#define _glColorPointer_size(size, type, stride, maxIndex) _glArrayPointer_size(size, type, stride, maxIndex) -#define _glIndexPointer_size(type, stride, maxIndex) _glArrayPointer_size(1, type, stride, maxIndex) -#define _glTexCoordPointer_size(size, type, stride, maxIndex) _glArrayPointer_size(size, type, stride, maxIndex) -#define _glEdgeFlagPointer_size(stride, maxIndex) _glArrayPointer_size(1, GL_BOOL, stride, 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) +#define _glVertexPointer_size(size, type, stride, count) _glArrayPointer_size(size, type, stride, count) +#define _glNormalPointer_size(type, stride, count) _glArrayPointer_size(3, type, stride, count) +#define _glColorPointer_size(size, type, stride, count) _glArrayPointer_size(size, type, stride, count) +#define _glIndexPointer_size(type, stride, count) _glArrayPointer_size(1, type, stride, count) +#define _glTexCoordPointer_size(size, type, stride, count) _glArrayPointer_size(size, type, stride, count) +#define _glEdgeFlagPointer_size(stride, count) _glArrayPointer_size(1, GL_BOOL, stride, count) +#define _glFogCoordPointer_size(type, stride, count) _glArrayPointer_size(1, type, stride, count) +#define _glSecondaryColorPointer_size(size, type, stride, count) _glArrayPointer_size(size, type, stride, count) +#define _glVertexAttribPointer_size(size, type, normalized, stride, count) _glArrayPointer_size(size, type, stride, count) +#define _glVertexAttribPointerARB_size(size, type, normalized, stride, count) _glArrayPointer_size(size, type, stride, count) +#define _glVertexAttribPointerNV_size(size, type, stride, count) _glArrayPointer_size(size, type, stride, count) + +/** + * Same as glGetIntegerv, but passing the result in the return value. + */ +static inline GLint +_glGetInteger(GLenum pname) { + GLint param = 0; + _glGetIntegerv(pname, ¶m); + return param; +} + +static inline GLint +_element_array_buffer_binding(void) { + return _glGetInteger(GL_ELEMENT_ARRAY_BUFFER_BINDING); +} static inline GLuint -_glDrawArrays_maxindex(GLint first, GLsizei count) +_glDrawArrays_count(GLint first, GLsizei count) { if (!count) { return 0; } - return first + count - 1; + return first + count; } -#define _glDrawArraysEXT_maxindex _glDrawArrays_maxindex +#define _glDrawArraysEXT_count _glDrawArrays_count + +/* Forward declaration for definition in gltrace.py */ +void +_shadow_glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, + GLvoid *data); static inline GLuint -_glDrawElementsBaseVertex_maxindex(GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex) +_glDrawElementsBaseVertex_count(GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex) { GLvoid *temp = 0; - GLint element_array_buffer = 0; if (!count) { return 0; } - _glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &element_array_buffer); + GLint element_array_buffer = _element_array_buffer_binding(); if (element_array_buffer) { // Read indices from index buffer object GLintptr offset = (GLintptr)indices; @@ -345,7 +379,7 @@ _glDrawElementsBaseVertex_maxindex(GLsizei count, GLenum type, const GLvoid *ind return 0; } memset(temp, 0, size); - _glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, temp); + _shadow_glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, temp); indices = temp; } else { if (!indices) { @@ -386,78 +420,78 @@ _glDrawElementsBaseVertex_maxindex(GLsizei count, GLenum type, const GLvoid *ind maxindex += basevertex; - return maxindex; + return maxindex + 1; } -#define _glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex) _glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex) +#define _glDrawRangeElementsBaseVertex_count(start, end, count, type, indices, basevertex) _glDrawElementsBaseVertex_count(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 +#define _glDrawElements_count(count, type, indices) _glDrawElementsBaseVertex_count(count, type, indices, 0); +#define _glDrawRangeElements_count(start, end, count, type, indices) _glDrawElements_count(count, type, indices) +#define _glDrawRangeElementsEXT_count _glDrawRangeElements_count /* 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 _glDrawArraysInstanced_count(first, count, primcount) _glDrawArrays_count(first, count) +#define _glDrawElementsInstanced_count(count, type, indices, primcount) _glDrawElements_count(count, type, indices) +#define _glDrawElementsInstancedBaseVertex_count(count, type, indices, primcount, basevertex) _glDrawElementsBaseVertex_count(count, type, indices, basevertex) +#define _glDrawRangeElementsInstanced_count(start, end, count, type, indices, primcount) _glDrawRangeElements_count(start, end, count, type, indices) +#define _glDrawRangeElementsInstancedBaseVertex_count(start, end, count, type, indices, primcount, basevertex) _glDrawRangeElementsBaseVertex_count(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 _glDrawArraysInstancedBaseInstance_count(first, count, primcount, baseinstance) _glDrawArrays_count(first, count) +#define _glDrawElementsInstancedBaseInstance_count(count, type, indices, primcount, baseinstance) _glDrawElements_count(count, type, indices) +#define _glDrawElementsInstancedBaseVertexBaseInstance_count(count, type, indices, primcount, basevertex, baseinstance) _glDrawElementsBaseVertex_count(count, type, indices, basevertex) -#define _glDrawArraysInstancedARB_maxindex _glDrawArraysInstanced_maxindex -#define _glDrawElementsInstancedARB_maxindex _glDrawElementsInstanced_maxindex -#define _glDrawArraysInstancedEXT_maxindex _glDrawArraysInstanced_maxindex -#define _glDrawElementsInstancedEXT_maxindex _glDrawElementsInstanced_maxindex +#define _glDrawArraysInstancedARB_count _glDrawArraysInstanced_count +#define _glDrawElementsInstancedARB_count _glDrawElementsInstanced_count +#define _glDrawArraysInstancedEXT_count _glDrawArraysInstanced_count +#define _glDrawElementsInstancedEXT_count _glDrawElementsInstanced_count static inline GLuint -_glDrawArraysIndirect_maxindex(const GLvoid *indirect) { +_glDrawArraysIndirect_count(const GLvoid *indirect) { os::log("apitrace: warning: %s: unsupported\n", __FUNCTION__); return 0; } static inline GLuint -_glDrawElementsIndirect_maxindex(GLenum type, const GLvoid *indirect) { +_glDrawElementsIndirect_count(GLenum type, const GLvoid *indirect) { os::log("apitrace: warning: %s: unsupported\n", __FUNCTION__); return 0; } 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); +_glMultiDrawArrays_count(const GLint *first, const GLsizei *count, GLsizei drawcount) { + GLuint _count = 0; + for (GLsizei draw = 0; draw < drawcount; ++draw) { + GLuint _count_draw = _glDrawArrays_count(first[draw], count[draw]); + _count = std::max(_count, _count_draw); } - return maxindex; + return _count; } 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); +_glMultiDrawElements_count(const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount) { + GLuint _count = 0; + for (GLsizei draw = 0; draw < drawcount; ++draw) { + GLuint _count_draw = _glDrawElements_count(count[draw], type, indices[draw]); + _count = std::max(_count, _count_draw); } - return maxindex; + return _count; } 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); +_glMultiDrawElementsBaseVertex_count(const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint * basevertex) { + GLuint _count = 0; + for (GLsizei draw = 0; draw < drawcount; ++draw) { + GLuint _count_draw = _glDrawElementsBaseVertex_count(count[draw], type, indices[draw], basevertex[draw]); + _count = std::max(_count, _count_draw); } - return maxindex; + return _count; } -#define _glMultiDrawArraysEXT_maxindex _glMultiDrawArrays_maxindex -#define _glMultiDrawElementsEXT_maxindex _glMultiDrawElements_maxindex +#define _glMultiDrawArraysEXT_count _glMultiDrawArrays_count +#define _glMultiDrawElementsEXT_count _glMultiDrawElements_count -#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) +#define _glMultiModeDrawArraysIBM_count(first, count, drawcount, modestride) _glMultiDrawArrays_count(first, count, drawcount) +#define _glMultiModeDrawElementsIBM_count(count, type, indices, drawcount, modestride) _glMultiDrawElements_count(count, type, (const GLvoid **)indices, drawcount) static inline size_t @@ -597,32 +631,36 @@ _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, GLboolean has_unpack_subimage) { +static inline void +_gl_format_size(GLenum format, GLenum type, + unsigned & bits_per_element, unsigned & bits_per_pixel) +{ unsigned num_channels = _gl_format_channels(format); - unsigned bits_per_pixel; switch (type) { case GL_BITMAP: - bits_per_pixel = 1; + bits_per_pixel = bits_per_element = 1; break; case GL_BYTE: case GL_UNSIGNED_BYTE: - bits_per_pixel = 8 * num_channels; + bits_per_element = 8; + bits_per_pixel = bits_per_element * num_channels; break; case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_HALF_FLOAT: - bits_per_pixel = 16 * num_channels; + bits_per_element = 16; + bits_per_pixel = bits_per_element * num_channels; break; case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: - bits_per_pixel = 32 * num_channels; + bits_per_element = 32; + bits_per_pixel = bits_per_element * num_channels; break; case GL_UNSIGNED_BYTE_3_3_2: case GL_UNSIGNED_BYTE_2_3_3_REV: - bits_per_pixel = 8; + bits_per_pixel = bits_per_element = 8; break; case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_4_4_4_4_REV: @@ -632,7 +670,7 @@ _gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsize case GL_UNSIGNED_SHORT_5_6_5_REV: case GL_UNSIGNED_SHORT_8_8_MESA: case GL_UNSIGNED_SHORT_8_8_REV_MESA: - bits_per_pixel = 16; + bits_per_pixel = bits_per_element = 16; break; case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: @@ -643,16 +681,32 @@ _gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsize case GL_UNSIGNED_INT_5_9_9_9_REV: case GL_UNSIGNED_INT_S8_S8_8_8_NV: case GL_UNSIGNED_INT_8_8_S8_S8_REV_NV: - bits_per_pixel = 32; + bits_per_pixel = bits_per_element = 32; break; case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: - bits_per_pixel = 64; + bits_per_pixel = bits_per_element = 64; break; default: os::log("apitrace: warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type); - bits_per_pixel = 0; + bits_per_pixel = bits_per_element = 0; break; } +} + +static inline size_t +_glClearBufferData_size(GLenum format, GLenum type) { + unsigned bits_per_element; + unsigned bits_per_pixel; + _gl_format_size(format, type, bits_per_element, bits_per_pixel); + return (bits_per_pixel + 7)/8; +} + +static inline size_t +_gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth, GLboolean has_unpack_subimage) { + + unsigned bits_per_element; + unsigned bits_per_pixel; + _gl_format_size(format, type, bits_per_element, bits_per_pixel); GLint alignment = 4; GLint row_length = 0; @@ -676,9 +730,11 @@ _gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsize size_t row_stride = (row_length*bits_per_pixel + 7)/8; - if ((GLint)bits_per_pixel < alignment*8 && - (bits_per_pixel & 7) == 0 && - _is_pot(bits_per_pixel)) { + if ((bits_per_element == 1*8 || + bits_per_element == 2*8 || + bits_per_element == 4*8 || + bits_per_element == 8*8) && + (GLint)bits_per_element < alignment*8) { row_stride = _align(row_stride, alignment); } @@ -759,6 +815,22 @@ _glClearBuffer_size(GLenum buffer) } } + +/** + * Helper function for determining the string lengths for glShaderSource and + * glShaderSourceARB, which is a tad too complex to inline in the specs. + */ +template +static inline size_t +_glShaderSource_length(const T * const * string, const GLint *length, GLsizei index) +{ + if (length != NULL && length[index] >= 0) { + return (size_t)length[index]; + } else { + return strlen(string[index]); + } +} + /* * attribute list, terminated by the given terminator. */