#include "st_context.h"
#include "st_cb_bufferobjects.h"
+#include "st_cb_memoryobjects.h"
#include "st_debug.h"
#include "pipe/p_context.h"
*/
static void
st_bufferobj_subdata(struct gl_context *ctx,
- GLintptrARB offset,
- GLsizeiptrARB size,
- const GLvoid * data, struct gl_buffer_object *obj)
+ GLintptrARB offset,
+ GLsizeiptrARB size,
+ const void * data, struct gl_buffer_object *obj)
{
struct st_buffer_object *st_obj = st_buffer_object(obj);
* buffer directly.
*/
pipe_buffer_write(st_context(ctx)->pipe,
- st_obj->buffer,
- offset, size, data);
+ st_obj->buffer,
+ offset, size, data);
}
st_bufferobj_get_subdata(struct gl_context *ctx,
GLintptrARB offset,
GLsizeiptrARB size,
- GLvoid * data, struct gl_buffer_object *obj)
+ void * data, struct gl_buffer_object *obj)
{
struct st_buffer_object *st_obj = st_buffer_object(obj);
offset, size, data);
}
-
-/**
- * Allocate space for and store data in a buffer object. Any data that was
- * previously stored in the buffer object is lost. If data is NULL,
- * memory will be allocated, but no copy will occur.
- * Called via ctx->Driver.BufferData().
- * \return GL_TRUE for success, GL_FALSE if out of memory
- */
-static GLboolean
-st_bufferobj_data(struct gl_context *ctx,
- GLenum target,
- GLsizeiptrARB size,
- const GLvoid * data,
- GLenum usage,
- GLbitfield storageFlags,
- struct gl_buffer_object *obj)
+static ALWAYS_INLINE GLboolean
+bufferobj_data(struct gl_context *ctx,
+ GLenum target,
+ GLsizeiptrARB size,
+ const void *data,
+ struct gl_memory_object *memObj,
+ GLuint64 offset,
+ GLenum usage,
+ GLbitfield storageFlags,
+ struct gl_buffer_object *obj)
{
struct st_context *st = st_context(ctx);
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct st_buffer_object *st_obj = st_buffer_object(obj);
+ struct st_memory_object *st_mem_obj = st_memory_object(memObj);
unsigned bind, pipe_usage, pipe_flags = 0;
if (target != GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD &&
* This should be the same as creating a new buffer, but we avoid
* a lot of validation in Mesa.
*/
- struct pipe_box box;
-
- u_box_1d(0, size, &box);
- pipe->transfer_inline_write(pipe, st_obj->buffer, 0,
- PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
- &box, data, 0, 0);
+ pipe->buffer_subdata(pipe, st_obj->buffer,
+ PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE,
+ 0, size, data);
return GL_TRUE;
} else if (screen->get_param(screen, PIPE_CAP_INVALIDATE_BUFFER)) {
pipe->invalidate_resource(pipe, st_obj->buffer);
case GL_PARAMETER_BUFFER_ARB:
bind = PIPE_BIND_COMMAND_ARGS_BUFFER;
break;
+ case GL_ATOMIC_COUNTER_BUFFER:
+ case GL_SHADER_STORAGE_BUFFER:
+ bind = PIPE_BIND_SHADER_BUFFER;
+ break;
+ case GL_QUERY_BUFFER:
+ bind = PIPE_BIND_QUERY_BUFFER;
+ break;
default:
bind = 0;
}
/* Set usage. */
if (st_obj->Base.Immutable) {
/* BufferStorage */
- if (storageFlags & GL_CLIENT_STORAGE_BIT)
- pipe_usage = PIPE_USAGE_STAGING;
- else
+ if (storageFlags & GL_CLIENT_STORAGE_BIT) {
+ if (storageFlags & GL_MAP_READ_BIT)
+ pipe_usage = PIPE_USAGE_STAGING;
+ else
+ pipe_usage = PIPE_USAGE_STREAM;
+ } else {
pipe_usage = PIPE_USAGE_DEFAULT;
+ }
}
else {
/* BufferData */
case GL_STATIC_DRAW:
case GL_STATIC_COPY:
default:
- pipe_usage = PIPE_USAGE_DEFAULT;
+ pipe_usage = PIPE_USAGE_DEFAULT;
break;
case GL_DYNAMIC_DRAW:
case GL_DYNAMIC_COPY:
pipe_flags |= PIPE_RESOURCE_FLAG_MAP_PERSISTENT;
if (storageFlags & GL_MAP_COHERENT_BIT)
pipe_flags |= PIPE_RESOURCE_FLAG_MAP_COHERENT;
+ if (storageFlags & GL_SPARSE_STORAGE_BIT_ARB)
+ pipe_flags |= PIPE_RESOURCE_FLAG_SPARSE;
pipe_resource_reference( &st_obj->buffer, NULL );
buffer.depth0 = 1;
buffer.array_size = 1;
- if (target == GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD) {
+ if (st_mem_obj) {
+ st_obj->buffer = screen->resource_from_memobj(screen, &buffer,
+ st_mem_obj->memory,
+ offset);
+ }
+ else if (target == GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD) {
st_obj->buffer =
screen->resource_from_user_memory(screen, &buffer, (void*)data);
}
}
}
- /* BufferData may change an array or uniform buffer, need to update it */
- st->dirty.st |= ST_NEW_VERTEX_ARRAYS | ST_NEW_UNIFORM_BUFFER;
+ /* The current buffer may be bound, so we have to revalidate all atoms that
+ * might be using it.
+ */
+ /* TODO: Add arrays to usage history */
+ ctx->NewDriverState |= ST_NEW_VERTEX_ARRAYS;
+ if (st_obj->Base.UsageHistory & USAGE_UNIFORM_BUFFER)
+ ctx->NewDriverState |= ST_NEW_UNIFORM_BUFFER;
+ if (st_obj->Base.UsageHistory & USAGE_SHADER_STORAGE_BUFFER)
+ ctx->NewDriverState |= ST_NEW_STORAGE_BUFFER;
+ if (st_obj->Base.UsageHistory & USAGE_TEXTURE_BUFFER)
+ ctx->NewDriverState |= ST_NEW_SAMPLER_VIEWS | ST_NEW_IMAGE_UNITS;
+ if (st_obj->Base.UsageHistory & USAGE_ATOMIC_COUNTER_BUFFER)
+ ctx->NewDriverState |= ST_NEW_ATOMIC_BUFFER;
return GL_TRUE;
}
+/**
+ * Allocate space for and store data in a buffer object. Any data that was
+ * previously stored in the buffer object is lost. If data is NULL,
+ * memory will be allocated, but no copy will occur.
+ * Called via ctx->Driver.BufferData().
+ * \return GL_TRUE for success, GL_FALSE if out of memory
+ */
+static GLboolean
+st_bufferobj_data(struct gl_context *ctx,
+ GLenum target,
+ GLsizeiptrARB size,
+ const void *data,
+ GLenum usage,
+ GLbitfield storageFlags,
+ struct gl_buffer_object *obj)
+{
+ return bufferobj_data(ctx, target, size, data, NULL, 0, usage, storageFlags, obj);
+}
+
+static GLboolean
+st_bufferobj_data_mem(struct gl_context *ctx,
+ GLenum target,
+ GLsizeiptrARB size,
+ struct gl_memory_object *memObj,
+ GLuint64 offset,
+ GLenum usage,
+ struct gl_buffer_object *bufObj)
+{
+ return bufferobj_data(ctx, target, size, NULL, memObj, offset, usage, 0, bufObj);
+}
/**
* Called via glInvalidateBuffer(Sub)Data.
flags |= PIPE_TRANSFER_COHERENT;
/* ... other flags ...
- */
+ */
if (access & MESA_MAP_NOWAIT_BIT)
flags |= PIPE_TRANSFER_DONTBLOCK;
assert(offset + length <= obj->Size);
obj->Mappings[index].Pointer = pipe_buffer_map_range(pipe,
- st_obj->buffer,
- offset, length,
- flags,
- &st_obj->transfer[index]);
+ st_obj->buffer,
+ offset, length,
+ flags,
+ &st_obj->transfer[index]);
if (obj->Mappings[index].Pointer) {
obj->Mappings[index].Offset = offset;
obj->Mappings[index].Length = length;
static void
st_clear_buffer_subdata(struct gl_context *ctx,
GLintptr offset, GLsizeiptr size,
- const GLvoid *clearValue,
+ const void *clearValue,
GLsizeiptr clearValueSize,
struct gl_buffer_object *bufObj)
{
clearValue, clearValueSize);
}
-
-/* TODO: if buffer wasn't created with appropriate usage flags, need
- * to recreate it now and copy contents -- or possibly create a
- * gallium entrypoint to extend the usage flags and let the driver
- * decide if a copy is necessary.
- */
-void
-st_bufferobj_validate_usage(struct st_context *st,
- struct st_buffer_object *obj,
- unsigned usage)
+static void
+st_bufferobj_page_commitment(struct gl_context *ctx,
+ struct gl_buffer_object *bufferObj,
+ GLintptr offset, GLsizeiptr size,
+ GLboolean commit)
{
-}
+ struct pipe_context *pipe = st_context(ctx)->pipe;
+ struct st_buffer_object *buf = st_buffer_object(bufferObj);
+ struct pipe_box box;
+
+ u_box_1d(offset, size, &box);
+ if (!pipe->resource_commit(pipe, buf->buffer, 0, &box, commit)) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferPageCommitmentARB(out of memory)");
+ return;
+ }
+}
void
st_init_bufferobject_functions(struct pipe_screen *screen,
struct dd_function_table *functions)
{
- /* plug in default driver fallbacks (such as for ClearBufferSubData) */
- _mesa_init_buffer_object_functions(functions);
-
functions->NewBufferObject = st_bufferobj_alloc;
functions->DeleteBuffer = st_bufferobj_free;
functions->BufferData = st_bufferobj_data;
+ functions->BufferDataMem = st_bufferobj_data_mem;
functions->BufferSubData = st_bufferobj_subdata;
functions->GetBufferSubData = st_bufferobj_get_subdata;
functions->MapBufferRange = st_bufferobj_map_range;
functions->UnmapBuffer = st_bufferobj_unmap;
functions->CopyBufferSubData = st_copy_buffer_subdata;
functions->ClearBufferSubData = st_clear_buffer_subdata;
+ functions->BufferPageCommitment = st_bufferobj_page_commitment;
if (screen->get_param(screen, PIPE_CAP_INVALIDATE_BUFFER))
functions->InvalidateBufferSubData = st_bufferobj_invalidate;
projects / mesa.git / blobdiff