1 /**************************************************************************
3 * Copyright 2007 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 **************************************************************************/
30 * Build post-transformation, post-clipping vertex buffers and element
31 * lists by hooking into the end of the primitive pipeline and
32 * manipulating the vertex_id field in the vertex headers.
34 * XXX: work in progress
36 * \author José Fonseca <jrfonseca@tungstengraphics.com>
37 * \author Keith Whitwell <keith@tungstengraphics.com>
41 #include "draw/draw_context.h"
42 #include "draw/draw_vbuf.h"
43 #include "util/u_debug.h"
44 #include "util/u_inlines.h"
45 #include "util/u_math.h"
46 #include "util/u_memory.h"
47 #include "util/u_fifo.h"
49 #include "i915_context.h"
51 #include "i915_batch.h"
52 #include "i915_state.h"
55 #define VBUF_MAP_BUFFER
58 * Primitive renderer for i915.
60 struct i915_vbuf_render
{
61 struct vbuf_render base
;
63 struct i915_context
*i915
;
65 /** Vertex size in bytes */
68 /** Software primitive */
71 /** Hardware primitive */
74 /** Genereate a vertex list */
77 /* Stuff for the vbo */
78 struct i915_winsys_buffer
*vbo
;
79 size_t vbo_size
; /**< current size of allocated buffer */
80 size_t vbo_alloc_size
; /**< minimum buffer size to allocate */
81 size_t vbo_hw_offset
; /**< offset that we program the hardware with */
82 size_t vbo_sw_offset
; /**< offset that we work with */
83 size_t vbo_index
; /**< index offset to be added to all indices */
86 size_t vbo_max_index
; /**< index offset to be added to all indices */
88 #ifndef VBUF_MAP_BUFFER
89 size_t map_used_start
;
97 * Basically a cast wrapper.
99 static INLINE
struct i915_vbuf_render
*
100 i915_vbuf_render(struct vbuf_render
*render
)
103 return (struct i915_vbuf_render
*)render
;
107 * If vbo state differs between renderer and context
108 * push state to the context. This function pushes
109 * hw_offset to i915->vbo_offset and vbo to i915->vbo.
112 * May updates context vbo_offset and vbo fields.
115 i915_vbuf_update_vbo_state(struct vbuf_render
*render
)
117 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
118 struct i915_context
*i915
= i915_render
->i915
;
120 if (i915
->vbo
!= i915_render
->vbo
||
121 i915
->vbo_offset
!= i915_render
->vbo_hw_offset
) {
122 i915
->vbo
= i915_render
->vbo
;
123 i915
->vbo_offset
= i915_render
->vbo_hw_offset
;
124 i915
->dirty
|= I915_NEW_VBO
;
129 * Callback exported to the draw module.
130 * Returns the current vertex_info.
133 * If state is dirty update derived state.
135 static const struct vertex_info
*
136 i915_vbuf_render_get_vertex_info(struct vbuf_render
*render
)
138 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
139 struct i915_context
*i915
= i915_render
->i915
;
142 /* make sure we have up to date vertex layout */
143 i915_update_derived(i915
);
146 return &i915
->current
.vertex_info
;
150 * Reserve space in the vbo for vertices.
156 i915_vbuf_render_reserve(struct i915_vbuf_render
*i915_render
, size_t size
)
158 struct i915_context
*i915
= i915_render
->i915
;
160 if (i915_render
->vbo_size
< size
+ i915_render
->vbo_sw_offset
)
163 if (i915
->vbo_flushed
)
170 * Allocate a new vbo buffer should there not be enough space for
171 * the requested number of vertices by the draw module.
174 * Updates hw_offset, sw_offset, index and allocates a new buffer.
177 i915_vbuf_render_new_buf(struct i915_vbuf_render
*i915_render
, size_t size
)
179 struct i915_context
*i915
= i915_render
->i915
;
180 struct i915_winsys
*iws
= i915
->iws
;
182 if (i915_render
->vbo
)
183 iws
->buffer_destroy(iws
, i915_render
->vbo
);
185 i915
->vbo_flushed
= 0;
187 i915_render
->vbo_size
= MAX2(size
, i915_render
->vbo_alloc_size
);
188 i915_render
->vbo_hw_offset
= 0;
189 i915_render
->vbo_sw_offset
= 0;
190 i915_render
->vbo_index
= 0;
192 #ifndef VBUF_MAP_BUFFER
193 if (i915_render
->vbo_size
> i915_render
->map_size
) {
194 i915_render
->map_size
= i915_render
->vbo_size
;
195 FREE(i915_render
->vbo_ptr
);
196 i915_render
->vbo_ptr
= MALLOC(i915_render
->map_size
);
200 i915_render
->vbo
= iws
->buffer_create(iws
, i915_render
->vbo_size
,
201 64, I915_NEW_VERTEX
);
205 * Callback exported to the draw module.
208 * Updates hw_offset, sw_offset, index and may allocate
209 * a new buffer. Also updates may update the vbo state
210 * on the i915 context.
213 i915_vbuf_render_allocate_vertices(struct vbuf_render
*render
,
217 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
218 size_t size
= (size_t)vertex_size
* (size_t)nr_vertices
;
222 * Align sw_offset with first multiple of vertex size from hw_offset.
223 * Set index to be the multiples from from hw_offset to sw_offset.
224 * i915_vbuf_render_new_buf will reset index, sw_offset, hw_offset
225 * when it allocates a new buffer this is correct.
228 offset
= i915_render
->vbo_sw_offset
- i915_render
->vbo_hw_offset
;
229 offset
= util_align_npot(offset
, vertex_size
);
230 i915_render
->vbo_sw_offset
= i915_render
->vbo_hw_offset
+ offset
;
231 i915_render
->vbo_index
= offset
/ vertex_size
;
234 if (!i915_vbuf_render_reserve(i915_render
, size
))
235 i915_vbuf_render_new_buf(i915_render
, size
);
238 * If a new buffer has been alocated sw_offset,
239 * hw_offset & index will be reset by new_buf
242 i915_render
->vertex_size
= vertex_size
;
244 i915_vbuf_update_vbo_state(render
);
246 if (!i915_render
->vbo
)
252 i915_vbuf_render_map_vertices(struct vbuf_render
*render
)
254 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
255 struct i915_context
*i915
= i915_render
->i915
;
256 struct i915_winsys
*iws
= i915
->iws
;
258 if (i915
->vbo_flushed
)
259 debug_printf("%s bad vbo flush occured stalling on hw\n", __FUNCTION__
);
261 #ifdef VBUF_MAP_BUFFER
262 i915_render
->vbo_ptr
= iws
->buffer_map(iws
, i915_render
->vbo
, TRUE
);
263 return (unsigned char *)i915_render
->vbo_ptr
+ i915_render
->vbo_sw_offset
;
266 return (unsigned char *)i915_render
->vbo_ptr
;
271 i915_vbuf_render_unmap_vertices(struct vbuf_render
*render
,
275 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
276 struct i915_context
*i915
= i915_render
->i915
;
277 struct i915_winsys
*iws
= i915
->iws
;
279 i915_render
->vbo_max_index
= max_index
;
280 i915_render
->vbo_max_used
= MAX2(i915_render
->vbo_max_used
, i915_render
->vertex_size
* (max_index
+ 1));
281 #ifdef VBUF_MAP_BUFFER
282 iws
->buffer_unmap(iws
, i915_render
->vbo
);
284 i915_render
->map_used_start
= i915_render
->vertex_size
* min_index
;
285 i915_render
->map_used_end
= i915_render
->vertex_size
* (max_index
+ 1);
286 iws
->buffer_write(iws
, i915_render
->vbo
,
287 i915_render
->map_used_start
+ i915_render
->vbo_sw_offset
,
288 i915_render
->map_used_end
- i915_render
->map_used_start
,
289 (unsigned char *)i915_render
->vbo_ptr
+ i915_render
->map_used_start
);
295 * Ensure that the given max_index given is not larger ushort max.
296 * If it is larger then ushort max it advanced the hw_offset to the
297 * same position in the vbo as sw_offset and set index to zero.
300 * On failure update hw_offset and index.
303 i915_vbuf_ensure_index_bounds(struct vbuf_render
*render
,
306 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
308 if (max_index
+ i915_render
->vbo_index
< ((1 << 17) - 1))
311 i915_render
->vbo_hw_offset
= i915_render
->vbo_sw_offset
;
312 i915_render
->vbo_index
= 0;
314 i915_vbuf_update_vbo_state(render
);
318 i915_vbuf_render_set_primitive(struct vbuf_render
*render
,
321 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
322 i915_render
->prim
= prim
;
325 case PIPE_PRIM_POINTS
:
326 i915_render
->hwprim
= PRIM3D_POINTLIST
;
327 i915_render
->fallback
= 0;
329 case PIPE_PRIM_LINES
:
330 i915_render
->hwprim
= PRIM3D_LINELIST
;
331 i915_render
->fallback
= 0;
333 case PIPE_PRIM_LINE_LOOP
:
334 i915_render
->hwprim
= PRIM3D_LINELIST
;
335 i915_render
->fallback
= PIPE_PRIM_LINE_LOOP
;
337 case PIPE_PRIM_LINE_STRIP
:
338 i915_render
->hwprim
= PRIM3D_LINESTRIP
;
339 i915_render
->fallback
= 0;
341 case PIPE_PRIM_TRIANGLES
:
342 i915_render
->hwprim
= PRIM3D_TRILIST
;
343 i915_render
->fallback
= 0;
345 case PIPE_PRIM_TRIANGLE_STRIP
:
346 i915_render
->hwprim
= PRIM3D_TRISTRIP
;
347 i915_render
->fallback
= 0;
349 case PIPE_PRIM_TRIANGLE_FAN
:
350 i915_render
->hwprim
= PRIM3D_TRIFAN
;
351 i915_render
->fallback
= 0;
353 case PIPE_PRIM_QUADS
:
354 i915_render
->hwprim
= PRIM3D_TRILIST
;
355 i915_render
->fallback
= PIPE_PRIM_QUADS
;
357 case PIPE_PRIM_QUAD_STRIP
:
358 i915_render
->hwprim
= PRIM3D_TRILIST
;
359 i915_render
->fallback
= PIPE_PRIM_QUAD_STRIP
;
361 case PIPE_PRIM_POLYGON
:
362 i915_render
->hwprim
= PRIM3D_POLY
;
363 i915_render
->fallback
= 0;
366 /* FIXME: Actually, can handle a lot more just fine... */
372 * Used for fallbacks in draw_arrays
375 draw_arrays_generate_indices(struct vbuf_render
*render
,
376 unsigned start
, uint nr
,
379 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
380 struct i915_context
*i915
= i915_render
->i915
;
382 unsigned end
= start
+ nr
+ i915_render
->vbo_index
;
383 start
+= i915_render
->vbo_index
;
387 for (i
= start
; i
+1 < end
; i
+= 2)
388 OUT_BATCH((i
+0) | (i
+1) << 16);
392 case PIPE_PRIM_LINE_LOOP
:
394 for (i
= start
+ 1; i
< end
; i
++)
395 OUT_BATCH((i
-0) | (i
+0) << 16);
396 OUT_BATCH((i
-0) | ( start
) << 16);
399 case PIPE_PRIM_QUADS
:
400 for (i
= start
; i
+ 3 < end
; i
+= 4) {
401 OUT_BATCH((i
+0) | (i
+1) << 16);
402 OUT_BATCH((i
+3) | (i
+1) << 16);
403 OUT_BATCH((i
+2) | (i
+3) << 16);
406 case PIPE_PRIM_QUAD_STRIP
:
407 for (i
= start
; i
+ 3 < end
; i
+= 2) {
408 OUT_BATCH((i
+0) | (i
+1) << 16);
409 OUT_BATCH((i
+3) | (i
+2) << 16);
410 OUT_BATCH((i
+0) | (i
+3) << 16);
419 draw_arrays_calc_nr_indices(uint nr
, unsigned type
)
424 case PIPE_PRIM_LINE_LOOP
:
429 case PIPE_PRIM_QUADS
:
431 case PIPE_PRIM_QUAD_STRIP
:
432 return ((nr
- 2) / 2) * 6;
440 draw_arrays_fallback(struct vbuf_render
*render
,
444 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
445 struct i915_context
*i915
= i915_render
->i915
;
448 nr_indices
= draw_arrays_calc_nr_indices(nr
, i915_render
->fallback
);
452 i915_vbuf_ensure_index_bounds(render
, start
+ nr_indices
);
455 i915_update_derived(i915
);
457 if (i915
->hardware_dirty
)
458 i915_emit_hardware_state(i915
);
460 if (!BEGIN_BATCH(1 + (nr_indices
+ 1)/2, 1)) {
463 /* Make sure state is re-emitted after a flush:
465 i915_update_derived(i915
);
466 i915_emit_hardware_state(i915
);
467 i915
->vbo_flushed
= 1;
469 if (!BEGIN_BATCH(1 + (nr_indices
+ 1)/2, 1)) {
475 OUT_BATCH(_3DPRIMITIVE
|
477 i915_render
->hwprim
|
481 draw_arrays_generate_indices(render
, start
, nr
, i915_render
->fallback
);
488 i915_vbuf_render_draw_arrays(struct vbuf_render
*render
,
492 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
493 struct i915_context
*i915
= i915_render
->i915
;
495 if (i915_render
->fallback
) {
496 draw_arrays_fallback(render
, start
, nr
);
500 i915_vbuf_ensure_index_bounds(render
, start
+ nr
);
501 start
+= i915_render
->vbo_index
;
504 i915_update_derived(i915
);
506 if (i915
->hardware_dirty
)
507 i915_emit_hardware_state(i915
);
509 if (!BEGIN_BATCH(2, 0)) {
512 /* Make sure state is re-emitted after a flush:
514 i915_update_derived(i915
);
515 i915_emit_hardware_state(i915
);
516 i915
->vbo_flushed
= 1;
518 if (!BEGIN_BATCH(2, 0)) {
524 OUT_BATCH(_3DPRIMITIVE
|
526 PRIM_INDIRECT_SEQUENTIAL
|
527 i915_render
->hwprim
|
529 OUT_BATCH(start
); /* Beginning vertex index */
536 * Used for normal and fallback emitting of indices
537 * If type is zero normal operation assumed.
540 draw_generate_indices(struct vbuf_render
*render
,
541 const ushort
*indices
,
545 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
546 struct i915_context
*i915
= i915_render
->i915
;
548 unsigned o
= i915_render
->vbo_index
;
552 for (i
= 0; i
+ 1 < nr_indices
; i
+= 2) {
553 OUT_BATCH((o
+indices
[i
]) | (o
+indices
[i
+1]) << 16);
555 if (i
< nr_indices
) {
556 OUT_BATCH((o
+indices
[i
]));
559 case PIPE_PRIM_LINE_LOOP
:
560 if (nr_indices
>= 2) {
561 for (i
= 1; i
< nr_indices
; i
++)
562 OUT_BATCH((o
+indices
[i
-1]) | (o
+indices
[i
]) << 16);
563 OUT_BATCH((o
+indices
[i
-1]) | (o
+indices
[0]) << 16);
566 case PIPE_PRIM_QUADS
:
567 for (i
= 0; i
+ 3 < nr_indices
; i
+= 4) {
568 OUT_BATCH((o
+indices
[i
+0]) | (o
+indices
[i
+1]) << 16);
569 OUT_BATCH((o
+indices
[i
+3]) | (o
+indices
[i
+1]) << 16);
570 OUT_BATCH((o
+indices
[i
+2]) | (o
+indices
[i
+3]) << 16);
573 case PIPE_PRIM_QUAD_STRIP
:
574 for (i
= 0; i
+ 3 < nr_indices
; i
+= 2) {
575 OUT_BATCH((o
+indices
[i
+0]) | (o
+indices
[i
+1]) << 16);
576 OUT_BATCH((o
+indices
[i
+3]) | (o
+indices
[i
+2]) << 16);
577 OUT_BATCH((o
+indices
[i
+0]) | (o
+indices
[i
+3]) << 16);
587 draw_calc_nr_indices(uint nr_indices
, unsigned type
)
592 case PIPE_PRIM_LINE_LOOP
:
594 return nr_indices
* 2;
597 case PIPE_PRIM_QUADS
:
598 return (nr_indices
/ 4) * 6;
599 case PIPE_PRIM_QUAD_STRIP
:
600 return ((nr_indices
- 2) / 2) * 6;
608 i915_vbuf_render_draw_elements(struct vbuf_render
*render
,
609 const ushort
*indices
,
612 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
613 struct i915_context
*i915
= i915_render
->i915
;
614 unsigned save_nr_indices
;
616 save_nr_indices
= nr_indices
;
618 nr_indices
= draw_calc_nr_indices(nr_indices
, i915_render
->fallback
);
622 i915_vbuf_ensure_index_bounds(render
, i915_render
->vbo_max_index
);
625 i915_update_derived(i915
);
627 if (i915
->hardware_dirty
)
628 i915_emit_hardware_state(i915
);
630 if (!BEGIN_BATCH(1 + (nr_indices
+ 1)/2, 1)) {
633 /* Make sure state is re-emitted after a flush:
635 i915_update_derived(i915
);
636 i915_emit_hardware_state(i915
);
637 i915
->vbo_flushed
= 1;
639 if (!BEGIN_BATCH(1 + (nr_indices
+ 1)/2, 1)) {
645 OUT_BATCH(_3DPRIMITIVE
|
647 i915_render
->hwprim
|
650 draw_generate_indices(render
,
653 i915_render
->fallback
);
660 i915_vbuf_render_release_vertices(struct vbuf_render
*render
)
662 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
664 i915_render
->vbo_sw_offset
+= i915_render
->vbo_max_used
;
665 i915_render
->vbo_max_used
= 0;
668 * Micro optimization, by calling update here we the offset change
669 * will be picked up on the next pipe_context::draw_*.
671 i915_vbuf_update_vbo_state(render
);
675 i915_vbuf_render_destroy(struct vbuf_render
*render
)
677 struct i915_vbuf_render
*i915_render
= i915_vbuf_render(render
);
682 * Create a new primitive render.
684 static struct vbuf_render
*
685 i915_vbuf_render_create(struct i915_context
*i915
)
687 struct i915_vbuf_render
*i915_render
= CALLOC_STRUCT(i915_vbuf_render
);
688 struct i915_winsys
*iws
= i915
->iws
;
691 i915_render
->i915
= i915
;
693 i915_render
->base
.max_vertex_buffer_bytes
= 16*4096;
695 /* NOTE: it must be such that state and vertices indices fit in a single
698 i915_render
->base
.max_indices
= 16*1024;
700 i915_render
->base
.get_vertex_info
= i915_vbuf_render_get_vertex_info
;
701 i915_render
->base
.allocate_vertices
= i915_vbuf_render_allocate_vertices
;
702 i915_render
->base
.map_vertices
= i915_vbuf_render_map_vertices
;
703 i915_render
->base
.unmap_vertices
= i915_vbuf_render_unmap_vertices
;
704 i915_render
->base
.set_primitive
= i915_vbuf_render_set_primitive
;
705 i915_render
->base
.draw_elements
= i915_vbuf_render_draw_elements
;
706 i915_render
->base
.draw_arrays
= i915_vbuf_render_draw_arrays
;
707 i915_render
->base
.release_vertices
= i915_vbuf_render_release_vertices
;
708 i915_render
->base
.destroy
= i915_vbuf_render_destroy
;
710 #ifndef VBUF_MAP_BUFFER
711 i915_render
->map_size
= 0;
712 i915_render
->map_used_start
= 0;
713 i915_render
->map_used_end
= 0;
716 i915_render
->vbo
= NULL
;
717 i915_render
->vbo_ptr
= NULL
;
718 i915_render
->vbo_size
= 0;
719 i915_render
->vbo_hw_offset
= 0;
720 i915_render
->vbo_sw_offset
= 0;
721 i915_render
->vbo_alloc_size
= i915_render
->base
.max_vertex_buffer_bytes
* 4;
724 i915_render
->pool_used
= FALSE
;
725 i915_render
->pool_buffer_size
= i915_render
->vbo_alloc_size
;
726 i915_render
->pool_fifo
= u_fifo_create(6);
727 for (i
= 0; i
< 6; i
++)
728 u_fifo_add(i915_render
->pool_fifo
,
729 iws
->buffer_create(iws
, i915_render
->pool_buffer_size
, 64,
736 return &i915_render
->base
;
740 * Create a new primitive vbuf/render stage.
742 struct draw_stage
*i915_draw_vbuf_stage(struct i915_context
*i915
)
744 struct vbuf_render
*render
;
745 struct draw_stage
*stage
;
747 render
= i915_vbuf_render_create(i915
);
751 stage
= draw_vbuf_stage(i915
->draw
, render
);
753 render
->destroy(render
);
756 /** TODO JB: this shouldn't be here */
757 draw_set_render(i915
->draw
, render
);