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 (at) 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 44 static void 45 vbo_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 */ 74 static GLuint 75 vbo_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 */ 160 static void 161 vbo_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 for (attr = 0; attr < VERT_ATTRIB_MAX ; attr++) { 219 const GLuint src = map[attr]; 220 221 if (exec->vtx.attrsz[src]) { 222 GLsizeiptr offset = (GLbyte *)exec->vtx.attrptr[src] - 223 (GLbyte *)exec->vtx.vertex; 224 225 /* override the default array set above */ 226 ASSERT(attr < Elements(exec->vtx.inputs)); 227 ASSERT(attr < Elements(exec->vtx.arrays)); /* arrays[] */ 228 exec->vtx.inputs[attr] = &arrays[attr]; 229 230 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 231 /* a real buffer obj: Ptr is an offset, not a pointer*/ 232 assert(exec->vtx.bufferobj->Pointer); /* buf should be mapped */ 233 assert(offset >= 0); 234 arrays[attr].Ptr = (GLubyte *)exec->vtx.bufferobj->Offset + offset; 235 } 236 else { 237 /* Ptr into ordinary app memory */ 238 arrays[attr].Ptr = (GLubyte *)exec->vtx.buffer_map + offset; 239 } 240 arrays[attr].Size = exec->vtx.attrsz[src]; 241 arrays[attr].StrideB = exec->vtx.vertex_size * sizeof(GLfloat); 242 arrays[attr].Stride = exec->vtx.vertex_size * sizeof(GLfloat); 243 arrays[attr].Type = exec->vtx.attrtype[src]; 244 arrays[attr].Integer = 245 vbo_attrtype_to_integer_flag(exec->vtx.attrtype[src]); 246 arrays[attr].Format = GL_RGBA; 247 arrays[attr].Enabled = 1; 248 arrays[attr]._ElementSize = arrays[attr].Size * sizeof(GLfloat); 249 _mesa_reference_buffer_object(ctx, 250 &arrays[attr].BufferObj, 251 exec->vtx.bufferobj); 252 arrays[attr]._MaxElement = count; /* ??? */ 253 254 varying_inputs |= VERT_BIT(attr); 255 } 256 } 257 258 _mesa_set_varying_vp_inputs( ctx, varying_inputs ); 259 ctx->NewDriverState |= ctx->DriverFlags.NewArray; 260 } 261 262 263 /** 264 * Unmap the VBO. This is called before drawing. 265 */ 266 static void 267 vbo_exec_vtx_unmap( struct vbo_exec_context *exec ) 268 { 269 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 270 struct gl_context *ctx = exec->ctx; 271 272 if (ctx->Driver.FlushMappedBufferRange) { 273 GLintptr offset = exec->vtx.buffer_used - exec->vtx.bufferobj->Offset; 274 GLsizeiptr length = (exec->vtx.buffer_ptr - exec->vtx.buffer_map) * sizeof(float); 275 276 if (length) 277 ctx->Driver.FlushMappedBufferRange(ctx, offset, length, 278 exec->vtx.bufferobj); 279 } 280 281 exec->vtx.buffer_used += (exec->vtx.buffer_ptr - 282 exec->vtx.buffer_map) * sizeof(float); 283 284 assert(exec->vtx.buffer_used <= VBO_VERT_BUFFER_SIZE); 285 assert(exec->vtx.buffer_ptr != NULL); 286 287 ctx->Driver.UnmapBuffer(ctx, exec->vtx.bufferobj); 288 exec->vtx.buffer_map = NULL; 289 exec->vtx.buffer_ptr = NULL; 290 exec->vtx.max_vert = 0; 291 } 292 } 293 294 295 /** 296 * Map the vertex buffer to begin storing glVertex, glColor, etc data. 297 */ 298 void 299 vbo_exec_vtx_map( struct vbo_exec_context *exec ) 300 { 301 struct gl_context *ctx = exec->ctx; 302 const GLenum accessRange = GL_MAP_WRITE_BIT | /* for MapBufferRange */ 303 GL_MAP_INVALIDATE_RANGE_BIT | 304 GL_MAP_UNSYNCHRONIZED_BIT | 305 GL_MAP_FLUSH_EXPLICIT_BIT | 306 MESA_MAP_NOWAIT_BIT; 307 const GLenum usage = GL_STREAM_DRAW_ARB; 308 309 if (!_mesa_is_bufferobj(exec->vtx.bufferobj)) 310 return; 311 312 assert(!exec->vtx.buffer_map); 313 assert(!exec->vtx.buffer_ptr); 314 315 if (VBO_VERT_BUFFER_SIZE > exec->vtx.buffer_used + 1024) { 316 /* The VBO exists and there's room for more */ 317 if (exec->vtx.bufferobj->Size > 0) { 318 exec->vtx.buffer_map = 319 (GLfloat *)ctx->Driver.MapBufferRange(ctx, 320 exec->vtx.buffer_used, 321 (VBO_VERT_BUFFER_SIZE - 322 exec->vtx.buffer_used), 323 accessRange, 324 exec->vtx.bufferobj); 325 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 326 } 327 else { 328 exec->vtx.buffer_ptr = exec->vtx.buffer_map = NULL; 329 } 330 } 331 332 if (!exec->vtx.buffer_map) { 333 /* Need to allocate a new VBO */ 334 exec->vtx.buffer_used = 0; 335 336 if (ctx->Driver.BufferData(ctx, GL_ARRAY_BUFFER_ARB, 337 VBO_VERT_BUFFER_SIZE, 338 NULL, usage, exec->vtx.bufferobj)) { 339 /* buffer allocation worked, now map the buffer */ 340 exec->vtx.buffer_map = 341 (GLfloat *)ctx->Driver.MapBufferRange(ctx, 342 0, VBO_VERT_BUFFER_SIZE, 343 accessRange, 344 exec->vtx.bufferobj); 345 } 346 else { 347 _mesa_error(ctx, GL_OUT_OF_MEMORY, "VBO allocation"); 348 exec->vtx.buffer_map = NULL; 349 } 350 } 351 352 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 353 354 if (!exec->vtx.buffer_map) { 355 /* out of memory */ 356 _mesa_install_exec_vtxfmt( ctx, &exec->vtxfmt_noop ); 357 } 358 else { 359 if (_mesa_using_noop_vtxfmt(ctx->Exec)) { 360 /* The no-op functions are installed so switch back to regular 361 * functions. We do this test just to avoid frequent and needless 362 * calls to _mesa_install_exec_vtxfmt(). 363 */ 364 _mesa_install_exec_vtxfmt(ctx, &exec->vtxfmt); 365 } 366 } 367 368 if (0) 369 printf("map %d..\n", exec->vtx.buffer_used); 370 } 371 372 373 374 /** 375 * Execute the buffer and save copied verts. 376 * \param keep_unmapped if true, leave the VBO unmapped when we're done. 377 */ 378 void 379 vbo_exec_vtx_flush(struct vbo_exec_context *exec, GLboolean keepUnmapped) 380 { 381 if (0) 382 vbo_exec_debug_verts( exec ); 383 384 if (exec->vtx.prim_count && 385 exec->vtx.vert_count) { 386 387 exec->vtx.copied.nr = vbo_copy_vertices( exec ); 388 389 if (exec->vtx.copied.nr != exec->vtx.vert_count) { 390 struct gl_context *ctx = exec->ctx; 391 392 /* Before the update_state() as this may raise _NEW_VARYING_VP_INPUTS 393 * from _mesa_set_varying_vp_inputs(). 394 */ 395 vbo_exec_bind_arrays( ctx ); 396 397 if (ctx->NewState) 398 _mesa_update_state( ctx ); 399 400 if (_mesa_is_bufferobj(exec->vtx.bufferobj)) { 401 vbo_exec_vtx_unmap( exec ); 402 } 403 404 if (0) 405 printf("%s %d %d\n", __FUNCTION__, exec->vtx.prim_count, 406 exec->vtx.vert_count); 407 408 vbo_context(ctx)->draw_prims( ctx, 409 exec->vtx.prim, 410 exec->vtx.prim_count, 411 NULL, 412 GL_TRUE, 413 0, 414 exec->vtx.vert_count - 1, 415 NULL); 416 417 /* If using a real VBO, get new storage -- unless asked not to. 418 */ 419 if (_mesa_is_bufferobj(exec->vtx.bufferobj) && !keepUnmapped) { 420 vbo_exec_vtx_map( exec ); 421 } 422 } 423 } 424 425 /* May have to unmap explicitly if we didn't draw: 426 */ 427 if (keepUnmapped && 428 _mesa_is_bufferobj(exec->vtx.bufferobj) && 429 exec->vtx.buffer_map) { 430 vbo_exec_vtx_unmap( exec ); 431 } 432 433 if (keepUnmapped || exec->vtx.vertex_size == 0) 434 exec->vtx.max_vert = 0; 435 else 436 exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) / 437 (exec->vtx.vertex_size * sizeof(GLfloat))); 438 439 exec->vtx.buffer_ptr = exec->vtx.buffer_map; 440 exec->vtx.prim_count = 0; 441 exec->vtx.vert_count = 0; 442 } 443 444 445 #endif /* FEATURE_beginend */ 446
