remove final imports.h and imports.c bits

[mesa.git] / src / mesa / drivers / dri / i965 / brw_primitive_restart.c

diff --git a/src/mesa/drivers/dri/i965/brw_primitive_restart.c b/src/mesa/drivers/dri/i965/brw_primitive_restart.c
index d7136ed6fb97e0b13ed685236ffec8fb672bfd94..e73f32720e16a4a659932dc29aebcfda0b6b109b 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_primitive_restart.c
+++ b/src/mesa/drivers/dri/i965/brw_primitive_restart.c
@@ -25,12 +25,100 @@
  *
  */
 
-#include "main/imports.h"
 #include "main/bufferobj.h"
+#include "main/varray.h"
+#include "vbo/vbo.h"
 
 #include "brw_context.h"
+#include "brw_defines.h"
 #include "brw_draw.h"
 
+#include "intel_batchbuffer.h"
+
+/**
+ * Check if the hardware's cut index support can handle the primitive
+ * restart index value (pre-Haswell only).
+ */
+static bool
+can_cut_index_handle_restart_index(struct gl_context *ctx,
+                                   const struct _mesa_index_buffer *ib)
+{
+   /* The FixedIndex variant means 0xFF, 0xFFFF, or 0xFFFFFFFF based on
+    * the index buffer type, which corresponds exactly to the hardware.
+    */
+   if (ctx->Array.PrimitiveRestartFixedIndex)
+      return true;
+
+   bool cut_index_will_work;
+
+   switch (ib->index_size_shift) {
+   case 0:
+      cut_index_will_work = ctx->Array.RestartIndex == 0xff;
+      break;
+   case 1:
+      cut_index_will_work = ctx->Array.RestartIndex == 0xffff;
+      break;
+   case 2:
+      cut_index_will_work = ctx->Array.RestartIndex == 0xffffffff;
+      break;
+   default:
+      unreachable("not reached");
+   }
+
+   return cut_index_will_work;
+}
+
+/**
+ * Check if the hardware's cut index support can handle the primitive
+ * restart case.
+ */
+static bool
+can_cut_index_handle_prims(struct gl_context *ctx,
+                           const struct _mesa_prim *prim,
+                           GLuint nr_prims,
+                           const struct _mesa_index_buffer *ib)
+{
+   struct brw_context *brw = brw_context(ctx);
+   const struct gen_device_info *devinfo = &brw->screen->devinfo;
+
+   /* Otherwise Haswell can do it all. */
+   if (devinfo->gen >= 8 || devinfo->is_haswell)
+      return true;
+
+   if (!can_cut_index_handle_restart_index(ctx, ib)) {
+      /* The primitive restart index can't be handled, so take
+       * the software path
+       */
+      return false;
+   }
+
+   for (unsigned i = 0; i < nr_prims; i++) {
+      switch (prim[i].mode) {
+      case GL_POINTS:
+      case GL_LINES:
+      case GL_LINE_STRIP:
+      case GL_TRIANGLES:
+      case GL_TRIANGLE_STRIP:
+      case GL_LINES_ADJACENCY:
+      case GL_LINE_STRIP_ADJACENCY:
+      case GL_TRIANGLES_ADJACENCY:
+      case GL_TRIANGLE_STRIP_ADJACENCY:
+         /* Cut index supports these primitive types */
+         break;
+      default:
+         /* Cut index does not support these primitive types */
+      //case GL_LINE_LOOP:
+      //case GL_TRIANGLE_FAN:
+      //case GL_QUADS:
+      //case GL_QUAD_STRIP:
+      //case GL_POLYGON:
+         return false;
+      }
+   }
+
+   return true;
+}
+
 /**
  * Check if primitive restart is enabled, and if so, handle it properly.
  *
@@ -39,9 +127,10 @@
  */
 GLboolean
 brw_handle_primitive_restart(struct gl_context *ctx,
-                             const struct _mesa_prim *prim,
+                             const struct _mesa_prim *prims,
                              GLuint nr_prims,
-                             const struct _mesa_index_buffer *ib)
+                             const struct _mesa_index_buffer *ib,
+                             GLuint num_instances, GLuint base_instance)
 {
    struct brw_context *brw = brw_context(ctx);
 
@@ -50,14 +139,6 @@ brw_handle_primitive_restart(struct gl_context *ctx,
       return GL_FALSE;
    }
 
-   /* If the driver has requested software handling of primitive restarts,
-    * then the VBO module has already taken care of things, and we can
-    * just draw as normal.
-    */
-   if (ctx->Const.PrimitiveRestartInSoftware) {
-      return GL_FALSE;
-   }
-
    /* If we have set the in_progress flag, then we are in the middle
     * of handling the primitive restart draw.
     */
@@ -68,7 +149,7 @@ brw_handle_primitive_restart(struct gl_context *ctx,
    /* If PrimitiveRestart is not enabled, then we aren't concerned about
     * handling this draw.
     */
-   if (!(ctx->Array.PrimitiveRestart)) {
+   if (!(ctx->Array._PrimitiveRestart)) {
       return GL_FALSE;
    }
 
@@ -77,11 +158,29 @@ brw_handle_primitive_restart(struct gl_context *ctx,
     */
    brw->prim_restart.in_progress = true;
 
-   vbo_sw_primitive_restart(ctx, prim, nr_prims, ib);
+   if (can_cut_index_handle_prims(ctx, prims, nr_prims, ib)) {
+      /* Cut index should work for primitive restart, so use it
+       */
+      brw->prim_restart.enable_cut_index = true;
+      brw_draw_prims(ctx, prims, nr_prims, ib, GL_FALSE, -1, -1,
+                     num_instances, base_instance, NULL, 0);
+      brw->prim_restart.enable_cut_index = false;
+   } else {
+      /* Not all the primitive draw modes are supported by the cut index,
+       * so take the software path
+       */
+      struct gl_buffer_object *indirect_data = brw->draw.draw_indirect_data;
+
+      /* Clear this to make the draw direct. */
+      brw->draw.draw_indirect_data = NULL;
+
+      vbo_sw_primitive_restart(ctx, prims, nr_prims, ib, num_instances,
+                               base_instance, indirect_data,
+                               brw->draw.draw_indirect_offset);
+   }
 
    brw->prim_restart.in_progress = false;
 
    /* The primitive restart draw was completed, so return true. */
    return GL_TRUE;
 }
-