* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+#include "main/arrayobj.h"
#include "main/bufferobj.h"
#include "main/context.h"
#include "main/enums.h"
#include "main/macros.h"
#include "main/glformats.h"
+#include "nir.h"
#include "brw_draw.h"
#include "brw_defines.h"
};
static GLuint
-double_types(struct brw_context *brw,
- int size,
- GLboolean doubles)
+double_types(int size, GLboolean doubles)
{
/* From the BDW PRM, Volume 2d, page 588 (VERTEX_ELEMENT_STATE):
* "When SourceElementFormat is set to one of the *64*_PASSTHRU formats,
*/
unsigned
brw_get_vertex_surface_type(struct brw_context *brw,
- const struct gl_vertex_array *glarray)
+ const struct gl_vertex_format *glformat)
{
- int size = glarray->Size;
+ int size = glformat->Size;
+ const struct gen_device_info *devinfo = &brw->screen->devinfo;
const bool is_ivybridge_or_older =
- brw->gen <= 7 && !brw->is_baytrail && !brw->is_haswell;
+ devinfo->gen <= 7 && !devinfo->is_baytrail && !devinfo->is_haswell;
if (unlikely(INTEL_DEBUG & DEBUG_VERTS))
fprintf(stderr, "type %s size %d normalized %d\n",
- _mesa_enum_to_string(glarray->Type),
- glarray->Size, glarray->Normalized);
+ _mesa_enum_to_string(glformat->Type),
+ glformat->Size, glformat->Normalized);
- if (glarray->Integer) {
- assert(glarray->Format == GL_RGBA); /* sanity check */
- switch (glarray->Type) {
+ if (glformat->Integer) {
+ assert(glformat->Format == GL_RGBA); /* sanity check */
+ switch (glformat->Type) {
case GL_INT: return int_types_direct[size];
case GL_SHORT:
if (is_ivybridge_or_older && size == 3)
return ubyte_types_direct[size];
default: unreachable("not reached");
}
- } else if (glarray->Type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
+ } else if (glformat->Type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
return ISL_FORMAT_R11G11B10_FLOAT;
- } else if (glarray->Normalized) {
- switch (glarray->Type) {
- case GL_DOUBLE: return double_types(brw, size, glarray->Doubles);
+ } else if (glformat->Normalized) {
+ switch (glformat->Type) {
+ case GL_DOUBLE: return double_types(size, glformat->Doubles);
case GL_FLOAT: return float_types[size];
case GL_HALF_FLOAT:
case GL_HALF_FLOAT_OES:
- if (brw->gen < 6 && size == 3)
+ if (devinfo->gen < 6 && size == 3)
return half_float_types[4];
else
return half_float_types[size];
case GL_UNSIGNED_INT: return uint_types_norm[size];
case GL_UNSIGNED_SHORT: return ushort_types_norm[size];
case GL_UNSIGNED_BYTE:
- if (glarray->Format == GL_BGRA) {
+ if (glformat->Format == GL_BGRA) {
/* See GL_EXT_vertex_array_bgra */
assert(size == 4);
return ISL_FORMAT_B8G8R8A8_UNORM;
return ubyte_types_norm[size];
}
case GL_FIXED:
- if (brw->gen >= 8 || brw->is_haswell)
+ if (devinfo->gen >= 8 || devinfo->is_haswell)
return fixed_point_types[size];
/* This produces GL_FIXED inputs as values between INT32_MIN and
*/
case GL_INT_2_10_10_10_REV:
assert(size == 4);
- if (brw->gen >= 8 || brw->is_haswell) {
- return glarray->Format == GL_BGRA
+ if (devinfo->gen >= 8 || devinfo->is_haswell) {
+ return glformat->Format == GL_BGRA
? ISL_FORMAT_B10G10R10A2_SNORM
: ISL_FORMAT_R10G10B10A2_SNORM;
}
return ISL_FORMAT_R10G10B10A2_UINT;
case GL_UNSIGNED_INT_2_10_10_10_REV:
assert(size == 4);
- if (brw->gen >= 8 || brw->is_haswell) {
- return glarray->Format == GL_BGRA
+ if (devinfo->gen >= 8 || devinfo->is_haswell) {
+ return glformat->Format == GL_BGRA
? ISL_FORMAT_B10G10R10A2_UNORM
: ISL_FORMAT_R10G10B10A2_UNORM;
}
* like to use here, so upload everything as UINT and fix
* it in the shader
*/
- if (glarray->Type == GL_INT_2_10_10_10_REV) {
+ if (glformat->Type == GL_INT_2_10_10_10_REV) {
assert(size == 4);
- if (brw->gen >= 8 || brw->is_haswell) {
- return glarray->Format == GL_BGRA
+ if (devinfo->gen >= 8 || devinfo->is_haswell) {
+ return glformat->Format == GL_BGRA
? ISL_FORMAT_B10G10R10A2_SSCALED
: ISL_FORMAT_R10G10B10A2_SSCALED;
}
return ISL_FORMAT_R10G10B10A2_UINT;
- } else if (glarray->Type == GL_UNSIGNED_INT_2_10_10_10_REV) {
+ } else if (glformat->Type == GL_UNSIGNED_INT_2_10_10_10_REV) {
assert(size == 4);
- if (brw->gen >= 8 || brw->is_haswell) {
- return glarray->Format == GL_BGRA
+ if (devinfo->gen >= 8 || devinfo->is_haswell) {
+ return glformat->Format == GL_BGRA
? ISL_FORMAT_B10G10R10A2_USCALED
: ISL_FORMAT_R10G10B10A2_USCALED;
}
return ISL_FORMAT_R10G10B10A2_UINT;
}
- assert(glarray->Format == GL_RGBA); /* sanity check */
- switch (glarray->Type) {
- case GL_DOUBLE: return double_types(brw, size, glarray->Doubles);
+ assert(glformat->Format == GL_RGBA); /* sanity check */
+ switch (glformat->Type) {
+ case GL_DOUBLE: return double_types(size, glformat->Doubles);
case GL_FLOAT: return float_types[size];
case GL_HALF_FLOAT:
case GL_HALF_FLOAT_OES:
- if (brw->gen < 6 && size == 3)
+ if (devinfo->gen < 6 && size == 3)
return half_float_types[4];
else
return half_float_types[size];
case GL_UNSIGNED_SHORT: return ushort_types_scale[size];
case GL_UNSIGNED_BYTE: return ubyte_types_scale[size];
case GL_FIXED:
- if (brw->gen >= 8 || brw->is_haswell)
+ if (devinfo->gen >= 8 || devinfo->is_haswell)
return fixed_point_types[size];
/* This produces GL_FIXED inputs as values between INT32_MIN and
static void
copy_array_to_vbo_array(struct brw_context *brw,
- struct brw_vertex_element *element,
+ const uint8_t *const ptr, const int src_stride,
int min, int max,
struct brw_vertex_buffer *buffer,
GLuint dst_stride)
{
- const int src_stride = element->glarray->StrideB;
-
- /* If the source stride is zero, we just want to upload the current
- * attribute once and set the buffer's stride to 0. There's no need
- * to replicate it out.
- */
- if (src_stride == 0) {
- intel_upload_data(brw, element->glarray->Ptr,
- element->glarray->_ElementSize,
- element->glarray->_ElementSize,
- &buffer->bo, &buffer->offset);
-
- buffer->stride = 0;
- buffer->size = element->glarray->_ElementSize;
- return;
- }
-
- const unsigned char *src = element->glarray->Ptr + min * src_stride;
+ const unsigned char *src = ptr + min * src_stride;
int count = max - min + 1;
GLuint size = count * dst_stride;
- uint8_t *dst = intel_upload_space(brw, size, dst_stride,
- &buffer->bo, &buffer->offset);
+ uint8_t *dst = brw_upload_space(&brw->upload, size, dst_stride,
+ &buffer->bo, &buffer->offset);
/* The GL 4.5 spec says:
* "If any enabled array’s buffer binding is zero when DrawArrays or
*
* In this case, let's the dst with undefined values
*/
- if (src != NULL) {
+ if (ptr != NULL) {
if (dst_stride == src_stride) {
memcpy(dst, src, size);
} else {
void
brw_prepare_vertices(struct brw_context *brw)
{
+ const struct gen_device_info *devinfo = &brw->screen->devinfo;
struct gl_context *ctx = &brw->ctx;
+ /* BRW_NEW_VERTEX_PROGRAM */
+ const struct gl_program *vp = brw->programs[MESA_SHADER_VERTEX];
/* BRW_NEW_VS_PROG_DATA */
const struct brw_vs_prog_data *vs_prog_data =
brw_vs_prog_data(brw->vs.base.prog_data);
- GLbitfield64 vs_inputs = vs_prog_data->inputs_read;
- const unsigned char *ptr = NULL;
- GLuint interleaved = 0;
+ const uint64_t vs_inputs64 =
+ nir_get_single_slot_attribs_mask(vs_prog_data->inputs_read,
+ vp->DualSlotInputs);
+ assert((vs_inputs64 & ~(uint64_t)VERT_BIT_ALL) == 0);
+ unsigned vs_inputs = (unsigned)vs_inputs64;
unsigned int min_index = brw->vb.min_index + brw->basevertex;
unsigned int max_index = brw->vb.max_index + brw->basevertex;
- unsigned i;
int delta, j;
- struct brw_vertex_element *upload[VERT_ATTRIB_MAX];
- GLuint nr_uploads = 0;
-
/* _NEW_POLYGON
*
* On gen6+, edge flags don't end up in the VUE (either in or out of the
* is passed sideband through the fixed function units. So, we need to
* prepare the vertex buffer for it, but it's not present in inputs_read.
*/
- if (brw->gen >= 6 && (ctx->Polygon.FrontMode != GL_FILL ||
+ if (devinfo->gen >= 6 && (ctx->Polygon.FrontMode != GL_FILL ||
ctx->Polygon.BackMode != GL_FILL)) {
vs_inputs |= VERT_BIT_EDGEFLAG;
}
/* Accumulate the list of enabled arrays. */
brw->vb.nr_enabled = 0;
- while (vs_inputs) {
- GLuint first = ffsll(vs_inputs) - 1;
- assert (first < 64);
- GLuint index =
- first - DIV_ROUND_UP(_mesa_bitcount_64(vs_prog_data->double_inputs_read &
- BITFIELD64_MASK(first)), 2);
- struct brw_vertex_element *input = &brw->vb.inputs[index];
- input->is_dual_slot = (vs_prog_data->double_inputs_read & BITFIELD64_BIT(first)) != 0;
- vs_inputs &= ~BITFIELD64_BIT(first);
- if (input->is_dual_slot)
- vs_inputs &= ~BITFIELD64_BIT(first + 1);
+
+ unsigned mask = vs_inputs;
+ while (mask) {
+ const gl_vert_attrib attr = u_bit_scan(&mask);
+ struct brw_vertex_element *input = &brw->vb.inputs[attr];
brw->vb.enabled[brw->vb.nr_enabled++] = input;
}
+ assert(brw->vb.nr_enabled <= VERT_ATTRIB_MAX);
if (brw->vb.nr_enabled == 0)
return;
if (brw->vb.nr_buffers)
return;
- /* The range of data in a given buffer represented as [min, max) */
- struct intel_buffer_object *enabled_buffer[VERT_ATTRIB_MAX];
- uint32_t buffer_range_start[VERT_ATTRIB_MAX];
- uint32_t buffer_range_end[VERT_ATTRIB_MAX];
-
- for (i = j = 0; i < brw->vb.nr_enabled; i++) {
- struct brw_vertex_element *input = brw->vb.enabled[i];
- const struct gl_vertex_array *glarray = input->glarray;
-
- if (_mesa_is_bufferobj(glarray->BufferObj)) {
- struct intel_buffer_object *intel_buffer =
- intel_buffer_object(glarray->BufferObj);
-
- const uint32_t offset = (uintptr_t)glarray->Ptr;
-
- /* Start with the worst case */
- uint32_t start = 0;
- uint32_t range = intel_buffer->Base.Size;
- if (glarray->InstanceDivisor) {
- if (brw->num_instances) {
- start = offset + glarray->StrideB * brw->baseinstance;
- range = (glarray->StrideB * ((brw->num_instances - 1) /
- glarray->InstanceDivisor) +
- glarray->_ElementSize);
- }
- } else {
- if (brw->vb.index_bounds_valid) {
- start = offset + min_index * glarray->StrideB;
- range = (glarray->StrideB * (max_index - min_index) +
- glarray->_ElementSize);
- }
- }
+ j = 0;
+ const struct gl_vertex_array_object *vao = ctx->Array._DrawVAO;
+
+ unsigned vbomask = vs_inputs & _mesa_draw_vbo_array_bits(ctx);
+ while (vbomask) {
+ const struct gl_vertex_buffer_binding *const glbinding =
+ _mesa_draw_buffer_binding(vao, ffs(vbomask) - 1);
+ const GLsizei stride = glbinding->Stride;
+
+ assert(glbinding->BufferObj);
+
+ /* Accumulate the range of a single vertex, start with inverted range */
+ uint32_t vertex_range_start = ~(uint32_t)0;
+ uint32_t vertex_range_end = 0;
+
+ const unsigned boundmask = _mesa_draw_bound_attrib_bits(glbinding);
+ unsigned attrmask = vbomask & boundmask;
+ /* Mark the those attributes as processed */
+ vbomask ^= attrmask;
+ /* We can assume that we have an array for the binding */
+ assert(attrmask);
+ /* Walk attributes belonging to the binding */
+ while (attrmask) {
+ const gl_vert_attrib attr = u_bit_scan(&attrmask);
+ const struct gl_array_attributes *const glattrib =
+ _mesa_draw_array_attrib(vao, attr);
+ const uint32_t rel_offset =
+ _mesa_draw_attributes_relative_offset(glattrib);
+ const uint32_t rel_end = rel_offset + glattrib->Format._ElementSize;
+
+ vertex_range_start = MIN2(vertex_range_start, rel_offset);
+ vertex_range_end = MAX2(vertex_range_end, rel_end);
+
+ struct brw_vertex_element *input = &brw->vb.inputs[attr];
+ input->glformat = &glattrib->Format;
+ input->buffer = j;
+ input->is_dual_slot = (vp->DualSlotInputs & BITFIELD64_BIT(attr)) != 0;
+ input->offset = rel_offset;
+ }
+ assert(vertex_range_start <= vertex_range_end);
+
+ struct intel_buffer_object *intel_buffer =
+ intel_buffer_object(glbinding->BufferObj);
+ struct brw_vertex_buffer *buffer = &brw->vb.buffers[j];
- /* If we have a VB set to be uploaded for this buffer object
- * already, reuse that VB state so that we emit fewer
- * relocations.
- */
- unsigned k;
- for (k = 0; k < i; k++) {
- const struct gl_vertex_array *other = brw->vb.enabled[k]->glarray;
- if (glarray->BufferObj == other->BufferObj &&
- glarray->StrideB == other->StrideB &&
- glarray->InstanceDivisor == other->InstanceDivisor &&
- (uintptr_t)(glarray->Ptr - other->Ptr) < glarray->StrideB)
- {
- input->buffer = brw->vb.enabled[k]->buffer;
- input->offset = glarray->Ptr - other->Ptr;
-
- buffer_range_start[input->buffer] =
- MIN2(buffer_range_start[input->buffer], start);
- buffer_range_end[input->buffer] =
- MAX2(buffer_range_end[input->buffer], start + range);
- break;
- }
- }
- if (k == i) {
- struct brw_vertex_buffer *buffer = &brw->vb.buffers[j];
-
- /* Named buffer object: Just reference its contents directly. */
- buffer->offset = offset;
- buffer->stride = glarray->StrideB;
- buffer->step_rate = glarray->InstanceDivisor;
- buffer->size = glarray->BufferObj->Size - offset;
-
- enabled_buffer[j] = intel_buffer;
- buffer_range_start[j] = start;
- buffer_range_end[j] = start + range;
-
- input->buffer = j++;
- input->offset = 0;
- }
+ const uint32_t offset = _mesa_draw_binding_offset(glbinding);
+
+ /* If nothing else is known take the buffer size and offset as a bound */
+ uint32_t start = vertex_range_start;
+ uint32_t range = intel_buffer->Base.Size - offset - vertex_range_start;
+ /* Check if we can get a more narrow range */
+ if (glbinding->InstanceDivisor) {
+ if (brw->num_instances) {
+ const uint32_t vertex_size = vertex_range_end - vertex_range_start;
+ start = vertex_range_start + stride * brw->baseinstance;
+ range = (stride * ((brw->num_instances - 1) /
+ glbinding->InstanceDivisor) +
+ vertex_size);
+ }
} else {
- /* Queue the buffer object up to be uploaded in the next pass,
- * when we've decided if we're doing interleaved or not.
- */
- if (nr_uploads == 0) {
- interleaved = glarray->StrideB;
- ptr = glarray->Ptr;
- }
- else if (interleaved != glarray->StrideB ||
- glarray->InstanceDivisor != 0 ||
- glarray->Ptr < ptr ||
- (uintptr_t)(glarray->Ptr - ptr) + glarray->_ElementSize > interleaved)
- {
- /* If our stride is different from the first attribute's stride,
- * or if we are using an instance divisor or if the first
- * attribute's stride didn't cover our element, disable the
- * interleaved upload optimization. The second case can most
- * commonly occur in cases where there is a single vertex and, for
- * example, the data is stored on the application's stack.
- *
- * NOTE: This will also disable the optimization in cases where
- * the data is in a different order than the array indices.
- * Something like:
- *
- * float data[...];
- * glVertexAttribPointer(0, 4, GL_FLOAT, 32, &data[4]);
- * glVertexAttribPointer(1, 4, GL_FLOAT, 32, &data[0]);
- */
- interleaved = 0;
- }
-
- upload[nr_uploads++] = input;
+ if (brw->vb.index_bounds_valid) {
+ const uint32_t vertex_size = vertex_range_end - vertex_range_start;
+ start = vertex_range_start + stride * min_index;
+ range = (stride * (max_index - min_index) +
+ vertex_size);
+ }
}
- }
- /* Now that we've set up all of the buffers, we walk through and reference
- * each of them. We do this late so that we get the right size in each
- * buffer and don't reference too little data.
- */
- for (i = 0; i < j; i++) {
- struct brw_vertex_buffer *buffer = &brw->vb.buffers[i];
- if (buffer->bo)
- continue;
+ buffer->offset = offset;
+ buffer->size = start + range;
+ buffer->stride = stride;
+ buffer->step_rate = glbinding->InstanceDivisor;
- const uint32_t start = buffer_range_start[i];
- const uint32_t range = buffer_range_end[i] - buffer_range_start[i];
-
- buffer->bo = intel_bufferobj_buffer(brw, enabled_buffer[i], start, range);
+ buffer->bo = intel_bufferobj_buffer(brw, intel_buffer, offset + start,
+ range, false);
brw_bo_reference(buffer->bo);
+
+ j++;
}
/* If we need to upload all the arrays, then we can trim those arrays to
*/
brw->vb.start_vertex_bias = 0;
delta = min_index;
- if (nr_uploads == brw->vb.nr_enabled) {
+ if ((vs_inputs & _mesa_draw_vbo_array_bits(ctx)) == 0) {
brw->vb.start_vertex_bias = -delta;
delta = 0;
}
- /* Handle any arrays to be uploaded. */
- if (nr_uploads > 1) {
- if (interleaved) {
- struct brw_vertex_buffer *buffer = &brw->vb.buffers[j];
- /* All uploads are interleaved, so upload the arrays together as
- * interleaved. First, upload the contents and set up upload[0].
- */
- copy_array_to_vbo_array(brw, upload[0], min_index, max_index,
- buffer, interleaved);
- buffer->offset -= delta * interleaved;
- buffer->size += delta * interleaved;
- buffer->step_rate = 0;
-
- for (i = 0; i < nr_uploads; i++) {
- /* Then, just point upload[i] at upload[0]'s buffer. */
- upload[i]->offset =
- ((const unsigned char *)upload[i]->glarray->Ptr - ptr);
- upload[i]->buffer = j;
- }
- j++;
-
- nr_uploads = 0;
+ unsigned usermask = vs_inputs & _mesa_draw_user_array_bits(ctx);
+ while (usermask) {
+ const struct gl_vertex_buffer_binding *const glbinding =
+ _mesa_draw_buffer_binding(vao, ffs(usermask) - 1);
+ const GLsizei stride = glbinding->Stride;
+
+ assert(!glbinding->BufferObj);
+ assert(brw->vb.index_bounds_valid);
+
+ /* Accumulate the range of a single vertex, start with inverted range */
+ uint32_t vertex_range_start = ~(uint32_t)0;
+ uint32_t vertex_range_end = 0;
+
+ const unsigned boundmask = _mesa_draw_bound_attrib_bits(glbinding);
+ unsigned attrmask = usermask & boundmask;
+ /* Mark the those attributes as processed */
+ usermask ^= attrmask;
+ /* We can assume that we have an array for the binding */
+ assert(attrmask);
+ /* Walk attributes belonging to the binding */
+ while (attrmask) {
+ const gl_vert_attrib attr = u_bit_scan(&attrmask);
+ const struct gl_array_attributes *const glattrib =
+ _mesa_draw_array_attrib(vao, attr);
+ const uint32_t rel_offset =
+ _mesa_draw_attributes_relative_offset(glattrib);
+ const uint32_t rel_end = rel_offset + glattrib->Format._ElementSize;
+
+ vertex_range_start = MIN2(vertex_range_start, rel_offset);
+ vertex_range_end = MAX2(vertex_range_end, rel_end);
+
+ struct brw_vertex_element *input = &brw->vb.inputs[attr];
+ input->glformat = &glattrib->Format;
+ input->buffer = j;
+ input->is_dual_slot = (vp->DualSlotInputs & BITFIELD64_BIT(attr)) != 0;
+ input->offset = rel_offset;
}
- }
- /* Upload non-interleaved arrays */
- for (i = 0; i < nr_uploads; i++) {
+ assert(vertex_range_start <= vertex_range_end);
+
struct brw_vertex_buffer *buffer = &brw->vb.buffers[j];
- if (upload[i]->glarray->InstanceDivisor == 0) {
- copy_array_to_vbo_array(brw, upload[i], min_index, max_index,
- buffer, upload[i]->glarray->_ElementSize);
+
+ const uint8_t *ptr = (const uint8_t*)_mesa_draw_binding_offset(glbinding);
+ ptr += vertex_range_start;
+ const uint32_t vertex_size = vertex_range_end - vertex_range_start;
+ if (glbinding->Stride == 0) {
+ /* If the source stride is zero, we just want to upload the current
+ * attribute once and set the buffer's stride to 0. There's no need
+ * to replicate it out.
+ */
+ copy_array_to_vbo_array(brw, ptr, 0, 0, 0, buffer, vertex_size);
+ } else if (glbinding->InstanceDivisor == 0) {
+ copy_array_to_vbo_array(brw, ptr, stride, min_index,
+ max_index, buffer, vertex_size);
} else {
/* This is an instanced attribute, since its InstanceDivisor
* is not zero. Therefore, its data will be stepped after the
* instanced draw has been run InstanceDivisor times.
*/
uint32_t instanced_attr_max_index =
- (brw->num_instances - 1) / upload[i]->glarray->InstanceDivisor;
- copy_array_to_vbo_array(brw, upload[i], 0, instanced_attr_max_index,
- buffer, upload[i]->glarray->_ElementSize);
+ (brw->num_instances - 1) / glbinding->InstanceDivisor;
+ copy_array_to_vbo_array(brw, ptr, stride, 0,
+ instanced_attr_max_index, buffer, vertex_size);
}
- buffer->offset -= delta * buffer->stride;
- buffer->size += delta * buffer->stride;
- buffer->step_rate = upload[i]->glarray->InstanceDivisor;
- upload[i]->buffer = j++;
- upload[i]->offset = 0;
+ buffer->offset -= delta * buffer->stride + vertex_range_start;
+ buffer->size += delta * buffer->stride + vertex_range_start;
+ buffer->step_rate = glbinding->InstanceDivisor;
+
+ j++;
}
+ /* Upload the current values */
+ unsigned curmask = vs_inputs & _mesa_draw_current_bits(ctx);
+ if (curmask) {
+ /* For each attribute, upload the maximum possible size. */
+ uint8_t data[VERT_ATTRIB_MAX * sizeof(GLdouble) * 4];
+ uint8_t *cursor = data;
+
+ do {
+ const gl_vert_attrib attr = u_bit_scan(&curmask);
+ const struct gl_array_attributes *const glattrib =
+ _mesa_draw_current_attrib(ctx, attr);
+ const unsigned size = glattrib->Format._ElementSize;
+ const unsigned alignment = align(size, sizeof(GLdouble));
+ memcpy(cursor, glattrib->Ptr, size);
+ if (alignment != size)
+ memset(cursor + size, 0, alignment - size);
+
+ struct brw_vertex_element *input = &brw->vb.inputs[attr];
+ input->glformat = &glattrib->Format;
+ input->buffer = j;
+ input->is_dual_slot = (vp->DualSlotInputs & BITFIELD64_BIT(attr)) != 0;
+ input->offset = cursor - data;
+
+ cursor += alignment;
+ } while (curmask);
+
+ struct brw_vertex_buffer *buffer = &brw->vb.buffers[j];
+ const unsigned size = cursor - data;
+ brw_upload_data(&brw->upload, data, size, size,
+ &buffer->bo, &buffer->offset);
+ buffer->stride = 0;
+ buffer->size = size;
+ buffer->step_rate = 0;
+
+ j++;
+ }
brw->vb.nr_buffers = j;
}
const struct brw_vs_prog_data *vs_prog_data =
brw_vs_prog_data(brw->vs.base.prog_data);
- /* For non-indirect draws, upload gl_BaseVertex. */
- if ((vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) &&
+ /* For non-indirect draws, upload the shader draw parameters */
+ if ((vs_prog_data->uses_firstvertex || vs_prog_data->uses_baseinstance) &&
brw->draw.draw_params_bo == NULL) {
- intel_upload_data(brw, &brw->draw.params, sizeof(brw->draw.params), 4,
- &brw->draw.draw_params_bo,
- &brw->draw.draw_params_offset);
+ brw_upload_data(&brw->upload,
+ &brw->draw.params, sizeof(brw->draw.params), 4,
+ &brw->draw.draw_params_bo,
+ &brw->draw.draw_params_offset);
}
- if (vs_prog_data->uses_drawid) {
- intel_upload_data(brw, &brw->draw.gl_drawid, sizeof(brw->draw.gl_drawid), 4,
- &brw->draw.draw_id_bo,
- &brw->draw.draw_id_offset);
+ if (vs_prog_data->uses_drawid || vs_prog_data->uses_is_indexed_draw) {
+ brw_upload_data(&brw->upload,
+ &brw->draw.derived_params, sizeof(brw->draw.derived_params), 4,
+ &brw->draw.derived_draw_params_bo,
+ &brw->draw.derived_draw_params_offset);
}
}
if (index_buffer == NULL)
return;
- ib_type_size = index_buffer->index_size;
+ ib_type_size = 1 << index_buffer->index_size_shift;
ib_size = index_buffer->count ? ib_type_size * index_buffer->count :
index_buffer->obj->Size;
bufferobj = index_buffer->obj;
/* Turn into a proper VBO:
*/
- if (!_mesa_is_bufferobj(bufferobj)) {
+ if (!bufferobj) {
/* Get new bufferobj, offset:
*/
- intel_upload_data(brw, index_buffer->ptr, ib_size, ib_type_size,
- &brw->ib.bo, &offset);
+ brw_upload_data(&brw->upload, index_buffer->ptr, ib_size, ib_type_size,
+ &brw->ib.bo, &offset);
brw->ib.size = brw->ib.bo->size;
} else {
offset = (GLuint) (unsigned long) index_buffer->ptr;
struct brw_bo *bo =
intel_bufferobj_buffer(brw, intel_buffer_object(bufferobj),
- offset, ib_size);
+ offset, ib_size, false);
if (bo != brw->ib.bo) {
brw_bo_unreference(brw->ib.bo);
brw->ib.bo = bo;
if (brw->ib.bo != old_bo)
brw->ctx.NewDriverState |= BRW_NEW_INDEX_BUFFER;
- if (index_buffer->index_size != brw->ib.index_size) {
- brw->ib.index_size = index_buffer->index_size;
+ unsigned index_size = 1 << index_buffer->index_size_shift;
+ if (index_size != brw->ib.index_size) {
+ brw->ib.index_size = index_size;
+ brw->ctx.NewDriverState |= BRW_NEW_INDEX_BUFFER;
+ }
+
+ /* We need to re-emit an index buffer state each time
+ * when cut index flag is changed
+ */
+ if (brw->prim_restart.enable_cut_index != brw->ib.enable_cut_index) {
+ brw->ib.enable_cut_index = brw->prim_restart.enable_cut_index;
brw->ctx.NewDriverState |= BRW_NEW_INDEX_BUFFER;
}
}
projects / mesa.git / blobdiff