aboutsummaryrefslogtreecommitdiff
path: root/mesalib/src/mesa/vbo
diff options
context:
space:
mode:
authormarha <marha@users.sourceforge.net>2012-05-21 09:10:35 +0200
committermarha <marha@users.sourceforge.net>2012-05-21 09:10:35 +0200
commitf543ceaca6820260f15a4eff86938214cf43c7d2 (patch)
treed66901c0385bd008ba46600be695c500daa78c8f /mesalib/src/mesa/vbo
parent062c45ff0df6a52080dcd74433710d47127cbe29 (diff)
downloadvcxsrv-f543ceaca6820260f15a4eff86938214cf43c7d2.tar.gz
vcxsrv-f543ceaca6820260f15a4eff86938214cf43c7d2.tar.bz2
vcxsrv-f543ceaca6820260f15a4eff86938214cf43c7d2.zip
fontconfig mesa xkeyboard-config xserver pixman git update 21 Mar 2012
Diffstat (limited to 'mesalib/src/mesa/vbo')
-rw-r--r--mesalib/src/mesa/vbo/vbo.h6
-rw-r--r--mesalib/src/mesa/vbo/vbo_exec_array.c43
-rw-r--r--mesalib/src/mesa/vbo/vbo_primitive_restart.c233
3 files changed, 276 insertions, 6 deletions
diff --git a/mesalib/src/mesa/vbo/vbo.h b/mesalib/src/mesa/vbo/vbo.h
index 3cff8987e..4387e10b7 100644
--- a/mesalib/src/mesa/vbo/vbo.h
+++ b/mesalib/src/mesa/vbo/vbo.h
@@ -157,6 +157,12 @@ void vbo_bind_arrays(struct gl_context *ctx);
size_t
count_tessellated_primitives(const struct _mesa_prim *prim);
+void
+vbo_sw_primitive_restart(struct gl_context *ctx,
+ const struct _mesa_prim *prim,
+ GLuint nr_prims,
+ const struct _mesa_index_buffer *ib);
+
void GLAPIENTRY
_es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a);
diff --git a/mesalib/src/mesa/vbo/vbo_exec_array.c b/mesalib/src/mesa/vbo/vbo_exec_array.c
index 9303ad719..3fb7c6480 100644
--- a/mesalib/src/mesa/vbo/vbo_exec_array.c
+++ b/mesalib/src/mesa/vbo/vbo_exec_array.c
@@ -543,6 +543,37 @@ vbo_bind_arrays(struct gl_context *ctx)
/**
+ * Handle a draw case that potentially has primitive restart enabled.
+ *
+ * If primitive restart is enabled, and PrimitiveRestartInSoftware is
+ * set, then vbo_sw_primitive_restart is used to handle the primitive
+ * restart case in software.
+ */
+static void
+vbo_handle_primitive_restart(struct gl_context *ctx,
+ const struct _mesa_prim *prim,
+ GLuint nr_prims,
+ const struct _mesa_index_buffer *ib,
+ GLboolean index_bounds_valid,
+ GLuint min_index,
+ GLuint max_index)
+{
+ struct vbo_context *vbo = vbo_context(ctx);
+
+ if ((ib != NULL) &&
+ ctx->Const.PrimitiveRestartInSoftware &&
+ ctx->Array.PrimitiveRestart) {
+ /* Handle primitive restart in software */
+ vbo_sw_primitive_restart(ctx, prim, nr_prims, ib);
+ } else {
+ /* Call driver directly for draw_prims */
+ vbo->draw_prims(ctx, prim, nr_prims, ib,
+ index_bounds_valid, min_index, max_index, NULL);
+ }
+}
+
+
+/**
* Helper function called by the other DrawArrays() functions below.
* This is where we handle primitive restart for drawing non-indexed
* arrays. If primitive restart is enabled, it typically means
@@ -805,8 +836,8 @@ vbo_validated_drawrangeelements(struct gl_context *ctx, GLenum mode,
*/
check_buffers_are_unmapped(exec->array.inputs);
- vbo->draw_prims( ctx, prim, 1, &ib,
- index_bounds_valid, start, end, NULL );
+ vbo_handle_primitive_restart(ctx, prim, 1, &ib,
+ index_bounds_valid, start, end);
if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
_mesa_flush(ctx);
@@ -1104,8 +1135,8 @@ vbo_validated_multidrawelements(struct gl_context *ctx, GLenum mode,
}
check_buffers_are_unmapped(exec->array.inputs);
- vbo->draw_prims(ctx, prim, primcount, &ib,
- GL_FALSE, ~0, ~0, NULL);
+ vbo_handle_primitive_restart(ctx, prim, primcount, &ib,
+ GL_FALSE, ~0, ~0);
} else {
/* render one prim at a time */
for (i = 0; i < primcount; i++) {
@@ -1129,8 +1160,8 @@ vbo_validated_multidrawelements(struct gl_context *ctx, GLenum mode,
prim[0].basevertex = 0;
check_buffers_are_unmapped(exec->array.inputs);
- vbo->draw_prims(ctx, prim, 1, &ib,
- GL_FALSE, ~0, ~0, NULL);
+ vbo_handle_primitive_restart(ctx, prim, 1, &ib,
+ GL_FALSE, ~0, ~0);
}
}
diff --git a/mesalib/src/mesa/vbo/vbo_primitive_restart.c b/mesalib/src/mesa/vbo/vbo_primitive_restart.c
new file mode 100644
index 000000000..18d851c1e
--- /dev/null
+++ b/mesalib/src/mesa/vbo/vbo_primitive_restart.c
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ *
+ * Copyright © 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * Authors:
+ * Jordan Justen <jordan.l.justen@intel.com>
+ *
+ */
+
+#include "main/imports.h"
+#include "main/bufferobj.h"
+#include "main/macros.h"
+
+#include "vbo.h"
+#include "vbo_context.h"
+
+#define UPDATE_MIN2(a, b) (a) = MIN2((a), (b))
+#define UPDATE_MAX2(a, b) (a) = MAX2((a), (b))
+
+/*
+ * Notes on primitive restart:
+ * The code below is used when the driver does not support primitive
+ * restart itself. (ctx->Const.PrimitiveRestartInSoftware == GL_TRUE)
+ *
+ * We map the index buffer, find the restart indexes, unmap
+ * the index buffer then draw the sub-primitives delineated by the restarts.
+ *
+ * A couple possible optimizations:
+ * 1. Save the list of sub-primitive (start, count) values in a list attached
+ * to the index buffer for re-use in subsequent draws. The list would be
+ * invalidated when the contents of the buffer changed.
+ * 2. If drawing triangle strips or quad strips, create a new index buffer
+ * that uses duplicated vertices to render the disjoint strips as one
+ * long strip. We'd have to be careful to avoid using too much memory
+ * for this.
+ *
+ * Finally, some apps might perform better if they don't use primitive restart
+ * at all rather than this fallback path. Set MESA_EXTENSION_OVERRIDE to
+ * "-GL_NV_primitive_restart" to test that.
+ */
+
+
+struct sub_primitive
+{
+ GLuint start;
+ GLuint count;
+ GLuint min_index;
+ GLuint max_index;
+};
+
+
+/**
+ * Scan the elements array to find restart indexes. Return an array
+ * of struct sub_primitive to indicate how to draw the sub-primitives
+ * are delineated by the restart index.
+ */
+static struct sub_primitive *
+find_sub_primitives(const void *elements, unsigned element_size,
+ unsigned start, unsigned end, unsigned restart_index,
+ unsigned *num_sub_prims)
+{
+ const unsigned max_prims = end - start;
+ struct sub_primitive *sub_prims;
+ unsigned i, cur_start, cur_count;
+ GLuint scan_index;
+ unsigned scan_num;
+
+ sub_prims = (struct sub_primitive *)
+ malloc(max_prims * sizeof(struct sub_primitive));
+
+ if (!sub_prims) {
+ *num_sub_prims = 0;
+ return NULL;
+ }
+
+ cur_start = start;
+ cur_count = 0;
+ scan_num = 0;
+
+#define IB_INDEX_READ(TYPE, INDEX) (((const GL##TYPE *) elements)[INDEX])
+
+#define SCAN_ELEMENTS(TYPE) \
+ sub_prims[scan_num].min_index = (GL##TYPE) 0xffffffff; \
+ sub_prims[scan_num].max_index = 0; \
+ for (i = start; i < end; i++) { \
+ scan_index = IB_INDEX_READ(TYPE, i); \
+ if (scan_index == restart_index) { \
+ if (cur_count > 0) { \
+ assert(scan_num < max_prims); \
+ sub_prims[scan_num].start = cur_start; \
+ sub_prims[scan_num].count = cur_count; \
+ scan_num++; \
+ sub_prims[scan_num].min_index = (GL##TYPE) 0xffffffff; \
+ sub_prims[scan_num].max_index = 0; \
+ } \
+ cur_start = i + 1; \
+ cur_count = 0; \
+ } \
+ else { \
+ UPDATE_MIN2(sub_prims[scan_num].min_index, scan_index); \
+ UPDATE_MAX2(sub_prims[scan_num].max_index, scan_index); \
+ cur_count++; \
+ } \
+ } \
+ if (cur_count > 0) { \
+ assert(scan_num < max_prims); \
+ sub_prims[scan_num].start = cur_start; \
+ sub_prims[scan_num].count = cur_count; \
+ scan_num++; \
+ }
+
+ switch (element_size) {
+ case 1:
+ SCAN_ELEMENTS(ubyte);
+ break;
+ case 2:
+ SCAN_ELEMENTS(ushort);
+ break;
+ case 4:
+ SCAN_ELEMENTS(uint);
+ break;
+ default:
+ assert(0 && "bad index_size in find_sub_primitives()");
+ }
+
+#undef SCAN_ELEMENTS
+
+ *num_sub_prims = scan_num;
+
+ return sub_prims;
+}
+
+
+/**
+ * Handle primitive restart in software.
+ *
+ * This function breaks up calls into the driver so primitive restart
+ * support is not required in the driver.
+ */
+void
+vbo_sw_primitive_restart(struct gl_context *ctx,
+ const struct _mesa_prim *prims,
+ GLuint nr_prims,
+ const struct _mesa_index_buffer *ib)
+{
+ GLuint prim_num;
+ struct sub_primitive *sub_prims;
+ struct sub_primitive *sub_prim;
+ GLuint num_sub_prims;
+ GLuint sub_prim_num;
+ GLuint end_index;
+ GLuint sub_end_index;
+ GLuint restart_index = ctx->Array.RestartIndex;
+ struct _mesa_prim temp_prim;
+ struct vbo_context *vbo = vbo_context(ctx);
+ vbo_draw_func draw_prims_func = vbo->draw_prims;
+ GLboolean map_ib = ib->obj->Name && !ib->obj->Pointer;
+ void *ptr;
+
+ /* Find the sub-primitives. These are regions in the index buffer which
+ * are split based on the primitive restart index value.
+ */
+ if (map_ib) {
+ ctx->Driver.MapBufferRange(ctx, 0, ib->obj->Size, GL_MAP_READ_BIT,
+ ib->obj);
+ }
+
+ ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);
+
+ sub_prims = find_sub_primitives(ptr, vbo_sizeof_ib_type(ib->type),
+ 0, ib->count, restart_index,
+ &num_sub_prims);
+
+ if (map_ib) {
+ ctx->Driver.UnmapBuffer(ctx, ib->obj);
+ }
+
+ /* Loop over the primitives, and use the located sub-primitives to draw
+ * each primitive with a break to implement each primitive restart.
+ */
+ for (prim_num = 0; prim_num < nr_prims; prim_num++) {
+ end_index = prims[prim_num].start + prims[prim_num].count;
+ memcpy(&temp_prim, &prims[prim_num], sizeof (temp_prim));
+ /* Loop over the sub-primitives drawing sub-ranges of the primitive. */
+ for (sub_prim_num = 0; sub_prim_num < num_sub_prims; sub_prim_num++) {
+ sub_prim = &sub_prims[sub_prim_num];
+ sub_end_index = sub_prim->start + sub_prim->count;
+ if (prims[prim_num].start <= sub_prim->start) {
+ temp_prim.start = MAX2(prims[prim_num].start, sub_prim->start);
+ temp_prim.count = MIN2(sub_end_index, end_index) - temp_prim.start;
+ if ((temp_prim.start == sub_prim->start) &&
+ (temp_prim.count == sub_prim->count)) {
+ draw_prims_func(ctx, &temp_prim, 1, ib,
+ GL_TRUE, sub_prim->min_index, sub_prim->max_index,
+ NULL);
+ } else {
+ draw_prims_func(ctx, &temp_prim, 1, ib,
+ GL_FALSE, -1, -1,
+ NULL);
+ }
+ }
+ if (sub_end_index >= end_index) {
+ break;
+ }
+ }
+ }
+
+ if (sub_prims) {
+ free(sub_prims);
+ }
+}
+