#include <stdbool.h>
#include <inttypes.h> /* for PRId64 macro */
+#include "util/debug.h"
#include "glheader.h"
#include "enums.h"
#include "hash.h"
#include "glformats.h"
#include "texstore.h"
#include "transformfeedback.h"
+#include "varray.h"
/* Debug flags */
return &ctx->CopyReadBuffer;
case GL_COPY_WRITE_BUFFER:
return &ctx->CopyWriteBuffer;
+ case GL_QUERY_BUFFER:
+ if (_mesa_has_ARB_query_buffer_object(ctx))
+ return &ctx->QueryBuffer;
+ break;
case GL_DRAW_INDIRECT_BUFFER:
if ((ctx->API == API_OPENGL_CORE &&
ctx->Extensions.ARB_draw_indirect) ||
return &ctx->DrawIndirectBuffer;
}
break;
+ case GL_PARAMETER_BUFFER_ARB:
+ if (_mesa_has_ARB_indirect_parameters(ctx)) {
+ return &ctx->ParameterBuffer;
+ }
+ break;
case GL_DISPATCH_INDIRECT_BUFFER:
if (_mesa_has_compute_shaders(ctx)) {
return &ctx->DispatchIndirectBuffer;
}
break;
case GL_TEXTURE_BUFFER:
- if (ctx->API == API_OPENGL_CORE &&
- ctx->Extensions.ARB_texture_buffer_object) {
+ if (_mesa_has_ARB_texture_buffer_object(ctx) ||
+ _mesa_has_OES_texture_buffer(ctx)) {
return &ctx->Texture.BufferObject;
}
break;
*
* Default callback for the \c dd_function_table::DeleteBuffer() hook.
*/
-static void
+void
_mesa_delete_buffer_object(struct gl_context *ctx,
struct gl_buffer_object *bufObj)
{
(void) ctx;
+ vbo_delete_minmax_cache(bufObj);
_mesa_align_free(bufObj->Data);
/* assign strange values here to help w/ debugging */
if (bufObj) {
/* reference new buffer */
mtx_lock(&bufObj->Mutex);
- if (bufObj->RefCount == 0) {
- /* this buffer's being deleted (look just above) */
- /* Not sure this can every really happen. Warn if it does. */
- _mesa_problem(NULL, "referencing deleted buffer object");
- *ptr = NULL;
- }
- else {
- bufObj->RefCount++;
- *ptr = bufObj;
- }
+ assert(bufObj->RefCount > 0);
+
+ bufObj->RefCount++;
+ *ptr = bufObj;
mtx_unlock(&bufObj->Mutex);
}
}
+/**
+ * Get the value of MESA_NO_MINMAX_CACHE.
+ */
+static bool
+get_no_minmax_cache()
+{
+ static bool read = false;
+ static bool disable = false;
+
+ if (!read) {
+ disable = env_var_as_boolean("MESA_NO_MINMAX_CACHE", false);
+ read = true;
+ }
+
+ return disable;
+}
+
+
/**
* Initialize a buffer object to default values.
*/
obj->RefCount = 1;
obj->Name = name;
obj->Usage = GL_STATIC_DRAW_ARB;
+
+ if (get_no_minmax_cache())
+ obj->UsageHistory |= USAGE_DISABLE_MINMAX_CACHE;
}
* \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData.
*/
static void
-_mesa_buffer_get_subdata( struct gl_context *ctx, GLintptrARB offset,
- GLsizeiptrARB size, GLvoid * data,
- struct gl_buffer_object * bufObj )
+buffer_get_subdata(struct gl_context *ctx, GLintptrARB offset,
+ GLsizeiptrARB size, GLvoid *data,
+ struct gl_buffer_object *bufObj )
{
(void) ctx;
_mesa_reference_buffer_object(ctx, &ctx->DrawIndirectBuffer,
ctx->Shared->NullBufferObj);
+ _mesa_reference_buffer_object(ctx, &ctx->ParameterBuffer,
+ ctx->Shared->NullBufferObj);
+
_mesa_reference_buffer_object(ctx, &ctx->DispatchIndirectBuffer,
ctx->Shared->NullBufferObj);
+ _mesa_reference_buffer_object(ctx, &ctx->QueryBuffer,
+ ctx->Shared->NullBufferObj);
+
for (i = 0; i < MAX_COMBINED_UNIFORM_BUFFERS; i++) {
_mesa_reference_buffer_object(ctx,
&ctx->UniformBufferBindings[i].BufferObject,
_mesa_reference_buffer_object(ctx, &ctx->DrawIndirectBuffer, NULL);
+ _mesa_reference_buffer_object(ctx, &ctx->ParameterBuffer, NULL);
+
_mesa_reference_buffer_object(ctx, &ctx->DispatchIndirectBuffer, NULL);
+ _mesa_reference_buffer_object(ctx, &ctx->QueryBuffer, NULL);
+
for (i = 0; i < MAX_COMBINED_UNIFORM_BUFFERS; i++) {
_mesa_reference_buffer_object(ctx,
&ctx->UniformBufferBindings[i].BufferObject,
{
struct gl_buffer_object *buf = *buf_handle;
- if (!buf && (ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx))) {
+ if (!buf && (ctx->API == API_OPENGL_CORE)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-gen name)", caller);
return false;
}
* Called by glBindBuffer() and other functions.
*/
static void
-bind_buffer_object(struct gl_context *ctx, GLenum target, GLuint buffer)
+bind_buffer_object(struct gl_context *ctx,
+ struct gl_buffer_object **bindTarget, GLuint buffer)
{
struct gl_buffer_object *oldBufObj;
struct gl_buffer_object *newBufObj = NULL;
- struct gl_buffer_object **bindTarget = NULL;
- bindTarget = get_buffer_target(ctx, target);
- if (!bindTarget) {
- _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)", target);
- return;
- }
+ assert(bindTarget);
/* Get pointer to old buffer object (to be unbound) */
oldBufObj = *bindTarget;
return;
}
+ /* record usage history */
+ if (bindTarget == &ctx->Pack.BufferObj) {
+ newBufObj->UsageHistory |= USAGE_PIXEL_PACK_BUFFER;
+ }
+
/* bind new buffer */
_mesa_reference_buffer_object(ctx, bindTarget, newBufObj);
}
/* Bind the NullBufferObj to remove references to those
* in the shared context hash table.
*/
- bind_buffer_object( ctx, GL_ARRAY_BUFFER_ARB, 0);
- bind_buffer_object( ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
- bind_buffer_object( ctx, GL_PIXEL_PACK_BUFFER_ARB, 0);
- bind_buffer_object( ctx, GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+ bind_buffer_object(ctx, &ctx->Array.ArrayBufferObj, 0);
+ bind_buffer_object(ctx, &ctx->Array.VAO->IndexBufferObj, 0);
+ bind_buffer_object(ctx, &ctx->Pack.BufferObj, 0);
+ bind_buffer_object(ctx, &ctx->Unpack.BufferObj, 0);
}
struct gl_buffer_object *
_mesa_lookup_bufferobj_locked(struct gl_context *ctx, GLuint buffer)
{
- return (struct gl_buffer_object *)
- _mesa_HashLookupLocked(ctx->Shared->BufferObjects, buffer);
+ if (buffer == 0)
+ return NULL;
+ else
+ return (struct gl_buffer_object *)
+ _mesa_HashLookupLocked(ctx->Shared->BufferObjects, buffer);
}
/**
}
-void
-_mesa_begin_bufferobj_lookups(struct gl_context *ctx)
-{
- _mesa_HashLockMutex(ctx->Shared->BufferObjects);
-}
-
-
-void
-_mesa_end_bufferobj_lookups(struct gl_context *ctx)
-{
- _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
-}
-
-
/**
* Look up a buffer object for a multi-bind function.
*
* returns NULL.
*
* This function assumes that the caller has already locked the
- * hash table mutex by calling _mesa_begin_bufferobj_lookups().
+ * hash table mutex by calling
+ * _mesa_HashLockMutex(ctx->Shared->BufferObjects).
*/
struct gl_buffer_object *
_mesa_multi_bind_lookup_bufferobj(struct gl_context *ctx,
*/
static void
unbind(struct gl_context *ctx,
- struct gl_buffer_object **ptr,
+ struct gl_vertex_array_object *vao, unsigned index,
struct gl_buffer_object *obj)
{
- if (*ptr == obj) {
- _mesa_reference_buffer_object(ctx, ptr, ctx->Shared->NullBufferObj);
+ if (vao->BufferBinding[index].BufferObj == obj) {
+ _mesa_bind_vertex_buffer(ctx, vao, index, ctx->Shared->NullBufferObj,
+ vao->BufferBinding[index].Offset,
+ vao->BufferBinding[index].Stride);
}
}
driver->DeleteBuffer = _mesa_delete_buffer_object;
driver->BufferData = buffer_data_fallback;
driver->BufferSubData = buffer_sub_data_fallback;
- driver->GetBufferSubData = _mesa_buffer_get_subdata;
+ driver->GetBufferSubData = buffer_get_subdata;
driver->UnmapBuffer = unmap_buffer_fallback;
/* GL_ARB_clear_buffer_object */
_mesa_buffer_unmap_all_mappings(struct gl_context *ctx,
struct gl_buffer_object *bufObj)
{
- int i;
-
- for (i = 0; i < MAP_COUNT; i++) {
+ for (int i = 0; i < MAP_COUNT; i++) {
if (_mesa_bufferobj_mapped(bufObj, i)) {
ctx->Driver.UnmapBuffer(ctx, bufObj, i);
assert(bufObj->Mappings[i].Pointer == NULL);
/* API Functions */
/**********************************************************************/
+void GLAPIENTRY
+_mesa_BindBuffer_no_error(GLenum target, GLuint buffer)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_buffer_object **bindTarget = get_buffer_target(ctx, target);
+ bind_buffer_object(ctx, bindTarget, buffer);
+}
+
+
void GLAPIENTRY
_mesa_BindBuffer(GLenum target, GLuint buffer)
{
_mesa_enum_to_string(target), buffer);
}
- bind_buffer_object(ctx, target, buffer);
+ struct gl_buffer_object **bindTarget = get_buffer_target(ctx, target);
+ if (!bindTarget) {
+ _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target %s)",
+ _mesa_enum_to_string(target));
+ return;
+ }
+
+ bind_buffer_object(ctx, bindTarget, buffer);
}
return;
}
- mtx_lock(&ctx->Shared->Mutex);
+ _mesa_HashLockMutex(ctx->Shared->BufferObjects);
for (i = 0; i < n; i++) {
- struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, ids[i]);
+ struct gl_buffer_object *bufObj =
+ _mesa_lookup_bufferobj_locked(ctx, ids[i]);
if (bufObj) {
struct gl_vertex_array_object *vao = ctx->Array.VAO;
GLuint j;
_mesa_buffer_unmap_all_mappings(ctx, bufObj);
/* unbind any vertex pointers bound to this buffer */
- for (j = 0; j < ARRAY_SIZE(vao->VertexBinding); j++) {
- unbind(ctx, &vao->VertexBinding[j].BufferObj, bufObj);
+ for (j = 0; j < ARRAY_SIZE(vao->BufferBinding); j++) {
+ unbind(ctx, vao, j, bufObj);
}
if (ctx->Array.ArrayBufferObj == bufObj) {
- _mesa_BindBuffer( GL_ARRAY_BUFFER_ARB, 0 );
+ bind_buffer_object(ctx, &ctx->Array.ArrayBufferObj, 0);
}
if (vao->IndexBufferObj == bufObj) {
- _mesa_BindBuffer( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
+ bind_buffer_object(ctx, &vao->IndexBufferObj, 0);
}
/* unbind ARB_draw_indirect binding point */
if (ctx->DrawIndirectBuffer == bufObj) {
- _mesa_BindBuffer( GL_DRAW_INDIRECT_BUFFER, 0 );
+ bind_buffer_object(ctx, &ctx->DrawIndirectBuffer, 0);
+ }
+
+ /* unbind ARB_indirect_parameters binding point */
+ if (ctx->ParameterBuffer == bufObj) {
+ bind_buffer_object(ctx, &ctx->ParameterBuffer, 0);
}
/* unbind ARB_compute_shader binding point */
if (ctx->DispatchIndirectBuffer == bufObj) {
- _mesa_BindBuffer(GL_DISPATCH_INDIRECT_BUFFER, 0);
+ bind_buffer_object(ctx, &ctx->DispatchIndirectBuffer, 0);
}
/* unbind ARB_copy_buffer binding points */
if (ctx->CopyReadBuffer == bufObj) {
- _mesa_BindBuffer( GL_COPY_READ_BUFFER, 0 );
+ bind_buffer_object(ctx, &ctx->CopyReadBuffer, 0);
}
if (ctx->CopyWriteBuffer == bufObj) {
- _mesa_BindBuffer( GL_COPY_WRITE_BUFFER, 0 );
+ bind_buffer_object(ctx, &ctx->CopyWriteBuffer, 0);
}
/* unbind transform feedback binding points */
if (ctx->TransformFeedback.CurrentBuffer == bufObj) {
- _mesa_BindBuffer( GL_TRANSFORM_FEEDBACK_BUFFER, 0 );
+ bind_buffer_object(ctx, &ctx->TransformFeedback.CurrentBuffer, 0);
}
for (j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
if (ctx->TransformFeedback.CurrentObject->Buffers[j] == bufObj) {
}
if (ctx->UniformBuffer == bufObj) {
- _mesa_BindBuffer( GL_UNIFORM_BUFFER, 0 );
+ bind_buffer_object(ctx, &ctx->UniformBuffer, 0);
}
/* unbind SSBO binding points */
}
if (ctx->ShaderStorageBuffer == bufObj) {
- _mesa_BindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+ bind_buffer_object(ctx, &ctx->ShaderStorageBuffer, 0);
}
/* unbind Atomci Buffer binding points */
}
if (ctx->AtomicBuffer == bufObj) {
- _mesa_BindBuffer( GL_ATOMIC_COUNTER_BUFFER, 0 );
+ bind_buffer_object(ctx, &ctx->AtomicBuffer, 0);
}
/* unbind any pixel pack/unpack pointers bound to this buffer */
if (ctx->Pack.BufferObj == bufObj) {
- _mesa_BindBuffer( GL_PIXEL_PACK_BUFFER_EXT, 0 );
+ bind_buffer_object(ctx, &ctx->Pack.BufferObj, 0);
}
if (ctx->Unpack.BufferObj == bufObj) {
- _mesa_BindBuffer( GL_PIXEL_UNPACK_BUFFER_EXT, 0 );
+ bind_buffer_object(ctx, &ctx->Unpack.BufferObj, 0);
}
if (ctx->Texture.BufferObject == bufObj) {
- _mesa_BindBuffer( GL_TEXTURE_BUFFER, 0 );
+ bind_buffer_object(ctx, &ctx->Texture.BufferObject, 0);
}
if (ctx->ExternalVirtualMemoryBuffer == bufObj) {
- _mesa_BindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0);
+ bind_buffer_object(ctx, &ctx->ExternalVirtualMemoryBuffer, 0);
+ }
+
+ /* unbind query buffer binding point */
+ if (ctx->QueryBuffer == bufObj) {
+ bind_buffer_object(ctx, &ctx->QueryBuffer, 0);
}
/* The ID is immediately freed for re-use */
- _mesa_HashRemove(ctx->Shared->BufferObjects, ids[i]);
+ _mesa_HashRemoveLocked(ctx->Shared->BufferObjects, ids[i]);
/* Make sure we do not run into the classic ABA problem on bind.
* We don't want to allow re-binding a buffer object that's been
* "deleted" by glDeleteBuffers().
}
}
- mtx_unlock(&ctx->Shared->Mutex);
+ _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
}
{
GET_CURRENT_CONTEXT(ctx);
GLuint first;
- GLint i;
struct gl_buffer_object *buf;
const char *func = dsa ? "glCreateBuffers" : "glGenBuffers";
/*
* This must be atomic (generation and allocation of buffer object IDs)
*/
- mtx_lock(&ctx->Shared->Mutex);
+ _mesa_HashLockMutex(ctx->Shared->BufferObjects);
first = _mesa_HashFindFreeKeyBlock(ctx->Shared->BufferObjects, n);
* DummyBufferObject. Otherwise, create a new buffer object and insert
* it.
*/
- for (i = 0; i < n; i++) {
+ for (int i = 0; i < n; i++) {
buffers[i] = first + i;
if (dsa) {
assert(ctx->Driver.NewBufferObject);
buf = ctx->Driver.NewBufferObject(ctx, buffers[i]);
if (!buf) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
- mtx_unlock(&ctx->Shared->Mutex);
+ _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
return;
}
}
else
buf = &DummyBufferObject;
- _mesa_HashInsert(ctx->Shared->BufferObjects, buffers[i], buf);
+ _mesa_HashInsertLocked(ctx->Shared->BufferObjects, buffers[i], buf);
}
- mtx_unlock(&ctx->Shared->Mutex);
+ _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
}
/**
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
- mtx_lock(&ctx->Shared->Mutex);
bufObj = _mesa_lookup_bufferobj(ctx, id);
- mtx_unlock(&ctx->Shared->Mutex);
return bufObj && bufObj != &DummyBufferObject;
}
-void
-_mesa_buffer_storage(struct gl_context *ctx, struct gl_buffer_object *bufObj,
- GLenum target, GLsizeiptr size, const GLvoid *data,
- GLbitfield flags, const char *func)
+static bool
+validate_buffer_storage(struct gl_context *ctx,
+ struct gl_buffer_object *bufObj, GLsizeiptr size,
+ GLbitfield flags, const char *func)
{
if (size <= 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(size <= 0)", func);
- return;
+ return false;
}
- if (flags & ~(GL_MAP_READ_BIT |
- GL_MAP_WRITE_BIT |
- GL_MAP_PERSISTENT_BIT |
- GL_MAP_COHERENT_BIT |
- GL_DYNAMIC_STORAGE_BIT |
- GL_CLIENT_STORAGE_BIT)) {
+ GLbitfield valid_flags = GL_MAP_READ_BIT |
+ GL_MAP_WRITE_BIT |
+ GL_MAP_PERSISTENT_BIT |
+ GL_MAP_COHERENT_BIT |
+ GL_DYNAMIC_STORAGE_BIT |
+ GL_CLIENT_STORAGE_BIT;
+
+ if (ctx->Extensions.ARB_sparse_buffer)
+ valid_flags |= GL_SPARSE_STORAGE_BIT_ARB;
+
+ if (flags & ~valid_flags) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(invalid flag bits set)", func);
- return;
+ return false;
+ }
+
+ /* The Errors section of the GL_ARB_sparse_buffer spec says:
+ *
+ * "INVALID_VALUE is generated by BufferStorage if <flags> contains
+ * SPARSE_STORAGE_BIT_ARB and <flags> also contains any combination of
+ * MAP_READ_BIT or MAP_WRITE_BIT."
+ */
+ if (flags & GL_SPARSE_STORAGE_BIT_ARB &&
+ flags & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "%s(SPARSE_STORAGE and READ/WRITE)", func);
+ return false;
}
if (flags & GL_MAP_PERSISTENT_BIT &&
!(flags & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT))) {
_mesa_error(ctx, GL_INVALID_VALUE,
"%s(PERSISTENT and flags!=READ/WRITE)", func);
- return;
+ return false;
}
if (flags & GL_MAP_COHERENT_BIT && !(flags & GL_MAP_PERSISTENT_BIT)) {
_mesa_error(ctx, GL_INVALID_VALUE,
"%s(COHERENT and flags!=PERSISTENT)", func);
- return;
+ return false;
}
- if (bufObj->Immutable) {
+ if (bufObj->Immutable || bufObj->HandleAllocated) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(immutable)", func);
- return;
+ return false;
}
+ return true;
+}
+
+
+static void
+buffer_storage(struct gl_context *ctx, struct gl_buffer_object *bufObj,
+ GLenum target, GLsizeiptr size, const GLvoid *data,
+ GLbitfield flags, const char *func)
+{
/* Unmap the existing buffer. We'll replace it now. Not an error. */
_mesa_buffer_unmap_all_mappings(ctx, bufObj);
- FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT);
+ FLUSH_VERTICES(ctx, 0);
bufObj->Written = GL_TRUE;
bufObj->Immutable = GL_TRUE;
+ bufObj->MinMaxCacheDirty = true;
assert(ctx->Driver.BufferData);
if (!ctx->Driver.BufferData(ctx, target, size, data, GL_DYNAMIC_DRAW,
}
}
+
+static ALWAYS_INLINE void
+inlined_buffer_storage(GLenum target, GLuint buffer, GLsizeiptr size,
+ const GLvoid *data, GLbitfield flags, bool dsa,
+ bool no_error, const char *func)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj;
+
+ if (dsa) {
+ if (no_error) {
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ } else {
+ bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, func);
+ if (!bufObj)
+ return;
+ }
+ } else {
+ if (no_error) {
+ struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
+ bufObj = *bufObjPtr;
+ } else {
+ bufObj = get_buffer(ctx, func, target, GL_INVALID_OPERATION);
+ if (!bufObj)
+ return;
+ }
+ }
+
+ if (no_error || validate_buffer_storage(ctx, bufObj, size, flags, func))
+ buffer_storage(ctx, bufObj, target, size, data, flags, func);
+}
+
+
+void GLAPIENTRY
+_mesa_BufferStorage_no_error(GLenum target, GLsizeiptr size,
+ const GLvoid *data, GLbitfield flags)
+{
+ inlined_buffer_storage(target, 0, size, data, flags, false, true,
+ "glBufferStorage");
+}
+
+
void GLAPIENTRY
_mesa_BufferStorage(GLenum target, GLsizeiptr size, const GLvoid *data,
GLbitfield flags)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_buffer_object *bufObj;
+ inlined_buffer_storage(target, 0, size, data, flags, false, false,
+ "glBufferStorage");
+}
- bufObj = get_buffer(ctx, "glBufferStorage", target, GL_INVALID_OPERATION);
- if (!bufObj)
- return;
- _mesa_buffer_storage(ctx, bufObj, target, size, data, flags,
- "glBufferStorage");
+void GLAPIENTRY
+_mesa_NamedBufferStorage_no_error(GLuint buffer, GLsizeiptr size,
+ const GLvoid *data, GLbitfield flags)
+{
+ /* In direct state access, buffer objects have an unspecified target
+ * since they are not required to be bound.
+ */
+ inlined_buffer_storage(GL_NONE, buffer, size, data, flags, true, true,
+ "glNamedBufferStorage");
}
+
void GLAPIENTRY
_mesa_NamedBufferStorage(GLuint buffer, GLsizeiptr size, const GLvoid *data,
GLbitfield flags)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_buffer_object *bufObj;
-
- bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, "glNamedBufferStorage");
- if (!bufObj)
- return;
-
- /*
- * In direct state access, buffer objects have an unspecified target since
- * they are not required to be bound.
+ /* In direct state access, buffer objects have an unspecified target
+ * since they are not required to be bound.
*/
- _mesa_buffer_storage(ctx, bufObj, GL_NONE, size, data, flags,
- "glNamedBufferStorage");
+ inlined_buffer_storage(GL_NONE, buffer, size, data, flags, true, false,
+ "glNamedBufferStorage");
}
return;
}
- if (bufObj->Immutable) {
+ if (bufObj->Immutable || bufObj->HandleAllocated) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(immutable)", func);
return;
}
/* Unmap the existing buffer. We'll replace it now. Not an error. */
_mesa_buffer_unmap_all_mappings(ctx, bufObj);
- FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT);
+ FLUSH_VERTICES(ctx, 0);
bufObj->Written = GL_TRUE;
+ bufObj->MinMaxCacheDirty = true;
#ifdef VBO_DEBUG
printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",
}
-/**
- * Implementation for glBufferSubData and glNamedBufferSubData.
- *
- * \param ctx GL context.
- * \param bufObj The buffer object.
- * \param offset Offset of the first byte of the subdata range.
- * \param size Size, in bytes, of the subdata range.
- * \param data The data store.
- * \param func Name of calling function for recording errors.
- *
- */
-void
-_mesa_buffer_sub_data(struct gl_context *ctx, struct gl_buffer_object *bufObj,
- GLintptr offset, GLsizeiptr size, const GLvoid *data,
- const char *func)
+static bool
+validate_buffer_sub_data(struct gl_context *ctx,
+ struct gl_buffer_object *bufObj,
+ GLintptr offset, GLsizeiptr size,
+ const char *func)
{
if (!buffer_object_subdata_range_good(ctx, bufObj, offset, size,
- false, func)) {
+ true, func)) {
/* error already recorded */
- return;
+ return false;
}
if (bufObj->Immutable &&
!(bufObj->StorageFlags & GL_DYNAMIC_STORAGE_BIT)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s", func);
- return;
+ return false;
}
- if (size == 0)
- return;
-
- bufObj->NumSubDataCalls++;
-
if ((bufObj->Usage == GL_STATIC_DRAW ||
bufObj->Usage == GL_STATIC_COPY) &&
- bufObj->NumSubDataCalls >= BUFFER_WARNING_CALL_COUNT) {
+ bufObj->NumSubDataCalls >= BUFFER_WARNING_CALL_COUNT - 1) {
/* If the application declared the buffer as static draw/copy or stream
* draw, it should not be frequently modified with glBufferSubData.
*/
_mesa_enum_to_string(bufObj->Usage));
}
+ return true;
+}
+
+
+/**
+ * Implementation for glBufferSubData and glNamedBufferSubData.
+ *
+ * \param ctx GL context.
+ * \param bufObj The buffer object.
+ * \param offset Offset of the first byte of the subdata range.
+ * \param size Size, in bytes, of the subdata range.
+ * \param data The data store.
+ * \param func Name of calling function for recording errors.
+ *
+ */
+void
+_mesa_buffer_sub_data(struct gl_context *ctx, struct gl_buffer_object *bufObj,
+ GLintptr offset, GLsizeiptr size, const GLvoid *data)
+{
+ if (size == 0)
+ return;
+
+ bufObj->NumSubDataCalls++;
bufObj->Written = GL_TRUE;
+ bufObj->MinMaxCacheDirty = true;
assert(ctx->Driver.BufferSubData);
ctx->Driver.BufferSubData(ctx, offset, size, data, bufObj);
}
-void GLAPIENTRY
-_mesa_BufferSubData(GLenum target, GLintptr offset,
- GLsizeiptr size, const GLvoid *data)
+
+static ALWAYS_INLINE void
+buffer_sub_data(GLenum target, GLuint buffer, GLintptr offset,
+ GLsizeiptr size, const GLvoid *data,
+ bool dsa, bool no_error, const char *func)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
- bufObj = get_buffer(ctx, "glBufferSubData", target, GL_INVALID_OPERATION);
- if (!bufObj)
- return;
+ if (dsa) {
+ if (no_error) {
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ } else {
+ bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, func);
+ if (!bufObj)
+ return;
+ }
+ } else {
+ if (no_error) {
+ struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
+ bufObj = *bufObjPtr;
+ } else {
+ bufObj = get_buffer(ctx, func, target, GL_INVALID_OPERATION);
+ if (!bufObj)
+ return;
+ }
+ }
+
+ if (no_error || validate_buffer_sub_data(ctx, bufObj, offset, size, func))
+ _mesa_buffer_sub_data(ctx, bufObj, offset, size, data);
+}
+
- _mesa_buffer_sub_data(ctx, bufObj, offset, size, data, "glBufferSubData");
+void GLAPIENTRY
+_mesa_BufferSubData_no_error(GLenum target, GLintptr offset,
+ GLsizeiptr size, const GLvoid *data)
+{
+ buffer_sub_data(target, 0, offset, size, data, false, true,
+ "glBufferSubData");
}
+
void GLAPIENTRY
-_mesa_NamedBufferSubData(GLuint buffer, GLintptr offset,
- GLsizeiptr size, const GLvoid *data)
+_mesa_BufferSubData(GLenum target, GLintptr offset,
+ GLsizeiptr size, const GLvoid *data)
{
- GET_CURRENT_CONTEXT(ctx);
- struct gl_buffer_object *bufObj;
+ buffer_sub_data(target, 0, offset, size, data, false, false,
+ "glBufferSubData");
+}
- bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, "glNamedBufferSubData");
- if (!bufObj)
- return;
+void GLAPIENTRY
+_mesa_NamedBufferSubData_no_error(GLuint buffer, GLintptr offset,
+ GLsizeiptr size, const GLvoid *data)
+{
+ buffer_sub_data(0, buffer, offset, size, data, true, true,
+ "glNamedBufferSubData");
+}
- _mesa_buffer_sub_data(ctx, bufObj, offset, size, data,
- "glNamedBufferSubData");
+void GLAPIENTRY
+_mesa_NamedBufferSubData(GLuint buffer, GLintptr offset,
+ GLsizeiptr size, const GLvoid *data)
+{
+ buffer_sub_data(0, buffer, offset, size, data, true, false,
+ "glNamedBufferSubData");
}
/**
* \param subdata true if caller is *SubData, false if *Data
*/
-void
-_mesa_clear_buffer_sub_data(struct gl_context *ctx,
- struct gl_buffer_object *bufObj,
- GLenum internalformat,
- GLintptr offset, GLsizeiptr size,
- GLenum format, GLenum type,
- const GLvoid *data,
- const char *func, bool subdata)
+static void
+clear_buffer_sub_data(struct gl_context *ctx, struct gl_buffer_object *bufObj,
+ GLenum internalformat, GLintptr offset, GLsizeiptr size,
+ GLenum format, GLenum type, const GLvoid *data,
+ const char *func, bool subdata)
{
mesa_format mesaFormat;
GLubyte clearValue[MAX_PIXEL_BYTES];
return;
}
+ /* Bail early. Negative size has already been checked. */
+ if (size == 0)
+ return;
+
+ bufObj->MinMaxCacheDirty = true;
+
if (data == NULL) {
/* clear to zeros, per the spec */
- if (size > 0) {
- ctx->Driver.ClearBufferSubData(ctx, offset, size,
- NULL, clearValueSize, bufObj);
- }
+ ctx->Driver.ClearBufferSubData(ctx, offset, size,
+ NULL, clearValueSize, bufObj);
return;
}
return;
}
- if (size > 0) {
- ctx->Driver.ClearBufferSubData(ctx, offset, size,
- clearValue, clearValueSize, bufObj);
- }
+ ctx->Driver.ClearBufferSubData(ctx, offset, size,
+ clearValue, clearValueSize, bufObj);
}
void GLAPIENTRY
if (!bufObj)
return;
- _mesa_clear_buffer_sub_data(ctx, bufObj, internalformat, 0, bufObj->Size,
- format, type, data,
- "glClearBufferData", false);
+ clear_buffer_sub_data(ctx, bufObj, internalformat, 0, bufObj->Size,
+ format, type, data, "glClearBufferData", false);
}
void GLAPIENTRY
if (!bufObj)
return;
- _mesa_clear_buffer_sub_data(ctx, bufObj, internalformat, 0, bufObj->Size,
- format, type, data,
- "glClearNamedBufferData", false);
+ clear_buffer_sub_data(ctx, bufObj, internalformat, 0, bufObj->Size,
+ format, type, data, "glClearNamedBufferData", false);
}
if (!bufObj)
return;
- _mesa_clear_buffer_sub_data(ctx, bufObj, internalformat, offset, size,
- format, type, data,
- "glClearBufferSubData", true);
+ clear_buffer_sub_data(ctx, bufObj, internalformat, offset, size,
+ format, type, data, "glClearBufferSubData", true);
}
void GLAPIENTRY
if (!bufObj)
return;
- _mesa_clear_buffer_sub_data(ctx, bufObj, internalformat, offset, size,
- format, type, data,
- "glClearNamedBufferSubData", true);
+ clear_buffer_sub_data(ctx, bufObj, internalformat, offset, size, format,
+ type, data, "glClearNamedBufferSubData", true);
}
+static GLboolean
+unmap_buffer(struct gl_context *ctx, struct gl_buffer_object *bufObj)
+{
+ GLboolean status = ctx->Driver.UnmapBuffer(ctx, bufObj, MAP_USER);
+ bufObj->Mappings[MAP_USER].AccessFlags = 0;
+ assert(bufObj->Mappings[MAP_USER].Pointer == NULL);
+ assert(bufObj->Mappings[MAP_USER].Offset == 0);
+ assert(bufObj->Mappings[MAP_USER].Length == 0);
+
+ return status;
+}
-GLboolean
-_mesa_unmap_buffer(struct gl_context *ctx, struct gl_buffer_object *bufObj,
- const char *func)
+static GLboolean
+validate_and_unmap_buffer(struct gl_context *ctx,
+ struct gl_buffer_object *bufObj,
+ const char *func)
{
- GLboolean status = GL_TRUE;
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
if (!_mesa_bufferobj_mapped(bufObj, MAP_USER)) {
}
#endif
- status = ctx->Driver.UnmapBuffer(ctx, bufObj, MAP_USER);
- bufObj->Mappings[MAP_USER].AccessFlags = 0;
- assert(bufObj->Mappings[MAP_USER].Pointer == NULL);
- assert(bufObj->Mappings[MAP_USER].Offset == 0);
- assert(bufObj->Mappings[MAP_USER].Length == 0);
+ return unmap_buffer(ctx, bufObj);
+}
- return status;
+GLboolean GLAPIENTRY
+_mesa_UnmapBuffer_no_error(GLenum target)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
+ struct gl_buffer_object *bufObj = *bufObjPtr;
+
+ return unmap_buffer(ctx, bufObj);
}
GLboolean GLAPIENTRY
if (!bufObj)
return GL_FALSE;
- return _mesa_unmap_buffer(ctx, bufObj, "glUnmapBuffer");
+ return validate_and_unmap_buffer(ctx, bufObj, "glUnmapBuffer");
+}
+
+GLboolean GLAPIENTRY
+_mesa_UnmapNamedBuffer_no_error(GLuint buffer)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+
+ return unmap_buffer(ctx, bufObj);
}
GLboolean GLAPIENTRY
if (!bufObj)
return GL_FALSE;
- return _mesa_unmap_buffer(ctx, bufObj, "glUnmapNamedBuffer");
+ return validate_and_unmap_buffer(ctx, bufObj, "glUnmapNamedBuffer");
}
}
-void
-_mesa_copy_buffer_sub_data(struct gl_context *ctx,
- struct gl_buffer_object *src,
- struct gl_buffer_object *dst,
- GLintptr readOffset, GLintptr writeOffset,
- GLsizeiptr size, const char *func)
+static void
+copy_buffer_sub_data(struct gl_context *ctx, struct gl_buffer_object *src,
+ struct gl_buffer_object *dst, GLintptr readOffset,
+ GLintptr writeOffset, GLsizeiptr size, const char *func)
{
if (_mesa_check_disallowed_mapping(src)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
}
}
+ dst->MinMaxCacheDirty = true;
+
ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset, size);
}
void GLAPIENTRY
-_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
- GLintptr readOffset, GLintptr writeOffset,
+_mesa_CopyBufferSubData_no_error(GLenum readTarget, GLenum writeTarget,
+ GLintptr readOffset, GLintptr writeOffset,
+ GLsizeiptr size)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_buffer_object **src_ptr = get_buffer_target(ctx, readTarget);
+ struct gl_buffer_object *src = *src_ptr;
+
+ struct gl_buffer_object **dst_ptr = get_buffer_target(ctx, writeTarget);
+ struct gl_buffer_object *dst = *dst_ptr;
+
+ dst->MinMaxCacheDirty = true;
+ ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset,
+ size);
+}
+
+void GLAPIENTRY
+_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
+ GLintptr readOffset, GLintptr writeOffset,
GLsizeiptr size)
{
GET_CURRENT_CONTEXT(ctx);
if (!dst)
return;
- _mesa_copy_buffer_sub_data(ctx, src, dst, readOffset, writeOffset, size,
- "glCopyBufferSubData");
+ copy_buffer_sub_data(ctx, src, dst, readOffset, writeOffset, size,
+ "glCopyBufferSubData");
+}
+
+void GLAPIENTRY
+_mesa_CopyNamedBufferSubData_no_error(GLuint readBuffer, GLuint writeBuffer,
+ GLintptr readOffset,
+ GLintptr writeOffset, GLsizeiptr size)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_buffer_object *src = _mesa_lookup_bufferobj(ctx, readBuffer);
+ struct gl_buffer_object *dst = _mesa_lookup_bufferobj(ctx, writeBuffer);
+
+ dst->MinMaxCacheDirty = true;
+ ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset,
+ size);
}
void GLAPIENTRY
if (!dst)
return;
- _mesa_copy_buffer_sub_data(ctx, src, dst, readOffset, writeOffset, size,
- "glCopyNamedBufferSubData");
+ copy_buffer_sub_data(ctx, src, dst, readOffset, writeOffset, size,
+ "glCopyNamedBufferSubData");
}
-
-void *
-_mesa_map_buffer_range(struct gl_context *ctx,
- struct gl_buffer_object *bufObj,
- GLintptr offset, GLsizeiptr length,
- GLbitfield access, const char *func)
+static bool
+validate_map_buffer_range(struct gl_context *ctx,
+ struct gl_buffer_object *bufObj, GLintptr offset,
+ GLsizeiptr length, GLbitfield access,
+ const char *func)
{
- void *map;
GLbitfield allowed_access;
- ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
+ ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, false);
if (offset < 0) {
_mesa_error(ctx, GL_INVALID_VALUE,
"%s(offset %ld < 0)", func, (long) offset);
- return NULL;
+ return false;
}
if (length < 0) {
_mesa_error(ctx, GL_INVALID_VALUE,
"%s(length %ld < 0)", func, (long) length);
- return NULL;
+ return false;
}
/* Page 38 of the PDF of the OpenGL ES 3.0 spec says:
*/
if (length == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(length = 0)", func);
- return NULL;
+ return false;
}
allowed_access = GL_MAP_READ_BIT |
/* generate an error if any bits other than those allowed are set */
_mesa_error(ctx, GL_INVALID_VALUE,
"%s(access has undefined bits set)", func);
- return NULL;
+ return false;
}
if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(access indicates neither read or write)", func);
- return NULL;
+ return false;
}
if ((access & GL_MAP_READ_BIT) &&
GL_MAP_UNSYNCHRONIZED_BIT))) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(read access with disallowed bits)", func);
- return NULL;
+ return false;
}
if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) &&
((access & GL_MAP_WRITE_BIT) == 0)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(access has flush explicit without write)", func);
- return NULL;
+ return false;
}
if (access & GL_MAP_READ_BIT &&
!(bufObj->StorageFlags & GL_MAP_READ_BIT)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(buffer does not allow read access)", func);
- return NULL;
+ return false;
}
if (access & GL_MAP_WRITE_BIT &&
!(bufObj->StorageFlags & GL_MAP_WRITE_BIT)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(buffer does not allow write access)", func);
- return NULL;
+ return false;
}
if (access & GL_MAP_COHERENT_BIT &&
!(bufObj->StorageFlags & GL_MAP_COHERENT_BIT)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(buffer does not allow coherent access)", func);
- return NULL;
+ return false;
}
if (access & GL_MAP_PERSISTENT_BIT &&
!(bufObj->StorageFlags & GL_MAP_PERSISTENT_BIT)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(buffer does not allow persistent access)", func);
- return NULL;
+ return false;
}
if (offset + length > bufObj->Size) {
_mesa_error(ctx, GL_INVALID_VALUE,
- "%s(offset %td + length %td > buffer_size %td)", func,
- offset, length, bufObj->Size);
- return NULL;
+ "%s(offset %lu + length %lu > buffer_size %lu)", func,
+ (unsigned long) offset, (unsigned long) length,
+ (unsigned long) bufObj->Size);
+ return false;
}
if (_mesa_bufferobj_mapped(bufObj, MAP_USER)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(buffer already mapped)", func);
- return NULL;
- }
-
- if (!bufObj->Size) {
- _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s(buffer size = 0)", func);
- return NULL;
+ return false;
}
if (access & GL_MAP_WRITE_BIT) {
}
}
+ return true;
+}
+
+static void *
+map_buffer_range(struct gl_context *ctx, struct gl_buffer_object *bufObj,
+ GLintptr offset, GLsizeiptr length, GLbitfield access,
+ const char *func)
+{
+ if (!bufObj->Size) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s(buffer size = 0)", func);
+ return NULL;
+ }
+
assert(ctx->Driver.MapBufferRange);
- map = ctx->Driver.MapBufferRange(ctx, offset, length, access, bufObj,
- MAP_USER);
+ void *map = ctx->Driver.MapBufferRange(ctx, offset, length, access, bufObj,
+ MAP_USER);
if (!map) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "%s(map failed)", func);
}
assert(bufObj->Mappings[MAP_USER].AccessFlags == access);
}
- if (access & GL_MAP_WRITE_BIT)
+ if (access & GL_MAP_WRITE_BIT) {
bufObj->Written = GL_TRUE;
+ bufObj->MinMaxCacheDirty = true;
+ }
#ifdef VBO_DEBUG
if (strstr(func, "Range") == NULL) { /* If not MapRange */
return map;
}
+void * GLAPIENTRY
+_mesa_MapBufferRange_no_error(GLenum target, GLintptr offset,
+ GLsizeiptr length, GLbitfield access)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
+ struct gl_buffer_object *bufObj = *bufObjPtr;
+
+ return map_buffer_range(ctx, bufObj, offset, length, access,
+ "glMapBufferRange");
+}
+
void * GLAPIENTRY
_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
GLbitfield access)
if (!bufObj)
return NULL;
- return _mesa_map_buffer_range(ctx, bufObj, offset, length, access,
- "glMapBufferRange");
+ if (!validate_map_buffer_range(ctx, bufObj, offset, length, access,
+ "glMapBufferRange"))
+ return NULL;
+
+ return map_buffer_range(ctx, bufObj, offset, length, access,
+ "glMapBufferRange");
+}
+
+void * GLAPIENTRY
+_mesa_MapNamedBufferRange_no_error(GLuint buffer, GLintptr offset,
+ GLsizeiptr length, GLbitfield access)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+
+ return map_buffer_range(ctx, bufObj, offset, length, access,
+ "glMapNamedBufferRange");
}
void * GLAPIENTRY
if (!bufObj)
return NULL;
- return _mesa_map_buffer_range(ctx, bufObj, offset, length, access,
- "glMapNamedBufferRange");
+ if (!validate_map_buffer_range(ctx, bufObj, offset, length, access,
+ "glMapNamedBufferRange"))
+ return NULL;
+
+ return map_buffer_range(ctx, bufObj, offset, length, access,
+ "glMapNamedBufferRange");
}
/**
* Converts GLenum access from MapBuffer and MapNamedBuffer into
- * flags for input to _mesa_map_buffer_range.
+ * flags for input to map_buffer_range.
*
* \return true if the type of requested access is permissible.
*/
}
}
+void * GLAPIENTRY
+_mesa_MapBuffer_no_error(GLenum target, GLenum access)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLbitfield accessFlags;
+ get_map_buffer_access_flags(ctx, access, &accessFlags);
+
+ struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
+ struct gl_buffer_object *bufObj = *bufObjPtr;
+
+ return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
+ "glMapBuffer");
+}
+
void * GLAPIENTRY
_mesa_MapBuffer(GLenum target, GLenum access)
{
if (!bufObj)
return NULL;
- return _mesa_map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
- "glMapBuffer");
+ if (!validate_map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
+ "glMapBuffer"))
+ return NULL;
+
+ return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
+ "glMapBuffer");
+}
+
+void * GLAPIENTRY
+_mesa_MapNamedBuffer_no_error(GLuint buffer, GLenum access)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLbitfield accessFlags;
+ get_map_buffer_access_flags(ctx, access, &accessFlags);
+
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+
+ return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
+ "glMapNamedBuffer");
}
void * GLAPIENTRY
if (!bufObj)
return NULL;
- return _mesa_map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
- "glMapNamedBuffer");
+ if (!validate_map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
+ "glMapNamedBuffer"))
+ return NULL;
+
+ return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
+ "glMapNamedBuffer");
}
-void
-_mesa_flush_mapped_buffer_range(struct gl_context *ctx,
- struct gl_buffer_object *bufObj,
- GLintptr offset, GLsizeiptr length,
- const char *func)
+static void
+flush_mapped_buffer_range(struct gl_context *ctx,
+ struct gl_buffer_object *bufObj,
+ GLintptr offset, GLsizeiptr length,
+ const char *func)
{
if (!ctx->Extensions.ARB_map_buffer_range) {
_mesa_error(ctx, GL_INVALID_OPERATION,
MAP_USER);
}
+void GLAPIENTRY
+_mesa_FlushMappedBufferRange_no_error(GLenum target, GLintptr offset,
+ GLsizeiptr length)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object **bufObjPtr = get_buffer_target(ctx, target);
+ struct gl_buffer_object *bufObj = *bufObjPtr;
+
+ if (ctx->Driver.FlushMappedBufferRange)
+ ctx->Driver.FlushMappedBufferRange(ctx, offset, length, bufObj,
+ MAP_USER);
+}
+
void GLAPIENTRY
_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset,
GLsizeiptr length)
if (!bufObj)
return;
- _mesa_flush_mapped_buffer_range(ctx, bufObj, offset, length,
- "glFlushMappedBufferRange");
+ flush_mapped_buffer_range(ctx, bufObj, offset, length,
+ "glFlushMappedBufferRange");
+}
+
+void GLAPIENTRY
+_mesa_FlushMappedNamedBufferRange_no_error(GLuint buffer, GLintptr offset,
+ GLsizeiptr length)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+
+ if (ctx->Driver.FlushMappedBufferRange)
+ ctx->Driver.FlushMappedBufferRange(ctx, offset, length, bufObj,
+ MAP_USER);
}
void GLAPIENTRY
if (!bufObj)
return;
- _mesa_flush_mapped_buffer_range(ctx, bufObj, offset, length,
- "glFlushMappedNamedBufferRange");
+ flush_mapped_buffer_range(ctx, bufObj, offset, length,
+ "glFlushMappedNamedBufferRange");
}
set_ssbo_binding(ctx, binding, bufObj, offset, size, autoSize);
}
+static void
+bind_buffer_range_uniform_buffer(struct gl_context *ctx, GLuint index,
+ struct gl_buffer_object *bufObj,
+ GLintptr offset, GLsizeiptr size)
+{
+ if (bufObj == ctx->Shared->NullBufferObj) {
+ offset = -1;
+ size = -1;
+ }
+
+ _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, bufObj);
+ bind_uniform_buffer(ctx, index, bufObj, offset, size, GL_FALSE);
+}
+
/**
* Bind a region of a buffer object to a uniform block binding point.
* \param index the uniform buffer binding point index
* \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)
+bind_buffer_range_uniform_buffer_err(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;
}
+ bind_buffer_range_uniform_buffer(ctx, index, bufObj, offset, size);
+}
+
+static void
+bind_buffer_range_shader_storage_buffer(struct gl_context *ctx,
+ GLuint index,
+ struct gl_buffer_object *bufObj,
+ GLintptr offset,
+ GLsizeiptr size)
+{
if (bufObj == ctx->Shared->NullBufferObj) {
offset = -1;
size = -1;
}
- _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, bufObj);
- bind_uniform_buffer(ctx, index, bufObj, offset, size, GL_FALSE);
+ _mesa_reference_buffer_object(ctx, &ctx->ShaderStorageBuffer, bufObj);
+ bind_shader_storage_buffer(ctx, index, bufObj, offset, size, GL_FALSE);
}
/**
* \param size size of the buffer object region
*/
static void
-bind_buffer_range_shader_storage_buffer(struct gl_context *ctx,
- GLuint index,
- struct gl_buffer_object *bufObj,
- GLintptr offset,
- GLsizeiptr size)
+bind_buffer_range_shader_storage_buffer_err(struct gl_context *ctx,
+ GLuint index,
+ struct gl_buffer_object *bufObj,
+ GLintptr offset, GLsizeiptr size)
{
if (index >= ctx->Const.MaxShaderStorageBufferBindings) {
_mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(index=%d)", index);
return;
}
- if (bufObj == ctx->Shared->NullBufferObj) {
- offset = -1;
- size = -1;
- }
-
- _mesa_reference_buffer_object(ctx, &ctx->ShaderStorageBuffer, bufObj);
- bind_shader_storage_buffer(ctx, index, bufObj, offset, size, GL_FALSE);
+ bind_buffer_range_shader_storage_buffer(ctx, index, bufObj, offset, size);
}
/**
_mesa_reference_buffer_object(ctx, &binding->BufferObject, bufObj);
if (bufObj == ctx->Shared->NullBufferObj) {
- binding->Offset = -1;
- binding->Size = -1;
+ binding->Offset = 0;
+ binding->Size = 0;
} else {
binding->Offset = offset;
binding->Size = size;
}
}
+static void
+bind_atomic_buffer(struct gl_context *ctx, unsigned index,
+ struct gl_buffer_object *bufObj, GLintptr offset,
+ GLsizeiptr size)
+{
+ _mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer, bufObj);
+
+ struct gl_atomic_buffer_binding *binding =
+ &ctx->AtomicBufferBindings[index];
+ if (binding->BufferObject == bufObj &&
+ binding->Offset == offset &&
+ binding->Size == size) {
+ return;
+ }
+
+ FLUSH_VERTICES(ctx, 0);
+ ctx->NewDriverState |= ctx->DriverFlags.NewAtomicBuffer;
+
+ set_atomic_buffer_binding(ctx, binding, bufObj, offset, size);
+}
+
/**
* Binds a buffer object to an atomic buffer binding point.
*
* updating it.
*/
static void
-bind_atomic_buffer(struct gl_context *ctx,
- unsigned index,
- struct gl_buffer_object *bufObj,
- GLintptr offset,
- GLsizeiptr size,
- const char *name)
+bind_atomic_buffer_err(struct gl_context *ctx, unsigned index,
+ struct gl_buffer_object *bufObj, GLintptr offset,
+ GLsizeiptr size, const char *name)
{
- struct gl_atomic_buffer_binding *binding;
-
if (index >= ctx->Const.MaxAtomicBufferBindings) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%d)", name, index);
return;
return;
}
- _mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer, bufObj);
-
- binding = &ctx->AtomicBufferBindings[index];
- if (binding->BufferObject == bufObj &&
- binding->Offset == offset &&
- binding->Size == size) {
- return;
- }
-
- FLUSH_VERTICES(ctx, 0);
- ctx->NewDriverState |= ctx->DriverFlags.NewAtomicBuffer;
-
- set_atomic_buffer_binding(ctx, binding, bufObj, offset, size);
+ bind_atomic_buffer(ctx, index, bufObj, offset, size);
}
static inline bool
const GLsizeiptr *sizes)
{
if (offsets[index] < 0) {
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_VALUE error is generated by BindBuffersRange if any
- * value in <offsets> is less than zero (per binding)."
- */
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_VALUE error is generated by BindBuffersRange if any
+ * value in <offsets> is less than zero (per binding)."
+ */
_mesa_error(ctx, GL_INVALID_VALUE,
"glBindBuffersRange(offsets[%u]=%" PRId64 " < 0)",
index, (int64_t) offsets[index]);
}
if (sizes[index] <= 0) {
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_VALUE error is generated by BindBuffersRange if any
- * value in <sizes> is less than or equal to zero (per binding)."
- */
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_VALUE error is generated by BindBuffersRange if any
+ * value in <sizes> is less than or equal to zero (per binding)."
+ */
_mesa_error(ctx, GL_INVALID_VALUE,
"glBindBuffersRange(sizes[%u]=%" PRId64 " <= 0)",
index, (int64_t) sizes[index]);
unbind_uniform_buffers(struct gl_context *ctx, GLuint first, GLsizei count)
{
struct gl_buffer_object *bufObj = ctx->Shared->NullBufferObj;
- GLint i;
- for (i = 0; i < count; i++)
+ for (int i = 0; i < count; i++)
set_ubo_binding(ctx, &ctx->UniformBufferBindings[first + i],
bufObj, -1, -1, GL_TRUE);
}
GLsizei count)
{
struct gl_buffer_object *bufObj = ctx->Shared->NullBufferObj;
- GLint i;
- for (i = 0; i < count; i++)
+ for (int i = 0; i < count; i++)
set_ssbo_binding(ctx, &ctx->ShaderStorageBufferBindings[first + i],
bufObj, -1, -1, GL_TRUE);
}
static void
-bind_uniform_buffers_base(struct gl_context *ctx, GLuint first, GLsizei count,
- const GLuint *buffers)
+bind_uniform_buffers(struct gl_context *ctx, GLuint first, GLsizei count,
+ const GLuint *buffers,
+ bool range,
+ const GLintptr *offsets, const GLsizeiptr *sizes,
+ const char *caller)
{
- GLint i;
-
- if (!error_check_bind_uniform_buffers(ctx, first, count, "glBindBuffersBase"))
+ if (!error_check_bind_uniform_buffers(ctx, first, count, caller))
return;
/* Assume that at least one binding will be changed */
if (!buffers) {
/* The ARB_multi_bind spec says:
*
- * "If <buffers> is NULL, all bindings from <first> through
- * <first>+<count>-1 are reset to their unbound (zero) state."
+ * "If <buffers> is NULL, all bindings from <first> through
+ * <first>+<count>-1 are reset to their unbound (zero) state.
+ * In this case, the offsets and sizes associated with the
+ * binding points are set to default values, ignoring
+ * <offsets> and <sizes>."
*/
unbind_uniform_buffers(ctx, first, count);
return;
* parameters are valid and no other error occurs."
*/
- _mesa_begin_bufferobj_lookups(ctx);
+ _mesa_HashLockMutex(ctx->Shared->BufferObjects);
- for (i = 0; i < count; i++) {
+ for (int i = 0; i < count; i++) {
struct gl_uniform_buffer_binding *binding =
- &ctx->UniformBufferBindings[first + i];
+ &ctx->UniformBufferBindings[first + i];
struct gl_buffer_object *bufObj;
+ GLintptr offset = 0;
+ GLsizeiptr size = 0;
+
+ if (range) {
+ if (!bind_buffers_check_offset_and_size(ctx, i, offsets, sizes))
+ continue;
+
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_VALUE error is generated by BindBuffersRange if any
+ * pair of values in <offsets> and <sizes> does not respectively
+ * satisfy the constraints described for those parameters for the
+ * specified target, as described in section 6.7.1 (per binding)."
+ *
+ * Section 6.7.1 refers to table 6.5, which says:
+ *
+ * "┌───────────────────────────────────────────────────────────────┐
+ * │ Uniform buffer array bindings (see sec. 7.6) │
+ * ├─────────────────────┬─────────────────────────────────────────┤
+ * │ ... │ ... │
+ * │ offset restriction │ multiple of value of UNIFORM_BUFFER_- │
+ * │ │ OFFSET_ALIGNMENT │
+ * │ ... │ ... │
+ * │ size restriction │ none │
+ * └─────────────────────┴─────────────────────────────────────────┘"
+ */
+ if (offsets[i] & (ctx->Const.UniformBufferOffsetAlignment - 1)) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glBindBuffersRange(offsets[%u]=%" PRId64
+ " is misaligned; it must be a multiple of the value of "
+ "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT=%u when "
+ "target=GL_UNIFORM_BUFFER)",
+ i, (int64_t) offsets[i],
+ ctx->Const.UniformBufferOffsetAlignment);
+ continue;
+ }
+
+ offset = offsets[i];
+ size = sizes[i];
+ }
if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
bufObj = binding->BufferObject;
else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i,
- "glBindBuffersBase");
+ bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, caller);
if (bufObj) {
if (bufObj == ctx->Shared->NullBufferObj)
- set_ubo_binding(ctx, binding, bufObj, -1, -1, GL_TRUE);
+ set_ubo_binding(ctx, binding, bufObj, -1, -1, !range);
else
- set_ubo_binding(ctx, binding, bufObj, 0, 0, GL_TRUE);
+ set_ubo_binding(ctx, binding, bufObj, offset, size, !range);
}
}
- _mesa_end_bufferobj_lookups(ctx);
+ _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
}
static void
-bind_shader_storage_buffers_base(struct gl_context *ctx, GLuint first,
- GLsizei count, const GLuint *buffers)
+bind_shader_storage_buffers(struct gl_context *ctx, GLuint first,
+ GLsizei count, const GLuint *buffers,
+ bool range,
+ const GLintptr *offsets,
+ const GLsizeiptr *sizes,
+ const char *caller)
{
- GLint i;
-
- if (!error_check_bind_shader_storage_buffers(ctx, first, count,
- "glBindBuffersBase"))
+ if (!error_check_bind_shader_storage_buffers(ctx, first, count, caller))
return;
/* Assume that at least one binding will be changed */
if (!buffers) {
/* The ARB_multi_bind spec says:
*
- * "If <buffers> is NULL, all bindings from <first> through
- * <first>+<count>-1 are reset to their unbound (zero) state."
+ * "If <buffers> is NULL, all bindings from <first> through
+ * <first>+<count>-1 are reset to their unbound (zero) state.
+ * In this case, the offsets and sizes associated with the
+ * binding points are set to default values, ignoring
+ * <offsets> and <sizes>."
*/
unbind_shader_storage_buffers(ctx, first, count);
return;
* parameters are valid and no other error occurs."
*/
- _mesa_begin_bufferobj_lookups(ctx);
+ _mesa_HashLockMutex(ctx->Shared->BufferObjects);
- for (i = 0; i < count; i++) {
+ for (int i = 0; i < count; i++) {
struct gl_shader_storage_buffer_binding *binding =
- &ctx->ShaderStorageBufferBindings[first + i];
+ &ctx->ShaderStorageBufferBindings[first + i];
struct gl_buffer_object *bufObj;
+ GLintptr offset = 0;
+ GLsizeiptr size = 0;
+
+ if (range) {
+ if (!bind_buffers_check_offset_and_size(ctx, i, offsets, sizes))
+ continue;
+
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_VALUE error is generated by BindBuffersRange if any
+ * pair of values in <offsets> and <sizes> does not respectively
+ * satisfy the constraints described for those parameters for the
+ * specified target, as described in section 6.7.1 (per binding)."
+ *
+ * Section 6.7.1 refers to table 6.5, which says:
+ *
+ * "┌───────────────────────────────────────────────────────────────┐
+ * │ Shader storage buffer array bindings (see sec. 7.8) │
+ * ├─────────────────────┬─────────────────────────────────────────┤
+ * │ ... │ ... │
+ * │ offset restriction │ multiple of value of SHADER_STORAGE_- │
+ * │ │ BUFFER_OFFSET_ALIGNMENT │
+ * │ ... │ ... │
+ * │ size restriction │ none │
+ * └─────────────────────┴─────────────────────────────────────────┘"
+ */
+ if (offsets[i] & (ctx->Const.ShaderStorageBufferOffsetAlignment - 1)) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glBindBuffersRange(offsets[%u]=%" PRId64
+ " is misaligned; it must be a multiple of the value of "
+ "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT=%u when "
+ "target=GL_SHADER_STORAGE_BUFFER)",
+ i, (int64_t) offsets[i],
+ ctx->Const.ShaderStorageBufferOffsetAlignment);
+ continue;
+ }
+
+ offset = offsets[i];
+ size = sizes[i];
+ }
if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
bufObj = binding->BufferObject;
else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i,
- "glBindBuffersBase");
+ bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, caller);
if (bufObj) {
if (bufObj == ctx->Shared->NullBufferObj)
- set_ssbo_binding(ctx, binding, bufObj, -1, -1, GL_TRUE);
+ set_ssbo_binding(ctx, binding, bufObj, -1, -1, !range);
else
- set_ssbo_binding(ctx, binding, bufObj, 0, 0, GL_TRUE);
+ set_ssbo_binding(ctx, binding, bufObj, offset, size, !range);
}
}
- _mesa_end_bufferobj_lookups(ctx);
+ _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
}
-static void
-bind_uniform_buffers_range(struct gl_context *ctx, GLuint first, GLsizei count,
- const GLuint *buffers,
- const GLintptr *offsets, const GLsizeiptr *sizes)
+static bool
+error_check_bind_xfb_buffers(struct gl_context *ctx,
+ struct gl_transform_feedback_object *tfObj,
+ GLuint first, GLsizei count, const char *caller)
{
- GLint i;
-
- if (!error_check_bind_uniform_buffers(ctx, first, count,
- "glBindBuffersRange"))
- return;
-
- /* Assume that at least one binding will be changed */
- FLUSH_VERTICES(ctx, 0);
- ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
-
- if (!buffers) {
- /* The ARB_multi_bind spec says:
- *
- * "If <buffers> is NULL, all bindings from <first> through
- * <first>+<count>-1 are reset to their unbound (zero) state.
- * In this case, the offsets and sizes associated with the
- * binding points are set to default values, ignoring
- * <offsets> and <sizes>."
- */
- unbind_uniform_buffers(ctx, first, count);
- return;
+ if (!ctx->Extensions.EXT_transform_feedback) {
+ _mesa_error(ctx, GL_INVALID_ENUM,
+ "%s(target=GL_TRANSFORM_FEEDBACK_BUFFER)", caller);
+ return false;
}
- /* Note that the error semantics for multi-bind commands differ from
- * those of other GL commands.
- *
- * The Issues section in the ARB_multi_bind spec says:
- *
- * "(11) Typically, OpenGL specifies that if an error is generated by a
- * command, that command has no effect. This is somewhat
- * unfortunate for multi-bind commands, because it would require a
- * first pass to scan the entire list of bound objects for errors
- * and then a second pass to actually perform the bindings.
- * Should we have different error semantics?
- *
- * RESOLVED: Yes. In this specification, when the parameters for
- * one of the <count> binding points are invalid, that binding point
- * is not updated and an error will be generated. However, other
- * binding points in the same command will be updated if their
- * parameters are valid and no other error occurs."
- */
-
- _mesa_begin_bufferobj_lookups(ctx);
-
- for (i = 0; i < count; i++) {
- struct gl_uniform_buffer_binding *binding =
- &ctx->UniformBufferBindings[first + i];
- struct gl_buffer_object *bufObj;
-
- if (!bind_buffers_check_offset_and_size(ctx, i, offsets, sizes))
- continue;
-
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_VALUE error is generated by BindBuffersRange if any
- * pair of values in <offsets> and <sizes> does not respectively
- * satisfy the constraints described for those parameters for the
- * specified target, as described in section 6.7.1 (per binding)."
- *
- * Section 6.7.1 refers to table 6.5, which says:
- *
- * "┌───────────────────────────────────────────────────────────────┐
- * │ Uniform buffer array bindings (see sec. 7.6) │
- * ├─────────────────────┬─────────────────────────────────────────┤
- * │ ... │ ... │
- * │ offset restriction │ multiple of value of UNIFORM_BUFFER_- │
- * │ │ OFFSET_ALIGNMENT │
- * │ ... │ ... │
- * │ size restriction │ none │
- * └─────────────────────┴─────────────────────────────────────────┘"
- */
- if (offsets[i] & (ctx->Const.UniformBufferOffsetAlignment - 1)) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "glBindBuffersRange(offsets[%u]=%" PRId64
- " is misaligned; it must be a multiple of the value of "
- "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT=%u when "
- "target=GL_UNIFORM_BUFFER)",
- i, (int64_t) offsets[i],
- ctx->Const.UniformBufferOffsetAlignment);
- continue;
- }
-
- if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
- bufObj = binding->BufferObject;
- else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i,
- "glBindBuffersRange");
-
- if (bufObj) {
- if (bufObj == ctx->Shared->NullBufferObj)
- set_ubo_binding(ctx, binding, bufObj, -1, -1, GL_FALSE);
- else
- set_ubo_binding(ctx, binding, bufObj,
- offsets[i], sizes[i], GL_FALSE);
- }
- }
-
- _mesa_end_bufferobj_lookups(ctx);
-}
-
-static void
-bind_shader_storage_buffers_range(struct gl_context *ctx, GLuint first,
- GLsizei count, const GLuint *buffers,
- const GLintptr *offsets,
- const GLsizeiptr *sizes)
-{
- GLint i;
-
- if (!error_check_bind_shader_storage_buffers(ctx, first, count,
- "glBindBuffersRange"))
- return;
-
- /* Assume that at least one binding will be changed */
- FLUSH_VERTICES(ctx, 0);
- ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer;
-
- if (!buffers) {
- /* The ARB_multi_bind spec says:
- *
- * "If <buffers> is NULL, all bindings from <first> through
- * <first>+<count>-1 are reset to their unbound (zero) state.
- * In this case, the offsets and sizes associated with the
- * binding points are set to default values, ignoring
- * <offsets> and <sizes>."
- */
- unbind_shader_storage_buffers(ctx, first, count);
- return;
- }
-
- /* Note that the error semantics for multi-bind commands differ from
- * those of other GL commands.
- *
- * The Issues section in the ARB_multi_bind spec says:
- *
- * "(11) Typically, OpenGL specifies that if an error is generated by a
- * command, that command has no effect. This is somewhat
- * unfortunate for multi-bind commands, because it would require a
- * first pass to scan the entire list of bound objects for errors
- * and then a second pass to actually perform the bindings.
- * Should we have different error semantics?
- *
- * RESOLVED: Yes. In this specification, when the parameters for
- * one of the <count> binding points are invalid, that binding point
- * is not updated and an error will be generated. However, other
- * binding points in the same command will be updated if their
- * parameters are valid and no other error occurs."
- */
-
- _mesa_begin_bufferobj_lookups(ctx);
-
- for (i = 0; i < count; i++) {
- struct gl_shader_storage_buffer_binding *binding =
- &ctx->ShaderStorageBufferBindings[first + i];
- struct gl_buffer_object *bufObj;
-
- if (!bind_buffers_check_offset_and_size(ctx, i, offsets, sizes))
- continue;
-
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_VALUE error is generated by BindBuffersRange if any
- * pair of values in <offsets> and <sizes> does not respectively
- * satisfy the constraints described for those parameters for the
- * specified target, as described in section 6.7.1 (per binding)."
- *
- * Section 6.7.1 refers to table 6.5, which says:
- *
- * "┌───────────────────────────────────────────────────────────────┐
- * │ Shader storage buffer array bindings (see sec. 7.8) │
- * ├─────────────────────┬─────────────────────────────────────────┤
- * │ ... │ ... │
- * │ offset restriction │ multiple of value of SHADER_STORAGE_- │
- * │ │ BUFFER_OFFSET_ALIGNMENT │
- * │ ... │ ... │
- * │ size restriction │ none │
- * └─────────────────────┴─────────────────────────────────────────┘"
- */
- if (offsets[i] & (ctx->Const.ShaderStorageBufferOffsetAlignment - 1)) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "glBindBuffersRange(offsets[%u]=%" PRId64
- " is misaligned; it must be a multiple of the value of "
- "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT=%u when "
- "target=GL_SHADER_STORAGE_BUFFER)",
- i, (int64_t) offsets[i],
- ctx->Const.ShaderStorageBufferOffsetAlignment);
- continue;
- }
-
- if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
- bufObj = binding->BufferObject;
- else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i,
- "glBindBuffersRange");
-
- if (bufObj) {
- if (bufObj == ctx->Shared->NullBufferObj)
- set_ssbo_binding(ctx, binding, bufObj, -1, -1, GL_FALSE);
- else
- set_ssbo_binding(ctx, binding, bufObj,
- offsets[i], sizes[i], GL_FALSE);
- }
- }
-
- _mesa_end_bufferobj_lookups(ctx);
-}
-
-static bool
-error_check_bind_xfb_buffers(struct gl_context *ctx,
- struct gl_transform_feedback_object *tfObj,
- GLuint first, GLsizei count, const char *caller)
-{
- if (!ctx->Extensions.EXT_transform_feedback) {
- _mesa_error(ctx, GL_INVALID_ENUM,
- "%s(target=GL_TRANSFORM_FEEDBACK_BUFFER)", caller);
- return false;
- }
-
- /* Page 398 of the PDF of the OpenGL 4.4 (Core Profile) spec says:
+ /* Page 398 of the PDF of the OpenGL 4.4 (Core Profile) spec says:
*
* "An INVALID_OPERATION error is generated :
*
GLuint first, GLsizei count)
{
struct gl_buffer_object * const bufObj = ctx->Shared->NullBufferObj;
- GLint i;
- for (i = 0; i < count; i++)
+ for (int i = 0; i < count; i++)
_mesa_set_transform_feedback_binding(ctx, tfObj, first + i,
bufObj, 0, 0);
}
static void
-bind_xfb_buffers_base(struct gl_context *ctx,
- GLuint first, GLsizei count,
- const GLuint *buffers)
-{
- struct gl_transform_feedback_object *tfObj =
- ctx->TransformFeedback.CurrentObject;
- GLint i;
-
- if (!error_check_bind_xfb_buffers(ctx, tfObj, first, count,
- "glBindBuffersBase"))
- return;
-
- /* Assume that at least one binding will be changed */
- FLUSH_VERTICES(ctx, 0);
- ctx->NewDriverState |= ctx->DriverFlags.NewTransformFeedback;
-
- if (!buffers) {
- /* The ARB_multi_bind spec says:
- *
- * "If <buffers> is NULL, all bindings from <first> through
- * <first>+<count>-1 are reset to their unbound (zero) state."
- */
- unbind_xfb_buffers(ctx, tfObj, first, count);
- return;
- }
-
- /* Note that the error semantics for multi-bind commands differ from
- * those of other GL commands.
- *
- * The Issues section in the ARB_multi_bind spec says:
- *
- * "(11) Typically, OpenGL specifies that if an error is generated by a
- * command, that command has no effect. This is somewhat
- * unfortunate for multi-bind commands, because it would require a
- * first pass to scan the entire list of bound objects for errors
- * and then a second pass to actually perform the bindings.
- * Should we have different error semantics?
- *
- * RESOLVED: Yes. In this specification, when the parameters for
- * one of the <count> binding points are invalid, that binding point
- * is not updated and an error will be generated. However, other
- * binding points in the same command will be updated if their
- * parameters are valid and no other error occurs."
- */
-
- _mesa_begin_bufferobj_lookups(ctx);
-
- for (i = 0; i < count; i++) {
- struct gl_buffer_object * const boundBufObj = tfObj->Buffers[first + i];
- struct gl_buffer_object *bufObj;
-
- if (boundBufObj && boundBufObj->Name == buffers[i])
- bufObj = boundBufObj;
- else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i,
- "glBindBuffersBase");
-
- if (bufObj)
- _mesa_set_transform_feedback_binding(ctx, tfObj, first + i,
- bufObj, 0, 0);
- }
-
- _mesa_end_bufferobj_lookups(ctx);
-}
-
-static void
-bind_xfb_buffers_range(struct gl_context *ctx,
- GLuint first, GLsizei count,
- const GLuint *buffers,
- const GLintptr *offsets,
- const GLsizeiptr *sizes)
+bind_xfb_buffers(struct gl_context *ctx,
+ GLuint first, GLsizei count,
+ const GLuint *buffers,
+ bool range,
+ const GLintptr *offsets,
+ const GLsizeiptr *sizes,
+ const char *caller)
{
struct gl_transform_feedback_object *tfObj =
ctx->TransformFeedback.CurrentObject;
- GLint i;
- if (!error_check_bind_xfb_buffers(ctx, tfObj, first, count,
- "glBindBuffersRange"))
+ if (!error_check_bind_xfb_buffers(ctx, tfObj, first, count, caller))
return;
/* Assume that at least one binding will be changed */
* parameters are valid and no other error occurs."
*/
- _mesa_begin_bufferobj_lookups(ctx);
+ _mesa_HashLockMutex(ctx->Shared->BufferObjects);
- for (i = 0; i < count; i++) {
+ for (int i = 0; i < count; i++) {
const GLuint index = first + i;
struct gl_buffer_object * const boundBufObj = tfObj->Buffers[index];
struct gl_buffer_object *bufObj;
+ GLintptr offset = 0;
+ GLsizeiptr size = 0;
- if (!bind_buffers_check_offset_and_size(ctx, i, offsets, sizes))
- continue;
+ if (range) {
+ offset = offsets[i];
+ size = sizes[i];
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_VALUE error is generated by BindBuffersRange if any
- * pair of values in <offsets> and <sizes> does not respectively
- * satisfy the constraints described for those parameters for the
- * specified target, as described in section 6.7.1 (per binding)."
- *
- * Section 6.7.1 refers to table 6.5, which says:
- *
- * "┌───────────────────────────────────────────────────────────────┐
- * │ Transform feedback array bindings (see sec. 13.2.2) │
- * ├───────────────────────┬───────────────────────────────────────┤
- * │ ... │ ... │
- * │ offset restriction │ multiple of 4 │
- * │ ... │ ... │
- * │ size restriction │ multiple of 4 │
- * └───────────────────────┴───────────────────────────────────────┘"
- */
- if (offsets[i] & 0x3) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "glBindBuffersRange(offsets[%u]=%" PRId64
- " is misaligned; it must be a multiple of 4 when "
- "target=GL_TRANSFORM_FEEDBACK_BUFFER)",
- i, (int64_t) offsets[i]);
- continue;
- }
+ if (!bind_buffers_check_offset_and_size(ctx, i, offsets, sizes))
+ continue;
- if (sizes[i] & 0x3) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "glBindBuffersRange(sizes[%u]=%" PRId64
- " is misaligned; it must be a multiple of 4 when "
- "target=GL_TRANSFORM_FEEDBACK_BUFFER)",
- i, (int64_t) sizes[i]);
- continue;
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_VALUE error is generated by BindBuffersRange if any
+ * pair of values in <offsets> and <sizes> does not respectively
+ * satisfy the constraints described for those parameters for the
+ * specified target, as described in section 6.7.1 (per binding)."
+ *
+ * Section 6.7.1 refers to table 6.5, which says:
+ *
+ * "┌───────────────────────────────────────────────────────────────┐
+ * │ Transform feedback array bindings (see sec. 13.2.2) │
+ * ├───────────────────────┬───────────────────────────────────────┤
+ * │ ... │ ... │
+ * │ offset restriction │ multiple of 4 │
+ * │ ... │ ... │
+ * │ size restriction │ multiple of 4 │
+ * └───────────────────────┴───────────────────────────────────────┘"
+ */
+ if (offsets[i] & 0x3) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glBindBuffersRange(offsets[%u]=%" PRId64
+ " is misaligned; it must be a multiple of 4 when "
+ "target=GL_TRANSFORM_FEEDBACK_BUFFER)",
+ i, (int64_t) offsets[i]);
+ continue;
+ }
+
+ if (sizes[i] & 0x3) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glBindBuffersRange(sizes[%u]=%" PRId64
+ " is misaligned; it must be a multiple of 4 when "
+ "target=GL_TRANSFORM_FEEDBACK_BUFFER)",
+ i, (int64_t) sizes[i]);
+ continue;
+ }
+
+ offset = offsets[i];
+ size = sizes[i];
}
if (boundBufObj && boundBufObj->Name == buffers[i])
bufObj = boundBufObj;
else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i,
- "glBindBuffersRange");
+ bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, caller);
if (bufObj)
_mesa_set_transform_feedback_binding(ctx, tfObj, index, bufObj,
- offsets[i], sizes[i]);
+ offset, size);
}
- _mesa_end_bufferobj_lookups(ctx);
+ _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
}
static bool
unbind_atomic_buffers(struct gl_context *ctx, GLuint first, GLsizei count)
{
struct gl_buffer_object * const bufObj = ctx->Shared->NullBufferObj;
- GLint i;
- for (i = 0; i < count; i++)
+ for (int i = 0; i < count; i++)
set_atomic_buffer_binding(ctx, &ctx->AtomicBufferBindings[first + i],
bufObj, -1, -1);
}
static void
-bind_atomic_buffers_base(struct gl_context *ctx,
- GLuint first,
- GLsizei count,
- const GLuint *buffers)
-{
- GLint i;
-
- if (!error_check_bind_atomic_buffers(ctx, first, count,
- "glBindBuffersBase"))
- return;
-
- /* Assume that at least one binding will be changed */
- FLUSH_VERTICES(ctx, 0);
- ctx->NewDriverState |= ctx->DriverFlags.NewAtomicBuffer;
-
- if (!buffers) {
- /* The ARB_multi_bind spec says:
- *
- * "If <buffers> is NULL, all bindings from <first> through
- * <first>+<count>-1 are reset to their unbound (zero) state."
- */
- unbind_atomic_buffers(ctx, first, count);
- return;
- }
-
- /* Note that the error semantics for multi-bind commands differ from
- * those of other GL commands.
- *
- * The Issues section in the ARB_multi_bind spec says:
- *
- * "(11) Typically, OpenGL specifies that if an error is generated by a
- * command, that command has no effect. This is somewhat
- * unfortunate for multi-bind commands, because it would require a
- * first pass to scan the entire list of bound objects for errors
- * and then a second pass to actually perform the bindings.
- * Should we have different error semantics?
- *
- * RESOLVED: Yes. In this specification, when the parameters for
- * one of the <count> binding points are invalid, that binding point
- * is not updated and an error will be generated. However, other
- * binding points in the same command will be updated if their
- * parameters are valid and no other error occurs."
- */
-
- _mesa_begin_bufferobj_lookups(ctx);
-
- for (i = 0; i < count; i++) {
- struct gl_atomic_buffer_binding *binding =
- &ctx->AtomicBufferBindings[first + i];
- struct gl_buffer_object *bufObj;
-
- if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
- bufObj = binding->BufferObject;
- else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i,
- "glBindBuffersBase");
-
- if (bufObj)
- set_atomic_buffer_binding(ctx, binding, bufObj, 0, 0);
- }
-
- _mesa_end_bufferobj_lookups(ctx);
-}
-
-static void
-bind_atomic_buffers_range(struct gl_context *ctx,
- GLuint first,
- GLsizei count,
- const GLuint *buffers,
- const GLintptr *offsets,
- const GLsizeiptr *sizes)
+bind_atomic_buffers(struct gl_context *ctx,
+ GLuint first,
+ GLsizei count,
+ const GLuint *buffers,
+ bool range,
+ const GLintptr *offsets,
+ const GLsizeiptr *sizes,
+ const char *caller)
{
- GLint i;
-
- if (!error_check_bind_atomic_buffers(ctx, first, count,
- "glBindBuffersRange"))
+ if (!error_check_bind_atomic_buffers(ctx, first, count, caller))
return;
/* Assume that at least one binding will be changed */
* parameters are valid and no other error occurs."
*/
- _mesa_begin_bufferobj_lookups(ctx);
+ _mesa_HashLockMutex(ctx->Shared->BufferObjects);
- for (i = 0; i < count; i++) {
+ for (int i = 0; i < count; i++) {
struct gl_atomic_buffer_binding *binding =
&ctx->AtomicBufferBindings[first + i];
struct gl_buffer_object *bufObj;
+ GLintptr offset = 0;
+ GLsizeiptr size = 0;
- if (!bind_buffers_check_offset_and_size(ctx, i, offsets, sizes))
- continue;
+ if (range) {
+ if (!bind_buffers_check_offset_and_size(ctx, i, offsets, sizes))
+ continue;
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_VALUE error is generated by BindBuffersRange if any
- * pair of values in <offsets> and <sizes> does not respectively
- * satisfy the constraints described for those parameters for the
- * specified target, as described in section 6.7.1 (per binding)."
- *
- * Section 6.7.1 refers to table 6.5, which says:
- *
- * "┌───────────────────────────────────────────────────────────────┐
- * │ Atomic counter array bindings (see sec. 7.7.2) │
- * ├───────────────────────┬───────────────────────────────────────┤
- * │ ... │ ... │
- * │ offset restriction │ multiple of 4 │
- * │ ... │ ... │
- * │ size restriction │ none │
- * └───────────────────────┴───────────────────────────────────────┘"
- */
- if (offsets[i] & (ATOMIC_COUNTER_SIZE - 1)) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "glBindBuffersRange(offsets[%u]=%" PRId64
- " is misaligned; it must be a multiple of %d when "
- "target=GL_ATOMIC_COUNTER_BUFFER)",
- i, (int64_t) offsets[i], ATOMIC_COUNTER_SIZE);
- continue;
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_VALUE error is generated by BindBuffersRange if any
+ * pair of values in <offsets> and <sizes> does not respectively
+ * satisfy the constraints described for those parameters for the
+ * specified target, as described in section 6.7.1 (per binding)."
+ *
+ * Section 6.7.1 refers to table 6.5, which says:
+ *
+ * "┌───────────────────────────────────────────────────────────────┐
+ * │ Atomic counter array bindings (see sec. 7.7.2) │
+ * ├───────────────────────┬───────────────────────────────────────┤
+ * │ ... │ ... │
+ * │ offset restriction │ multiple of 4 │
+ * │ ... │ ... │
+ * │ size restriction │ none │
+ * └───────────────────────┴───────────────────────────────────────┘"
+ */
+ if (offsets[i] & (ATOMIC_COUNTER_SIZE - 1)) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glBindBuffersRange(offsets[%u]=%" PRId64
+ " is misaligned; it must be a multiple of %d when "
+ "target=GL_ATOMIC_COUNTER_BUFFER)",
+ i, (int64_t) offsets[i], ATOMIC_COUNTER_SIZE);
+ continue;
+ }
+
+ offset = offsets[i];
+ size = sizes[i];
}
if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
bufObj = binding->BufferObject;
else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i,
- "glBindBuffersRange");
+ bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, caller);
if (bufObj)
- set_atomic_buffer_binding(ctx, binding, bufObj, offsets[i], sizes[i]);
+ set_atomic_buffer_binding(ctx, binding, bufObj, offset, size);
}
- _mesa_end_bufferobj_lookups(ctx);
+ _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
}
-void GLAPIENTRY
-_mesa_BindBufferRange(GLenum target, GLuint index,
- GLuint buffer, GLintptr offset, GLsizeiptr size)
+static ALWAYS_INLINE void
+bind_buffer_range(GLenum target, GLuint index, GLuint buffer, GLintptr offset,
+ GLsizeiptr size, bool no_error)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
if (MESA_VERBOSE & VERBOSE_API) {
- _mesa_debug(ctx, "glBindBufferRange(%s, %u, %u, %ld, %ld)\n",
- _mesa_enum_to_string(target), index, buffer, offset, size);
+ _mesa_debug(ctx, "glBindBufferRange(%s, %u, %u, %lu, %lu)\n",
+ _mesa_enum_to_string(target), index, buffer,
+ (unsigned long) offset, (unsigned long) size);
}
if (buffer == 0) {
&bufObj, "glBindBufferRange"))
return;
- if (!bufObj) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "glBindBufferRange(invalid buffer=%u)", buffer);
- return;
- }
+ if (no_error) {
+ switch (target) {
+ case GL_TRANSFORM_FEEDBACK_BUFFER:
+ _mesa_bind_buffer_range_xfb(ctx, ctx->TransformFeedback.CurrentObject,
+ index, bufObj, offset, size);
+ return;
+ case GL_UNIFORM_BUFFER:
+ bind_buffer_range_uniform_buffer(ctx, index, bufObj, offset, size);
+ return;
+ case GL_SHADER_STORAGE_BUFFER:
+ bind_buffer_range_shader_storage_buffer(ctx, index, bufObj, offset,
+ size);
+ return;
+ case GL_ATOMIC_COUNTER_BUFFER:
+ bind_atomic_buffer(ctx, index, bufObj, offset, size);
+ return;
+ default:
+ unreachable("invalid BindBufferRange target with KHR_no_error");
+ }
+ } else {
+ if (!bufObj) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glBindBufferRange(invalid buffer=%u)", buffer);
+ return;
+ }
- if (buffer != 0) {
- if (size <= 0) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(size=%d)",
- (int) size);
+ if (buffer != 0) {
+ if (size <= 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(size=%d)",
+ (int) size);
+ return;
+ }
+ }
+
+ switch (target) {
+ case GL_TRANSFORM_FEEDBACK_BUFFER:
+ if (!_mesa_validate_buffer_range_xfb(ctx,
+ ctx->TransformFeedback.CurrentObject,
+ index, bufObj, offset, size,
+ false))
+ return;
+
+ _mesa_bind_buffer_range_xfb(ctx, ctx->TransformFeedback.CurrentObject,
+ index, bufObj, offset, size);
+ return;
+ case GL_UNIFORM_BUFFER:
+ bind_buffer_range_uniform_buffer_err(ctx, index, bufObj, offset,
+ size);
+ return;
+ case GL_SHADER_STORAGE_BUFFER:
+ bind_buffer_range_shader_storage_buffer_err(ctx, index, bufObj,
+ offset, size);
+ return;
+ case GL_ATOMIC_COUNTER_BUFFER:
+ bind_atomic_buffer_err(ctx, index, bufObj, offset, size,
+ "glBindBufferRange");
+ return;
+ default:
+ _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferRange(target)");
return;
}
}
+}
- switch (target) {
- case GL_TRANSFORM_FEEDBACK_BUFFER:
- _mesa_bind_buffer_range_transform_feedback(ctx,
- ctx->TransformFeedback.CurrentObject,
- index, bufObj, offset, size,
- false);
- return;
- case GL_UNIFORM_BUFFER:
- bind_buffer_range_uniform_buffer(ctx, index, bufObj, offset, size);
- return;
- case GL_SHADER_STORAGE_BUFFER:
- bind_buffer_range_shader_storage_buffer(ctx, index, bufObj, offset, size);
- return;
- case GL_ATOMIC_COUNTER_BUFFER:
- bind_atomic_buffer(ctx, index, bufObj, offset, size,
- "glBindBufferRange");
- return;
- default:
- _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferRange(target)");
- return;
- }
+void GLAPIENTRY
+_mesa_BindBufferRange_no_error(GLenum target, GLuint index, GLuint buffer,
+ GLintptr offset, GLsizeiptr size)
+{
+ bind_buffer_range(target, index, buffer, offset, size, true);
+}
+
+void GLAPIENTRY
+_mesa_BindBufferRange(GLenum target, GLuint index,
+ GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+ bind_buffer_range(target, index, buffer, offset, size, false);
}
void GLAPIENTRY
bind_buffer_base_shader_storage_buffer(ctx, index, bufObj);
return;
case GL_ATOMIC_COUNTER_BUFFER:
- bind_atomic_buffer(ctx, index, bufObj, 0, 0,
- "glBindBufferBase");
+ bind_atomic_buffer_err(ctx, index, bufObj, 0, 0,
+ "glBindBufferBase");
return;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferBase(target)");
switch (target) {
case GL_TRANSFORM_FEEDBACK_BUFFER:
- bind_xfb_buffers_range(ctx, first, count, buffers, offsets, sizes);
+ bind_xfb_buffers(ctx, first, count, buffers, true, offsets, sizes,
+ "glBindBuffersRange");
return;
case GL_UNIFORM_BUFFER:
- bind_uniform_buffers_range(ctx, first, count, buffers, offsets, sizes);
+ bind_uniform_buffers(ctx, first, count, buffers, true, offsets, sizes,
+ "glBindBuffersRange");
return;
case GL_SHADER_STORAGE_BUFFER:
- bind_shader_storage_buffers_range(ctx, first, count, buffers, offsets,
- sizes);
+ bind_shader_storage_buffers(ctx, first, count, buffers, true, offsets, sizes,
+ "glBindBuffersRange");
return;
case GL_ATOMIC_COUNTER_BUFFER:
- bind_atomic_buffers_range(ctx, first, count, buffers,
- offsets, sizes);
+ bind_atomic_buffers(ctx, first, count, buffers, true, offsets, sizes,
+ "glBindBuffersRange");
return;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glBindBuffersRange(target=%s)",
switch (target) {
case GL_TRANSFORM_FEEDBACK_BUFFER:
- bind_xfb_buffers_base(ctx, first, count, buffers);
+ bind_xfb_buffers(ctx, first, count, buffers, false, NULL, NULL,
+ "glBindBuffersBase");
return;
case GL_UNIFORM_BUFFER:
- bind_uniform_buffers_base(ctx, first, count, buffers);
+ bind_uniform_buffers(ctx, first, count, buffers, false, NULL, NULL,
+ "glBindBuffersBase");
return;
case GL_SHADER_STORAGE_BUFFER:
- bind_shader_storage_buffers_base(ctx, first, count, buffers);
+ bind_shader_storage_buffers(ctx, first, count, buffers, false, NULL, NULL,
+ "glBindBuffersBase");
return;
case GL_ATOMIC_COUNTER_BUFFER:
- bind_atomic_buffers_base(ctx, first, count, buffers);
+ bind_atomic_buffers(ctx, first, count, buffers, false, NULL, NULL,
+ "glBindBuffersBase");
return;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glBindBuffersBase(target=%s)",
}
}
+static ALWAYS_INLINE void
+invalidate_buffer_subdata(struct gl_context *ctx,
+ struct gl_buffer_object *bufObj, GLintptr offset,
+ GLsizeiptr length)
+{
+ if (ctx->Driver.InvalidateBufferSubData)
+ ctx->Driver.InvalidateBufferSubData(ctx, bufObj, offset, length);
+}
+
+void GLAPIENTRY
+_mesa_InvalidateBufferSubData_no_error(GLuint buffer, GLintptr offset,
+ GLsizeiptr length)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ invalidate_buffer_subdata(ctx, bufObj, offset, length);
+}
+
void GLAPIENTRY
_mesa_InvalidateBufferSubData(GLuint buffer, GLintptr offset,
GLsizeiptr length)
struct gl_buffer_object *bufObj;
const GLintptr end = offset + length;
+ /* Section 6.5 (Invalidating Buffer Data) of the OpenGL 4.5 (Compatibility
+ * Profile) spec says:
+ *
+ * "An INVALID_VALUE error is generated if buffer is zero or is not the
+ * name of an existing buffer object."
+ */
bufObj = _mesa_lookup_bufferobj(ctx, buffer);
- if (!bufObj) {
+ if (!bufObj || bufObj == &DummyBufferObject) {
_mesa_error(ctx, GL_INVALID_VALUE,
- "glInvalidateBufferSubData(name = 0x%x) invalid object",
+ "glInvalidateBufferSubData(name = %u) invalid object",
buffer);
return;
}
* negative, or if <offset> + <length> is greater than the value of
* BUFFER_SIZE."
*/
- if (end < 0 || end > bufObj->Size) {
+ if (offset < 0 || length < 0 || end > bufObj->Size) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glInvalidateBufferSubData(invalid offset or length)");
return;
return;
}
- /* We don't actually do anything for this yet. Just return after
- * validating the parameters and generating the required errors.
- */
- return;
+ invalidate_buffer_subdata(ctx, bufObj, offset, length);
+}
+
+void GLAPIENTRY
+_mesa_InvalidateBufferData_no_error(GLuint buffer)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_buffer_object *bufObj =_mesa_lookup_bufferobj(ctx, buffer);
+ invalidate_buffer_subdata(ctx, bufObj, 0, bufObj->Size);
}
void GLAPIENTRY
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
+ /* Section 6.5 (Invalidating Buffer Data) of the OpenGL 4.5 (Compatibility
+ * Profile) spec says:
+ *
+ * "An INVALID_VALUE error is generated if buffer is zero or is not the
+ * name of an existing buffer object."
+ */
bufObj = _mesa_lookup_bufferobj(ctx, buffer);
- if (!bufObj) {
+ if (!bufObj || bufObj == &DummyBufferObject) {
_mesa_error(ctx, GL_INVALID_VALUE,
- "glInvalidateBufferData(name = 0x%x) invalid object",
+ "glInvalidateBufferData(name = %u) invalid object",
buffer);
return;
}
return;
}
- /* We don't actually do anything for this yet. Just return after
- * validating the parameters and generating the required errors.
+ invalidate_buffer_subdata(ctx, bufObj, 0, bufObj->Size);
+}
+
+static void
+buffer_page_commitment(struct gl_context *ctx,
+ struct gl_buffer_object *bufferObj,
+ GLintptr offset, GLsizeiptr size,
+ GLboolean commit, const char *func)
+{
+ if (!(bufferObj->StorageFlags & GL_SPARSE_STORAGE_BIT_ARB)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "%s(not a sparse buffer object)",
+ func);
+ return;
+ }
+
+ if (size < 0 || size > bufferObj->Size ||
+ offset < 0 || offset > bufferObj->Size - size) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "%s(out of bounds)",
+ func);
+ return;
+ }
+
+ /* The GL_ARB_sparse_buffer extension specification says:
+ *
+ * "INVALID_VALUE is generated by BufferPageCommitmentARB if <offset> is
+ * not an integer multiple of SPARSE_BUFFER_PAGE_SIZE_ARB, or if <size>
+ * is not an integer multiple of SPARSE_BUFFER_PAGE_SIZE_ARB and does
+ * not extend to the end of the buffer's data store."
*/
- return;
+ if (offset % ctx->Const.SparseBufferPageSize != 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "%s(offset not aligned to page size)",
+ func);
+ return;
+ }
+
+ if (size % ctx->Const.SparseBufferPageSize != 0 &&
+ offset + size != bufferObj->Size) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "%s(size not aligned to page size)",
+ func);
+ return;
+ }
+
+ ctx->Driver.BufferPageCommitment(ctx, bufferObj, offset, size, commit);
+}
+
+void GLAPIENTRY
+_mesa_BufferPageCommitmentARB(GLenum target, GLintptr offset, GLsizeiptr size,
+ GLboolean commit)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufferObj;
+
+ bufferObj = get_buffer(ctx, "glBufferPageCommitmentARB", target,
+ GL_INVALID_ENUM);
+ if (!bufferObj)
+ return;
+
+ buffer_page_commitment(ctx, bufferObj, offset, size, commit,
+ "glBufferPageCommitmentARB");
+}
+
+void GLAPIENTRY
+_mesa_NamedBufferPageCommitmentARB(GLuint buffer, GLintptr offset,
+ GLsizeiptr size, GLboolean commit)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufferObj;
+
+ bufferObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!bufferObj || bufferObj == &DummyBufferObject) {
+ /* Note: the extension spec is not clear about the excpected error value. */
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glNamedBufferPageCommitmentARB(name = %u) invalid object",
+ buffer);
+ return;
+ }
+
+ buffer_page_commitment(ctx, bufferObj, offset, size, commit,
+ "glNamedBufferPageCommitmentARB");
}
projects / mesa.git / blobdiff