gallium: New PIPE_BUFFER_USAGE_FLUSH_EXPLICIT flag for buffer_flush_mapped_range.

When a buffer was mapped for write and no explicit flush range was provided
the existing semantics were that the whole buffer would be flushed, mostly
for backwards compatability with non map-buffer-range aware code.

However if the buffer was mapped/unmapped with nothing really written --
something that often happens with the vbo -- we were unnecessarily assuming
that the whole buffer was written.

The new PIPE_BUFFER_USAGE_FLUSH_EXPLICIT flag (based from ARB_map_buffer_range
's GL_MAP_FLUSH_EXPLICIT_BIT flag) allows to clearly distinguish the
legacy usage from the nothing written usage.

1 files changed, 14 insertions, 6 deletions

diff --git a/src/gallium/include/pipe/p_screen.h b/src/gallium/include/pipe/p_screen.h
index b449522fac3..6cbdd759434 100644
--- a/src/gallium/include/pipe/p_screen.h
+++ b/src/gallium/include/pipe/p_screen.h
@@ -221,23 +221,31 @@ struct pipe_screen {
    /**
     * Notify a range that was actually written into.
     * 
+    * Can only be used if the buffer was mapped with the 
+    * PIPE_BUFFER_USAGE_CPU_WRITE and PIPE_BUFFER_USAGE_FLUSH_EXPLICIT flags 
+    * set.
+    * 
     * The range is relative to the buffer start, regardless of the range 
     * specified to buffer_map_range. This is different from the 
     * ARB_map_buffer_range semantics because we don't forbid multiple mappings 
     * of the same buffer (yet).
     * 
-    * If the buffer was mapped for writing and no buffer_flush_mapped_range 
-    * call was done until the buffer_unmap is called then the pipe driver will
-    * assumed that the whole buffer was written. This is for backward 
-    * compatibility purposes and may affect performance -- the state tracker 
-    * should always specify exactly what got written while the buffer was 
-    * mapped.  
     */
    void (*buffer_flush_mapped_range)( struct pipe_screen *screen,
                                       struct pipe_buffer *buf,
                                       unsigned offset,
                                       unsigned length);
 
+   /**
+    * Unmap buffer.
+    * 
+    * If the buffer was mapped with PIPE_BUFFER_USAGE_CPU_WRITE flag but not
+    * PIPE_BUFFER_USAGE_FLUSH_EXPLICIT then the pipe driver will
+    * assume that the whole buffer was written. This is mostly for backward 
+    * compatibility purposes and may affect performance -- the state tracker 
+    * should always specify exactly what got written while the buffer was 
+    * mapped.
+    */
    void (*buffer_unmap)( struct pipe_screen *screen,
                          struct pipe_buffer *buf );