vbo_exec_draw.c revision a69fc5129bdf2f245c5bf2e0fe7b542caf7809a9
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/context.h" 31#include "main/enums.h" 32#include "main/state.h" 33#include "main/macros.h" 34 35#include "vbo_context.h" 36 37 38static void vbo_exec_debug_verts( struct vbo_exec_context *exec ) 39{ 40 GLuint count = exec->vtx.vert_count; 41 GLuint i; 42 43 _mesa_printf("%s: %u vertices %d primitives, %d vertsize\n", 44 __FUNCTION__, 45 count, 46 exec->vtx.prim_count, 47 exec->vtx.vertex_size); 48 49 for (i = 0 ; i < exec->vtx.prim_count ; i++) { 50 struct _mesa_prim *prim = &exec->vtx.prim[i]; 51 _mesa_printf(" prim %d: %s%s %d..%d %s %s\n", 52 i, 53 _mesa_lookup_enum_by_nr(prim->mode), 54 prim->weak ? " (weak)" : "", 55 prim->start, 56 prim->start + prim->count, 57 prim->begin ? "BEGIN" : "(wrap)", 58 prim->end ? "END" : "(wrap)"); 59 } 60} 61 62 63/* 64 * NOTE: Need to have calculated primitives by this point -- do it on the fly. 65 * NOTE: Old 'parity' issue is gone. 66 */ 67static GLuint vbo_copy_vertices( struct vbo_exec_context *exec ) 68{ 69 GLuint nr = exec->vtx.prim[exec->vtx.prim_count-1].count; 70 GLuint ovf, i; 71 GLuint sz = exec->vtx.vertex_size; 72 GLfloat *dst = exec->vtx.copied.buffer; 73 GLfloat *src = ((GLfloat *)exec->vtx.buffer_map + 74 exec->vtx.prim[exec->vtx.prim_count-1].start * 75 exec->vtx.vertex_size); 76 77 78 switch( exec->ctx->Driver.CurrentExecPrimitive ) 79 { 80 case GL_POINTS: 81 return 0; 82 case GL_LINES: 83 ovf = nr&1; 84 for (i = 0 ; i < ovf ; i++) 85 _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 86 return i; 87 case GL_TRIANGLES: 88 ovf = nr%3; 89 for (i = 0 ; i < ovf ; i++) 90 _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 91 return i; 92 case GL_QUADS: 93 ovf = nr&3; 94 for (i = 0 ; i < ovf ; i++) 95 _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 96 return i; 97 case GL_LINE_STRIP: 98 if (nr == 0) 99 return 0; 100 else { 101 _mesa_memcpy( dst, src+(nr-1)*sz, sz * sizeof(GLfloat) ); 102 return 1; 103 } 104 case GL_LINE_LOOP: 105 case GL_TRIANGLE_FAN: 106 case GL_POLYGON: 107 if (nr == 0) 108 return 0; 109 else if (nr == 1) { 110 _mesa_memcpy( dst, src+0, sz * sizeof(GLfloat) ); 111 return 1; 112 } else { 113 _mesa_memcpy( dst, src+0, sz * sizeof(GLfloat) ); 114 _mesa_memcpy( dst+sz, src+(nr-1)*sz, sz * sizeof(GLfloat) ); 115 return 2; 116 } 117 case GL_TRIANGLE_STRIP: 118 /* no parity issue, but need to make sure the tri is not drawn twice */ 119 if (nr & 1) { 120 exec->vtx.prim[exec->vtx.prim_count-1].count--; 121 } 122 /* fallthrough */ 123 case GL_QUAD_STRIP: 124 switch (nr) { 125 case 0: ovf = 0; break; 126 case 1: ovf = 1; break; 127 default: ovf = 2 + (nr&1); break; 128 } 129 for (i = 0 ; i < ovf ; i++) 130 _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); 131 return i; 132 case PRIM_OUTSIDE_BEGIN_END: 133 return 0; 134 default: 135 assert(0); 136 return 0; 137 } 138} 139 140 141 142/* TODO: populate these as the vertex is defined: 143 */ 144static void vbo_exec_bind_arrays( GLcontext *ctx ) 145{ 146 struct vbo_context *vbo = vbo_context(ctx); 147 struct vbo_exec_context *exec = &vbo->exec; 148 struct gl_client_array *arrays = exec->vtx.arrays; 149 GLuint count = exec->vtx.vert_count; 150 GLubyte *data = exec->vtx.buffer_map; 151 const GLuint *map; 152 GLuint attr; 153 154 /* Install the default (ie Current) attributes first, then overlay 155 * all active ones. 156 */ 157 switch (get_program_mode(exec->ctx)) { 158 case VP_NONE: 159 for (attr = 0; attr < 16; attr++) { 160 exec->vtx.inputs[attr] = &vbo->legacy_currval[attr]; 161 } 162 for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) { 163 exec->vtx.inputs[attr + 16] = &vbo->mat_currval[attr]; 164 } 165 map = vbo->map_vp_none; 166 break; 167 case VP_NV: 168 case VP_ARB: 169 /* The aliasing of attributes for NV vertex programs has already 170 * occurred. NV vertex programs cannot access material values, 171 * nor attributes greater than VERT_ATTRIB_TEX7. 172 */ 173 for (attr = 0; attr < 16; attr++) { 174 exec->vtx.inputs[attr] = &vbo->legacy_currval[attr]; 175 exec->vtx.inputs[attr + 16] = &vbo->generic_currval[attr]; 176 } 177 map = vbo->map_vp_arb; 178 break; 179 } 180 181 /* Make all active attributes (including edgeflag) available as 182 * arrays of floats. 183 */ 184 for (attr = 0; attr < VERT_ATTRIB_MAX ; attr++) { 185 const GLuint src = map[attr]; 186 187 if (exec->vtx.attrsz[src]) { 188 /* override the default array set above */ 189 exec->vtx.inputs[attr] = &arrays[attr]; 190 191 if (exec->vtx.bufferobj->Name) { 192 /* a real buffer obj: Ptr is an offset, not a pointer*/ 193 int offset; 194 assert(exec->vtx.bufferobj->Pointer); /* buf should be mapped */ 195 offset = (GLbyte *) data - (GLbyte *) exec->vtx.bufferobj->Pointer; 196 assert(offset >= 0); 197 arrays[attr].Ptr = (void *) offset; 198 } 199 else { 200 /* Ptr into ordinary app memory */ 201 arrays[attr].Ptr = (void *) data; 202 } 203 arrays[attr].Size = exec->vtx.attrsz[src]; 204 arrays[attr].StrideB = exec->vtx.vertex_size * sizeof(GLfloat); 205 arrays[attr].Stride = exec->vtx.vertex_size * sizeof(GLfloat); 206 arrays[attr].Type = GL_FLOAT; 207 arrays[attr].Enabled = 1; 208 _mesa_reference_buffer_object(ctx, 209 &arrays[attr].BufferObj, 210 exec->vtx.bufferobj); 211 arrays[attr]._MaxElement = count; /* ??? */ 212 213 data += exec->vtx.attrsz[src] * sizeof(GLfloat); 214 } 215 } 216} 217 218 219/** 220 * Execute the buffer and save copied verts. 221 */ 222void vbo_exec_vtx_flush( struct vbo_exec_context *exec ) 223{ 224 if (0) 225 vbo_exec_debug_verts( exec ); 226 227 228 if (exec->vtx.prim_count && 229 exec->vtx.vert_count) { 230 231 exec->vtx.copied.nr = vbo_copy_vertices( exec ); 232 233 if (exec->vtx.copied.nr != exec->vtx.vert_count) { 234 GLcontext *ctx = exec->ctx; 235 236 GLenum target = GL_ARRAY_BUFFER_ARB; 237 GLenum access = GL_READ_WRITE_ARB; 238 GLenum usage = GL_STREAM_DRAW_ARB; 239 GLsizei size = VBO_VERT_BUFFER_SIZE * sizeof(GLfloat); 240 241 /* Before the unmap (why?) 242 */ 243 vbo_exec_bind_arrays( ctx ); 244 245 ctx->Driver.UnmapBuffer(ctx, target, exec->vtx.bufferobj); 246 exec->vtx.buffer_map = NULL; 247 248 vbo_context(ctx)->draw_prims( ctx, 249 exec->vtx.inputs, 250 exec->vtx.prim, 251 exec->vtx.prim_count, 252 NULL, 253 0, 254 exec->vtx.vert_count - 1); 255 256 /* Get new data: 257 */ 258 ctx->Driver.BufferData(ctx, target, size, NULL, usage, exec->vtx.bufferobj); 259 exec->vtx.buffer_map 260 = ctx->Driver.MapBuffer(ctx, target, access, exec->vtx.bufferobj); 261 } 262 } 263 264 exec->vtx.prim_count = 0; 265 exec->vtx.vert_count = 0; 266 exec->vtx.vbptr = (GLfloat *)exec->vtx.buffer_map; 267} 268