#include "main/imports.h"
#include "main/bufferobj.h"
+#include "main/varray.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;
+ cut_index_will_work = ctx->Array.RestartIndex == 0xff;
break;
case GL_UNSIGNED_SHORT:
- cut_index_will_work = (ctx->Array.RestartIndex & 0xffff) == 0xffff;
+ cut_index_will_work = ctx->Array.RestartIndex == 0xffff;
break;
case GL_UNSIGNED_INT:
cut_index_will_work = ctx->Array.RestartIndex == 0xffffffff;
{
struct brw_context *brw = brw_context(ctx);
- 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 (brw->gen >= 8 || brw->is_haswell)
+ return true;
if (!can_cut_index_handle_restart_index(ctx, ib)) {
/* The primitive restart index can't be handled, so take
/* 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;
}
static void
haswell_upload_cut_index(struct brw_context *brw)
{
- struct intel_context *intel = &brw->intel;
- struct gl_context *ctx = &intel->ctx;
+ struct gl_context *ctx = &brw->ctx;
/* Don't trigger on Ivybridge */
- if (!intel->is_haswell)
+ if (!brw->is_haswell)
return;
const unsigned cut_index_setting =
- ctx->Array.PrimitiveRestart ? HSW_CUT_INDEX_ENABLE : 0;
+ ctx->Array._PrimitiveRestart ? HSW_CUT_INDEX_ENABLE : 0;
+
+ /* BRW_NEW_INDEX_BUFFER */
+ unsigned cut_index;
+ if (brw->ib.ib) {
+ cut_index = _mesa_primitive_restart_index(ctx, brw->ib.type);
+ } else {
+ /* There's no index buffer, but primitive restart may still apply
+ * to glDrawArrays and such. FIXED_INDEX mode only applies to drawing
+ * operations that use an index buffer, so we can ignore it and use
+ * the GL restart index directly.
+ */
+ cut_index = ctx->Array.RestartIndex;
+ }
BEGIN_BATCH(2);
OUT_BATCH(_3DSTATE_VF << 16 | cut_index_setting | (2 - 2));
- OUT_BATCH(ctx->Array.RestartIndex);
+ OUT_BATCH(cut_index);
ADVANCE_BATCH();
}
const struct brw_tracked_state haswell_cut_index = {
.dirty = {
.mesa = _NEW_TRANSFORM,
- .brw = 0,
+ .brw = BRW_NEW_INDEX_BUFFER,
.cache = 0,
},
.emit = haswell_upload_cut_index,