mesa: Remove target parameter from dd_function_table::MapBuffer
[mesa.git] / src / mesa / state_tracker / st_cb_bufferobjects.c
index 8e09d0b9324152ebb196665c949e314d10d48adc..a1df11806ebb424459fb6d0af4676824849c2e5c 100644 (file)
 #include "main/arrayobj.h"
 #include "main/bufferobj.h"
 
-#include "st_inlines.h"
 #include "st_context.h"
 #include "st_cb_bufferobjects.h"
 
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_inlines.h"
+#include "util/u_inlines.h"
 
 
 /**
@@ -52,7 +51,7 @@
  * internal structure where somehow shared.
  */
 static struct gl_buffer_object *
-st_bufferobj_alloc(GLcontext *ctx, GLuint name, GLenum target)
+st_bufferobj_alloc(struct gl_context *ctx, GLuint name, GLenum target)
 {
    struct st_buffer_object *st_obj = ST_CALLOC_STRUCT(st_buffer_object);
 
@@ -71,14 +70,17 @@ st_bufferobj_alloc(GLcontext *ctx, GLuint name, GLenum target)
  * Called via glDeleteBuffersARB().
  */
 static void
-st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj)
+st_bufferobj_free(struct gl_context *ctx, struct gl_buffer_object *obj)
 {
    struct st_buffer_object *st_obj = st_buffer_object(obj);
 
+   assert(obj->RefCount == 0);
+   assert(st_obj->transfer == NULL);
+
    if (st_obj->buffer) 
-      pipe_buffer_reference(&st_obj->buffer, NULL);
+      pipe_resource_reference(&st_obj->buffer, NULL);
 
-   _mesa_free(st_obj);
+   free(st_obj);
 }
 
 
@@ -90,7 +92,7 @@ st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj)
  * Called via glBufferSubDataARB().
  */
 static void
-st_bufferobj_subdata(GLcontext *ctx,
+st_bufferobj_subdata(struct gl_context *ctx,
                     GLenum target,
                     GLintptrARB offset,
                     GLsizeiptrARB size,
@@ -103,8 +105,26 @@ st_bufferobj_subdata(GLcontext *ctx,
    ASSERT(size >= 0);
    ASSERT(offset + size <= obj->Size);
 
-   st_cond_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer,
-                                  offset, size, data);
+   if (!size)
+      return;
+
+   /*
+    * According to ARB_vertex_buffer_object specification, if data is null,
+    * then the contents of the buffer object's data store is undefined. We just
+    * ignore, and leave it unchanged.
+    */
+   if (!data)
+      return;
+
+   /* Now that transfers are per-context, we don't have to figure out
+    * flushing here.  Usually drivers won't need to flush in this case
+    * even if the buffer is currently referenced by hardware - they
+    * just queue the upload as dma rather than mapping the underlying
+    * buffer directly.
+    */
+   pipe_buffer_write(st_context(ctx)->pipe,
+                    st_obj->buffer,
+                    offset, size, data);
 }
 
 
@@ -112,7 +132,7 @@ st_bufferobj_subdata(GLcontext *ctx,
  * Called via glGetBufferSubDataARB().
  */
 static void
-st_bufferobj_get_subdata(GLcontext *ctx,
+st_bufferobj_get_subdata(struct gl_context *ctx,
                          GLenum target,
                          GLintptrARB offset,
                          GLsizeiptrARB size,
@@ -125,8 +145,11 @@ st_bufferobj_get_subdata(GLcontext *ctx,
    ASSERT(size >= 0);
    ASSERT(offset + size <= obj->Size);
 
-   st_cond_flush_pipe_buffer_read(st_context(ctx), st_obj->buffer,
-                                 offset, size, data);
+   if (!size)
+      return;
+
+   pipe_buffer_read(st_context(ctx)->pipe, st_obj->buffer,
+                    offset, size, data);
 }
 
 
@@ -138,7 +161,7 @@ st_bufferobj_get_subdata(GLcontext *ctx,
  * \return GL_TRUE for success, GL_FALSE if out of memory
  */
 static GLboolean
-st_bufferobj_data(GLcontext *ctx,
+st_bufferobj_data(struct gl_context *ctx,
                  GLenum target,
                  GLsizeiptrARB size,
                  const GLvoid * data,
@@ -148,7 +171,7 @@ st_bufferobj_data(GLcontext *ctx,
    struct st_context *st = st_context(ctx);
    struct pipe_context *pipe = st->pipe;
    struct st_buffer_object *st_obj = st_buffer_object(obj);
-   unsigned buffer_usage;
+   unsigned bind, pipe_usage;
 
    st_obj->Base.Size = size;
    st_obj->Base.Usage = usage;
@@ -156,38 +179,69 @@ st_bufferobj_data(GLcontext *ctx,
    switch(target) {
    case GL_PIXEL_PACK_BUFFER_ARB:
    case GL_PIXEL_UNPACK_BUFFER_ARB:
-      buffer_usage = PIPE_BUFFER_USAGE_PIXEL;
+      bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
       break;
    case GL_ARRAY_BUFFER_ARB:
-      buffer_usage = PIPE_BUFFER_USAGE_VERTEX;
+      bind = PIPE_BIND_VERTEX_BUFFER;
       break;
    case GL_ELEMENT_ARRAY_BUFFER_ARB:
-      buffer_usage = PIPE_BUFFER_USAGE_INDEX;
+      bind = PIPE_BIND_INDEX_BUFFER;
       break;
    default:
-      buffer_usage = 0;
+      bind = 0;
    }
 
-   pipe_buffer_reference( &st_obj->buffer, NULL );
+   switch (usage) {
+   case GL_STATIC_DRAW:
+   case GL_STATIC_READ:
+   case GL_STATIC_COPY:
+      pipe_usage = PIPE_USAGE_STATIC;
+      break;
+   case GL_DYNAMIC_DRAW:
+   case GL_DYNAMIC_READ:
+   case GL_DYNAMIC_COPY:
+      pipe_usage = PIPE_USAGE_DYNAMIC;
+      break;
+   case GL_STREAM_DRAW:
+   case GL_STREAM_READ:
+   case GL_STREAM_COPY:
+      pipe_usage = PIPE_USAGE_STREAM;
+      break;
+   default:
+      pipe_usage = PIPE_USAGE_DEFAULT;
+   }
 
-   st_obj->buffer = pipe_buffer_create( pipe->screen, 32, buffer_usage, size );
+   pipe_resource_reference( &st_obj->buffer, NULL );
 
-   if (!st_obj->buffer) {
-      return GL_FALSE;
+   if (size != 0) {
+      st_obj->buffer = pipe_buffer_create(pipe->screen, bind,
+                                          pipe_usage, size);
+
+      if (!st_obj->buffer) {
+         return GL_FALSE;
+      }
+
+      if (data)
+         pipe_buffer_write(pipe, st_obj->buffer, 0, size, data);
+      return GL_TRUE;
    }
 
-   if (data)
-      st_no_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer, 0,
-                                   size, data);
    return GL_TRUE;
 }
 
 
+/**
+ * Dummy data whose's pointer is used for zero size buffers or ranges.
+ */
+static long st_bufferobj_zero_length = 0;
+
+
+
 /**
  * Called via glMapBufferARB().
  */
 static void *
-st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access,
+st_bufferobj_map(struct gl_context *ctx, GLenum access,
                  struct gl_buffer_object *obj)
 {
    struct st_buffer_object *st_obj = st_buffer_object(obj);
@@ -195,21 +249,28 @@ st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access,
 
    switch (access) {
    case GL_WRITE_ONLY:
-      flags = PIPE_BUFFER_USAGE_CPU_WRITE;
+      flags = PIPE_TRANSFER_WRITE;
       break;
    case GL_READ_ONLY:
-      flags = PIPE_BUFFER_USAGE_CPU_READ;
+      flags = PIPE_TRANSFER_READ;
       break;
    case GL_READ_WRITE:
-      /* fall-through */
    default:
-      flags = PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE;
+      flags = PIPE_TRANSFER_READ_WRITE;
       break;      
    }
 
-   obj->Pointer = st_cond_flush_pipe_buffer_map(st_context(ctx),
-                                               st_obj->buffer,
-                                               flags);
+   /* Handle zero-size buffers here rather than in drivers */
+   if (obj->Size == 0) {
+      obj->Pointer = &st_bufferobj_zero_length;
+   }
+   else {
+      obj->Pointer = pipe_buffer_map(st_context(ctx)->pipe,
+                                     st_obj->buffer,
+                                     flags,
+                                     &st_obj->transfer);
+   }
+
    if (obj->Pointer) {
       obj->Offset = 0;
       obj->Length = obj->Size;
@@ -222,48 +283,77 @@ st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access,
  * Called via glMapBufferRange().
  */
 static void *
-st_bufferobj_map_range(GLcontext *ctx, GLenum target, 
+st_bufferobj_map_range(struct gl_context *ctx, GLenum target, 
                        GLintptr offset, GLsizeiptr length, GLbitfield access,
                        struct gl_buffer_object *obj)
 {
    struct pipe_context *pipe = st_context(ctx)->pipe;
    struct st_buffer_object *st_obj = st_buffer_object(obj);
-   uint flags = 0x0;
+   enum pipe_transfer_usage flags = 0x0;
 
    if (access & GL_MAP_WRITE_BIT)
-      flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
+      flags |= PIPE_TRANSFER_WRITE;
 
    if (access & GL_MAP_READ_BIT)
-      flags |= PIPE_BUFFER_USAGE_CPU_READ;
+      flags |= PIPE_TRANSFER_READ;
 
    if (access & GL_MAP_FLUSH_EXPLICIT_BIT)
-      flags |= PIPE_BUFFER_USAGE_FLUSH_EXPLICIT;
+      flags |= PIPE_TRANSFER_FLUSH_EXPLICIT;
+
+   if (access & GL_MAP_INVALIDATE_BUFFER_BIT) {
+      flags |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
+   }
+   else if (access & GL_MAP_INVALIDATE_RANGE_BIT) {
+      if (offset == 0 && length == obj->Size)
+         flags |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
+      else
+         flags |= PIPE_TRANSFER_DISCARD_RANGE;
+   }
    
+   if (access & GL_MAP_UNSYNCHRONIZED_BIT)
+      flags |= PIPE_TRANSFER_UNSYNCHRONIZED;
+
    /* ... other flags ...
     */
 
    if (access & MESA_MAP_NOWAIT_BIT)
-      flags |= PIPE_BUFFER_USAGE_DONTBLOCK;
+      flags |= PIPE_TRANSFER_DONTBLOCK;
 
    assert(offset >= 0);
    assert(length >= 0);
    assert(offset < obj->Size);
    assert(offset + length <= obj->Size);
 
-   obj->Pointer = pipe_buffer_map_range(pipe->screen, st_obj->buffer, offset, length, flags);
+   /*
+    * We go out of way here to hide the degenerate yet valid case of zero
+    * length range from the pipe driver.
+    */
+   if (!length) {
+      obj->Pointer = &st_bufferobj_zero_length;
+   }
+   else {
+      obj->Pointer = pipe_buffer_map_range(pipe, 
+                                           st_obj->buffer,
+                                           offset, length,
+                                           flags,
+                                           &st_obj->transfer);
+      if (obj->Pointer) {
+         obj->Pointer = (ubyte *) obj->Pointer + offset;
+      }
+   }
+   
    if (obj->Pointer) {
-      obj->Pointer = (ubyte *) obj->Pointer + offset;
       obj->Offset = offset;
       obj->Length = length;
       obj->AccessFlags = access;
    }
-   
+
    return obj->Pointer;
 }
 
 
 static void
-st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target, 
+st_bufferobj_flush_mapped_range(struct gl_context *ctx, GLenum target, 
                                 GLintptr offset, GLsizeiptr length,
                                 struct gl_buffer_object *obj)
 {
@@ -274,8 +364,12 @@ st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target,
    assert(offset >= 0);
    assert(length >= 0);
    assert(offset + length <= obj->Length);
+   assert(obj->Pointer);
    
-   pipe_buffer_flush_mapped_range(pipe->screen, st_obj->buffer, 
+   if (!length)
+      return;
+
+   pipe_buffer_flush_mapped_range(pipe, st_obj->transfer, 
                                   obj->Offset + offset, length);
 }
 
@@ -284,12 +378,15 @@ st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target,
  * Called via glUnmapBufferARB().
  */
 static GLboolean
-st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj)
+st_bufferobj_unmap(struct gl_context *ctx, struct gl_buffer_object *obj)
 {
    struct pipe_context *pipe = st_context(ctx)->pipe;
    struct st_buffer_object *st_obj = st_buffer_object(obj);
 
-   pipe_buffer_unmap(pipe->screen, st_obj->buffer);
+   if (obj->Length)
+      pipe_buffer_unmap(pipe, st_obj->transfer);
+
+   st_obj->transfer = NULL;
    obj->Pointer = NULL;
    obj->Offset = 0;
    obj->Length = 0;
@@ -301,7 +398,7 @@ st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj)
  * Called via glCopyBufferSubData().
  */
 static void
-st_copy_buffer_subdata(GLcontext *ctx,
+st_copy_buffer_subdata(struct gl_context *ctx,
                        struct gl_buffer_object *src,
                        struct gl_buffer_object *dst,
                        GLintptr readOffset, GLintptr writeOffset,
@@ -310,27 +407,32 @@ st_copy_buffer_subdata(GLcontext *ctx,
    struct pipe_context *pipe = st_context(ctx)->pipe;
    struct st_buffer_object *srcObj = st_buffer_object(src);
    struct st_buffer_object *dstObj = st_buffer_object(dst);
-   ubyte *srcPtr, *dstPtr;
+   struct pipe_box box;
+
+   if(!size)
+      return;
 
    /* buffer should not already be mapped */
    assert(!src->Pointer);
    assert(!dst->Pointer);
 
-   srcPtr = (ubyte *) pipe_buffer_map_range(pipe->screen,
-                                            srcObj->buffer,
-                                            readOffset, size,
-                                            PIPE_BUFFER_USAGE_CPU_READ);
+   u_box_1d(readOffset, size, &box);
 
-   dstPtr = (ubyte *) pipe_buffer_map_range(pipe->screen,
-                                            dstObj->buffer,
-                                            writeOffset, size,
-                                            PIPE_BUFFER_USAGE_CPU_WRITE);
+   pipe->resource_copy_region(pipe, dstObj->buffer, 0, writeOffset, 0, 0,
+                              srcObj->buffer, 0, &box);
+}
 
-   if (srcPtr && dstPtr)
-      _mesa_memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);
 
-   pipe_buffer_unmap(pipe->screen, srcObj->buffer);
-   pipe_buffer_unmap(pipe->screen, dstObj->buffer);
+/* 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)
+{
 }