svn merge ^/branches/released .

17 files changed, 266 insertions, 211 deletions

diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index 020595bd0..714d63afc 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -1240,7 +1240,7 @@ struct gl_texture_image
 				 *   GL_DEPTH_COMPONENT or GL_DEPTH_STENCIL_EXT

                                  *   only. Used for choosing TexEnv arithmetic.

 				 */

-   GLuint TexFormat;            /**< The actual format: MESA_FORMAT_x */

+   gl_format TexFormat;         /**< The actual texture memory format */

 

    GLuint Border;		/**< 0 or 1 */

    GLuint Width;		/**< = 2^WidthLog2 + 2*Border */

@@ -1643,6 +1643,7 @@ struct gl_array_attrib
    GLuint RestartIndex;

 

    GLbitfield NewState;		/**< mask of _NEW_ARRAY_* values */

+   GLboolean RebindArrays; /**< whether the VBO module should rebind arrays */

 

    /* GL_ARB_vertex_buffer_object */

    struct gl_buffer_object *ArrayBufferObj;

@@ -2379,7 +2380,7 @@ struct gl_renderbuffer
    GLenum InternalFormat; /**< The user-specified format */

    GLenum _BaseFormat;    /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or

                                GL_STENCIL_INDEX. */

-   GLuint Format;         /**< The actual format: MESA_FORMAT_x */

+   gl_format Format;      /**< The actual renderbuffer memory format */

 

    GLubyte NumSamples;

 

diff --git a/mesalib/src/mesa/main/state.c b/mesalib/src/mesa/main/state.c
index c07e2c380..f11578faf 100644
--- a/mesalib/src/mesa/main/state.c
+++ b/mesalib/src/mesa/main/state.c
@@ -662,6 +662,8 @@ _mesa_update_state_locked( struct gl_context *ctx )
    ctx->NewState = 0;

    ctx->Driver.UpdateState(ctx, new_state);

    ctx->Array.NewState = 0;

+   if (!ctx->Array.RebindArrays)

+      ctx->Array.RebindArrays = (new_state & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;

 }

 

 

diff --git a/mesalib/src/mesa/state_tracker/st_atom_blend.c b/mesalib/src/mesa/state_tracker/st_atom_blend.c
index 26bb3dab9..e3b3b9936 100644
--- a/mesalib/src/mesa/state_tracker/st_atom_blend.c
+++ b/mesalib/src/mesa/state_tracker/st_atom_blend.c
@@ -191,7 +191,7 @@ update_blend( struct st_context *st )
 {

    struct pipe_blend_state *blend = &st->state.blend;

    unsigned num_state = 1;

-   unsigned i;

+   unsigned i, j;

 

    memset(blend, 0, sizeof(*blend));

 

@@ -214,12 +214,15 @@ update_blend( struct st_context *st )
    }

    else if (st->ctx->Color.BlendEnabled) {

       /* blending enabled */

-      for (i = 0; i < num_state; i++) {

+      for (i = 0, j = 0; i < num_state; i++) {

 

          blend->rt[i].blend_enable = (st->ctx->Color.BlendEnabled >> i) & 0x1;

 

+         if (st->ctx->Extensions.ARB_draw_buffers_blend)

+            j = i;

+

          blend->rt[i].rgb_func =

-            translate_blend(st->ctx->Color.Blend[i].EquationRGB);

+            translate_blend(st->ctx->Color.Blend[j].EquationRGB);

 

          if (st->ctx->Color.Blend[i].EquationRGB == GL_MIN ||

              st->ctx->Color.Blend[i].EquationRGB == GL_MAX) {

@@ -229,13 +232,13 @@ update_blend( struct st_context *st )
          }

          else {

             blend->rt[i].rgb_src_factor =

-               translate_blend(st->ctx->Color.Blend[i].SrcRGB);

+               translate_blend(st->ctx->Color.Blend[j].SrcRGB);

             blend->rt[i].rgb_dst_factor =

-               translate_blend(st->ctx->Color.Blend[i].DstRGB);

+               translate_blend(st->ctx->Color.Blend[j].DstRGB);

          }

 

          blend->rt[i].alpha_func =

-            translate_blend(st->ctx->Color.Blend[i].EquationA);

+            translate_blend(st->ctx->Color.Blend[j].EquationA);

 

          if (st->ctx->Color.Blend[i].EquationA == GL_MIN ||

              st->ctx->Color.Blend[i].EquationA == GL_MAX) {

@@ -245,9 +248,9 @@ update_blend( struct st_context *st )
          }

          else {

             blend->rt[i].alpha_src_factor =

-               translate_blend(st->ctx->Color.Blend[i].SrcA);

+               translate_blend(st->ctx->Color.Blend[j].SrcA);

             blend->rt[i].alpha_dst_factor =

-               translate_blend(st->ctx->Color.Blend[i].DstA);

+               translate_blend(st->ctx->Color.Blend[j].DstA);

          }

       }

    }

diff --git a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
index ddd130a81..51623c179 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
@@ -349,6 +349,7 @@ setup_bitmap_vertex_data(struct st_context *st, bool normalized,
    if (!st->bitmap.vbuf) {

       st->bitmap.vbuf = pipe_buffer_create(pipe->screen, 

                                            PIPE_BIND_VERTEX_BUFFER,

+                                           PIPE_USAGE_STREAM,

                                            max_slots *

                                            sizeof(st->bitmap.vertices));

    }

@@ -456,6 +457,7 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
    cso_save_fragment_shader(cso);

    cso_save_vertex_shader(cso);

    cso_save_vertex_elements(cso);

+   cso_save_vertex_buffers(cso);

 

    /* rasterizer state: just scissor */

    st->bitmap.rasterizer.scissor = ctx->Scissor.Enabled;

@@ -517,7 +519,7 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
                                      sv->texture->target != PIPE_TEXTURE_RECT,

                                      x, y, width, height, z, color);

 

-   util_draw_vertex_buffer(pipe, st->bitmap.vbuf, offset,

+   util_draw_vertex_buffer(pipe, st->cso_context, st->bitmap.vbuf, offset,

                            PIPE_PRIM_TRIANGLE_FAN,

                            4,  /* verts */

                            3); /* attribs/vert */

@@ -531,6 +533,7 @@ draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
    cso_restore_fragment_shader(cso);

    cso_restore_vertex_shader(cso);

    cso_restore_vertex_elements(cso);

+   cso_restore_vertex_buffers(cso);

 }

 

 

diff --git a/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c b/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
index ba8a8cf89..9dd1f8a3e 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
@@ -171,7 +171,7 @@ st_bufferobj_data(struct gl_context *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;

@@ -179,22 +179,43 @@ st_bufferobj_data(struct gl_context *ctx,
    switch(target) {

    case GL_PIXEL_PACK_BUFFER_ARB:

    case GL_PIXEL_UNPACK_BUFFER_ARB:

-      buffer_usage = PIPE_BIND_RENDER_TARGET;

+      bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;

       break;

    case GL_ARRAY_BUFFER_ARB:

-      buffer_usage = PIPE_BIND_VERTEX_BUFFER;

+      bind = PIPE_BIND_VERTEX_BUFFER;

       break;

    case GL_ELEMENT_ARRAY_BUFFER_ARB:

-      buffer_usage = PIPE_BIND_INDEX_BUFFER;

+      bind = PIPE_BIND_INDEX_BUFFER;

       break;

    default:

-      buffer_usage = 0;

+      bind = 0;

+   }

+

+   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;

    }

 

    pipe_resource_reference( &st_obj->buffer, NULL );

 

    if (size != 0) {

-      st_obj->buffer = pipe_buffer_create(pipe->screen, buffer_usage, size);

+      st_obj->buffer = pipe_buffer_create(pipe->screen, bind,

+                                          pipe_usage, size);

 

       if (!st_obj->buffer) {

          return GL_FALSE;

diff --git a/mesalib/src/mesa/state_tracker/st_cb_clear.c b/mesalib/src/mesa/state_tracker/st_cb_clear.c
index 3e27be271..461f4e315 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_clear.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_clear.c
@@ -138,6 +138,7 @@ draw_quad(struct st_context *st,
    if (!st->clear.vbuf) {

       st->clear.vbuf = pipe_buffer_create(pipe->screen,

                                           PIPE_BIND_VERTEX_BUFFER,

+                                          PIPE_USAGE_STREAM,

                                           max_slots * sizeof(st->clear.vertices));

    }

 

@@ -172,7 +173,8 @@ draw_quad(struct st_context *st,
                                            st->clear.vertices);

 

    /* draw */

-   util_draw_vertex_buffer(pipe, 

+   util_draw_vertex_buffer(pipe,

+                           st->cso_context,

                            st->clear.vbuf, 

                            st->clear.vbuf_slot * sizeof(st->clear.vertices),

                            PIPE_PRIM_TRIANGLE_FAN,

@@ -221,6 +223,7 @@ clear_with_quad(struct gl_context *ctx,
    cso_save_fragment_shader(st->cso_context);

    cso_save_vertex_shader(st->cso_context);

    cso_save_vertex_elements(st->cso_context);

+   cso_save_vertex_buffers(st->cso_context);

 

    /* blend state: RGBA masking */

    {

@@ -309,6 +312,7 @@ clear_with_quad(struct gl_context *ctx,
    cso_restore_fragment_shader(st->cso_context);

    cso_restore_vertex_shader(st->cso_context);

    cso_restore_vertex_elements(st->cso_context);

+   cso_restore_vertex_buffers(st->cso_context);

 }

 

 

diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
index 56c7e8581..18ac6c8e0 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -522,10 +522,11 @@ draw_quad(struct gl_context *ctx, GLfloat x0, GLfloat y0, GLfloat z,
       /* allocate/load buffer object with vertex data */

       buf = pipe_buffer_create(pipe->screen,

 			       PIPE_BIND_VERTEX_BUFFER,

+			       PIPE_USAGE_STATIC,

                                sizeof(verts));

       pipe_buffer_write(st->pipe, buf, 0, sizeof(verts), verts);

 

-      util_draw_vertex_buffer(pipe, buf, 0,

+      util_draw_vertex_buffer(pipe, st->cso_context, buf, 0,

                               PIPE_PRIM_QUADS,

                               4,  /* verts */

                               3); /* attribs/vert */

@@ -570,6 +571,7 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
    cso_save_fragment_shader(cso);

    cso_save_vertex_shader(cso);

    cso_save_vertex_elements(cso);

+   cso_save_vertex_buffers(cso);

    if (write_stencil) {

       cso_save_depth_stencil_alpha(cso);

       cso_save_blend(cso);

@@ -686,6 +688,7 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
    cso_restore_fragment_shader(cso);

    cso_restore_vertex_shader(cso);

    cso_restore_vertex_elements(cso);

+   cso_restore_vertex_buffers(cso);

    if (write_stencil) {

       cso_restore_depth_stencil_alpha(cso);

       cso_restore_blend(cso);

diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawtex.c b/mesalib/src/mesa/state_tracker/st_cb_drawtex.c
index 5976f1048..db299eb8d 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_drawtex.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_drawtex.c
@@ -139,6 +139,7 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
 

    /* create the vertex buffer */

    vbuffer = pipe_buffer_create(pipe->screen, PIPE_BIND_VERTEX_BUFFER,

+                                PIPE_USAGE_STREAM,

                                 numAttribs * 4 * 4 * sizeof(GLfloat));

 

    /* load vertex buffer */

@@ -230,6 +231,7 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
    cso_save_viewport(cso);

    cso_save_vertex_shader(cso);

    cso_save_vertex_elements(cso);

+   cso_save_vertex_buffers(cso);

 

    {

       void *vs = lookup_shader(pipe, numAttribs,

@@ -264,7 +266,7 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
    }

 

 

-   util_draw_vertex_buffer(pipe, vbuffer,

+   util_draw_vertex_buffer(pipe, cso, vbuffer,

                            0,  /* offset */

                            PIPE_PRIM_TRIANGLE_FAN,

                            4,  /* verts */

@@ -277,6 +279,7 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
    cso_restore_viewport(cso);

    cso_restore_vertex_shader(cso);

    cso_restore_vertex_elements(cso);

+   cso_restore_vertex_buffers(cso);

 }

 

 

diff --git a/mesalib/src/mesa/state_tracker/st_context.c b/mesalib/src/mesa/state_tracker/st_context.c
index b16d965f8..8f3a7415d 100644
--- a/mesalib/src/mesa/state_tracker/st_context.c
+++ b/mesalib/src/mesa/state_tracker/st_context.c
@@ -203,6 +203,11 @@ static void st_destroy_context_priv( struct st_context *st )
    st_destroy_drawpix(st);

    st_destroy_drawtex(st);

 

+   /* 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 < Elements(st->state.sampler_views); i++) {

       pipe_sampler_view_reference(&st->state.sampler_views[i], NULL);

    }

diff --git a/mesalib/src/mesa/state_tracker/st_context.h b/mesalib/src/mesa/state_tracker/st_context.h
index 492ee600e..ef54fd7cd 100644
--- a/mesalib/src/mesa/state_tracker/st_context.h
+++ b/mesalib/src/mesa/state_tracker/st_context.h
@@ -185,6 +185,11 @@ struct st_context
 

    int force_msaa;

    void *winsys_drawable_handle;

+

+   /* User vertex buffers. */

+   struct pipe_resource *user_vb[PIPE_MAX_ATTRIBS];

+   unsigned user_vb_stride[PIPE_MAX_ATTRIBS];

+   unsigned num_user_vbs;

 };

 

 

diff --git a/mesalib/src/mesa/state_tracker/st_draw.c b/mesalib/src/mesa/state_tracker/st_draw.c
index 19466ea44..a31cbdc9e 100644
--- a/mesalib/src/mesa/state_tracker/st_draw.c
+++ b/mesalib/src/mesa/state_tracker/st_draw.c
@@ -243,13 +243,11 @@ st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
 static GLboolean

 is_interleaved_arrays(const struct st_vertex_program *vp,

                       const struct st_vp_variant *vpv,

-                      const struct gl_client_array **arrays,

-                      GLboolean *userSpace)

+                      const struct gl_client_array **arrays)

 {

    GLuint attr;

    const struct gl_buffer_object *firstBufObj = NULL;

    GLint firstStride = -1;

-   GLuint num_client_arrays = 0;

    const GLubyte *client_addr = NULL;

 

    for (attr = 0; attr < vpv->num_inputs; attr++) {

@@ -263,9 +261,8 @@ is_interleaved_arrays(const struct st_vertex_program *vp,
       else if (firstStride != stride) {

          return GL_FALSE;

       }

-         

+

       if (!bufObj || !bufObj->Name) {

-         num_client_arrays++;

          /* Try to detect if the client-space arrays are

           * "close" to each other.

           */

@@ -285,57 +282,11 @@ is_interleaved_arrays(const struct st_vertex_program *vp,
       }

    }

 

-   *userSpace = (num_client_arrays == vpv->num_inputs);

-   /* debug_printf("user space: %s (%d arrays, %d inputs)\n",

-      (int)*userSpace ? "Yes" : "No", num_client_arrays, vp->num_inputs); */

-

    return GL_TRUE;

 }

 

 

 /**

- * Compute the memory range occupied by the arrays.

- */

-static void

-get_arrays_bounds(const struct st_vertex_program *vp,

-                  const struct st_vp_variant *vpv,

-                  const struct gl_client_array **arrays,

-                  GLuint max_index,

-                  const GLubyte **low, const GLubyte **high)

-{

-   const GLubyte *low_addr = NULL;

-   const GLubyte *high_addr = NULL;

-   GLuint attr;

-

-   /* debug_printf("get_arrays_bounds: Handling %u attrs\n", vpv->num_inputs); */

-

-   for (attr = 0; attr < vpv->num_inputs; attr++) {

-      const GLuint mesaAttr = vp->index_to_input[attr];

-      const GLint stride = arrays[mesaAttr]->StrideB;

-      const GLubyte *start = arrays[mesaAttr]->Ptr;

-      const unsigned sz = (arrays[mesaAttr]->Size * 

-                           _mesa_sizeof_type(arrays[mesaAttr]->Type));

-      const GLubyte *end = start + (max_index * stride) + sz;

-

-      /* debug_printf("attr %u: stride %d size %u start %p end %p\n",

-         attr, stride, sz, start, end); */

-

-      if (attr == 0) {

-         low_addr = start;

-         high_addr = end;

-      }

-      else {

-         low_addr = MIN2(low_addr, start);

-         high_addr = MAX2(high_addr, end);

-      }

-   }

-

-   *low = low_addr;

-   *high = high_addr;

-}

-

-

-/**

  * Set up for drawing interleaved arrays that all live in one VBO

  * or all live in user space.

  * \param vbuffer  returns vertex buffer info

@@ -346,15 +297,21 @@ setup_interleaved_attribs(struct gl_context *ctx,
                           const struct st_vertex_program *vp,

                           const struct st_vp_variant *vpv,

                           const struct gl_client_array **arrays,

-                          GLuint max_index,

-                          GLboolean userSpace,

                           struct pipe_vertex_buffer *vbuffer,

-                          struct pipe_vertex_element velements[])

+                          struct pipe_vertex_element velements[],

+                          unsigned max_index)

 {

    struct st_context *st = st_context(ctx);

    struct pipe_context *pipe = st->pipe;

    GLuint attr;

-   const GLubyte *offset0 = NULL;

+   const GLubyte *low_addr = NULL;

+

+   /* Find the lowest address. */

+   for (attr = 0; attr < vpv->num_inputs; attr++) {

+      const GLubyte *start = arrays[vp->index_to_input[attr]]->Ptr;

+

+      low_addr = !low_addr ? start : MIN2(low_addr, start);

+   }

 

    for (attr = 0; attr < vpv->num_inputs; attr++) {

       const GLuint mesaAttr = vp->index_to_input[attr];

@@ -362,40 +319,28 @@ setup_interleaved_attribs(struct gl_context *ctx,
       struct st_buffer_object *stobj = st_buffer_object(bufobj);

       GLsizei stride = arrays[mesaAttr]->StrideB;

 

-      /*printf("stobj %u = %p\n", attr, (void*)stobj);*/

-

       if (attr == 0) {

-         const GLubyte *low, *high;

-

-         get_arrays_bounds(vp, vpv, arrays, max_index, &low, &high);

-         /* debug_printf("buffer range: %p %p range %d max index %u\n",

-            low, high, high - low, max_index); */

-

-         offset0 = low;

-         if (userSpace) {

+         if (bufobj && bufobj->Name) {

+            vbuffer->buffer = NULL;

+            pipe_resource_reference(&vbuffer->buffer, stobj->buffer);

+            vbuffer->buffer_offset = pointer_to_offset(low_addr);

+         } else {

             vbuffer->buffer =

-               pipe_user_buffer_create(pipe->screen, (void *) low, high - low,

+               pipe_user_buffer_create(pipe->screen, (void*)low_addr,

+                                       stride * (max_index + 1),

 				       PIPE_BIND_VERTEX_BUFFER);

             vbuffer->buffer_offset = 0;

-         }

-         else {

-            vbuffer->buffer = NULL;

-            pipe_resource_reference(&vbuffer->buffer, stobj->buffer);

-            vbuffer->buffer_offset = pointer_to_offset(low);

+

+            /* Track user vertex buffers. */

+            pipe_resource_reference(&st->user_vb[0], vbuffer->buffer);

+            st->user_vb_stride[0] = stride;

+            st->num_user_vbs = 1;

          }

          vbuffer->stride = stride; /* in bytes */

-         vbuffer->max_index = max_index;

       }

 

-      /*

-      if (arrays[mesaAttr]->InstanceDivisor)

-         vbuffer[attr].max_index = arrays[mesaAttr]->_MaxElement;

-      else

-         vbuffer[attr].max_index = max_index;

-      */

-

       velements[attr].src_offset =

-         (unsigned) (arrays[mesaAttr]->Ptr - offset0);

+         (unsigned) (arrays[mesaAttr]->Ptr - low_addr);

       velements[attr].instance_divisor = arrays[mesaAttr]->InstanceDivisor;

       velements[attr].vertex_buffer_index = 0;

       velements[attr].src_format =

@@ -419,10 +364,9 @@ setup_non_interleaved_attribs(struct gl_context *ctx,
                               const struct st_vertex_program *vp,

                               const struct st_vp_variant *vpv,

                               const struct gl_client_array **arrays,

-                              GLuint max_index,

-                              GLboolean *userSpace,

                               struct pipe_vertex_buffer vbuffer[],

-                              struct pipe_vertex_element velements[])

+                              struct pipe_vertex_element velements[],

+                              unsigned max_index)

 {

    struct st_context *st = st_context(ctx);

    struct pipe_context *pipe = st->pipe;

@@ -433,8 +377,6 @@ setup_non_interleaved_attribs(struct gl_context *ctx,
       struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;

       GLsizei stride = arrays[mesaAttr]->StrideB;

 

-      *userSpace = GL_FALSE;

-

       if (bufobj && bufobj->Name) {

          /* Attribute data is in a VBO.

           * Recall that for VBOs, the gl_client_array->Ptr field is

@@ -442,37 +384,23 @@ setup_non_interleaved_attribs(struct gl_context *ctx,
           */

          struct st_buffer_object *stobj = st_buffer_object(bufobj);

          assert(stobj->buffer);

-         /*printf("stobj %u = %p\n", attr, (void*) stobj);*/

 

          vbuffer[attr].buffer = NULL;

          pipe_resource_reference(&vbuffer[attr].buffer, stobj->buffer);

          vbuffer[attr].buffer_offset = pointer_to_offset(arrays[mesaAttr]->Ptr);

       }

       else {

-         /* attribute data is in user-space memory, not a VBO */

-         uint bytes;

-         /*printf("user-space array %d stride %d\n", attr, stride);*/

-	

-         *userSpace = GL_TRUE;

-

          /* wrap user data */

          if (arrays[mesaAttr]->Ptr) {

-            /* user's vertex array */

-            if (arrays[mesaAttr]->StrideB) {

-               bytes = arrays[mesaAttr]->StrideB * (max_index + 1);

-            }

-            else {

-               bytes = arrays[mesaAttr]->Size

-                  * _mesa_sizeof_type(arrays[mesaAttr]->Type);

-            }

             vbuffer[attr].buffer = 

 	       pipe_user_buffer_create(pipe->screen,

-				       (void *) arrays[mesaAttr]->Ptr, bytes,

+				       (void *) arrays[mesaAttr]->Ptr,

+				       stride * (max_index + 1),

 				       PIPE_BIND_VERTEX_BUFFER);

          }

          else {

             /* no array, use ctx->Current.Attrib[] value */

-            bytes = sizeof(ctx->Current.Attrib[0]);

+            uint bytes = sizeof(ctx->Current.Attrib[0]);

             vbuffer[attr].buffer = 

 	       pipe_user_buffer_create(pipe->screen,

 				       (void *) ctx->Current.Attrib[mesaAttr],

@@ -482,16 +410,15 @@ setup_non_interleaved_attribs(struct gl_context *ctx,
          }

 

          vbuffer[attr].buffer_offset = 0;

-      }

 

-      assert(velements[attr].src_offset <= 2048); /* 11-bit field */

+         /* Track user vertex buffers. */

+         pipe_resource_reference(&st->user_vb[attr], vbuffer->buffer);

+         st->user_vb_stride[attr] = stride;

+         st->num_user_vbs = MAX2(st->num_user_vbs, attr+1);

+      }

 

       /* common-case setup */

       vbuffer[attr].stride = stride; /* in bytes */

-      if (arrays[mesaAttr]->InstanceDivisor)

-         vbuffer[attr].max_index = arrays[mesaAttr]->_MaxElement;

-      else

-         vbuffer[attr].max_index = max_index;

 

       velements[attr].src_offset = 0;

       velements[attr].instance_divisor = arrays[mesaAttr]->InstanceDivisor;

@@ -609,6 +536,62 @@ translate_prim(const struct gl_context *ctx, unsigned prim)
 }

 

 

+static void

+st_validate_varrays(struct gl_context *ctx,

+                    const struct gl_client_array **arrays,

+                    unsigned max_index)

+{

+   struct st_context *st = st_context(ctx);

+   const struct st_vertex_program *vp;

+   const struct st_vp_variant *vpv;

+   struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];

+   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];

+   unsigned num_vbuffers, num_velements;

+   GLuint attr;

+   unsigned i;

+

+   /* must get these after state validation! */

+   vp = st->vp;

+   vpv = st->vp_variant;

+

+   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);

+   }

+   st->num_user_vbs = 0;

+

+   /*

+    * Setup the vbuffer[] and velements[] arrays.

+    */

+   if (is_interleaved_arrays(vp, vpv, arrays)) {

+      setup_interleaved_attribs(ctx, vp, vpv, arrays, vbuffer, velements,

+                                max_index);

+      num_vbuffers = 1;

+      num_velements = vpv->num_inputs;

+      if (num_velements == 0)

+         num_vbuffers = 0;

+   }

+   else {

+      setup_non_interleaved_attribs(ctx, vp, vpv, arrays,

+                                    vbuffer, velements, max_index);

+      num_vbuffers = vpv->num_inputs;

+      num_velements = vpv->num_inputs;

+   }

+

+   cso_set_vertex_buffers(st->cso_context, num_vbuffers, vbuffer);

+   cso_set_vertex_elements(st->cso_context, num_velements, velements);

+

+   /* unreference buffers (frees wrapped user-space buffer objects)

+    * This is OK, because the pipe driver should reference buffers by itself

+    * in set_vertex_buffers. */

+   for (attr = 0; attr < num_vbuffers; attr++) {

+      pipe_resource_reference(&vbuffer[attr].buffer, NULL);

+      assert(!vbuffer[attr].buffer);

+   }

+}

+

 

 /**

  * This function gets plugged into the VBO module and is called when

@@ -627,90 +610,79 @@ st_draw_vbo(struct gl_context *ctx,
 {

    struct st_context *st = st_context(ctx);

    struct pipe_context *pipe = st->pipe;

-   const struct st_vertex_program *vp;

-   const struct st_vp_variant *vpv;

-   struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];

-   GLuint attr;

-   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];

-   unsigned num_vbuffers, num_velements;

    struct pipe_index_buffer ibuffer;

-   GLboolean userSpace = GL_FALSE;

-   GLboolean vertDataEdgeFlags;

    struct pipe_draw_info info;

    unsigned i;

+   GLboolean new_array =

+         st->dirty.st && (st->dirty.mesa & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;

 

    /* Mesa core state should have been validated already */

    assert(ctx->NewState == 0x0);

 

-   /* Gallium probably doesn't want this in some cases. */

-   if (!index_bounds_valid)

-      if (!vbo_all_varyings_in_vbos(arrays))

-	 vbo_get_minmax_index(ctx, prims, ib, &min_index, &max_index);

+   if (ib) {

+      /* Gallium probably doesn't want this in some cases. */

+      if (!index_bounds_valid)

+         if (!vbo_all_varyings_in_vbos(arrays))

+            vbo_get_minmax_index(ctx, prims, ib, &min_index, &max_index);

+   } else {

+      /* Get min/max index for non-indexed drawing. */

+      min_index = ~0;

+      max_index = 0;

+

+      for (i = 0; i < nr_prims; i++) {

+         min_index = MIN2(min_index, prims[i].start);

+         max_index = MAX2(max_index, prims[i].start + prims[i].count - 1);

+      }

+   }

 

-   /* sanity check for pointer arithmetic below */

-   assert(sizeof(arrays[0]->Ptr[0]) == 1);

+   /* Validate state. */

+   if (st->dirty.st) {

+      GLboolean vertDataEdgeFlags;

 

-   vertDataEdgeFlags = arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj &&

-                       arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj->Name;

-   if (vertDataEdgeFlags != st->vertdata_edgeflags) {

-      st->vertdata_edgeflags = vertDataEdgeFlags;

-      st->dirty.st |= ST_NEW_EDGEFLAGS_DATA;

-   }

+      /* sanity check for pointer arithmetic below */

+      assert(sizeof(arrays[0]->Ptr[0]) == 1);

 

-   st_validate_state(st);

+      vertDataEdgeFlags = arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj &&

+                          arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj->Name;

+      if (vertDataEdgeFlags != st->vertdata_edgeflags) {

+         st->vertdata_edgeflags = vertDataEdgeFlags;

+         st->dirty.st |= ST_NEW_EDGEFLAGS_DATA;

+      }

 

-   /* must get these after state validation! */

-   vp = st->vp;

-   vpv = st->vp_variant;

+      st_validate_state(st);

+

+      if (new_array) {

+         st_validate_varrays(ctx, arrays, max_index);

+      }

 

 #if 0

-   if (MESA_VERBOSE & VERBOSE_GLSL) {

-      check_uniforms(ctx);

-   }

+      if (MESA_VERBOSE & VERBOSE_GLSL) {

+         check_uniforms(ctx);

+      }

 #else

-   (void) check_uniforms;

+      (void) check_uniforms;

 #endif

-

-   memset(velements, 0, sizeof(struct pipe_vertex_element) * vpv->num_inputs);

-   /*

-    * Setup the vbuffer[] and velements[] arrays.

-    */

-   if (is_interleaved_arrays(vp, vpv, arrays, &userSpace)) {

-      /*printf("Draw interleaved\n");*/

-      setup_interleaved_attribs(ctx, vp, vpv, arrays, max_index, userSpace,

-                                vbuffer, velements);

-      num_vbuffers = 1;

-      num_velements = vpv->num_inputs;

-      if (num_velements == 0)

-         num_vbuffers = 0;

-   }

-   else {

-      /*printf("Draw non-interleaved\n");*/

-      setup_non_interleaved_attribs(ctx, vp, vpv, arrays, max_index,

-                                    &userSpace, vbuffer, velements);

-      num_vbuffers = vpv->num_inputs;

-      num_velements = vpv->num_inputs;

    }

 

-#if 0

-   {

-      GLuint i;

-      for (i = 0; i < num_vbuffers; i++) {

-         printf("buffers[%d].stride = %u\n", i, vbuffer[i].stride);

-         printf("buffers[%d].max_index = %u\n", i, vbuffer[i].max_index);

-         printf("buffers[%d].buffer_offset = %u\n", i, vbuffer[i].buffer_offset);

-         printf("buffers[%d].buffer = %p\n", i, (void*) vbuffer[i].buffer);

-      }

-      for (i = 0; i < num_velements; i++) {

-         printf("vlements[%d].vbuffer_index = %u\n", i, velements[i].vertex_buffer_index);

-         printf("vlements[%d].src_offset = %u\n", i, velements[i].src_offset);

-         printf("vlements[%d].format = %s\n", i, util_format_name(velements[i].src_format));

+   /* 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);

+            }

+         }

       }

    }

-#endif

-

-   pipe->set_vertex_buffers(pipe, num_vbuffers, vbuffer);

-   cso_set_vertex_elements(st->cso_context, num_velements, velements);

 

    setup_index_buffer(ctx, ib, &ibuffer);

    pipe->set_index_buffer(pipe, &ibuffer);

@@ -744,17 +716,6 @@ st_draw_vbo(struct gl_context *ctx,
    }

 

    pipe_resource_reference(&ibuffer.buffer, NULL);

-

-   /* unreference buffers (frees wrapped user-space buffer objects) */

-   for (attr = 0; attr < num_vbuffers; attr++) {

-      pipe_resource_reference(&vbuffer[attr].buffer, NULL);

-      assert(!vbuffer[attr].buffer);

-   }

-

-   if (userSpace) 

-   {

-      pipe->set_vertex_buffers(pipe, 0, NULL);

-   }

 }

 

 

diff --git a/mesalib/src/mesa/state_tracker/st_draw_feedback.c b/mesalib/src/mesa/state_tracker/st_draw_feedback.c
index 2ecb8e202..f0734eae0 100644
--- a/mesalib/src/mesa/state_tracker/st_draw_feedback.c
+++ b/mesalib/src/mesa/state_tracker/st_draw_feedback.c
@@ -179,7 +179,6 @@ st_feedback_draw_vbo(struct gl_context *ctx,
 

       /* common-case setup */

       vbuffers[attr].stride = arrays[mesaAttr]->StrideB; /* in bytes */

-      vbuffers[attr].max_index = max_index;

       velements[attr].instance_divisor = 0;

       velements[attr].vertex_buffer_index = attr;

       velements[attr].src_format = 

diff --git a/mesalib/src/mesa/state_tracker/st_gen_mipmap.c b/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
index 0be66a2c2..5fcd806e0 100644
--- a/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
+++ b/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
@@ -105,13 +105,12 @@ st_render_mipmap(struct st_context *st,
 static void

 decompress_image(enum pipe_format format,

                  const uint8_t *src, uint8_t *dst,

-                 unsigned width, unsigned height)

+                 unsigned width, unsigned height, unsigned src_stride)

 {

    const struct util_format_description *desc = util_format_description(format);

    const uint bw = util_format_get_blockwidth(format);

    const uint bh = util_format_get_blockheight(format);

    const uint dst_stride = 4 * MAX2(width, bw);

-   const uint src_stride = util_format_get_stride(format, width);

 

    desc->unpack_rgba_8unorm(dst, dst_stride, src, src_stride, width, height);

 

@@ -144,10 +143,9 @@ decompress_image(enum pipe_format format,
 static void

 compress_image(enum pipe_format format,

                const uint8_t *src, uint8_t *dst,

-               unsigned width, unsigned height)

+               unsigned width, unsigned height, unsigned dst_stride)

 {

    const struct util_format_description *desc = util_format_description(format);

-   const uint dst_stride = util_format_get_stride(format, width);

    const uint src_stride = 4 * width;

 

    desc->pack_rgba_8unorm(dst, dst_stride, src, src_stride, width, height);

@@ -236,7 +234,7 @@ fallback_generate_mipmap(struct gl_context *ctx, GLenum target,
          dstTemp = malloc(dstWidth2 * dstHeight2 * comps + 000);

 

          /* decompress the src image: srcData -> srcTemp */

-         decompress_image(format, srcData, srcTemp, srcWidth, srcHeight);

+         decompress_image(format, srcData, srcTemp, srcWidth, srcHeight, srcTrans->stride);

 

          _mesa_generate_mipmap_level(target, datatype, comps,

                                      0 /*border*/,

@@ -248,7 +246,7 @@ fallback_generate_mipmap(struct gl_context *ctx, GLenum target,
                                      dstWidth2); /* stride in texels */

 

          /* compress the new image: dstTemp -> dstData */

-         compress_image(format, dstTemp, dstData, dstWidth, dstHeight);

+         compress_image(format, dstTemp, dstData, dstWidth, dstHeight, dstTrans->stride);

 

          free(srcTemp);

          free(dstTemp);

diff --git a/mesalib/src/mesa/tnl/t_draw.c b/mesalib/src/mesa/tnl/t_draw.c
index 741f0ed3f..a2ca6225b 100644
--- a/mesalib/src/mesa/tnl/t_draw.c
+++ b/mesalib/src/mesa/tnl/t_draw.c
@@ -125,6 +125,43 @@ convert_half_to_float(const struct gl_client_array *input,
    }

 }

 

+/**

+ * \brief Convert fixed-point to floating-point.

+ *

+ * In OpenGL, a fixed-point number is a "signed 2's complement 16.16 scaled

+ * integer" (Table 2.2 of the OpenGL ES 2.0 spec).

+ *

+ * If the buffer has the \c normalized flag set, the formula

+ *     \code normalize(x) := (2*x + 1) / (2^16 - 1) \endcode

+ * is used to map the fixed-point numbers into the range [-1, 1].

+ */

+static void

+convert_fixed_to_float(const struct gl_client_array *input,

+                       const GLubyte *ptr, GLfloat *fptr,

+                       GLuint count)

+{

+   GLuint i, j;

+   const GLint size = input->Size;

+

+   if (input->Normalized) {

+      for (i = 0; i < count; ++i) {

+         const GLfixed *in = (GLfixed *) ptr;

+         for (j = 0; j < size; ++j) {

+            *fptr++ = (GLfloat) (2 * in[j] + 1) / (GLfloat) ((1 << 16) - 1);

+         }

+         ptr += input->StrideB;

+      }

+   } else {

+      for (i = 0; i < count; ++i) {

+         const GLfixed *in = (GLfixed *) ptr;

+         for (j = 0; j < size; ++j) {

+            *fptr++ = in[j] / (GLfloat) (1 << 16);

+         }

+         ptr += input->StrideB;

+      }

+   }

+}

+

 /* Adjust pointer to point at first requested element, convert to

  * floating point, populate VB->AttribPtr[].

  */

@@ -174,6 +211,9 @@ static void _tnl_import_array( struct gl_context *ctx,
       case GL_HALF_FLOAT:

 	 convert_half_to_float(input, ptr, fptr, count, sz);

 	 break;

+      case GL_FIXED:

+         convert_fixed_to_float(input, ptr, fptr, count);

+         break;

       default:

 	 assert(0);

 	 break;

diff --git a/mesalib/src/mesa/vbo/vbo_exec_array.c b/mesalib/src/mesa/vbo/vbo_exec_array.c
index 13b54d59c..4304985aa 100644
--- a/mesalib/src/mesa/vbo/vbo_exec_array.c
+++ b/mesalib/src/mesa/vbo/vbo_exec_array.c
@@ -502,8 +502,13 @@ recalculate_input_bindings(struct gl_context *ctx)
 static void

 bind_arrays(struct gl_context *ctx)

 {

+   if (!ctx->Array.RebindArrays) {

+      return;

+   }

+

    bind_array_obj(ctx);

    recalculate_input_bindings(ctx);

+   ctx->Array.RebindArrays = GL_FALSE;

 }

 

 

diff --git a/mesalib/src/mesa/vbo/vbo_exec_draw.c b/mesalib/src/mesa/vbo/vbo_exec_draw.c
index 048f3d170..a2a098857 100644
--- a/mesalib/src/mesa/vbo/vbo_exec_draw.c
+++ b/mesalib/src/mesa/vbo/vbo_exec_draw.c
@@ -245,6 +245,7 @@ vbo_exec_bind_arrays( struct gl_context *ctx )
 	 arrays[attr]._MaxElement = count; /* ??? */

 

          varying_inputs |= 1 << attr;

+         ctx->NewState |= _NEW_ARRAY;

       }

    }

 

diff --git a/mesalib/src/mesa/vbo/vbo_save_draw.c b/mesalib/src/mesa/vbo/vbo_save_draw.c
index 6d8dbdb86..5a19b0d62 100644
--- a/mesalib/src/mesa/vbo/vbo_save_draw.c
+++ b/mesalib/src/mesa/vbo/vbo_save_draw.c
@@ -202,6 +202,7 @@ static void vbo_bind_vertex_list(struct gl_context *ctx,
 

 	 buffer_offset += node->attrsz[src] * sizeof(GLfloat);

          varying_inputs |= 1<<attr;

+         ctx->NewState |= _NEW_ARRAY;

       }

    }