X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsoftpipe%2Fsp_draw_arrays.c;h=6363701cf92ae36fe9853bf9bc75cc6565683ee9;hb=330d0607ed60fd3edca192e54b4246310f06652f;hp=461c9a6c4d49aafd62961520b52dcc6e11314fc4;hpb=35489ef285f1fde234b2b9bbb91fdc41fddefc02;p=mesa.git diff --git a/src/gallium/drivers/softpipe/sp_draw_arrays.c b/src/gallium/drivers/softpipe/sp_draw_arrays.c index 461c9a6c4d4..6363701cf92 100644 --- a/src/gallium/drivers/softpipe/sp_draw_arrays.c +++ b/src/gallium/drivers/softpipe/sp_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. @@ -34,195 +34,128 @@ #include "pipe/p_defines.h" #include "pipe/p_context.h" #include "util/u_inlines.h" +#include "util/u_draw.h" #include "util/u_prim.h" #include "sp_context.h" #include "sp_query.h" #include "sp_state.h" #include "sp_texture.h" +#include "sp_screen.h" #include "draw/draw_context.h" - - - - - /** - * Draw vertex arrays, with optional indexing. - * Basically, map the vertex buffers (and drawing surfaces), then hand off - * the drawing to the 'draw' module. + * This function handles drawing indexed and non-indexed prims, + * instanced and non-instanced drawing, with or without min/max element + * indexes. + * All the other drawing functions are expressed in terms of this + * function. + * + * For non-indexed prims, indexBuffer should be NULL. + * For non-instanced drawing, instanceCount should be 1. + * When the min/max element indexes aren't known, minIndex should be 0 + * and maxIndex should be ~0. */ -static void -softpipe_draw_range_elements_instanced(struct pipe_context *pipe, - struct pipe_resource *indexBuffer, - unsigned indexSize, - unsigned minIndex, - unsigned maxIndex, - unsigned mode, - unsigned start, - unsigned count, - unsigned startInstance, - unsigned instanceCount); - - -void -softpipe_draw_arrays(struct pipe_context *pipe, unsigned mode, - unsigned start, unsigned count) -{ - softpipe_draw_range_elements_instanced(pipe, - NULL, - 0, - 0, - 0xffffffff, - mode, - start, - count, - 0, - 1); -} - - -void -softpipe_draw_range_elements(struct pipe_context *pipe, - struct pipe_resource *indexBuffer, - unsigned indexSize, - unsigned min_index, - unsigned max_index, - unsigned mode, unsigned start, unsigned count) -{ - softpipe_draw_range_elements_instanced(pipe, - indexBuffer, - indexSize, - min_index, - max_index, - mode, - start, - count, - 0, - 1); -} - - void -softpipe_draw_elements(struct pipe_context *pipe, - struct pipe_resource *indexBuffer, - unsigned indexSize, - unsigned mode, unsigned start, unsigned count) -{ - softpipe_draw_range_elements_instanced(pipe, - indexBuffer, - indexSize, - 0, - 0xffffffff, - mode, - start, - count, - 0, - 1); -} - -void -softpipe_draw_arrays_instanced(struct pipe_context *pipe, - unsigned mode, - unsigned start, - unsigned count, - unsigned startInstance, - unsigned instanceCount) -{ - softpipe_draw_range_elements_instanced(pipe, - NULL, - 0, - 0, - 0xffffffff, - mode, - start, - count, - startInstance, - instanceCount); -} - -void -softpipe_draw_elements_instanced(struct pipe_context *pipe, - struct pipe_resource *indexBuffer, - unsigned indexSize, - unsigned mode, - unsigned start, - unsigned count, - unsigned startInstance, - unsigned instanceCount) -{ - softpipe_draw_range_elements_instanced(pipe, - indexBuffer, - indexSize, - 0, - 0xffffffff, - mode, - start, - count, - startInstance, - instanceCount); -} - -static void -softpipe_draw_range_elements_instanced(struct pipe_context *pipe, - struct pipe_resource *indexBuffer, - unsigned indexSize, - unsigned minIndex, - unsigned maxIndex, - unsigned mode, - unsigned start, - unsigned count, - unsigned startInstance, - unsigned instanceCount) +softpipe_draw_vbo(struct pipe_context *pipe, + const struct pipe_draw_info *info) { struct softpipe_context *sp = softpipe_context(pipe); struct draw_context *draw = sp->draw; + const void *mapped_indices = NULL; unsigned i; if (!softpipe_check_render_cond(sp)) return; - sp->reduced_api_prim = u_reduced_prim(mode); + if (info->indirect) { + util_draw_indirect(pipe, info); + return; + } + + sp->reduced_api_prim = u_reduced_prim(info->mode); if (sp->dirty) { - softpipe_update_derived(sp); + softpipe_update_derived(sp, sp->reduced_api_prim); } - softpipe_map_transfers(sp); - /* Map vertex buffers */ for (i = 0; i < sp->num_vertex_buffers; i++) { - void *buf = softpipe_resource(sp->vertex_buffer[i].buffer)->data; - draw_set_mapped_vertex_buffer(draw, i, buf); + const void *buf = sp->vertex_buffer[i].is_user_buffer ? + sp->vertex_buffer[i].buffer.user : NULL; + size_t size = ~0; + if (!buf) { + if (!sp->vertex_buffer[i].buffer.resource) { + continue; + } + buf = softpipe_resource_data(sp->vertex_buffer[i].buffer.resource); + size = sp->vertex_buffer[i].buffer.resource->width0; + } + draw_set_mapped_vertex_buffer(draw, i, buf, size); } /* Map index buffer, if present */ - if (indexBuffer) { - void *mapped_indexes = softpipe_resource(indexBuffer)->data; - draw_set_mapped_element_buffer_range(draw, - indexSize, - minIndex, - maxIndex, - mapped_indexes); - } else { - /* no index/element buffer */ - draw_set_mapped_element_buffer_range(draw, - 0, - start, - start + count - 1, - NULL); + if (info->index_size) { + unsigned available_space = ~0; + mapped_indices = info->has_user_indices ? info->index.user : NULL; + if (!mapped_indices) { + mapped_indices = softpipe_resource_data(info->index.resource); + available_space = info->index.resource->width0; + } + + draw_set_indexes(draw, + (ubyte *) mapped_indices, + info->index_size, available_space); } + + for (i = 0; i < sp->num_so_targets; i++) { + void *buf = 0; + if (sp->so_targets[i]) { + buf = softpipe_resource(sp->so_targets[i]->target.buffer)->data; + sp->so_targets[i]->mapping = buf; + } + } + + draw_set_mapped_so_targets(draw, sp->num_so_targets, + sp->so_targets); + + if (softpipe_screen(sp->pipe.screen)->use_llvm) { + softpipe_prepare_vertex_sampling(sp, + sp->num_sampler_views[PIPE_SHADER_VERTEX], + sp->sampler_views[PIPE_SHADER_VERTEX]); + softpipe_prepare_geometry_sampling(sp, + sp->num_sampler_views[PIPE_SHADER_GEOMETRY], + sp->sampler_views[PIPE_SHADER_GEOMETRY]); + } + + if (sp->gs && !sp->gs->shader.tokens) { + /* we have an empty geometry shader with stream output, so + attach the stream output info to the current vertex shader */ + if (sp->vs) { + draw_vs_attach_so(sp->vs->draw_data, &sp->gs->shader.stream_output); + } + } + draw_collect_pipeline_statistics(draw, + sp->active_statistics_queries > 0); + /* draw! */ - draw_arrays_instanced(draw, mode, start, count, startInstance, instanceCount); + draw_vbo(draw, info); /* unmap vertex/index buffers - will cause draw module to flush */ for (i = 0; i < sp->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, NULL); + + draw_set_mapped_so_targets(draw, 0, NULL); + + if (softpipe_screen(sp->pipe.screen)->use_llvm) { + softpipe_cleanup_vertex_sampling(sp); + softpipe_cleanup_geometry_sampling(sp); } /*