1 /**************************************************************************
3 * Copyright 2007 VMware, Inc.
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 VMWARE 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 <jfonseca@vmware.com>
33 * \author Keith Whitwell <keithw@vmware.com>
37 #include "util/u_debug.h"
38 #include "util/u_math.h"
39 #include "util/u_memory.h"
40 #include "draw_vbuf.h"
41 #include "draw_private.h"
42 #include "draw_vertex.h"
43 #include "draw_pipe.h"
44 #include "translate/translate.h"
45 #include "translate/translate_cache.h"
49 * Vertex buffer emit stage.
52 struct draw_stage stage
; /**< This must be first (base class) */
54 struct vbuf_render
*render
;
56 const struct vertex_info
*vinfo
;
58 /** Vertex size in bytes */
61 struct translate
*translate
;
63 /* FIXME: we have no guarantee that 'unsigned' is 32bit */
65 /** Vertices in hardware format */
68 unsigned max_vertices
;
76 /* Cache point size somewhere its 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
);
101 check_space(struct vbuf_stage
*vbuf
, unsigned nr
)
103 if (vbuf
->nr_vertices
+ nr
> vbuf
->max_vertices
||
104 vbuf
->nr_indices
+ nr
> vbuf
->max_indices
) {
105 vbuf_flush_vertices(vbuf
);
106 vbuf_alloc_vertices(vbuf
);
112 * Extract the needed fields from post-transformed vertex and emit
113 * a hardware(driver) vertex.
114 * Recall that the vertices are constructed by the 'draw' module and
115 * have a couple of slots at the beginning (1-dword header, 4-dword
116 * clip pos) that we ignore here. We only use the vertex->data[] fields.
119 emit_vertex(struct vbuf_stage
*vbuf
, struct vertex_header
*vertex
)
121 if (vertex
->vertex_id
== UNDEFINED_VERTEX_ID
&& vbuf
->vertex_ptr
) {
122 /* Hmm - vertices are emitted one at a time - better make sure
123 * set_buffer is efficient. Consider a special one-shot mode for
126 /* Note: we really do want data[0] here, not data[pos]:
128 vbuf
->translate
->set_buffer(vbuf
->translate
, 0, vertex
->data
[0], 0, ~0);
129 vbuf
->translate
->run(vbuf
->translate
, 0, 1, 0, 0, vbuf
->vertex_ptr
);
131 if (0) draw_dump_emitted_vertex(vbuf
->vinfo
, (uint8_t *)vbuf
->vertex_ptr
);
133 vbuf
->vertex_ptr
+= vbuf
->vertex_size
/4;
134 vertex
->vertex_id
= vbuf
->nr_vertices
++;
137 return (ushort
)vertex
->vertex_id
;
142 vbuf_tri(struct draw_stage
*stage
, struct prim_header
*prim
)
144 struct vbuf_stage
*vbuf
= vbuf_stage(stage
);
147 check_space(vbuf
, 3);
149 for (i
= 0; i
< 3; i
++) {
150 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex(vbuf
, prim
->v
[i
]);
156 vbuf_line(struct draw_stage
*stage
, struct prim_header
*prim
)
158 struct vbuf_stage
*vbuf
= vbuf_stage(stage
);
161 check_space(vbuf
, 2);
163 for (i
= 0; i
< 2; i
++) {
164 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex(vbuf
, prim
->v
[i
]);
170 vbuf_point(struct draw_stage
*stage
, struct prim_header
*prim
)
172 struct vbuf_stage
*vbuf
= vbuf_stage(stage
);
174 check_space(vbuf
, 1);
176 vbuf
->indices
[vbuf
->nr_indices
++] = emit_vertex(vbuf
, prim
->v
[0]);
181 * Set the prim type for subsequent vertices.
182 * This may result in a new vertex size. The existing vbuffer (if any)
183 * will be flushed if needed and a new one allocated.
186 vbuf_start_prim(struct vbuf_stage
*vbuf
, uint prim
)
188 struct translate_key hw_key
;
191 const struct vertex_info
*vinfo
;
193 vbuf
->render
->set_primitive(vbuf
->render
, prim
);
195 /* Must do this after set_primitive() above:
197 * XXX: need some state managment to track when this needs to be
198 * recalculated. The driver should tell us whether there was a
201 vbuf
->vinfo
= vbuf
->render
->get_vertex_info(vbuf
->render
);
203 vbuf
->vertex_size
= vinfo
->size
* sizeof(float);
205 /* Translate from pipeline vertices to hw vertices.
209 for (i
= 0; i
< vinfo
->num_attribs
; i
++) {
210 unsigned emit_sz
= 0;
211 unsigned src_buffer
= 0;
212 enum pipe_format output_format
;
213 unsigned src_offset
= (vinfo
->attrib
[i
].src_index
* 4 * sizeof(float));
215 output_format
= draw_translate_vinfo_format(vinfo
->attrib
[i
].emit
);
216 emit_sz
= draw_translate_vinfo_size(vinfo
->attrib
[i
].emit
);
218 /* doesn't handle EMIT_OMIT */
219 assert(emit_sz
!= 0);
221 if (vinfo
->attrib
[i
].emit
== EMIT_1F_PSIZE
) {
225 else if (vinfo
->attrib
[i
].src_index
== DRAW_ATTR_NONEXIST
) {
226 /* elements which don't exist will get assigned zeros */
231 hw_key
.element
[i
].type
= TRANSLATE_ELEMENT_NORMAL
;
232 hw_key
.element
[i
].input_format
= PIPE_FORMAT_R32G32B32A32_FLOAT
;
233 hw_key
.element
[i
].input_buffer
= src_buffer
;
234 hw_key
.element
[i
].input_offset
= src_offset
;
235 hw_key
.element
[i
].instance_divisor
= 0;
236 hw_key
.element
[i
].output_format
= output_format
;
237 hw_key
.element
[i
].output_offset
= dst_offset
;
239 dst_offset
+= emit_sz
;
242 hw_key
.nr_elements
= vinfo
->num_attribs
;
243 hw_key
.output_stride
= vbuf
->vertex_size
;
245 /* Don't bother with caching at this stage:
247 if (!vbuf
->translate
||
248 translate_key_compare(&vbuf
->translate
->key
, &hw_key
) != 0) {
249 translate_key_sanitize(&hw_key
);
250 vbuf
->translate
= translate_cache_find(vbuf
->cache
, &hw_key
);
252 vbuf
->translate
->set_buffer(vbuf
->translate
, 1, &vbuf
->point_size
, 0, ~0);
253 vbuf
->translate
->set_buffer(vbuf
->translate
, 2, &vbuf
->zero4
[0], 0, ~0);
256 vbuf
->point_size
= vbuf
->stage
.draw
->rasterizer
->point_size
;
258 /* Allocate new buffer?
260 assert(vbuf
->vertices
== NULL
);
261 vbuf_alloc_vertices(vbuf
);
266 vbuf_first_tri(struct draw_stage
*stage
, struct prim_header
*prim
)
268 struct vbuf_stage
*vbuf
= vbuf_stage(stage
);
270 vbuf_flush_vertices(vbuf
);
271 vbuf_start_prim(vbuf
, PIPE_PRIM_TRIANGLES
);
272 stage
->tri
= vbuf_tri
;
273 stage
->tri(stage
, prim
);
278 vbuf_first_line(struct draw_stage
*stage
, struct prim_header
*prim
)
280 struct vbuf_stage
*vbuf
= vbuf_stage(stage
);
282 vbuf_flush_vertices(vbuf
);
283 vbuf_start_prim(vbuf
, PIPE_PRIM_LINES
);
284 stage
->line
= vbuf_line
;
285 stage
->line(stage
, prim
);
290 vbuf_first_point(struct draw_stage
*stage
, struct prim_header
*prim
)
292 struct vbuf_stage
*vbuf
= vbuf_stage(stage
);
294 vbuf_flush_vertices(vbuf
);
295 vbuf_start_prim(vbuf
, PIPE_PRIM_POINTS
);
296 stage
->point
= vbuf_point
;
297 stage
->point(stage
, prim
);
303 * Flush existing vertex buffer and allocate a new one.
306 vbuf_flush_vertices(struct vbuf_stage
*vbuf
)
308 if (vbuf
->vertices
) {
309 vbuf
->render
->unmap_vertices(vbuf
->render
, 0, vbuf
->nr_vertices
- 1);
311 if (vbuf
->nr_indices
) {
312 vbuf
->render
->draw_elements(vbuf
->render
,
316 vbuf
->nr_indices
= 0;
319 /* Reset temporary vertices ids */
320 if (vbuf
->nr_vertices
)
321 draw_reset_vertex_ids(vbuf
->stage
.draw
);
323 /* Free the vertex buffer */
324 vbuf
->render
->release_vertices(vbuf
->render
);
326 vbuf
->max_vertices
= vbuf
->nr_vertices
= 0;
327 vbuf
->vertex_ptr
= vbuf
->vertices
= NULL
;
330 /* Reset point/line/tri function pointers.
331 * If (for example) we transition from points to tris and back to points
332 * again, we need to call the vbuf_first_point() function again to flush
333 * the triangles before drawing more points. This can happen when drawing
334 * with front polygon mode = filled and back polygon mode = line or point.
336 vbuf
->stage
.point
= vbuf_first_point
;
337 vbuf
->stage
.line
= vbuf_first_line
;
338 vbuf
->stage
.tri
= vbuf_first_tri
;
343 vbuf_alloc_vertices(struct vbuf_stage
*vbuf
)
345 if (vbuf
->vertex_ptr
) {
346 assert(!vbuf
->nr_indices
);
347 assert(!vbuf
->vertices
);
350 /* Allocate a new vertex buffer */
352 vbuf
->render
->max_vertex_buffer_bytes
/ vbuf
->vertex_size
;
354 if (vbuf
->max_vertices
>= UNDEFINED_VERTEX_ID
)
355 vbuf
->max_vertices
= UNDEFINED_VERTEX_ID
- 1;
357 /* Must always succeed -- driver gives us a
358 * 'max_vertex_buffer_bytes' which it guarantees it can allocate,
359 * and it will flush itself if necessary to do so. If this does
360 * fail, we are basically without usable hardware.
362 vbuf
->render
->allocate_vertices(vbuf
->render
,
363 (ushort
) vbuf
->vertex_size
,
364 (ushort
) vbuf
->max_vertices
);
366 vbuf
->vertices
= (uint
*) vbuf
->render
->map_vertices(vbuf
->render
);
368 vbuf
->vertex_ptr
= vbuf
->vertices
;
373 vbuf_flush(struct draw_stage
*stage
, unsigned flags
)
375 struct vbuf_stage
*vbuf
= vbuf_stage(stage
);
377 vbuf_flush_vertices(vbuf
);
382 vbuf_reset_stipple_counter(struct draw_stage
*stage
)
384 /* XXX: Need to do something here for hardware with linestipple.
391 vbuf_destroy(struct draw_stage
*stage
)
393 struct vbuf_stage
*vbuf
= vbuf_stage(stage
);
396 align_free(vbuf
->indices
);
399 vbuf
->render
->destroy(vbuf
->render
);
402 translate_cache_destroy(vbuf
->cache
);
409 * Create a new primitive vbuf/render stage.
412 draw_vbuf_stage(struct draw_context
*draw
, struct vbuf_render
*render
)
414 struct vbuf_stage
*vbuf
= CALLOC_STRUCT(vbuf_stage
);
418 vbuf
->stage
.draw
= draw
;
419 vbuf
->stage
.name
= "vbuf";
420 vbuf
->stage
.point
= vbuf_first_point
;
421 vbuf
->stage
.line
= vbuf_first_line
;
422 vbuf
->stage
.tri
= vbuf_first_tri
;
423 vbuf
->stage
.flush
= vbuf_flush
;
424 vbuf
->stage
.reset_stipple_counter
= vbuf_reset_stipple_counter
;
425 vbuf
->stage
.destroy
= vbuf_destroy
;
427 vbuf
->render
= render
;
428 vbuf
->max_indices
= MIN2(render
->max_indices
, UNDEFINED_VERTEX_ID
-1);
430 vbuf
->indices
= (ushort
*) align_malloc(vbuf
->max_indices
*
431 sizeof(vbuf
->indices
[0]),
436 vbuf
->cache
= translate_cache_create();
440 vbuf
->vertices
= NULL
;
441 vbuf
->vertex_ptr
= vbuf
->vertices
;
443 vbuf
->zero4
[0] = vbuf
->zero4
[1] = vbuf
->zero4
[2] = vbuf
->zero4
[3] = 0.0f
;
449 vbuf_destroy(&vbuf
->stage
);