#include <stdio.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/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)");
+ 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)");
}
}
* 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)
{
struct _mesa_prim *last_prim = &exec->vtx.prim[exec->vtx.prim_count - 1];
const GLuint nr = last_prim->count;
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) {
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) {
- last_prim->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 vbo_exec_context *exec = &vbo->exec;
- struct gl_client_array *arrays = exec->vtx.arrays;
- const GLuint *map;
+ struct gl_vertex_array *arrays = exec->vtx.arrays;
+ const GLubyte *map;
GLuint attr;
- GLbitfield64 varying_inputs = 0x0;
+ GLbitfield varying_inputs = 0x0;
bool swap_pos = false;
- /* Install the default (ie Current) attributes first, then overlay
- * all active ones.
- */
+ /* Install the default (ie Current) attributes first */
+ for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) {
+ exec->vtx.inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr];
+ }
+
+ /* Overlay other active attributes */
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)] =
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)] =
* glVertexAttrib(0, val) calls to feed into the GENERIC0 input.
* The original state gets essentially restored below.
*/
- if ((ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_POS) == 0 &&
- (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_GENERIC0)) {
+ const GLbitfield64 inputs_read =
+ ctx->VertexProgram._Current->info.inputs_read;
+ if ((inputs_read & VERT_BIT_POS) == 0 &&
+ (inputs_read & VERT_BIT_GENERIC0)) {
swap_pos = true;
exec->vtx.inputs[VERT_ATTRIB_GENERIC0] = exec->vtx.inputs[0];
exec->vtx.attrsz[VERT_ATTRIB_GENERIC0] = exec->vtx.attrsz[0];
}
break;
default:
- assert(0);
+ unreachable("Bad vertex program mode");
}
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;
+ GLsizeiptr offset = (GLbyte *)exec->vtx.attrptr[src] -
+ (GLbyte *)exec->vtx.vertex;
/* override the default array set above */
assert(attr < ARRAY_SIZE(exec->vtx.inputs));
/* 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].Type = exec->vtx.attrtype[src];
- arrays[attr].Integer =
+ arrays[attr].Size = exec->vtx.attrsz[src];
+ arrays[attr].StrideB = 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]._ElementSize = arrays[attr].Size * sizeof(GLfloat);
exec->vtx.attrsz[VERT_ATTRIB_GENERIC0] = 0;
}
- _mesa_set_varying_vp_inputs( ctx, varying_inputs );
+ _mesa_set_varying_vp_inputs(ctx, varying_inputs);
ctx->NewDriverState |= ctx->DriverFlags.NewArray;
}
* 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);
- if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {
- vbo_exec_vtx_unmap( exec );
- }
+ vbo_exec_vtx_unmap(exec);
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);
+
+ 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);
+
+ /* 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)
projects / mesa.git / blobdiff