vbo_exec_draw.c revision 038d654bcb4e9d88eab420cefc3169d4845db4c9
1/* 2 * Mesa 3-D graphics library 3 * Version: 7.2 4 * 5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: 25 * Keith Whitwell <keith@tungstengraphics.com> 26 */ 27 28#include "main/glheader.h" 29#include "main/bufferobj.h" 30#include "main/compiler.h" 31#include "main/enums.h" 32#include "main/mfeatures.h" 33#include "main/state.h" 34 35#include "vbo_context.h" 36 37 38#if FEATURE_beginend 39 40 41static void 42vbo_exec_debug_verts( struct vbo_exec_context *exec ) 43{ 44 GLuint count = exec->vtx.vert_count; 45 GLuint i; 46 47 printf("%s: %u vertices %d primitives, %d vertsize\n", 48 __FUNCTION__, 49 count, 50 exec->vtx.prim_count, 51 exec->vtx.vertex_size); 52 53 for (i = 0 ; i < exec->vtx.prim_count ; i++) { 54 struct _mesa_prim *prim = &exec->vtx.prim[i]; 55 printf(" prim %d: %s%s %d..%d %s %s\n", 56 i, 57 _mesa_lookup_prim_by_nr(prim->mode), 58 prim->weak ? " (weak)" : "", 59 prim->start, 60 prim->start + prim->count, 61 prim->begin ? "BEGIN" : "(wrap)", 62 prim->end ? "END" : "(wrap)"); 63 } 64} 65 66 67/* 68 * NOTE: Need to have calculated primitives by this point -- do it on the fly. 69 * NOTE: Old 'parity' issue is gone. 70 */ 71static GLuint 72vbo_copy_vertices( struct vbo_exec_context *exec ) 73{ 74 GLuint nr = exec->vtx.prim[exec->vtx.prim_count-1].count; 75 GLuint ovf, i; 76 GLuint sz = exec->vtx.vertex_size; 77 GLfloat *dst = exec->vtx.copied.buffer; 78 const GLfloat *src = (exec->vtx.buffer_map + 79 exec->vtx.prim[exec->vtx.prim_count-1].start * 80 exec->vtx.vertex_size); 81 82 83 switch (exec->ctx->Driver.CurrentExecPrimitive) { 84 case GL_POINTS: 85 return 0; 86 case GL_LINES: 87 ovf = nr&1; 88 for (i = 0 ; i < ovf ; i++) 89 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 90 return i; 91 case GL_TRIANGLES: 92 ovf = nr%3; 93 for (i = 0 ; i < ovf ; i++) 94 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 95 return i; 96 case GL_QUADS: 97 ovf = nr&3; 98 for (i = 0 ; i < ovf ; i++) 99 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 100 return i; 101 case GL_LINE_STRIP: 102 if (nr == 0) { 103 return 0; 104 } 105 else { 106 memcpy( dst, src+(nr-1)*sz, sz * sizeof(GLfloat) ); 107 return 1; 108 } 109 case GL_LINE_LOOP: 110 case GL_TRIANGLE_FAN: 111 case GL_POLYGON: 112 if (nr == 0) { 113 return 0; 114 } 115 else if (nr == 1) { 116 memcpy( dst, src+0, sz * sizeof(GLfloat) ); 117 return 1; 118 } 119 else { 120 memcpy( dst, src+0, sz * sizeof(GLfloat) ); 121 memcpy( dst+sz, src+(nr-1)*sz, sz * sizeof(GLfloat) ); 122 return 2; 123 } 124 case GL_TRIANGLE_STRIP: 125 /* no parity issue, but need to make sure the tri is not drawn twice */ 126 if (nr & 1) { 127 exec->vtx.prim[exec->vtx.prim_count-1].count--; 128 } 129 /* fallthrough */ 130 case GL_QUAD_STRIP: 131 switch (nr) { 132 case 0: 133 ovf = 0; 134 break; 135 case 1: 136 ovf = 1; 137 break; 138 default: 139 ovf = 2 + (nr & 1); 140 break; 141 } 142 for (i = 0 ; i < ovf ; i++) 143 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 144 return i; 145 case PRIM_OUTSIDE_BEGIN_END: 146 return 0; 147 default: 148 assert(0); 149 return 0; 150 } 151} 152 153 154 155/* TODO: populate these as the vertex is defined: 156 */ 157static void 158vbo_exec_bind_arrays( struct gl_context *ctx ) 159{ 160 struct vbo_context *vbo = vbo_context(ctx); 161 struct vbo_exec_context *exec = &vbo->exec; 162 struct gl_client_array *arrays = exec->vtx.arrays; 163 const GLuint count = exec->vtx.vert_count; 164 const GLuint *map; 165 GLuint attr; 166 GLbitfield varying_inputs = 0x0; 167 168 /* Install the default (ie Current) attributes first, then overlay 169 * all active ones. 170 */ 171 switch (get_program_mode(exec->ctx)) { 172 case VP_NONE: 173 for (attr = 0; attr < 16; attr++) { 174 exec->vtx.inputs[attr] = &vbo->legacy_currval[attr]; 175 } 176 for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) { 177 ASSERT(attr + 16 < Elements(exec->vtx.inputs)); 178 exec->vtx.inputs[attr + 16] = &vbo->mat_currval[attr]; 179 } 180 map = vbo->map_vp_none; 181 break; 182 case VP_NV: 183 case VP_ARB: 184 /* The aliasing of attributes for NV vertex programs has already 185 * occurred. NV vertex programs cannot access material values, 186 * nor attributes greater than VERT_ATTRIB_TEX7. 187 */ 188 for (attr = 0; attr < 16; attr++) { 189 exec->vtx.inputs[attr] = &vbo->legacy_currval[attr]; 190 ASSERT(attr + 16 < Elements(exec->vtx.inputs)); 191 exec->vtx.inputs[attr + 16] = &vbo->generic_currval[attr]; 192 } 193 map = vbo->map_vp_arb; 194 195 /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read. 196 * In that case we effectively need to route the data from 197 * glVertexAttrib(0, val) calls to feed into the GENERIC0 input. 198 */ 199 if ((ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_POS) == 0 && 200 (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_GENERIC0)) { 201 exec->vtx.inputs[16] = exec->vtx.inputs[0]; 202 exec->vtx.attrsz[16] = exec->vtx.attrsz[0]; 203 exec->vtx.attrptr[16] = exec->vtx.attrptr[0]; 204 exec->vtx.attrsz[0] = 0; 205 } 206 break; 207 default: 208 assert(0); 209 } 210 211 /* Make all active attributes (including edgeflag) available as 212 * arrays of floats. 213 */ 214 for (attr = 0; attr < VERT_ATTRIB_MAX ; attr++) { 215 const GLuint src = map[attr]; 216 217 if (exec->vtx.attrsz[src]) { 218 GLsizeiptr offset = (GLbyte *)exec->vtx.attrptr[src] - 219 (GLbyte *)exec->vtx.vertex; 220 221 /* override the default array set above */ 222 ASSERT(attr < Elements(exec->vtx.inputs)); 223 ASSERT(attr < Elements(exec->vtx.arrays)); /* arrays[] */ 224 exec->vtx.inputs[attr] = &arrays[attr]; 225 226 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 227 /* a real buffer obj: Ptr is an offset, not a pointer*/ 228 assert(exec->vtx.bufferobj->Pointer); /* buf should be mapped */ 229 assert(offset >= 0); 230 arrays[attr].Ptr = (GLubyte *)exec->vtx.bufferobj->Offset + offset; 231 } 232 else { 233 /* Ptr into ordinary app memory */ 234 arrays[attr].Ptr = (GLubyte *)exec->vtx.buffer_map + offset; 235 } 236 arrays[attr].Size = exec->vtx.attrsz[src]; 237 arrays[attr].StrideB = exec->vtx.vertex_size * sizeof(GLfloat); 238 arrays[attr].Stride = exec->vtx.vertex_size * sizeof(GLfloat); 239 arrays[attr].Type = GL_FLOAT; 240 arrays[attr].Format = GL_RGBA; 241 arrays[attr].Enabled = 1; 242 arrays[attr]._ElementSize = arrays[attr].Size * sizeof(GLfloat); 243 _mesa_reference_buffer_object(ctx, 244 &arrays[attr].BufferObj, 245 exec->vtx.bufferobj); 246 arrays[attr]._MaxElement = count; /* ??? */ 247 248 varying_inputs |= 1 << attr; 249 ctx->NewState |= _NEW_ARRAY; 250 } 251 } 252 253 _mesa_set_varying_vp_inputs( ctx, varying_inputs ); 254} 255 256 257/** 258 * Unmap the VBO. This is called before drawing. 259 */ 260static void 261vbo_exec_vtx_unmap( struct vbo_exec_context *exec ) 262{ 263 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 264 struct gl_context *ctx = exec->ctx; 265 266 if (ctx->Driver.FlushMappedBufferRange) { 267 GLintptr offset = exec->vtx.buffer_used - exec->vtx.bufferobj->Offset; 268 GLsizeiptr length = (exec->vtx.buffer_ptr - exec->vtx.buffer_map) * sizeof(float); 269 270 if (length) 271 ctx->Driver.FlushMappedBufferRange(ctx, offset, length, 272 exec->vtx.bufferobj); 273 } 274 275 exec->vtx.buffer_used += (exec->vtx.buffer_ptr - 276 exec->vtx.buffer_map) * sizeof(float); 277 278 assert(exec->vtx.buffer_used <= VBO_VERT_BUFFER_SIZE); 279 assert(exec->vtx.buffer_ptr != NULL); 280 281 ctx->Driver.UnmapBuffer(ctx, exec->vtx.bufferobj); 282 exec->vtx.buffer_map = NULL; 283 exec->vtx.buffer_ptr = NULL; 284 exec->vtx.max_vert = 0; 285 } 286} 287 288 289/** 290 * Map the vertex buffer to begin storing glVertex, glColor, etc data. 291 */ 292void 293vbo_exec_vtx_map( struct vbo_exec_context *exec ) 294{ 295 struct gl_context *ctx = exec->ctx; 296 const GLenum accessRange = GL_MAP_WRITE_BIT | /* for MapBufferRange */ 297 GL_MAP_INVALIDATE_RANGE_BIT | 298 GL_MAP_UNSYNCHRONIZED_BIT | 299 GL_MAP_FLUSH_EXPLICIT_BIT | 300 MESA_MAP_NOWAIT_BIT; 301 const GLenum usage = GL_STREAM_DRAW_ARB; 302 303 if (!_mesa_is_bufferobj(exec->vtx.bufferobj)) 304 return; 305 306 assert(!exec->vtx.buffer_map); 307 assert(!exec->vtx.buffer_ptr); 308 309 if (VBO_VERT_BUFFER_SIZE > exec->vtx.buffer_used + 1024) { 310 /* The VBO exists and there's room for more */ 311 exec->vtx.buffer_map = 312 (GLfloat *)ctx->Driver.MapBufferRange(ctx, 313 exec->vtx.buffer_used, 314 (VBO_VERT_BUFFER_SIZE - 315 exec->vtx.buffer_used), 316 accessRange, 317 exec->vtx.bufferobj); 318 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 319 } 320 321 if (!exec->vtx.buffer_map) { 322 /* Need to allocate a new VBO */ 323 exec->vtx.buffer_used = 0; 324 325 ctx->Driver.BufferData(ctx, GL_ARRAY_BUFFER_ARB, 326 VBO_VERT_BUFFER_SIZE, 327 NULL, usage, exec->vtx.bufferobj); 328 329 330 exec->vtx.buffer_map = 331 (GLfloat *)ctx->Driver.MapBufferRange(ctx, 332 0, VBO_VERT_BUFFER_SIZE, 333 accessRange, 334 exec->vtx.bufferobj); 335 assert(exec->vtx.buffer_map); 336 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 337 } 338 339 if (0) 340 printf("map %d..\n", exec->vtx.buffer_used); 341} 342 343 344 345/** 346 * Execute the buffer and save copied verts. 347 * \param keep_unmapped if true, leave the VBO unmapped when we're done. 348 */ 349void 350vbo_exec_vtx_flush(struct vbo_exec_context *exec, GLboolean keepUnmapped) 351{ 352 if (0) 353 vbo_exec_debug_verts( exec ); 354 355 if (exec->vtx.prim_count && 356 exec->vtx.vert_count) { 357 358 exec->vtx.copied.nr = vbo_copy_vertices( exec ); 359 360 if (exec->vtx.copied.nr != exec->vtx.vert_count) { 361 struct gl_context *ctx = exec->ctx; 362 363 /* Before the update_state() as this may raise _NEW_ARRAY 364 * from _mesa_set_varying_vp_inputs(). 365 */ 366 vbo_exec_bind_arrays( ctx ); 367 368 if (ctx->NewState) 369 _mesa_update_state( ctx ); 370 371 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 372 vbo_exec_vtx_unmap( exec ); 373 } 374 375 if (0) 376 printf("%s %d %d\n", __FUNCTION__, exec->vtx.prim_count, 377 exec->vtx.vert_count); 378 379 vbo_context(ctx)->draw_prims( ctx, 380 exec->vtx.inputs, 381 exec->vtx.prim, 382 exec->vtx.prim_count, 383 NULL, 384 GL_TRUE, 385 0, 386 exec->vtx.vert_count - 1); 387 388 /* If using a real VBO, get new storage -- unless asked not to. 389 */ 390 if (_mesa_is_bufferobj(exec->vtx.bufferobj) && !keepUnmapped) { 391 vbo_exec_vtx_map( exec ); 392 } 393 } 394 } 395 396 /* May have to unmap explicitly if we didn't draw: 397 */ 398 if (keepUnmapped && 399 _mesa_is_bufferobj(exec->vtx.bufferobj) && 400 exec->vtx.buffer_map) { 401 vbo_exec_vtx_unmap( exec ); 402 } 403 404 if (keepUnmapped || exec->vtx.vertex_size == 0) 405 exec->vtx.max_vert = 0; 406 else 407 exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) / 408 (exec->vtx.vertex_size * sizeof(GLfloat))); 409 410 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 411 exec->vtx.prim_count = 0; 412 exec->vtx.vert_count = 0; 413} 414 415 416#endif /* FEATURE_beginend */ 417