#include "glheader.h"
#include "enums.h"
#include "hash.h"
-#include "imports.h"
#include "context.h"
#include "bufferobj.h"
#include "externalobjects.h"
#include "texstore.h"
#include "transformfeedback.h"
#include "varray.h"
+#include "util/u_atomic.h"
+#include "util/u_memory.h"
/* Debug flags */
va_list args;
va_start(args, fmt);
- _mesa_gl_vdebug(ctx, id,
- MESA_DEBUG_SOURCE_API,
- MESA_DEBUG_TYPE_PERFORMANCE,
- MESA_DEBUG_SEVERITY_MEDIUM,
- fmt, args);
+ _mesa_gl_vdebugf(ctx, id,
+ MESA_DEBUG_SOURCE_API,
+ MESA_DEBUG_TYPE_PERFORMANCE,
+ MESA_DEBUG_SEVERITY_MEDIUM,
+ fmt, args);
va_end(args);
}
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;
+ /* Other targets are only supported in desktop OpenGL and OpenGL ES 3.0. */
+ if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx)) {
+ switch (target) {
+ case GL_ARRAY_BUFFER:
+ case GL_ELEMENT_ARRAY_BUFFER:
+ break;
+ case GL_PIXEL_PACK_BUFFER:
+ case GL_PIXEL_UNPACK_BUFFER:
+ if (!ctx->Extensions.EXT_pixel_buffer_object)
+ return NULL;
+ break;
+ default:
+ return NULL;
+ }
+ }
switch (target) {
case GL_ARRAY_BUFFER_ARB:
+ if (ctx->Array.ArrayBufferObj)
+ ctx->Array.ArrayBufferObj->UsageHistory |= USAGE_ARRAY_BUFFER;
return &ctx->Array.ArrayBufferObj;
case GL_ELEMENT_ARRAY_BUFFER_ARB:
+ if (ctx->Array.VAO->IndexBufferObj)
+ ctx->Array.VAO->IndexBufferObj->UsageHistory
+ |= USAGE_ELEMENT_ARRAY_BUFFER;
return &ctx->Array.VAO->IndexBufferObj;
case GL_PIXEL_PACK_BUFFER_EXT:
return &ctx->Pack.BufferObj;
return &ctx->QueryBuffer;
break;
case GL_DRAW_INDIRECT_BUFFER:
- if ((ctx->API == API_OPENGL_CORE &&
- ctx->Extensions.ARB_draw_indirect) ||
+ if ((_mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_draw_indirect) ||
_mesa_is_gles31(ctx)) {
return &ctx->DrawIndirectBuffer;
}
return NULL;
}
- if (!_mesa_is_bufferobj(*bufObj)) {
+ if (!*bufObj) {
_mesa_error(ctx, error, "%s(no buffer bound)", func);
return NULL;
}
/**
* Test the format and type parameters and set the GL error code for
- * \c glClearBufferData and \c glClearBufferSubData.
+ * \c glClearBufferData, \c glClearNamedBufferData, \c glClearBufferSubData
+ * and \c glClearNamedBufferSubData.
*
* \param ctx GL context.
* \param internalformat Format to which the data is to be converted.
* \return If internalformat, format and type are legal the mesa_format
* corresponding to internalformat, otherwise MESA_FORMAT_NONE.
*
- * \sa glClearBufferData and glClearBufferSubData
+ * \sa glClearBufferData, glClearNamedBufferData, glClearBufferSubData and
+ * glClearNamedBufferSubData.
*/
static mesa_format
validate_clear_buffer_format(struct gl_context *ctx,
}
if (!_mesa_is_color_format(format)) {
- _mesa_error(ctx, GL_INVALID_ENUM,
+ _mesa_error(ctx, GL_INVALID_VALUE,
"%s(format is not a color format)", caller);
return MESA_FORMAT_NONE;
}
errorFormatType = _mesa_error_check_format_and_type(ctx, format, type);
if (errorFormatType != GL_NO_ERROR) {
- _mesa_error(ctx, GL_INVALID_ENUM,
+ _mesa_error(ctx, GL_INVALID_VALUE,
"%s(invalid format or type)", caller);
return MESA_FORMAT_NONE;
}
(void) ctx;
vbo_delete_minmax_cache(bufObj);
- _mesa_align_free(bufObj->Data);
+ align_free(bufObj->Data);
/* assign strange values here to help w/ debugging */
bufObj->RefCount = -1000;
bufObj->Name = ~0;
- mtx_destroy(&bufObj->Mutex);
+ simple_mtx_destroy(&bufObj->MinMaxCacheMutex);
free(bufObj->Label);
free(bufObj);
}
{
if (*ptr) {
/* Unreference the old buffer */
- GLboolean deleteFlag = GL_FALSE;
struct gl_buffer_object *oldObj = *ptr;
- mtx_lock(&oldObj->Mutex);
- assert(oldObj->RefCount > 0);
- oldObj->RefCount--;
- deleteFlag = (oldObj->RefCount == 0);
- mtx_unlock(&oldObj->Mutex);
-
- if (deleteFlag) {
+ if (p_atomic_dec_zero(&oldObj->RefCount)) {
assert(ctx->Driver.DeleteBuffer);
ctx->Driver.DeleteBuffer(ctx, oldObj);
}
if (bufObj) {
/* reference new buffer */
- mtx_lock(&bufObj->Mutex);
- assert(bufObj->RefCount > 0);
-
- bufObj->RefCount++;
+ p_atomic_inc(&bufObj->RefCount);
*ptr = bufObj;
- mtx_unlock(&bufObj->Mutex);
}
}
GLuint name)
{
memset(obj, 0, sizeof(struct gl_buffer_object));
- mtx_init(&obj->Mutex, mtx_plain);
obj->RefCount = 1;
obj->Name = name;
obj->Usage = GL_STATIC_DRAW_ARB;
+ simple_mtx_init(&obj->MinMaxCacheMutex, mtx_plain);
if (get_no_minmax_cache())
obj->UsageHistory |= USAGE_DISABLE_MINMAX_CACHE;
}
* \sa glBufferDataARB, dd_function_table::BufferData.
*/
static GLboolean
-buffer_data_fallback(struct gl_context *ctx, GLenum target, GLsizeiptr size,
+buffer_data_fallback(struct gl_context *ctx, GLenum target, GLsizeiptrARB size,
const GLvoid *data, GLenum usage, GLenum storageFlags,
struct gl_buffer_object *bufObj)
{
(void) target;
- _mesa_align_free( bufObj->Data );
+ align_free( bufObj->Data );
- new_data = _mesa_align_malloc( size, ctx->Const.MinMapBufferAlignment );
+ new_data = align_malloc( size, ctx->Const.MinMapBufferAlignment );
if (new_data) {
bufObj->Data = (GLubyte *) new_data;
bufObj->Size = size;
* \sa glBufferSubDataARB, dd_function_table::BufferSubData.
*/
static void
-buffer_sub_data_fallback(struct gl_context *ctx, GLintptr offset,
- GLsizeiptr size, const GLvoid *data,
+buffer_sub_data_fallback(struct gl_context *ctx, GLintptrARB offset,
+ GLsizeiptrARB size, const GLvoid *data,
struct gl_buffer_object *bufObj)
{
(void) ctx;
GLuint i;
memset(&DummyBufferObject, 0, sizeof(DummyBufferObject));
- mtx_init(&DummyBufferObject.Mutex, mtx_plain);
+ simple_mtx_init(&DummyBufferObject.MinMaxCacheMutex, mtx_plain);
DummyBufferObject.RefCount = 1000*1000*1000; /* never delete */
- _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj,
- ctx->Shared->NullBufferObj);
-
- _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer,
- ctx->Shared->NullBufferObj);
- _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer,
- ctx->Shared->NullBufferObj);
-
- _mesa_reference_buffer_object(ctx, &ctx->UniformBuffer,
- ctx->Shared->NullBufferObj);
-
- _mesa_reference_buffer_object(ctx, &ctx->ShaderStorageBuffer,
- ctx->Shared->NullBufferObj);
-
- _mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer,
- ctx->Shared->NullBufferObj);
-
- _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,
- ctx->Shared->NullBufferObj);
+ NULL);
ctx->UniformBufferBindings[i].Offset = -1;
ctx->UniformBufferBindings[i].Size = -1;
}
for (i = 0; i < MAX_COMBINED_SHADER_STORAGE_BUFFERS; i++) {
_mesa_reference_buffer_object(ctx,
&ctx->ShaderStorageBufferBindings[i].BufferObject,
- ctx->Shared->NullBufferObj);
+ NULL);
ctx->ShaderStorageBufferBindings[i].Offset = -1;
ctx->ShaderStorageBufferBindings[i].Size = -1;
}
for (i = 0; i < MAX_COMBINED_ATOMIC_BUFFERS; i++) {
_mesa_reference_buffer_object(ctx,
&ctx->AtomicBufferBindings[i].BufferObject,
- ctx->Shared->NullBufferObj);
+ NULL);
ctx->AtomicBufferBindings[i].Offset = 0;
ctx->AtomicBufferBindings[i].Size = 0;
}
/* Get pointer to old buffer object (to be unbound) */
oldBufObj = *bindTarget;
- if (oldBufObj && oldBufObj->Name == buffer && !oldBufObj->DeletePending)
+ if ((oldBufObj && oldBufObj->Name == buffer && !oldBufObj->DeletePending) ||
+ (!oldBufObj && buffer == 0))
return; /* rebinding the same buffer object- no change */
/*
* Get pointer to new buffer object (newBufObj)
*/
- if (buffer == 0) {
- /* The spec says there's not a buffer object named 0, but we use
- * one internally because it simplifies things.
- */
- newBufObj = ctx->Shared->NullBufferObj;
- }
- else {
+ if (buffer != 0) {
/* non-default buffer object */
newBufObj = _mesa_lookup_bufferobj(ctx, buffer);
if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
&newBufObj, "glBindBuffer"))
return;
- }
- /* record usage history */
- if (bindTarget == &ctx->Pack.BufferObj) {
- newBufObj->UsageHistory |= USAGE_PIXEL_PACK_BUFFER;
+ /* record usage history */
+ if (bindTarget == &ctx->Pack.BufferObj)
+ newBufObj->UsageHistory |= USAGE_PIXEL_PACK_BUFFER;
}
/* bind new buffer */
void
_mesa_update_default_objects_buffer_objects(struct gl_context *ctx)
{
- /* Bind the NullBufferObj to remove references to those
- * in the shared context hash table.
- */
+ /* Bind 0 to remove references to those in the shared context hash table. */
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);
* of an existing buffer object.
*
* If the buffer ID refers to an existing buffer object, a pointer
- * to the buffer object is returned. If the ID is zero, a pointer
- * to the shared NullBufferObj is returned. If the ID is not zero
- * and does not refer to a valid buffer object, this function
- * returns NULL.
+ * to the buffer object is returned. If the ID is zero, NULL is returned.
+ * If the ID is not zero and does not refer to a valid buffer object, this
+ * function returns NULL.
*
* This function assumes that the caller has already locked the
* hash table mutex by calling
struct gl_buffer_object *
_mesa_multi_bind_lookup_bufferobj(struct gl_context *ctx,
const GLuint *buffers,
- GLuint index, const char *caller)
+ GLuint index, const char *caller,
+ bool *error)
{
- struct gl_buffer_object *bufObj;
+ struct gl_buffer_object *bufObj = NULL;
+
+ *error = false;
if (buffers[index] != 0) {
bufObj = _mesa_lookup_bufferobj_locked(ctx, buffers[index]);
when they don't exist. */
if (bufObj == &DummyBufferObject)
bufObj = NULL;
- } else
- bufObj = ctx->Shared->NullBufferObj;
- if (!bufObj) {
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_OPERATION error is generated if any value
- * in <buffers> is not zero or the name of an existing
- * buffer object (per binding)."
- */
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "%s(buffers[%u]=%u is not zero or the name "
- "of an existing buffer object)",
- caller, index, buffers[index]);
+ if (!bufObj) {
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_OPERATION error is generated if any value
+ * in <buffers> is not zero or the name of an existing
+ * buffer object (per binding)."
+ */
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "%s(buffers[%u]=%u is not zero or the name "
+ "of an existing buffer object)",
+ caller, index, buffers[index]);
+ *error = true;
+ }
}
return bufObj;
struct gl_buffer_object *obj)
{
if (vao->BufferBinding[index].BufferObj == obj) {
- _mesa_bind_vertex_buffer(ctx, vao, index, ctx->Shared->NullBufferObj,
+ _mesa_bind_vertex_buffer(ctx, vao, index, NULL,
vao->BufferBinding[index].Offset,
- vao->BufferBinding[index].Stride);
+ vao->BufferBinding[index].Stride, true, false);
}
}
bind_buffer_object(ctx, bindTarget, buffer);
}
+void
+_mesa_InternalBindElementBuffer(struct gl_context *ctx,
+ struct gl_buffer_object *buf)
+{
+ struct gl_buffer_object **bindTarget =
+ get_buffer_target(ctx, GL_ELEMENT_ARRAY_BUFFER);
+
+ /* Move the buffer reference from the parameter to the bind point. */
+ _mesa_reference_buffer_object(ctx, bindTarget, NULL);
+ if (buf)
+ *bindTarget = buf;
+}
+
/**
- * Binds a buffer object to an atomic buffer binding point.
+ * Binds a buffer object to a binding point.
*
* The caller is responsible for validating the offset,
* flushing the vertices and updating NewDriverState.
*/
static void
-set_atomic_buffer_binding(struct gl_context *ctx,
- struct gl_atomic_buffer_binding *binding,
- struct gl_buffer_object *bufObj,
- GLintptr offset,
- GLsizeiptr size,
- bool autoSize)
+set_buffer_binding(struct gl_context *ctx,
+ struct gl_buffer_binding *binding,
+ struct gl_buffer_object *bufObj,
+ GLintptr offset,
+ GLsizeiptr size,
+ bool autoSize, gl_buffer_usage usage)
{
_mesa_reference_buffer_object(ctx, &binding->BufferObject, bufObj);
* at some point as an atomic counter buffer.
*/
if (size >= 0)
- bufObj->UsageHistory |= USAGE_ATOMIC_COUNTER_BUFFER;
+ bufObj->UsageHistory |= usage;
}
-/**
- * Binds a buffer object to a uniform buffer binding point.
- *
- * The caller is responsible for flushing vertices and updating
- * NewDriverState.
- */
static void
-set_ubo_binding(struct gl_context *ctx,
- struct gl_uniform_buffer_binding *binding,
- struct gl_buffer_object *bufObj,
- GLintptr offset,
- GLsizeiptr size,
- GLboolean autoSize)
+set_buffer_multi_binding(struct gl_context *ctx,
+ const GLuint *buffers,
+ int idx,
+ const char *caller,
+ struct gl_buffer_binding *binding,
+ GLintptr offset,
+ GLsizeiptr size,
+ bool range,
+ gl_buffer_usage usage)
{
- _mesa_reference_buffer_object(ctx, &binding->BufferObject, bufObj);
+ struct gl_buffer_object *bufObj;
- binding->Offset = offset;
- binding->Size = size;
- binding->AutomaticSize = autoSize;
+ if (binding->BufferObject && binding->BufferObject->Name == buffers[idx])
+ bufObj = binding->BufferObject;
+ else {
+ bool error;
+ bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, idx, caller,
+ &error);
+ if (error)
+ return;
+ }
- /* If this is a real buffer object, mark it has having been used
- * at some point as a UBO.
- */
- if (size >= 0)
- bufObj->UsageHistory |= USAGE_UNIFORM_BUFFER;
+ if (!bufObj)
+ set_buffer_binding(ctx, binding, bufObj, -1, -1, !range, usage);
+ else
+ set_buffer_binding(ctx, binding, bufObj, offset, size, !range, usage);
}
-/**
- * Binds a buffer object to a shader storage buffer binding point.
- *
- * The caller is responsible for flushing vertices and updating
- * NewDriverState.
- */
static void
-set_ssbo_binding(struct gl_context *ctx,
- struct gl_shader_storage_buffer_binding *binding,
- struct gl_buffer_object *bufObj,
- GLintptr offset,
- GLsizeiptr size,
- GLboolean autoSize)
+bind_buffer(struct gl_context *ctx,
+ struct gl_buffer_binding *binding,
+ struct gl_buffer_object *bufObj,
+ GLintptr offset,
+ GLsizeiptr size,
+ GLboolean autoSize,
+ uint64_t driver_state,
+ gl_buffer_usage usage)
{
- _mesa_reference_buffer_object(ctx, &binding->BufferObject, bufObj);
+ if (binding->BufferObject == bufObj &&
+ binding->Offset == offset &&
+ binding->Size == size &&
+ binding->AutomaticSize == autoSize) {
+ return;
+ }
- binding->Offset = offset;
- binding->Size = size;
- binding->AutomaticSize = autoSize;
+ FLUSH_VERTICES(ctx, 0);
+ ctx->NewDriverState |= driver_state;
- /* If this is a real buffer object, mark it has having been used
- * at some point as a SSBO.
- */
- if (size >= 0)
- bufObj->UsageHistory |= USAGE_SHADER_STORAGE_BUFFER;
+ set_buffer_binding(ctx, binding, bufObj, offset, size, autoSize, usage);
}
/**
* Binds a buffer object to a uniform buffer binding point.
*
- * Unlike set_ubo_binding(), this function also flushes vertices
+ * Unlike set_buffer_binding(), this function also flushes vertices
* and updates NewDriverState. It also checks if the binding
* has actually changed before updating it.
*/
GLsizeiptr size,
GLboolean autoSize)
{
- struct gl_uniform_buffer_binding *binding =
- &ctx->UniformBufferBindings[index];
-
- if (binding->BufferObject == bufObj &&
- binding->Offset == offset &&
- binding->Size == size &&
- binding->AutomaticSize == autoSize) {
- return;
- }
-
- FLUSH_VERTICES(ctx, 0);
- ctx->NewDriverState |= ctx->DriverFlags.NewUniformBuffer;
-
- set_ubo_binding(ctx, binding, bufObj, offset, size, autoSize);
+ bind_buffer(ctx, &ctx->UniformBufferBindings[index],
+ bufObj, offset, size, autoSize,
+ ctx->DriverFlags.NewUniformBuffer,
+ USAGE_UNIFORM_BUFFER);
}
/**
GLsizeiptr size,
GLboolean autoSize)
{
- struct gl_shader_storage_buffer_binding *binding =
- &ctx->ShaderStorageBufferBindings[index];
-
- if (binding->BufferObject == bufObj &&
- binding->Offset == offset &&
- binding->Size == size &&
- binding->AutomaticSize == autoSize) {
- return;
- }
-
- FLUSH_VERTICES(ctx, 0);
- ctx->NewDriverState |= ctx->DriverFlags.NewShaderStorageBuffer;
-
- set_ssbo_binding(ctx, binding, bufObj, offset, size, autoSize);
+ bind_buffer(ctx, &ctx->ShaderStorageBufferBindings[index],
+ bufObj, offset, size, autoSize,
+ ctx->DriverFlags.NewShaderStorageBuffer,
+ USAGE_SHADER_STORAGE_BUFFER);
}
/**
struct gl_buffer_object *bufObj, GLintptr offset,
GLsizeiptr size, GLboolean autoSize)
{
- struct gl_atomic_buffer_binding *binding =
- &ctx->AtomicBufferBindings[index];
-
- if (binding->BufferObject == bufObj &&
- binding->Offset == offset &&
- binding->Size == size &&
- binding->AutomaticSize == autoSize) {
- return;
- }
-
- FLUSH_VERTICES(ctx, 0);
- ctx->NewDriverState |= ctx->DriverFlags.NewAtomicBuffer;
-
- set_atomic_buffer_binding(ctx, binding, bufObj, offset, size, autoSize);
+ bind_buffer(ctx, &ctx->AtomicBufferBindings[index],
+ bufObj, offset, size, autoSize,
+ ctx->DriverFlags.NewAtomicBuffer,
+ USAGE_ATOMIC_COUNTER_BUFFER);
}
/**
_mesa_reference_buffer_object(ctx, &ctx->UniformBuffer, bufObj);
- if (bufObj == ctx->Shared->NullBufferObj)
+ if (!bufObj)
bind_uniform_buffer(ctx, index, bufObj, -1, -1, GL_TRUE);
else
bind_uniform_buffer(ctx, index, bufObj, 0, 0, GL_TRUE);
_mesa_reference_buffer_object(ctx, &ctx->ShaderStorageBuffer, bufObj);
- if (bufObj == ctx->Shared->NullBufferObj)
+ if (!bufObj)
bind_shader_storage_buffer(ctx, index, bufObj, -1, -1, GL_TRUE);
else
bind_shader_storage_buffer(ctx, index, bufObj, 0, 0, GL_TRUE);
_mesa_reference_buffer_object(ctx, &ctx->AtomicBuffer, bufObj);
- if (bufObj == ctx->Shared->NullBufferObj)
+ if (!bufObj)
bind_atomic_buffer(ctx, index, bufObj, -1, -1, GL_TRUE);
else
bind_atomic_buffer(ctx, index, bufObj, 0, 0, GL_TRUE);
if (ctx->TransformFeedback.CurrentObject->Buffers[j] == bufObj) {
_mesa_bind_buffer_base_transform_feedback(ctx,
ctx->TransformFeedback.CurrentObject,
- j, ctx->Shared->NullBufferObj,
- false);
+ j, NULL, false);
}
}
/* unbind UBO binding points */
for (j = 0; j < ctx->Const.MaxUniformBufferBindings; j++) {
if (ctx->UniformBufferBindings[j].BufferObject == bufObj) {
- bind_buffer_base_uniform_buffer(ctx, j,
- ctx->Shared->NullBufferObj);
+ bind_buffer_base_uniform_buffer(ctx, j, NULL);
}
}
/* unbind SSBO binding points */
for (j = 0; j < ctx->Const.MaxShaderStorageBufferBindings; j++) {
if (ctx->ShaderStorageBufferBindings[j].BufferObject == bufObj) {
- bind_buffer_base_shader_storage_buffer(ctx, j,
- ctx->Shared->NullBufferObj);
+ bind_buffer_base_shader_storage_buffer(ctx, j, NULL);
}
}
/* unbind Atomci Buffer binding points */
for (j = 0; j < ctx->Const.MaxAtomicBufferBindings; j++) {
if (ctx->AtomicBufferBindings[j].BufferObject == bufObj) {
- bind_buffer_base_atomic_buffer(ctx, j,
- ctx->Shared->NullBufferObj);
+ bind_buffer_base_atomic_buffer(ctx, j, NULL);
}
}
false, false, false, "glBufferStorage");
}
+void GLAPIENTRY
+_mesa_NamedBufferStorageEXT(GLuint buffer, GLsizeiptr size,
+ const GLvoid *data, GLbitfield flags)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glNamedBufferStorageEXT"))
+ return;
+
+ inlined_buffer_storage(GL_NONE, buffer, size, data, flags, GL_NONE, 0,
+ true, false, false, "glNamedBufferStorageEXT");
+}
+
void GLAPIENTRY
_mesa_BufferStorageMemEXT(GLenum target, GLsizeiptr size,
"glNamedBufferData");
}
+void GLAPIENTRY
+_mesa_NamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const GLvoid *data,
+ GLenum usage)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj;
+
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glNamedBufferDataEXT(buffer=0)");
+ return;
+ }
+
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glNamedBufferDataEXT"))
+ return;
+
+ _mesa_buffer_data(ctx, bufObj, GL_NONE, size, data, usage,
+ "glNamedBufferDataEXT");
+}
static bool
validate_buffer_sub_data(struct gl_context *ctx,
"glNamedBufferSubData");
}
+void GLAPIENTRY
+_mesa_NamedBufferSubDataEXT(GLuint buffer, GLintptr offset,
+ GLsizeiptr size, const GLvoid *data)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj;
+
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glNamedBufferSubDataEXT(buffer=0)");
+ return;
+ }
+
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glNamedBufferSubDataEXT"))
+ return;
+
+ if (validate_buffer_sub_data(ctx, bufObj, offset, size,
+ "glNamedBufferSubDataEXT")) {
+ _mesa_buffer_sub_data(ctx, bufObj, offset, size, data);
+ }
+}
+
void GLAPIENTRY
_mesa_GetBufferSubData(GLenum target, GLintptr offset,
}
+void GLAPIENTRY
+_mesa_GetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset,
+ GLsizeiptr size, GLvoid *data)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj;
+
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glGetNamedBufferSubDataEXT(buffer=0)");
+ return;
+ }
+
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glGetNamedBufferSubDataEXT"))
+ return;
+
+ if (!buffer_object_subdata_range_good(ctx, bufObj, offset, size, false,
+ "glGetNamedBufferSubDataEXT")) {
+ return;
+ }
+
+ assert(ctx->Driver.GetBufferSubData);
+ ctx->Driver.GetBufferSubData(ctx, offset, size, data, bufObj);
+}
+
/**
* \param subdata true if caller is *SubData, false if *Data
*/
}
+void GLAPIENTRY
+_mesa_ClearNamedBufferDataEXT(GLuint buffer, GLenum internalformat,
+ GLenum format, GLenum type, const GLvoid *data)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glClearNamedBufferDataEXT"))
+ return;
+
+ clear_buffer_sub_data_error(ctx, bufObj, internalformat, 0, bufObj->Size,
+ format, type, data, "glClearNamedBufferDataEXT",
+ false);
+}
+
+
void GLAPIENTRY
_mesa_ClearBufferSubData_no_error(GLenum target, GLenum internalformat,
GLintptr offset, GLsizeiptr size,
true);
}
+void GLAPIENTRY
+_mesa_ClearNamedBufferSubDataEXT(GLuint buffer, GLenum internalformat,
+ GLintptr offset, GLsizeiptr size,
+ GLenum format, GLenum type,
+ const GLvoid *data)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glClearNamedBufferSubDataEXT"))
+ return;
+
+ clear_buffer_sub_data_error(ctx, bufObj, internalformat, offset, size,
+ format, type, data, "glClearNamedBufferSubDataEXT",
+ true);
+}
+
static GLboolean
unmap_buffer(struct gl_context *ctx, struct gl_buffer_object *bufObj)
{
}
GLboolean GLAPIENTRY
-_mesa_UnmapNamedBuffer_no_error(GLuint buffer)
+_mesa_UnmapNamedBufferEXT_no_error(GLuint buffer)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
}
GLboolean GLAPIENTRY
-_mesa_UnmapNamedBuffer(GLuint buffer)
+_mesa_UnmapNamedBufferEXT(GLuint buffer)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *bufObj;
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glUnmapNamedBufferEXT(buffer=0)");
+ return GL_FALSE;
+ }
+
bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, "glUnmapNamedBuffer");
if (!bufObj)
return GL_FALSE;
*params = (GLint) parameter;
}
+void GLAPIENTRY
+_mesa_GetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint *params)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj;
+ GLint64 parameter;
+
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glGetNamedBufferParameterivEXT: buffer=0");
+ return;
+ }
+
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glGetNamedBufferParameterivEXT"))
+ return;
+
+ if (!get_buffer_parameter(ctx, bufObj, pname, ¶meter,
+ "glGetNamedBufferParameterivEXT"))
+ return; /* Error already recorded. */
+
+ *params = (GLint) parameter;
+}
+
void GLAPIENTRY
_mesa_GetNamedBufferParameteri64v(GLuint buffer, GLenum pname,
GLint64 *params)
*params = bufObj->Mappings[MAP_USER].Pointer;
}
+void GLAPIENTRY
+_mesa_GetNamedBufferPointervEXT(GLuint buffer, GLenum pname, GLvoid **params)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj;
+
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glGetNamedBufferPointervEXT(buffer=0)");
+ return;
+ }
+ if (pname != GL_BUFFER_MAP_POINTER) {
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetNamedBufferPointervEXT(pname != "
+ "GL_BUFFER_MAP_POINTER)");
+ return;
+ }
+
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glGetNamedBufferPointervEXT"))
+ return;
+
+ *params = bufObj->Mappings[MAP_USER].Pointer;
+}
static void
copy_buffer_sub_data(struct gl_context *ctx, struct gl_buffer_object *src,
"glCopyBufferSubData");
}
+void GLAPIENTRY
+_mesa_NamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer,
+ GLintptr readOffset, GLintptr writeOffset,
+ GLsizeiptr size)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *src, *dst;
+
+ src = _mesa_lookup_bufferobj(ctx, readBuffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, readBuffer,
+ &src,
+ "glNamedCopyBufferSubDataEXT"))
+ return;
+
+ dst = _mesa_lookup_bufferobj(ctx, writeBuffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, writeBuffer,
+ &dst,
+ "glNamedCopyBufferSubDataEXT"))
+ return;
+
+ copy_buffer_sub_data(ctx, src, dst, readOffset, writeOffset, size,
+ "glNamedCopyBufferSubDataEXT");
+}
+
void GLAPIENTRY
_mesa_CopyNamedBufferSubData_no_error(GLuint readBuffer, GLuint writeBuffer,
GLintptr readOffset,
"glCopyNamedBufferSubData");
}
+void GLAPIENTRY
+_mesa_InternalBufferSubDataCopyMESA(GLintptr srcBuffer, GLuint srcOffset,
+ GLuint dstTargetOrName, GLintptr dstOffset,
+ GLsizeiptr size, GLboolean named,
+ GLboolean ext_dsa)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *src = (struct gl_buffer_object *)srcBuffer;
+ struct gl_buffer_object *dst;
+ const char *func;
+
+ /* Handle behavior for all 3 variants. */
+ if (named && ext_dsa) {
+ func = "glNamedBufferSubDataEXT";
+ dst = _mesa_lookup_bufferobj(ctx, dstTargetOrName);
+ if (!_mesa_handle_bind_buffer_gen(ctx, dstTargetOrName, &dst, func))
+ goto done;
+ } else if (named) {
+ func = "glNamedBufferSubData";
+ dst = _mesa_lookup_bufferobj_err(ctx, dstTargetOrName, func);
+ if (!dst)
+ goto done;
+ } else {
+ assert(!ext_dsa);
+ func = "glBufferSubData";
+ dst = get_buffer(ctx, func, dstTargetOrName, GL_INVALID_OPERATION);
+ if (!dst)
+ goto done;
+ }
+
+ if (!validate_buffer_sub_data(ctx, dst, dstOffset, size, func))
+ goto done; /* the error is already set */
+
+ dst->MinMaxCacheDirty = true;
+ ctx->Driver.CopyBufferSubData(ctx, src, dst, srcOffset, dstOffset, size);
+
+done:
+ /* The caller passes the reference to this function, so unreference it. */
+ _mesa_reference_buffer_object(ctx, &src, NULL);
+}
+
static bool
validate_map_buffer_range(struct gl_context *ctx,
struct gl_buffer_object *bufObj, GLintptr offset,
"glMapNamedBufferRange");
}
-void * GLAPIENTRY
-_mesa_MapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length,
- GLbitfield access)
+static void *
+map_named_buffer_range(GLuint buffer, GLintptr offset, GLsizeiptr length,
+ GLbitfield access, bool dsa_ext, const char *func)
{
GET_CURRENT_CONTEXT(ctx);
- struct gl_buffer_object *bufObj;
+ struct gl_buffer_object *bufObj = NULL;
if (!ctx->Extensions.ARB_map_buffer_range) {
_mesa_error(ctx, GL_INVALID_OPERATION,
- "glMapNamedBufferRange("
- "ARB_map_buffer_range not supported)");
+ "%s(ARB_map_buffer_range not supported)", func);
return NULL;
}
- bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, "glMapNamedBufferRange");
- if (!bufObj)
+ if (dsa_ext) {
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer, &bufObj, func))
+ return NULL;
+ } else {
+ bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, func);
+ if (!bufObj)
+ return NULL;
+ }
+
+ if (!validate_map_buffer_range(ctx, bufObj, offset, length, access, func))
return NULL;
- if (!validate_map_buffer_range(ctx, bufObj, offset, length, access,
- "glMapNamedBufferRange"))
+ return map_buffer_range(ctx, bufObj, offset, length, access, func);
+}
+
+void * GLAPIENTRY
+_mesa_MapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length,
+ GLbitfield access)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glMapNamedBufferRangeEXT(buffer=0)");
return NULL;
+ }
+ return map_named_buffer_range(buffer, offset, length, access, true,
+ "glMapNamedBufferRangeEXT");
+}
- return map_buffer_range(ctx, bufObj, offset, length, access,
- "glMapNamedBufferRange");
+void * GLAPIENTRY
+_mesa_MapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length,
+ GLbitfield access)
+{
+ return map_named_buffer_range(buffer, offset, length, access, false,
+ "glMapNamedBufferRange");
}
/**
"glMapNamedBuffer");
}
+void * GLAPIENTRY
+_mesa_MapNamedBufferEXT(GLuint buffer, GLenum access)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLbitfield accessFlags;
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glMapNamedBufferEXT(buffer=0)");
+ return NULL;
+ }
+ if (!get_map_buffer_access_flags(ctx, access, &accessFlags)) {
+ _mesa_error(ctx, GL_INVALID_ENUM, "glMapNamedBufferEXT(invalid access)");
+ return NULL;
+ }
+
+ struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glMapNamedBufferEXT"))
+ return NULL;
+
+ if (!validate_map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
+ "glMapNamedBufferEXT"))
+ return NULL;
+
+ return map_buffer_range(ctx, bufObj, 0, bufObj->Size, accessFlags,
+ "glMapNamedBufferEXT");
+}
static void
flush_mapped_buffer_range(struct gl_context *ctx,
"glFlushMappedNamedBufferRange");
}
+void GLAPIENTRY
+_mesa_FlushMappedNamedBufferRangeEXT(GLuint buffer, GLintptr offset,
+ GLsizeiptr length)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufObj;
+
+ if (!buffer) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glFlushMappedNamedBufferRangeEXT(buffer=0)");
+ return;
+ }
+
+ bufObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
+ &bufObj, "glFlushMappedNamedBufferRangeEXT"))
+ return;
+
+ flush_mapped_buffer_range(ctx, bufObj, offset, length,
+ "glFlushMappedNamedBufferRangeEXT");
+}
+
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) {
+ if (!bufObj) {
offset = -1;
size = -1;
}
GLintptr offset,
GLsizeiptr size)
{
- if (bufObj == ctx->Shared->NullBufferObj) {
+ if (!bufObj) {
offset = -1;
size = -1;
}
struct gl_buffer_object *bufObj,
GLintptr offset, GLsizeiptr size)
{
- if (bufObj == ctx->Shared->NullBufferObj) {
+ if (!bufObj) {
offset = -1;
size = -1;
}
static void
unbind_uniform_buffers(struct gl_context *ctx, GLuint first, GLsizei count)
{
- struct gl_buffer_object *bufObj = ctx->Shared->NullBufferObj;
-
for (int i = 0; i < count; i++)
- set_ubo_binding(ctx, &ctx->UniformBufferBindings[first + i],
- bufObj, -1, -1, GL_TRUE);
+ set_buffer_binding(ctx, &ctx->UniformBufferBindings[first + i],
+ NULL, -1, -1, GL_TRUE, 0);
}
/**
unbind_shader_storage_buffers(struct gl_context *ctx, GLuint first,
GLsizei count)
{
- struct gl_buffer_object *bufObj = ctx->Shared->NullBufferObj;
-
for (int i = 0; i < count; i++)
- set_ssbo_binding(ctx, &ctx->ShaderStorageBufferBindings[first + i],
- bufObj, -1, -1, GL_TRUE);
+ set_buffer_binding(ctx, &ctx->ShaderStorageBufferBindings[first + i],
+ NULL, -1, -1, GL_TRUE, 0);
}
static void
_mesa_HashLockMutex(ctx->Shared->BufferObjects);
for (int i = 0; i < count; i++) {
- struct gl_uniform_buffer_binding *binding =
+ struct gl_buffer_binding *binding =
&ctx->UniformBufferBindings[first + i];
- struct gl_buffer_object *bufObj;
GLintptr offset = 0;
GLsizeiptr size = 0;
size = sizes[i];
}
- if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
- bufObj = binding->BufferObject;
- else
- 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, !range);
- else
- set_ubo_binding(ctx, binding, bufObj, offset, size, !range);
- }
+ set_buffer_multi_binding(ctx, buffers, i, caller,
+ binding, offset, size, range,
+ USAGE_UNIFORM_BUFFER);
}
_mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
_mesa_HashLockMutex(ctx->Shared->BufferObjects);
for (int i = 0; i < count; i++) {
- struct gl_shader_storage_buffer_binding *binding =
+ struct gl_buffer_binding *binding =
&ctx->ShaderStorageBufferBindings[first + i];
- struct gl_buffer_object *bufObj;
GLintptr offset = 0;
GLsizeiptr size = 0;
size = sizes[i];
}
- if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
- bufObj = binding->BufferObject;
- else
- 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, !range);
- else
- set_ssbo_binding(ctx, binding, bufObj, offset, size, !range);
- }
+ set_buffer_multi_binding(ctx, buffers, i, caller,
+ binding, offset, size, range,
+ USAGE_SHADER_STORAGE_BUFFER);
}
_mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
struct gl_transform_feedback_object *tfObj,
GLuint first, GLsizei count)
{
- struct gl_buffer_object * const bufObj = ctx->Shared->NullBufferObj;
-
for (int i = 0; i < count; i++)
_mesa_set_transform_feedback_binding(ctx, tfObj, first + i,
- bufObj, 0, 0);
+ NULL, 0, 0);
}
static void
if (boundBufObj && boundBufObj->Name == buffers[i])
bufObj = boundBufObj;
- else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, caller);
+ else {
+ bool error;
+ bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, caller,
+ &error);
+ if (error)
+ continue;
+ }
- if (bufObj)
- _mesa_set_transform_feedback_binding(ctx, tfObj, index, bufObj,
- offset, size);
+ _mesa_set_transform_feedback_binding(ctx, tfObj, index, bufObj,
+ offset, size);
}
_mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
static void
unbind_atomic_buffers(struct gl_context *ctx, GLuint first, GLsizei count)
{
- struct gl_buffer_object * const bufObj = ctx->Shared->NullBufferObj;
-
for (int i = 0; i < count; i++)
- set_atomic_buffer_binding(ctx, &ctx->AtomicBufferBindings[first + i],
- bufObj, -1, -1, GL_TRUE);
+ set_buffer_binding(ctx, &ctx->AtomicBufferBindings[first + i],
+ NULL, -1, -1, GL_TRUE, 0);
}
static void
_mesa_HashLockMutex(ctx->Shared->BufferObjects);
for (int i = 0; i < count; i++) {
- struct gl_atomic_buffer_binding *binding =
+ struct gl_buffer_binding *binding =
&ctx->AtomicBufferBindings[first + i];
- struct gl_buffer_object *bufObj;
GLintptr offset = 0;
GLsizeiptr size = 0;
size = sizes[i];
}
- if (binding->BufferObject && binding->BufferObject->Name == buffers[i])
- bufObj = binding->BufferObject;
- else
- bufObj = _mesa_multi_bind_lookup_bufferobj(ctx, buffers, i, caller);
-
- if (bufObj)
- if (bufObj == ctx->Shared->NullBufferObj)
- set_atomic_buffer_binding(ctx, binding, bufObj, -1, -1, !range);
- else
- set_atomic_buffer_binding(ctx, binding, bufObj, offset, size, !range);
+ set_buffer_multi_binding(ctx, buffers, i, caller,
+ binding, offset, size, range,
+ USAGE_ATOMIC_COUNTER_BUFFER);
}
_mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
}
if (buffer == 0) {
- bufObj = ctx->Shared->NullBufferObj;
+ bufObj = NULL;
} else {
bufObj = _mesa_lookup_bufferobj(ctx, buffer);
if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
}
if (buffer == 0) {
- bufObj = ctx->Shared->NullBufferObj;
+ bufObj = NULL;
} else {
bufObj = _mesa_lookup_bufferobj(ctx, buffer);
if (!_mesa_handle_bind_buffer_gen(ctx, buffer,
buffer_page_commitment(ctx, bufferObj, offset, size, commit,
"glNamedBufferPageCommitmentARB");
}
+
+void GLAPIENTRY
+_mesa_NamedBufferPageCommitmentEXT(GLuint buffer, GLintptr offset,
+ GLsizeiptr size, GLboolean commit)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *bufferObj;
+
+ /* Use NamedBuffer* functions logic from EXT_direct_state_access */
+ if (buffer != 0) {
+ bufferObj = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer, &bufferObj,
+ "glNamedBufferPageCommitmentEXT"))
+ return;
+ } else {
+ /* GL_EXT_direct_state_access says about NamedBuffer* functions:
+ *
+ * There is no buffer corresponding to the name zero, these commands
+ * generate the INVALID_OPERATION error if the buffer parameter is
+ * zero.
+ */
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glNamedBufferPageCommitmentEXT(buffer = 0)");
+ return;
+ }
+ buffer_page_commitment(ctx, bufferObj, offset, size, commit,
+ "glNamedBufferPageCommitmentEXT");
+}
projects / mesa.git / blobdiff