1 /**************************************************************************
3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
28 #include "pipe/p_context.h"
29 #include "util/u_inlines.h"
31 #include "util/u_upload_mgr.h"
32 #include "util/u_math.h"
35 #include "brw_defines.h"
36 #include "brw_context.h"
37 #include "brw_state.h"
38 #include "brw_screen.h"
39 #include "brw_batchbuffer.h"
40 #include "brw_debug.h"
41 #include "brw_resource.h"
46 static unsigned get_index_type(int type)
49 case 1: return BRW_INDEX_BYTE;
50 case 2: return BRW_INDEX_WORD;
51 case 4: return BRW_INDEX_DWORD;
52 default: assert(0); return 0;
57 static int brw_prepare_vertices(struct brw_context *brw)
59 unsigned int min_index = brw->curr.min_index;
60 unsigned int max_index = brw->curr.max_index;
64 if (BRW_DEBUG & DEBUG_VERTS)
65 debug_printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
68 for (i = 0; i < brw->curr.num_vertex_buffers; i++) {
69 struct pipe_vertex_buffer *vb = &brw->curr.vertex_buffer[i];
70 struct brw_winsys_buffer *bo;
71 struct pipe_resource *upload_buf = NULL;
74 if (BRW_DEBUG & DEBUG_VERTS)
75 debug_printf("%s vb[%d] user:%d offset:0x%x sz:0x%x stride:0x%x\n",
77 brw_buffer_is_user_buffer(vb->buffer),
82 if (brw_buffer_is_user_buffer(vb->buffer)) {
84 /* XXX: simplify this. Stop the state trackers from generating
85 * zero-stride buffers & have them use additional constants (or
86 * add support for >1 constant buffer) instead.
88 unsigned size = (vb->stride == 0 ?
89 vb->buffer->width0 - vb->buffer_offset :
90 MAX2(vb->buffer->width0 - vb->buffer_offset,
91 vb->stride * (max_index + 1 - min_index)));
94 ret = u_upload_buffer( brw->vb.upload_vertex,
96 vb->buffer_offset + min_index * vb->stride,
105 bo = brw_buffer(upload_buf)->bo;
107 assert(offset + size <= bo->size);
111 offset = vb->buffer_offset;
112 bo = brw_buffer(vb->buffer)->bo;
115 assert(offset < bo->size);
117 /* Set up post-upload info about this vertex buffer:
119 brw->vb.vb[i].offset = offset;
120 brw->vb.vb[i].stride = vb->stride;
121 brw->vb.vb[i].vertex_count = (vb->stride == 0 ?
123 (bo->size - offset) / vb->stride);
125 bo_reference( &brw->vb.vb[i].bo, bo );
127 /* Don't need to retain this reference. We have a reference on
128 * the underlying winsys buffer:
130 pipe_resource_reference( &upload_buf, NULL );
134 brw_prepare_query_begin(brw);
136 for (i = 0; i < brw->vb.nr_vb; i++) {
137 brw_add_validated_bo(brw, brw->vb.vb[i].bo);
143 static int brw_emit_vertex_buffers( struct brw_context *brw )
147 /* If the VS doesn't read any inputs (calculating vertex position from
148 * a state variable for some reason, for example), just bail.
150 * The stale VB state stays in place, but they don't do anything unless
151 * a VE loads from them.
153 if (brw->vb.nr_vb == 0) {
154 if (BRW_DEBUG & DEBUG_VERTS)
155 debug_printf("%s: no active vertex buffers\n", __FUNCTION__);
160 /* Emit VB state packets.
162 BEGIN_BATCH(1 + brw->vb.nr_vb * 4, IGNORE_CLIPRECTS);
163 OUT_BATCH((CMD_VERTEX_BUFFER << 16) |
164 ((1 + brw->vb.nr_vb * 4) - 2));
166 for (i = 0; i < brw->vb.nr_vb; i++) {
167 OUT_BATCH((i << BRW_VB0_INDEX_SHIFT) |
168 BRW_VB0_ACCESS_VERTEXDATA |
169 (brw->vb.vb[i].stride << BRW_VB0_PITCH_SHIFT));
170 OUT_RELOC(brw->vb.vb[i].bo,
172 brw->vb.vb[i].offset);
174 OUT_RELOC(brw->vb.vb[i].bo,
176 brw->vb.vb[i].bo->size - 1);
178 OUT_BATCH(brw->vb.vb[i].stride ? brw->vb.vb[i].vertex_count : 0);
179 OUT_BATCH(0); /* Instance data step rate */
187 static int brw_emit_vertex_elements(struct brw_context *brw)
189 const struct brw_vertex_element_packet *brw_velems = brw->curr.velems;
190 unsigned size = brw_velems->header.length + 2;
192 /* why is this here */
193 brw_emit_query_begin(brw);
195 brw_batchbuffer_data(brw->batch, brw_velems, size * 4, IGNORE_CLIPRECTS);
201 static int brw_emit_vertices( struct brw_context *brw )
205 ret = brw_emit_vertex_buffers( brw );
209 /* XXX should separate this? */
210 ret = brw_emit_vertex_elements( brw );
218 const struct brw_tracked_state brw_vertices = {
220 .mesa = (PIPE_NEW_INDEX_RANGE |
221 PIPE_NEW_VERTEX_BUFFER |
222 PIPE_NEW_VERTEX_ELEMENT),
223 .brw = BRW_NEW_BATCH,
226 .prepare = brw_prepare_vertices,
227 .emit = brw_emit_vertices,
231 static int brw_prepare_indices(struct brw_context *brw)
233 struct pipe_resource *index_buffer = brw->curr.index_buffer;
234 struct pipe_resource *upload_buf = NULL;
235 struct brw_winsys_buffer *bo = NULL;
237 GLuint index_size, index_offset;
241 if (index_buffer == NULL)
244 if (BRW_DEBUG & DEBUG_VERTS)
245 debug_printf("%s: index_size:%d index_buffer->size:%d\n",
247 brw->curr.index_size,
248 brw->curr.index_buffer->width0);
250 ib_size = index_buffer->width0;
251 index_size = brw->curr.index_size;
252 index_offset = brw->curr.index_offset;
254 /* Turn userbuffer into a proper hardware buffer?
256 if (brw_buffer_is_user_buffer(index_buffer)) {
259 ret = u_upload_buffer( brw->vb.upload_index,
270 bo = brw_buffer(upload_buf)->bo;
272 /* XXX: annotate the userbuffer with the upload information so
273 * that successive calls don't get re-uploaded.
277 bo = brw_buffer(index_buffer)->bo;
279 offset = index_offset;
282 /* Use CMD_3D_PRIM's start_vertex_offset to avoid re-uploading the
283 * index buffer state when we're just moving the start index of our
286 * In gallium this will happen in the case where successive draw
287 * calls are made with (distinct?) userbuffers, but the upload_mgr
288 * places the data into a single winsys buffer.
290 * This statechange doesn't raise any state flags and is always
291 * just merged into the final draw packet:
294 assert((offset & (index_size - 1)) == 0);
295 brw->ib.start_vertex_offset = offset / index_size;
298 /* These statechanges trigger a new CMD_INDEX_BUFFER packet:
300 if (brw->ib.bo != bo ||
301 brw->ib.size != ib_size)
303 bo_reference(&brw->ib.bo, bo);
304 brw->ib.size = ib_size;
305 brw->state.dirty.brw |= BRW_NEW_INDEX_BUFFER;
308 pipe_resource_reference( &upload_buf, NULL );
309 brw_add_validated_bo(brw, brw->ib.bo);
313 const struct brw_tracked_state brw_indices = {
315 .mesa = PIPE_NEW_INDEX_BUFFER,
319 .prepare = brw_prepare_indices,
322 static int brw_emit_index_buffer(struct brw_context *brw)
324 /* Emit the indexbuffer packet:
328 struct brw_indexbuffer ib;
330 memset(&ib, 0, sizeof(ib));
332 ib.header.bits.opcode = CMD_INDEX_BUFFER;
333 ib.header.bits.length = sizeof(ib)/4 - 2;
334 ib.header.bits.index_format = get_index_type(brw->ib.size);
335 ib.header.bits.cut_index_enable = 0;
337 BEGIN_BATCH(4, IGNORE_CLIPRECTS);
338 OUT_BATCH( ib.header.dword );
339 OUT_RELOC(brw->ib.bo,
342 OUT_RELOC(brw->ib.bo,
344 brw->ib.offset + brw->ib.size - 1);
352 const struct brw_tracked_state brw_index_buffer = {
355 .brw = BRW_NEW_BATCH | BRW_NEW_INDEX_BUFFER,
358 .emit = brw_emit_index_buffer,