X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_draw.c;h=fac0ab7a1f7025398b4781210b633d779e6c5925;hb=649d03d54d2b508bc6144fed41cedf7aa9ad0be5;hp=487f3f19cb3ea7207a4946e9be46ea83e7372afe;hpb=5d92596c5619eee4bac0fdc7733bafcd578309de;p=mesa.git

diff --git a/src/mesa/state_tracker/st_draw.c b/src/mesa/state_tracker/st_draw.c
index 487f3f19cb3..fac0ab7a1f7 100644
--- a/src/mesa/state_tracker/st_draw.c
+++ b/src/mesa/state_tracker/st_draw.c
@@ -33,7 +33,7 @@
  *
  * We basically convert the VBO's vertex attribute/array information into
  * Gallium vertex state, bind the vertex buffer objects and call
- * pipe->draw_elements(), pipe->draw_range_elements() or pipe->draw_arrays().
+ * pipe->draw_vbo().
  *
  * Authors:
  *   Keith Whitwell <keith@tungstengraphics.com>
@@ -42,6 +42,7 @@
 
 #include "main/imports.h"
 #include "main/image.h"
+#include "main/bufferobj.h"
 #include "main/macros.h"
 #include "main/mfeatures.h"
 #include "program/prog_uniform.h"
@@ -236,7 +237,6 @@ st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
 /**
  * Examine the active arrays to determine if we have interleaved
  * vertex arrays all living in one VBO, or all living in user space.
- * \param userSpace  returns whether the arrays are in user space.
  */
 static GLboolean
 is_interleaved_arrays(const struct st_vertex_program *vp,
@@ -246,8 +246,8 @@ is_interleaved_arrays(const struct st_vertex_program *vp,
    GLuint attr;
    const struct gl_buffer_object *firstBufObj = NULL;
    GLint firstStride = -1;
-   const GLubyte *client_addr = NULL;
-   GLboolean user_memory;
+   const GLubyte *firstPtr = NULL;
+   GLboolean userSpaceBuffer = GL_FALSE;
 
    for (attr = 0; attr < vpv->num_inputs; attr++) {
       const GLuint mesaAttr = vp->index_to_input[attr];
@@ -255,37 +255,26 @@ is_interleaved_arrays(const struct st_vertex_program *vp,
       const struct gl_buffer_object *bufObj = array->BufferObj;
       const GLsizei stride = array->StrideB; /* in bytes */
 
-      if (firstStride < 0) {
+      if (attr == 0) {
+         /* save info about the first array */
          firstStride = stride;
-         user_memory = !bufObj || !bufObj->Name;
-      }
-      else if (firstStride != stride) {
-         return GL_FALSE;
-      }
-
-      if (!bufObj || !bufObj->Name) {
-         /* Try to detect if the client-space arrays are
-          * "close" to each other.
-          */
-         if (!user_memory) {
-            return GL_FALSE;
-         }
-         if (!client_addr) {
-            client_addr = array->Ptr;
-         }
-         else if (abs(array->Ptr - client_addr) > firstStride) {
-            /* arrays start too far apart */
-            return GL_FALSE;
-         }
-      }
-      else if (!firstBufObj) {
-         if (user_memory) {
-            return GL_FALSE;
-         }
+         firstPtr = array->Ptr;         
          firstBufObj = bufObj;
+         userSpaceBuffer = !bufObj || !bufObj->Name;
       }
-      else if (bufObj != firstBufObj) {
-         return GL_FALSE;
+      else {
+         /* check if other arrays interleave with the first, in same buffer */
+         if (stride != firstStride)
+            return GL_FALSE; /* strides don't match */
+
+         if (bufObj != firstBufObj)
+            return GL_FALSE; /* arrays in different VBOs */
+
+         if (abs(array->Ptr - firstPtr) > firstStride)
+            return GL_FALSE; /* arrays start too far apart */
+
+         if ((!bufObj || !_mesa_is_bufferobj(bufObj)) != userSpaceBuffer)
+            return GL_FALSE; /* mix of VBO and user-space arrays */
       }
    }
 
@@ -329,32 +318,39 @@ setup_interleaved_attribs(struct gl_context *ctx,
       const struct gl_client_array *array = arrays[mesaAttr];
       struct gl_buffer_object *bufobj = array->BufferObj;
       struct st_buffer_object *stobj = st_buffer_object(bufobj);
+      unsigned src_offset = (unsigned) (array->Ptr - low_addr);
+      GLuint element_size = array->_ElementSize;
       GLsizei stride = array->StrideB;
 
+      assert(element_size == array->Size * _mesa_sizeof_type(array->Type));
+
       if (attr == 0) {
-         if (bufobj && bufobj->Name) {
+         if (bufobj && _mesa_is_bufferobj(bufobj)) {
             vbuffer->buffer = NULL;
             pipe_resource_reference(&vbuffer->buffer, stobj->buffer);
             vbuffer->buffer_offset = pointer_to_offset(low_addr);
          }
          else {
             uint divisor = array->InstanceDivisor;
-            uint length = (divisor ? num_instances / divisor : max_index) + 1;
+            uint last_index = divisor ? num_instances / divisor : max_index;
+            uint bytes = src_offset + stride * last_index + element_size;
+
             vbuffer->buffer = pipe_user_buffer_create(pipe->screen,
                                                       (void*) low_addr,
-                                                      stride * length,
+                                                      bytes,
                                                       PIPE_BIND_VERTEX_BUFFER);
             vbuffer->buffer_offset = 0;
 
             /* Track user vertex buffers. */
-            pipe_resource_reference(&st->user_vb[0], vbuffer->buffer);
-            st->user_vb_stride[0] = stride;
-            st->num_user_vbs = 1;
+            pipe_resource_reference(&st->user_attrib[0].buffer, vbuffer->buffer);
+            st->user_attrib[0].element_size = element_size;
+            st->user_attrib[0].stride = stride;
+            st->num_user_attribs = 1;
          }
          vbuffer->stride = stride; /* in bytes */
       }
 
-      velements[attr].src_offset = (unsigned) (array->Ptr - low_addr);
+      velements[attr].src_offset = src_offset;
       velements[attr].instance_divisor = array->InstanceDivisor;
       velements[attr].vertex_buffer_index = 0;
       velements[attr].src_format = st_pipe_vertex_format(array->Type,
@@ -390,9 +386,12 @@ setup_non_interleaved_attribs(struct gl_context *ctx,
       const GLuint mesaAttr = vp->index_to_input[attr];
       const struct gl_client_array *array = arrays[mesaAttr];
       struct gl_buffer_object *bufobj = array->BufferObj;
+      GLuint element_size = array->_ElementSize;
       GLsizei stride = array->StrideB;
 
-      if (bufobj && bufobj->Name) {
+      assert(element_size == array->Size * _mesa_sizeof_type(array->Type));
+
+      if (bufobj && _mesa_is_bufferobj(bufobj)) {
          /* Attribute data is in a VBO.
           * Recall that for VBOs, the gl_client_array->Ptr field is
           * really an offset from the start of the VBO, not a pointer.
@@ -410,20 +409,16 @@ setup_non_interleaved_attribs(struct gl_context *ctx,
          void *ptr;
 
          if (array->Ptr) {
-            if (stride == 0) {
-               bytes = _mesa_sizeof_type(array->Type) * array->Size;
-            }
-            else {
-               uint divisor = array->InstanceDivisor;
-               uint length = (divisor ? num_instances / divisor : max_index) + 1;
-               bytes = stride * length;
-            }
+            uint divisor = array->InstanceDivisor;
+            uint last_index = divisor ? num_instances / divisor : max_index;
+
+            bytes = stride * last_index + element_size;
 
             ptr = (void *) array->Ptr;
          }
          else {
             /* no array, use ctx->Current.Attrib[] value */
-            bytes = sizeof(ctx->Current.Attrib[0]);
+            bytes = element_size = sizeof(ctx->Current.Attrib[0]);
             ptr = (void *) ctx->Current.Attrib[mesaAttr];
             stride = 0;
          }
@@ -438,9 +433,10 @@ setup_non_interleaved_attribs(struct gl_context *ctx,
          vbuffer[attr].buffer_offset = 0;
 
          /* Track user vertex buffers. */
-         pipe_resource_reference(&st->user_vb[attr], vbuffer[attr].buffer);
-         st->user_vb_stride[attr] = stride;
-         st->num_user_vbs = MAX2(st->num_user_vbs, attr+1);
+         pipe_resource_reference(&st->user_attrib[attr].buffer, vbuffer[attr].buffer);
+         st->user_attrib[attr].element_size = element_size;
+         st->user_attrib[attr].stride = stride;
+         st->num_user_attribs = MAX2(st->num_user_attribs, attr + 1);
       }
 
       /* common-case setup */
@@ -486,7 +482,7 @@ setup_index_buffer(struct gl_context *ctx,
       }
 
       /* get/create the index buffer object */
-      if (bufobj && bufobj->Name) {
+      if (bufobj && _mesa_is_bufferobj(bufobj)) {
          /* elements/indexes are in a real VBO */
          struct st_buffer_object *stobj = st_buffer_object(bufobj);
          pipe_resource_reference(&ibuffer->buffer, stobj->buffer);
@@ -502,6 +498,7 @@ setup_index_buffer(struct gl_context *ctx,
    }
 }
 
+
 /**
  * Prior to drawing, check that any uniforms referenced by the
  * current shader have been set.  If a uniform has not been set,
@@ -548,8 +545,8 @@ translate_prim(const struct gl_context *ctx, unsigned prim)
    assert(GL_TRIANGLE_STRIP_ADJACENCY == PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY);
 
    /* Avoid quadstrips if it's easy to do so:
-    * Note: it's imporant to do the correct trimming if we change the prim type!
-    * We do that wherever this function is called.
+    * Note: it's important to do the correct trimming if we change the
+    * prim type!  We do that wherever this function is called.
     */
    if (prim == GL_QUAD_STRIP &&
        ctx->Light.ShadeModel != GL_FLAT &&
@@ -583,10 +580,10 @@ st_validate_varrays(struct gl_context *ctx,
    memset(velements, 0, sizeof(struct pipe_vertex_element) * vpv->num_inputs);
 
    /* Unreference any user vertex buffers. */
-   for (i = 0; i < st->num_user_vbs; i++) {
-      pipe_resource_reference(&st->user_vb[i], NULL);
+   for (i = 0; i < st->num_user_attribs; i++) {
+      pipe_resource_reference(&st->user_attrib[i].buffer, NULL);
    }
-   st->num_user_vbs = 0;
+   st->num_user_attribs = 0;
 
    /*
     * Setup the vbuffer[] and velements[] arrays.
@@ -642,7 +639,8 @@ st_draw_vbo(struct gl_context *ctx,
    struct pipe_draw_info info;
    unsigned i, num_instances = 1;
    GLboolean new_array =
-         st->dirty.st && (st->dirty.mesa & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;
+      st->dirty.st &&
+      (st->dirty.mesa & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT)) != 0;
 
    /* Mesa core state should have been validated already */
    assert(ctx->NewState == 0x0);
@@ -700,21 +698,20 @@ st_draw_vbo(struct gl_context *ctx,
 
    /* Notify the driver that the content of user buffers may have been
     * changed. */
-   if (!new_array && st->num_user_vbs) {
-      for (i = 0; i < st->num_user_vbs; i++) {
-         if (st->user_vb[i]) {
-            unsigned stride = st->user_vb_stride[i];
-
-            if (stride) {
-               pipe->redefine_user_buffer(pipe, st->user_vb[i],
-                                          min_index * stride,
-                                          (max_index + 1 - min_index) * stride);
-            }
-            else {
-               /* stride == 0 */
-               pipe->redefine_user_buffer(pipe, st->user_vb[i],
-                                          0, st->user_vb[i]->width0);
-            }
+   assert(max_index >= min_index);
+   if (!new_array && st->num_user_attribs) {
+      for (i = 0; i < st->num_user_attribs; i++) {
+         if (st->user_attrib[i].buffer) {
+            unsigned element_size = st->user_attrib[i].element_size;
+            unsigned stride = st->user_attrib[i].stride;
+            unsigned min_offset = min_index * stride;
+            unsigned max_offset = max_index * stride + element_size;
+
+            assert(max_offset > min_offset);
+
+            pipe->redefine_user_buffer(pipe, st->user_attrib[i].buffer,
+                                       min_offset,
+                                       max_offset - min_offset);
          }
       }
    }
@@ -731,8 +728,8 @@ st_draw_vbo(struct gl_context *ctx,
       }
    }
 
-   info.primitive_restart = st->ctx->Array.PrimitiveRestart;
-   info.restart_index = st->ctx->Array.RestartIndex;
+   info.primitive_restart = ctx->Array.PrimitiveRestart;
+   info.restart_index = ctx->Array.RestartIndex;
 
    /* do actual drawing */
    for (i = 0; i < nr_prims; i++) {