X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fllvmpipe%2Flp_draw_arrays.c;h=edfb2040969b04bc331e04db21041361a9b0326f;hb=dd4802c8deedc0b2bad7d361c487761be31f2b56;hp=91d99db01717f58c1eff40fa52b43760538299a9;hpb=99c8d9b6dac55263b3f0ddce939173ec9a16cf80;p=mesa.git diff --git a/src/gallium/drivers/llvmpipe/lp_draw_arrays.c b/src/gallium/drivers/llvmpipe/lp_draw_arrays.c index 91d99db0171..edfb2040969 100644 --- a/src/gallium/drivers/llvmpipe/lp_draw_arrays.c +++ b/src/gallium/drivers/llvmpipe/lp_draw_arrays.c @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2007 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -18,7 +18,7 @@ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. @@ -33,33 +33,39 @@ #include "pipe/p_defines.h" #include "pipe/p_context.h" +#include "util/u_draw.h" #include "util/u_prim.h" #include "lp_context.h" #include "lp_state.h" +#include "lp_query.h" #include "draw/draw_context.h" /** - * Draw vertex arrays, with optional indexing. + * Draw vertex arrays, with optional indexing, optional instancing. + * All the other drawing functions are implemented in terms of this function. * Basically, map the vertex buffers (and drawing surfaces), then hand off * the drawing to the 'draw' module. */ static void -llvmpipe_draw_range_elements(struct pipe_context *pipe, - struct pipe_resource *indexBuffer, - unsigned indexSize, - int indexBias, - unsigned min_index, - unsigned max_index, - unsigned mode, unsigned start, unsigned count) +llvmpipe_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info) { struct llvmpipe_context *lp = llvmpipe_context(pipe); struct draw_context *draw = lp->draw; + const void *mapped_indices = NULL; unsigned i; + if (!llvmpipe_check_render_cond(lp)) + return; + + if (info->indirect) { + util_draw_indirect(pipe, info); + return; + } + if (lp->dirty) llvmpipe_update_derived( lp ); @@ -67,40 +73,85 @@ llvmpipe_draw_range_elements(struct pipe_context *pipe, * Map vertex buffers */ for (i = 0; i < lp->num_vertex_buffers; i++) { - void *buf = llvmpipe_resource_data(lp->vertex_buffer[i].buffer); - draw_set_mapped_vertex_buffer(draw, i, buf); + const void *buf = lp->vertex_buffer[i].user_buffer; + size_t size = ~0; + if (!buf) { + if (!lp->vertex_buffer[i].buffer) { + continue; + } + buf = llvmpipe_resource_data(lp->vertex_buffer[i].buffer); + size = lp->vertex_buffer[i].buffer->width0; + } + draw_set_mapped_vertex_buffer(draw, i, buf, size); } /* Map index buffer, if present */ - if (indexBuffer) { - void *mapped_indexes = llvmpipe_resource_data(indexBuffer); - draw_set_mapped_element_buffer_range(draw, indexSize, indexBias, - min_index, - max_index, - mapped_indexes); + if (info->indexed) { + unsigned available_space = ~0; + mapped_indices = lp->index_buffer.user_buffer; + if (!mapped_indices) { + mapped_indices = llvmpipe_resource_data(lp->index_buffer.buffer); + if (lp->index_buffer.buffer->width0 > lp->index_buffer.offset) + available_space = + (lp->index_buffer.buffer->width0 - lp->index_buffer.offset); + else + available_space = 0; + } + draw_set_indexes(draw, + (ubyte *) mapped_indices + lp->index_buffer.offset, + lp->index_buffer.index_size, available_space); } - else { - /* no index/element buffer */ - draw_set_mapped_element_buffer_range(draw, 0, 0, start, - start + count - 1, NULL); + + for (i = 0; i < lp->num_so_targets; i++) { + void *buf = 0; + if (lp->so_targets[i]) { + buf = llvmpipe_resource(lp->so_targets[i]->target.buffer)->data; + lp->so_targets[i]->mapping = buf; + } } + draw_set_mapped_so_targets(draw, lp->num_so_targets, + lp->so_targets); + llvmpipe_prepare_vertex_sampling(lp, - lp->num_vertex_sampler_views, - lp->vertex_sampler_views); + lp->num_sampler_views[PIPE_SHADER_VERTEX], + lp->sampler_views[PIPE_SHADER_VERTEX]); + llvmpipe_prepare_geometry_sampling(lp, + lp->num_sampler_views[PIPE_SHADER_GEOMETRY], + lp->sampler_views[PIPE_SHADER_GEOMETRY]); + if (lp->gs && lp->gs->no_tokens) { + /* we have an empty geometry shader with stream output, so + attach the stream output info to the current vertex shader */ + if (lp->vs) { + draw_vs_attach_so(lp->vs, &lp->gs->stream_output); + } + } + draw_collect_pipeline_statistics(draw, + lp->active_statistics_queries > 0); /* draw! */ - draw_arrays(draw, mode, start, count); + draw_vbo(draw, info); /* * unmap vertex/index buffers */ for (i = 0; i < lp->num_vertex_buffers; i++) { - draw_set_mapped_vertex_buffer(draw, i, NULL); + draw_set_mapped_vertex_buffer(draw, i, NULL, 0); + } + if (mapped_indices) { + draw_set_indexes(draw, NULL, 0, 0); } - if (indexBuffer) { - draw_set_mapped_element_buffer(draw, 0, 0, NULL); + draw_set_mapped_so_targets(draw, 0, NULL); + + if (lp->gs && lp->gs->no_tokens) { + /* we have attached stream output to the vs for rendering, + now lets reset it */ + if (lp->vs) { + draw_vs_reset_so(lp->vs); + } } + llvmpipe_cleanup_vertex_sampling(lp); + llvmpipe_cleanup_geometry_sampling(lp); /* * TODO: Flush only when a user vertex/index buffer is present @@ -111,32 +162,8 @@ llvmpipe_draw_range_elements(struct pipe_context *pipe, } -static void -llvmpipe_draw_elements(struct pipe_context *pipe, - struct pipe_resource *indexBuffer, - unsigned indexSize, - int indexBias, - unsigned mode, unsigned start, unsigned count) -{ - llvmpipe_draw_range_elements( pipe, indexBuffer, - indexSize, indexBias, - 0, 0xffffffff, - mode, start, count ); -} - - -static void -llvmpipe_draw_arrays(struct pipe_context *pipe, unsigned mode, - unsigned start, unsigned count) -{ - llvmpipe_draw_elements(pipe, NULL, 0, 0, mode, start, count); -} - - void llvmpipe_init_draw_funcs(struct llvmpipe_context *llvmpipe) { - llvmpipe->pipe.draw_arrays = llvmpipe_draw_arrays; - llvmpipe->pipe.draw_elements = llvmpipe_draw_elements; - llvmpipe->pipe.draw_range_elements = llvmpipe_draw_range_elements; + llvmpipe->pipe.draw_vbo = llvmpipe_draw_vbo; }