#include "translate/translate.h"
#include "translate/translate_cache.h"
-/* Hardware vertex fetcher limitations can be described by this structure. */
-struct u_vbuf_caps {
- /* Vertex format CAPs. */
- /* TRUE if hardware supports it. */
- unsigned format_fixed32:1; /* PIPE_FORMAT_*32*_FIXED */
- unsigned format_float16:1; /* PIPE_FORMAT_*16*_FLOAT */
- unsigned format_float64:1; /* PIPE_FORMAT_*64*_FLOAT */
- unsigned format_norm32:1; /* PIPE_FORMAT_*32*NORM */
- unsigned format_scaled32:1; /* PIPE_FORMAT_*32*SCALED */
-
- /* Whether vertex fetches don't have to be dword-aligned. */
- /* TRUE if hardware supports it. */
- unsigned fetch_dword_unaligned:1;
-};
-
-struct u_vbuf_mgr_elements {
+struct u_vbuf_elements {
unsigned count;
struct pipe_vertex_element ve[PIPE_MAX_ATTRIBS];
* - src_format != native_format, as discussed above.
* - src_offset % 4 != 0 (if the caps don't allow such an offset). */
boolean incompatible_layout;
+ /* Per-element flags. */
+ boolean incompatible_layout_elem[PIPE_MAX_ATTRIBS];
};
-struct u_vbuf_mgr_priv {
+struct u_vbuf_priv {
struct u_vbuf_mgr b;
- struct u_vbuf_caps caps;
struct pipe_context *pipe;
-
struct translate_cache *translate_cache;
- unsigned translate_vb_slot;
- struct u_vbuf_mgr_elements *ve;
- void *saved_ve, *fallback_ve;
+ /* Vertex element state bound by the state tracker. */
+ void *saved_ve;
+ /* and its associated helper structure for this module. */
+ struct u_vbuf_elements *ve;
+
+ /* Vertex elements used for the translate fallback. */
+ struct pipe_vertex_element fallback_velems[PIPE_MAX_ATTRIBS];
+ /* If non-NULL, this is a vertex element state used for the translate
+ * fallback and therefore used for rendering too. */
+ void *fallback_ve;
+ /* The vertex buffer slot index where translated vertices have been
+ * stored in. */
+ unsigned fallback_vb_slot;
+ /* When binding the fallback vertex element state, we don't want to
+ * change saved_ve and ve. This is set to TRUE in such cases. */
boolean ve_binding_lock;
+ /* Whether there is any user buffer. */
boolean any_user_vbs;
+ /* Whether there is a buffer with a non-native layout. */
boolean incompatible_vb_layout;
+ /* Per-buffer flags. */
+ boolean incompatible_vb[PIPE_MAX_ATTRIBS];
};
-static void u_vbuf_mgr_init_format_caps(struct u_vbuf_mgr_priv *mgr)
+static void u_vbuf_init_format_caps(struct u_vbuf_priv *mgr)
{
struct pipe_screen *screen = mgr->pipe->screen;
- mgr->caps.format_fixed32 =
+ mgr->b.caps.format_fixed32 =
screen->is_format_supported(screen, PIPE_FORMAT_R32_FIXED, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER);
- mgr->caps.format_float16 =
+ mgr->b.caps.format_float16 =
screen->is_format_supported(screen, PIPE_FORMAT_R16_FLOAT, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER);
- mgr->caps.format_float64 =
+ mgr->b.caps.format_float64 =
screen->is_format_supported(screen, PIPE_FORMAT_R64_FLOAT, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER);
- mgr->caps.format_norm32 =
+ mgr->b.caps.format_norm32 =
screen->is_format_supported(screen, PIPE_FORMAT_R32_UNORM, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER) &&
screen->is_format_supported(screen, PIPE_FORMAT_R32_SNORM, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER);
- mgr->caps.format_scaled32 =
+ mgr->b.caps.format_scaled32 =
screen->is_format_supported(screen, PIPE_FORMAT_R32_USCALED, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER) &&
screen->is_format_supported(screen, PIPE_FORMAT_R32_SSCALED, PIPE_BUFFER,
}
struct u_vbuf_mgr *
-u_vbuf_mgr_create(struct pipe_context *pipe,
- unsigned upload_buffer_size,
- unsigned upload_buffer_alignment,
- unsigned upload_buffer_bind,
- enum u_fetch_alignment fetch_alignment)
+u_vbuf_create(struct pipe_context *pipe,
+ unsigned upload_buffer_size,
+ unsigned upload_buffer_alignment,
+ unsigned upload_buffer_bind,
+ enum u_fetch_alignment fetch_alignment)
{
- struct u_vbuf_mgr_priv *mgr = CALLOC_STRUCT(u_vbuf_mgr_priv);
+ struct u_vbuf_priv *mgr = CALLOC_STRUCT(u_vbuf_priv);
mgr->pipe = pipe;
mgr->translate_cache = translate_cache_create();
+ mgr->fallback_vb_slot = ~0;
mgr->b.uploader = u_upload_create(pipe, upload_buffer_size,
upload_buffer_alignment,
upload_buffer_bind);
- mgr->caps.fetch_dword_unaligned =
+ mgr->b.caps.fetch_dword_unaligned =
fetch_alignment == U_VERTEX_FETCH_BYTE_ALIGNED;
- u_vbuf_mgr_init_format_caps(mgr);
+ u_vbuf_init_format_caps(mgr);
return &mgr->b;
}
-void u_vbuf_mgr_destroy(struct u_vbuf_mgr *mgrb)
+void u_vbuf_destroy(struct u_vbuf_mgr *mgrb)
{
- struct u_vbuf_mgr_priv *mgr = (struct u_vbuf_mgr_priv*)mgrb;
+ struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
unsigned i;
- for (i = 0; i < mgr->b.nr_real_vertex_buffers; i++) {
+ for (i = 0; i < mgr->b.nr_vertex_buffers; i++) {
pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, NULL);
- pipe_resource_reference(&mgr->b.real_vertex_buffer[i], NULL);
+ }
+ for (i = 0; i < mgr->b.nr_real_vertex_buffers; i++) {
+ pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
}
translate_cache_destroy(mgr->translate_cache);
}
-static void u_vbuf_translate_begin(struct u_vbuf_mgr_priv *mgr,
- int min_index, int max_index,
- boolean *upload_flushed)
+static void
+u_vbuf_translate_begin(struct u_vbuf_priv *mgr,
+ int min_index, int max_index)
{
struct translate_key key;
struct translate_element *te;
struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = {0};
struct pipe_resource *out_buffer = NULL;
unsigned i, num_verts, out_offset;
- struct pipe_vertex_element new_velems[PIPE_MAX_ATTRIBS];
+ boolean upload_flushed = FALSE;
memset(&key, 0, sizeof(key));
memset(tr_elem_index, 0xff, sizeof(tr_elem_index));
/* Initialize the translate key, i.e. the recipe how vertices should be
- * translated. */
+ * translated. */
memset(&key, 0, sizeof key);
for (i = 0; i < mgr->ve->count; i++) {
- struct pipe_vertex_buffer *vb =
- &mgr->b.vertex_buffer[mgr->ve->ve[i].vertex_buffer_index];
enum pipe_format output_format = mgr->ve->native_format[i];
unsigned output_format_size = mgr->ve->native_format_size[i];
/* Check for support. */
- if (mgr->ve->ve[i].src_format == mgr->ve->native_format[i] &&
- (mgr->caps.fetch_dword_unaligned ||
- (vb->buffer_offset % 4 == 0 &&
- vb->stride % 4 == 0 &&
- mgr->ve->ve[i].src_offset % 4 == 0))) {
+ if (!mgr->ve->incompatible_layout_elem[i] &&
+ !mgr->incompatible_vb[mgr->ve->ve[i].vertex_buffer_index]) {
continue;
}
u_upload_alloc(mgr->b.uploader,
key.output_stride * min_index,
key.output_stride * num_verts,
- &out_offset, &out_buffer, upload_flushed,
+ &out_offset, &out_buffer, &upload_flushed,
(void**)&out_map);
out_offset -= key.output_stride * min_index;
}
/* Setup the new vertex buffer in the first free slot. */
- mgr->translate_vb_slot = ~0;
+ mgr->fallback_vb_slot = ~0;
for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
if (!mgr->b.vertex_buffer[i].buffer) {
- mgr->translate_vb_slot = i;
+ mgr->fallback_vb_slot = i;
if (i >= mgr->b.nr_vertex_buffers) {
mgr->b.nr_real_vertex_buffers = i+1;
}
}
- if (mgr->translate_vb_slot != ~0) {
+ if (mgr->fallback_vb_slot != ~0) {
/* Setup the new vertex buffer. */
pipe_resource_reference(
- &mgr->b.real_vertex_buffer[mgr->translate_vb_slot], out_buffer);
- mgr->b.vertex_buffer[mgr->translate_vb_slot].buffer_offset = out_offset;
- mgr->b.vertex_buffer[mgr->translate_vb_slot].stride = key.output_stride;
+ &mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].buffer, out_buffer);
+ mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].buffer_offset = out_offset;
+ mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].stride = key.output_stride;
/* Setup new vertex elements. */
for (i = 0; i < mgr->ve->count; i++) {
if (tr_elem_index[i] < key.nr_elements) {
te = &key.element[tr_elem_index[i]];
- new_velems[i].instance_divisor = mgr->ve->ve[i].instance_divisor;
- new_velems[i].src_format = te->output_format;
- new_velems[i].src_offset = te->output_offset;
- new_velems[i].vertex_buffer_index = mgr->translate_vb_slot;
+ mgr->fallback_velems[i].instance_divisor = mgr->ve->ve[i].instance_divisor;
+ mgr->fallback_velems[i].src_format = te->output_format;
+ mgr->fallback_velems[i].src_offset = te->output_offset;
+ mgr->fallback_velems[i].vertex_buffer_index = mgr->fallback_vb_slot;
} else {
- memcpy(&new_velems[i], &mgr->ve->ve[i],
+ memcpy(&mgr->fallback_velems[i], &mgr->ve->ve[i],
sizeof(struct pipe_vertex_element));
}
}
mgr->fallback_ve =
mgr->pipe->create_vertex_elements_state(mgr->pipe, mgr->ve->count,
- new_velems);
+ mgr->fallback_velems);
/* Preserve saved_ve. */
mgr->ve_binding_lock = TRUE;
pipe_resource_reference(&out_buffer, NULL);
}
-static void u_vbuf_translate_end(struct u_vbuf_mgr_priv *mgr)
+static void u_vbuf_translate_end(struct u_vbuf_priv *mgr)
{
if (mgr->fallback_ve == NULL) {
return;
mgr->fallback_ve = NULL;
/* Delete the now-unused VBO. */
- pipe_resource_reference(&mgr->b.real_vertex_buffer[mgr->translate_vb_slot],
+ pipe_resource_reference(&mgr->b.real_vertex_buffer[mgr->fallback_vb_slot].buffer,
NULL);
+ mgr->fallback_vb_slot = ~0;
mgr->b.nr_real_vertex_buffers = mgr->b.nr_vertex_buffers;
}
#define FORMAT_REPLACE(what, withwhat) \
case PIPE_FORMAT_##what: format = PIPE_FORMAT_##withwhat; break
-struct u_vbuf_mgr_elements *
-u_vbuf_mgr_create_vertex_elements(struct u_vbuf_mgr *mgrb,
- unsigned count,
- const struct pipe_vertex_element *attribs,
- struct pipe_vertex_element *native_attribs)
+struct u_vbuf_elements *
+u_vbuf_create_vertex_elements(struct u_vbuf_mgr *mgrb,
+ unsigned count,
+ const struct pipe_vertex_element *attribs,
+ struct pipe_vertex_element *native_attribs)
{
- struct u_vbuf_mgr_priv *mgr = (struct u_vbuf_mgr_priv*)mgrb;
+ struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
unsigned i;
- struct u_vbuf_mgr_elements *ve = CALLOC_STRUCT(u_vbuf_mgr_elements);
+ struct u_vbuf_elements *ve = CALLOC_STRUCT(u_vbuf_elements);
ve->count = count;
/* Choose a native format.
* For now we don't care about the alignment, that's going to
* be sorted out later. */
- if (!mgr->caps.format_fixed32) {
+ if (!mgr->b.caps.format_fixed32) {
switch (format) {
FORMAT_REPLACE(R32_FIXED, R32_FLOAT);
FORMAT_REPLACE(R32G32_FIXED, R32G32_FLOAT);
default:;
}
}
- if (!mgr->caps.format_float16) {
+ if (!mgr->b.caps.format_float16) {
switch (format) {
FORMAT_REPLACE(R16_FLOAT, R32_FLOAT);
FORMAT_REPLACE(R16G16_FLOAT, R32G32_FLOAT);
default:;
}
}
- if (!mgr->caps.format_float64) {
+ if (!mgr->b.caps.format_float64) {
switch (format) {
FORMAT_REPLACE(R64_FLOAT, R32_FLOAT);
FORMAT_REPLACE(R64G64_FLOAT, R32G32_FLOAT);
default:;
}
}
- if (!mgr->caps.format_norm32) {
+ if (!mgr->b.caps.format_norm32) {
switch (format) {
FORMAT_REPLACE(R32_UNORM, R32_FLOAT);
FORMAT_REPLACE(R32G32_UNORM, R32G32_FLOAT);
default:;
}
}
- if (!mgr->caps.format_scaled32) {
+ if (!mgr->b.caps.format_scaled32) {
switch (format) {
FORMAT_REPLACE(R32_USCALED, R32_FLOAT);
FORMAT_REPLACE(R32G32_USCALED, R32G32_FLOAT);
ve->native_format_size[i] =
util_format_get_blocksize(ve->native_format[i]);
+ ve->incompatible_layout_elem[i] =
+ ve->ve[i].src_format != ve->native_format[i] ||
+ (!mgr->b.caps.fetch_dword_unaligned && ve->ve[i].src_offset % 4 != 0);
ve->incompatible_layout =
ve->incompatible_layout ||
- ve->ve[i].src_format != ve->native_format[i] ||
- (!mgr->caps.fetch_dword_unaligned && ve->ve[i].src_offset % 4 != 0);
+ ve->incompatible_layout_elem[i];
}
/* Align the formats to the size of DWORD if needed. */
- if (!mgr->caps.fetch_dword_unaligned) {
+ if (!mgr->b.caps.fetch_dword_unaligned) {
for (i = 0; i < count; i++) {
ve->native_format_size[i] = align(ve->native_format_size[i], 4);
}
return ve;
}
-void u_vbuf_mgr_bind_vertex_elements(struct u_vbuf_mgr *mgrb,
- void *cso,
- struct u_vbuf_mgr_elements *ve)
+void u_vbuf_bind_vertex_elements(struct u_vbuf_mgr *mgrb,
+ void *cso,
+ struct u_vbuf_elements *ve)
{
- struct u_vbuf_mgr_priv *mgr = (struct u_vbuf_mgr_priv*)mgrb;
+ struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
if (!cso) {
return;
}
}
-void u_vbuf_mgr_destroy_vertex_elements(struct u_vbuf_mgr *mgr,
- struct u_vbuf_mgr_elements *ve)
+void u_vbuf_destroy_vertex_elements(struct u_vbuf_mgr *mgr,
+ struct u_vbuf_elements *ve)
{
FREE(ve);
}
-void u_vbuf_mgr_set_vertex_buffers(struct u_vbuf_mgr *mgrb,
- unsigned count,
- const struct pipe_vertex_buffer *bufs)
+void u_vbuf_set_vertex_buffers(struct u_vbuf_mgr *mgrb,
+ unsigned count,
+ const struct pipe_vertex_buffer *bufs)
{
- struct u_vbuf_mgr_priv *mgr = (struct u_vbuf_mgr_priv*)mgrb;
+ struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
unsigned i;
mgr->any_user_vbs = FALSE;
mgr->incompatible_vb_layout = FALSE;
+ memset(mgr->incompatible_vb, 0, sizeof(mgr->incompatible_vb));
- if (!mgr->caps.fetch_dword_unaligned) {
+ if (!mgr->b.caps.fetch_dword_unaligned) {
/* Check if the strides and offsets are aligned to the size of DWORD. */
for (i = 0; i < count; i++) {
if (bufs[i].buffer) {
if (bufs[i].stride % 4 != 0 ||
bufs[i].buffer_offset % 4 != 0) {
mgr->incompatible_vb_layout = TRUE;
- break;
+ mgr->incompatible_vb[i] = TRUE;
}
}
}
const struct pipe_vertex_buffer *vb = &bufs[i];
pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, vb->buffer);
- pipe_resource_reference(&mgr->b.real_vertex_buffer[i], NULL);
- if (!vb->buffer) {
+ mgr->b.real_vertex_buffer[i].buffer_offset =
+ mgr->b.vertex_buffer[i].buffer_offset = vb->buffer_offset;
+
+ mgr->b.real_vertex_buffer[i].stride =
+ mgr->b.vertex_buffer[i].stride = vb->stride;
+
+ if (!vb->buffer ||
+ mgr->incompatible_vb[i]) {
+ pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
continue;
}
if (u_vbuf_resource(vb->buffer)->user_ptr) {
+ pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
mgr->any_user_vbs = TRUE;
continue;
}
- pipe_resource_reference(&mgr->b.real_vertex_buffer[i], vb->buffer);
+ pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, vb->buffer);
}
- for (; i < mgr->b.nr_real_vertex_buffers; i++) {
+ for (i = count; i < mgr->b.nr_vertex_buffers; i++) {
pipe_resource_reference(&mgr->b.vertex_buffer[i].buffer, NULL);
- pipe_resource_reference(&mgr->b.real_vertex_buffer[i], NULL);
}
-
- memcpy(mgr->b.vertex_buffer, bufs,
- sizeof(struct pipe_vertex_buffer) * count);
+ for (i = count; i < mgr->b.nr_real_vertex_buffers; i++) {
+ pipe_resource_reference(&mgr->b.real_vertex_buffer[i].buffer, NULL);
+ }
mgr->b.nr_vertex_buffers = count;
mgr->b.nr_real_vertex_buffers = count;
}
-static void u_vbuf_upload_buffers(struct u_vbuf_mgr_priv *mgr,
- int min_index, int max_index,
- unsigned instance_count,
- boolean *upload_flushed)
+void u_vbuf_set_index_buffer(struct u_vbuf_mgr *mgr,
+ const struct pipe_index_buffer *ib)
{
- unsigned i, nr = mgr->ve->count;
- unsigned count = max_index + 1 - min_index;
- boolean uploaded[PIPE_MAX_ATTRIBS] = {0};
+ if (ib && ib->buffer) {
+ assert(ib->offset % ib->index_size == 0);
+ pipe_resource_reference(&mgr->index_buffer.buffer, ib->buffer);
+ mgr->index_buffer.offset = ib->offset;
+ mgr->index_buffer.index_size = ib->index_size;
+ } else {
+ pipe_resource_reference(&mgr->index_buffer.buffer, NULL);
+ }
+}
- for (i = 0; i < nr; i++) {
- unsigned index = mgr->ve->ve[i].vertex_buffer_index;
+static void
+u_vbuf_upload_buffers(struct u_vbuf_priv *mgr,
+ int min_index, int max_index,
+ unsigned instance_count)
+{
+ unsigned i;
+ unsigned count = max_index + 1 - min_index;
+ unsigned nr_velems = mgr->ve->count;
+ unsigned nr_vbufs = mgr->b.nr_vertex_buffers;
+ struct pipe_vertex_element *velems =
+ mgr->fallback_ve ? mgr->fallback_velems : mgr->ve->ve;
+ unsigned start_offset[PIPE_MAX_ATTRIBS];
+ unsigned end_offset[PIPE_MAX_ATTRIBS] = {0};
+
+ /* Determine how much data needs to be uploaded. */
+ for (i = 0; i < nr_velems; i++) {
+ struct pipe_vertex_element *velem = &velems[i];
+ unsigned index = velem->vertex_buffer_index;
struct pipe_vertex_buffer *vb = &mgr->b.vertex_buffer[index];
+ unsigned instance_div, first, size;
- if (vb->buffer &&
- u_vbuf_resource(vb->buffer)->user_ptr &&
- !uploaded[index]) {
- unsigned first, size;
- boolean flushed;
- unsigned instance_div = mgr->ve->ve[i].instance_divisor;
-
- if (instance_div) {
- first = 0;
- size = vb->stride *
- ((instance_count + instance_div - 1) / instance_div);
- } else if (vb->stride) {
- first = vb->stride * min_index;
- size = vb->stride * count;
- } else {
- first = 0;
- size = mgr->ve->native_format_size[i];
- }
+ /* Skip the buffer generated by translate. */
+ if (index == mgr->fallback_vb_slot) {
+ continue;
+ }
- u_upload_data(mgr->b.uploader, first, size,
- u_vbuf_resource(vb->buffer)->user_ptr + first,
- &vb->buffer_offset,
- &mgr->b.real_vertex_buffer[index],
- &flushed);
+ assert(vb->buffer);
- vb->buffer_offset -= first;
+ if (!u_vbuf_resource(vb->buffer)->user_ptr) {
+ continue;
+ }
- uploaded[index] = TRUE;
- *upload_flushed = *upload_flushed || flushed;
+ instance_div = velem->instance_divisor;
+ first = vb->buffer_offset + velem->src_offset;
+
+ if (!vb->stride) {
+ /* Constant attrib. */
+ size = mgr->ve->src_format_size[i];
+ } else if (instance_div) {
+ /* Per-instance attrib. */
+ unsigned count = (instance_count + instance_div - 1) / instance_div;
+ size = vb->stride * (count - 1) + mgr->ve->src_format_size[i];
} else {
- assert(mgr->b.real_vertex_buffer[index]);
+ /* Per-vertex attrib. */
+ first += vb->stride * min_index;
+ size = vb->stride * (count - 1) + mgr->ve->src_format_size[i];
+ }
+
+ /* Update offsets. */
+ if (!end_offset[index]) {
+ start_offset[index] = first;
+ end_offset[index] = first + size;
+ } else {
+ if (first < start_offset[index])
+ start_offset[index] = first;
+ if (first + size > end_offset[index])
+ end_offset[index] = first + size;
}
}
+
+ /* Upload buffers. */
+ for (i = 0; i < nr_vbufs; i++) {
+ unsigned start, end = end_offset[i];
+ boolean flushed;
+ struct pipe_vertex_buffer *real_vb;
+ uint8_t *ptr;
+
+ if (!end) {
+ continue;
+ }
+
+ start = start_offset[i];
+ assert(start < end);
+
+ real_vb = &mgr->b.real_vertex_buffer[i];
+ ptr = u_vbuf_resource(mgr->b.vertex_buffer[i].buffer)->user_ptr;
+
+ u_upload_data(mgr->b.uploader, start, end - start, ptr + start,
+ &real_vb->buffer_offset, &real_vb->buffer, &flushed);
+
+ real_vb->buffer_offset -= start;
+ }
}
-static void u_vbuf_mgr_compute_max_index(struct u_vbuf_mgr_priv *mgr)
+unsigned u_vbuf_draw_max_vertex_count(struct u_vbuf_mgr *mgrb)
{
+ struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
unsigned i, nr = mgr->ve->count;
-
- mgr->b.max_index = ~0;
+ struct pipe_vertex_element *velems =
+ mgr->fallback_ve ? mgr->fallback_velems : mgr->ve->ve;
+ unsigned result = ~0;
for (i = 0; i < nr; i++) {
struct pipe_vertex_buffer *vb =
- &mgr->b.vertex_buffer[mgr->ve->ve[i].vertex_buffer_index];
- int unused;
- unsigned max_index;
+ &mgr->b.real_vertex_buffer[velems[i].vertex_buffer_index];
+ unsigned size, max_count, value;
+ /* We're not interested in constant and per-instance attribs. */
if (!vb->buffer ||
!vb->stride ||
- u_vbuf_resource(vb->buffer)->user_ptr) {
+ velems[i].instance_divisor) {
continue;
}
- /* How many bytes is unused after the last vertex.
- * width0 may be "count*stride - unused" and we have to compensate
- * for that when dividing by stride. */
- unused = vb->stride -
- (mgr->ve->ve[i].src_offset + mgr->ve->src_format_size[i]);
+ size = vb->buffer->width0;
+
+ /* Subtract buffer_offset. */
+ value = vb->buffer_offset;
+ if (value >= size) {
+ return 0;
+ }
+ size -= value;
- /* If src_offset is greater than stride (which means it's a buffer
- * offset rather than a vertex offset)... */
- if (unused < 0) {
- unused = 0;
+ /* Subtract src_offset. */
+ value = velems[i].src_offset;
+ if (value >= size) {
+ return 0;
}
+ size -= value;
- /* Compute the maximum index for this vertex element. */
- max_index =
- (vb->buffer->width0 - vb->buffer_offset + (unsigned)unused) /
- vb->stride - 1;
+ /* Subtract format_size. */
+ value = mgr->ve->native_format_size[i];
+ if (value >= size) {
+ return 0;
+ }
+ size -= value;
- mgr->b.max_index = MIN2(mgr->b.max_index, max_index);
+ /* Compute the max count. */
+ max_count = 1 + size / vb->stride;
+ result = MIN2(result, max_count);
}
+ return result;
}
-void u_vbuf_mgr_draw_begin(struct u_vbuf_mgr *mgrb,
- const struct pipe_draw_info *info,
- boolean *buffers_updated,
- boolean *uploader_flushed)
+static boolean u_vbuf_need_minmax_index(struct u_vbuf_priv *mgr)
{
- struct u_vbuf_mgr_priv *mgr = (struct u_vbuf_mgr_priv*)mgrb;
- boolean bufs_updated = FALSE, upload_flushed = FALSE;
+ unsigned i, nr = mgr->ve->count;
+
+ for (i = 0; i < nr; i++) {
+ struct pipe_vertex_buffer *vb;
+ unsigned index;
+
+ /* Per-instance attribs don't need min/max_index. */
+ if (mgr->ve->ve[i].instance_divisor) {
+ continue;
+ }
+
+ index = mgr->ve->ve[i].vertex_buffer_index;
+ vb = &mgr->b.vertex_buffer[index];
+
+ /* Constant attribs don't need min/max_index. */
+ if (!vb->stride) {
+ continue;
+ }
+
+ /* Per-vertex attribs need min/max_index. */
+ if (u_vbuf_resource(vb->buffer)->user_ptr ||
+ mgr->ve->incompatible_layout_elem[i] ||
+ mgr->incompatible_vb[index]) {
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+static void u_vbuf_get_minmax_index(struct pipe_context *pipe,
+ struct pipe_index_buffer *ib,
+ const struct pipe_draw_info *info,
+ int *out_min_index,
+ int *out_max_index)
+{
+ struct pipe_transfer *transfer = NULL;
+ const void *indices;
+ unsigned i;
+ unsigned restart_index = info->restart_index;
+
+ if (u_vbuf_resource(ib->buffer)->user_ptr) {
+ indices = u_vbuf_resource(ib->buffer)->user_ptr +
+ ib->offset + info->start * ib->index_size;
+ } else {
+ indices = pipe_buffer_map_range(pipe, ib->buffer,
+ ib->offset + info->start * ib->index_size,
+ info->count * ib->index_size,
+ PIPE_TRANSFER_READ, &transfer);
+ }
+
+ switch (ib->index_size) {
+ case 4: {
+ const unsigned *ui_indices = (const unsigned*)indices;
+ unsigned max_ui = 0;
+ unsigned min_ui = ~0U;
+ if (info->primitive_restart) {
+ for (i = 0; i < info->count; i++) {
+ if (ui_indices[i] != restart_index) {
+ if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
+ if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
+ }
+ }
+ }
+ else {
+ for (i = 0; i < info->count; i++) {
+ if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
+ if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
+ }
+ }
+ *out_min_index = min_ui;
+ *out_max_index = max_ui;
+ break;
+ }
+ case 2: {
+ const unsigned short *us_indices = (const unsigned short*)indices;
+ unsigned max_us = 0;
+ unsigned min_us = ~0U;
+ if (info->primitive_restart) {
+ for (i = 0; i < info->count; i++) {
+ if (us_indices[i] != restart_index) {
+ if (us_indices[i] > max_us) max_us = us_indices[i];
+ if (us_indices[i] < min_us) min_us = us_indices[i];
+ }
+ }
+ }
+ else {
+ for (i = 0; i < info->count; i++) {
+ if (us_indices[i] > max_us) max_us = us_indices[i];
+ if (us_indices[i] < min_us) min_us = us_indices[i];
+ }
+ }
+ *out_min_index = min_us;
+ *out_max_index = max_us;
+ break;
+ }
+ case 1: {
+ const unsigned char *ub_indices = (const unsigned char*)indices;
+ unsigned max_ub = 0;
+ unsigned min_ub = ~0U;
+ if (info->primitive_restart) {
+ for (i = 0; i < info->count; i++) {
+ if (ub_indices[i] != restart_index) {
+ if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
+ if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
+ }
+ }
+ }
+ else {
+ for (i = 0; i < info->count; i++) {
+ if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
+ if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
+ }
+ }
+ *out_min_index = min_ub;
+ *out_max_index = max_ub;
+ break;
+ }
+ default:
+ assert(0);
+ }
+
+ if (transfer) {
+ pipe_buffer_unmap(pipe, transfer);
+ }
+}
+
+enum u_vbuf_return_flags
+u_vbuf_draw_begin(struct u_vbuf_mgr *mgrb,
+ const struct pipe_draw_info *info)
+{
+ struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
int min_index, max_index;
- u_vbuf_mgr_compute_max_index(mgr);
+ if (!mgr->incompatible_vb_layout &&
+ !mgr->ve->incompatible_layout &&
+ !mgr->any_user_vbs) {
+ return 0;
+ }
- min_index = info->min_index - info->index_bias;
- if (info->max_index == ~0) {
- max_index = mgr->b.max_index;
+ if (info->indexed) {
+ if (info->max_index != ~0) {
+ min_index = info->min_index + info->index_bias;
+ max_index = info->max_index + info->index_bias;
+ } else if (u_vbuf_need_minmax_index(mgr)) {
+ u_vbuf_get_minmax_index(mgr->pipe, &mgr->b.index_buffer, info,
+ &min_index, &max_index);
+ min_index += info->index_bias;
+ max_index += info->index_bias;
+ } else {
+ min_index = 0;
+ max_index = 0;
+ }
} else {
- max_index = MIN2(info->max_index - info->index_bias, mgr->b.max_index);
+ min_index = info->start;
+ max_index = info->start + info->count - 1;
}
/* Translate vertices with non-native layouts or formats. */
if (mgr->incompatible_vb_layout || mgr->ve->incompatible_layout) {
- u_vbuf_translate_begin(mgr, min_index, max_index, &upload_flushed);
-
- if (mgr->fallback_ve) {
- bufs_updated = TRUE;
- }
+ u_vbuf_translate_begin(mgr, min_index, max_index);
}
/* Upload user buffers. */
if (mgr->any_user_vbs) {
- u_vbuf_upload_buffers(mgr, min_index, max_index, info->instance_count,
- &upload_flushed);
- bufs_updated = TRUE;
- }
-
- /* Set the return values. */
- if (buffers_updated) {
- *buffers_updated = bufs_updated;
- }
- if (uploader_flushed) {
- *uploader_flushed = upload_flushed;
+ u_vbuf_upload_buffers(mgr, min_index, max_index, info->instance_count);
}
+ return U_VBUF_BUFFERS_UPDATED;
}
-void u_vbuf_mgr_draw_end(struct u_vbuf_mgr *mgrb)
+void u_vbuf_draw_end(struct u_vbuf_mgr *mgrb)
{
- struct u_vbuf_mgr_priv *mgr = (struct u_vbuf_mgr_priv*)mgrb;
+ struct u_vbuf_priv *mgr = (struct u_vbuf_priv*)mgrb;
if (mgr->fallback_ve) {
u_vbuf_translate_end(mgr);
projects / mesa.git / blobdiff