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

/** * Clear the given buffers to the specified values. * No masking, no scissor (clear entire buffer). */voidsoftpipe_clear(struct pipe_context *pipe, unsigned buffers,               const union pipe_color_union *color,               double depth, unsigned stencil){   struct softpipe_context *softpipe = softpipe_context(pipe);   uint64_t cv;   uint i;   if (softpipe->no_rast)      return;   if (!softpipe_check_render_cond(softpipe))      return;#if 0   softpipe_update_derived(softpipe, PIPE_PRIM_TRIANGLES); /* not needed?? */#endif   if (buffers & PIPE_CLEAR_COLOR) {      for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++) {         sp_tile_cache_clear(softpipe->cbuf_cache[i], color, 0);      }   }   if (buffers & PIPE_CLEAR_DEPTHSTENCIL) {      static const union pipe_color_union zero;      struct pipe_surface *ps = softpipe->framebuffer.zsbuf;      cv = util_pack64_z_stencil(ps->format, depth, stencil);      sp_tile_cache_clear(softpipe->zsbuf_cache, &zero, cv);   }   softpipe->dirty_render_cache = TRUE;}

voidsoftpipe_set_vertex_sampler_textures(struct pipe_context *pipe,                                     unsigned num_textures,                                     struct pipe_texture **textures){   struct softpipe_context *softpipe = softpipe_context(pipe);   uint i;   assert(num_textures <= PIPE_MAX_VERTEX_SAMPLERS);   /* Check for no-op */   if (num_textures == softpipe->num_vertex_textures &&       !memcmp(softpipe->vertex_textures, textures, num_textures * sizeof(struct pipe_texture *))) {      return;   }   draw_flush(softpipe->draw);   for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {      struct pipe_texture *tex = i < num_textures ? textures[i] : NULL;      pipe_texture_reference(&softpipe->vertex_textures[i], tex);      sp_tex_tile_cache_set_texture(softpipe->vertex_tex_cache[i], tex);   }   softpipe->num_vertex_textures = num_textures;   softpipe->dirty |= SP_NEW_TEXTURE;}

voidsoftpipe_bind_vertex_sampler_states(struct pipe_context *pipe,                                    unsigned num_samplers,                                    void **samplers){   struct softpipe_context *softpipe = softpipe_context(pipe);   unsigned i;   assert(num_samplers <= PIPE_MAX_VERTEX_SAMPLERS);   /* Check for no-op */   if (num_samplers == softpipe->num_vertex_samplers &&       !memcmp(softpipe->vertex_samplers, samplers, num_samplers * sizeof(void *)))      return;   draw_flush(softpipe->draw);   for (i = 0; i < num_samplers; ++i)      softpipe->vertex_samplers[i] = samplers[i];   for (i = num_samplers; i < PIPE_MAX_VERTEX_SAMPLERS; ++i)      softpipe->vertex_samplers[i] = NULL;   softpipe->num_vertex_samplers = num_samplers;   softpipe->dirty |= SP_NEW_SAMPLER;}

static voidsoftpipe_destroy( struct pipe_context *pipe ){   struct softpipe_context *softpipe = softpipe_context( pipe );   uint i, sh;#if DO_PSTIPPLE_IN_HELPER_MODULE   if (softpipe->pstipple.sampler)      pipe->delete_sampler_state(pipe, softpipe->pstipple.sampler);   pipe_resource_reference(&softpipe->pstipple.texture, NULL);   pipe_sampler_view_reference(&softpipe->pstipple.sampler_view, NULL);#endif   if (softpipe->draw)      draw_destroy( softpipe->draw );   if (softpipe->quad.shade)      softpipe->quad.shade->destroy( softpipe->quad.shade );   if (softpipe->quad.depth_test)      softpipe->quad.depth_test->destroy( softpipe->quad.depth_test );   if (softpipe->quad.blend)      softpipe->quad.blend->destroy( softpipe->quad.blend );   if (softpipe->quad.pstipple)      softpipe->quad.pstipple->destroy( softpipe->quad.pstipple );   for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {      sp_destroy_tile_cache(softpipe->cbuf_cache[i]);      pipe_surface_reference(&softpipe->framebuffer.cbufs[i], NULL);   }   sp_destroy_tile_cache(softpipe->zsbuf_cache);   pipe_surface_reference(&softpipe->framebuffer.zsbuf, NULL);   for (sh = 0; sh < Elements(softpipe->tex_cache); sh++) {      for (i = 0; i < Elements(softpipe->tex_cache[0]); i++) {         sp_destroy_tex_tile_cache(softpipe->tex_cache[sh][i]);         pipe_sampler_view_reference(&softpipe->sampler_views[sh][i], NULL);      }   }   for (sh = 0; sh < Elements(softpipe->constants); sh++) {      for (i = 0; i < Elements(softpipe->constants[0]); i++) {         if (softpipe->constants[sh][i]) {            pipe_resource_reference(&softpipe->constants[sh][i], NULL);         }      }   }   for (i = 0; i < softpipe->num_vertex_buffers; i++) {      pipe_resource_reference(&softpipe->vertex_buffer[i].buffer, NULL);   }   tgsi_exec_machine_destroy(softpipe->fs_machine);   FREE( softpipe );}

static voidsoftpipe_begin_query(struct pipe_context *pipe, struct pipe_query *q){   struct softpipe_context *softpipe = softpipe_context( pipe );   struct softpipe_query *sq = softpipe_query(q);   switch (sq->type) {   case PIPE_QUERY_OCCLUSION_COUNTER:      sq->start = softpipe->occlusion_count;      break;   case PIPE_QUERY_TIMESTAMP_DISJOINT:   case PIPE_QUERY_TIME_ELAPSED:      sq->start = 1000*os_time_get();      break;   case PIPE_QUERY_SO_STATISTICS:      sq->so.primitives_storage_needed = 0;   case PIPE_QUERY_PRIMITIVES_EMITTED:      sq->so.num_primitives_written = 0;      softpipe->so_stats.num_primitives_written = 0;      break;   case PIPE_QUERY_PRIMITIVES_GENERATED:      sq->num_primitives_generated = 0;      softpipe->num_primitives_generated = 0;      break;   case PIPE_QUERY_TIMESTAMP:   case PIPE_QUERY_GPU_FINISHED:      break;   default:      assert(0);      break;   }   softpipe->active_query_count++;   softpipe->dirty |= SP_NEW_QUERY;}

static voidsoftpipe_end_query(struct pipe_context *pipe, struct pipe_query *q){   struct softpipe_context *softpipe = softpipe_context( pipe );   struct softpipe_query *sq = softpipe_query(q);   sq->end = softpipe->occlusion_count;}

void softpipe_set_clip_state( struct pipe_context *pipe,			     const struct pipe_clip_state *clip ){   struct softpipe_context *softpipe = softpipe_context(pipe);   /* pass the clip state to the draw module */   draw_set_clip_state(softpipe->draw, clip);}

voidsoftpipe_set_sampler_views(struct pipe_context *pipe,                           unsigned shader,                           unsigned start,                           unsigned num,                           struct pipe_sampler_view **views){   struct softpipe_context *softpipe = softpipe_context(pipe);   uint i;   assert(shader < PIPE_SHADER_TYPES);   assert(start + num <= ARRAY_SIZE(softpipe->sampler_views[shader]));   draw_flush(softpipe->draw);   /* set the new sampler views */   for (i = 0; i < num; i++) {      struct sp_sampler_view *sp_sviewsrc;      struct sp_sampler_view *sp_sviewdst =         &softpipe->tgsi.sampler[shader]->sp_sview[start + i];      struct pipe_sampler_view **pview = &softpipe->sampler_views[shader][start + i];      pipe_sampler_view_reference(pview, views[i]);      sp_tex_tile_cache_set_sampler_view(softpipe->tex_cache[shader][start + i],                                         views[i]);      /*       * We don't really have variants, however some bits are different per shader,       * so just copy?       */      sp_sviewsrc = (struct sp_sampler_view *)*pview;      if (sp_sviewsrc) {         memcpy(sp_sviewdst, sp_sviewsrc, sizeof(*sp_sviewsrc));         sp_sviewdst->compute_lambda = softpipe_get_lambda_func(&sp_sviewdst->base, shader);         sp_sviewdst->cache = softpipe->tex_cache[shader][start + i];      }      else {         memset(sp_sviewdst, 0,  sizeof(*sp_sviewsrc));      }   }   /* find highest non-null sampler_views[] entry */   {      unsigned j = MAX2(softpipe->num_sampler_views[shader], start + num);      while (j > 0 && softpipe->sampler_views[shader][j - 1] == NULL)         j--;      softpipe->num_sampler_views[shader] = j;   }   if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) {      draw_set_sampler_views(softpipe->draw,                             shader,                             softpipe->sampler_views[shader],                             softpipe->num_sampler_views[shader]);   }   softpipe->dirty |= SP_NEW_TEXTURE;}

void softpipe_set_stencil_ref( struct pipe_context *pipe,                               const struct pipe_stencil_ref *stencil_ref ){   struct softpipe_context *softpipe = softpipe_context(pipe);   softpipe->stencil_ref = *stencil_ref;   softpipe->dirty |= SP_NEW_DEPTH_STENCIL_ALPHA;}

void softpipe_set_blend_color( struct pipe_context *pipe,                               const struct pipe_blend_color *blend_color ){    struct softpipe_context *softpipe = softpipe_context(pipe);    softpipe->blend_color = *blend_color;    softpipe->dirty |= SP_NEW_BLEND;}

void softpipe_bind_blend_state( struct pipe_context *pipe,                                void *blend ){    struct softpipe_context *softpipe = softpipe_context(pipe);    softpipe->blend = (const struct pipe_blend_state *)blend;    softpipe->dirty |= SP_NEW_BLEND;}

voidsoftpipe_bind_depth_stencil_state(struct pipe_context *pipe,                                  void *depth_stencil){   struct softpipe_context *softpipe = softpipe_context(pipe);   softpipe->depth_stencil = (struct pipe_depth_stencil_alpha_state *)depth_stencil;   softpipe->dirty |= SP_NEW_DEPTH_STENCIL_ALPHA;}

static voidsoftpipe_render_condition( struct pipe_context *pipe,                           struct pipe_query *query,                           uint mode ){   struct softpipe_context *softpipe = softpipe_context( pipe );   softpipe->render_cond_query = query;   softpipe->render_cond_mode = mode;}

void softpipe_set_polygon_stipple( struct pipe_context *pipe,                                   const struct pipe_poly_stipple *stipple ){   struct softpipe_context *softpipe = softpipe_context(pipe);   draw_flush(softpipe->draw);   softpipe->poly_stipple = *stipple; /* struct copy */   softpipe->dirty |= SP_NEW_STIPPLE;}

void softpipe_set_scissor_state( struct pipe_context *pipe,                                 const struct pipe_scissor_state *scissor ){   struct softpipe_context *softpipe = softpipe_context(pipe);   draw_flush(softpipe->draw);   softpipe->scissor = *scissor; /* struct copy */   softpipe->dirty |= SP_NEW_SCISSOR;}

/** * XXX this might get moved someday * Set the framebuffer surface info: color buffers, zbuffer, stencil buffer. * Here, we flush the old surfaces and update the tile cache to point to the new * surfaces. */voidsoftpipe_set_framebuffer_state(struct pipe_context *pipe,                               const struct pipe_framebuffer_state *fb){   struct softpipe_context *sp = softpipe_context(pipe);   uint i;   draw_flush(sp->draw);   for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {      struct pipe_surface *cb = i < fb->nr_cbufs ? fb->cbufs[i] : NULL;      /* check if changing cbuf */      if (sp->framebuffer.cbufs[i] != cb) {         /* flush old */         sp_flush_tile_cache(sp->cbuf_cache[i]);         /* assign new */         pipe_surface_reference(&sp->framebuffer.cbufs[i], cb);         /* update cache */         sp_tile_cache_set_surface(sp->cbuf_cache[i], cb);      }   }   sp->framebuffer.nr_cbufs = fb->nr_cbufs;   /* zbuf changing? */   if (sp->framebuffer.zsbuf != fb->zsbuf) {      /* flush old */      sp_flush_tile_cache(sp->zsbuf_cache);      /* assign new */      pipe_surface_reference(&sp->framebuffer.zsbuf, fb->zsbuf);      /* update cache */      sp_tile_cache_set_surface(sp->zsbuf_cache, fb->zsbuf);      /* Tell draw module how deep the Z/depth buffer is       *       * If no depth buffer is bound, send the utility function the       * format for no bound depth (PIPE_FORMAT_NONE).       */      draw_set_zs_format(sp->draw,                         (sp->framebuffer.zsbuf) ?                            sp->framebuffer.zsbuf->format : PIPE_FORMAT_NONE);   }   sp->framebuffer.width = fb->width;   sp->framebuffer.height = fb->height;   sp->framebuffer.samples = fb->samples;   sp->framebuffer.layers = fb->layers;   sp->dirty |= SP_NEW_FRAMEBUFFER;}

void softpipe_set_viewport_state( struct pipe_context *pipe,                                  const struct pipe_viewport_state *viewport ){   struct softpipe_context *softpipe = softpipe_context(pipe);   /* pass the viewport info to the draw module */   draw_set_viewport_state(softpipe->draw, viewport);   softpipe->viewport = *viewport; /* struct copy */   softpipe->dirty |= SP_NEW_VIEWPORT;}

static voidsoftpipe_set_index_buffer(struct pipe_context *pipe,                          const struct pipe_index_buffer *ib){   struct softpipe_context *softpipe = softpipe_context(pipe);   if (ib)      memcpy(&softpipe->index_buffer, ib, sizeof(softpipe->index_buffer));   else      memset(&softpipe->index_buffer, 0, sizeof(softpipe->index_buffer));}

static void sp_blit(struct pipe_context *pipe,                    const struct pipe_blit_info *info){   struct softpipe_context *sp = softpipe_context(pipe);   if (info->render_condition_enable && !softpipe_check_render_cond(sp))      return;   if (info->src.resource->nr_samples > 1 &&       info->dst.resource->nr_samples <= 1 &&       !util_format_is_depth_or_stencil(info->src.resource->format) &&       !util_format_is_pure_integer(info->src.resource->format)) {      debug_printf("softpipe: color resolve unimplemented/n");      return;   }   if (util_try_blit_via_copy_region(pipe, info)) {      return; /* done */   }   if (!util_blitter_is_blit_supported(sp->blitter, info)) {      debug_printf("softpipe: blit unsupported %s -> %s/n",                   util_format_short_name(info->src.resource->format),                   util_format_short_name(info->dst.resource->format));      return;   }   /* XXX turn off occlusion and streamout queries */   util_blitter_save_vertex_buffer_slot(sp->blitter, sp->vertex_buffer);   util_blitter_save_vertex_elements(sp->blitter, sp->velems);   util_blitter_save_vertex_shader(sp->blitter, sp->vs);   util_blitter_save_geometry_shader(sp->blitter, sp->gs);   util_blitter_save_so_targets(sp->blitter, sp->num_so_targets,                     (struct pipe_stream_output_target**)sp->so_targets);   util_blitter_save_rasterizer(sp->blitter, sp->rasterizer);   util_blitter_save_viewport(sp->blitter, &sp->viewports[0]);   util_blitter_save_scissor(sp->blitter, &sp->scissors[0]);   util_blitter_save_fragment_shader(sp->blitter, sp->fs);   util_blitter_save_blend(sp->blitter, sp->blend);   util_blitter_save_depth_stencil_alpha(sp->blitter, sp->depth_stencil);   util_blitter_save_stencil_ref(sp->blitter, &sp->stencil_ref);   /*util_blitter_save_sample_mask(sp->blitter, sp->sample_mask);*/   util_blitter_save_framebuffer(sp->blitter, &sp->framebuffer);   util_blitter_save_fragment_sampler_states(sp->blitter,                     sp->num_samplers[PIPE_SHADER_FRAGMENT],                     (void**)sp->samplers[PIPE_SHADER_FRAGMENT]);   util_blitter_save_fragment_sampler_views(sp->blitter,                     sp->num_sampler_views[PIPE_SHADER_FRAGMENT],                     sp->sampler_views[PIPE_SHADER_FRAGMENT]);   util_blitter_save_render_condition(sp->blitter, sp->render_cond_query,                                      sp->render_cond_cond, sp->render_cond_mode);   util_blitter_blit(sp->blitter, info);}

void softpipe_bind_rasterizer_state(struct pipe_context *pipe,                                    void *setup){   struct softpipe_context *softpipe = softpipe_context(pipe);   /* pass-through to draw module */   draw_set_rasterizer_state(softpipe->draw, setup);   softpipe->rasterizer = (struct pipe_rasterizer_state *)setup;   softpipe->dirty |= SP_NEW_RASTERIZER;}

static voidsoftpipe_bind_blend_state(struct pipe_context *pipe,                          void *blend){   struct softpipe_context *softpipe = softpipe_context(pipe);   draw_flush(softpipe->draw);   softpipe->blend = (struct pipe_blend_state *)blend;   softpipe->dirty |= SP_NEW_BLEND;}

voidsoftpipe_flush( struct pipe_context *pipe,                unsigned flags,                struct pipe_fence_handle **fence ){   struct softpipe_context *softpipe = softpipe_context(pipe);   uint i;   draw_flush(softpipe->draw);   if (flags & SP_FLUSH_TEXTURE_CACHE) {      unsigned sh;      for (sh = 0; sh < Elements(softpipe->tex_cache); sh++) {         for (i = 0; i < softpipe->num_sampler_views[sh]; i++) {            sp_flush_tex_tile_cache(softpipe->tex_cache[sh][i]);         }      }   }   /* If this is a swapbuffers, just flush color buffers.    *    * The zbuffer changes are not discarded, but held in the cache    * in the hope that a later clear will wipe them out.    */   for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++)      if (softpipe->cbuf_cache[i])         sp_flush_tile_cache(softpipe->cbuf_cache[i]);   if (softpipe->zsbuf_cache)      sp_flush_tile_cache(softpipe->zsbuf_cache);   softpipe->dirty_render_cache = FALSE;   /* Enable to dump BMPs of the color/depth buffers each frame */#if 0   if (flags & PIPE_FLUSH_END_OF_FRAME) {      static unsigned frame_no = 1;      static char filename[256];      util_snprintf(filename, sizeof(filename), "cbuf_%u.bmp", frame_no);      debug_dump_surface_bmp(pipe, filename, softpipe->framebuffer.cbufs[0]);      util_snprintf(filename, sizeof(filename), "zsbuf_%u.bmp", frame_no);      debug_dump_surface_bmp(pipe, filename, softpipe->framebuffer.zsbuf);      ++frame_no;   }#endif   if (fence)      *fence = (void*)(intptr_t)1;}

static voidsoftpipe_bind_vertex_elements_state(struct pipe_context *pipe,                                    void *velems){   struct softpipe_context *softpipe = softpipe_context(pipe);   struct sp_velems_state *sp_velems = (struct sp_velems_state *) velems;   softpipe->velems = sp_velems;   softpipe->dirty |= SP_NEW_VERTEX;   if (sp_velems)      draw_set_vertex_elements(softpipe->draw, sp_velems->count, sp_velems->velem);}

static booleansoftpipe_begin_query(struct pipe_context *pipe, struct pipe_query *q){   struct softpipe_context *softpipe = softpipe_context( pipe );   struct softpipe_query *sq = softpipe_query(q);   switch (sq->type) {   case PIPE_QUERY_OCCLUSION_COUNTER:   case PIPE_QUERY_OCCLUSION_PREDICATE:      sq->start = softpipe->occlusion_count;      break;   case PIPE_QUERY_TIME_ELAPSED:      sq->start = os_time_get_nano();      break;   case PIPE_QUERY_SO_STATISTICS:      sq->so.num_primitives_written = softpipe->so_stats.num_primitives_written;      sq->so.primitives_storage_needed = softpipe->so_stats.primitives_storage_needed;      break;   case PIPE_QUERY_SO_OVERFLOW_PREDICATE:      sq->end = FALSE;      break;   case PIPE_QUERY_PRIMITIVES_EMITTED:      sq->so.num_primitives_written = softpipe->so_stats.num_primitives_written;      break;   case PIPE_QUERY_PRIMITIVES_GENERATED:      sq->so.primitives_storage_needed = softpipe->so_stats.primitives_storage_needed;      break;   case PIPE_QUERY_TIMESTAMP:   case PIPE_QUERY_GPU_FINISHED:   case PIPE_QUERY_TIMESTAMP_DISJOINT:      break;   case PIPE_QUERY_PIPELINE_STATISTICS:      /* reset our cache */      if (softpipe->active_statistics_queries == 0) {         memset(&softpipe->pipeline_statistics, 0,                sizeof(softpipe->pipeline_statistics));      }      memcpy(&sq->stats, &softpipe->pipeline_statistics,             sizeof(sq->stats));      softpipe->active_statistics_queries++;      break;   default:      assert(0);      break;   }   softpipe->active_query_count++;   softpipe->dirty |= SP_NEW_QUERY;   return true;}

void softpipe_bind_rasterizer_state(struct pipe_context *pipe,                                    void *rasterizer){   struct softpipe_context *softpipe = softpipe_context(pipe);   if (softpipe->rasterizer == rasterizer)      return;   /* pass-through to draw module */   draw_set_rasterizer_state(softpipe->draw, rasterizer);   softpipe->rasterizer = rasterizer;   softpipe->dirty |= SP_NEW_RASTERIZER;}

static voidsoftpipe_clear_render_target(struct pipe_context *pipe,                             struct pipe_surface *dst,                             const union pipe_color_union *color,                             unsigned dstx, unsigned dsty,                             unsigned width, unsigned height){   struct softpipe_context *softpipe = softpipe_context(pipe);   if (!softpipe_check_render_cond(softpipe))      return;   util_clear_render_target(pipe, dst, color,                            dstx, dsty, width, height);}

static voidsoftpipe_set_viewport_states(struct pipe_context *pipe,                             unsigned start_slot,                             unsigned num_viewports,                             const struct pipe_viewport_state *viewports){   struct softpipe_context *softpipe = softpipe_context(pipe);   /* pass the viewport info to the draw module */   draw_set_viewport_states(softpipe->draw, start_slot, num_viewports,                            viewports);   memcpy(softpipe->viewports + start_slot, viewports,          sizeof(struct pipe_viewport_state) * num_viewports);   softpipe->dirty |= SP_NEW_VIEWPORT;}

voidsoftpipe_set_vertex_buffers(struct pipe_context *pipe,                            unsigned count,                            const struct pipe_vertex_buffer *buffers){   struct softpipe_context *softpipe = softpipe_context(pipe);   assert(count <= PIPE_MAX_ATTRIBS);   memcpy(softpipe->vertex_buffer, buffers, count * sizeof(buffers[0]));   softpipe->num_vertex_buffers = count;   softpipe->dirty |= SP_NEW_VERTEX;   draw_set_vertex_buffers(softpipe->draw, count, buffers);}

static voidsoftpipe_set_sampler_views(struct pipe_context *pipe,                           unsigned shader,                           unsigned start,                           unsigned num,                           struct pipe_sampler_view **views){    struct softpipe_context *softpipe = softpipe_context(pipe);    uint i;    assert(shader < PIPE_SHADER_TYPES);    assert(start + num <= Elements(softpipe->sampler_views[shader]));    /* Check for no-op */    if (start + num <= softpipe->num_sampler_views[shader] &&            !memcmp(softpipe->sampler_views[shader] + start, views,                    num * sizeof(struct pipe_sampler_view *))) {        return;    }    draw_flush(softpipe->draw);    /* set the new sampler views */    for (i = 0; i < num; i++) {        pipe_sampler_view_reference(&softpipe->sampler_views[shader][start + i],                                    views[i]);        sp_tex_tile_cache_set_sampler_view(softpipe->tex_cache[shader][start + i],                                           views[i]);    }    /* find highest non-null sampler_views[] entry */    {        unsigned j = MAX2(softpipe->num_sampler_views[shader], start + num);        while (j > 0 && softpipe->sampler_views[shader][j - 1] == NULL)            j--;        softpipe->num_sampler_views[shader] = j;    }    if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) {        draw_set_sampler_views(softpipe->draw,                               shader,                               softpipe->sampler_views[shader],                               softpipe->num_sampler_views[shader]);    }    softpipe->dirty |= SP_NEW_TEXTURE;}

static voidsoftpipe_set_vertex_buffers(struct pipe_context *pipe,                            unsigned count,                            const struct pipe_vertex_buffer *buffers){   struct softpipe_context *softpipe = softpipe_context(pipe);   assert(count <= PIPE_MAX_ATTRIBS);   util_copy_vertex_buffers(softpipe->vertex_buffer,                            &softpipe->num_vertex_buffers,                            buffers, count);   softpipe->dirty |= SP_NEW_VERTEX;   draw_set_vertex_buffers(softpipe->draw, count, buffers);}