1/* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included 14 * in all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25/* Author: 26 * Keith Whitwell <keithw@vmware.com> 27 */ 28 29#include "main/glheader.h" 30#include "main/bufferobj.h" 31#include "main/context.h" 32#include "main/imports.h" 33#include "main/mtypes.h" 34#include "main/macros.h" 35#include "main/light.h" 36#include "main/state.h" 37#include "util/bitscan.h" 38 39#include "vbo_context.h" 40 41 42/** 43 * After playback, copy everything but the position from the 44 * last vertex to the saved state 45 */ 46static void 47_playback_copy_to_current(struct gl_context *ctx, 48 const struct vbo_save_vertex_list *node) 49{ 50 struct vbo_context *vbo = vbo_context(ctx); 51 fi_type vertex[VBO_ATTRIB_MAX * 4]; 52 fi_type *data; 53 GLbitfield64 mask; 54 GLuint offset; 55 56 if (node->current_size == 0) 57 return; 58 59 if (node->current_data) { 60 data = node->current_data; 61 } 62 else { 63 data = vertex; 64 65 if (node->count) 66 offset = (node->buffer_offset + 67 (node->count-1) * node->vertex_size * sizeof(GLfloat)); 68 else 69 offset = node->buffer_offset; 70 71 ctx->Driver.GetBufferSubData( ctx, offset, 72 node->vertex_size * sizeof(GLfloat), 73 data, node->vertex_store->bufferobj ); 74 75 data += node->attrsz[0]; /* skip vertex position */ 76 } 77 78 mask = node->enabled & (~BITFIELD64_BIT(VBO_ATTRIB_POS)); 79 while (mask) { 80 const int i = u_bit_scan64(&mask); 81 fi_type *current = (fi_type *)vbo->currval[i].Ptr; 82 fi_type tmp[4]; 83 assert(node->attrsz[i]); 84 85 COPY_CLEAN_4V_TYPE_AS_UNION(tmp, 86 node->attrsz[i], 87 data, 88 node->attrtype[i]); 89 90 if (node->attrtype[i] != vbo->currval[i].Type || 91 memcmp(current, tmp, 4 * sizeof(GLfloat)) != 0) { 92 memcpy(current, tmp, 4 * sizeof(GLfloat)); 93 94 vbo->currval[i].Size = node->attrsz[i]; 95 vbo->currval[i]._ElementSize = vbo->currval[i].Size * sizeof(GLfloat); 96 vbo->currval[i].Type = node->attrtype[i]; 97 vbo->currval[i].Integer = 98 vbo_attrtype_to_integer_flag(node->attrtype[i]); 99 100 if (i >= VBO_ATTRIB_FIRST_MATERIAL && 101 i <= VBO_ATTRIB_LAST_MATERIAL) 102 ctx->NewState |= _NEW_LIGHT; 103 104 ctx->NewState |= _NEW_CURRENT_ATTRIB; 105 } 106 107 data += node->attrsz[i]; 108 } 109 110 /* Colormaterial -- this kindof sucks. 111 */ 112 if (ctx->Light.ColorMaterialEnabled) { 113 _mesa_update_color_material(ctx, ctx->Current.Attrib[VBO_ATTRIB_COLOR0]); 114 } 115 116 /* CurrentExecPrimitive 117 */ 118 if (node->prim_count) { 119 const struct _mesa_prim *prim = &node->prim[node->prim_count - 1]; 120 if (prim->end) 121 ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END; 122 else 123 ctx->Driver.CurrentExecPrimitive = prim->mode; 124 } 125} 126 127 128 129/** 130 * Treat the vertex storage as a VBO, define vertex arrays pointing 131 * into it: 132 */ 133static void vbo_bind_vertex_list(struct gl_context *ctx, 134 const struct vbo_save_vertex_list *node) 135{ 136 struct vbo_context *vbo = vbo_context(ctx); 137 struct vbo_save_context *save = &vbo->save; 138 struct gl_vertex_array *arrays = save->arrays; 139 GLuint buffer_offset = node->buffer_offset; 140 const GLuint *map; 141 GLuint attr; 142 GLubyte node_attrsz[VBO_ATTRIB_MAX]; /* copy of node->attrsz[] */ 143 GLenum node_attrtype[VBO_ATTRIB_MAX]; /* copy of node->attrtype[] */ 144 GLbitfield64 varying_inputs = 0x0; 145 146 memcpy(node_attrsz, node->attrsz, sizeof(node->attrsz)); 147 memcpy(node_attrtype, node->attrtype, sizeof(node->attrtype)); 148 149 /* Install the default (ie Current) attributes first, then overlay 150 * all active ones. 151 */ 152 switch (get_program_mode(ctx)) { 153 case VP_NONE: 154 for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) { 155 save->inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr]; 156 } 157 for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) { 158 save->inputs[VERT_ATTRIB_GENERIC(attr)] = 159 &vbo->currval[VBO_ATTRIB_MAT_FRONT_AMBIENT+attr]; 160 } 161 map = vbo->map_vp_none; 162 break; 163 case VP_ARB: 164 for (attr = 0; attr < VERT_ATTRIB_FF_MAX; attr++) { 165 save->inputs[attr] = &vbo->currval[VBO_ATTRIB_POS+attr]; 166 } 167 for (attr = 0; attr < VERT_ATTRIB_GENERIC_MAX; attr++) { 168 save->inputs[VERT_ATTRIB_GENERIC(attr)] = 169 &vbo->currval[VBO_ATTRIB_GENERIC0+attr]; 170 } 171 map = vbo->map_vp_arb; 172 173 /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read. 174 * In that case we effectively need to route the data from 175 * glVertexAttrib(0, val) calls to feed into the GENERIC0 input. 176 */ 177 if ((ctx->VertexProgram._Current->info.inputs_read & 178 VERT_BIT_POS) == 0 && 179 (ctx->VertexProgram._Current->info.inputs_read & 180 VERT_BIT_GENERIC0)) { 181 save->inputs[VERT_ATTRIB_GENERIC0] = save->inputs[0]; 182 node_attrsz[VERT_ATTRIB_GENERIC0] = node_attrsz[0]; 183 node_attrtype[VERT_ATTRIB_GENERIC0] = node_attrtype[0]; 184 node_attrsz[0] = 0; 185 } 186 break; 187 default: 188 assert(0); 189 } 190 191 for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) { 192 const GLuint src = map[attr]; 193 194 if (node_attrsz[src]) { 195 /* override the default array set above */ 196 save->inputs[attr] = &arrays[attr]; 197 198 arrays[attr].Ptr = (const GLubyte *) NULL + buffer_offset; 199 arrays[attr].Size = node_attrsz[src]; 200 arrays[attr].StrideB = node->vertex_size * sizeof(GLfloat); 201 arrays[attr].Type = node_attrtype[src]; 202 arrays[attr].Integer = 203 vbo_attrtype_to_integer_flag(node_attrtype[src]); 204 arrays[attr].Format = GL_RGBA; 205 arrays[attr]._ElementSize = arrays[attr].Size * sizeof(GLfloat); 206 _mesa_reference_buffer_object(ctx, 207 &arrays[attr].BufferObj, 208 node->vertex_store->bufferobj); 209 210 assert(arrays[attr].BufferObj->Name); 211 212 buffer_offset += node_attrsz[src] * sizeof(GLfloat); 213 varying_inputs |= VERT_BIT(attr); 214 } 215 } 216 217 _mesa_set_varying_vp_inputs( ctx, varying_inputs ); 218 ctx->NewDriverState |= ctx->DriverFlags.NewArray; 219} 220 221 222static void 223vbo_save_loopback_vertex_list(struct gl_context *ctx, 224 const struct vbo_save_vertex_list *list) 225{ 226 const char *buffer = 227 ctx->Driver.MapBufferRange(ctx, 0, 228 list->vertex_store->bufferobj->Size, 229 GL_MAP_READ_BIT, /* ? */ 230 list->vertex_store->bufferobj, 231 MAP_INTERNAL); 232 233 vbo_loopback_vertex_list(ctx, 234 (const GLfloat *)(buffer + list->buffer_offset), 235 list->attrsz, 236 list->prim, 237 list->prim_count, 238 list->wrap_count, 239 list->vertex_size); 240 241 ctx->Driver.UnmapBuffer(ctx, list->vertex_store->bufferobj, 242 MAP_INTERNAL); 243} 244 245 246/** 247 * Execute the buffer and save copied verts. 248 * This is called from the display list code when executing 249 * a drawing command. 250 */ 251void 252vbo_save_playback_vertex_list(struct gl_context *ctx, void *data) 253{ 254 const struct vbo_save_vertex_list *node = 255 (const struct vbo_save_vertex_list *) data; 256 struct vbo_save_context *save = &vbo_context(ctx)->save; 257 GLboolean remap_vertex_store = GL_FALSE; 258 259 if (save->vertex_store && save->vertex_store->buffer) { 260 /* The vertex store is currently mapped but we're about to replay 261 * a display list. This can happen when a nested display list is 262 * being build with GL_COMPILE_AND_EXECUTE. 263 * We never want to have mapped vertex buffers when we're drawing. 264 * Unmap the vertex store, execute the list, then remap the vertex 265 * store. 266 */ 267 vbo_save_unmap_vertex_store(ctx, save->vertex_store); 268 remap_vertex_store = GL_TRUE; 269 } 270 271 FLUSH_CURRENT(ctx, 0); 272 273 if (node->prim_count > 0) { 274 275 if (_mesa_inside_begin_end(ctx) && node->prim[0].begin) { 276 /* Error: we're about to begin a new primitive but we're already 277 * inside a glBegin/End pair. 278 */ 279 _mesa_error(ctx, GL_INVALID_OPERATION, 280 "draw operation inside glBegin/End"); 281 goto end; 282 } 283 else if (save->replay_flags) { 284 /* Various degenerate cases: translate into immediate mode 285 * calls rather than trying to execute in place. 286 */ 287 vbo_save_loopback_vertex_list( ctx, node ); 288 289 goto end; 290 } 291 292 if (ctx->NewState) 293 _mesa_update_state( ctx ); 294 295 /* XXX also need to check if shader enabled, but invalid */ 296 if ((ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) || 297 (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled)) { 298 _mesa_error(ctx, GL_INVALID_OPERATION, 299 "glBegin (invalid vertex/fragment program)"); 300 return; 301 } 302 303 vbo_bind_vertex_list( ctx, node ); 304 305 vbo_draw_method(vbo_context(ctx), DRAW_DISPLAY_LIST); 306 307 /* Again... 308 */ 309 if (ctx->NewState) 310 _mesa_update_state( ctx ); 311 312 if (node->count > 0) { 313 vbo_context(ctx)->draw_prims(ctx, 314 node->prim, 315 node->prim_count, 316 NULL, 317 GL_TRUE, 318 0, /* Node is a VBO, so this is ok */ 319 node->count - 1, 320 NULL, 0, NULL); 321 } 322 } 323 324 /* Copy to current? 325 */ 326 _playback_copy_to_current( ctx, node ); 327 328end: 329 if (remap_vertex_store) { 330 save->buffer_ptr = vbo_save_map_vertex_store(ctx, save->vertex_store); 331 } 332} 333