#include "main/imports.h"
#include "main/bufferobj.h"
+#include "main/varray.h"
+#include "vbo/vbo.h"
#include "brw_context.h"
#include "brw_defines.h"
/**
* Check if the hardware's cut index support can handle the primitive
- * restart index value.
+ * restart index value (pre-Haswell only).
*/
static bool
can_cut_index_handle_restart_index(struct gl_context *ctx,
const struct _mesa_index_buffer *ib)
{
- struct intel_context *intel = intel_context(ctx);
-
- /* Haswell supports an arbitrary cut index. */
- if (intel->is_haswell)
+ /* 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->type) {
- case GL_UNSIGNED_BYTE:
- cut_index_will_work = (ctx->Array._RestartIndex & 0xff) == 0xff;
+ switch (ib->index_size) {
+ case 1:
+ cut_index_will_work = ctx->Array.RestartIndex == 0xff;
break;
- case GL_UNSIGNED_SHORT:
- cut_index_will_work = (ctx->Array._RestartIndex & 0xffff) == 0xffff;
+ case 2:
+ cut_index_will_work = ctx->Array.RestartIndex == 0xffff;
break;
- case GL_UNSIGNED_INT:
- cut_index_will_work = ctx->Array._RestartIndex == 0xffffffff;
+ case 4:
+ cut_index_will_work = ctx->Array.RestartIndex == 0xffffffff;
break;
default:
- cut_index_will_work = false;
- assert(0);
+ unreachable("not reached");
}
return cut_index_will_work;
const struct _mesa_index_buffer *ib)
{
struct brw_context *brw = brw_context(ctx);
+ const struct gen_device_info *devinfo = &brw->screen->devinfo;
- if (brw->sol.counting_primitives_generated ||
- brw->sol.counting_primitives_written) {
- /* Counting primitives generated in hardware is not currently
- * supported, so take the software path. We need to investigate
- * the *_PRIMITIVES_COUNT registers to allow this to be handled
- * entirely in hardware.
- */
- return false;
- }
+ /* 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
return false;
}
- for ( ; nr_prims > 0; nr_prims--) {
- switch(prim->mode) {
+ 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:
*/
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,
+ struct gl_buffer_object *indirect)
{
struct brw_context *brw = brw_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.
*/
*/
brw->prim_restart.in_progress = true;
- if (can_cut_index_handle_prims(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, prim, nr_prims, ib, GL_FALSE, -1, -1, NULL);
+ brw_draw_prims(ctx, prims, nr_prims, ib, GL_FALSE, -1, -1, NULL, 0,
+ indirect);
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
*/
- vbo_sw_primitive_restart(ctx, prim, nr_prims, ib);
+ vbo_sw_primitive_restart(ctx, prims, nr_prims, ib, indirect);
}
brw->prim_restart.in_progress = false;
/* The primitive restart draw was completed, so return true. */
return GL_TRUE;
}
-
-static void
-haswell_upload_cut_index(struct brw_context *brw)
-{
- struct intel_context *intel = &brw->intel;
- struct gl_context *ctx = &intel->ctx;
-
- /* Don't trigger on Ivybridge */
- if (!intel->is_haswell)
- return;
-
- const unsigned cut_index_setting =
- ctx->Array.PrimitiveRestart ? HSW_CUT_INDEX_ENABLE : 0;
-
- BEGIN_BATCH(2);
- OUT_BATCH(_3DSTATE_VF << 16 | cut_index_setting | (2 - 2));
- OUT_BATCH(ctx->Array.RestartIndex);
- ADVANCE_BATCH();
-}
-
-const struct brw_tracked_state haswell_cut_index = {
- .dirty = {
- .mesa = _NEW_TRANSFORM,
- .brw = 0,
- .cache = 0,
- },
- .emit = haswell_upload_cut_index,
-};
projects / mesa.git / blobdiff