**************************************************************************/
+#include "util/u_inlines.h"
+#include "util/u_prim.h"
+#include "util/u_upload_mgr.h"
+
#include "brw_draw.h"
#include "brw_defines.h"
#include "brw_context.h"
#include "brw_state.h"
+#include "brw_debug.h"
#include "brw_batchbuffer.h"
-#include "intel_buffer_objects.h"
-#define FILE_DEBUG_FLAG DEBUG_BATCH
static uint32_t prim_to_hw_prim[PIPE_PRIM_POLYGON+1] = {
_3DPRIM_POINTLIST,
* programs be immune to the active primitive (ie. cope with all
* possibilities). That may not be realistic however.
*/
-static GLuint brw_set_prim(struct brw_context *brw, GLenum prim)
+static int brw_set_prim(struct brw_context *brw, unsigned prim )
{
- if (INTEL_DEBUG & DEBUG_PRIMS)
- _mesa_printf("PRIM: %s\n", _mesa_lookup_enum_by_nr(prim));
+ if (BRW_DEBUG & DEBUG_PRIMS)
+ debug_printf("PRIM: %s\n", u_prim_name(prim));
- /* Slight optimization to avoid the GS program when not needed:
- */
- if (prim == GL_QUAD_STRIP &&
- ctx->Light.ShadeModel != GL_FLAT &&
- ctx->Polygon.FrontMode == GL_FILL &&
- ctx->Polygon.BackMode == GL_FILL)
- prim = GL_TRIANGLE_STRIP;
-
if (prim != brw->primitive) {
+ unsigned reduced_prim;
+
brw->primitive = prim;
brw->state.dirty.brw |= BRW_NEW_PRIMITIVE;
- if (reduced_prim[prim] != brw->intel.reduced_primitive) {
- brw->intel.reduced_primitive = reduced_prim[prim];
+ reduced_prim = u_reduced_prim(prim);
+ if (reduced_prim != brw->reduced_primitive) {
+ brw->reduced_primitive = reduced_prim;
brw->state.dirty.brw |= BRW_NEW_REDUCED_PRIMITIVE;
}
}
}
-static GLuint trim(GLenum prim, GLuint length)
-{
- if (prim == GL_QUAD_STRIP)
- return length > 3 ? (length - length % 2) : 0;
- else if (prim == GL_QUADS)
- return length - length % 4;
- else
- return length;
-}
-
-static void brw_emit_prim(struct brw_context *brw,
- const struct _mesa_prim *prim,
- uint32_t hw_prim)
+static int brw_emit_prim(struct brw_context *brw,
+ unsigned start,
+ unsigned count,
+ boolean indexed,
+ uint32_t hw_prim)
{
struct brw_3d_primitive prim_packet;
+ int ret;
- if (INTEL_DEBUG & DEBUG_PRIMS)
- _mesa_printf("PRIM: %s %d %d\n", _mesa_lookup_enum_by_nr(prim->mode),
- prim->start, prim->count);
+ if (BRW_DEBUG & DEBUG_PRIMS)
+ debug_printf("%s start %d count %d indexed %d hw_prim %d\n",
+ __FUNCTION__, start, count, indexed, hw_prim);
prim_packet.header.opcode = CMD_3D_PRIM;
prim_packet.header.length = sizeof(prim_packet)/4 - 2;
prim_packet.header.pad = 0;
prim_packet.header.topology = hw_prim;
- prim_packet.header.indexed = prim->indexed;
+ prim_packet.header.indexed = indexed;
- prim_packet.verts_per_instance = trim(prim->mode, prim->count);
- prim_packet.start_vert_location = prim->start;
- if (prim->indexed)
+ prim_packet.verts_per_instance = count;
+ prim_packet.start_vert_location = start;
+ if (indexed)
prim_packet.start_vert_location += brw->ib.start_vertex_offset;
prim_packet.instance_count = 1;
prim_packet.start_instance_location = 0;
- prim_packet.base_vert_location = prim->basevertex;
+ prim_packet.base_vert_location = 0; /* prim->basevertex; XXX: add this to gallium */
- /* Can't wrap here, since we rely on the validated state. */
- brw->no_batch_wrap = GL_TRUE;
/* If we're set to always flush, do it before and after the primitive emit.
* We want to catch both missed flushes that hurt instruction/state cache
* and missed flushes of the render cache as it heads to other parts of
* the besides the draw code.
*/
- if (intel->always_flush_cache) {
+ if (0) {
BEGIN_BATCH(1, IGNORE_CLIPRECTS);
- OUT_BATCH(intel->vtbl.flush_cmd());
+ OUT_BATCH((CMD_MI_FLUSH << 16) | BRW_FLUSH_STATE_CACHE);
ADVANCE_BATCH();
}
if (prim_packet.verts_per_instance) {
- brw_batchbuffer_data( brw->intel.batch, &prim_packet,
- sizeof(prim_packet), LOOP_CLIPRECTS);
+ ret = brw_batchbuffer_data( brw->batch, &prim_packet,
+ sizeof(prim_packet), LOOP_CLIPRECTS);
+ if (ret)
+ return ret;
}
- if (intel->always_flush_cache) {
+ if (0) {
BEGIN_BATCH(1, IGNORE_CLIPRECTS);
- OUT_BATCH(intel->vtbl.flush_cmd());
+ OUT_BATCH((CMD_MI_FLUSH << 16) | BRW_FLUSH_STATE_CACHE);
ADVANCE_BATCH();
}
- brw->no_batch_wrap = GL_FALSE;
+ return 0;
}
-static void brw_merge_inputs( struct brw_context *brw,
- const struct gl_client_array *arrays[])
-{
- struct brw_vertex_info old = brw->vb.info;
- GLuint i;
-
- for (i = 0; i < VERT_ATTRIB_MAX; i++)
- brw->sws->bo_unreference(brw->vb.inputs[i].bo);
-
- memset(&brw->vb.inputs, 0, sizeof(brw->vb.inputs));
- memset(&brw->vb.info, 0, sizeof(brw->vb.info));
-
- for (i = 0; i < VERT_ATTRIB_MAX; i++) {
- brw->vb.inputs[i].glarray = arrays[i];
- brw->vb.inputs[i].attrib = (gl_vert_attrib) i;
-
- if (arrays[i]->StrideB != 0)
- brw->vb.info.sizes[i/16] |= (brw->vb.inputs[i].glarray->Size - 1) <<
- ((i%16) * 2);
- }
-
- /* Raise statechanges if input sizes have changed. */
- if (memcmp(brw->vb.info.sizes, old.sizes, sizeof(old.sizes)) != 0)
- brw->state.dirty.brw |= BRW_NEW_INPUT_DIMENSIONS;
-}
/* May fail if out of video memory for texture or vbo upload, or on
* fallback conditions.
*/
-static GLboolean brw_try_draw_prims( struct brw_context *brw,
- const struct gl_client_array *arrays[],
- const struct _mesa_prim *prim,
- GLuint nr_prims,
- const struct _mesa_index_buffer *ib,
- GLuint min_index,
- GLuint max_index )
+static int
+try_draw_range_elements(struct brw_context *brw,
+ struct pipe_resource *index_buffer,
+ unsigned hw_prim,
+ unsigned start, unsigned count)
{
- struct brw_context *brw = brw_context(ctx);
- GLboolean retval = GL_FALSE;
- GLboolean warn = GL_FALSE;
- GLboolean first_time = GL_TRUE;
- uint32_t hw_prim;
- GLuint i;
-
- if (ctx->NewState)
- _mesa_update_state( ctx );
+ int ret;
- /* Bind all inputs, derive varying and size information:
- */
- brw_merge_inputs( brw, arrays );
-
- brw->ib.ib = ib;
- brw->state.dirty.brw |= BRW_NEW_INDICES;
-
- brw->vb.min_index = min_index;
- brw->vb.max_index = max_index;
- brw->state.dirty.brw |= BRW_NEW_VERTICES;
-
- hw_prim = brw_set_prim(brw, prim[i].mode);
-
- brw_validate_state(brw);
+ ret = brw_validate_state(brw);
+ if (ret)
+ return ret;
/* Check that we can fit our state in with our existing batchbuffer, or
* flush otherwise.
*/
- ret = dri_bufmgr_check_aperture_space(brw->state.validated_bos,
- brw->state.validated_bo_count);
+ ret = brw->sws->check_aperture_space(brw->sws,
+ brw->state.validated_bos,
+ brw->state.validated_bo_count);
if (ret)
return ret;
if (ret)
return ret;
- ret = brw_emit_prim(brw, &prim[i], hw_prim);
+ ret = brw_emit_prim(brw, start, count, index_buffer != NULL, hw_prim);
if (ret)
return ret;
- if (intel->always_flush_batch)
- brw_batchbuffer_flush(intel->batch);
+ if (brw->flags.always_flush_batch)
+ brw_context_flush( brw );
return 0;
}
-void brw_draw_prims( struct brw_context *brw,
- const struct gl_client_array *arrays[],
- const struct _mesa_prim *prim,
- GLuint nr_prims,
- const struct _mesa_index_buffer *ib,
- GLboolean index_bounds_valid,
- GLuint min_index,
- GLuint max_index )
+
+static void
+brw_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 mode, unsigned start, unsigned count)
{
- enum pipe_error ret;
+ struct brw_context *brw = brw_context(pipe);
+ int ret;
+ uint32_t hw_prim;
+
+ hw_prim = brw_set_prim(brw, mode);
+
+ if (BRW_DEBUG & DEBUG_PRIMS)
+ debug_printf("PRIM: %s start %d count %d index_buffer %p\n",
+ u_prim_name(mode), start, count, (void *)index_buffer);
+
+ assert(index_bias == 0);
- if (!vbo_all_varyings_in_vbos(arrays)) {
- if (!index_bounds_valid)
- vbo_get_minmax_index(ctx, prim, ib, &min_index, &max_index);
+ /* Potentially trigger upload of new index buffer.
+ *
+ * XXX: do we need to go through state validation to achieve this?
+ * Could just call upload code directly.
+ */
+ if (brw->curr.index_buffer != index_buffer ||
+ brw->curr.index_size != index_size) {
+ pipe_resource_reference( &brw->curr.index_buffer, index_buffer );
+ brw->curr.index_size = index_size;
+ brw->state.dirty.mesa |= PIPE_NEW_INDEX_BUFFER;
+ }
+
+ /* XXX: do we really care?
+ */
+ if (brw->curr.min_index != min_index ||
+ brw->curr.max_index != max_index)
+ {
+ brw->curr.min_index = min_index;
+ brw->curr.max_index = max_index;
+ brw->state.dirty.mesa |= PIPE_NEW_INDEX_RANGE;
}
+
/* Make a first attempt at drawing:
*/
- ret = brw_try_draw_prims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);
+ ret = try_draw_range_elements(brw, index_buffer, hw_prim, start, count );
/* Otherwise, flush and retry:
*/
if (ret != 0) {
- brw_batchbuffer_flush(intel->batch);
- ret = brw_try_draw_prims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);
+ brw_context_flush( brw );
+ ret = try_draw_range_elements(brw, index_buffer, hw_prim, start, count );
assert(ret == 0);
}
}
-void brw_draw_init( struct brw_context *brw )
+static void
+brw_draw_elements(struct pipe_context *pipe,
+ struct pipe_resource *index_buffer,
+ unsigned index_size, int index_bias,
+ unsigned mode,
+ unsigned start, unsigned count)
+{
+ brw_draw_range_elements( pipe, index_buffer,
+ index_size, index_bias,
+ 0, 0xffffffff,
+ mode,
+ start, count );
+}
+
+static void
+brw_draw_arrays(struct pipe_context *pipe, unsigned mode,
+ unsigned start, unsigned count)
{
- struct vbo_context *vbo = vbo_context(ctx);
+ brw_draw_elements(pipe, NULL, 0, 0, mode, start, count);
+}
+
+
+boolean brw_draw_init( struct brw_context *brw )
+{
/* Register our drawing function:
*/
- vbo->draw_prims = brw_draw_prims;
+ brw->base.draw_arrays = brw_draw_arrays;
+ brw->base.draw_elements = brw_draw_elements;
+ brw->base.draw_range_elements = brw_draw_range_elements;
+
+ /* Create helpers for uploading data in user buffers:
+ */
+ brw->vb.upload_vertex = u_upload_create( &brw->base,
+ 128 * 1024,
+ 64,
+ PIPE_BIND_VERTEX_BUFFER );
+ if (brw->vb.upload_vertex == NULL)
+ return FALSE;
+
+ brw->vb.upload_index = u_upload_create( &brw->base,
+ 32 * 1024,
+ 64,
+ PIPE_BIND_INDEX_BUFFER );
+ if (brw->vb.upload_index == NULL)
+ return FALSE;
+
+ return TRUE;
}
-void brw_draw_destroy( struct brw_context *brw )
+void brw_draw_cleanup( struct brw_context *brw )
{
- int i;
-
- if (brw->vb.upload.bo != NULL) {
- brw->sws->bo_unreference(brw->vb.upload.bo);
- brw->vb.upload.bo = NULL;
- }
-
- for (i = 0; i < VERT_ATTRIB_MAX; i++) {
- brw->sws->bo_unreference(brw->vb.inputs[i].bo);
- brw->vb.inputs[i].bo = NULL;
- }
+ u_upload_destroy( brw->vb.upload_vertex );
+ u_upload_destroy( brw->vb.upload_index );
- brw->sws->bo_unreference(brw->ib.bo);
- brw->ib.bo = NULL;
+ bo_reference(&brw->ib.bo, NULL);
}
projects / mesa.git / blobdiff