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 struct u_vbuf_mgr_elements
{
39 struct pipe_vertex_element ve
[PIPE_MAX_ATTRIBS
];
41 unsigned src_format_size
[PIPE_MAX_ATTRIBS
];
43 /* If (velem[i].src_format != native_format[i]), the vertex buffer
44 * referenced by the vertex element cannot be used for rendering and
45 * its vertex data must be translated to native_format[i]. */
46 enum pipe_format native_format
[PIPE_MAX_ATTRIBS
];
47 unsigned native_format_size
[PIPE_MAX_ATTRIBS
];
49 /* This might mean two things:
50 * - src_format != native_format, as discussed above.
51 * - src_offset % 4 != 0 (if the caps don't allow such an offset). */
52 boolean incompatible_layout
;
55 struct u_vbuf_mgr_priv
{
57 struct pipe_context
*pipe
;
59 struct translate_cache
*translate_cache
;
60 unsigned translate_vb_slot
;
62 struct u_vbuf_mgr_elements
*ve
;
63 void *saved_ve
, *fallback_ve
;
64 boolean ve_binding_lock
;
67 boolean incompatible_vb_layout
;
70 static void u_vbuf_mgr_init_format_caps(struct u_vbuf_mgr_priv
*mgr
)
72 struct pipe_screen
*screen
= mgr
->pipe
->screen
;
74 mgr
->b
.caps
.format_fixed32
=
75 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_FIXED
, PIPE_BUFFER
,
76 0, PIPE_BIND_VERTEX_BUFFER
);
78 mgr
->b
.caps
.format_float16
=
79 screen
->is_format_supported(screen
, PIPE_FORMAT_R16_FLOAT
, PIPE_BUFFER
,
80 0, PIPE_BIND_VERTEX_BUFFER
);
82 mgr
->b
.caps
.format_float64
=
83 screen
->is_format_supported(screen
, PIPE_FORMAT_R64_FLOAT
, PIPE_BUFFER
,
84 0, PIPE_BIND_VERTEX_BUFFER
);
86 mgr
->b
.caps
.format_norm32
=
87 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_UNORM
, PIPE_BUFFER
,
88 0, PIPE_BIND_VERTEX_BUFFER
) &&
89 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_SNORM
, PIPE_BUFFER
,
90 0, PIPE_BIND_VERTEX_BUFFER
);
92 mgr
->b
.caps
.format_scaled32
=
93 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_USCALED
, PIPE_BUFFER
,
94 0, PIPE_BIND_VERTEX_BUFFER
) &&
95 screen
->is_format_supported(screen
, PIPE_FORMAT_R32_SSCALED
, PIPE_BUFFER
,
96 0, PIPE_BIND_VERTEX_BUFFER
);
100 u_vbuf_mgr_create(struct pipe_context
*pipe
,
101 unsigned upload_buffer_size
,
102 unsigned upload_buffer_alignment
,
103 unsigned upload_buffer_bind
,
104 enum u_fetch_alignment fetch_alignment
)
106 struct u_vbuf_mgr_priv
*mgr
= CALLOC_STRUCT(u_vbuf_mgr_priv
);
109 mgr
->translate_cache
= translate_cache_create();
111 mgr
->b
.uploader
= u_upload_create(pipe
, upload_buffer_size
,
112 upload_buffer_alignment
,
115 mgr
->b
.caps
.fetch_dword_unaligned
=
116 fetch_alignment
== U_VERTEX_FETCH_BYTE_ALIGNED
;
118 u_vbuf_mgr_init_format_caps(mgr
);
123 void u_vbuf_mgr_destroy(struct u_vbuf_mgr
*mgrb
)
125 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
128 for (i
= 0; i
< mgr
->b
.nr_vertex_buffers
; i
++) {
129 pipe_resource_reference(&mgr
->b
.vertex_buffer
[i
].buffer
, NULL
);
131 for (i
= 0; i
< mgr
->b
.nr_real_vertex_buffers
; i
++) {
132 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[i
].buffer
, NULL
);
135 translate_cache_destroy(mgr
->translate_cache
);
136 u_upload_destroy(mgr
->b
.uploader
);
141 static enum u_vbuf_return_flags
142 u_vbuf_translate_begin(struct u_vbuf_mgr_priv
*mgr
,
143 int min_index
, int max_index
)
145 struct translate_key key
;
146 struct translate_element
*te
;
147 unsigned tr_elem_index
[PIPE_MAX_ATTRIBS
];
148 struct translate
*tr
;
149 boolean vb_translated
[PIPE_MAX_ATTRIBS
] = {0};
150 uint8_t *vb_map
[PIPE_MAX_ATTRIBS
] = {0}, *out_map
;
151 struct pipe_transfer
*vb_transfer
[PIPE_MAX_ATTRIBS
] = {0};
152 struct pipe_resource
*out_buffer
= NULL
;
153 unsigned i
, num_verts
, out_offset
;
154 struct pipe_vertex_element new_velems
[PIPE_MAX_ATTRIBS
];
155 boolean upload_flushed
= FALSE
;
157 memset(&key
, 0, sizeof(key
));
158 memset(tr_elem_index
, 0xff, sizeof(tr_elem_index
));
160 /* Initialize the translate key, i.e. the recipe how vertices should be
162 memset(&key
, 0, sizeof key
);
163 for (i
= 0; i
< mgr
->ve
->count
; i
++) {
164 struct pipe_vertex_buffer
*vb
=
165 &mgr
->b
.vertex_buffer
[mgr
->ve
->ve
[i
].vertex_buffer_index
];
166 enum pipe_format output_format
= mgr
->ve
->native_format
[i
];
167 unsigned output_format_size
= mgr
->ve
->native_format_size
[i
];
169 /* Check for support. */
170 if (mgr
->ve
->ve
[i
].src_format
== mgr
->ve
->native_format
[i
] &&
171 (mgr
->b
.caps
.fetch_dword_unaligned
||
172 (vb
->buffer_offset
% 4 == 0 &&
173 vb
->stride
% 4 == 0 &&
174 mgr
->ve
->ve
[i
].src_offset
% 4 == 0))) {
178 /* Workaround for translate: output floats instead of halfs. */
179 switch (output_format
) {
180 case PIPE_FORMAT_R16_FLOAT
:
181 output_format
= PIPE_FORMAT_R32_FLOAT
;
182 output_format_size
= 4;
184 case PIPE_FORMAT_R16G16_FLOAT
:
185 output_format
= PIPE_FORMAT_R32G32_FLOAT
;
186 output_format_size
= 8;
188 case PIPE_FORMAT_R16G16B16_FLOAT
:
189 output_format
= PIPE_FORMAT_R32G32B32_FLOAT
;
190 output_format_size
= 12;
192 case PIPE_FORMAT_R16G16B16A16_FLOAT
:
193 output_format
= PIPE_FORMAT_R32G32B32A32_FLOAT
;
194 output_format_size
= 16;
199 /* Add this vertex element. */
200 te
= &key
.element
[key
.nr_elements
];
202 te->instance_divisor;*/
203 te
->input_buffer
= mgr
->ve
->ve
[i
].vertex_buffer_index
;
204 te
->input_format
= mgr
->ve
->ve
[i
].src_format
;
205 te
->input_offset
= mgr
->ve
->ve
[i
].src_offset
;
206 te
->output_format
= output_format
;
207 te
->output_offset
= key
.output_stride
;
209 key
.output_stride
+= output_format_size
;
210 vb_translated
[mgr
->ve
->ve
[i
].vertex_buffer_index
] = TRUE
;
211 tr_elem_index
[i
] = key
.nr_elements
;
215 /* Get a translate object. */
216 tr
= translate_cache_find(mgr
->translate_cache
, &key
);
218 /* Map buffers we want to translate. */
219 for (i
= 0; i
< mgr
->b
.nr_vertex_buffers
; i
++) {
220 if (vb_translated
[i
]) {
221 struct pipe_vertex_buffer
*vb
= &mgr
->b
.vertex_buffer
[i
];
223 vb_map
[i
] = pipe_buffer_map(mgr
->pipe
, vb
->buffer
,
224 PIPE_TRANSFER_READ
, &vb_transfer
[i
]);
226 tr
->set_buffer(tr
, i
,
227 vb_map
[i
] + vb
->buffer_offset
+ vb
->stride
* min_index
,
232 /* Create and map the output buffer. */
233 num_verts
= max_index
+ 1 - min_index
;
235 u_upload_alloc(mgr
->b
.uploader
,
236 key
.output_stride
* min_index
,
237 key
.output_stride
* num_verts
,
238 &out_offset
, &out_buffer
, &upload_flushed
,
241 out_offset
-= key
.output_stride
* min_index
;
244 tr
->run(tr
, 0, num_verts
, 0, out_map
);
246 /* Unmap all buffers. */
247 for (i
= 0; i
< mgr
->b
.nr_vertex_buffers
; i
++) {
248 if (vb_translated
[i
]) {
249 pipe_buffer_unmap(mgr
->pipe
, vb_transfer
[i
]);
253 /* Setup the new vertex buffer in the first free slot. */
254 mgr
->translate_vb_slot
= ~0;
255 for (i
= 0; i
< PIPE_MAX_ATTRIBS
; i
++) {
256 if (!mgr
->b
.vertex_buffer
[i
].buffer
) {
257 mgr
->translate_vb_slot
= i
;
259 if (i
>= mgr
->b
.nr_vertex_buffers
) {
260 mgr
->b
.nr_real_vertex_buffers
= i
+1;
266 if (mgr
->translate_vb_slot
!= ~0) {
267 /* Setup the new vertex buffer. */
268 pipe_resource_reference(
269 &mgr
->b
.real_vertex_buffer
[mgr
->translate_vb_slot
].buffer
, out_buffer
);
270 mgr
->b
.real_vertex_buffer
[mgr
->translate_vb_slot
].buffer_offset
= out_offset
;
271 mgr
->b
.real_vertex_buffer
[mgr
->translate_vb_slot
].stride
= key
.output_stride
;
273 /* Setup new vertex elements. */
274 for (i
= 0; i
< mgr
->ve
->count
; i
++) {
275 if (tr_elem_index
[i
] < key
.nr_elements
) {
276 te
= &key
.element
[tr_elem_index
[i
]];
277 new_velems
[i
].instance_divisor
= mgr
->ve
->ve
[i
].instance_divisor
;
278 new_velems
[i
].src_format
= te
->output_format
;
279 new_velems
[i
].src_offset
= te
->output_offset
;
280 new_velems
[i
].vertex_buffer_index
= mgr
->translate_vb_slot
;
282 memcpy(&new_velems
[i
], &mgr
->ve
->ve
[i
],
283 sizeof(struct pipe_vertex_element
));
288 mgr
->pipe
->create_vertex_elements_state(mgr
->pipe
, mgr
->ve
->count
,
291 /* Preserve saved_ve. */
292 mgr
->ve_binding_lock
= TRUE
;
293 mgr
->pipe
->bind_vertex_elements_state(mgr
->pipe
, mgr
->fallback_ve
);
294 mgr
->ve_binding_lock
= FALSE
;
297 pipe_resource_reference(&out_buffer
, NULL
);
299 return upload_flushed
? U_VBUF_UPLOAD_FLUSHED
: 0;
302 static void u_vbuf_translate_end(struct u_vbuf_mgr_priv
*mgr
)
304 if (mgr
->fallback_ve
== NULL
) {
308 /* Restore vertex elements. */
309 /* Note that saved_ve will be overwritten in bind_vertex_elements_state. */
310 mgr
->pipe
->bind_vertex_elements_state(mgr
->pipe
, mgr
->saved_ve
);
311 mgr
->pipe
->delete_vertex_elements_state(mgr
->pipe
, mgr
->fallback_ve
);
312 mgr
->fallback_ve
= NULL
;
314 /* Delete the now-unused VBO. */
315 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[mgr
->translate_vb_slot
].buffer
,
317 mgr
->b
.nr_real_vertex_buffers
= mgr
->b
.nr_vertex_buffers
;
320 #define FORMAT_REPLACE(what, withwhat) \
321 case PIPE_FORMAT_##what: format = PIPE_FORMAT_##withwhat; break
323 struct u_vbuf_mgr_elements
*
324 u_vbuf_mgr_create_vertex_elements(struct u_vbuf_mgr
*mgrb
,
326 const struct pipe_vertex_element
*attribs
,
327 struct pipe_vertex_element
*native_attribs
)
329 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
331 struct u_vbuf_mgr_elements
*ve
= CALLOC_STRUCT(u_vbuf_mgr_elements
);
339 memcpy(ve
->ve
, attribs
, sizeof(struct pipe_vertex_element
) * count
);
340 memcpy(native_attribs
, attribs
, sizeof(struct pipe_vertex_element
) * count
);
342 /* Set the best native format in case the original format is not
344 for (i
= 0; i
< count
; i
++) {
345 enum pipe_format format
= ve
->ve
[i
].src_format
;
347 ve
->src_format_size
[i
] = util_format_get_blocksize(format
);
349 /* Choose a native format.
350 * For now we don't care about the alignment, that's going to
351 * be sorted out later. */
352 if (!mgr
->b
.caps
.format_fixed32
) {
354 FORMAT_REPLACE(R32_FIXED
, R32_FLOAT
);
355 FORMAT_REPLACE(R32G32_FIXED
, R32G32_FLOAT
);
356 FORMAT_REPLACE(R32G32B32_FIXED
, R32G32B32_FLOAT
);
357 FORMAT_REPLACE(R32G32B32A32_FIXED
, R32G32B32A32_FLOAT
);
361 if (!mgr
->b
.caps
.format_float16
) {
363 FORMAT_REPLACE(R16_FLOAT
, R32_FLOAT
);
364 FORMAT_REPLACE(R16G16_FLOAT
, R32G32_FLOAT
);
365 FORMAT_REPLACE(R16G16B16_FLOAT
, R32G32B32_FLOAT
);
366 FORMAT_REPLACE(R16G16B16A16_FLOAT
, R32G32B32A32_FLOAT
);
370 if (!mgr
->b
.caps
.format_float64
) {
372 FORMAT_REPLACE(R64_FLOAT
, R32_FLOAT
);
373 FORMAT_REPLACE(R64G64_FLOAT
, R32G32_FLOAT
);
374 FORMAT_REPLACE(R64G64B64_FLOAT
, R32G32B32_FLOAT
);
375 FORMAT_REPLACE(R64G64B64A64_FLOAT
, R32G32B32A32_FLOAT
);
379 if (!mgr
->b
.caps
.format_norm32
) {
381 FORMAT_REPLACE(R32_UNORM
, R32_FLOAT
);
382 FORMAT_REPLACE(R32G32_UNORM
, R32G32_FLOAT
);
383 FORMAT_REPLACE(R32G32B32_UNORM
, R32G32B32_FLOAT
);
384 FORMAT_REPLACE(R32G32B32A32_UNORM
, R32G32B32A32_FLOAT
);
385 FORMAT_REPLACE(R32_SNORM
, R32_FLOAT
);
386 FORMAT_REPLACE(R32G32_SNORM
, R32G32_FLOAT
);
387 FORMAT_REPLACE(R32G32B32_SNORM
, R32G32B32_FLOAT
);
388 FORMAT_REPLACE(R32G32B32A32_SNORM
, R32G32B32A32_FLOAT
);
392 if (!mgr
->b
.caps
.format_scaled32
) {
394 FORMAT_REPLACE(R32_USCALED
, R32_FLOAT
);
395 FORMAT_REPLACE(R32G32_USCALED
, R32G32_FLOAT
);
396 FORMAT_REPLACE(R32G32B32_USCALED
, R32G32B32_FLOAT
);
397 FORMAT_REPLACE(R32G32B32A32_USCALED
,R32G32B32A32_FLOAT
);
398 FORMAT_REPLACE(R32_SSCALED
, R32_FLOAT
);
399 FORMAT_REPLACE(R32G32_SSCALED
, R32G32_FLOAT
);
400 FORMAT_REPLACE(R32G32B32_SSCALED
, R32G32B32_FLOAT
);
401 FORMAT_REPLACE(R32G32B32A32_SSCALED
,R32G32B32A32_FLOAT
);
406 native_attribs
[i
].src_format
= format
;
407 ve
->native_format
[i
] = format
;
408 ve
->native_format_size
[i
] =
409 util_format_get_blocksize(ve
->native_format
[i
]);
411 ve
->incompatible_layout
=
412 ve
->incompatible_layout
||
413 ve
->ve
[i
].src_format
!= ve
->native_format
[i
] ||
414 (!mgr
->b
.caps
.fetch_dword_unaligned
&& ve
->ve
[i
].src_offset
% 4 != 0);
417 /* Align the formats to the size of DWORD if needed. */
418 if (!mgr
->b
.caps
.fetch_dword_unaligned
) {
419 for (i
= 0; i
< count
; i
++) {
420 ve
->native_format_size
[i
] = align(ve
->native_format_size
[i
], 4);
427 void u_vbuf_mgr_bind_vertex_elements(struct u_vbuf_mgr
*mgrb
,
429 struct u_vbuf_mgr_elements
*ve
)
431 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
437 if (!mgr
->ve_binding_lock
) {
443 void u_vbuf_mgr_destroy_vertex_elements(struct u_vbuf_mgr
*mgr
,
444 struct u_vbuf_mgr_elements
*ve
)
449 void u_vbuf_mgr_set_vertex_buffers(struct u_vbuf_mgr
*mgrb
,
451 const struct pipe_vertex_buffer
*bufs
)
453 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
456 mgr
->any_user_vbs
= FALSE
;
457 mgr
->incompatible_vb_layout
= FALSE
;
459 if (!mgr
->b
.caps
.fetch_dword_unaligned
) {
460 /* Check if the strides and offsets are aligned to the size of DWORD. */
461 for (i
= 0; i
< count
; i
++) {
462 if (bufs
[i
].buffer
) {
463 if (bufs
[i
].stride
% 4 != 0 ||
464 bufs
[i
].buffer_offset
% 4 != 0) {
465 mgr
->incompatible_vb_layout
= TRUE
;
472 for (i
= 0; i
< count
; i
++) {
473 const struct pipe_vertex_buffer
*vb
= &bufs
[i
];
475 pipe_resource_reference(&mgr
->b
.vertex_buffer
[i
].buffer
, vb
->buffer
);
476 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[i
].buffer
, NULL
);
478 mgr
->b
.real_vertex_buffer
[i
].buffer_offset
=
479 mgr
->b
.vertex_buffer
[i
].buffer_offset
= vb
->buffer_offset
;
481 mgr
->b
.real_vertex_buffer
[i
].stride
=
482 mgr
->b
.vertex_buffer
[i
].stride
= vb
->stride
;
488 if (u_vbuf_resource(vb
->buffer
)->user_ptr
) {
489 mgr
->any_user_vbs
= TRUE
;
493 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[i
].buffer
, vb
->buffer
);
496 for (i
= count
; i
< mgr
->b
.nr_vertex_buffers
; i
++) {
497 pipe_resource_reference(&mgr
->b
.vertex_buffer
[i
].buffer
, NULL
);
499 for (i
= count
; i
< mgr
->b
.nr_real_vertex_buffers
; i
++) {
500 pipe_resource_reference(&mgr
->b
.real_vertex_buffer
[i
].buffer
, NULL
);
503 mgr
->b
.nr_vertex_buffers
= count
;
504 mgr
->b
.nr_real_vertex_buffers
= count
;
507 static enum u_vbuf_return_flags
508 u_vbuf_upload_buffers(struct u_vbuf_mgr_priv
*mgr
,
509 int min_index
, int max_index
,
510 unsigned instance_count
)
512 unsigned i
, nr
= mgr
->ve
->count
;
513 unsigned count
= max_index
+ 1 - min_index
;
514 boolean uploaded
[PIPE_MAX_ATTRIBS
] = {0};
515 enum u_vbuf_return_flags retval
= 0;
517 for (i
= 0; i
< nr
; i
++) {
518 unsigned index
= mgr
->ve
->ve
[i
].vertex_buffer_index
;
519 struct pipe_vertex_buffer
*vb
= &mgr
->b
.vertex_buffer
[index
];
522 u_vbuf_resource(vb
->buffer
)->user_ptr
&&
524 unsigned first
, size
;
526 unsigned instance_div
= mgr
->ve
->ve
[i
].instance_divisor
;
531 ((instance_count
+ instance_div
- 1) / instance_div
);
532 } else if (vb
->stride
) {
533 first
= vb
->stride
* min_index
;
534 size
= vb
->stride
* count
;
536 /* Unusual case when stride is smaller than the format size.
537 * XXX This won't work with interleaved arrays. */
538 if (mgr
->ve
->native_format_size
[i
] > vb
->stride
)
539 size
+= mgr
->ve
->native_format_size
[i
] - vb
->stride
;
542 size
= mgr
->ve
->native_format_size
[i
];
545 u_upload_data(mgr
->b
.uploader
, first
, size
,
546 u_vbuf_resource(vb
->buffer
)->user_ptr
+ first
,
547 &mgr
->b
.real_vertex_buffer
[index
].buffer_offset
,
548 &mgr
->b
.real_vertex_buffer
[index
].buffer
,
551 mgr
->b
.real_vertex_buffer
[index
].buffer_offset
-= first
;
553 uploaded
[index
] = TRUE
;
555 retval
|= U_VBUF_UPLOAD_FLUSHED
;
557 assert(mgr
->b
.real_vertex_buffer
[index
].buffer
);
564 static void u_vbuf_mgr_compute_max_index(struct u_vbuf_mgr_priv
*mgr
)
566 unsigned i
, nr
= mgr
->ve
->count
;
568 mgr
->b
.max_index
= ~0;
570 for (i
= 0; i
< nr
; i
++) {
571 struct pipe_vertex_buffer
*vb
=
572 &mgr
->b
.vertex_buffer
[mgr
->ve
->ve
[i
].vertex_buffer_index
];
578 u_vbuf_resource(vb
->buffer
)->user_ptr
) {
582 /* How many bytes is unused after the last vertex.
583 * width0 may be "count*stride - unused" and we have to compensate
584 * for that when dividing by stride. */
585 unused
= vb
->stride
-
586 (mgr
->ve
->ve
[i
].src_offset
+ mgr
->ve
->src_format_size
[i
]);
588 /* If src_offset is greater than stride (which means it's a buffer
589 * offset rather than a vertex offset)... */
594 /* Compute the maximum index for this vertex element. */
596 (vb
->buffer
->width0
- vb
->buffer_offset
+ (unsigned)unused
) /
599 mgr
->b
.max_index
= MIN2(mgr
->b
.max_index
, max_index
);
603 enum u_vbuf_return_flags
604 u_vbuf_mgr_draw_begin(struct u_vbuf_mgr
*mgrb
,
605 const struct pipe_draw_info
*info
)
607 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
608 int min_index
, max_index
;
609 enum u_vbuf_return_flags retval
= 0;
611 u_vbuf_mgr_compute_max_index(mgr
);
613 min_index
= info
->min_index
- info
->index_bias
;
614 if (info
->max_index
== ~0) {
615 max_index
= mgr
->b
.max_index
;
617 max_index
= MIN2(info
->max_index
- info
->index_bias
, mgr
->b
.max_index
);
620 /* Translate vertices with non-native layouts or formats. */
621 if (mgr
->incompatible_vb_layout
|| mgr
->ve
->incompatible_layout
) {
622 retval
|= u_vbuf_translate_begin(mgr
, min_index
, max_index
);
624 if (mgr
->fallback_ve
) {
625 retval
|= U_VBUF_BUFFERS_UPDATED
;
629 /* Upload user buffers. */
630 if (mgr
->any_user_vbs
) {
631 retval
|= u_vbuf_upload_buffers(mgr
, min_index
, max_index
,
632 info
->instance_count
);
633 retval
|= U_VBUF_BUFFERS_UPDATED
;
638 void u_vbuf_mgr_draw_end(struct u_vbuf_mgr
*mgrb
)
640 struct u_vbuf_mgr_priv
*mgr
= (struct u_vbuf_mgr_priv
*)mgrb
;
642 if (mgr
->fallback_ve
) {
643 u_vbuf_translate_end(mgr
);