/**************************************************************************
-Copyright 2002-2008 Tungsten Graphics Inc., Cedar Park, Texas.
+Copyright 2002-2008 VMware, Inc.
All Rights Reserved.
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 NON-INFRINGEMENT. IN NO EVENT SHALL
-TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+VMWARE AND/OR THEIR SUPPLIERS 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:
- * Keith Whitwell <keith@tungstengraphics.com>
+ * Keith Whitwell <keithw@vmware.com>
*/
* example by building a list that consists of one very long primitive
* (eg Begin(Triangles), 1000 vertices, End), and calling that list
* from inside a different begin/end object (Begin(Lines), CallList,
- * End).
+ * End).
*
* In that case the code will have to replay the list as individual
* commands through the Exec dispatch table, or fix up the copied
*
* The list compiler currently doesn't attempt to compile lists
* containing EvalCoord or EvalPoint commands. On encountering one of
- * these, compilation falls back to opcodes.
+ * these, compilation falls back to opcodes.
*
* This could be improved to fallback only when a mix of EvalCoord and
* Vertex commands are issued within a single primitive.
GL_ARRAY_BUFFER_ARB,
VBO_SAVE_BUFFER_SIZE * sizeof(GLfloat),
NULL, GL_STATIC_DRAW_ARB,
+ GL_MAP_WRITE_BIT |
+ GL_DYNAMIC_STORAGE_BIT,
vertex_store->bufferobj);
}
else {
vbo_save_map_vertex_store(struct gl_context *ctx,
struct vbo_save_vertex_store *vertex_store)
{
+ const GLbitfield access = (GL_MAP_WRITE_BIT |
+ GL_MAP_INVALIDATE_RANGE_BIT |
+ GL_MAP_UNSYNCHRONIZED_BIT |
+ GL_MAP_FLUSH_EXPLICIT_BIT);
+
assert(vertex_store->bufferobj);
- assert(!vertex_store->buffer);
+ assert(!vertex_store->buffer); /* the buffer should not be mapped */
+
if (vertex_store->bufferobj->Size > 0) {
- vertex_store->buffer =
- (GLfloat *) ctx->Driver.MapBufferRange(ctx, 0,
- vertex_store->bufferobj->Size,
- GL_MAP_WRITE_BIT, /* not used */
- vertex_store->bufferobj);
- assert(vertex_store->buffer);
- return vertex_store->buffer + vertex_store->used;
+ /* Map the remaining free space in the VBO */
+ GLintptr offset = vertex_store->used * sizeof(GLfloat);
+ GLsizeiptr size = vertex_store->bufferobj->Size - offset;
+ GLfloat *range = (GLfloat *)
+ ctx->Driver.MapBufferRange(ctx, offset, size, access,
+ vertex_store->bufferobj,
+ MAP_INTERNAL);
+ if (range) {
+ /* compute address of start of whole buffer (needed elsewhere) */
+ vertex_store->buffer = range - vertex_store->used;
+ assert(vertex_store->buffer);
+ return range;
+ }
+ else {
+ vertex_store->buffer = NULL;
+ return NULL;
+ }
}
else {
/* probably ran out of memory for buffers */
struct vbo_save_vertex_store *vertex_store)
{
if (vertex_store->bufferobj->Size > 0) {
- ctx->Driver.UnmapBuffer(ctx, vertex_store->bufferobj);
+ GLintptr offset = 0;
+ GLsizeiptr length = vertex_store->used * sizeof(GLfloat)
+ - vertex_store->bufferobj->Mappings[MAP_INTERNAL].Offset;
+
+ /* Explicitly flush the region we wrote to */
+ ctx->Driver.FlushMappedBufferRange(ctx, offset, length,
+ vertex_store->bufferobj,
+ MAP_INTERNAL);
+
+ ctx->Driver.UnmapBuffer(ctx, vertex_store->bufferobj, MAP_INTERNAL);
}
vertex_store->buffer = NULL;
}
assert(save->buffer == save->buffer_ptr);
if (save->vertex_size)
- save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) /
- save->vertex_size);
+ save->max_vert = (VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) /
+ save->vertex_size;
else
save->max_vert = 0;
save->vert_count = 0;
save->prim_count = 0;
save->prim_max = VBO_SAVE_PRIM_SIZE - save->prim_store->used;
- save->dangling_attr_ref = 0;
+ save->dangling_attr_ref = GL_FALSE;
}
/**
save->vertex_store->used += save->vertex_size * node->count;
save->prim_store->used += node->prim_count;
- /* Copy duplicated vertices
+ /* Copy duplicated vertices
*/
save->copied.nr = _save_copy_vertices(ctx, node, save->buffer);
save->prim[0].count = 0;
save->prim[0].num_instances = 1;
save->prim[0].base_instance = 0;
+ save->prim[0].is_indirect = 0;
save->prim_count = 1;
}
/**
* Called only when buffers are wrapped as the result of filling the
- * vertex_store struct.
+ * vertex_store struct.
*/
static void
_save_wrap_filled_vertex(struct gl_context *ctx)
/* Do a COPY_TO_CURRENT to ensure back-copying works for the case
* when the attribute already exists in the vertex and is having
- * its size increased.
+ * its size increased.
*/
_save_copy_to_current(ctx);
* unfortunately, otherwise this primitive won't be handled
* properly:
*/
- save->dangling_attr_ref = 1;
+ save->dangling_attr_ref = GL_TRUE;
_save_compile_vertex_list(ctx);
}
save->prim[i].count = 0;
save->prim[i].num_instances = 1;
save->prim[i].base_instance = 0;
+ save->prim[i].is_indirect = 0;
if (save->out_of_memory) {
_mesa_install_save_vtxfmt(ctx, &save->vtxfmt_noop);
{
GET_CURRENT_CONTEXT(ctx);
struct vbo_save_context *save = &vbo_context(ctx)->save;
+ struct gl_buffer_object *indexbuf = ctx->Array.VAO->IndexBufferObj;
GLint i;
if (!_mesa_is_valid_prim_mode(ctx, mode)) {
_ae_map_vbos(ctx);
- if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj))
+ if (_mesa_is_bufferobj(indexbuf))
indices =
- ADD_POINTERS(ctx->Array.ArrayObj->ElementArrayBufferObj->Pointer, indices);
+ ADD_POINTERS(indexbuf->Mappings[MAP_INTERNAL].Pointer, indices);
vbo_save_NotifyBegin(ctx, (mode | VBO_SAVE_PRIM_WEAK |
VBO_SAVE_PRIM_NO_CURRENT_UPDATE));
static void GLAPIENTRY
_save_OBE_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
- const GLvoid **indices, GLsizei primcount)
+ const GLvoid * const *indices, GLsizei primcount)
{
GLsizei i;
GLint i = save->prim_count - 1;
ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
save->prim[i].end = 0;
- save->prim[i].count = (save->vert_count - save->prim[i].start);
+ save->prim[i].count = save->vert_count - save->prim[i].start;
}
/* Make sure this vertex list gets replayed by the "loopback"
* mechanism:
*/
- save->dangling_attr_ref = 1;
+ save->dangling_attr_ref = GL_TRUE;
vbo_save_SaveFlushVertices(ctx);
/* Swap out this vertex format while outside begin/end. Any color,
projects / mesa.git / blobdiff