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 * Vertex buffer drawing stage.
32 * \author Jose Fonseca <jrfonsec@tungstengraphics.com>
33 * \author Keith Whitwell <keith@tungstengraphics.com>
37 #include "util/u_debug.h"
38 #include "util/u_math.h"
39 #include "util/u_memory.h"
41 #include "draw_vbuf.h"
42 #include "draw_private.h"
43 #include "draw_vertex.h"
44 #include "draw_pipe.h"
45 #include "translate/translate.h"
46 #include "translate/translate_cache.h"
50 * Vertex buffer emit stage.
53 struct draw_stage stage
; /**< This must be first (base class) */
55 struct vbuf_render
*render
;
57 const struct vertex_info
*vinfo
;
59 /** Vertex size in bytes */
62 struct translate
*translate
;
64 /* FIXME: we have no guarantee that 'unsigned' is 32bit */
66 /** Vertices in hardware format */
69 unsigned max_vertices
;
77 /* Cache point size somewhere it's address won't change:
81 struct translate_cache
*cache
;
86 * Basically a cast wrapper.
88 static INLINE
struct vbuf_stage
*
89 vbuf_stage( struct draw_stage
*stage
)
92 return (struct vbuf_stage
*)stage
;
96 static void vbuf_flush_vertices( struct vbuf_stage
*vbuf
);
97 static void vbuf_alloc_vertices( struct vbuf_stage
*vbuf
);
100 static INLINE boolean
101 overflow( void *map
, void *ptr
, unsigned bytes
, unsigned bufsz
)
103 unsigned long used
= (unsigned long) ((char *)ptr
- (char *)map
);
104 return (used
+ bytes
) > bufsz
;
109 check_space( struct vbuf_stage
*vbuf
, unsigned nr
)
111 if (vbuf
->nr_vertices
+ nr
> vbuf
->max_vertices
||
112 vbuf
->nr_indices
+ nr
> vbuf
->max_indices
)
114 vbuf_flush_vertices( vbuf
);
115 vbuf_alloc_vertices( vbuf
);
123 * Extract the needed fields from post-transformed vertex and emit
124 * a hardware(driver) vertex.
125 * Recall that the vertices are constructed by the 'draw' module and
126 * have a couple of slots at the beginning (1-dword header, 4-dword
127 * clip pos) that we ignore here. We only use the vertex->data[] fields.
130 emit_vertex( struct vbuf_stage
*vbuf
,
131 struct vertex_header
*vertex
)
133 if(vertex
->vertex_id
== UNDEFINED_VERTEX_ID
) {
134 /* Hmm - vertices are emitted one at a time - better make sure
135 * set_buffer is efficient. Consider a special one-shot mode for
138 /* Note: we really do want data[0] here, not data[pos]:
140 vbuf
->translate
->set_buffer(vbuf
->translate
, 0, vertex
->data
[0], 0);
141 vbuf
->translate
->run(vbuf
->translate
, 0, 1, vbuf
->vertex_ptr
);
143 if (0) draw_dump_emitted_vertex(vbuf
->vinfo
, (uint8_t *)vbuf
->vertex_ptr
);
145 vbuf
->vertex_ptr
+= vbuf
->vertex_size
/4;
146 vertex
->vertex_id
= vbuf
->nr_vertices
++;
149 return (ushort
)vertex
->vertex_id
;
154 vbuf_tri( struct draw_stage
*stage
,
155 struct prim_header
*prim
)
157 struct vbuf_stage
*vbuf
= vbuf_stage( stage
);
160 check_space( vbuf
, 3 );
162 if (vbuf
->stage
.draw
->rasterizer
->flatshade_first
) {
163 /* Put provoking vertex in position expected by the driver.
164 * Emit last provoking vertex in first pos.
165 * Swap verts 0 & 1 to preserve polygon winding.
167 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex( vbuf
, prim
->v
[2] );
168 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex( vbuf
, prim
->v
[0] );
169 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex( vbuf
, prim
->v
[1] );
172 for (i
= 0; i
< 3; i
++) {
173 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex( vbuf
, prim
->v
[i
] );
180 vbuf_line( struct draw_stage
*stage
,
181 struct prim_header
*prim
)
183 struct vbuf_stage
*vbuf
= vbuf_stage( stage
);
186 check_space( vbuf
, 2 );
188 for (i
= 0; i
< 2; i
++) {
189 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex( vbuf
, prim
->v
[i
] );
195 vbuf_point( struct draw_stage
*stage
,
196 struct prim_header
*prim
)
198 struct vbuf_stage
*vbuf
= vbuf_stage( stage
);
200 check_space( vbuf
, 1 );
202 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex( vbuf
, prim
->v
[0] );
209 * Set the prim type for subsequent vertices.
210 * This may result in a new vertex size. The existing vbuffer (if any)
211 * will be flushed if needed and a new one allocated.
214 vbuf_start_prim( struct vbuf_stage
*vbuf
, uint prim
)
216 struct translate_key hw_key
;
220 vbuf
->render
->set_primitive(vbuf
->render
, prim
);
222 /* Must do this after set_primitive() above:
224 * XXX: need some state managment to track when this needs to be
225 * recalculated. The driver should tell us whether there was a
228 vbuf
->vinfo
= vbuf
->render
->get_vertex_info(vbuf
->render
);
229 vbuf
->vertex_size
= vbuf
->vinfo
->size
* sizeof(float);
231 /* Translate from pipeline vertices to hw vertices.
235 for (i
= 0; i
< vbuf
->vinfo
->num_attribs
; i
++) {
236 unsigned emit_sz
= 0;
237 unsigned src_buffer
= 0;
238 unsigned output_format
;
239 unsigned src_offset
= (vbuf
->vinfo
->attrib
[i
].src_index
* 4 * sizeof(float) );
241 switch (vbuf
->vinfo
->attrib
[i
].emit
) {
243 output_format
= PIPE_FORMAT_R32G32B32A32_FLOAT
;
244 emit_sz
= 4 * sizeof(float);
247 output_format
= PIPE_FORMAT_R32G32B32_FLOAT
;
248 emit_sz
= 3 * sizeof(float);
251 output_format
= PIPE_FORMAT_R32G32_FLOAT
;
252 emit_sz
= 2 * sizeof(float);
255 output_format
= PIPE_FORMAT_R32_FLOAT
;
256 emit_sz
= 1 * sizeof(float);
259 output_format
= PIPE_FORMAT_R32_FLOAT
;
260 emit_sz
= 1 * sizeof(float);
265 output_format
= PIPE_FORMAT_B8G8R8A8_UNORM
;
266 emit_sz
= 4 * sizeof(ubyte
);
270 output_format
= PIPE_FORMAT_NONE
;
275 hw_key
.element
[i
].input_format
= PIPE_FORMAT_R32G32B32A32_FLOAT
;
276 hw_key
.element
[i
].input_buffer
= src_buffer
;
277 hw_key
.element
[i
].input_offset
= src_offset
;
278 hw_key
.element
[i
].output_format
= output_format
;
279 hw_key
.element
[i
].output_offset
= dst_offset
;
281 dst_offset
+= emit_sz
;
284 hw_key
.nr_elements
= vbuf
->vinfo
->num_attribs
;
285 hw_key
.output_stride
= vbuf
->vinfo
->size
* 4;
287 /* Don't bother with caching at this stage:
289 if (!vbuf
->translate
||
290 translate_key_compare(&vbuf
->translate
->key
, &hw_key
) != 0)
292 translate_key_sanitize(&hw_key
);
293 vbuf
->translate
= translate_cache_find(vbuf
->cache
, &hw_key
);
295 vbuf
->translate
->set_buffer(vbuf
->translate
, 1, &vbuf
->point_size
, 0);
298 vbuf
->point_size
= vbuf
->stage
.draw
->rasterizer
->point_size
;
300 /* Allocate new buffer?
302 assert(vbuf
->vertices
== NULL
);
303 vbuf_alloc_vertices(vbuf
);
308 vbuf_first_tri( struct draw_stage
*stage
,
309 struct prim_header
*prim
)
311 struct vbuf_stage
*vbuf
= vbuf_stage( stage
);
313 vbuf_flush_vertices( vbuf
);
314 vbuf_start_prim(vbuf
, PIPE_PRIM_TRIANGLES
);
315 stage
->tri
= vbuf_tri
;
316 stage
->tri( stage
, prim
);
321 vbuf_first_line( struct draw_stage
*stage
,
322 struct prim_header
*prim
)
324 struct vbuf_stage
*vbuf
= vbuf_stage( stage
);
326 vbuf_flush_vertices( vbuf
);
327 vbuf_start_prim(vbuf
, PIPE_PRIM_LINES
);
328 stage
->line
= vbuf_line
;
329 stage
->line( stage
, prim
);
334 vbuf_first_point( struct draw_stage
*stage
,
335 struct prim_header
*prim
)
337 struct vbuf_stage
*vbuf
= vbuf_stage( stage
);
339 vbuf_flush_vertices(vbuf
);
340 vbuf_start_prim(vbuf
, PIPE_PRIM_POINTS
);
341 stage
->point
= vbuf_point
;
342 stage
->point( stage
, prim
);
348 * Flush existing vertex buffer and allocate a new one.
351 vbuf_flush_vertices( struct vbuf_stage
*vbuf
)
355 vbuf
->render
->unmap_vertices( vbuf
->render
, 0, vbuf
->nr_vertices
- 1 );
357 if (vbuf
->nr_indices
)
359 vbuf
->render
->draw(vbuf
->render
,
363 vbuf
->nr_indices
= 0;
366 /* Reset temporary vertices ids */
367 if(vbuf
->nr_vertices
)
368 draw_reset_vertex_ids( vbuf
->stage
.draw
);
370 /* Free the vertex buffer */
371 vbuf
->render
->release_vertices( vbuf
->render
);
373 vbuf
->max_vertices
= vbuf
->nr_vertices
= 0;
374 vbuf
->vertex_ptr
= vbuf
->vertices
= NULL
;
380 vbuf_alloc_vertices( struct vbuf_stage
*vbuf
)
382 assert(!vbuf
->nr_indices
);
383 assert(!vbuf
->vertices
);
385 /* Allocate a new vertex buffer */
386 vbuf
->max_vertices
= vbuf
->render
->max_vertex_buffer_bytes
/ vbuf
->vertex_size
;
389 vbuf
->max_vertices
= vbuf
->max_vertices
& ~1;
391 if(vbuf
->max_vertices
>= UNDEFINED_VERTEX_ID
)
392 vbuf
->max_vertices
= UNDEFINED_VERTEX_ID
- 1;
394 /* Must always succeed -- driver gives us a
395 * 'max_vertex_buffer_bytes' which it guarantees it can allocate,
396 * and it will flush itself if necessary to do so. If this does
397 * fail, we are basically without usable hardware.
399 vbuf
->render
->allocate_vertices(vbuf
->render
,
400 (ushort
) vbuf
->vertex_size
,
401 (ushort
) vbuf
->max_vertices
);
403 vbuf
->vertices
= (uint
*) vbuf
->render
->map_vertices( vbuf
->render
);
405 vbuf
->vertex_ptr
= vbuf
->vertices
;
411 vbuf_flush( struct draw_stage
*stage
, unsigned flags
)
413 struct vbuf_stage
*vbuf
= vbuf_stage( stage
);
415 vbuf_flush_vertices( vbuf
);
417 stage
->point
= vbuf_first_point
;
418 stage
->line
= vbuf_first_line
;
419 stage
->tri
= vbuf_first_tri
;
424 vbuf_reset_stipple_counter( struct draw_stage
*stage
)
426 /* XXX: Need to do something here for hardware with linestipple.
432 static void vbuf_destroy( struct draw_stage
*stage
)
434 struct vbuf_stage
*vbuf
= vbuf_stage( stage
);
437 align_free( vbuf
->indices
);
440 vbuf
->render
->destroy( vbuf
->render
);
443 translate_cache_destroy(vbuf
->cache
);
450 * Create a new primitive vbuf/render stage.
452 struct draw_stage
*draw_vbuf_stage( struct draw_context
*draw
,
453 struct vbuf_render
*render
)
455 struct vbuf_stage
*vbuf
= CALLOC_STRUCT(vbuf_stage
);
459 vbuf
->stage
.draw
= draw
;
460 vbuf
->stage
.name
= "vbuf";
461 vbuf
->stage
.point
= vbuf_first_point
;
462 vbuf
->stage
.line
= vbuf_first_line
;
463 vbuf
->stage
.tri
= vbuf_first_tri
;
464 vbuf
->stage
.flush
= vbuf_flush
;
465 vbuf
->stage
.reset_stipple_counter
= vbuf_reset_stipple_counter
;
466 vbuf
->stage
.destroy
= vbuf_destroy
;
468 vbuf
->render
= render
;
469 vbuf
->max_indices
= MAX2(render
->max_indices
, UNDEFINED_VERTEX_ID
-1);
471 vbuf
->indices
= (ushort
*) align_malloc( vbuf
->max_indices
*
472 sizeof(vbuf
->indices
[0]),
477 vbuf
->cache
= translate_cache_create();
482 vbuf
->vertices
= NULL
;
483 vbuf
->vertex_ptr
= vbuf
->vertices
;
489 vbuf_destroy(&vbuf
->stage
);