X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsoftpipe%2Fsp_draw_arrays.c;h=91427348a25732c26a0460d92ea8473b36c0e64a;hb=44ab7c265fdb511077b120ee40c0d6af0125e276;hp=d4045816d03ed7a428d8ea6849d057ad84c3b956;hpb=b96ae1b2c463d6d99ee0418083ef68f4027b7cd7;p=mesa.git diff --git a/src/gallium/drivers/softpipe/sp_draw_arrays.c b/src/gallium/drivers/softpipe/sp_draw_arrays.c index d4045816d03..91427348a25 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. @@ -33,162 +33,124 @@ #include "pipe/p_defines.h" #include "pipe/p_context.h" -#include "pipe/internal/p_winsys_screen.h" -#include "pipe/p_inlines.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" - - -static void -softpipe_map_constant_buffers(struct softpipe_context *sp) -{ - struct pipe_winsys *ws = sp->pipe.winsys; - uint i, size; - - for (i = 0; i < PIPE_SHADER_TYPES; i++) { - if (sp->constants[i].buffer && sp->constants[i].buffer->size) - sp->mapped_constants[i] = ws->buffer_map(ws, sp->constants[i].buffer, - PIPE_BUFFER_USAGE_CPU_READ); - } - - if (sp->constants[PIPE_SHADER_VERTEX].buffer) - size = sp->constants[PIPE_SHADER_VERTEX].buffer->size; - else - size = 0; - - draw_set_mapped_constant_buffer(sp->draw, - sp->mapped_constants[PIPE_SHADER_VERTEX], - size); -} - - -static void -softpipe_unmap_constant_buffers(struct softpipe_context *sp) -{ - struct pipe_winsys *ws = sp->pipe.winsys; - uint i; - - /* really need to flush all prims since the vert/frag shaders const buffers - * are going away now. - */ - draw_flush(sp->draw); - - draw_set_mapped_constant_buffer(sp->draw, NULL, 0); - - for (i = 0; i < 2; i++) { - if (sp->constants[i].buffer && sp->constants[i].buffer->size) - ws->buffer_unmap(ws, sp->constants[i].buffer); - sp->mapped_constants[i] = NULL; - } -} - - -boolean -softpipe_draw_arrays(struct pipe_context *pipe, unsigned mode, - unsigned start, unsigned count) -{ - return softpipe_draw_elements(pipe, NULL, 0, mode, start, count); -} - - /** - * 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. */ -boolean -softpipe_draw_range_elements(struct pipe_context *pipe, - struct pipe_buffer *indexBuffer, - unsigned indexSize, - unsigned min_index, - unsigned max_index, - unsigned mode, unsigned start, unsigned count) +void +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; - sp->reduced_api_prim = u_reduced_prim(mode); + if (!softpipe_check_render_cond(sp)) + return; - if (sp->dirty) - softpipe_update_derived( sp ); + if (info->indirect) { + util_draw_indirect(pipe, info); + return; + } - softpipe_map_transfers(sp); - softpipe_map_constant_buffers(sp); + sp->reduced_api_prim = u_reduced_prim(info->mode); - /* - * Map vertex buffers - */ + if (sp->dirty) { + softpipe_update_derived(sp, sp->reduced_api_prim); + } + + /* Map vertex buffers */ for (i = 0; i < sp->num_vertex_buffers; i++) { - void *buf - = pipe_buffer_map(pipe->screen, - sp->vertex_buffer[i].buffer, - PIPE_BUFFER_USAGE_CPU_READ); - 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 - = pipe_buffer_map(pipe->screen, indexBuffer, - PIPE_BUFFER_USAGE_CPU_READ); - draw_set_mapped_element_buffer_range(draw, indexSize, - min_index, - max_index, - mapped_indexes); + 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); + } + + 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]); } - else { - /* no index/element buffer */ - draw_set_mapped_element_buffer_range(draw, 0, start, - start + count - 1, NULL); + + 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(draw, mode, start, count); + draw_vbo(draw, info); - /* - * unmap vertex/index buffers - will cause draw module to flush - */ + /* 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); - pipe_buffer_unmap(pipe->screen, sp->vertex_buffer[i].buffer); + draw_set_mapped_vertex_buffer(draw, i, NULL, 0); } - if (indexBuffer) { - draw_set_mapped_element_buffer(draw, 0, NULL); - pipe_buffer_unmap(pipe->screen, indexBuffer); + if (mapped_indices) { + draw_set_indexes(draw, NULL, 0, 0); } + if (softpipe_screen(sp->pipe.screen)->use_llvm) { + softpipe_cleanup_vertex_sampling(sp); + softpipe_cleanup_geometry_sampling(sp); + } - /* Note: leave drawing surfaces mapped */ - softpipe_unmap_constant_buffers(sp); + /* + * TODO: Flush only when a user vertex/index buffer is present + * (or even better, modify draw module to do this + * internally when this condition is seen?) + */ + draw_flush(draw); + /* Note: leave drawing surfaces mapped */ sp->dirty_render_cache = TRUE; - - return TRUE; -} - - -boolean -softpipe_draw_elements(struct pipe_context *pipe, - struct pipe_buffer *indexBuffer, - unsigned indexSize, - unsigned mode, unsigned start, unsigned count) -{ - return softpipe_draw_range_elements( pipe, indexBuffer, - indexSize, - 0, 0xffffffff, - mode, start, count ); -} - - -void -softpipe_set_edgeflags(struct pipe_context *pipe, const unsigned *edgeflags) -{ - struct softpipe_context *sp = softpipe_context(pipe); - draw_set_edgeflags(sp->draw, edgeflags); }