1 /*
2 * Copyright 2003 VMware, Inc.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial portions
15 * of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
21 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26 #include "main/bufferobj.h"
27 #include "main/context.h"
28 #include "main/enums.h"
29 #include "main/macros.h"
30 #include "main/glformats.h"
31
32 #include "brw_draw.h"
33 #include "brw_defines.h"
34 #include "brw_context.h"
35 #include "brw_state.h"
36
37 #include "intel_batchbuffer.h"
38 #include "intel_buffer_objects.h"
39
40 static const GLuint double_types_float[5] = {
41 0,
42 ISL_FORMAT_R64_FLOAT,
43 ISL_FORMAT_R64G64_FLOAT,
44 ISL_FORMAT_R64G64B64_FLOAT,
45 ISL_FORMAT_R64G64B64A64_FLOAT
46 };
47
48 static const GLuint double_types_passthru[5] = {
49 0,
50 ISL_FORMAT_R64_PASSTHRU,
51 ISL_FORMAT_R64G64_PASSTHRU,
52 ISL_FORMAT_R64G64B64_PASSTHRU,
53 ISL_FORMAT_R64G64B64A64_PASSTHRU
54 };
55
56 static const GLuint float_types[5] = {
57 0,
58 ISL_FORMAT_R32_FLOAT,
59 ISL_FORMAT_R32G32_FLOAT,
60 ISL_FORMAT_R32G32B32_FLOAT,
61 ISL_FORMAT_R32G32B32A32_FLOAT
62 };
63
64 static const GLuint half_float_types[5] = {
65 0,
66 ISL_FORMAT_R16_FLOAT,
67 ISL_FORMAT_R16G16_FLOAT,
68 ISL_FORMAT_R16G16B16_FLOAT,
69 ISL_FORMAT_R16G16B16A16_FLOAT
70 };
71
72 static const GLuint fixed_point_types[5] = {
73 0,
74 ISL_FORMAT_R32_SFIXED,
75 ISL_FORMAT_R32G32_SFIXED,
76 ISL_FORMAT_R32G32B32_SFIXED,
77 ISL_FORMAT_R32G32B32A32_SFIXED,
78 };
79
80 static const GLuint uint_types_direct[5] = {
81 0,
82 ISL_FORMAT_R32_UINT,
83 ISL_FORMAT_R32G32_UINT,
84 ISL_FORMAT_R32G32B32_UINT,
85 ISL_FORMAT_R32G32B32A32_UINT
86 };
87
88 static const GLuint uint_types_norm[5] = {
89 0,
90 ISL_FORMAT_R32_UNORM,
91 ISL_FORMAT_R32G32_UNORM,
92 ISL_FORMAT_R32G32B32_UNORM,
93 ISL_FORMAT_R32G32B32A32_UNORM
94 };
95
96 static const GLuint uint_types_scale[5] = {
97 0,
98 ISL_FORMAT_R32_USCALED,
99 ISL_FORMAT_R32G32_USCALED,
100 ISL_FORMAT_R32G32B32_USCALED,
101 ISL_FORMAT_R32G32B32A32_USCALED
102 };
103
104 static const GLuint int_types_direct[5] = {
105 0,
106 ISL_FORMAT_R32_SINT,
107 ISL_FORMAT_R32G32_SINT,
108 ISL_FORMAT_R32G32B32_SINT,
109 ISL_FORMAT_R32G32B32A32_SINT
110 };
111
112 static const GLuint int_types_norm[5] = {
113 0,
114 ISL_FORMAT_R32_SNORM,
115 ISL_FORMAT_R32G32_SNORM,
116 ISL_FORMAT_R32G32B32_SNORM,
117 ISL_FORMAT_R32G32B32A32_SNORM
118 };
119
120 static const GLuint int_types_scale[5] = {
121 0,
122 ISL_FORMAT_R32_SSCALED,
123 ISL_FORMAT_R32G32_SSCALED,
124 ISL_FORMAT_R32G32B32_SSCALED,
125 ISL_FORMAT_R32G32B32A32_SSCALED
126 };
127
128 static const GLuint ushort_types_direct[5] = {
129 0,
130 ISL_FORMAT_R16_UINT,
131 ISL_FORMAT_R16G16_UINT,
132 ISL_FORMAT_R16G16B16_UINT,
133 ISL_FORMAT_R16G16B16A16_UINT
134 };
135
136 static const GLuint ushort_types_norm[5] = {
137 0,
138 ISL_FORMAT_R16_UNORM,
139 ISL_FORMAT_R16G16_UNORM,
140 ISL_FORMAT_R16G16B16_UNORM,
141 ISL_FORMAT_R16G16B16A16_UNORM
142 };
143
144 static const GLuint ushort_types_scale[5] = {
145 0,
146 ISL_FORMAT_R16_USCALED,
147 ISL_FORMAT_R16G16_USCALED,
148 ISL_FORMAT_R16G16B16_USCALED,
149 ISL_FORMAT_R16G16B16A16_USCALED
150 };
151
152 static const GLuint short_types_direct[5] = {
153 0,
154 ISL_FORMAT_R16_SINT,
155 ISL_FORMAT_R16G16_SINT,
156 ISL_FORMAT_R16G16B16_SINT,
157 ISL_FORMAT_R16G16B16A16_SINT
158 };
159
160 static const GLuint short_types_norm[5] = {
161 0,
162 ISL_FORMAT_R16_SNORM,
163 ISL_FORMAT_R16G16_SNORM,
164 ISL_FORMAT_R16G16B16_SNORM,
165 ISL_FORMAT_R16G16B16A16_SNORM
166 };
167
168 static const GLuint short_types_scale[5] = {
169 0,
170 ISL_FORMAT_R16_SSCALED,
171 ISL_FORMAT_R16G16_SSCALED,
172 ISL_FORMAT_R16G16B16_SSCALED,
173 ISL_FORMAT_R16G16B16A16_SSCALED
174 };
175
176 static const GLuint ubyte_types_direct[5] = {
177 0,
178 ISL_FORMAT_R8_UINT,
179 ISL_FORMAT_R8G8_UINT,
180 ISL_FORMAT_R8G8B8_UINT,
181 ISL_FORMAT_R8G8B8A8_UINT
182 };
183
184 static const GLuint ubyte_types_norm[5] = {
185 0,
186 ISL_FORMAT_R8_UNORM,
187 ISL_FORMAT_R8G8_UNORM,
188 ISL_FORMAT_R8G8B8_UNORM,
189 ISL_FORMAT_R8G8B8A8_UNORM
190 };
191
192 static const GLuint ubyte_types_scale[5] = {
193 0,
194 ISL_FORMAT_R8_USCALED,
195 ISL_FORMAT_R8G8_USCALED,
196 ISL_FORMAT_R8G8B8_USCALED,
197 ISL_FORMAT_R8G8B8A8_USCALED
198 };
199
200 static const GLuint byte_types_direct[5] = {
201 0,
202 ISL_FORMAT_R8_SINT,
203 ISL_FORMAT_R8G8_SINT,
204 ISL_FORMAT_R8G8B8_SINT,
205 ISL_FORMAT_R8G8B8A8_SINT
206 };
207
208 static const GLuint byte_types_norm[5] = {
209 0,
210 ISL_FORMAT_R8_SNORM,
211 ISL_FORMAT_R8G8_SNORM,
212 ISL_FORMAT_R8G8B8_SNORM,
213 ISL_FORMAT_R8G8B8A8_SNORM
214 };
215
216 static const GLuint byte_types_scale[5] = {
217 0,
218 ISL_FORMAT_R8_SSCALED,
219 ISL_FORMAT_R8G8_SSCALED,
220 ISL_FORMAT_R8G8B8_SSCALED,
221 ISL_FORMAT_R8G8B8A8_SSCALED
222 };
223
224 static GLuint
double_types(struct brw_context * brw,int size,GLboolean doubles)225 double_types(struct brw_context *brw,
226 int size,
227 GLboolean doubles)
228 {
229 /* From the BDW PRM, Volume 2d, page 588 (VERTEX_ELEMENT_STATE):
230 * "When SourceElementFormat is set to one of the *64*_PASSTHRU formats,
231 * 64-bit components are stored in the URB without any conversion."
232 * Also included on BDW PRM, Volume 7, page 470, table "Source Element
233 * Formats Supported in VF Unit"
234 *
235 * Previous PRMs don't include those references, so for gen7 we can't use
236 * PASSTHRU formats directly. But in any case, we prefer to return passthru
237 * even in that case, because that reflects what we want to achieve, even
238 * if we would need to workaround on gen < 8.
239 */
240 return (doubles
241 ? double_types_passthru[size]
242 : double_types_float[size]);
243 }
244
245 /**
246 * Given vertex array type/size/format/normalized info, return
247 * the appopriate hardware surface type.
248 * Format will be GL_RGBA or possibly GL_BGRA for GLubyte[4] color arrays.
249 */
250 unsigned
brw_get_vertex_surface_type(struct brw_context * brw,const struct gl_vertex_array * glarray)251 brw_get_vertex_surface_type(struct brw_context *brw,
252 const struct gl_vertex_array *glarray)
253 {
254 int size = glarray->Size;
255 const struct gen_device_info *devinfo = &brw->screen->devinfo;
256 const bool is_ivybridge_or_older =
257 devinfo->gen <= 7 && !devinfo->is_baytrail && !devinfo->is_haswell;
258
259 if (unlikely(INTEL_DEBUG & DEBUG_VERTS))
260 fprintf(stderr, "type %s size %d normalized %d\n",
261 _mesa_enum_to_string(glarray->Type),
262 glarray->Size, glarray->Normalized);
263
264 if (glarray->Integer) {
265 assert(glarray->Format == GL_RGBA); /* sanity check */
266 switch (glarray->Type) {
267 case GL_INT: return int_types_direct[size];
268 case GL_SHORT:
269 if (is_ivybridge_or_older && size == 3)
270 return short_types_direct[4];
271 else
272 return short_types_direct[size];
273 case GL_BYTE:
274 if (is_ivybridge_or_older && size == 3)
275 return byte_types_direct[4];
276 else
277 return byte_types_direct[size];
278 case GL_UNSIGNED_INT: return uint_types_direct[size];
279 case GL_UNSIGNED_SHORT:
280 if (is_ivybridge_or_older && size == 3)
281 return ushort_types_direct[4];
282 else
283 return ushort_types_direct[size];
284 case GL_UNSIGNED_BYTE:
285 if (is_ivybridge_or_older && size == 3)
286 return ubyte_types_direct[4];
287 else
288 return ubyte_types_direct[size];
289 default: unreachable("not reached");
290 }
291 } else if (glarray->Type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
292 return ISL_FORMAT_R11G11B10_FLOAT;
293 } else if (glarray->Normalized) {
294 switch (glarray->Type) {
295 case GL_DOUBLE: return double_types(brw, size, glarray->Doubles);
296 case GL_FLOAT: return float_types[size];
297 case GL_HALF_FLOAT:
298 case GL_HALF_FLOAT_OES:
299 if (devinfo->gen < 6 && size == 3)
300 return half_float_types[4];
301 else
302 return half_float_types[size];
303 case GL_INT: return int_types_norm[size];
304 case GL_SHORT: return short_types_norm[size];
305 case GL_BYTE: return byte_types_norm[size];
306 case GL_UNSIGNED_INT: return uint_types_norm[size];
307 case GL_UNSIGNED_SHORT: return ushort_types_norm[size];
308 case GL_UNSIGNED_BYTE:
309 if (glarray->Format == GL_BGRA) {
310 /* See GL_EXT_vertex_array_bgra */
311 assert(size == 4);
312 return ISL_FORMAT_B8G8R8A8_UNORM;
313 }
314 else {
315 return ubyte_types_norm[size];
316 }
317 case GL_FIXED:
318 if (devinfo->gen >= 8 || devinfo->is_haswell)
319 return fixed_point_types[size];
320
321 /* This produces GL_FIXED inputs as values between INT32_MIN and
322 * INT32_MAX, which will be scaled down by 1/65536 by the VS.
323 */
324 return int_types_scale[size];
325 /* See GL_ARB_vertex_type_2_10_10_10_rev.
326 * W/A: Pre-Haswell, the hardware doesn't really support the formats we'd
327 * like to use here, so upload everything as UINT and fix
328 * it in the shader
329 */
330 case GL_INT_2_10_10_10_REV:
331 assert(size == 4);
332 if (devinfo->gen >= 8 || devinfo->is_haswell) {
333 return glarray->Format == GL_BGRA
334 ? ISL_FORMAT_B10G10R10A2_SNORM
335 : ISL_FORMAT_R10G10B10A2_SNORM;
336 }
337 return ISL_FORMAT_R10G10B10A2_UINT;
338 case GL_UNSIGNED_INT_2_10_10_10_REV:
339 assert(size == 4);
340 if (devinfo->gen >= 8 || devinfo->is_haswell) {
341 return glarray->Format == GL_BGRA
342 ? ISL_FORMAT_B10G10R10A2_UNORM
343 : ISL_FORMAT_R10G10B10A2_UNORM;
344 }
345 return ISL_FORMAT_R10G10B10A2_UINT;
346 default: unreachable("not reached");
347 }
348 }
349 else {
350 /* See GL_ARB_vertex_type_2_10_10_10_rev.
351 * W/A: the hardware doesn't really support the formats we'd
352 * like to use here, so upload everything as UINT and fix
353 * it in the shader
354 */
355 if (glarray->Type == GL_INT_2_10_10_10_REV) {
356 assert(size == 4);
357 if (devinfo->gen >= 8 || devinfo->is_haswell) {
358 return glarray->Format == GL_BGRA
359 ? ISL_FORMAT_B10G10R10A2_SSCALED
360 : ISL_FORMAT_R10G10B10A2_SSCALED;
361 }
362 return ISL_FORMAT_R10G10B10A2_UINT;
363 } else if (glarray->Type == GL_UNSIGNED_INT_2_10_10_10_REV) {
364 assert(size == 4);
365 if (devinfo->gen >= 8 || devinfo->is_haswell) {
366 return glarray->Format == GL_BGRA
367 ? ISL_FORMAT_B10G10R10A2_USCALED
368 : ISL_FORMAT_R10G10B10A2_USCALED;
369 }
370 return ISL_FORMAT_R10G10B10A2_UINT;
371 }
372 assert(glarray->Format == GL_RGBA); /* sanity check */
373 switch (glarray->Type) {
374 case GL_DOUBLE: return double_types(brw, size, glarray->Doubles);
375 case GL_FLOAT: return float_types[size];
376 case GL_HALF_FLOAT:
377 case GL_HALF_FLOAT_OES:
378 if (devinfo->gen < 6 && size == 3)
379 return half_float_types[4];
380 else
381 return half_float_types[size];
382 case GL_INT: return int_types_scale[size];
383 case GL_SHORT: return short_types_scale[size];
384 case GL_BYTE: return byte_types_scale[size];
385 case GL_UNSIGNED_INT: return uint_types_scale[size];
386 case GL_UNSIGNED_SHORT: return ushort_types_scale[size];
387 case GL_UNSIGNED_BYTE: return ubyte_types_scale[size];
388 case GL_FIXED:
389 if (devinfo->gen >= 8 || devinfo->is_haswell)
390 return fixed_point_types[size];
391
392 /* This produces GL_FIXED inputs as values between INT32_MIN and
393 * INT32_MAX, which will be scaled down by 1/65536 by the VS.
394 */
395 return int_types_scale[size];
396 default: unreachable("not reached");
397 }
398 }
399 }
400
401 static void
copy_array_to_vbo_array(struct brw_context * brw,struct brw_vertex_element * element,int min,int max,struct brw_vertex_buffer * buffer,GLuint dst_stride)402 copy_array_to_vbo_array(struct brw_context *brw,
403 struct brw_vertex_element *element,
404 int min, int max,
405 struct brw_vertex_buffer *buffer,
406 GLuint dst_stride)
407 {
408 const int src_stride = element->glarray->StrideB;
409
410 /* If the source stride is zero, we just want to upload the current
411 * attribute once and set the buffer's stride to 0. There's no need
412 * to replicate it out.
413 */
414 if (src_stride == 0) {
415 intel_upload_data(brw, element->glarray->Ptr,
416 element->glarray->_ElementSize,
417 element->glarray->_ElementSize,
418 &buffer->bo, &buffer->offset);
419
420 buffer->stride = 0;
421 buffer->size = element->glarray->_ElementSize;
422 return;
423 }
424
425 const unsigned char *src = element->glarray->Ptr + min * src_stride;
426 int count = max - min + 1;
427 GLuint size = count * dst_stride;
428 uint8_t *dst = intel_upload_space(brw, size, dst_stride,
429 &buffer->bo, &buffer->offset);
430
431 /* The GL 4.5 spec says:
432 * "If any enabled array’s buffer binding is zero when DrawArrays or
433 * one of the other drawing commands defined in section 10.4 is called,
434 * the result is undefined."
435 *
436 * In this case, let's the dst with undefined values
437 */
438 if (src != NULL) {
439 if (dst_stride == src_stride) {
440 memcpy(dst, src, size);
441 } else {
442 while (count--) {
443 memcpy(dst, src, dst_stride);
444 src += src_stride;
445 dst += dst_stride;
446 }
447 }
448 }
449 buffer->stride = dst_stride;
450 buffer->size = size;
451 }
452
453 void
brw_prepare_vertices(struct brw_context * brw)454 brw_prepare_vertices(struct brw_context *brw)
455 {
456 const struct gen_device_info *devinfo = &brw->screen->devinfo;
457 struct gl_context *ctx = &brw->ctx;
458 /* BRW_NEW_VS_PROG_DATA */
459 const struct brw_vs_prog_data *vs_prog_data =
460 brw_vs_prog_data(brw->vs.base.prog_data);
461 GLbitfield64 vs_inputs = vs_prog_data->inputs_read;
462 const unsigned char *ptr = NULL;
463 GLuint interleaved = 0;
464 unsigned int min_index = brw->vb.min_index + brw->basevertex;
465 unsigned int max_index = brw->vb.max_index + brw->basevertex;
466 unsigned i;
467 int delta, j;
468
469 struct brw_vertex_element *upload[VERT_ATTRIB_MAX];
470 GLuint nr_uploads = 0;
471
472 /* _NEW_POLYGON
473 *
474 * On gen6+, edge flags don't end up in the VUE (either in or out of the
475 * VS). Instead, they're uploaded as the last vertex element, and the data
476 * is passed sideband through the fixed function units. So, we need to
477 * prepare the vertex buffer for it, but it's not present in inputs_read.
478 */
479 if (devinfo->gen >= 6 && (ctx->Polygon.FrontMode != GL_FILL ||
480 ctx->Polygon.BackMode != GL_FILL)) {
481 vs_inputs |= VERT_BIT_EDGEFLAG;
482 }
483
484 if (0)
485 fprintf(stderr, "%s %d..%d\n", __func__, min_index, max_index);
486
487 /* Accumulate the list of enabled arrays. */
488 brw->vb.nr_enabled = 0;
489 while (vs_inputs) {
490 GLuint first = ffsll(vs_inputs) - 1;
491 assert (first < 64);
492 GLuint index =
493 first - DIV_ROUND_UP(_mesa_bitcount_64(vs_prog_data->double_inputs_read &
494 BITFIELD64_MASK(first)), 2);
495 struct brw_vertex_element *input = &brw->vb.inputs[index];
496 input->is_dual_slot = (vs_prog_data->double_inputs_read & BITFIELD64_BIT(first)) != 0;
497 vs_inputs &= ~BITFIELD64_BIT(first);
498 if (input->is_dual_slot)
499 vs_inputs &= ~BITFIELD64_BIT(first + 1);
500 brw->vb.enabled[brw->vb.nr_enabled++] = input;
501 }
502
503 if (brw->vb.nr_enabled == 0)
504 return;
505
506 if (brw->vb.nr_buffers)
507 return;
508
509 /* The range of data in a given buffer represented as [min, max) */
510 struct intel_buffer_object *enabled_buffer[VERT_ATTRIB_MAX];
511 uint32_t buffer_range_start[VERT_ATTRIB_MAX];
512 uint32_t buffer_range_end[VERT_ATTRIB_MAX];
513
514 for (i = j = 0; i < brw->vb.nr_enabled; i++) {
515 struct brw_vertex_element *input = brw->vb.enabled[i];
516 const struct gl_vertex_array *glarray = input->glarray;
517
518 if (_mesa_is_bufferobj(glarray->BufferObj)) {
519 struct intel_buffer_object *intel_buffer =
520 intel_buffer_object(glarray->BufferObj);
521
522 const uint32_t offset = (uintptr_t)glarray->Ptr;
523
524 /* Start with the worst case */
525 uint32_t start = 0;
526 uint32_t range = intel_buffer->Base.Size;
527 if (glarray->InstanceDivisor) {
528 if (brw->num_instances) {
529 start = offset + glarray->StrideB * brw->baseinstance;
530 range = (glarray->StrideB * ((brw->num_instances - 1) /
531 glarray->InstanceDivisor) +
532 glarray->_ElementSize);
533 }
534 } else {
535 if (brw->vb.index_bounds_valid) {
536 start = offset + min_index * glarray->StrideB;
537 range = (glarray->StrideB * (max_index - min_index) +
538 glarray->_ElementSize);
539 }
540 }
541
542 /* If we have a VB set to be uploaded for this buffer object
543 * already, reuse that VB state so that we emit fewer
544 * relocations.
545 */
546 unsigned k;
547 for (k = 0; k < i; k++) {
548 const struct gl_vertex_array *other = brw->vb.enabled[k]->glarray;
549 if (glarray->BufferObj == other->BufferObj &&
550 glarray->StrideB == other->StrideB &&
551 glarray->InstanceDivisor == other->InstanceDivisor &&
552 (uintptr_t)(glarray->Ptr - other->Ptr) < glarray->StrideB)
553 {
554 input->buffer = brw->vb.enabled[k]->buffer;
555 input->offset = glarray->Ptr - other->Ptr;
556
557 buffer_range_start[input->buffer] =
558 MIN2(buffer_range_start[input->buffer], start);
559 buffer_range_end[input->buffer] =
560 MAX2(buffer_range_end[input->buffer], start + range);
561 break;
562 }
563 }
564 if (k == i) {
565 struct brw_vertex_buffer *buffer = &brw->vb.buffers[j];
566
567 /* Named buffer object: Just reference its contents directly. */
568 buffer->offset = offset;
569 buffer->stride = glarray->StrideB;
570 buffer->step_rate = glarray->InstanceDivisor;
571 buffer->size = glarray->BufferObj->Size - offset;
572
573 enabled_buffer[j] = intel_buffer;
574 buffer_range_start[j] = start;
575 buffer_range_end[j] = start + range;
576
577 input->buffer = j++;
578 input->offset = 0;
579 }
580 } else {
581 /* Queue the buffer object up to be uploaded in the next pass,
582 * when we've decided if we're doing interleaved or not.
583 */
584 if (nr_uploads == 0) {
585 interleaved = glarray->StrideB;
586 ptr = glarray->Ptr;
587 }
588 else if (interleaved != glarray->StrideB ||
589 glarray->InstanceDivisor != 0 ||
590 glarray->Ptr < ptr ||
591 (uintptr_t)(glarray->Ptr - ptr) + glarray->_ElementSize > interleaved)
592 {
593 /* If our stride is different from the first attribute's stride,
594 * or if we are using an instance divisor or if the first
595 * attribute's stride didn't cover our element, disable the
596 * interleaved upload optimization. The second case can most
597 * commonly occur in cases where there is a single vertex and, for
598 * example, the data is stored on the application's stack.
599 *
600 * NOTE: This will also disable the optimization in cases where
601 * the data is in a different order than the array indices.
602 * Something like:
603 *
604 * float data[...];
605 * glVertexAttribPointer(0, 4, GL_FLOAT, 32, &data[4]);
606 * glVertexAttribPointer(1, 4, GL_FLOAT, 32, &data[0]);
607 */
608 interleaved = 0;
609 }
610
611 upload[nr_uploads++] = input;
612 }
613 }
614
615 /* Now that we've set up all of the buffers, we walk through and reference
616 * each of them. We do this late so that we get the right size in each
617 * buffer and don't reference too little data.
618 */
619 for (i = 0; i < j; i++) {
620 struct brw_vertex_buffer *buffer = &brw->vb.buffers[i];
621 if (buffer->bo)
622 continue;
623
624 const uint32_t start = buffer_range_start[i];
625 const uint32_t range = buffer_range_end[i] - buffer_range_start[i];
626
627 buffer->bo = intel_bufferobj_buffer(brw, enabled_buffer[i], start,
628 range, false);
629 brw_bo_reference(buffer->bo);
630 }
631
632 /* If we need to upload all the arrays, then we can trim those arrays to
633 * only the used elements [min_index, max_index] so long as we adjust all
634 * the values used in the 3DPRIMITIVE i.e. by setting the vertex bias.
635 */
636 brw->vb.start_vertex_bias = 0;
637 delta = min_index;
638 if (nr_uploads == brw->vb.nr_enabled) {
639 brw->vb.start_vertex_bias = -delta;
640 delta = 0;
641 }
642
643 /* Handle any arrays to be uploaded. */
644 if (nr_uploads > 1) {
645 if (interleaved) {
646 struct brw_vertex_buffer *buffer = &brw->vb.buffers[j];
647 /* All uploads are interleaved, so upload the arrays together as
648 * interleaved. First, upload the contents and set up upload[0].
649 */
650 copy_array_to_vbo_array(brw, upload[0], min_index, max_index,
651 buffer, interleaved);
652 buffer->offset -= delta * interleaved;
653 buffer->size += delta * interleaved;
654 buffer->step_rate = 0;
655
656 for (i = 0; i < nr_uploads; i++) {
657 /* Then, just point upload[i] at upload[0]'s buffer. */
658 upload[i]->offset =
659 ((const unsigned char *)upload[i]->glarray->Ptr - ptr);
660 upload[i]->buffer = j;
661 }
662 j++;
663
664 nr_uploads = 0;
665 }
666 }
667 /* Upload non-interleaved arrays */
668 for (i = 0; i < nr_uploads; i++) {
669 struct brw_vertex_buffer *buffer = &brw->vb.buffers[j];
670 if (upload[i]->glarray->InstanceDivisor == 0) {
671 copy_array_to_vbo_array(brw, upload[i], min_index, max_index,
672 buffer, upload[i]->glarray->_ElementSize);
673 } else {
674 /* This is an instanced attribute, since its InstanceDivisor
675 * is not zero. Therefore, its data will be stepped after the
676 * instanced draw has been run InstanceDivisor times.
677 */
678 uint32_t instanced_attr_max_index =
679 (brw->num_instances - 1) / upload[i]->glarray->InstanceDivisor;
680 copy_array_to_vbo_array(brw, upload[i], 0, instanced_attr_max_index,
681 buffer, upload[i]->glarray->_ElementSize);
682 }
683 buffer->offset -= delta * buffer->stride;
684 buffer->size += delta * buffer->stride;
685 buffer->step_rate = upload[i]->glarray->InstanceDivisor;
686 upload[i]->buffer = j++;
687 upload[i]->offset = 0;
688 }
689
690 brw->vb.nr_buffers = j;
691 }
692
693 void
brw_prepare_shader_draw_parameters(struct brw_context * brw)694 brw_prepare_shader_draw_parameters(struct brw_context *brw)
695 {
696 const struct brw_vs_prog_data *vs_prog_data =
697 brw_vs_prog_data(brw->vs.base.prog_data);
698
699 /* For non-indirect draws, upload gl_BaseVertex. */
700 if ((vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) &&
701 brw->draw.draw_params_bo == NULL) {
702 intel_upload_data(brw, &brw->draw.params, sizeof(brw->draw.params), 4,
703 &brw->draw.draw_params_bo,
704 &brw->draw.draw_params_offset);
705 }
706
707 if (vs_prog_data->uses_drawid) {
708 intel_upload_data(brw, &brw->draw.gl_drawid, sizeof(brw->draw.gl_drawid), 4,
709 &brw->draw.draw_id_bo,
710 &brw->draw.draw_id_offset);
711 }
712 }
713
714 static void
brw_upload_indices(struct brw_context * brw)715 brw_upload_indices(struct brw_context *brw)
716 {
717 const struct _mesa_index_buffer *index_buffer = brw->ib.ib;
718 GLuint ib_size;
719 struct brw_bo *old_bo = brw->ib.bo;
720 struct gl_buffer_object *bufferobj;
721 GLuint offset;
722 GLuint ib_type_size;
723
724 if (index_buffer == NULL)
725 return;
726
727 ib_type_size = index_buffer->index_size;
728 ib_size = index_buffer->count ? ib_type_size * index_buffer->count :
729 index_buffer->obj->Size;
730 bufferobj = index_buffer->obj;
731
732 /* Turn into a proper VBO:
733 */
734 if (!_mesa_is_bufferobj(bufferobj)) {
735 /* Get new bufferobj, offset:
736 */
737 intel_upload_data(brw, index_buffer->ptr, ib_size, ib_type_size,
738 &brw->ib.bo, &offset);
739 brw->ib.size = brw->ib.bo->size;
740 } else {
741 offset = (GLuint) (unsigned long) index_buffer->ptr;
742
743 struct brw_bo *bo =
744 intel_bufferobj_buffer(brw, intel_buffer_object(bufferobj),
745 offset, ib_size, false);
746 if (bo != brw->ib.bo) {
747 brw_bo_unreference(brw->ib.bo);
748 brw->ib.bo = bo;
749 brw->ib.size = bufferobj->Size;
750 brw_bo_reference(bo);
751 }
752 }
753
754 /* Use 3DPRIMITIVE's start_vertex_offset to avoid re-uploading
755 * the index buffer state when we're just moving the start index
756 * of our drawing.
757 */
758 brw->ib.start_vertex_offset = offset / ib_type_size;
759
760 if (brw->ib.bo != old_bo)
761 brw->ctx.NewDriverState |= BRW_NEW_INDEX_BUFFER;
762
763 if (index_buffer->index_size != brw->ib.index_size) {
764 brw->ib.index_size = index_buffer->index_size;
765 brw->ctx.NewDriverState |= BRW_NEW_INDEX_BUFFER;
766 }
767 }
768
769 const struct brw_tracked_state brw_indices = {
770 .dirty = {
771 .mesa = 0,
772 .brw = BRW_NEW_BLORP |
773 BRW_NEW_INDICES,
774 },
775 .emit = brw_upload_indices,
776 };
777