* Keith Whitwell <keithw@vmware.com>
*/
+#include <stdbool.h>
#include <stdio.h>
+#include "main/arrayobj.h"
#include "main/glheader.h"
#include "main/bufferobj.h"
-#include "main/compiler.h"
#include "main/context.h"
#include "main/enums.h"
#include "main/state.h"
+#include "main/varray.h"
#include "main/vtxfmt.h"
-#include "vbo_context.h"
#include "vbo_noop.h"
+#include "vbo_private.h"
static void
-vbo_exec_debug_verts( struct vbo_exec_context *exec )
+vbo_exec_debug_verts(struct vbo_exec_context *exec)
{
GLuint count = exec->vtx.vert_count;
GLuint i;
printf("%s: %u vertices %d primitives, %d vertsize\n",
- __func__,
- count,
- exec->vtx.prim_count,
- exec->vtx.vertex_size);
+ __func__,
+ count,
+ exec->vtx.prim_count,
+ exec->vtx.vertex_size);
for (i = 0 ; i < exec->vtx.prim_count ; i++) {
struct _mesa_prim *prim = &exec->vtx.prim[i];
- printf(" prim %d: %s%s %d..%d %s %s\n",
- i,
- _mesa_lookup_prim_by_nr(prim->mode),
- prim->weak ? " (weak)" : "",
- prim->start,
- prim->start + prim->count,
- prim->begin ? "BEGIN" : "(wrap)",
- prim->end ? "END" : "(wrap)");
+ printf(" prim %d: %s %d..%d %s %s\n",
+ i,
+ _mesa_lookup_prim_by_nr(prim->mode),
+ prim->start,
+ prim->start + prim->count,
+ prim->begin ? "BEGIN" : "(wrap)",
+ prim->end ? "END" : "(wrap)");
}
}
* copied from the old buffer to the new one.
*/
static GLuint
-vbo_copy_vertices( struct vbo_exec_context *exec )
+vbo_copy_vertices(struct vbo_exec_context *exec)
{
- GLuint nr = exec->vtx.prim[exec->vtx.prim_count-1].count;
+ struct _mesa_prim *last_prim = &exec->vtx.prim[exec->vtx.prim_count - 1];
+ const GLuint nr = last_prim->count;
GLuint ovf, i;
- GLuint sz = exec->vtx.vertex_size;
+ const GLuint sz = exec->vtx.vertex_size;
fi_type *dst = exec->vtx.copied.buffer;
- const fi_type *src = (exec->vtx.buffer_map +
- exec->vtx.prim[exec->vtx.prim_count-1].start *
- exec->vtx.vertex_size);
+ const fi_type *src = exec->vtx.buffer_map + last_prim->start * sz;
switch (exec->ctx->Driver.CurrentExecPrimitive) {
case GL_POINTS:
case GL_LINES:
ovf = nr&1;
for (i = 0 ; i < ovf ; i++)
- memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );
+ memcpy(dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat));
return i;
case GL_TRIANGLES:
ovf = nr%3;
for (i = 0 ; i < ovf ; i++)
- memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );
+ memcpy(dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat));
return i;
case GL_QUADS:
ovf = nr&3;
for (i = 0 ; i < ovf ; i++)
- memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );
+ memcpy(dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat));
return i;
case GL_LINE_STRIP:
if (nr == 0) {
- return 0;
+ return 0;
}
else {
- memcpy( dst, src+(nr-1)*sz, sz * sizeof(GLfloat) );
- return 1;
+ memcpy(dst, src+(nr-1)*sz, sz * sizeof(GLfloat));
+ return 1;
}
case GL_LINE_LOOP:
+ if (last_prim->begin == 0) {
+ /* We're dealing with the second or later section of a split/wrapped
+ * GL_LINE_LOOP. Since we're converting line loops to line strips,
+ * we've already increment the last_prim->start counter by one to
+ * skip the 0th vertex in the loop. We need to undo that (effectively
+ * subtract one from last_prim->start) so that we copy the 0th vertex
+ * to the next vertex buffer.
+ */
+ assert(last_prim->start > 0);
+ src -= sz;
+ }
+ /* fall-through */
case GL_TRIANGLE_FAN:
case GL_POLYGON:
if (nr == 0) {
- return 0;
+ return 0;
}
else if (nr == 1) {
- memcpy( dst, src+0, sz * sizeof(GLfloat) );
- return 1;
+ memcpy(dst, src+0, sz * sizeof(GLfloat));
+ return 1;
}
else {
- memcpy( dst, src+0, sz * sizeof(GLfloat) );
- memcpy( dst+sz, src+(nr-1)*sz, sz * sizeof(GLfloat) );
- return 2;
+ memcpy(dst, src+0, sz * sizeof(GLfloat));
+ memcpy(dst+sz, src+(nr-1)*sz, sz * sizeof(GLfloat));
+ return 2;
}
case GL_TRIANGLE_STRIP:
/* no parity issue, but need to make sure the tri is not drawn twice */
if (nr & 1) {
- exec->vtx.prim[exec->vtx.prim_count-1].count--;
+ last_prim->count--;
}
/* fallthrough */
case GL_QUAD_STRIP:
break;
}
for (i = 0 ; i < ovf ; i++)
- memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );
+ memcpy(dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat));
return i;
case PRIM_OUTSIDE_BEGIN_END:
return 0;
default:
- assert(0);
+ unreachable("Unexpected primitive type");
return 0;
}
}
/* TODO: populate these as the vertex is defined:
*/
static void
-vbo_exec_bind_arrays( struct gl_context *ctx )
+vbo_exec_bind_arrays(struct gl_context *ctx)
{
struct vbo_context *vbo = vbo_context(ctx);
+ struct gl_vertex_array_object *vao = vbo->VAO;
struct vbo_exec_context *exec = &vbo->exec;
- struct gl_client_array *arrays = exec->vtx.arrays;
- const GLuint *map;
- GLuint attr;
- GLbitfield64 varying_inputs = 0x0;
- /* Install the default (ie Current) attributes first, then overlay
- * all active ones.
- */
- switch (get_program_mode(exec->ctx)) {
- case VP_NONE:
- for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) {
- exec->vtx.inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr];
- }
- for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) {
- assert(VERT_ATTRIB_GENERIC(attr) < ARRAY_SIZE(exec->vtx.inputs));
- exec->vtx.inputs[VERT_ATTRIB_GENERIC(attr)] =
- &vbo->currval[VBO_ATTRIB_MAT_FRONT_AMBIENT+attr];
- }
- map = vbo->map_vp_none;
- break;
- case VP_ARB:
- for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) {
- exec->vtx.inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr];
- }
- for (attr = 0; attr < VERT_ATTRIB_GENERIC_MAX; attr++) {
- assert(VERT_ATTRIB_GENERIC(attr) < ARRAY_SIZE(exec->vtx.inputs));
- exec->vtx.inputs[VERT_ATTRIB_GENERIC(attr)] =
- &vbo->currval[VBO_ATTRIB_GENERIC0+attr];
- }
- map = vbo->map_vp_arb;
-
- /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read.
- * In that case we effectively need to route the data from
- * glVertexAttrib(0, val) calls to feed into the GENERIC0 input.
- */
- if ((ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_POS) == 0 &&
- (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_GENERIC0)) {
- exec->vtx.inputs[VERT_ATTRIB_GENERIC0] = exec->vtx.inputs[0];
- exec->vtx.attrsz[VERT_ATTRIB_GENERIC0] = exec->vtx.attrsz[0];
- exec->vtx.attrptr[VERT_ATTRIB_GENERIC0] = exec->vtx.attrptr[0];
- exec->vtx.attrsz[0] = 0;
- }
- break;
- default:
- assert(0);
+ GLintptr buffer_offset;
+ if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {
+ assert(exec->vtx.bufferobj->Mappings[MAP_INTERNAL].Pointer);
+ buffer_offset = exec->vtx.bufferobj->Mappings[MAP_INTERNAL].Offset;
+ } else {
+ /* Ptr into ordinary app memory */
+ buffer_offset = (GLbyte *)exec->vtx.buffer_map - (GLbyte *)NULL;
}
- for (attr = 0; attr < VERT_ATTRIB_MAX ; attr++) {
- const GLuint src = map[attr];
-
- if (exec->vtx.attrsz[src]) {
- GLsizeiptr offset = (GLbyte *)exec->vtx.attrptr[src] -
- (GLbyte *)exec->vtx.vertex;
-
- /* override the default array set above */
- assert(attr < ARRAY_SIZE(exec->vtx.inputs));
- assert(attr < ARRAY_SIZE(exec->vtx.arrays)); /* arrays[] */
- exec->vtx.inputs[attr] = &arrays[attr];
-
- if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {
- /* a real buffer obj: Ptr is an offset, not a pointer */
- assert(exec->vtx.bufferobj->Mappings[MAP_INTERNAL].Pointer);
- assert(offset >= 0);
- arrays[attr].Ptr = (GLubyte *)
- exec->vtx.bufferobj->Mappings[MAP_INTERNAL].Offset + offset;
- }
- else {
- /* Ptr into ordinary app memory */
- arrays[attr].Ptr = (GLubyte *)exec->vtx.buffer_map + offset;
- }
- arrays[attr].Size = exec->vtx.attrsz[src];
- arrays[attr].StrideB = exec->vtx.vertex_size * sizeof(GLfloat);
- arrays[attr].Stride = exec->vtx.vertex_size * sizeof(GLfloat);
- arrays[attr].Type = exec->vtx.attrtype[src];
- arrays[attr].Integer =
- vbo_attrtype_to_integer_flag(exec->vtx.attrtype[src]);
- arrays[attr].Format = GL_RGBA;
- arrays[attr].Enabled = 1;
- arrays[attr]._ElementSize = arrays[attr].Size * sizeof(GLfloat);
- _mesa_reference_buffer_object(ctx,
- &arrays[attr].BufferObj,
- exec->vtx.bufferobj);
-
- varying_inputs |= VERT_BIT(attr);
- }
+ const gl_vertex_processing_mode mode = ctx->VertexProgram._VPMode;
+
+ /* Compute the bitmasks of vao_enabled arrays */
+ GLbitfield vao_enabled = _vbo_get_vao_enabled_from_vbo(mode, exec->vtx.enabled);
+
+ /* At first disable arrays no longer needed */
+ GLbitfield mask = vao->_Enabled & ~vao_enabled;
+ while (mask) {
+ const int vao_attr = u_bit_scan(&mask);
+ _mesa_disable_vertex_array_attrib(ctx, vao, vao_attr);
}
+ assert((~vao_enabled & vao->_Enabled) == 0);
+
+ /* Bind the buffer object */
+ const GLuint stride = exec->vtx.vertex_size*sizeof(GLfloat);
+ _mesa_bind_vertex_buffer(ctx, vao, 0, exec->vtx.bufferobj, buffer_offset,
+ stride);
- _mesa_set_varying_vp_inputs( ctx, varying_inputs );
- ctx->NewDriverState |= ctx->DriverFlags.NewArray;
+ /* Retrieve the mapping from VBO_ATTRIB to VERT_ATTRIB space
+ * Note that the position/generic0 aliasing is done in the VAO.
+ */
+ const GLubyte *const vao_to_vbo_map = _vbo_attribute_alias_map[mode];
+ /* Now set the enabled arrays */
+ mask = vao_enabled;
+ while (mask) {
+ const int vao_attr = u_bit_scan(&mask);
+ const GLubyte vbo_attr = vao_to_vbo_map[vao_attr];
+
+ const GLubyte size = exec->vtx.attrsz[vbo_attr];
+ const GLenum16 type = exec->vtx.attrtype[vbo_attr];
+ const GLuint offset = (GLuint)((GLbyte *)exec->vtx.attrptr[vbo_attr] -
+ (GLbyte *)exec->vtx.vertex);
+ assert(offset <= ctx->Const.MaxVertexAttribRelativeOffset);
+
+ /* Set and enable */
+ _vbo_set_attrib_format(ctx, vao, vao_attr, buffer_offset,
+ size, type, offset);
+ if ((vao->_Enabled & VERT_BIT(vao_attr)) == 0)
+ _mesa_enable_vertex_array_attrib(ctx, vao, vao_attr);
+
+ /* The vao is initially created with all bindings set to 0. */
+ assert(vao->VertexAttrib[vao_attr].BufferBindingIndex == 0);
+ }
+ assert(vao_enabled == vao->_Enabled);
+ assert(!_mesa_is_bufferobj(exec->vtx.bufferobj) ||
+ (vao_enabled & ~vao->VertexAttribBufferMask) == 0);
+
+ _mesa_set_draw_vao(ctx, vao, _vbo_get_vao_filter(mode));
}
* Unmap the VBO. This is called before drawing.
*/
static void
-vbo_exec_vtx_unmap( struct vbo_exec_context *exec )
+vbo_exec_vtx_unmap(struct vbo_exec_context *exec)
{
if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {
struct gl_context *ctx = exec->ctx;
* Map the vertex buffer to begin storing glVertex, glColor, etc data.
*/
void
-vbo_exec_vtx_map( struct vbo_exec_context *exec )
+vbo_exec_vtx_map(struct vbo_exec_context *exec)
{
struct gl_context *ctx = exec->ctx;
const GLenum accessRange = GL_MAP_WRITE_BIT | /* for MapBufferRange */
if (VBO_VERT_BUFFER_SIZE > exec->vtx.buffer_used + 1024) {
/* The VBO exists and there's room for more */
if (exec->vtx.bufferobj->Size > 0) {
- exec->vtx.buffer_map =
- (fi_type *)ctx->Driver.MapBufferRange(ctx,
- exec->vtx.buffer_used,
- (VBO_VERT_BUFFER_SIZE -
- exec->vtx.buffer_used),
- accessRange,
- exec->vtx.bufferobj,
- MAP_INTERNAL);
+ exec->vtx.buffer_map = (fi_type *)
+ ctx->Driver.MapBufferRange(ctx,
+ exec->vtx.buffer_used,
+ VBO_VERT_BUFFER_SIZE
+ - exec->vtx.buffer_used,
+ accessRange,
+ exec->vtx.bufferobj,
+ MAP_INTERNAL);
exec->vtx.buffer_ptr = exec->vtx.buffer_map;
}
else {
if (!exec->vtx.buffer_map) {
/* out of memory */
- _mesa_install_exec_vtxfmt( ctx, &exec->vtxfmt_noop );
+ _mesa_install_exec_vtxfmt(ctx, &exec->vtxfmt_noop);
}
else {
if (_mesa_using_noop_vtxfmt(ctx->Exec)) {
vbo_exec_vtx_flush(struct vbo_exec_context *exec, GLboolean keepUnmapped)
{
if (0)
- vbo_exec_debug_verts( exec );
+ vbo_exec_debug_verts(exec);
if (exec->vtx.prim_count &&
exec->vtx.vert_count) {
- exec->vtx.copied.nr = vbo_copy_vertices( exec );
+ exec->vtx.copied.nr = vbo_copy_vertices(exec);
if (exec->vtx.copied.nr != exec->vtx.vert_count) {
- struct gl_context *ctx = exec->ctx;
+ struct gl_context *ctx = exec->ctx;
- /* Before the update_state() as this may raise _NEW_VARYING_VP_INPUTS
+ /* Before the update_state() as this may raise _NEW_VARYING_VP_INPUTS
* from _mesa_set_varying_vp_inputs().
- */
- vbo_exec_bind_arrays( ctx );
+ */
+ vbo_exec_bind_arrays(ctx);
if (ctx->NewState)
- _mesa_update_state( ctx );
+ _mesa_update_state(ctx);
+
+ vbo_exec_vtx_unmap(exec);
- if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {
- vbo_exec_vtx_unmap( exec );
- }
+ assert(ctx->NewState == 0);
if (0)
printf("%s %d %d\n", __func__, exec->vtx.prim_count,
- exec->vtx.vert_count);
-
- vbo_context(ctx)->draw_prims( ctx,
- exec->vtx.prim,
- exec->vtx.prim_count,
- NULL,
- GL_TRUE,
- 0,
- exec->vtx.vert_count - 1,
- NULL, 0, NULL);
-
- /* If using a real VBO, get new storage -- unless asked not to.
- */
- if (_mesa_is_bufferobj(exec->vtx.bufferobj) && !keepUnmapped) {
- vbo_exec_vtx_map( exec );
- }
+ exec->vtx.vert_count);
+
+ ctx->Driver.Draw(ctx, exec->vtx.prim, exec->vtx.prim_count,
+ NULL, GL_TRUE, 0, exec->vtx.vert_count - 1,
+ NULL, 0, NULL);
+
+ /* Get new storage -- unless asked not to. */
+ if (!keepUnmapped)
+ vbo_exec_vtx_map(exec);
}
}
/* May have to unmap explicitly if we didn't draw:
*/
- if (keepUnmapped &&
- _mesa_is_bufferobj(exec->vtx.bufferobj) &&
- exec->vtx.buffer_map) {
- vbo_exec_vtx_unmap( exec );
+ if (keepUnmapped && exec->vtx.buffer_map) {
+ vbo_exec_vtx_unmap(exec);
}
if (keepUnmapped || exec->vtx.vertex_size == 0)
exec->vtx.max_vert = 0;
else
- exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) /
- (exec->vtx.vertex_size * sizeof(GLfloat)));
+ exec->vtx.max_vert = vbo_compute_max_verts(exec);
exec->vtx.buffer_ptr = exec->vtx.buffer_map;
exec->vtx.prim_count = 0;
projects / mesa.git / blobdiff