X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fbufferobj.c;h=ac58c99d945696d03c714f9b45d92d816df71c1e;hb=298d7a20e1fb5eeed9832ea34f674e12aca59f4c;hp=eef10c42213556499b2519f76736c695ddd518c6;hpb=ffee498fb848b253a7833373fe5430f8c7ca0c5f;p=mesa.git diff --git a/src/mesa/main/bufferobj.c b/src/mesa/main/bufferobj.c index eef10c42213..ac58c99d945 100644 --- a/src/mesa/main/bufferobj.c +++ b/src/mesa/main/bufferobj.c @@ -30,7 +30,7 @@ * \author Brian Paul, Ian Romanick */ - +#include #include "glheader.h" #include "enums.h" #include "hash.h" @@ -42,6 +42,8 @@ #include "mfeatures.h" #include "mtypes.h" #include "texobj.h" +#include "transformfeedback.h" +#include "dispatch.h" /* Debug flags */ @@ -66,6 +68,12 @@ static struct gl_buffer_object DummyBufferObject; static inline struct gl_buffer_object ** get_buffer_target(struct gl_context *ctx, GLenum target) { + /* Other targets are only supported in desktop OpenGL and OpenGL ES 3.0. + */ + if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx) + && target != GL_ARRAY_BUFFER && target != GL_ELEMENT_ARRAY_BUFFER) + return NULL; + switch (target) { case GL_ARRAY_BUFFER_ARB: return &ctx->Array.ArrayBufferObj; @@ -79,18 +87,22 @@ get_buffer_target(struct gl_context *ctx, GLenum target) return &ctx->CopyReadBuffer; case GL_COPY_WRITE_BUFFER: return &ctx->CopyWriteBuffer; -#if FEATURE_EXT_transform_feedback case GL_TRANSFORM_FEEDBACK_BUFFER: if (ctx->Extensions.EXT_transform_feedback) { return &ctx->TransformFeedback.CurrentBuffer; } break; -#endif case GL_TEXTURE_BUFFER: - if (ctx->Extensions.ARB_texture_buffer_object) { + if (_mesa_is_desktop_gl(ctx) + && ctx->Extensions.ARB_texture_buffer_object) { return &ctx->Texture.BufferObject; } break; + case GL_UNIFORM_BUFFER: + if (ctx->Extensions.ARB_uniform_buffer_object) { + return &ctx->UniformBuffer; + } + break; default: return NULL; } @@ -124,7 +136,7 @@ get_buffer(struct gl_context *ctx, const char *func, GLenum target) } -static inline GLenum +static inline GLbitfield default_access_mode(const struct gl_context *ctx) { /* Table 2.6 on page 31 (page 44 of the PDF) of the OpenGL 1.5 spec says: @@ -143,7 +155,7 @@ default_access_mode(const struct gl_context *ctx) * The difference is because GL_OES_mapbuffer only supports mapping buffers * write-only. */ - return (ctx->API == API_OPENGLES) + return _mesa_is_gles(ctx) ? GL_MAP_WRITE_BIT : (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT); } @@ -250,8 +262,7 @@ _mesa_delete_buffer_object(struct gl_context *ctx, { (void) ctx; - if (bufObj->Data) - free(bufObj->Data); + free(bufObj->Data); /* assign strange values here to help w/ debugging */ bufObj->RefCount = -1000; @@ -347,6 +358,36 @@ _mesa_initialize_buffer_object( struct gl_context *ctx, } + +/** + * Callback called from _mesa_HashWalk() + */ +static void +count_buffer_size(GLuint key, void *data, void *userData) +{ + const struct gl_buffer_object *bufObj = + (const struct gl_buffer_object *) data; + GLuint *total = (GLuint *) userData; + + *total = *total + bufObj->Size; +} + + +/** + * Compute total size (in bytes) of all buffer objects for the given context. + * For debugging purposes. + */ +GLuint +_mesa_total_buffer_object_memory(struct gl_context *ctx) +{ + GLuint total = 0; + + _mesa_HashWalk(ctx->Shared->BufferObjects, count_buffer_size, &total); + + return total; +} + + /** * Allocate space for and store data in a buffer object. Any data that was * previously stored in the buffer object is lost. If \c data is \c NULL, @@ -515,7 +556,7 @@ _mesa_buffer_unmap( struct gl_context *ctx, struct gl_buffer_object *bufObj ) /** * Default fallback for \c dd_function_table::CopyBufferSubData(). - * Called via glCopyBuffserSubData(). + * Called via glCopyBufferSubData(). */ static void _mesa_copy_buffer_subdata(struct gl_context *ctx, @@ -567,6 +608,8 @@ _mesa_copy_buffer_subdata(struct gl_context *ctx, void _mesa_init_buffer_objects( struct gl_context *ctx ) { + GLuint i; + memset(&DummyBufferObject, 0, sizeof(DummyBufferObject)); _glthread_INIT_MUTEX(DummyBufferObject.Mutex); DummyBufferObject.RefCount = 1000*1000*1000; /* never delete */ @@ -578,18 +621,67 @@ _mesa_init_buffer_objects( struct gl_context *ctx ) ctx->Shared->NullBufferObj); _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer, ctx->Shared->NullBufferObj); + + ctx->UniformBufferBindings = calloc(ctx->Const.MaxUniformBufferBindings, + sizeof(*ctx->UniformBufferBindings)); + + _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, + ctx->Shared->NullBufferObj); + + for (i = 0; i < ctx->Const.MaxUniformBufferBindings; i++) { + _mesa_reference_buffer_object(ctx, + &ctx->UniformBufferBindings[i].BufferObject, + ctx->Shared->NullBufferObj); + ctx->UniformBufferBindings[i].Offset = -1; + ctx->UniformBufferBindings[i].Size = -1; + } } void _mesa_free_buffer_objects( struct gl_context *ctx ) { + GLuint i; + _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL); _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer, NULL); _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer, NULL); + + _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, NULL); + + for (i = 0; i < ctx->Const.MaxUniformBufferBindings; i++) { + _mesa_reference_buffer_object(ctx, + &ctx->UniformBufferBindings[i].BufferObject, + NULL); + } + + free(ctx->UniformBufferBindings); + ctx->UniformBufferBindings = NULL; } +static void +handle_bind_buffer_gen(struct gl_context *ctx, + GLenum target, + GLuint buffer, + struct gl_buffer_object **buf_handle) +{ + struct gl_buffer_object *buf = *buf_handle; + + if (!buf || buf == &DummyBufferObject) { + /* If this is a new buffer object id, or one which was generated but + * never used before, allocate a buffer object now. + */ + ASSERT(ctx->Driver.NewBufferObject); + buf = ctx->Driver.NewBufferObject(ctx, buffer, target); + if (!buf) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB"); + return; + } + _mesa_HashInsert(ctx->Shared->BufferObjects, buffer, buf); + *buf_handle = buf; + } +} /** * Bind the specified target to buffer for the specified context. @@ -625,18 +717,11 @@ bind_buffer_object(struct gl_context *ctx, GLenum target, GLuint buffer) else { /* non-default buffer object */ newBufObj = _mesa_lookup_bufferobj(ctx, buffer); - if (!newBufObj || newBufObj == &DummyBufferObject) { - /* If this is a new buffer object id, or one which was generated but - * never used before, allocate a buffer object now. - */ - ASSERT(ctx->Driver.NewBufferObject); - newBufObj = ctx->Driver.NewBufferObject(ctx, buffer, target); - if (!newBufObj) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB"); - return; - } - _mesa_HashInsert(ctx->Shared->BufferObjects, buffer, newBufObj); + if (newBufObj == NULL && ctx->API == API_OPENGL_CORE) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glBindBuffer(non-gen name)"); + return; } + handle_bind_buffer_gen(ctx, target, buffer, &newBufObj); } /* bind new buffer */ @@ -791,6 +876,35 @@ _mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids) _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 ); } + /* unbind ARB_copy_buffer binding points */ + if (ctx->CopyReadBuffer == bufObj) { + _mesa_BindBufferARB( GL_COPY_READ_BUFFER, 0 ); + } + if (ctx->CopyWriteBuffer == bufObj) { + _mesa_BindBufferARB( GL_COPY_WRITE_BUFFER, 0 ); + } + + /* unbind transform feedback binding points */ + if (ctx->TransformFeedback.CurrentBuffer == bufObj) { + _mesa_BindBufferARB( GL_TRANSFORM_FEEDBACK_BUFFER, 0 ); + } + for (j = 0; j < MAX_FEEDBACK_BUFFERS; j++) { + if (ctx->TransformFeedback.CurrentObject->Buffers[j] == bufObj) { + _mesa_BindBufferBase( GL_TRANSFORM_FEEDBACK_BUFFER, j, 0 ); + } + } + + /* unbind UBO binding points */ + for (j = 0; j < ctx->Const.MaxUniformBufferBindings; j++) { + if (ctx->UniformBufferBindings[j].BufferObject == bufObj) { + _mesa_BindBufferBase( GL_UNIFORM_BUFFER, j, 0 ); + } + } + + if (ctx->UniformBuffer == bufObj) { + _mesa_BindBufferARB( GL_UNIFORM_BUFFER, 0 ); + } + /* unbind any pixel pack/unpack pointers bound to this buffer */ if (ctx->Pack.BufferObj == bufObj) { _mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 ); @@ -799,6 +913,10 @@ _mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids) _mesa_BindBufferARB( GL_PIXEL_UNPACK_BUFFER_EXT, 0 ); } + if (ctx->Texture.BufferObject == bufObj) { + _mesa_BindBufferARB( GL_TEXTURE_BUFFER, 0 ); + } + /* The ID is immediately freed for re-use */ _mesa_HashRemove(ctx->Shared->BufferObjects, ids[i]); /* Make sure we do not run into the classic ABA problem on bind. @@ -892,6 +1010,7 @@ _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size, { GET_CURRENT_CONTEXT(ctx); struct gl_buffer_object *bufObj; + bool valid_usage; ASSERT_OUTSIDE_BEGIN_END(ctx); if (MESA_VERBOSE & VERBOSE_API) @@ -907,18 +1026,30 @@ _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size, switch (usage) { case GL_STREAM_DRAW_ARB: + valid_usage = (ctx->API != API_OPENGLES); + break; + + case GL_STATIC_DRAW_ARB: + case GL_DYNAMIC_DRAW_ARB: + valid_usage = true; + break; + case GL_STREAM_READ_ARB: case GL_STREAM_COPY_ARB: - case GL_STATIC_DRAW_ARB: case GL_STATIC_READ_ARB: case GL_STATIC_COPY_ARB: - case GL_DYNAMIC_DRAW_ARB: case GL_DYNAMIC_READ_ARB: case GL_DYNAMIC_COPY_ARB: - /* OK */ + valid_usage = _mesa_is_desktop_gl(ctx) || _mesa_is_gles3(ctx); break; + default: - _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(usage)"); + valid_usage = false; + break; + } + + if (!valid_usage) { + _mesa_error(ctx, GL_INVALID_ENUM, "glBufferData(usage)"); return; } @@ -1005,20 +1136,29 @@ _mesa_MapBufferARB(GLenum target, GLenum access) struct gl_buffer_object * bufObj; GLbitfield accessFlags; void *map; + bool valid_access; ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL); switch (access) { case GL_READ_ONLY_ARB: accessFlags = GL_MAP_READ_BIT; + valid_access = _mesa_is_desktop_gl(ctx); break; case GL_WRITE_ONLY_ARB: accessFlags = GL_MAP_WRITE_BIT; + valid_access = true; break; case GL_READ_WRITE_ARB: accessFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT; + valid_access = _mesa_is_desktop_gl(ctx); break; default: + valid_access = false; + break; + } + + if (!valid_access) { _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)"); return NULL; } @@ -1279,48 +1419,54 @@ _mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, struct gl_buffer_object *src, *dst; ASSERT_OUTSIDE_BEGIN_END(ctx); - src = get_buffer(ctx, "glCopyBuffserSubData", readTarget); + src = get_buffer(ctx, "glCopyBufferSubData", readTarget); if (!src) return; - dst = get_buffer(ctx, "glCopyBuffserSubData", writeTarget); + dst = get_buffer(ctx, "glCopyBufferSubData", writeTarget); if (!dst) return; if (_mesa_bufferobj_mapped(src)) { _mesa_error(ctx, GL_INVALID_OPERATION, - "glCopyBuffserSubData(readBuffer is mapped)"); + "glCopyBufferSubData(readBuffer is mapped)"); return; } if (_mesa_bufferobj_mapped(dst)) { _mesa_error(ctx, GL_INVALID_OPERATION, - "glCopyBuffserSubData(writeBuffer is mapped)"); + "glCopyBufferSubData(writeBuffer is mapped)"); return; } if (readOffset < 0) { _mesa_error(ctx, GL_INVALID_VALUE, - "glCopyBuffserSubData(readOffset = %d)", (int) readOffset); + "glCopyBufferSubData(readOffset = %d)", (int) readOffset); return; } if (writeOffset < 0) { _mesa_error(ctx, GL_INVALID_VALUE, - "glCopyBuffserSubData(writeOffset = %d)", (int) writeOffset); + "glCopyBufferSubData(writeOffset = %d)", (int) writeOffset); + return; + } + + if (size < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glCopyBufferSubData(writeOffset = %d)", (int) size); return; } if (readOffset + size > src->Size) { _mesa_error(ctx, GL_INVALID_VALUE, - "glCopyBuffserSubData(readOffset + size = %d)", + "glCopyBufferSubData(readOffset + size = %d)", (int) (readOffset + size)); return; } if (writeOffset + size > dst->Size) { _mesa_error(ctx, GL_INVALID_VALUE, - "glCopyBuffserSubData(writeOffset + size = %d)", + "glCopyBufferSubData(writeOffset + size = %d)", (int) (writeOffset + size)); return; } @@ -1335,7 +1481,7 @@ _mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, else { /* overlapping src/dst is illegal */ _mesa_error(ctx, GL_INVALID_VALUE, - "glCopyBuffserSubData(overlapping src/dst)"); + "glCopyBufferSubData(overlapping src/dst)"); return; } } @@ -1375,6 +1521,19 @@ _mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, return NULL; } + /* Page 38 of the PDF of the OpenGL ES 3.0 spec says: + * + * "An INVALID_OPERATION error is generated for any of the following + * conditions: + * + * * is zero." + */ + if (_mesa_is_gles(ctx) && length == 0) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(length = 0)"); + return NULL; + } + if (access & ~(GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | @@ -1519,7 +1678,6 @@ _mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) } -#if FEATURE_APPLE_object_purgeable static GLenum buffer_object_purgeable(struct gl_context *ctx, GLuint name, GLenum option) { @@ -1894,4 +2052,313 @@ _mesa_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname, } } -#endif /* FEATURE_APPLE_object_purgeable */ +static void +set_ubo_binding(struct gl_context *ctx, + int index, + struct gl_buffer_object *bufObj, + GLintptr offset, + GLsizeiptr size, + GLboolean autoSize) +{ + struct gl_uniform_buffer_binding *binding; + + binding = &ctx->UniformBufferBindings[index]; + if (binding->BufferObject == bufObj && + binding->Offset == offset && + binding->Size == size && + binding->AutomaticSize == autoSize) { + return; + } + + FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT); + + _mesa_reference_buffer_object(ctx, &binding->BufferObject, bufObj); + binding->Offset = offset; + binding->Size = size; + binding->AutomaticSize = autoSize; +} + +/** + * Bind a region of a buffer object to a uniform block binding point. + * \param index the uniform buffer binding point index + * \param bufObj the buffer object + * \param offset offset to the start of buffer object region + * \param size size of the buffer object region + */ +static void +bind_buffer_range_uniform_buffer(struct gl_context *ctx, + GLuint index, + struct gl_buffer_object *bufObj, + GLintptr offset, + GLsizeiptr size) +{ + if (index >= ctx->Const.MaxUniformBufferBindings) { + _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(index=%d)", index); + return; + } + + if (offset & (ctx->Const.UniformBufferOffsetAlignment - 1)) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glBindBufferRange(offset misalgned %d/%d)", (int) offset, + ctx->Const.UniformBufferOffsetAlignment); + return; + } + + if (bufObj == ctx->Shared->NullBufferObj) { + offset = -1; + size = -1; + } + + _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, bufObj); + set_ubo_binding(ctx, index, bufObj, offset, size, GL_FALSE); +} + + +/** + * Bind a buffer object to a uniform block binding point. + * As above, but offset = 0. + */ +static void +bind_buffer_base_uniform_buffer(struct gl_context *ctx, + GLuint index, + struct gl_buffer_object *bufObj) +{ + if (index >= ctx->Const.MaxUniformBufferBindings) { + _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferBase(index=%d)", index); + return; + } + + _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, bufObj); + if (bufObj == ctx->Shared->NullBufferObj) + set_ubo_binding(ctx, index, bufObj, -1, -1, GL_TRUE); + else + set_ubo_binding(ctx, index, bufObj, 0, 0, GL_TRUE); +} + +void GLAPIENTRY +_mesa_BindBufferRange(GLenum target, GLuint index, + GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_buffer_object *bufObj; + + if (buffer == 0) { + bufObj = ctx->Shared->NullBufferObj; + } else { + bufObj = _mesa_lookup_bufferobj(ctx, buffer); + } + handle_bind_buffer_gen(ctx, target, buffer, &bufObj); + + if (!bufObj) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glBindBufferRange(invalid buffer=%u)", buffer); + return; + } + + if (size <= 0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(size=%d)", + (int) size); + return; + } + + if (offset + size > bufObj->Size) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glBindBufferRange(offset + size %d > buffer size %d)", + (int) (offset + size), (int) (bufObj->Size)); + return; + } + + switch (target) { + case GL_TRANSFORM_FEEDBACK_BUFFER: + _mesa_bind_buffer_range_transform_feedback(ctx, index, bufObj, + offset, size); + return; + case GL_UNIFORM_BUFFER: + bind_buffer_range_uniform_buffer(ctx, index, bufObj, offset, size); + return; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferRange(target)"); + return; + } +} + +void GLAPIENTRY +_mesa_BindBufferBase(GLenum target, GLuint index, GLuint buffer) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_buffer_object *bufObj; + + if (buffer == 0) { + bufObj = ctx->Shared->NullBufferObj; + } else { + bufObj = _mesa_lookup_bufferobj(ctx, buffer); + } + handle_bind_buffer_gen(ctx, target, buffer, &bufObj); + + if (!bufObj) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glBindBufferBase(invalid buffer=%u)", buffer); + return; + } + + /* Note that there's some oddness in the GL 3.1-GL 3.3 specifications with + * regards to BindBufferBase. It says (GL 3.1 core spec, page 63): + * + * "BindBufferBase is equivalent to calling BindBufferRange with offset + * zero and size equal to the size of buffer." + * + * but it says for glGetIntegeri_v (GL 3.1 core spec, page 230): + * + * "If the parameter (starting offset or size) was not specified when the + * buffer object was bound, zero is returned." + * + * What happens if the size of the buffer changes? Does the size of the + * buffer at the moment glBindBufferBase was called still play a role, like + * the first quote would imply, or is the size meaningless in the + * glBindBufferBase case like the second quote would suggest? The GL 4.1 + * core spec page 45 says: + * + * "It is equivalent to calling BindBufferRange with offset zero, while + * size is determined by the size of the bound buffer at the time the + * binding is used." + * + * My interpretation is that the GL 4.1 spec was a clarification of the + * behavior, not a change. In particular, this choice will only make + * rendering work in cases where it would have had undefined results. + */ + + switch (target) { + case GL_TRANSFORM_FEEDBACK_BUFFER: + _mesa_bind_buffer_base_transform_feedback(ctx, index, bufObj); + return; + case GL_UNIFORM_BUFFER: + bind_buffer_base_uniform_buffer(ctx, index, bufObj); + return; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferBase(target)"); + return; + } +} + +static void GLAPIENTRY +_mesa_InvalidateBufferSubData(GLuint buffer, GLintptr offset, + GLsizeiptr length) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_buffer_object *bufObj; + const GLintptr end = offset + length; + + bufObj = _mesa_lookup_bufferobj(ctx, buffer); + if (!bufObj) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glInvalidateBufferSubData(name = 0x%x) invalid object", + buffer); + return; + } + + /* The GL_ARB_invalidate_subdata spec says: + * + * "An INVALID_VALUE error is generated if or is + * negative, or if + is greater than the value of + * BUFFER_SIZE." + */ + if (end < 0 || end > bufObj->Size) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glInvalidateBufferSubData(invalid offset or length)"); + return; + } + + /* The GL_ARB_invalidate_subdata spec says: + * + * "An INVALID_OPERATION error is generated if the buffer is currently + * mapped by MapBuffer, or if the invalidate range intersects the range + * currently mapped by MapBufferRange." + */ + if (_mesa_bufferobj_mapped(bufObj)) { + const GLintptr mapEnd = bufObj->Offset + bufObj->Length; + + /* The regions do not overlap if and only if the end of the discard + * region is before the mapped region or the start of the discard region + * is after the mapped region. + * + * Note that 'end' and 'mapEnd' are the first byte *after* the discard + * region and the mapped region, repsectively. It is okay for that byte + * to be mapped (for 'end') or discarded (for 'mapEnd'). + */ + if (!(end <= bufObj->Offset || offset >= mapEnd)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glInvalidateBufferSubData(intersection with mapped " + "range)"); + return; + } + } + + /* We don't actually do anything for this yet. Just return after + * validating the parameters and generating the required errors. + */ + return; +} + +static void GLAPIENTRY +_mesa_InvalidateBufferData(GLuint buffer) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_buffer_object *bufObj; + + bufObj = _mesa_lookup_bufferobj(ctx, buffer); + if (!bufObj) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glInvalidateBufferData(name = 0x%x) invalid object", + buffer); + return; + } + + /* The GL_ARB_invalidate_subdata spec says: + * + * "An INVALID_OPERATION error is generated if the buffer is currently + * mapped by MapBuffer, or if the invalidate range intersects the range + * currently mapped by MapBufferRange." + */ + if (_mesa_bufferobj_mapped(bufObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glInvalidateBufferData(intersection with mapped " + "range)"); + return; + } + + /* We don't actually do anything for this yet. Just return after + * validating the parameters and generating the required errors. + */ + return; +} + +void +_mesa_init_bufferobj_dispatch(struct gl_context *ctx, struct _glapi_table *disp) +{ + SET_BindBufferARB(disp, _mesa_BindBufferARB); + SET_BufferDataARB(disp, _mesa_BufferDataARB); + SET_BufferSubDataARB(disp, _mesa_BufferSubDataARB); + SET_DeleteBuffersARB(disp, _mesa_DeleteBuffersARB); + SET_GenBuffersARB(disp, _mesa_GenBuffersARB); + SET_GetBufferParameterivARB(disp, _mesa_GetBufferParameterivARB); + /* TODO: add GetBufferParameteri64v for desktop GL and GLES3 once tests + * exist for it. + */ + SET_GetBufferPointervARB(disp, _mesa_GetBufferPointervARB); + if (ctx->API != API_OPENGLES2) { + SET_GetBufferSubDataARB(disp, _mesa_GetBufferSubDataARB); + } + SET_IsBufferARB(disp, _mesa_IsBufferARB); + SET_MapBufferARB(disp, _mesa_MapBufferARB); + SET_UnmapBufferARB(disp, _mesa_UnmapBufferARB); + + if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles3(ctx)) { + SET_BindBufferRangeEXT(disp, _mesa_BindBufferRange); + SET_BindBufferBaseEXT(disp, _mesa_BindBufferBase); + } + + if (_mesa_is_desktop_gl(ctx)) { + SET_InvalidateBufferData(disp, _mesa_InvalidateBufferData); + SET_InvalidateBufferSubData(disp, _mesa_InvalidateBufferSubData); + } +}