自学教程：C++ st_buffer_object函数代码示例

/** * Called via glMapBufferARB(). */static void *st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access,                 struct gl_buffer_object *obj){   struct st_buffer_object *st_obj = st_buffer_object(obj);   GLuint flags;   switch (access) {   case GL_WRITE_ONLY:      flags = PIPE_BUFFER_USAGE_CPU_WRITE;      break;   case GL_READ_ONLY:      flags = PIPE_BUFFER_USAGE_CPU_READ;      break;   case GL_READ_WRITE:      /* fall-through */   default:      flags = PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE;      break;         }   obj->Pointer = st_cond_flush_pipe_buffer_map(st_context(ctx),						st_obj->buffer,						flags);   if(obj->Pointer) {      obj->Offset = 0;      obj->Length = obj->Size;   }   return obj->Pointer;}

/** * Called via glMapBufferRange(). */static void *st_bufferobj_map_range(struct gl_context *ctx,                       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);   enum pipe_transfer_usage flags = 0x0;   if (access & GL_MAP_WRITE_BIT)      flags |= PIPE_TRANSFER_WRITE;   if (access & GL_MAP_READ_BIT)      flags |= PIPE_TRANSFER_READ;   if (access & GL_MAP_FLUSH_EXPLICIT_BIT)      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_TRANSFER_DONTBLOCK;   assert(offset >= 0);   assert(length >= 0);   assert(offset < obj->Size);   assert(offset + length <= obj->Size);   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->Offset = offset;      obj->Length = length;      obj->AccessFlags = access;   }   return obj->Pointer;}

static void st_dispatch_compute_indirect(struct gl_context *ctx,                                         GLintptr indirect_offset){   struct gl_buffer_object *indirect_buffer = ctx->DispatchIndirectBuffer;   struct pipe_resource *indirect = st_buffer_object(indirect_buffer)->buffer;   st_dispatch_compute_common(ctx, NULL, NULL, indirect, indirect_offset);}

/* Validate and fill buffer addressing information based on GL pixelstore * attributes. * * Returns false if some aspect of the addressing (e.g. alignment) prevents * PBO upload/download. */boolst_pbo_addresses_pixelstore(struct st_context *st,                            GLenum gl_target, bool skip_images,                            const struct gl_pixelstore_attrib *store,                            const void *pixels,                            struct st_pbo_addresses *addr){   struct pipe_resource *buf = st_buffer_object(store->BufferObj)->buffer;   intptr_t buf_offset = (intptr_t) pixels;   if (buf_offset % addr->bytes_per_pixel)      return false;   /* Convert to texels */   buf_offset = buf_offset / addr->bytes_per_pixel;   /* Determine image height */   if (gl_target == GL_TEXTURE_1D_ARRAY) {      addr->image_height = 1;   } else {      addr->image_height = store->ImageHeight > 0 ? store->ImageHeight : addr->height;   }   /* Compute the stride, taking store->Alignment into account */   {       unsigned pixels_per_row = store->RowLength > 0 ?                           store->RowLength : addr->width;       unsigned bytes_per_row = pixels_per_row * addr->bytes_per_pixel;       unsigned remainder = bytes_per_row % store->Alignment;       unsigned offset_rows;       if (remainder > 0)          bytes_per_row += store->Alignment - remainder;       if (bytes_per_row % addr->bytes_per_pixel)          return false;       addr->pixels_per_row = bytes_per_row / addr->bytes_per_pixel;       offset_rows = store->SkipRows;       if (skip_images)          offset_rows += addr->image_height * store->SkipImages;       buf_offset += store->SkipPixels + addr->pixels_per_row * offset_rows;   }   if (!st_pbo_addresses_setup(st, buf, buf_offset, addr))      return false;   /* Support GL_PACK_INVERT_MESA */   if (store->Invert) {      addr->constants.xoffset += (addr->height - 1) * addr->constants.stride;      addr->constants.stride = -addr->constants.stride;   }   return true;}

voidst_setup_arrays(struct st_context *st,                const struct st_vertex_program *vp,                const struct st_vp_variant *vp_variant,                struct pipe_vertex_element *velements,                struct pipe_vertex_buffer *vbuffer, unsigned *num_vbuffers){   struct gl_context *ctx = st->ctx;   const struct gl_vertex_array_object *vao = ctx->Array._DrawVAO;   const GLbitfield inputs_read = vp_variant->vert_attrib_mask;   const ubyte *input_to_index = vp->input_to_index;   /* Process attribute array data. */   GLbitfield mask = inputs_read & _mesa_draw_array_bits(ctx);   while (mask) {      /* The attribute index to start pulling a binding */      const gl_vert_attrib i = ffs(mask) - 1;      const struct gl_vertex_buffer_binding *const binding         = _mesa_draw_buffer_binding(vao, i);      const unsigned bufidx = (*num_vbuffers)++;      if (_mesa_is_bufferobj(binding->BufferObj)) {         /* Set the binding */         struct st_buffer_object *stobj = st_buffer_object(binding->BufferObj);         vbuffer[bufidx].buffer.resource = stobj ? stobj->buffer : NULL;         vbuffer[bufidx].is_user_buffer = false;         vbuffer[bufidx].buffer_offset = _mesa_draw_binding_offset(binding);      } else {         /* Set the binding */         const void *ptr = (const void *)_mesa_draw_binding_offset(binding);         vbuffer[bufidx].buffer.user = ptr;         vbuffer[bufidx].is_user_buffer = true;         vbuffer[bufidx].buffer_offset = 0;         if (!binding->InstanceDivisor)            st->draw_needs_minmax_index = true;      }      vbuffer[bufidx].stride = binding->Stride; /* in bytes */      const GLbitfield boundmask = _mesa_draw_bound_attrib_bits(binding);      GLbitfield attrmask = mask & boundmask;      /* Mark the those attributes as processed */      mask &= ~boundmask;      /* We can assume that we have array for the binding */      assert(attrmask);      /* Walk attributes belonging to the binding */      while (attrmask) {         const gl_vert_attrib attr = u_bit_scan(&attrmask);         const struct gl_array_attributes *const attrib            = _mesa_draw_array_attrib(vao, attr);         const GLuint off = _mesa_draw_attributes_relative_offset(attrib);         init_velement_lowered(vp, velements, &attrib->Format, off,                               binding->InstanceDivisor, bufidx,                               input_to_index[attr]);      }   }}

/** * Deallocate/free a vertex/pixel buffer object. * Called via glDeleteBuffersARB(). */static voidst_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj){   struct st_buffer_object *st_obj = st_buffer_object(obj);   if (st_obj->buffer)       pipe_buffer_reference(&st_obj->buffer, NULL);   _mesa_free(st_obj);}

/** * Called via glUnmapBufferARB(). */static GLbooleanst_bufferobj_unmap(GLcontext *ctx, GLenum target, 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);   obj->Pointer = NULL;   obj->Offset = 0;   obj->Length = 0;   return GL_TRUE;}

/** * Deallocate/free a vertex/pixel buffer object. * Called via glDeleteBuffersARB(). */static voidst_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_resource_reference(&st_obj->buffer, NULL);   free(st_obj);}

/** * Deallocate/free a vertex/pixel buffer object. * Called via glDeleteBuffersARB(). */static voidst_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);   _mesa_buffer_unmap_all_mappings(ctx, obj);   if (st_obj->buffer)      pipe_resource_reference(&st_obj->buffer, NULL);   _mesa_delete_buffer_object(ctx, obj);}

static voidst_bind_ssbos(struct st_context *st, struct gl_program *prog,              enum pipe_shader_type shader_type){   unsigned i;   struct pipe_shader_buffer buffers[MAX_SHADER_STORAGE_BUFFERS];   struct gl_program_constants *c;   if (!prog || !st->pipe->set_shader_buffers)      return;   c = &st->ctx->Const.Program[prog->info.stage];   for (i = 0; i < prog->info.num_ssbos; i++) {      struct gl_buffer_binding *binding;      struct st_buffer_object *st_obj;      struct pipe_shader_buffer *sb = &buffers[i];      binding = &st->ctx->ShaderStorageBufferBindings[            prog->sh.ShaderStorageBlocks[i]->Binding];      st_obj = st_buffer_object(binding->BufferObject);      sb->buffer = st_obj->buffer;      if (sb->buffer) {         sb->buffer_offset = binding->Offset;         sb->buffer_size = sb->buffer->width0 - binding->Offset;         /* AutomaticSize is FALSE if the buffer was set with BindBufferRange.          * Take the minimum just to be sure.          */         if (!binding->AutomaticSize)            sb->buffer_size = MIN2(sb->buffer_size, (unsigned) binding->Size);      }      else {         sb->buffer_offset = 0;         sb->buffer_size = 0;      }   }   st->pipe->set_shader_buffers(st->pipe, shader_type, c->MaxAtomicBuffers,                                prog->info.num_ssbos, buffers);   /* clear out any stale shader buffers */   if (prog->info.num_ssbos < c->MaxShaderStorageBlocks)      st->pipe->set_shader_buffers(            st->pipe, shader_type,            c->MaxAtomicBuffers + prog->info.num_ssbos,            c->MaxShaderStorageBlocks - prog->info.num_ssbos,            NULL);}

/** * Called via glCopyBufferSubData(). */static voidst_copy_buffer_subdata(struct gl_context *ctx,                       struct gl_buffer_object *src,                       struct gl_buffer_object *dst,                       GLintptr readOffset, GLintptr writeOffset,                       GLsizeiptr size){   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);   struct pipe_box box;   if (!size)      return;   /* buffer should not already be mapped */   assert(!src->Pointer);   assert(!dst->Pointer);   u_box_1d(readOffset, size, &box);   pipe->resource_copy_region(pipe, dstObj->buffer, 0, writeOffset, 0, 0,                              srcObj->buffer, 0, &box);}

/** * Replace data in a subrange of buffer object.  If the data range * specified by size + offset extends beyond the end of the buffer or * if data is NULL, no copy is performed. * Called via glBufferSubDataARB(). */static voidst_bufferobj_subdata(GLcontext *ctx,		     GLenum target,		     GLintptrARB offset,		     GLsizeiptrARB size,		     const GLvoid * data, struct gl_buffer_object *obj){   struct st_buffer_object *st_obj = st_buffer_object(obj);   if (offset >= st_obj->size || size > (st_obj->size - offset))      return;   st_cond_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer,				   offset, size, data);}

/** * Called via glUnmapBufferARB(). */static GLbooleanst_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);   if (obj->Length)      pipe_buffer_unmap(pipe, st_obj->transfer);   st_obj->transfer = NULL;   obj->Pointer = NULL;   obj->Offset = 0;   obj->Length = 0;   return GL_TRUE;}

/** * Called via glUnmapBufferARB(). */static GLbooleanst_bufferobj_unmap(struct gl_context *ctx, struct gl_buffer_object *obj,                   gl_map_buffer_index index){   struct pipe_context *pipe = st_context(ctx)->pipe;   struct st_buffer_object *st_obj = st_buffer_object(obj);   if (obj->Mappings[index].Length)      pipe_buffer_unmap(pipe, st_obj->transfer[index]);   st_obj->transfer[index] = NULL;   obj->Mappings[index].Pointer = NULL;   obj->Mappings[index].Offset = 0;   obj->Mappings[index].Length = 0;   return GL_TRUE;}

static voidst_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target,                                 GLintptr offset, GLsizeiptr length,                                struct gl_buffer_object *obj){   struct pipe_context *pipe = st_context(ctx)->pipe;   struct st_buffer_object *st_obj = st_buffer_object(obj);   /* Subrange is relative to mapped range */   assert(offset >= 0);   assert(length >= 0);   assert(offset + length <= obj->Length);      pipe_buffer_flush_mapped_range(pipe->screen, st_obj->buffer,                                   obj->Offset + offset, length);}

/** * 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 glBufferDataARB(). */static voidst_bufferobj_data(GLcontext *ctx,		  GLenum target,		  GLsizeiptrARB size,		  const GLvoid * data,		  GLenum usage, 		  struct gl_buffer_object *obj){   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;   st_obj->Base.Size = size;   st_obj->Base.Usage = usage;      switch(target) {   case GL_PIXEL_PACK_BUFFER_ARB:   case GL_PIXEL_UNPACK_BUFFER_ARB:      buffer_usage = PIPE_BUFFER_USAGE_PIXEL;      break;   case GL_ARRAY_BUFFER_ARB:      buffer_usage = PIPE_BUFFER_USAGE_VERTEX;      break;   case GL_ELEMENT_ARRAY_BUFFER_ARB:      buffer_usage = PIPE_BUFFER_USAGE_INDEX;      break;   default:      buffer_usage = 0;   }   pipe_buffer_reference( &st_obj->buffer, NULL );   st_obj->buffer = pipe_buffer_create( pipe->screen, 32, buffer_usage, size );   if (!st_obj->buffer) {      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferDataARB");      return;   }   st_obj->size = size;   if (data)      st_no_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer, 0,				    size, data);}

/* XXX Do we really need the mode? */static voidst_begin_transform_feedback(struct gl_context *ctx, GLenum mode,                            struct gl_transform_feedback_object *obj){   struct st_context *st = st_context(ctx);   struct pipe_context *pipe = st->pipe;   struct st_transform_feedback_object *sobj =         st_transform_feedback_object(obj);   unsigned i, max_num_targets;   max_num_targets = MIN2(Elements(sobj->base.Buffers),                          Elements(sobj->targets));   /* Convert the transform feedback state into the gallium representation. */   for (i = 0; i < max_num_targets; i++) {      struct st_buffer_object *bo = st_buffer_object(sobj->base.Buffers[i]);      if (bo) {         /* Check whether we need to recreate the target. */         if (!sobj->targets[i] ||             sobj->targets[i] == sobj->draw_count ||             sobj->targets[i]->buffer != bo->buffer ||             sobj->targets[i]->buffer_offset != sobj->base.Offset[i] ||             sobj->targets[i]->buffer_size != sobj->base.Size[i]) {            /* Create a new target. */            struct pipe_stream_output_target *so_target =                  pipe->create_stream_output_target(pipe, bo->buffer,                                                    sobj->base.Offset[i],                                                    sobj->base.Size[i]);            pipe_so_target_reference(&sobj->targets[i], NULL);            sobj->targets[i] = so_target;         }         sobj->num_targets = i+1;      } else {         pipe_so_target_reference(&sobj->targets[i], NULL);      }   }   /* Start writing at the beginning of each target. */   cso_set_stream_outputs(st->cso_context, sobj->num_targets, sobj->targets,                          0);}

/** * Called via glInvalidateBuffer(Sub)Data. */static voidst_bufferobj_invalidate(struct gl_context *ctx,                        struct gl_buffer_object *obj,                        GLintptr offset,                        GLsizeiptr size){   struct st_context *st = st_context(ctx);   struct pipe_context *pipe = st->pipe;   struct st_buffer_object *st_obj = st_buffer_object(obj);   /* We ignore partial invalidates. */   if (offset != 0 || size != obj->Size)      return;   /* Nothing to invalidate. */   if (!st_obj->buffer)      return;   pipe->invalidate_resource(pipe, st_obj->buffer);}

static voidst_bufferobj_flush_mapped_range(struct gl_context *ctx,                                GLintptr offset, GLsizeiptr length,                                struct gl_buffer_object *obj){   struct pipe_context *pipe = st_context(ctx)->pipe;   struct st_buffer_object *st_obj = st_buffer_object(obj);   /* Subrange is relative to mapped range */   assert(offset >= 0);   assert(length >= 0);   assert(offset + length <= obj->Length);   assert(obj->Pointer);   if (!length)      return;   pipe_buffer_flush_mapped_range(pipe, st_obj->transfer,                                  obj->Offset + offset, length);}

/** * Replace data in a subrange of buffer object.  If the data range * specified by size + offset extends beyond the end of the buffer or * if data is NULL, no copy is performed. * Called via glBufferSubDataARB(). */static voidst_bufferobj_subdata(struct gl_context *ctx,		     GLintptrARB offset,		     GLsizeiptrARB size,		     const GLvoid * data, struct gl_buffer_object *obj){   struct st_buffer_object *st_obj = st_buffer_object(obj);   /* we may be called from VBO code, so double-check params here */   ASSERT(offset >= 0);   ASSERT(size >= 0);   ASSERT(offset + size <= obj->Size);   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;   if (!st_obj->buffer) {      /* we probably ran out of memory during buffer allocation */      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);}

/** * Called via glMapBufferRange(). */static void *st_bufferobj_map_range(GLcontext *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);   GLuint flags = 0;   char *map;   if (access & GL_MAP_WRITE_BIT)      flags |= PIPE_BUFFER_USAGE_CPU_WRITE;   if (access & GL_MAP_READ_BIT)      flags |= PIPE_BUFFER_USAGE_CPU_READ;   if (access & GL_MAP_FLUSH_EXPLICIT_BIT)      flags |= PIPE_BUFFER_USAGE_FLUSH_EXPLICIT;      /* ... other flags ...    */   if (access & MESA_MAP_NOWAIT_BIT)      flags |= PIPE_BUFFER_USAGE_DONTBLOCK;   assert(offset >= 0);   assert(length >= 0);   assert(offset < obj->Size);   assert(offset + length <= obj->Size);   map = obj->Pointer = pipe_buffer_map_range(pipe->screen, st_obj->buffer, offset, length, flags);   if(obj->Pointer) {      obj->Offset = offset;      obj->Length = length;      map += offset;   }      return map;}

/** * Called via glClearBufferSubData(). */static voidst_clear_buffer_subdata(struct gl_context *ctx,                        GLintptr offset, GLsizeiptr size,                        const GLvoid *clearValue,                        GLsizeiptr clearValueSize,                        struct gl_buffer_object *bufObj){   struct pipe_context *pipe = st_context(ctx)->pipe;   struct st_buffer_object *buf = st_buffer_object(bufObj);   static const char zeros[16] = {0};   if (!pipe->clear_buffer) {      _mesa_buffer_clear_subdata(ctx, offset, size,                                 clearValue, clearValueSize, bufObj);      return;   }   if (!clearValue)      clearValue = zeros;   pipe->clear_buffer(pipe, buf->buffer, offset, size,                      clearValue, clearValueSize);}

static void st_bind_ubos(struct st_context *st, struct gl_program *prog,                         unsigned shader_type){   unsigned i;   struct pipe_constant_buffer cb = { 0 };   if (!prog)      return;   for (i = 0; i < prog->info.num_ubos; i++) {      struct gl_buffer_binding *binding;      struct st_buffer_object *st_obj;      binding =         &st->ctx->UniformBufferBindings[prog->sh.UniformBlocks[i]->Binding];      st_obj = st_buffer_object(binding->BufferObject);      cb.buffer = st_obj->buffer;      if (cb.buffer) {         cb.buffer_offset = binding->Offset;         cb.buffer_size = cb.buffer->width0 - binding->Offset;         /* AutomaticSize is FALSE if the buffer was set with BindBufferRange.          * Take the minimum just to be sure.          */         if (!binding->AutomaticSize)            cb.buffer_size = MIN2(cb.buffer_size, (unsigned) binding->Size);      }      else {         cb.buffer_offset = 0;         cb.buffer_size = 0;      }      cso_set_constant_buffer(st->cso_context, shader_type, 1 + i, &cb);   }}

/** * Called via glGetBufferSubDataARB(). */static voidst_bufferobj_get_subdata(struct gl_context *ctx,                         GLintptrARB offset,                         GLsizeiptrARB size,                         GLvoid * data, struct gl_buffer_object *obj){   struct st_buffer_object *st_obj = st_buffer_object(obj);   /* we may be called from VBO code, so double-check params here */   ASSERT(offset >= 0);   ASSERT(size >= 0);   ASSERT(offset + size <= obj->Size);   if (!size)      return;   if (!st_obj->buffer) {      /* we probably ran out of memory during buffer allocation */      return;   }   pipe_buffer_read(st_context(ctx)->pipe, st_obj->buffer,                    offset, size, data);}

static void st_bind_ubos(struct st_context *st,                           struct gl_shader *shader,                           unsigned shader_type){   unsigned i;   struct pipe_constant_buffer cb = { 0 };   if (!shader)      return;   for (i = 0; i < shader->NumUniformBlocks; i++) {      struct gl_uniform_buffer_binding *binding;      struct st_buffer_object *st_obj;      binding = &st->ctx->UniformBufferBindings[shader->UniformBlocks[i].Binding];      st_obj = st_buffer_object(binding->BufferObject);      pipe_resource_reference(&cb.buffer, st_obj->buffer);      cb.buffer_size = st_obj->buffer->width0 - binding->Offset;      st->pipe->set_constant_buffer(st->pipe, shader_type, 1 + i, &cb);      pipe_resource_reference(&cb.buffer, NULL);   }}

/** * Set up a separate pipe_vertex_buffer and pipe_vertex_element for each * vertex attribute. * /param vbuffer  returns vertex buffer info * /param velements  returns vertex element info */static booleansetup_non_interleaved_attribs(struct st_context *st,                              const struct st_vertex_program *vp,                              const struct st_vp_variant *vpv,                              const struct gl_client_array **arrays,                              struct pipe_vertex_buffer vbuffer[],                              struct pipe_vertex_element velements[]){   struct gl_context *ctx = st->ctx;   GLuint attr;   for (attr = 0; attr < vpv->num_inputs; attr++) {      const GLuint mesaAttr = vp->index_to_input[attr];      const struct gl_client_array *array = arrays[mesaAttr];      struct gl_buffer_object *bufobj = array->BufferObj;      GLsizei stride = array->StrideB;      assert(array->_ElementSize ==             _mesa_bytes_per_vertex_attrib(array->Size, array->Type));      if (_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.          */         struct st_buffer_object *stobj = st_buffer_object(bufobj);         if (!stobj || !stobj->buffer) {            return FALSE; /* out-of-memory error probably */         }         vbuffer[attr].buffer = stobj->buffer;         vbuffer[attr].user_buffer = NULL;         vbuffer[attr].buffer_offset = pointer_to_offset(array->Ptr);      }      else {         /* wrap user data */         void *ptr;         if (array->Ptr) {            ptr = (void *) array->Ptr;         }         else {            /* no array, use ctx->Current.Attrib[] value */            ptr = (void *) ctx->Current.Attrib[mesaAttr];            stride = 0;         }         assert(ptr);         vbuffer[attr].buffer = NULL;         vbuffer[attr].user_buffer = ptr;         vbuffer[attr].buffer_offset = 0;      }      /* common-case setup */      vbuffer[attr].stride = stride; /* in bytes */      velements[attr].src_offset = 0;      velements[attr].instance_divisor = array->InstanceDivisor;      velements[attr].vertex_buffer_index = attr;      velements[attr].src_format = st_pipe_vertex_format(array->Type,                                                         array->Size,                                                         array->Format,                                                         array->Normalized,                                                         array->Integer);      assert(velements[attr].src_format);   }   return TRUE;}

/** * Set up for drawing interleaved arrays that all live in one VBO * or all live in user space. * /param vbuffer  returns vertex buffer info * /param velements  returns vertex element info */static booleansetup_interleaved_attribs(const struct st_vertex_program *vp,                          const struct st_vp_variant *vpv,                          const struct gl_client_array **arrays,                          struct pipe_vertex_buffer *vbuffer,                          struct pipe_vertex_element velements[]){   GLuint attr;   const GLubyte *low_addr = NULL;   GLboolean usingVBO;      /* all arrays in a VBO? */   struct gl_buffer_object *bufobj;   GLsizei stride;   /* Find the lowest address of the arrays we're drawing,    * Init bufobj and stride.    */   if (vpv->num_inputs) {      const GLuint mesaAttr0 = vp->index_to_input[0];      const struct gl_client_array *array = arrays[mesaAttr0];      /* Since we're doing interleaved arrays, we know there'll be at most       * one buffer object and the stride will be the same for all arrays.       * Grab them now.       */      bufobj = array->BufferObj;      stride = array->StrideB;      low_addr = arrays[vp->index_to_input[0]]->Ptr;      for (attr = 1; attr < vpv->num_inputs; attr++) {         const GLubyte *start = arrays[vp->index_to_input[attr]]->Ptr;         low_addr = MIN2(low_addr, start);      }   }   else {      /* not sure we'll ever have zero inputs, but play it safe */      bufobj = NULL;      stride = 0;      low_addr = 0;   }   /* are the arrays in user space? */   usingVBO = _mesa_is_bufferobj(bufobj);   for (attr = 0; attr < vpv->num_inputs; attr++) {      const GLuint mesaAttr = vp->index_to_input[attr];      const struct gl_client_array *array = arrays[mesaAttr];      unsigned src_offset = (unsigned) (array->Ptr - low_addr);      assert(array->_ElementSize ==             _mesa_bytes_per_vertex_attrib(array->Size, array->Type));      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,                                                         array->Size,                                                         array->Format,                                                         array->Normalized,                                                         array->Integer);      assert(velements[attr].src_format);   }   /*    * Return the vbuffer info and setup user-space attrib info, if needed.    */   if (vpv->num_inputs == 0) {      /* just defensive coding here */      vbuffer->buffer = NULL;      vbuffer->user_buffer = NULL;      vbuffer->buffer_offset = 0;      vbuffer->stride = 0;   }   else if (usingVBO) {      /* all interleaved arrays in a VBO */      struct st_buffer_object *stobj = st_buffer_object(bufobj);      if (!stobj || !stobj->buffer) {         return FALSE; /* out-of-memory error probably */      }      vbuffer->buffer = stobj->buffer;      vbuffer->user_buffer = NULL;      vbuffer->buffer_offset = pointer_to_offset(low_addr);      vbuffer->stride = stride;   }   else {      /* all interleaved arrays in user memory */      vbuffer->buffer = NULL;      vbuffer->user_buffer = low_addr;      vbuffer->buffer_offset = 0;      vbuffer->stride = stride;   }   return TRUE;//.........这里部分代码省略.........