1 /**************************************************************************
3 * Copyright 2011 Marek Olšák <maraeo@gmail.com>
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 AUTHORS 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 "util/u_vbuf_mgr.h"
30 #include "util/u_format.h"
31 #include "util/u_inlines.h"
32 #include "util/u_memory.h"
33 #include "util/u_upload_mgr.h"
34 #include "translate/translate.h"
35 #include "translate/translate_cache.h"
37 /* Hardware vertex fetcher limitations can be described by this structure. */
39 /* Vertex format CAPs. */
40 /* TRUE if hardware supports it. */
41 unsigned format_fixed32
:1; /* PIPE_FORMAT_*32*_FIXED */
42 unsigned format_float16
:1; /* PIPE_FORMAT_*16*_FLOAT */
43 unsigned format_float64
:1; /* PIPE_FORMAT_*64*_FLOAT */
44 unsigned format_norm32
:1; /* PIPE_FORMAT_*32*NORM */
45 unsigned format_scaled32
:1; /* PIPE_FORMAT_*32*SCALED */
47 /* Whether vertex fetches don't have to be dword-aligned. */
48 /* TRUE if hardware supports it. */
49 unsigned fetch_dword_unaligned
:1;
52 struct u_vbuf_mgr_elements
{
54 struct pipe_vertex_element ve
[PIPE_MAX_ATTRIBS
];
56 /* If (velem[i].src_format != real_format[i]), the vertex buffer
57 * referenced by the vertex element cannot be used for rendering and
58 * its vertex data must be translated to real_format[i]. */
59 enum pipe_format native_format
[PIPE_MAX_ATTRIBS
];
60 unsigned native_format_size
[PIPE_MAX_ATTRIBS
];
62 /* This might mean two things:
63 * - src_format != native_format, as discussed above.
64 * - src_offset % 4 != 0 (if the caps don't allow such an offset). */
65 boolean incompatible_layout
;
68 struct u_vbuf_mgr_priv
{
70 struct u_vbuf_caps caps
;
71 struct pipe_context
*pipe
;
73 struct translate_cache
*translate_cache
;
74 unsigned translate_vb_slot
;
76 struct u_vbuf_mgr_elements
*ve
;
77 void *saved_ve
, *fallback_ve
;
78 boolean ve_binding_lock
;
81 boolean incompatible_vb_layout
;
84 static void u_vbuf_mgr_init_format_caps(struct u_vbuf_mgr_priv
*mgr
)
86 struct pipe_screen
*screen
= mgr
->pipe
->screen
;
88 mgr
->caps
.format_fixed32
=
89 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_FIXED
, PIPE_BUFFER
,
90 0, PIPE_BIND_VERTEX_BUFFER
);
92 mgr
->caps
.format_float16
=
93 screen
->is_format_supported(screen
, PIPE_FORMAT_R16_FLOAT
, PIPE_BUFFER
,
94 0, PIPE_BIND_VERTEX_BUFFER
);
96 mgr
->caps
.format_float64
=
97 screen
->is_format_supported(screen
, PIPE_FORMAT_R64_FLOAT
, PIPE_BUFFER
,
98 0, PIPE_BIND_VERTEX_BUFFER
);
100 mgr
->caps
.format_norm32
=
101 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_UNORM
, PIPE_BUFFER
,
102 0, PIPE_BIND_VERTEX_BUFFER
) &&
103 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_SNORM
, PIPE_BUFFER
,
104 0, PIPE_BIND_VERTEX_BUFFER
);
106 mgr
->caps
.format_scaled32
=
107 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_USCALED
, PIPE_BUFFER
,
108 0, PIPE_BIND_VERTEX_BUFFER
) &&
109 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_SSCALED
, PIPE_BUFFER
,
110 0, PIPE_BIND_VERTEX_BUFFER
);
114 u_vbuf_mgr_create(struct pipe_context
*pipe
,
115 unsigned upload_buffer_size
,
116 unsigned upload_buffer_alignment
,
117 unsigned upload_buffer_bind
,
118 enum u_fetch_alignment fetch_alignment
)
120 struct u_vbuf_mgr_priv
*mgr
= CALLOC_STRUCT(u_vbuf_mgr_priv
);
123 mgr
->translate_cache
= translate_cache_create();
125 mgr
->b
.uploader
= u_upload_create(pipe
, upload_buffer_size
,
126 upload_buffer_alignment
,
129 mgr
->caps
.fetch_dword_unaligned
=
130 fetch_alignment
== U_VERTEX_FETCH_BYTE_ALIGNED
;
132 u_vbuf_mgr_init_format_caps(mgr
);
137 void u_vbuf_mgr_destroy(struct u_vbuf_mgr
*mgrb
)
139 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
142 for (i
= 0; i
< mgr
->b
.nr_real_vertex_buffers
; i
++) {
143 pipe_resource_reference(&mgr
->b
.vertex_buffer
[i
].buffer
, NULL
);
144 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[i
], NULL
);
147 translate_cache_destroy(mgr
->translate_cache
);
148 u_upload_destroy(mgr
->b
.uploader
);
153 static void u_vbuf_translate_begin(struct u_vbuf_mgr_priv
*mgr
,
154 int min_index
, int max_index
,
155 boolean
*upload_flushed
)
157 struct translate_key key
;
158 struct translate_element
*te
;
159 unsigned tr_elem_index
[PIPE_MAX_ATTRIBS
];
160 struct translate
*tr
;
161 boolean vb_translated
[PIPE_MAX_ATTRIBS
] = {0};
162 uint8_t *vb_map
[PIPE_MAX_ATTRIBS
] = {0}, *out_map
;
163 struct pipe_transfer
*vb_transfer
[PIPE_MAX_ATTRIBS
] = {0};
164 struct pipe_resource
*out_buffer
= NULL
;
165 unsigned i
, num_verts
, out_offset
;
166 struct pipe_vertex_element new_velems
[PIPE_MAX_ATTRIBS
];
168 memset(&key
, 0, sizeof(key
));
169 memset(tr_elem_index
, 0xff, sizeof(tr_elem_index
));
171 /* Initialize the translate key, i.e. the recipe how vertices should be
173 memset(&key
, 0, sizeof key
);
174 for (i
= 0; i
< mgr
->ve
->count
; i
++) {
175 struct pipe_vertex_buffer
*vb
=
176 &mgr
->b
.vertex_buffer
[mgr
->ve
->ve
[i
].vertex_buffer_index
];
177 enum pipe_format output_format
= mgr
->ve
->native_format
[i
];
178 unsigned output_format_size
= mgr
->ve
->native_format_size
[i
];
180 /* Check for support. */
181 if (mgr
->ve
->ve
[i
].src_format
== mgr
->ve
->native_format
[i
] &&
182 (mgr
->caps
.fetch_dword_unaligned
||
183 (vb
->buffer_offset
% 4 == 0 &&
184 vb
->stride
% 4 == 0 &&
185 mgr
->ve
->ve
[i
].src_offset
% 4 == 0))) {
189 /* Workaround for translate: output floats instead of halfs. */
190 switch (output_format
) {
191 case PIPE_FORMAT_R16_FLOAT
:
192 output_format
= PIPE_FORMAT_R32_FLOAT
;
193 output_format_size
= 4;
195 case PIPE_FORMAT_R16G16_FLOAT
:
196 output_format
= PIPE_FORMAT_R32G32_FLOAT
;
197 output_format_size
= 8;
199 case PIPE_FORMAT_R16G16B16_FLOAT
:
200 output_format
= PIPE_FORMAT_R32G32B32_FLOAT
;
201 output_format_size
= 12;
203 case PIPE_FORMAT_R16G16B16A16_FLOAT
:
204 output_format
= PIPE_FORMAT_R32G32B32A32_FLOAT
;
205 output_format_size
= 16;
210 /* Add this vertex element. */
211 te
= &key
.element
[key
.nr_elements
];
213 te->instance_divisor;*/
214 te
->input_buffer
= mgr
->ve
->ve
[i
].vertex_buffer_index
;
215 te
->input_format
= mgr
->ve
->ve
[i
].src_format
;
216 te
->input_offset
= mgr
->ve
->ve
[i
].src_offset
;
217 te
->output_format
= output_format
;
218 te
->output_offset
= key
.output_stride
;
220 key
.output_stride
+= output_format_size
;
221 vb_translated
[mgr
->ve
->ve
[i
].vertex_buffer_index
] = TRUE
;
222 tr_elem_index
[i
] = key
.nr_elements
;
226 /* Get a translate object. */
227 tr
= translate_cache_find(mgr
->translate_cache
, &key
);
229 /* Map buffers we want to translate. */
230 for (i
= 0; i
< mgr
->b
.nr_vertex_buffers
; i
++) {
231 if (vb_translated
[i
]) {
232 struct pipe_vertex_buffer
*vb
= &mgr
->b
.vertex_buffer
[i
];
234 vb_map
[i
] = pipe_buffer_map(mgr
->pipe
, vb
->buffer
,
235 PIPE_TRANSFER_READ
, &vb_transfer
[i
]);
237 tr
->set_buffer(tr
, i
,
238 vb_map
[i
] + vb
->buffer_offset
+ vb
->stride
* min_index
,
243 /* Create and map the output buffer. */
244 num_verts
= max_index
+ 1 - min_index
;
246 u_upload_alloc(mgr
->b
.uploader
,
247 key
.output_stride
* min_index
,
248 key
.output_stride
* num_verts
,
249 &out_offset
, &out_buffer
, upload_flushed
,
252 out_offset
-= key
.output_stride
* min_index
;
255 tr
->run(tr
, 0, num_verts
, 0, out_map
);
257 /* Unmap all buffers. */
258 for (i
= 0; i
< mgr
->b
.nr_vertex_buffers
; i
++) {
259 if (vb_translated
[i
]) {
260 pipe_buffer_unmap(mgr
->pipe
, vb_transfer
[i
]);
264 /* Setup the new vertex buffer in the first free slot. */
265 mgr
->translate_vb_slot
= ~0;
266 for (i
= 0; i
< PIPE_MAX_ATTRIBS
; i
++) {
267 if (!mgr
->b
.vertex_buffer
[i
].buffer
) {
268 mgr
->translate_vb_slot
= i
;
270 if (i
>= mgr
->b
.nr_vertex_buffers
) {
271 mgr
->b
.nr_real_vertex_buffers
= i
+1;
277 if (mgr
->translate_vb_slot
!= ~0) {
278 /* Setup the new vertex buffer. */
279 pipe_resource_reference(
280 &mgr
->b
.real_vertex_buffer
[mgr
->translate_vb_slot
], out_buffer
);
281 mgr
->b
.vertex_buffer
[mgr
->translate_vb_slot
].buffer_offset
= out_offset
;
282 mgr
->b
.vertex_buffer
[mgr
->translate_vb_slot
].stride
= key
.output_stride
;
284 /* Setup new vertex elements. */
285 for (i
= 0; i
< mgr
->ve
->count
; i
++) {
286 if (tr_elem_index
[i
] < key
.nr_elements
) {
287 te
= &key
.element
[tr_elem_index
[i
]];
288 new_velems
[i
].instance_divisor
= mgr
->ve
->ve
[i
].instance_divisor
;
289 new_velems
[i
].src_format
= te
->output_format
;
290 new_velems
[i
].src_offset
= te
->output_offset
;
291 new_velems
[i
].vertex_buffer_index
= mgr
->translate_vb_slot
;
293 memcpy(&new_velems
[i
], &mgr
->ve
->ve
[i
],
294 sizeof(struct pipe_vertex_element
));
299 mgr
->pipe
->create_vertex_elements_state(mgr
->pipe
, mgr
->ve
->count
,
302 /* Preserve saved_ve. */
303 mgr
->ve_binding_lock
= TRUE
;
304 mgr
->pipe
->bind_vertex_elements_state(mgr
->pipe
, mgr
->fallback_ve
);
305 mgr
->ve_binding_lock
= FALSE
;
308 pipe_resource_reference(&out_buffer
, NULL
);
311 static void u_vbuf_translate_end(struct u_vbuf_mgr_priv
*mgr
)
313 if (mgr
->fallback_ve
== NULL
) {
317 /* Restore vertex elements. */
318 /* Note that saved_ve will be overwritten in bind_vertex_elements_state. */
319 mgr
->pipe
->bind_vertex_elements_state(mgr
->pipe
, mgr
->saved_ve
);
320 mgr
->pipe
->delete_vertex_elements_state(mgr
->pipe
, mgr
->fallback_ve
);
321 mgr
->fallback_ve
= NULL
;
323 /* Delete the now-unused VBO. */
324 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[mgr
->translate_vb_slot
],
326 mgr
->b
.nr_real_vertex_buffers
= mgr
->b
.nr_vertex_buffers
;
329 #define FORMAT_REPLACE(what, withwhat) \
330 case PIPE_FORMAT_##what: format = PIPE_FORMAT_##withwhat; break
332 struct u_vbuf_mgr_elements
*
333 u_vbuf_mgr_create_vertex_elements(struct u_vbuf_mgr
*mgrb
,
335 const struct pipe_vertex_element
*attribs
,
336 struct pipe_vertex_element
*native_attribs
)
338 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
340 struct u_vbuf_mgr_elements
*ve
= CALLOC_STRUCT(u_vbuf_mgr_elements
);
348 memcpy(ve
->ve
, attribs
, sizeof(struct pipe_vertex_element
) * count
);
349 memcpy(native_attribs
, attribs
, sizeof(struct pipe_vertex_element
) * count
);
351 /* Set the best native format in case the original format is not
353 for (i
= 0; i
< count
; i
++) {
354 enum pipe_format format
= ve
->ve
[i
].src_format
;
356 /* Choose a native format.
357 * For now we don't care about the alignment, that's going to
358 * be sorted out later. */
359 if (!mgr
->caps
.format_fixed32
) {
361 FORMAT_REPLACE(R32_FIXED
, R32_FLOAT
);
362 FORMAT_REPLACE(R32G32_FIXED
, R32G32_FLOAT
);
363 FORMAT_REPLACE(R32G32B32_FIXED
, R32G32B32_FLOAT
);
364 FORMAT_REPLACE(R32G32B32A32_FIXED
, R32G32B32A32_FLOAT
);
368 if (!mgr
->caps
.format_float16
) {
370 FORMAT_REPLACE(R16_FLOAT
, R32_FLOAT
);
371 FORMAT_REPLACE(R16G16_FLOAT
, R32G32_FLOAT
);
372 FORMAT_REPLACE(R16G16B16_FLOAT
, R32G32B32_FLOAT
);
373 FORMAT_REPLACE(R16G16B16A16_FLOAT
, R32G32B32A32_FLOAT
);
377 if (!mgr
->caps
.format_float64
) {
379 FORMAT_REPLACE(R64_FLOAT
, R32_FLOAT
);
380 FORMAT_REPLACE(R64G64_FLOAT
, R32G32_FLOAT
);
381 FORMAT_REPLACE(R64G64B64_FLOAT
, R32G32B32_FLOAT
);
382 FORMAT_REPLACE(R64G64B64A64_FLOAT
, R32G32B32A32_FLOAT
);
386 if (!mgr
->caps
.format_norm32
) {
388 FORMAT_REPLACE(R32_UNORM
, R32_FLOAT
);
389 FORMAT_REPLACE(R32G32_UNORM
, R32G32_FLOAT
);
390 FORMAT_REPLACE(R32G32B32_UNORM
, R32G32B32_FLOAT
);
391 FORMAT_REPLACE(R32G32B32A32_UNORM
, R32G32B32A32_FLOAT
);
392 FORMAT_REPLACE(R32_SNORM
, R32_FLOAT
);
393 FORMAT_REPLACE(R32G32_SNORM
, R32G32_FLOAT
);
394 FORMAT_REPLACE(R32G32B32_SNORM
, R32G32B32_FLOAT
);
395 FORMAT_REPLACE(R32G32B32A32_SNORM
, R32G32B32A32_FLOAT
);
399 if (!mgr
->caps
.format_scaled32
) {
401 FORMAT_REPLACE(R32_USCALED
, R32_FLOAT
);
402 FORMAT_REPLACE(R32G32_USCALED
, R32G32_FLOAT
);
403 FORMAT_REPLACE(R32G32B32_USCALED
, R32G32B32_FLOAT
);
404 FORMAT_REPLACE(R32G32B32A32_USCALED
,R32G32B32A32_FLOAT
);
405 FORMAT_REPLACE(R32_SSCALED
, R32_FLOAT
);
406 FORMAT_REPLACE(R32G32_SSCALED
, R32G32_FLOAT
);
407 FORMAT_REPLACE(R32G32B32_SSCALED
, R32G32B32_FLOAT
);
408 FORMAT_REPLACE(R32G32B32A32_SSCALED
,R32G32B32A32_FLOAT
);
413 native_attribs
[i
].src_format
= format
;
414 ve
->native_format
[i
] = format
;
415 ve
->native_format_size
[i
] =
416 util_format_get_blocksize(ve
->native_format
[i
]);
418 ve
->incompatible_layout
=
419 ve
->incompatible_layout
||
420 ve
->ve
[i
].src_format
!= ve
->native_format
[i
] ||
421 (!mgr
->caps
.fetch_dword_unaligned
&& ve
->ve
[i
].src_offset
% 4 != 0);
424 /* Align the formats to the size of DWORD if needed. */
425 if (!mgr
->caps
.fetch_dword_unaligned
) {
426 for (i
= 0; i
< count
; i
++) {
427 ve
->native_format_size
[i
] = align(ve
->native_format_size
[i
], 4);
434 void u_vbuf_mgr_bind_vertex_elements(struct u_vbuf_mgr
*mgrb
,
436 struct u_vbuf_mgr_elements
*ve
)
438 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
444 if (!mgr
->ve_binding_lock
) {
450 void u_vbuf_mgr_destroy_vertex_elements(struct u_vbuf_mgr
*mgr
,
451 struct u_vbuf_mgr_elements
*ve
)
456 void u_vbuf_mgr_set_vertex_buffers(struct u_vbuf_mgr
*mgrb
,
458 const struct pipe_vertex_buffer
*bufs
)
460 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
463 mgr
->b
.max_index
= ~0;
464 mgr
->any_user_vbs
= FALSE
;
465 mgr
->incompatible_vb_layout
= FALSE
;
467 if (!mgr
->caps
.fetch_dword_unaligned
) {
468 /* Check if the strides and offsets are aligned to the size of DWORD. */
469 for (i
= 0; i
< count
; i
++) {
470 if (bufs
[i
].buffer
) {
471 if (bufs
[i
].stride
% 4 != 0 ||
472 bufs
[i
].buffer_offset
% 4 != 0) {
473 mgr
->incompatible_vb_layout
= TRUE
;
480 for (i
= 0; i
< count
; i
++) {
481 const struct pipe_vertex_buffer
*vb
= &bufs
[i
];
483 pipe_resource_reference(&mgr
->b
.vertex_buffer
[i
].buffer
, vb
->buffer
);
484 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[i
], NULL
);
486 if (u_vbuf_resource(vb
->buffer
)->user_ptr
) {
487 mgr
->any_user_vbs
= TRUE
;
491 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[i
], vb
->buffer
);
493 /* The stride of zero means we will be fetching only the first
494 * vertex, so don't care about max_index. */
499 /* Update the maximum index. */
501 MIN2(mgr
->b
.max_index
,
502 (vb
->buffer
->width0
- vb
->buffer_offset
) / vb
->stride
- 1);
505 for (; i
< mgr
->b
.nr_real_vertex_buffers
; i
++) {
506 pipe_resource_reference(&mgr
->b
.vertex_buffer
[i
].buffer
, NULL
);
507 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[i
], NULL
);
510 memcpy(mgr
->b
.vertex_buffer
, bufs
,
511 sizeof(struct pipe_vertex_buffer
) * count
);
513 mgr
->b
.nr_vertex_buffers
= count
;
514 mgr
->b
.nr_real_vertex_buffers
= count
;
517 static void u_vbuf_upload_buffers(struct u_vbuf_mgr_priv
*mgr
,
518 int min_index
, int max_index
,
519 unsigned instance_count
,
520 boolean
*upload_flushed
)
522 int i
, nr
= mgr
->ve
->count
;
523 unsigned count
= max_index
+ 1 - min_index
;
524 boolean uploaded
[PIPE_MAX_ATTRIBS
] = {0};
526 for (i
= 0; i
< nr
; i
++) {
527 unsigned index
= mgr
->ve
->ve
[i
].vertex_buffer_index
;
528 struct pipe_vertex_buffer
*vb
= &mgr
->b
.vertex_buffer
[index
];
531 u_vbuf_resource(vb
->buffer
)->user_ptr
&&
533 unsigned first
, size
;
535 unsigned instance_div
= mgr
->ve
->ve
[i
].instance_divisor
;
540 ((instance_count
+ instance_div
- 1) / instance_div
);
541 } else if (vb
->stride
) {
542 first
= vb
->stride
* min_index
;
543 size
= vb
->stride
* count
;
546 size
= mgr
->ve
->native_format_size
[i
];
549 u_upload_data(mgr
->b
.uploader
, first
, size
,
550 u_vbuf_resource(vb
->buffer
)->user_ptr
+ first
,
552 &mgr
->b
.real_vertex_buffer
[index
],
555 vb
->buffer_offset
-= first
;
557 uploaded
[index
] = TRUE
;
558 *upload_flushed
= *upload_flushed
|| flushed
;
560 assert(mgr
->b
.real_vertex_buffer
[index
]);
565 void u_vbuf_mgr_draw_begin(struct u_vbuf_mgr
*mgrb
,
566 const struct pipe_draw_info
*info
,
567 boolean
*buffers_updated
,
568 boolean
*uploader_flushed
)
570 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
571 boolean bufs_updated
= FALSE
, upload_flushed
= FALSE
;
572 int min_index
, max_index
;
574 min_index
= info
->min_index
- info
->index_bias
;
575 if (info
->max_index
== ~0) {
576 max_index
= mgr
->b
.max_index
;
578 max_index
= MIN2(info
->max_index
- info
->index_bias
, mgr
->b
.max_index
);
581 /* Translate vertices with non-native layouts or formats. */
582 if (mgr
->incompatible_vb_layout
|| mgr
->ve
->incompatible_layout
) {
583 u_vbuf_translate_begin(mgr
, min_index
, max_index
, &upload_flushed
);
585 if (mgr
->fallback_ve
) {
590 /* Upload user buffers. */
591 if (mgr
->any_user_vbs
) {
592 u_vbuf_upload_buffers(mgr
, min_index
, max_index
, info
->instance_count
,
597 /* Set the return values. */
598 if (buffers_updated
) {
599 *buffers_updated
= bufs_updated
;
601 if (uploader_flushed
) {
602 *uploader_flushed
= upload_flushed
;
606 void u_vbuf_mgr_draw_end(struct u_vbuf_mgr
*mgrb
)
608 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
610 if (mgr
->fallback_ve
) {
611 u_vbuf_translate_end(mgr
);