projects / mesa.git / blob
? search:


7c87bf8b210407a77541239d095b8a452717dd48
[mesa.git] / src / gallium / auxiliary / util / u_vbuf.c
1 /**************************************************************************
2 *
3 * Copyright 2011 Marek Olšák <maraeo@gmail.com>
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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.
25 *
26 **************************************************************************/
27
28 #include "util/u_vbuf.h"
29
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"
36
37 struct u_vbuf_elements {
38 unsigned count;
39 struct pipe_vertex_element ve[PIPE_MAX_ATTRIBS];
40
41 unsigned src_format_size[PIPE_MAX_ATTRIBS];
42
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];
48
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;
53 /* Per-element flags. */
54 boolean incompatible_layout_elem[PIPE_MAX_ATTRIBS];
55 };
56
57 struct u_vbuf_priv {
58 struct u_vbuf b;
59 struct pipe_context *pipe;
60 struct translate_cache *translate_cache;
61
62 /* Vertex element state bound by the state tracker. */
63 void *saved_ve;
64 /* and its associated helper structure for this module. */
65 struct u_vbuf_elements *ve;
66
67 /* Vertex elements used for the translate fallback. */
68 struct pipe_vertex_element fallback_velems[PIPE_MAX_ATTRIBS];
69 /* If non-NULL, this is a vertex element state used for the translate
70 * fallback and therefore used for rendering too. */
71 void *fallback_ve;
72 /* The vertex buffer slot index where translated vertices have been
73 * stored in. */
74 unsigned fallback_vb_slot;
75 /* When binding the fallback vertex element state, we don't want to
76 * change saved_ve and ve. This is set to TRUE in such cases. */
77 boolean ve_binding_lock;
78
79 /* Whether there is any user buffer. */
80 boolean any_user_vbs;
81 /* Whether there is a buffer with a non-native layout. */
82 boolean incompatible_vb_layout;
83 /* Per-buffer flags. */
84 boolean incompatible_vb[PIPE_MAX_ATTRIBS];
85 };
86
87 static void u_vbuf_init_format_caps(struct u_vbuf_priv *mgr)
88 {
89 struct pipe_screen *screen = mgr->pipe->screen;
90
91 mgr->b.caps.format_fixed32 =
92 screen->is_format_supported(screen, PIPE_FORMAT_R32_FIXED, PIPE_BUFFER,
93 0, PIPE_BIND_VERTEX_BUFFER);
94
95 mgr->b.caps.format_float16 =
96 screen->is_format_supported(screen, PIPE_FORMAT_R16_FLOAT, PIPE_BUFFER,
97 0, PIPE_BIND_VERTEX_BUFFER);
98
99 mgr->b.caps.format_float64 =
100 screen->is_format_supported(screen, PIPE_FORMAT_R64_FLOAT, PIPE_BUFFER,
101 0, PIPE_BIND_VERTEX_BUFFER);
102
103 mgr->b.caps.format_norm32 =
104 screen->is_format_supported(screen, PIPE_FORMAT_R32_UNORM, PIPE_BUFFER,
105 0, PIPE_BIND_VERTEX_BUFFER) &&
106 screen->is_format_supported(screen, PIPE_FORMAT_R32_SNORM, PIPE_BUFFER,
107 0, PIPE_BIND_VERTEX_BUFFER);
108
109 mgr->b.caps.format_scaled32 =
110 screen->is_format_supported(screen, PIPE_FORMAT_R32_USCALED, PIPE_BUFFER,
111 0, PIPE_BIND_VERTEX_BUFFER) &&
112 screen->is_format_supported(screen, PIPE_FORMAT_R32_SSCALED, PIPE_BUFFER,
113 0, PIPE_BIND_VERTEX_BUFFER);
114 }
115
116 struct u_vbuf *
117 u_vbuf_create(struct pipe_context *pipe,
118 unsigned upload_buffer_size,
119 unsigned upload_buffer_alignment,
120 unsigned upload_buffer_bind,
121 enum u_fetch_alignment fetch_alignment)
122 {
123 struct u_vbuf_priv *mgr = CALLOC_STRUCT(u_vbuf_priv);
124
125 mgr->pipe = pipe;
126 mgr->translate_cache = translate_cache_create();
127 mgr->fallback_vb_slot = ~0;
128
129 mgr->b.uploader = u_upload_create(pipe, upload_buffer_size,
130 upload_buffer_alignment,
131 upload_buffer_bind);
132
133 mgr->b.caps.fetch_dword_unaligned =
134 fetch_alignment == U_VERTEX_FETCH_BYTE_ALIGNED;
135
136 u_vbuf_init_format_caps(mgr);
137
138 return &mgr->b;
139 }
140
141 void u_vbuf_destroy(struct u_vbuf *mgrb)
142 {
143 struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
144 unsigned i;
145
146 for (i = 0; i < mgr->b.nr_vertex_buffers; i++) {
147 pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, NULL);
148 }
149 for (i = 0; i < mgr->b.nr_real_vertex_buffers; i++) {
150 pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
151 }
152
153 translate_cache_destroy(mgr->translate_cache);
154 u_upload_destroy(mgr->b.uploader);
155 FREE(mgr);
156 }
157
158
159 static unsigned u_vbuf_get_free_real_vb_slot(struct u_vbuf_priv *mgr)
160 {
161 unsigned i, nr = mgr->ve->count;
162 boolean used_vb[PIPE_MAX_ATTRIBS] = {0};
163
164 for (i = 0; i < nr; i++) {
165 if (!mgr->ve->incompatible_layout_elem[i]) {
166 unsigned index = mgr->ve->ve[i].vertex_buffer_index;
167
168 if (!mgr->incompatible_vb[index]) {
169 used_vb[index] = TRUE;
170 }
171 }
172 }
173
174 for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
175 if (!used_vb[i]) {
176 if (i >= mgr->b.nr_real_vertex_buffers) {
177 mgr->b.nr_real_vertex_buffers = i+1;
178 }
179 return i;
180 }
181 }
182 return ~0;
183 }
184
185 static void
186 u_vbuf_translate_begin(struct u_vbuf_priv *mgr,
187 int min_index, int max_index)
188 {
189 struct translate_key key;
190 struct translate_element *te;
191 unsigned tr_elem_index[PIPE_MAX_ATTRIBS];
192 struct translate *tr;
193 boolean vb_translated[PIPE_MAX_ATTRIBS] = {0};
194 uint8_t *out_map;
195 struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = {0};
196 struct pipe_resource *out_buffer = NULL;
197 unsigned i, out_offset, num_verts = max_index + 1 - min_index;
198 boolean upload_flushed = FALSE;
199
200 memset(&key, 0, sizeof(key));
201 memset(tr_elem_index, 0xff, sizeof(tr_elem_index));
202
203 /* Get a new vertex buffer slot. */
204 mgr->fallback_vb_slot = u_vbuf_get_free_real_vb_slot(mgr);
205
206 if (mgr->fallback_vb_slot == ~0) {
207 return; /* XXX error, not enough attribs */
208 }
209
210 /* Initialize the description of how vertices should be translated. */
211 for (i = 0; i < mgr->ve->count; i++) {
212 enum pipe_format output_format = mgr->ve->native_format[i];
213 unsigned output_format_size = mgr->ve->native_format_size[i];
214
215 /* Check for support. */
216 if (!mgr->ve->incompatible_layout_elem[i] &&
217 !mgr->incompatible_vb[mgr->ve->ve[i].vertex_buffer_index]) {
218 continue;
219 }
220
221 assert(translate_is_output_format_supported(output_format));
222
223 /* Add this vertex element. */
224 te = &key.element[key.nr_elements];
225 te->type = TRANSLATE_ELEMENT_NORMAL;
226 te->instance_divisor = 0;
227 te->input_buffer = mgr->ve->ve[i].vertex_buffer_index;
228 te->input_format = mgr->ve->ve[i].src_format;
229 te->input_offset = mgr->ve->ve[i].src_offset;
230 te->output_format = output_format;
231 te->output_offset = key.output_stride;
232
233 key.output_stride += output_format_size;
234 vb_translated[mgr->ve->ve[i].vertex_buffer_index] = TRUE;
235 tr_elem_index[i] = key.nr_elements;
236 key.nr_elements++;
237 }
238
239 /* Get a translate object. */
240 tr = translate_cache_find(mgr->translate_cache, &key);
241
242 /* Map buffers we want to translate. */
243 for (i = 0; i < mgr->b.nr_vertex_buffers; i++) {
244 if (vb_translated[i]) {
245 struct pipe_vertex_buffer *vb = &mgr->b.vertex_buffer[i];
246 unsigned offset = vb->buffer_offset + vb->stride * min_index;
247 unsigned size = vb->stride ? num_verts * vb->stride
248 : vb->buffer->width0 - offset;
249 uint8_t *map;
250
251 if (u_vbuf_resource(vb->buffer)->user_ptr) {
252 map = u_vbuf_resource(vb->buffer)->user_ptr + offset;
253 } else {
254 map = pipe_buffer_map_range(mgr->pipe, vb->buffer, offset, size,
255 PIPE_TRANSFER_READ, &vb_transfer[i]);
256 }
257
258 tr->set_buffer(tr, i, map, vb->stride, ~0);
259 }
260 }
261
262 /* Create and map the output buffer. */
263 u_upload_alloc(mgr->b.uploader,
264 key.output_stride * min_index,
265 key.output_stride * num_verts,
266 &out_offset, &out_buffer, &upload_flushed,
267 (void**)&out_map);
268
269 out_offset -= key.output_stride * min_index;
270
271 /* Translate. */
272 tr->run(tr, 0, num_verts, 0, out_map);
273
274 /* Unmap all buffers. */
275 for (i = 0; i < mgr->b.nr_vertex_buffers; i++) {
276 if (vb_transfer[i]) {
277 pipe_buffer_unmap(mgr->pipe, vb_transfer[i]);
278 }
279 }
280
281 /* Setup the new vertex buffer. */
282 mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].buffer_offset = out_offset;
283 mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].stride = key.output_stride;
284
285 /* Move the buffer reference. */
286 pipe_resource_reference(
287 &mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].buffer, NULL);
288 mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].buffer = out_buffer;
289 out_buffer = NULL;
290
291 /* Setup new vertex elements. */
292 for (i = 0; i < mgr->ve->count; i++) {
293 if (tr_elem_index[i] < key.nr_elements) {
294 te = &key.element[tr_elem_index[i]];
295 mgr->fallback_velems[i].instance_divisor = mgr->ve->ve[i].instance_divisor;
296 mgr->fallback_velems[i].src_format = te->output_format;
297 mgr->fallback_velems[i].src_offset = te->output_offset;
298 mgr->fallback_velems[i].vertex_buffer_index = mgr->fallback_vb_slot;
299 } else {
300 memcpy(&mgr->fallback_velems[i], &mgr->ve->ve[i],
301 sizeof(struct pipe_vertex_element));
302 }
303 }
304
305
306 mgr->fallback_ve =
307 mgr->pipe->create_vertex_elements_state(mgr->pipe, mgr->ve->count,
308 mgr->fallback_velems);
309
310 /* Preserve saved_ve. */
311 mgr->ve_binding_lock = TRUE;
312 mgr->pipe->bind_vertex_elements_state(mgr->pipe, mgr->fallback_ve);
313 mgr->ve_binding_lock = FALSE;
314 }
315
316 static void u_vbuf_translate_end(struct u_vbuf_priv *mgr)
317 {
318 if (mgr->fallback_ve == NULL) {
319 return;
320 }
321
322 /* Restore vertex elements. */
323 /* Note that saved_ve will be overwritten in bind_vertex_elements_state. */
324 mgr->pipe->bind_vertex_elements_state(mgr->pipe, mgr->saved_ve);
325 mgr->pipe->delete_vertex_elements_state(mgr->pipe, mgr->fallback_ve);
326 mgr->fallback_ve = NULL;
327
328 /* Delete the now-unused VBO. */
329 pipe_resource_reference(&mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].buffer,
330 NULL);
331 mgr->fallback_vb_slot = ~0;
332 mgr->b.nr_real_vertex_buffers = mgr->b.nr_vertex_buffers;
333 }
334
335 #define FORMAT_REPLACE(what, withwhat) \
336 case PIPE_FORMAT_##what: format = PIPE_FORMAT_##withwhat; break
337
338 struct u_vbuf_elements *
339 u_vbuf_create_vertex_elements(struct u_vbuf *mgrb,
340 unsigned count,
341 const struct pipe_vertex_element *attribs,
342 struct pipe_vertex_element *native_attribs)
343 {
344 struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
345 unsigned i;
346 struct u_vbuf_elements *ve = CALLOC_STRUCT(u_vbuf_elements);
347
348 ve->count = count;
349
350 if (!count) {
351 return ve;
352 }
353
354 memcpy(ve->ve, attribs, sizeof(struct pipe_vertex_element) * count);
355 memcpy(native_attribs, attribs, sizeof(struct pipe_vertex_element) * count);
356
357 /* Set the best native format in case the original format is not
358 * supported. */
359 for (i = 0; i < count; i++) {
360 enum pipe_format format = ve->ve[i].src_format;
361
362 ve->src_format_size[i] = util_format_get_blocksize(format);
363
364 /* Choose a native format.
365 * For now we don't care about the alignment, that's going to
366 * be sorted out later. */
367 if (!mgr->b.caps.format_fixed32) {
368 switch (format) {
369 FORMAT_REPLACE(R32_FIXED, R32_FLOAT);
370 FORMAT_REPLACE(R32G32_FIXED, R32G32_FLOAT);
371 FORMAT_REPLACE(R32G32B32_FIXED, R32G32B32_FLOAT);
372 FORMAT_REPLACE(R32G32B32A32_FIXED, R32G32B32A32_FLOAT);
373 default:;
374 }
375 }
376 if (!mgr->b.caps.format_float16) {
377 switch (format) {
378 FORMAT_REPLACE(R16_FLOAT, R32_FLOAT);
379 FORMAT_REPLACE(R16G16_FLOAT, R32G32_FLOAT);
380 FORMAT_REPLACE(R16G16B16_FLOAT, R32G32B32_FLOAT);
381 FORMAT_REPLACE(R16G16B16A16_FLOAT, R32G32B32A32_FLOAT);
382 default:;
383 }
384 }
385 if (!mgr->b.caps.format_float64) {
386 switch (format) {
387 FORMAT_REPLACE(R64_FLOAT, R32_FLOAT);
388 FORMAT_REPLACE(R64G64_FLOAT, R32G32_FLOAT);
389 FORMAT_REPLACE(R64G64B64_FLOAT, R32G32B32_FLOAT);
390 FORMAT_REPLACE(R64G64B64A64_FLOAT, R32G32B32A32_FLOAT);
391 default:;
392 }
393 }
394 if (!mgr->b.caps.format_norm32) {
395 switch (format) {
396 FORMAT_REPLACE(R32_UNORM, R32_FLOAT);
397 FORMAT_REPLACE(R32G32_UNORM, R32G32_FLOAT);
398 FORMAT_REPLACE(R32G32B32_UNORM, R32G32B32_FLOAT);
399 FORMAT_REPLACE(R32G32B32A32_UNORM, R32G32B32A32_FLOAT);
400 FORMAT_REPLACE(R32_SNORM, R32_FLOAT);
401 FORMAT_REPLACE(R32G32_SNORM, R32G32_FLOAT);
402 FORMAT_REPLACE(R32G32B32_SNORM, R32G32B32_FLOAT);
403 FORMAT_REPLACE(R32G32B32A32_SNORM, R32G32B32A32_FLOAT);
404 default:;
405 }
406 }
407 if (!mgr->b.caps.format_scaled32) {
408 switch (format) {
409 FORMAT_REPLACE(R32_USCALED, R32_FLOAT);
410 FORMAT_REPLACE(R32G32_USCALED, R32G32_FLOAT);
411 FORMAT_REPLACE(R32G32B32_USCALED, R32G32B32_FLOAT);
412 FORMAT_REPLACE(R32G32B32A32_USCALED,R32G32B32A32_FLOAT);
413 FORMAT_REPLACE(R32_SSCALED, R32_FLOAT);
414 FORMAT_REPLACE(R32G32_SSCALED, R32G32_FLOAT);
415 FORMAT_REPLACE(R32G32B32_SSCALED, R32G32B32_FLOAT);
416 FORMAT_REPLACE(R32G32B32A32_SSCALED,R32G32B32A32_FLOAT);
417 default:;
418 }
419 }
420
421 native_attribs[i].src_format = format;
422 ve->native_format[i] = format;
423 ve->native_format_size[i] =
424 util_format_get_blocksize(ve->native_format[i]);
425
426 ve->incompatible_layout_elem[i] =
427 ve->ve[i].src_format != ve->native_format[i] ||
428 (!mgr->b.caps.fetch_dword_unaligned && ve->ve[i].src_offset % 4 != 0);
429 ve->incompatible_layout =
430 ve->incompatible_layout ||
431 ve->incompatible_layout_elem[i];
432 }
433
434 /* Align the formats to the size of DWORD if needed. */
435 if (!mgr->b.caps.fetch_dword_unaligned) {
436 for (i = 0; i < count; i++) {
437 ve->native_format_size[i] = align(ve->native_format_size[i], 4);
438 }
439 }
440
441 return ve;
442 }
443
444 void u_vbuf_bind_vertex_elements(struct u_vbuf *mgrb,
445 void *cso,
446 struct u_vbuf_elements *ve)
447 {
448 struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
449
450 if (!cso) {
451 return;
452 }
453
454 if (!mgr->ve_binding_lock) {
455 mgr->saved_ve = cso;
456 mgr->ve = ve;
457 }
458 }
459
460 void u_vbuf_destroy_vertex_elements(struct u_vbuf *mgr,
461 struct u_vbuf_elements *ve)
462 {
463 FREE(ve);
464 }
465
466 void u_vbuf_set_vertex_buffers(struct u_vbuf *mgrb,
467 unsigned count,
468 const struct pipe_vertex_buffer *bufs)
469 {
470 struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
471 unsigned i;
472
473 mgr->any_user_vbs = FALSE;
474 mgr->incompatible_vb_layout = FALSE;
475 memset(mgr->incompatible_vb, 0, sizeof(mgr->incompatible_vb));
476
477 if (!mgr->b.caps.fetch_dword_unaligned) {
478 /* Check if the strides and offsets are aligned to the size of DWORD. */
479 for (i = 0; i < count; i++) {
480 if (bufs[i].buffer) {
481 if (bufs[i].stride % 4 != 0 ||
482 bufs[i].buffer_offset % 4 != 0) {
483 mgr->incompatible_vb_layout = TRUE;
484 mgr->incompatible_vb[i] = TRUE;
485 }
486 }
487 }
488 }
489
490 for (i = 0; i < count; i++) {
491 const struct pipe_vertex_buffer *vb = &bufs[i];
492
493 pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, vb->buffer);
494
495 mgr->b.real_vertex_buffer[i].buffer_offset =
496 mgr->b.vertex_buffer[i].buffer_offset = vb->buffer_offset;
497
498 mgr->b.real_vertex_buffer[i].stride =
499 mgr->b.vertex_buffer[i].stride = vb->stride;
500
501 if (!vb->buffer ||
502 mgr->incompatible_vb[i]) {
503 pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
504 continue;
505 }
506
507 if (u_vbuf_resource(vb->buffer)->user_ptr) {
508 pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
509 mgr->any_user_vbs = TRUE;
510 continue;
511 }
512
513 pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, vb->buffer);
514 }
515
516 for (i = count; i < mgr->b.nr_vertex_buffers; i++) {
517 pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, NULL);
518 }
519 for (i = count; i < mgr->b.nr_real_vertex_buffers; i++) {
520 pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
521 }
522
523 mgr->b.nr_vertex_buffers = count;
524 mgr->b.nr_real_vertex_buffers = count;
525 }
526
527 void u_vbuf_set_index_buffer(struct u_vbuf *mgr,
528 const struct pipe_index_buffer *ib)
529 {
530 if (ib && ib->buffer) {
531 assert(ib->offset % ib->index_size == 0);
532 pipe_resource_reference(&mgr->index_buffer.buffer, ib->buffer);
533 mgr->index_buffer.offset = ib->offset;
534 mgr->index_buffer.index_size = ib->index_size;
535 } else {
536 pipe_resource_reference(&mgr->index_buffer.buffer, NULL);
537 }
538 }
539
540 static void
541 u_vbuf_upload_buffers(struct u_vbuf_priv *mgr,
542 int min_index, int max_index,
543 unsigned instance_count)
544 {
545 unsigned i;
546 unsigned count = max_index + 1 - min_index;
547 unsigned nr_velems = mgr->ve->count;
548 unsigned nr_vbufs = mgr->b.nr_vertex_buffers;
549 struct pipe_vertex_element *velems =
550 mgr->fallback_ve ? mgr->fallback_velems : mgr->ve->ve;
551 unsigned start_offset[PIPE_MAX_ATTRIBS];
552 unsigned end_offset[PIPE_MAX_ATTRIBS] = {0};
553
554 /* Determine how much data needs to be uploaded. */
555 for (i = 0; i < nr_velems; i++) {
556 struct pipe_vertex_element *velem = &velems[i];
557 unsigned index = velem->vertex_buffer_index;
558 struct pipe_vertex_buffer *vb = &mgr->b.vertex_buffer[index];
559 unsigned instance_div, first, size;
560
561 /* Skip the buffer generated by translate. */
562 if (index == mgr->fallback_vb_slot) {
563 continue;
564 }
565
566 assert(vb->buffer);
567
568 if (!u_vbuf_resource(vb->buffer)->user_ptr) {
569 continue;
570 }
571
572 instance_div = velem->instance_divisor;
573 first = vb->buffer_offset + velem->src_offset;
574
575 if (!vb->stride) {
576 /* Constant attrib. */
577 size = mgr->ve->src_format_size[i];
578 } else if (instance_div) {
579 /* Per-instance attrib. */
580 unsigned count = (instance_count + instance_div - 1) / instance_div;
581 size = vb->stride * (count - 1) + mgr->ve->src_format_size[i];
582 } else {
583 /* Per-vertex attrib. */
584 first += vb->stride * min_index;
585 size = vb->stride * (count - 1) + mgr->ve->src_format_size[i];
586 }
587
588 /* Update offsets. */
589 if (!end_offset[index]) {
590 start_offset[index] = first;
591 end_offset[index] = first + size;
592 } else {
593 if (first < start_offset[index])
594 start_offset[index] = first;
595 if (first + size > end_offset[index])
596 end_offset[index] = first + size;
597 }
598 }
599
600 /* Upload buffers. */
601 for (i = 0; i < nr_vbufs; i++) {
602 unsigned start, end = end_offset[i];
603 boolean flushed;
604 struct pipe_vertex_buffer *real_vb;
605 uint8_t *ptr;
606
607 if (!end) {
608 continue;
609 }
610
611 start = start_offset[i];
612 assert(start < end);
613
614 real_vb = &mgr->b.real_vertex_buffer[i];
615 ptr = u_vbuf_resource(mgr->b.vertex_buffer[i].buffer)->user_ptr;
616
617 u_upload_data(mgr->b.uploader, start, end - start, ptr + start,
618 &real_vb->buffer_offset, &real_vb->buffer, &flushed);
619
620 real_vb->buffer_offset -= start;
621 }
622 }
623
624 unsigned u_vbuf_draw_max_vertex_count(struct u_vbuf *mgrb)
625 {
626 struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
627 unsigned i, nr = mgr->ve->count;
628 struct pipe_vertex_element *velems =
629 mgr->fallback_ve ? mgr->fallback_velems : mgr->ve->ve;
630 unsigned result = ~0;
631
632 for (i = 0; i < nr; i++) {
633 struct pipe_vertex_buffer *vb =
634 &mgr->b.real_vertex_buffer[velems[i].vertex_buffer_index];
635 unsigned size, max_count, value;
636
637 /* We're not interested in constant and per-instance attribs. */
638 if (!vb->buffer ||
639 !vb->stride ||
640 velems[i].instance_divisor) {
641 continue;
642 }
643
644 size = vb->buffer->width0;
645
646 /* Subtract buffer_offset. */
647 value = vb->buffer_offset;
648 if (value >= size) {
649 return 0;
650 }
651 size -= value;
652
653 /* Subtract src_offset. */
654 value = velems[i].src_offset;
655 if (value >= size) {
656 return 0;
657 }
658 size -= value;
659
660 /* Subtract format_size. */
661 value = mgr->ve->native_format_size[i];
662 if (value >= size) {
663 return 0;
664 }
665 size -= value;
666
667 /* Compute the max count. */
668 max_count = 1 + size / vb->stride;
669 result = MIN2(result, max_count);
670 }
671 return result;
672 }
673
674 static boolean u_vbuf_need_minmax_index(struct u_vbuf_priv *mgr)
675 {
676 unsigned i, nr = mgr->ve->count;
677
678 for (i = 0; i < nr; i++) {
679 struct pipe_vertex_buffer *vb;
680 unsigned index;
681
682 /* Per-instance attribs don't need min/max_index. */
683 if (mgr->ve->ve[i].instance_divisor) {
684 continue;
685 }
686
687 index = mgr->ve->ve[i].vertex_buffer_index;
688 vb = &mgr->b.vertex_buffer[index];
689
690 /* Constant attribs don't need min/max_index. */
691 if (!vb->stride) {
692 continue;
693 }
694
695 /* Per-vertex attribs need min/max_index. */
696 if (u_vbuf_resource(vb->buffer)->user_ptr ||
697 mgr->ve->incompatible_layout_elem[i] ||
698 mgr->incompatible_vb[index]) {
699 return TRUE;
700 }
701 }
702
703 return FALSE;
704 }
705
706 static void u_vbuf_get_minmax_index(struct pipe_context *pipe,
707 struct pipe_index_buffer *ib,
708 const struct pipe_draw_info *info,
709 int *out_min_index,
710 int *out_max_index)
711 {
712 struct pipe_transfer *transfer = NULL;
713 const void *indices;
714 unsigned i;
715 unsigned restart_index = info->restart_index;
716
717 if (u_vbuf_resource(ib->buffer)->user_ptr) {
718 indices = u_vbuf_resource(ib->buffer)->user_ptr +
719 ib->offset + info->start * ib->index_size;
720 } else {
721 indices = pipe_buffer_map_range(pipe, ib->buffer,
722 ib->offset + info->start * ib->index_size,
723 info->count * ib->index_size,
724 PIPE_TRANSFER_READ, &transfer);
725 }
726
727 switch (ib->index_size) {
728 case 4: {
729 const unsigned *ui_indices = (const unsigned*)indices;
730 unsigned max_ui = 0;
731 unsigned min_ui = ~0U;
732 if (info->primitive_restart) {
733 for (i = 0; i < info->count; i++) {
734 if (ui_indices[i] != restart_index) {
735 if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
736 if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
737 }
738 }
739 }
740 else {
741 for (i = 0; i < info->count; i++) {
742 if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
743 if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
744 }
745 }
746 *out_min_index = min_ui;
747 *out_max_index = max_ui;
748 break;
749 }
750 case 2: {
751 const unsigned short *us_indices = (const unsigned short*)indices;
752 unsigned max_us = 0;
753 unsigned min_us = ~0U;
754 if (info->primitive_restart) {
755 for (i = 0; i < info->count; i++) {
756 if (us_indices[i] != restart_index) {
757 if (us_indices[i] > max_us) max_us = us_indices[i];
758 if (us_indices[i] < min_us) min_us = us_indices[i];
759 }
760 }
761 }
762 else {
763 for (i = 0; i < info->count; i++) {
764 if (us_indices[i] > max_us) max_us = us_indices[i];
765 if (us_indices[i] < min_us) min_us = us_indices[i];
766 }
767 }
768 *out_min_index = min_us;
769 *out_max_index = max_us;
770 break;
771 }
772 case 1: {
773 const unsigned char *ub_indices = (const unsigned char*)indices;
774 unsigned max_ub = 0;
775 unsigned min_ub = ~0U;
776 if (info->primitive_restart) {
777 for (i = 0; i < info->count; i++) {
778 if (ub_indices[i] != restart_index) {
779 if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
780 if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
781 }
782 }
783 }
784 else {
785 for (i = 0; i < info->count; i++) {
786 if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
787 if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
788 }
789 }
790 *out_min_index = min_ub;
791 *out_max_index = max_ub;
792 break;
793 }
794 default:
795 assert(0);
796 *out_min_index = 0;
797 *out_max_index = 0;
798 }
799
800 if (transfer) {
801 pipe_buffer_unmap(pipe, transfer);
802 }
803 }
804
805 enum u_vbuf_return_flags
806 u_vbuf_draw_begin(struct u_vbuf *mgrb,
807 const struct pipe_draw_info *info)
808 {
809 struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
810 int min_index, max_index;
811
812 if (!mgr->incompatible_vb_layout &&
813 !mgr->ve->incompatible_layout &&
814 !mgr->any_user_vbs) {
815 return 0;
816 }
817
818 if (info->indexed) {
819 if (info->max_index != ~0) {
820 min_index = info->min_index + info->index_bias;
821 max_index = info->max_index + info->index_bias;
822 } else if (u_vbuf_need_minmax_index(mgr)) {
823 u_vbuf_get_minmax_index(mgr->pipe, &mgr->b.index_buffer, info,
824 &min_index, &max_index);
825 min_index += info->index_bias;
826 max_index += info->index_bias;
827 } else {
828 min_index = 0;
829 max_index = 0;
830 }
831 } else {
832 min_index = info->start;
833 max_index = info->start + info->count - 1;
834 }
835
836 /* Translate vertices with non-native layouts or formats. */
837 if (mgr->incompatible_vb_layout || mgr->ve->incompatible_layout) {
838 u_vbuf_translate_begin(mgr, min_index, max_index);
839 }
840
841 /* Upload user buffers. */
842 if (mgr->any_user_vbs) {
843 u_vbuf_upload_buffers(mgr, min_index, max_index, info->instance_count);
844 }
845 return U_VBUF_BUFFERS_UPDATED;
846 }
847
848 void u_vbuf_draw_end(struct u_vbuf *mgrb)
849 {
850 struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
851
852 if (mgr->fallback_ve) {
853 u_vbuf_translate_end(mgr);
854 }
855 }