X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsvga%2Fsvga_pipe_draw.c;h=5ebd17cf0eabc5c50685467353883625beefdd9e;hb=e9cf8c1d3010e9eada5a7921239ad7895f249b5c;hp=de08bc5e562879f92cd35095077f704b5ba29c31;hpb=443a7e4e9a360acbc3e662c098be436f180bf81d;p=mesa.git diff --git a/src/gallium/drivers/svga/svga_pipe_draw.c b/src/gallium/drivers/svga/svga_pipe_draw.c index de08bc5e562..5ebd17cf0ea 100644 --- a/src/gallium/drivers/svga/svga_pipe_draw.c +++ b/src/gallium/drivers/svga/svga_pipe_draw.c @@ -23,147 +23,115 @@ * **********************************************************/ -#include "svga_cmd.h" +#include "util/u_helpers.h" #include "util/u_inlines.h" #include "util/u_prim.h" -#include "util/u_time.h" -#include "indices/u_indices.h" +#include "util/u_prim_restart.h" -#include "svga_hw_reg.h" #include "svga_context.h" -#include "svga_screen.h" #include "svga_draw.h" -#include "svga_state.h" +#include "svga_shader.h" +#include "svga_surface.h" #include "svga_swtnl.h" #include "svga_debug.h" +#include "svga_resource_buffer.h" +/* Returns TRUE if we are currently using flat shading. + */ +static boolean +is_using_flat_shading(const struct svga_context *svga) +{ + return + svga->state.hw_draw.fs ? svga->state.hw_draw.fs->uses_flat_interp : FALSE; +} static enum pipe_error -retry_draw_range_elements( struct svga_context *svga, - struct pipe_resource *index_buffer, - unsigned index_size, - int index_bias, - unsigned min_index, - unsigned max_index, - unsigned prim, - unsigned start, - unsigned count, - boolean do_retry ) +retry_draw_range_elements(struct svga_context *svga, + const struct pipe_draw_info *info, + unsigned count) { - enum pipe_error ret = 0; - - svga_hwtnl_set_unfilled( svga->hwtnl, - svga->curr.rast->hw_unfilled ); - - svga_hwtnl_set_flatshade( svga->hwtnl, - svga->curr.rast->templ.flatshade, - svga->curr.rast->templ.flatshade_first ); - - - ret = svga_update_state( svga, SVGA_STATE_HW_DRAW ); - if (ret) - goto retry; - - ret = svga_hwtnl_draw_range_elements( svga->hwtnl, - index_buffer, index_size, index_bias, - min_index, max_index, - prim, start, count ); - if (ret) - goto retry; - - if (svga->curr.any_user_vertex_buffers) { - ret = svga_hwtnl_flush( svga->hwtnl ); - if (ret) - goto retry; - } - - return PIPE_OK; + enum pipe_error ret; -retry: - svga_context_flush( svga, NULL ); + SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_DRAWELEMENTS); - if (do_retry) - { - return retry_draw_range_elements( svga, - index_buffer, index_size, index_bias, - min_index, max_index, - prim, start, count, - FALSE ); + ret = svga_hwtnl_draw_range_elements(svga->hwtnl, info, count); + if (ret != PIPE_OK) { + svga_context_flush(svga, NULL); + ret = svga_hwtnl_draw_range_elements(svga->hwtnl, info, count); } + assert (ret == PIPE_OK); + SVGA_STATS_TIME_POP(svga_sws(svga)); return ret; } static enum pipe_error -retry_draw_arrays( struct svga_context *svga, - unsigned prim, - unsigned start, - unsigned count, - boolean do_retry ) +retry_draw_arrays(struct svga_context *svga, + enum pipe_prim_type prim, unsigned start, unsigned count, + unsigned start_instance, unsigned instance_count) { enum pipe_error ret; - svga_hwtnl_set_unfilled( svga->hwtnl, - svga->curr.rast->hw_unfilled ); + SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_DRAWARRAYS); - svga_hwtnl_set_flatshade( svga->hwtnl, - svga->curr.rast->templ.flatshade, - svga->curr.rast->templ.flatshade_first ); - - ret = svga_update_state( svga, SVGA_STATE_HW_DRAW ); - if (ret) - goto retry; - - ret = svga_hwtnl_draw_arrays( svga->hwtnl, prim, - start, count ); - if (ret) - goto retry; - - if (svga->curr.any_user_vertex_buffers) { - ret = svga_hwtnl_flush( svga->hwtnl ); - if (ret) - goto retry; - } - - return 0; - -retry: - if (ret == PIPE_ERROR_OUT_OF_MEMORY && do_retry) - { - svga_context_flush( svga, NULL ); - - return retry_draw_arrays( svga, - prim, - start, - count, - FALSE ); + for (unsigned try = 0; try < 2; try++) { + ret = svga_hwtnl_draw_arrays(svga->hwtnl, prim, start, count, + start_instance, instance_count); + if (ret == PIPE_OK) + break; + svga_context_flush(svga, NULL); } + SVGA_STATS_TIME_POP(svga_sws(svga)); return ret; } +/** + * Determine if we need to implement primitive restart with a fallback + * path which breaks the original primitive into sub-primitive at the + * restart indexes. + */ +static boolean +need_fallback_prim_restart(const struct svga_context *svga, + const struct pipe_draw_info *info) +{ + if (info->primitive_restart && info->index_size) { + if (!svga_have_vgpu10(svga)) + return TRUE; + else if (!svga->state.sw.need_swtnl) { + if (info->index_size == 1) + return TRUE; /* no device support for 1-byte indexes */ + else if (info->index_size == 2) + return info->restart_index != 0xffff; + else + return info->restart_index != 0xffffffff; + } + } + return FALSE; +} static void -svga_draw_range_elements( struct pipe_context *pipe, - struct pipe_resource *index_buffer, - unsigned index_size, - int index_bias, - unsigned min_index, - unsigned max_index, - unsigned prim, unsigned start, unsigned count) +svga_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info) { - struct svga_context *svga = svga_context( pipe ); - unsigned reduced_prim = u_reduced_prim(prim); + struct svga_context *svga = svga_context(pipe); + enum pipe_prim_type reduced_prim = u_reduced_prim(info->mode); + unsigned count = info->count; enum pipe_error ret = 0; + boolean needed_swtnl; + + SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_DRAWVBO); - if (!u_trim_pipe_prim( prim, &count )) - return; + svga->hud.num_draw_calls++; /* for SVGA_QUERY_NUM_DRAW_CALLS */ + + if (u_reduced_prim(info->mode) == PIPE_PRIM_TRIANGLES && + svga->curr.rast->templ.cull_face == PIPE_FACE_FRONT_AND_BACK) + goto done; /* * Mark currently bound target surfaces as dirty @@ -178,79 +146,81 @@ svga_draw_range_elements( struct pipe_context *pipe, svga->curr.reduced_prim = reduced_prim; svga->dirty |= SVGA_NEW_REDUCED_PRIMITIVE; } - - svga_update_state_retry( svga, SVGA_STATE_NEED_SWTNL ); - -#ifdef DEBUG - if (svga->curr.vs->base.id == svga->debug.disable_shader || - svga->curr.fs->base.id == svga->debug.disable_shader) - return; -#endif - - if (svga->state.sw.need_swtnl) - { - ret = svga_swtnl_draw_range_elements( svga, - index_buffer, - index_size, - index_bias, - min_index, max_index, - prim, - start, count ); + + if (need_fallback_prim_restart(svga, info)) { + enum pipe_error r; + r = util_draw_vbo_without_prim_restart(pipe, info); + assert(r == PIPE_OK); + (void) r; + goto done; + } + + if (!u_trim_pipe_prim(info->mode, &count)) + goto done; + + needed_swtnl = svga->state.sw.need_swtnl; + + svga_update_state_retry(svga, SVGA_STATE_NEED_SWTNL); + + if (svga->state.sw.need_swtnl) { + svga->hud.num_fallbacks++; /* for SVGA_QUERY_NUM_FALLBACKS */ + if (!needed_swtnl) { + /* + * We're switching from HW to SW TNL. SW TNL will require mapping all + * currently bound vertex buffers, some of which may already be + * referenced in the current command buffer as result of previous HW + * TNL. So flush now, to prevent the context to flush while a referred + * vertex buffer is mapped. + */ + + svga_context_flush(svga, NULL); + } + + /* Avoid leaking the previous hwtnl bias to swtnl */ + svga_hwtnl_set_index_bias(svga->hwtnl, 0); + ret = svga_swtnl_draw_vbo(svga, info); } else { - if (index_buffer) { - ret = retry_draw_range_elements( svga, - index_buffer, - index_size, - index_bias, - min_index, - max_index, - prim, - start, - count, - TRUE ); + if (!svga_update_state_retry(svga, SVGA_STATE_HW_DRAW)) { + static const char *msg = "State update failed, skipping draw call"; + debug_printf("%s\n", msg); + pipe_debug_message(&svga->debug.callback, INFO, "%s", msg); + goto done; + } + svga_hwtnl_set_fillmode(svga->hwtnl, svga->curr.rast->hw_fillmode); + + /** determine if flatshade is to be used after svga_update_state() + * in case the fragment shader is changed. + */ + svga_hwtnl_set_flatshade(svga->hwtnl, + svga->curr.rast->templ.flatshade || + is_using_flat_shading(svga), + svga->curr.rast->templ.flatshade_first); + + if (info->index_size) { + ret = retry_draw_range_elements(svga, info, count); } else { - ret = retry_draw_arrays( svga, - prim, - start, - count, - TRUE ); + ret = retry_draw_arrays(svga, info->mode, info->start, count, + info->start_instance, info->instance_count); } } + /* XXX: Silence warnings, do something sensible here? */ + (void)ret; + if (SVGA_DEBUG & DEBUG_FLUSH) { - svga_hwtnl_flush_retry( svga ); + svga_hwtnl_flush_retry(svga); svga_context_flush(svga, NULL); } -} - -static void -svga_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info) -{ - struct svga_context *svga = svga_context(pipe); - - if (info->indexed && svga->curr.ib.buffer) { - unsigned offset; - - assert(svga->curr.ib.offset % svga->curr.ib.index_size == 0); - offset = svga->curr.ib.offset / svga->curr.ib.index_size; - - svga_draw_range_elements(pipe, svga->curr.ib.buffer, - svga->curr.ib.index_size, info->index_bias, - info->min_index, info->max_index, - info->mode, info->start + offset, info->count); - } - else { - svga_draw_range_elements(pipe, NULL, 0, 0, - info->min_index, info->max_index, - info->mode, info->start, info->count); - } +done: + SVGA_STATS_TIME_POP(svga_sws(svga)); } -void svga_init_draw_functions( struct svga_context *svga ) +void +svga_init_draw_functions(struct svga_context *svga) { svga->pipe.draw_vbo = svga_draw_vbo; }