vbo_exec_draw.c revision 97e2f625b8bcba96acde29dcd017031e036f4a24
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/context.h" 32#include "main/enums.h" 33#include "main/mfeatures.h" 34#include "main/state.h" 35#include "main/vtxfmt.h" 36 37#include "vbo_context.h" 38#include "vbo_noop.h" 39 40 41#if FEATURE_beginend 42 43 44static void 45vbo_exec_debug_verts( struct vbo_exec_context *exec ) 46{ 47 GLuint count = exec->vtx.vert_count; 48 GLuint i; 49 50 printf("%s: %u vertices %d primitives, %d vertsize\n", 51 __FUNCTION__, 52 count, 53 exec->vtx.prim_count, 54 exec->vtx.vertex_size); 55 56 for (i = 0 ; i < exec->vtx.prim_count ; i++) { 57 struct _mesa_prim *prim = &exec->vtx.prim[i]; 58 printf(" prim %d: %s%s %d..%d %s %s\n", 59 i, 60 _mesa_lookup_prim_by_nr(prim->mode), 61 prim->weak ? " (weak)" : "", 62 prim->start, 63 prim->start + prim->count, 64 prim->begin ? "BEGIN" : "(wrap)", 65 prim->end ? "END" : "(wrap)"); 66 } 67} 68 69 70/* 71 * NOTE: Need to have calculated primitives by this point -- do it on the fly. 72 * NOTE: Old 'parity' issue is gone. 73 */ 74static GLuint 75vbo_copy_vertices( struct vbo_exec_context *exec ) 76{ 77 GLuint nr = exec->vtx.prim[exec->vtx.prim_count-1].count; 78 GLuint ovf, i; 79 GLuint sz = exec->vtx.vertex_size; 80 GLfloat *dst = exec->vtx.copied.buffer; 81 const GLfloat *src = (exec->vtx.buffer_map + 82 exec->vtx.prim[exec->vtx.prim_count-1].start * 83 exec->vtx.vertex_size); 84 85 86 switch (exec->ctx->Driver.CurrentExecPrimitive) { 87 case GL_POINTS: 88 return 0; 89 case GL_LINES: 90 ovf = nr&1; 91 for (i = 0 ; i < ovf ; i++) 92 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 93 return i; 94 case GL_TRIANGLES: 95 ovf = nr%3; 96 for (i = 0 ; i < ovf ; i++) 97 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 98 return i; 99 case GL_QUADS: 100 ovf = nr&3; 101 for (i = 0 ; i < ovf ; i++) 102 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 103 return i; 104 case GL_LINE_STRIP: 105 if (nr == 0) { 106 return 0; 107 } 108 else { 109 memcpy( dst, src+(nr-1)*sz, sz * sizeof(GLfloat) ); 110 return 1; 111 } 112 case GL_LINE_LOOP: 113 case GL_TRIANGLE_FAN: 114 case GL_POLYGON: 115 if (nr == 0) { 116 return 0; 117 } 118 else if (nr == 1) { 119 memcpy( dst, src+0, sz * sizeof(GLfloat) ); 120 return 1; 121 } 122 else { 123 memcpy( dst, src+0, sz * sizeof(GLfloat) ); 124 memcpy( dst+sz, src+(nr-1)*sz, sz * sizeof(GLfloat) ); 125 return 2; 126 } 127 case GL_TRIANGLE_STRIP: 128 /* no parity issue, but need to make sure the tri is not drawn twice */ 129 if (nr & 1) { 130 exec->vtx.prim[exec->vtx.prim_count-1].count--; 131 } 132 /* fallthrough */ 133 case GL_QUAD_STRIP: 134 switch (nr) { 135 case 0: 136 ovf = 0; 137 break; 138 case 1: 139 ovf = 1; 140 break; 141 default: 142 ovf = 2 + (nr & 1); 143 break; 144 } 145 for (i = 0 ; i < ovf ; i++) 146 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 147 return i; 148 case PRIM_OUTSIDE_BEGIN_END: 149 return 0; 150 default: 151 assert(0); 152 return 0; 153 } 154} 155 156 157 158/* TODO: populate these as the vertex is defined: 159 */ 160static void 161vbo_exec_bind_arrays( struct gl_context *ctx ) 162{ 163 struct vbo_context *vbo = vbo_context(ctx); 164 struct vbo_exec_context *exec = &vbo->exec; 165 struct gl_client_array *arrays = exec->vtx.arrays; 166 const GLuint count = exec->vtx.vert_count; 167 const GLuint *map; 168 GLuint attr; 169 GLbitfield64 varying_inputs = 0x0; 170 171 /* Install the default (ie Current) attributes first, then overlay 172 * all active ones. 173 */ 174 switch (get_program_mode(exec->ctx)) { 175 case VP_NONE: 176 for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) { 177 exec->vtx.inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr]; 178 } 179 for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) { 180 ASSERT(VERT_ATTRIB_GENERIC(attr) < Elements(exec->vtx.inputs)); 181 exec->vtx.inputs[VERT_ATTRIB_GENERIC(attr)] = 182 &vbo->currval[VBO_ATTRIB_MAT_FRONT_AMBIENT+attr]; 183 } 184 map = vbo->map_vp_none; 185 break; 186 case VP_NV: 187 case VP_ARB: 188 /* The aliasing of attributes for NV vertex programs has already 189 * occurred. NV vertex programs cannot access material values, 190 * nor attributes greater than VERT_ATTRIB_TEX7. 191 */ 192 for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) { 193 exec->vtx.inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr]; 194 } 195 for (attr = 0; attr < VERT_ATTRIB_GENERIC_MAX; attr++) { 196 ASSERT(VERT_ATTRIB_GENERIC(attr) < Elements(exec->vtx.inputs)); 197 exec->vtx.inputs[VERT_ATTRIB_GENERIC(attr)] = 198 &vbo->currval[VBO_ATTRIB_GENERIC0+attr]; 199 } 200 map = vbo->map_vp_arb; 201 202 /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read. 203 * In that case we effectively need to route the data from 204 * glVertexAttrib(0, val) calls to feed into the GENERIC0 input. 205 */ 206 if ((ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_POS) == 0 && 207 (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_GENERIC0)) { 208 exec->vtx.inputs[VERT_ATTRIB_GENERIC0] = exec->vtx.inputs[0]; 209 exec->vtx.attrsz[VERT_ATTRIB_GENERIC0] = exec->vtx.attrsz[0]; 210 exec->vtx.attrptr[VERT_ATTRIB_GENERIC0] = exec->vtx.attrptr[0]; 211 exec->vtx.attrsz[0] = 0; 212 } 213 break; 214 default: 215 assert(0); 216 } 217 218 /* Make all active attributes (including edgeflag) available as 219 * arrays of floats. 220 */ 221 for (attr = 0; attr < VERT_ATTRIB_MAX ; attr++) { 222 const GLuint src = map[attr]; 223 224 if (exec->vtx.attrsz[src]) { 225 GLsizeiptr offset = (GLbyte *)exec->vtx.attrptr[src] - 226 (GLbyte *)exec->vtx.vertex; 227 228 /* override the default array set above */ 229 ASSERT(attr < Elements(exec->vtx.inputs)); 230 ASSERT(attr < Elements(exec->vtx.arrays)); /* arrays[] */ 231 exec->vtx.inputs[attr] = &arrays[attr]; 232 233 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 234 /* a real buffer obj: Ptr is an offset, not a pointer*/ 235 assert(exec->vtx.bufferobj->Pointer); /* buf should be mapped */ 236 assert(offset >= 0); 237 arrays[attr].Ptr = (GLubyte *)exec->vtx.bufferobj->Offset + offset; 238 } 239 else { 240 /* Ptr into ordinary app memory */ 241 arrays[attr].Ptr = (GLubyte *)exec->vtx.buffer_map + offset; 242 } 243 arrays[attr].Size = exec->vtx.attrsz[src]; 244 arrays[attr].StrideB = exec->vtx.vertex_size * sizeof(GLfloat); 245 arrays[attr].Stride = exec->vtx.vertex_size * sizeof(GLfloat); 246 arrays[attr].Type = GL_FLOAT; 247 arrays[attr].Format = GL_RGBA; 248 arrays[attr].Enabled = 1; 249 arrays[attr]._ElementSize = arrays[attr].Size * sizeof(GLfloat); 250 _mesa_reference_buffer_object(ctx, 251 &arrays[attr].BufferObj, 252 exec->vtx.bufferobj); 253 arrays[attr]._MaxElement = count; /* ??? */ 254 255 varying_inputs |= VERT_BIT(attr); 256 ctx->NewState |= _NEW_ARRAY; 257 } 258 } 259 260 _mesa_set_varying_vp_inputs( ctx, varying_inputs ); 261} 262 263 264/** 265 * Unmap the VBO. This is called before drawing. 266 */ 267static void 268vbo_exec_vtx_unmap( struct vbo_exec_context *exec ) 269{ 270 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 271 struct gl_context *ctx = exec->ctx; 272 273 if (ctx->Driver.FlushMappedBufferRange) { 274 GLintptr offset = exec->vtx.buffer_used - exec->vtx.bufferobj->Offset; 275 GLsizeiptr length = (exec->vtx.buffer_ptr - exec->vtx.buffer_map) * sizeof(float); 276 277 if (length) 278 ctx->Driver.FlushMappedBufferRange(ctx, offset, length, 279 exec->vtx.bufferobj); 280 } 281 282 exec->vtx.buffer_used += (exec->vtx.buffer_ptr - 283 exec->vtx.buffer_map) * sizeof(float); 284 285 assert(exec->vtx.buffer_used <= VBO_VERT_BUFFER_SIZE); 286 assert(exec->vtx.buffer_ptr != NULL); 287 288 ctx->Driver.UnmapBuffer(ctx, exec->vtx.bufferobj); 289 exec->vtx.buffer_map = NULL; 290 exec->vtx.buffer_ptr = NULL; 291 exec->vtx.max_vert = 0; 292 } 293} 294 295 296/** 297 * Map the vertex buffer to begin storing glVertex, glColor, etc data. 298 */ 299void 300vbo_exec_vtx_map( struct vbo_exec_context *exec ) 301{ 302 struct gl_context *ctx = exec->ctx; 303 const GLenum accessRange = GL_MAP_WRITE_BIT | /* for MapBufferRange */ 304 GL_MAP_INVALIDATE_RANGE_BIT | 305 GL_MAP_UNSYNCHRONIZED_BIT | 306 GL_MAP_FLUSH_EXPLICIT_BIT | 307 MESA_MAP_NOWAIT_BIT; 308 const GLenum usage = GL_STREAM_DRAW_ARB; 309 310 if (!_mesa_is_bufferobj(exec->vtx.bufferobj)) 311 return; 312 313 assert(!exec->vtx.buffer_map); 314 assert(!exec->vtx.buffer_ptr); 315 316 if (VBO_VERT_BUFFER_SIZE > exec->vtx.buffer_used + 1024) { 317 /* The VBO exists and there's room for more */ 318 if (exec->vtx.bufferobj->Size > 0) { 319 exec->vtx.buffer_map = 320 (GLfloat *)ctx->Driver.MapBufferRange(ctx, 321 exec->vtx.buffer_used, 322 (VBO_VERT_BUFFER_SIZE - 323 exec->vtx.buffer_used), 324 accessRange, 325 exec->vtx.bufferobj); 326 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 327 } 328 else { 329 exec->vtx.buffer_ptr = exec->vtx.buffer_map = NULL; 330 } 331 } 332 333 if (!exec->vtx.buffer_map) { 334 /* Need to allocate a new VBO */ 335 exec->vtx.buffer_used = 0; 336 337 if (ctx->Driver.BufferData(ctx, GL_ARRAY_BUFFER_ARB, 338 VBO_VERT_BUFFER_SIZE, 339 NULL, usage, exec->vtx.bufferobj)) { 340 /* buffer allocation worked, now map the buffer */ 341 exec->vtx.buffer_map = 342 (GLfloat *)ctx->Driver.MapBufferRange(ctx, 343 0, VBO_VERT_BUFFER_SIZE, 344 accessRange, 345 exec->vtx.bufferobj); 346 } 347 else { 348 _mesa_error(ctx, GL_OUT_OF_MEMORY, "VBO allocation"); 349 exec->vtx.buffer_map = NULL; 350 } 351 } 352 353 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 354 355 if (!exec->vtx.buffer_map) { 356 /* out of memory */ 357 _mesa_install_exec_vtxfmt( ctx, &exec->vtxfmt_noop ); 358 } 359 else { 360 if (_mesa_using_noop_vtxfmt(ctx->Exec)) { 361 /* The no-op functions are installed so switch back to regular 362 * functions. We do this test just to avoid frequent and needless 363 * calls to _mesa_install_exec_vtxfmt(). 364 */ 365 _mesa_install_exec_vtxfmt(ctx, &exec->vtxfmt); 366 } 367 } 368 369 if (0) 370 printf("map %d..\n", exec->vtx.buffer_used); 371} 372 373 374 375/** 376 * Execute the buffer and save copied verts. 377 * \param keep_unmapped if true, leave the VBO unmapped when we're done. 378 */ 379void 380vbo_exec_vtx_flush(struct vbo_exec_context *exec, GLboolean keepUnmapped) 381{ 382 if (0) 383 vbo_exec_debug_verts( exec ); 384 385 if (exec->vtx.prim_count && 386 exec->vtx.vert_count) { 387 388 exec->vtx.copied.nr = vbo_copy_vertices( exec ); 389 390 if (exec->vtx.copied.nr != exec->vtx.vert_count) { 391 struct gl_context *ctx = exec->ctx; 392 393 /* Before the update_state() as this may raise _NEW_VARYING_VP_INPUTS 394 * from _mesa_set_varying_vp_inputs(). 395 */ 396 vbo_exec_bind_arrays( ctx ); 397 398 if (ctx->NewState) 399 _mesa_update_state( ctx ); 400 401 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 402 vbo_exec_vtx_unmap( exec ); 403 } 404 405 if (0) 406 printf("%s %d %d\n", __FUNCTION__, exec->vtx.prim_count, 407 exec->vtx.vert_count); 408 409 vbo_context(ctx)->draw_prims( ctx, 410 exec->vtx.inputs, 411 exec->vtx.prim, 412 exec->vtx.prim_count, 413 NULL, 414 GL_TRUE, 415 0, 416 exec->vtx.vert_count - 1, 417 NULL); 418 419 /* If using a real VBO, get new storage -- unless asked not to. 420 */ 421 if (_mesa_is_bufferobj(exec->vtx.bufferobj) && !keepUnmapped) { 422 vbo_exec_vtx_map( exec ); 423 } 424 } 425 } 426 427 /* May have to unmap explicitly if we didn't draw: 428 */ 429 if (keepUnmapped && 430 _mesa_is_bufferobj(exec->vtx.bufferobj) && 431 exec->vtx.buffer_map) { 432 vbo_exec_vtx_unmap( exec ); 433 } 434 435 if (keepUnmapped || exec->vtx.vertex_size == 0) 436 exec->vtx.max_vert = 0; 437 else 438 exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) / 439 (exec->vtx.vertex_size * sizeof(GLfloat))); 440 441 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 442 exec->vtx.prim_count = 0; 443 exec->vtx.vert_count = 0; 444} 445 446 447#endif /* FEATURE_beginend */ 448