X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsvga%2Fsvga_swtnl_draw.c;h=96d8a52eb6244608c0afff0726a39a94c219f68d;hb=935299188086c87e1ccb159cf9cf205a31c57468;hp=8b14c913f726b465b326e0dc5089a9c3f94dc4e1;hpb=b57abd3bea29e95e5dee2524c3f1be4b26017c0f;p=mesa.git

diff --git a/src/gallium/drivers/svga/svga_swtnl_draw.c b/src/gallium/drivers/svga/svga_swtnl_draw.c
index 8b14c913f72..96d8a52eb62 100644
--- a/src/gallium/drivers/svga/svga_swtnl_draw.c
+++ b/src/gallium/drivers/svga/svga_swtnl_draw.c
@@ -25,11 +25,11 @@
 
 #include "draw/draw_context.h"
 #include "draw/draw_vbuf.h"
-#include "pipe/p_inlines.h"
+#include "util/u_inlines.h"
 #include "pipe/p_state.h"
-#include "util/u_memory.h"
 
 #include "svga_context.h"
+#include "svga_screen.h"
 #include "svga_swtnl.h"
 #include "svga_state.h"
 #include "svga_swtnl_private.h"
@@ -37,24 +37,29 @@
 
 
 enum pipe_error
-svga_swtnl_draw_range_elements(struct svga_context *svga,
-                               struct pipe_buffer *indexBuffer,
-                               unsigned indexSize,
-                               unsigned min_index,
-                               unsigned max_index,
-                               unsigned prim, unsigned start, unsigned count)
+svga_swtnl_draw_vbo(struct svga_context *svga,
+                    const struct pipe_draw_info *info)
 {
+   struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = { 0 };
+   struct pipe_transfer *ib_transfer = NULL;
+   struct pipe_transfer *cb_transfer[SVGA_MAX_CONST_BUFS] = { 0 };
    struct draw_context *draw = svga->swtnl.draw;
+   ASSERTED unsigned old_num_vertex_buffers;
    unsigned i;
    const void *map;
    enum pipe_error ret;
 
+   SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_SWTNLDRAWVBO);
+
    assert(!svga->dirty);
    assert(svga->state.sw.need_swtnl);
    assert(draw);
 
+   /* Make sure that the need_swtnl flag does not go away */
+   svga->state.sw.in_swtnl_draw = TRUE;
+
    ret = svga_update_state(svga, SVGA_STATE_SWTNL_DRAW);
-   if (ret) {
+   if (ret != PIPE_OK) {
       svga_context_flush(svga, NULL);
       ret = svga_update_state(svga, SVGA_STATE_SWTNL_DRAW);
       svga->swtnl.new_vbuf = TRUE;
@@ -65,106 +70,153 @@ svga_swtnl_draw_range_elements(struct svga_context *svga,
     * Map vertex buffers
     */
    for (i = 0; i < svga->curr.num_vertex_buffers; i++) {
-      map = pipe_buffer_map(svga->pipe.screen,
-                            svga->curr.vb[i].buffer,
-                            PIPE_BUFFER_USAGE_CPU_READ);
-
-      draw_set_mapped_vertex_buffer(draw, i, map);
+      if (svga->curr.vb[i].buffer.resource) {
+         map = pipe_buffer_map(&svga->pipe,
+                               svga->curr.vb[i].buffer.resource,
+                               PIPE_TRANSFER_READ |
+                               PIPE_TRANSFER_UNSYNCHRONIZED,
+                               &vb_transfer[i]);
+
+         draw_set_mapped_vertex_buffer(draw, i, map, ~0);
+      }
    }
+   old_num_vertex_buffers = svga->curr.num_vertex_buffers;
 
    /* Map index buffer, if present */
-   if (indexBuffer) {
-      map = pipe_buffer_map(svga->pipe.screen, indexBuffer,
-                            PIPE_BUFFER_USAGE_CPU_READ);
-
-      draw_set_mapped_element_buffer_range(draw, 
-                                           indexSize, 
-                                           min_index,
-                                           max_index,
-                                           map);
+   map = NULL;
+   if (info->index_size) {
+      if (info->has_user_indices) {
+         map = (ubyte *) info->index.user;
+      } else {
+         map = pipe_buffer_map(&svga->pipe, info->index.resource,
+                               PIPE_TRANSFER_READ |
+                               PIPE_TRANSFER_UNSYNCHRONIZED, &ib_transfer);
+      }
+      draw_set_indexes(draw,
+                       (const ubyte *) map,
+                       info->index_size, ~0);
    }
-   
-   if (svga->curr.cb[PIPE_SHADER_VERTEX]) {
-      map = pipe_buffer_map(svga->pipe.screen,
-                            svga->curr.cb[PIPE_SHADER_VERTEX],
-                            PIPE_BUFFER_USAGE_CPU_READ);
+
+   /* Map constant buffers */
+   for (i = 0; i < ARRAY_SIZE(svga->curr.constbufs[PIPE_SHADER_VERTEX]); ++i) {
+      if (svga->curr.constbufs[PIPE_SHADER_VERTEX][i].buffer == NULL) {
+         continue;
+      }
+
+      map = pipe_buffer_map(&svga->pipe,
+                            svga->curr.constbufs[PIPE_SHADER_VERTEX][i].buffer,
+                            PIPE_TRANSFER_READ |
+                            PIPE_TRANSFER_UNSYNCHRONIZED,
+                            &cb_transfer[i]);
       assert(map);
       draw_set_mapped_constant_buffer(
-         draw, 
+         draw, PIPE_SHADER_VERTEX, i,
          map,
-         svga->curr.cb[PIPE_SHADER_VERTEX]->size);
+         svga->curr.constbufs[PIPE_SHADER_VERTEX][i].buffer->width0);
    }
 
-   draw_arrays(svga->swtnl.draw, prim, start, count);
+   draw_vbo(draw, info);
 
    draw_flush(svga->swtnl.draw);
 
    /* Ensure the draw module didn't touch this */
-   assert(i == svga->curr.num_vertex_buffers);
-   
+   assert(old_num_vertex_buffers == svga->curr.num_vertex_buffers);
+
    /*
     * unmap vertex/index buffers
     */
    for (i = 0; i < svga->curr.num_vertex_buffers; i++) {
-      pipe_buffer_unmap(svga->pipe.screen, svga->curr.vb[i].buffer);
-      draw_set_mapped_vertex_buffer(draw, i, NULL);
+      if (svga->curr.vb[i].buffer.resource) {
+         pipe_buffer_unmap(&svga->pipe, vb_transfer[i]);
+         draw_set_mapped_vertex_buffer(draw, i, NULL, 0);
+      }
    }
 
-   if (indexBuffer) {
-      pipe_buffer_unmap(svga->pipe.screen, indexBuffer);
-      draw_set_mapped_element_buffer(draw, 0, NULL);
+   if (ib_transfer) {
+      pipe_buffer_unmap(&svga->pipe, ib_transfer);
+      draw_set_indexes(draw, NULL, 0, 0);
    }
 
-   if (svga->curr.cb[PIPE_SHADER_VERTEX]) {
-      pipe_buffer_unmap(svga->pipe.screen,
-                        svga->curr.cb[PIPE_SHADER_VERTEX]);
+   for (i = 0; i < ARRAY_SIZE(svga->curr.constbufs[PIPE_SHADER_VERTEX]); ++i) {
+      if (svga->curr.constbufs[PIPE_SHADER_VERTEX][i].buffer) {
+         pipe_buffer_unmap(&svga->pipe, cb_transfer[i]);
+      }
    }
 
+   /* Now safe to remove the need_swtnl flag in any update_state call */
+   svga->state.sw.in_swtnl_draw = FALSE;
+   svga->dirty |= SVGA_NEW_NEED_PIPELINE | SVGA_NEW_NEED_SWVFETCH;
+
+   SVGA_STATS_TIME_POP(svga_sws(svga));
    return ret;
 }
 
 
-
-
-boolean svga_init_swtnl( struct svga_context *svga )
+boolean
+svga_init_swtnl(struct svga_context *svga)
 {
+   struct svga_screen *screen = svga_screen(svga->pipe.screen);
+
    svga->swtnl.backend = svga_vbuf_render_create(svga);
-   if(!svga->swtnl.backend)
+   if (!svga->swtnl.backend)
       goto fail;
 
    /*
     * Create drawing context and plug our rendering stage into it.
     */
-   svga->swtnl.draw = draw_create();
+   svga->swtnl.draw = draw_create(&svga->pipe);
    if (svga->swtnl.draw == NULL)
       goto fail;
 
 
-   draw_set_rasterize_stage(svga->swtnl.draw, 
-                            draw_vbuf_stage( svga->swtnl.draw, svga->swtnl.backend ));
+   draw_set_rasterize_stage(svga->swtnl.draw,
+                 draw_vbuf_stage(svga->swtnl.draw, svga->swtnl.backend));
 
    draw_set_render(svga->swtnl.draw, svga->swtnl.backend);
 
-   draw_install_aaline_stage(svga->swtnl.draw, &svga->pipe);
+   svga->blitter = util_blitter_create(&svga->pipe);
+   if (!svga->blitter)
+      goto fail;
+
+   /* must be done before installing Draw stages */
+   util_blitter_cache_all_shaders(svga->blitter);
+
+   if (!screen->haveLineSmooth)
+      draw_install_aaline_stage(svga->swtnl.draw, &svga->pipe);
+
+   /* enable/disable line stipple stage depending on device caps */
+   draw_enable_line_stipple(svga->swtnl.draw, !screen->haveLineStipple);
+
+   /* always install AA point stage */
    draw_install_aapoint_stage(svga->swtnl.draw, &svga->pipe);
-   draw_install_pstipple_stage(svga->swtnl.draw, &svga->pipe);
 
-   draw_set_driver_clipping(svga->swtnl.draw, debug_get_bool_option("SVGA_SWTNL_FSE", FALSE));
+   /* Set wide line threshold above device limit (so we'll never really use it)
+    */
+   draw_wide_line_threshold(svga->swtnl.draw,
+                            MAX2(screen->maxLineWidth,
+                                 screen->maxLineWidthAA));
+
+   if (debug_get_bool_option("SVGA_SWTNL_FSE", FALSE))
+      draw_set_driver_clipping(svga->swtnl.draw, TRUE, TRUE, TRUE, FALSE);
 
    return TRUE;
 
 fail:
+   if (svga->blitter)
+      util_blitter_destroy(svga->blitter);
+
    if (svga->swtnl.backend)
-      svga->swtnl.backend->destroy( svga->swtnl.backend );
+      svga->swtnl.backend->destroy(svga->swtnl.backend);
 
    if (svga->swtnl.draw)
-      draw_destroy( svga->swtnl.draw );
+      draw_destroy(svga->swtnl.draw);
 
    return FALSE;
 }
 
 
-void svga_destroy_swtnl( struct svga_context *svga )
+void
+svga_destroy_swtnl(struct svga_context *svga)
 {
-   draw_destroy( svga->swtnl.draw );
+   draw_destroy(svga->swtnl.draw);
 }