1 /* 2 * Copyright 2002-2005 Jason Edmeades 3 * Copyright 2002-2005 Raphael Junqueira 4 * Copyright 2004 Christian Costa 5 * Copyright 2005 Oliver Stieber 6 * Copyright 2007-2011, 2013-2014 Stefan Dösinger for CodeWeavers 7 * Copyright 2009-2010 Henri Verbeet for CodeWeavers 8 * 9 * This library is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * This library is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 19 * You should have received a copy of the GNU Lesser General Public 20 * License along with this library; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 22 * 23 */ 24 25 #include "config.h" 26 #include "wine/port.h" 27 28 #include "wined3d_private.h" 29 30 WINE_DEFAULT_DEBUG_CHANNEL(d3d); 31 32 #define WINED3D_BUFFER_HASDESC 0x01 /* A vertex description has been found. */ 33 #define WINED3D_BUFFER_USE_BO 0x02 /* Use a buffer object for this buffer. */ 34 #define WINED3D_BUFFER_PIN_SYSMEM 0x04 /* Keep a system memory copy for this buffer. */ 35 #define WINED3D_BUFFER_DISCARD 0x08 /* A DISCARD lock has occurred since the last preload. */ 36 #define WINED3D_BUFFER_APPLESYNC 0x10 /* Using sync as in GL_APPLE_flush_buffer_range. */ 37 38 #define VB_MAXDECLCHANGES 100 /* After that number of decl changes we stop converting */ 39 #define VB_RESETDECLCHANGE 1000 /* Reset the decl changecount after that number of draws */ 40 #define VB_MAXFULLCONVERSIONS 5 /* Number of full conversions before we stop converting */ 41 #define VB_RESETFULLCONVS 20 /* Reset full conversion counts after that number of draws */ 42 43 static void wined3d_buffer_evict_sysmem(struct wined3d_buffer *buffer) 44 { 45 if (buffer->flags & WINED3D_BUFFER_PIN_SYSMEM) 46 { 47 TRACE("Not evicting system memory for buffer %p.\n", buffer); 48 return; 49 } 50 51 TRACE("Evicting system memory for buffer %p.\n", buffer); 52 wined3d_buffer_invalidate_location(buffer, WINED3D_LOCATION_SYSMEM); 53 wined3d_resource_free_sysmem(&buffer->resource); 54 } 55 56 static void buffer_invalidate_bo_range(struct wined3d_buffer *buffer, unsigned int offset, unsigned int size) 57 { 58 if (!offset && (!size || size == buffer->resource.size)) 59 goto invalidate_all; 60 61 if (offset > buffer->resource.size || size > buffer->resource.size - offset) 62 { 63 WARN("Invalid range specified, invalidating entire buffer.\n"); 64 goto invalidate_all; 65 } 66 67 if (!wined3d_array_reserve((void **)&buffer->maps, &buffer->maps_size, 68 buffer->modified_areas + 1, sizeof(*buffer->maps))) 69 { 70 ERR("Failed to allocate maps array, invalidating entire buffer.\n"); 71 goto invalidate_all; 72 } 73 74 buffer->maps[buffer->modified_areas].offset = offset; 75 buffer->maps[buffer->modified_areas].size = size; 76 ++buffer->modified_areas; 77 return; 78 79 invalidate_all: 80 buffer->modified_areas = 1; 81 buffer->maps[0].offset = 0; 82 buffer->maps[0].size = buffer->resource.size; 83 } 84 85 static inline void buffer_clear_dirty_areas(struct wined3d_buffer *This) 86 { 87 This->modified_areas = 0; 88 } 89 90 static BOOL buffer_is_dirty(const struct wined3d_buffer *buffer) 91 { 92 return !!buffer->modified_areas; 93 } 94 95 static BOOL buffer_is_fully_dirty(const struct wined3d_buffer *buffer) 96 { 97 return buffer->modified_areas == 1 98 && !buffer->maps->offset && buffer->maps->size == buffer->resource.size; 99 } 100 101 static void wined3d_buffer_validate_location(struct wined3d_buffer *buffer, DWORD location) 102 { 103 TRACE("buffer %p, location %s.\n", buffer, wined3d_debug_location(location)); 104 105 if (location & WINED3D_LOCATION_BUFFER) 106 buffer_clear_dirty_areas(buffer); 107 108 buffer->locations |= location; 109 110 TRACE("New locations flags are %s.\n", wined3d_debug_location(buffer->locations)); 111 } 112 113 static void wined3d_buffer_invalidate_range(struct wined3d_buffer *buffer, DWORD location, 114 unsigned int offset, unsigned int size) 115 { 116 TRACE("buffer %p, location %s, offset %u, size %u.\n", 117 buffer, wined3d_debug_location(location), offset, size); 118 119 if (location & WINED3D_LOCATION_BUFFER) 120 buffer_invalidate_bo_range(buffer, offset, size); 121 122 buffer->locations &= ~location; 123 124 TRACE("New locations flags are %s.\n", wined3d_debug_location(buffer->locations)); 125 126 if (!buffer->locations) 127 ERR("Buffer %p does not have any up to date location.\n", buffer); 128 } 129 130 void wined3d_buffer_invalidate_location(struct wined3d_buffer *buffer, DWORD location) 131 { 132 wined3d_buffer_invalidate_range(buffer, location, 0, 0); 133 } 134 135 /* Context activation is done by the caller. */ 136 static void buffer_bind(struct wined3d_buffer *buffer, struct wined3d_context *context) 137 { 138 context_bind_bo(context, buffer->buffer_type_hint, buffer->buffer_object); 139 } 140 141 /* Context activation is done by the caller. */ 142 static void buffer_destroy_buffer_object(struct wined3d_buffer *buffer, struct wined3d_context *context) 143 { 144 const struct wined3d_gl_info *gl_info = context->gl_info; 145 struct wined3d_resource *resource = &buffer->resource; 146 147 if (!buffer->buffer_object) 148 return; 149 150 /* The stream source state handler might have read the memory of the 151 * vertex buffer already and got the memory in the vbo which is not 152 * valid any longer. Dirtify the stream source to force a reload. This 153 * happens only once per changed vertexbuffer and should occur rather 154 * rarely. */ 155 if (resource->bind_count) 156 { 157 if (buffer->bind_flags & WINED3D_BIND_VERTEX_BUFFER) 158 device_invalidate_state(resource->device, STATE_STREAMSRC); 159 if (buffer->bind_flags & WINED3D_BIND_INDEX_BUFFER) 160 device_invalidate_state(resource->device, STATE_INDEXBUFFER); 161 if (buffer->bind_flags & WINED3D_BIND_CONSTANT_BUFFER) 162 { 163 device_invalidate_state(resource->device, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX)); 164 device_invalidate_state(resource->device, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL)); 165 device_invalidate_state(resource->device, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN)); 166 device_invalidate_state(resource->device, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY)); 167 device_invalidate_state(resource->device, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL)); 168 device_invalidate_state(resource->device, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE)); 169 } 170 if (buffer->bind_flags & WINED3D_BIND_STREAM_OUTPUT) 171 { 172 device_invalidate_state(resource->device, STATE_STREAM_OUTPUT); 173 if (context->transform_feedback_active) 174 { 175 /* We have to make sure that transform feedback is not active 176 * when deleting a potentially bound transform feedback buffer. 177 * This may happen when the device is being destroyed. */ 178 WARN("Deleting buffer object for buffer %p, disabling transform feedback.\n", buffer); 179 context_end_transform_feedback(context); 180 } 181 } 182 } 183 184 GL_EXTCALL(glDeleteBuffers(1, &buffer->buffer_object)); 185 checkGLcall("glDeleteBuffers"); 186 buffer->buffer_object = 0; 187 188 if (buffer->fence) 189 { 190 wined3d_fence_destroy(buffer->fence); 191 buffer->fence = NULL; 192 } 193 buffer->flags &= ~WINED3D_BUFFER_APPLESYNC; 194 } 195 196 /* Context activation is done by the caller. */ 197 static BOOL buffer_create_buffer_object(struct wined3d_buffer *buffer, struct wined3d_context *context) 198 { 199 const struct wined3d_gl_info *gl_info = context->gl_info; 200 GLenum gl_usage = GL_STATIC_DRAW; 201 GLenum error; 202 203 TRACE("Creating an OpenGL buffer object for wined3d_buffer %p with usage %s.\n", 204 buffer, debug_d3dusage(buffer->resource.usage)); 205 206 /* Make sure that the gl error is cleared. Do not use checkGLcall 207 * here because checkGLcall just prints a fixme and continues. However, 208 * if an error during VBO creation occurs we can fall back to non-VBO operation 209 * with full functionality(but performance loss). 210 */ 211 while (gl_info->gl_ops.gl.p_glGetError() != GL_NO_ERROR); 212 213 /* Basically the FVF parameter passed to CreateVertexBuffer is no good. 214 * The vertex declaration from the device determines how the data in the 215 * buffer is interpreted. This means that on each draw call the buffer has 216 * to be verified to check if the rhw and color values are in the correct 217 * format. */ 218 219 GL_EXTCALL(glGenBuffers(1, &buffer->buffer_object)); 220 error = gl_info->gl_ops.gl.p_glGetError(); 221 if (!buffer->buffer_object || error != GL_NO_ERROR) 222 { 223 ERR("Failed to create a BO with error %s (%#x).\n", debug_glerror(error), error); 224 goto fail; 225 } 226 227 buffer_bind(buffer, context); 228 error = gl_info->gl_ops.gl.p_glGetError(); 229 if (error != GL_NO_ERROR) 230 { 231 ERR("Failed to bind the BO with error %s (%#x).\n", debug_glerror(error), error); 232 goto fail; 233 } 234 235 if (buffer->resource.usage & WINED3DUSAGE_DYNAMIC) 236 { 237 TRACE("Buffer has WINED3DUSAGE_DYNAMIC set.\n"); 238 gl_usage = GL_STREAM_DRAW_ARB; 239 240 if (gl_info->supported[APPLE_FLUSH_BUFFER_RANGE]) 241 { 242 GL_EXTCALL(glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE)); 243 GL_EXTCALL(glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE)); 244 checkGLcall("glBufferParameteriAPPLE"); 245 buffer->flags |= WINED3D_BUFFER_APPLESYNC; 246 } 247 /* No setup is needed here for GL_ARB_map_buffer_range. */ 248 } 249 250 GL_EXTCALL(glBufferData(buffer->buffer_type_hint, buffer->resource.size, NULL, gl_usage)); 251 error = gl_info->gl_ops.gl.p_glGetError(); 252 if (error != GL_NO_ERROR) 253 { 254 ERR("glBufferData failed with error %s (%#x).\n", debug_glerror(error), error); 255 goto fail; 256 } 257 258 buffer->buffer_object_usage = gl_usage; 259 buffer_invalidate_bo_range(buffer, 0, 0); 260 261 return TRUE; 262 263 fail: 264 /* Clean up all BO init, but continue because we can work without a BO :-) */ 265 ERR("Failed to create a buffer object. Continuing, but performance issues may occur.\n"); 266 buffer->flags &= ~WINED3D_BUFFER_USE_BO; 267 buffer_destroy_buffer_object(buffer, context); 268 buffer_clear_dirty_areas(buffer); 269 return FALSE; 270 } 271 272 static BOOL buffer_process_converted_attribute(struct wined3d_buffer *buffer, 273 const enum wined3d_buffer_conversion_type conversion_type, 274 const struct wined3d_stream_info_element *attrib, DWORD *stride_this_run) 275 { 276 const struct wined3d_format *format = attrib->format; 277 BOOL ret = FALSE; 278 unsigned int i; 279 DWORD_PTR data; 280 281 /* Check for some valid situations which cause us pain. One is if the buffer is used for 282 * constant attributes(stride = 0), the other one is if the buffer is used on two streams 283 * with different strides. In the 2nd case we might have to drop conversion entirely, 284 * it is possible that the same bytes are once read as FLOAT2 and once as UBYTE4N. 285 */ 286 if (!attrib->stride) 287 { 288 FIXME("%s used with stride 0, let's hope we get the vertex stride from somewhere else.\n", 289 debug_d3dformat(format->id)); 290 } 291 else if (attrib->stride != *stride_this_run && *stride_this_run) 292 { 293 FIXME("Got two concurrent strides, %d and %d.\n", attrib->stride, *stride_this_run); 294 } 295 else 296 { 297 *stride_this_run = attrib->stride; 298 if (buffer->stride != *stride_this_run) 299 { 300 /* We rely that this happens only on the first converted attribute that is found, 301 * if at all. See above check 302 */ 303 TRACE("Reconverting because converted attributes occur, and the stride changed.\n"); 304 buffer->stride = *stride_this_run; 305 heap_free(buffer->conversion_map); 306 buffer->conversion_map = heap_calloc(buffer->stride, sizeof(*buffer->conversion_map)); 307 ret = TRUE; 308 } 309 } 310 311 data = ((DWORD_PTR)attrib->data.addr) % buffer->stride; 312 for (i = 0; i < format->attribute_size; ++i) 313 { 314 DWORD_PTR idx = (data + i) % buffer->stride; 315 if (buffer->conversion_map[idx] != conversion_type) 316 { 317 TRACE("Byte %lu in vertex changed:\n", idx); 318 TRACE(" It was type %#x, is %#x now.\n", buffer->conversion_map[idx], conversion_type); 319 ret = TRUE; 320 buffer->conversion_map[idx] = conversion_type; 321 } 322 } 323 324 return ret; 325 } 326 327 #define WINED3D_BUFFER_FIXUP_D3DCOLOR 0x01 328 #define WINED3D_BUFFER_FIXUP_XYZRHW 0x02 329 330 static BOOL buffer_check_attribute(struct wined3d_buffer *This, const struct wined3d_stream_info *si, 331 const struct wined3d_state *state, UINT attrib_idx, DWORD fixup_flags, DWORD *stride_this_run) 332 { 333 const struct wined3d_stream_info_element *attrib = &si->elements[attrib_idx]; 334 enum wined3d_format_id format; 335 BOOL ret = FALSE; 336 337 /* Ignore attributes that do not have our vbo. After that check we can be sure that the attribute is 338 * there, on nonexistent attribs the vbo is 0. 339 */ 340 if (!(si->use_map & (1u << attrib_idx)) 341 || state->streams[attrib->stream_idx].buffer != This) 342 return FALSE; 343 344 format = attrib->format->id; 345 /* Look for newly appeared conversion */ 346 if (fixup_flags & WINED3D_BUFFER_FIXUP_D3DCOLOR && format == WINED3DFMT_B8G8R8A8_UNORM) 347 { 348 ret = buffer_process_converted_attribute(This, CONV_D3DCOLOR, attrib, stride_this_run); 349 } 350 else if (fixup_flags & WINED3D_BUFFER_FIXUP_XYZRHW && si->position_transformed) 351 { 352 if (format != WINED3DFMT_R32G32B32A32_FLOAT) 353 { 354 FIXME("Unexpected format %s for transformed position.\n", debug_d3dformat(format)); 355 return FALSE; 356 } 357 358 ret = buffer_process_converted_attribute(This, CONV_POSITIONT, attrib, stride_this_run); 359 } 360 else if (This->conversion_map) 361 { 362 ret = buffer_process_converted_attribute(This, CONV_NONE, attrib, stride_this_run); 363 } 364 365 return ret; 366 } 367 368 static BOOL buffer_find_decl(struct wined3d_buffer *This, const struct wined3d_stream_info *si, 369 const struct wined3d_state *state, DWORD fixup_flags) 370 { 371 UINT stride_this_run = 0; 372 BOOL ret = FALSE; 373 374 /* In d3d7 the vertex buffer declaration NEVER changes because it is stored in the d3d7 vertex buffer. 375 * Once we have our declaration there is no need to look it up again. Index buffers also never need 376 * conversion, so once the (empty) conversion structure is created don't bother checking again 377 */ 378 if (This->flags & WINED3D_BUFFER_HASDESC) 379 { 380 if(This->resource.usage & WINED3DUSAGE_STATICDECL) return FALSE; 381 } 382 383 if (!fixup_flags) 384 { 385 TRACE("No fixup required.\n"); 386 if(This->conversion_map) 387 { 388 heap_free(This->conversion_map); 389 This->conversion_map = NULL; 390 This->stride = 0; 391 return TRUE; 392 } 393 394 return FALSE; 395 } 396 397 TRACE("Finding vertex buffer conversion information\n"); 398 /* Certain declaration types need some fixups before we can pass them to 399 * opengl. This means D3DCOLOR attributes with fixed function vertex 400 * processing, FLOAT4 POSITIONT with fixed function, and FLOAT16 if 401 * GL_ARB_half_float_vertex is not supported. 402 * 403 * Note for d3d8 and d3d9: 404 * The vertex buffer FVF doesn't help with finding them, we have to use 405 * the decoded vertex declaration and pick the things that concern the 406 * current buffer. A problem with this is that this can change between 407 * draws, so we have to validate the information and reprocess the buffer 408 * if it changes, and avoid false positives for performance reasons. 409 * WineD3D doesn't even know the vertex buffer any more, it is managed 410 * by the client libraries and passed to SetStreamSource and ProcessVertices 411 * as needed. 412 * 413 * We have to distinguish between vertex shaders and fixed function to 414 * pick the way we access the strided vertex information. 415 * 416 * This code sets up a per-byte array with the size of the detected 417 * stride of the arrays in the buffer. For each byte we have a field 418 * that marks the conversion needed on this byte. For example, the 419 * following declaration with fixed function vertex processing: 420 * 421 * POSITIONT, FLOAT4 422 * NORMAL, FLOAT3 423 * DIFFUSE, FLOAT16_4 424 * SPECULAR, D3DCOLOR 425 * 426 * Will result in 427 * { POSITIONT }{ NORMAL }{ DIFFUSE }{SPECULAR } 428 * [P][P][P][P][P][P][P][P][P][P][P][P][P][P][P][P][0][0][0][0][0][0][0][0][0][0][0][0][F][F][F][F][F][F][F][F][C][C][C][C] 429 * 430 * Where in this example map P means 4 component position conversion, 0 431 * means no conversion, F means FLOAT16_2 conversion and C means D3DCOLOR 432 * conversion (red / blue swizzle). 433 * 434 * If we're doing conversion and the stride changes we have to reconvert 435 * the whole buffer. Note that we do not mind if the semantic changes, 436 * we only care for the conversion type. So if the NORMAL is replaced 437 * with a TEXCOORD, nothing has to be done, or if the DIFFUSE is replaced 438 * with a D3DCOLOR BLENDWEIGHT we can happily dismiss the change. Some 439 * conversion types depend on the semantic as well, for example a FLOAT4 440 * texcoord needs no conversion while a FLOAT4 positiont needs one 441 */ 442 443 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_POSITION, 444 fixup_flags, &stride_this_run) || ret; 445 fixup_flags &= ~WINED3D_BUFFER_FIXUP_XYZRHW; 446 447 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_BLENDWEIGHT, 448 fixup_flags, &stride_this_run) || ret; 449 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_BLENDINDICES, 450 fixup_flags, &stride_this_run) || ret; 451 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_NORMAL, 452 fixup_flags, &stride_this_run) || ret; 453 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_DIFFUSE, 454 fixup_flags, &stride_this_run) || ret; 455 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_SPECULAR, 456 fixup_flags, &stride_this_run) || ret; 457 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_TEXCOORD0, 458 fixup_flags, &stride_this_run) || ret; 459 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_TEXCOORD1, 460 fixup_flags, &stride_this_run) || ret; 461 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_TEXCOORD2, 462 fixup_flags, &stride_this_run) || ret; 463 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_TEXCOORD3, 464 fixup_flags, &stride_this_run) || ret; 465 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_TEXCOORD4, 466 fixup_flags, &stride_this_run) || ret; 467 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_TEXCOORD5, 468 fixup_flags, &stride_this_run) || ret; 469 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_TEXCOORD6, 470 fixup_flags, &stride_this_run) || ret; 471 ret = buffer_check_attribute(This, si, state, WINED3D_FFP_TEXCOORD7, 472 fixup_flags, &stride_this_run) || ret; 473 474 if (!stride_this_run && This->conversion_map) 475 { 476 /* Sanity test */ 477 if (!ret) 478 ERR("no converted attributes found, old conversion map exists, and no declaration change?\n"); 479 heap_free(This->conversion_map); 480 This->conversion_map = NULL; 481 This->stride = 0; 482 } 483 484 if (ret) TRACE("Conversion information changed\n"); 485 486 return ret; 487 } 488 489 static inline unsigned int fixup_d3dcolor(DWORD *dst_color) 490 { 491 DWORD src_color = *dst_color; 492 493 /* Color conversion like in draw_primitive_immediate_mode(). Watch out for 494 * endianness. If we want this to work on big-endian machines as well we 495 * have to consider more things. 496 * 497 * 0xff000000: Alpha mask 498 * 0x00ff0000: Blue mask 499 * 0x0000ff00: Green mask 500 * 0x000000ff: Red mask 501 */ 502 *dst_color = 0; 503 *dst_color |= (src_color & 0xff00ff00u); /* Alpha Green */ 504 *dst_color |= (src_color & 0x00ff0000u) >> 16; /* Red */ 505 *dst_color |= (src_color & 0x000000ffu) << 16; /* Blue */ 506 507 return sizeof(*dst_color); 508 } 509 510 static inline unsigned int fixup_transformed_pos(struct wined3d_vec4 *p) 511 { 512 /* rhw conversion like in position_float4(). */ 513 if (p->w != 1.0f && p->w != 0.0f) 514 { 515 float w = 1.0f / p->w; 516 p->x *= w; 517 p->y *= w; 518 p->z *= w; 519 p->w = w; 520 } 521 522 return sizeof(*p); 523 } 524 525 ULONG CDECL wined3d_buffer_incref(struct wined3d_buffer *buffer) 526 { 527 ULONG refcount = InterlockedIncrement(&buffer->resource.ref); 528 529 TRACE("%p increasing refcount to %u.\n", buffer, refcount); 530 531 return refcount; 532 } 533 534 /* Context activation is done by the caller. */ 535 static void wined3d_buffer_upload_ranges(struct wined3d_buffer *buffer, struct wined3d_context *context, 536 const void *data, unsigned int data_offset, unsigned int range_count, const struct wined3d_map_range *ranges) 537 { 538 const struct wined3d_gl_info *gl_info = context->gl_info; 539 const struct wined3d_map_range *range; 540 541 buffer_bind(buffer, context); 542 543 while (range_count--) 544 { 545 range = &ranges[range_count]; 546 GL_EXTCALL(glBufferSubData(buffer->buffer_type_hint, 547 range->offset, range->size, (BYTE *)data + range->offset - data_offset)); 548 } 549 checkGLcall("glBufferSubData"); 550 } 551 552 static void buffer_conversion_upload(struct wined3d_buffer *buffer, struct wined3d_context *context) 553 { 554 unsigned int i, j, range_idx, start, end, vertex_count; 555 BYTE *data; 556 557 if (!wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM)) 558 { 559 ERR("Failed to load system memory.\n"); 560 return; 561 } 562 buffer->flags |= WINED3D_BUFFER_PIN_SYSMEM; 563 564 /* Now for each vertex in the buffer that needs conversion. */ 565 vertex_count = buffer->resource.size / buffer->stride; 566 567 if (!(data = heap_alloc(buffer->resource.size))) 568 { 569 ERR("Out of memory.\n"); 570 return; 571 } 572 573 for (range_idx = 0; range_idx < buffer->modified_areas; ++range_idx) 574 { 575 start = buffer->maps[range_idx].offset; 576 end = start + buffer->maps[range_idx].size; 577 578 memcpy(data + start, (BYTE *)buffer->resource.heap_memory + start, end - start); 579 for (i = start / buffer->stride; i < min((end / buffer->stride) + 1, vertex_count); ++i) 580 { 581 for (j = 0; j < buffer->stride;) 582 { 583 switch (buffer->conversion_map[j]) 584 { 585 case CONV_NONE: 586 /* Done already */ 587 j += sizeof(DWORD); 588 break; 589 case CONV_D3DCOLOR: 590 j += fixup_d3dcolor((DWORD *) (data + i * buffer->stride + j)); 591 break; 592 case CONV_POSITIONT: 593 j += fixup_transformed_pos((struct wined3d_vec4 *) (data + i * buffer->stride + j)); 594 break; 595 default: 596 FIXME("Unimplemented conversion %d in shifted conversion.\n", buffer->conversion_map[j]); 597 ++j; 598 } 599 } 600 } 601 } 602 603 wined3d_buffer_upload_ranges(buffer, context, data, 0, buffer->modified_areas, buffer->maps); 604 605 heap_free(data); 606 } 607 608 static BOOL wined3d_buffer_prepare_location(struct wined3d_buffer *buffer, 609 struct wined3d_context *context, DWORD location) 610 { 611 switch (location) 612 { 613 case WINED3D_LOCATION_SYSMEM: 614 if (buffer->resource.heap_memory) 615 return TRUE; 616 617 if (!wined3d_resource_allocate_sysmem(&buffer->resource)) 618 return FALSE; 619 return TRUE; 620 621 case WINED3D_LOCATION_BUFFER: 622 if (buffer->buffer_object) 623 return TRUE; 624 625 if (!(buffer->flags & WINED3D_BUFFER_USE_BO)) 626 { 627 WARN("Trying to create BO for buffer %p with no WINED3D_BUFFER_USE_BO.\n", buffer); 628 return FALSE; 629 } 630 return buffer_create_buffer_object(buffer, context); 631 632 default: 633 ERR("Invalid location %s.\n", wined3d_debug_location(location)); 634 return FALSE; 635 } 636 } 637 638 BOOL wined3d_buffer_load_location(struct wined3d_buffer *buffer, 639 struct wined3d_context *context, DWORD location) 640 { 641 const struct wined3d_gl_info *gl_info = context->gl_info; 642 643 TRACE("buffer %p, context %p, location %s.\n", 644 buffer, context, wined3d_debug_location(location)); 645 646 if (buffer->locations & location) 647 { 648 TRACE("Location (%#x) is already up to date.\n", location); 649 return TRUE; 650 } 651 652 if (!buffer->locations) 653 { 654 ERR("Buffer %p does not have any up to date location.\n", buffer); 655 wined3d_buffer_validate_location(buffer, WINED3D_LOCATION_DISCARDED); 656 return wined3d_buffer_load_location(buffer, context, location); 657 } 658 659 TRACE("Current buffer location %s.\n", wined3d_debug_location(buffer->locations)); 660 661 if (!wined3d_buffer_prepare_location(buffer, context, location)) 662 return FALSE; 663 664 if (buffer->locations & WINED3D_LOCATION_DISCARDED) 665 { 666 TRACE("Buffer previously discarded, nothing to do.\n"); 667 wined3d_buffer_validate_location(buffer, location); 668 wined3d_buffer_invalidate_location(buffer, WINED3D_LOCATION_DISCARDED); 669 return TRUE; 670 } 671 672 switch (location) 673 { 674 case WINED3D_LOCATION_SYSMEM: 675 buffer_bind(buffer, context); 676 GL_EXTCALL(glGetBufferSubData(buffer->buffer_type_hint, 0, buffer->resource.size, 677 buffer->resource.heap_memory)); 678 checkGLcall("buffer download"); 679 break; 680 681 case WINED3D_LOCATION_BUFFER: 682 if (!buffer->conversion_map) 683 wined3d_buffer_upload_ranges(buffer, context, buffer->resource.heap_memory, 684 0, buffer->modified_areas, buffer->maps); 685 else 686 buffer_conversion_upload(buffer, context); 687 break; 688 689 default: 690 ERR("Invalid location %s.\n", wined3d_debug_location(location)); 691 return FALSE; 692 } 693 694 wined3d_buffer_validate_location(buffer, location); 695 if (buffer->resource.heap_memory && location == WINED3D_LOCATION_BUFFER 696 && !(buffer->resource.usage & WINED3DUSAGE_DYNAMIC)) 697 wined3d_buffer_evict_sysmem(buffer); 698 699 return TRUE; 700 } 701 702 /* Context activation is done by the caller. */ 703 BYTE *wined3d_buffer_load_sysmem(struct wined3d_buffer *buffer, struct wined3d_context *context) 704 { 705 if (wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM)) 706 buffer->flags |= WINED3D_BUFFER_PIN_SYSMEM; 707 return buffer->resource.heap_memory; 708 } 709 710 DWORD wined3d_buffer_get_memory(struct wined3d_buffer *buffer, 711 struct wined3d_bo_address *data, DWORD locations) 712 { 713 TRACE("buffer %p, data %p, locations %s.\n", 714 buffer, data, wined3d_debug_location(locations)); 715 716 if (locations & WINED3D_LOCATION_BUFFER) 717 { 718 data->buffer_object = buffer->buffer_object; 719 data->addr = NULL; 720 return WINED3D_LOCATION_BUFFER; 721 } 722 if (locations & WINED3D_LOCATION_SYSMEM) 723 { 724 data->buffer_object = 0; 725 data->addr = buffer->resource.heap_memory; 726 return WINED3D_LOCATION_SYSMEM; 727 } 728 729 ERR("Unexpected locations %s.\n", wined3d_debug_location(locations)); 730 data->buffer_object = 0; 731 data->addr = NULL; 732 return 0; 733 } 734 735 static void buffer_unload(struct wined3d_resource *resource) 736 { 737 struct wined3d_buffer *buffer = buffer_from_resource(resource); 738 739 TRACE("buffer %p.\n", buffer); 740 741 if (buffer->buffer_object) 742 { 743 struct wined3d_context *context; 744 745 context = context_acquire(resource->device, NULL, 0); 746 747 wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM); 748 wined3d_buffer_invalidate_location(buffer, WINED3D_LOCATION_BUFFER); 749 buffer_destroy_buffer_object(buffer, context); 750 buffer_clear_dirty_areas(buffer); 751 752 context_release(context); 753 754 heap_free(buffer->conversion_map); 755 buffer->conversion_map = NULL; 756 buffer->stride = 0; 757 buffer->conversion_stride = 0; 758 buffer->flags &= ~WINED3D_BUFFER_HASDESC; 759 } 760 761 resource_unload(resource); 762 } 763 764 static void wined3d_buffer_drop_bo(struct wined3d_buffer *buffer) 765 { 766 buffer->flags &= ~WINED3D_BUFFER_USE_BO; 767 buffer_unload(&buffer->resource); 768 } 769 770 static void wined3d_buffer_destroy_object(void *object) 771 { 772 struct wined3d_buffer *buffer = object; 773 struct wined3d_context *context; 774 775 if (buffer->buffer_object) 776 { 777 context = context_acquire(buffer->resource.device, NULL, 0); 778 buffer_destroy_buffer_object(buffer, context); 779 context_release(context); 780 781 heap_free(buffer->conversion_map); 782 } 783 784 heap_free(buffer->maps); 785 heap_free(buffer); 786 } 787 788 ULONG CDECL wined3d_buffer_decref(struct wined3d_buffer *buffer) 789 { 790 ULONG refcount = InterlockedDecrement(&buffer->resource.ref); 791 792 TRACE("%p decreasing refcount to %u.\n", buffer, refcount); 793 794 if (!refcount) 795 { 796 buffer->resource.parent_ops->wined3d_object_destroyed(buffer->resource.parent); 797 resource_cleanup(&buffer->resource); 798 wined3d_cs_destroy_object(buffer->resource.device->cs, wined3d_buffer_destroy_object, buffer); 799 } 800 801 return refcount; 802 } 803 804 void * CDECL wined3d_buffer_get_parent(const struct wined3d_buffer *buffer) 805 { 806 TRACE("buffer %p.\n", buffer); 807 808 return buffer->resource.parent; 809 } 810 811 /* The caller provides a context and binds the buffer */ 812 static void buffer_sync_apple(struct wined3d_buffer *buffer, DWORD flags, const struct wined3d_gl_info *gl_info) 813 { 814 enum wined3d_fence_result ret; 815 HRESULT hr; 816 817 /* No fencing needs to be done if the app promises not to overwrite 818 * existing data. */ 819 if (flags & WINED3D_MAP_NOOVERWRITE) 820 return; 821 822 if (flags & WINED3D_MAP_DISCARD) 823 { 824 GL_EXTCALL(glBufferData(buffer->buffer_type_hint, buffer->resource.size, NULL, buffer->buffer_object_usage)); 825 checkGLcall("glBufferData"); 826 return; 827 } 828 829 if (!buffer->fence) 830 { 831 TRACE("Creating fence for buffer %p.\n", buffer); 832 833 if (FAILED(hr = wined3d_fence_create(buffer->resource.device, &buffer->fence))) 834 { 835 if (hr == WINED3DERR_NOTAVAILABLE) 836 FIXME("Fences not supported, dropping async buffer locks.\n"); 837 else 838 ERR("Failed to create fence, hr %#x.\n", hr); 839 goto drop_fence; 840 } 841 842 /* Since we don't know about old draws a glFinish is needed once */ 843 gl_info->gl_ops.gl.p_glFinish(); 844 return; 845 } 846 847 TRACE("Synchronizing buffer %p.\n", buffer); 848 ret = wined3d_fence_wait(buffer->fence, buffer->resource.device); 849 switch (ret) 850 { 851 case WINED3D_FENCE_NOT_STARTED: 852 case WINED3D_FENCE_OK: 853 /* All done */ 854 return; 855 856 case WINED3D_FENCE_WRONG_THREAD: 857 WARN("Cannot synchronize buffer lock due to a thread conflict.\n"); 858 goto drop_fence; 859 860 default: 861 ERR("wined3d_fence_wait() returned %u, dropping async buffer locks.\n", ret); 862 goto drop_fence; 863 } 864 865 drop_fence: 866 if (buffer->fence) 867 { 868 wined3d_fence_destroy(buffer->fence); 869 buffer->fence = NULL; 870 } 871 872 gl_info->gl_ops.gl.p_glFinish(); 873 GL_EXTCALL(glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE)); 874 checkGLcall("glBufferParameteriAPPLE(buffer->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE)"); 875 buffer->flags &= ~WINED3D_BUFFER_APPLESYNC; 876 } 877 878 static void buffer_mark_used(struct wined3d_buffer *buffer) 879 { 880 buffer->flags &= ~WINED3D_BUFFER_DISCARD; 881 } 882 883 /* Context activation is done by the caller. */ 884 void wined3d_buffer_load(struct wined3d_buffer *buffer, struct wined3d_context *context, 885 const struct wined3d_state *state) 886 { 887 const struct wined3d_gl_info *gl_info = context->gl_info; 888 BOOL decl_changed = FALSE; 889 890 TRACE("buffer %p.\n", buffer); 891 892 if (buffer->resource.map_count) 893 { 894 WARN("Buffer is mapped, skipping preload.\n"); 895 return; 896 } 897 898 buffer_mark_used(buffer); 899 900 /* TODO: Make converting independent from VBOs */ 901 if (!(buffer->flags & WINED3D_BUFFER_USE_BO)) 902 { 903 /* Not doing any conversion */ 904 return; 905 } 906 907 if (!wined3d_buffer_prepare_location(buffer, context, WINED3D_LOCATION_BUFFER)) 908 { 909 ERR("Failed to prepare buffer location.\n"); 910 return; 911 } 912 913 /* Reading the declaration makes only sense if we have valid state information 914 * (i.e., if this function is called during draws). */ 915 if (state) 916 { 917 DWORD fixup_flags = 0; 918 919 if (!use_vs(state)) 920 { 921 if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && !context->d3d_info->ffp_generic_attributes) 922 fixup_flags |= WINED3D_BUFFER_FIXUP_D3DCOLOR; 923 if (!context->d3d_info->xyzrhw) 924 fixup_flags |= WINED3D_BUFFER_FIXUP_XYZRHW; 925 } 926 927 decl_changed = buffer_find_decl(buffer, &context->stream_info, state, fixup_flags); 928 buffer->flags |= WINED3D_BUFFER_HASDESC; 929 } 930 931 if (!decl_changed && !(buffer->flags & WINED3D_BUFFER_HASDESC && buffer_is_dirty(buffer))) 932 { 933 ++buffer->draw_count; 934 if (buffer->draw_count > VB_RESETDECLCHANGE) 935 buffer->decl_change_count = 0; 936 if (buffer->draw_count > VB_RESETFULLCONVS) 937 buffer->full_conversion_count = 0; 938 return; 939 } 940 941 /* If applications change the declaration over and over, reconverting all the time is a huge 942 * performance hit. So count the declaration changes and release the VBO if there are too many 943 * of them (and thus stop converting) 944 */ 945 if (decl_changed) 946 { 947 ++buffer->decl_change_count; 948 buffer->draw_count = 0; 949 950 if (buffer->decl_change_count > VB_MAXDECLCHANGES 951 || (buffer->conversion_map && (buffer->resource.usage & WINED3DUSAGE_DYNAMIC))) 952 { 953 FIXME("Too many declaration changes or converting dynamic buffer, stopping converting.\n"); 954 wined3d_buffer_drop_bo(buffer); 955 return; 956 } 957 958 /* The declaration changed, reload the whole buffer. */ 959 WARN("Reloading buffer because of a vertex declaration change.\n"); 960 buffer_invalidate_bo_range(buffer, 0, 0); 961 } 962 else 963 { 964 /* However, it is perfectly fine to change the declaration every now and then. We don't want a game that 965 * changes it every minute drop the VBO after VB_MAX_DECL_CHANGES minutes. So count draws without 966 * decl changes and reset the decl change count after a specific number of them 967 */ 968 if (buffer->conversion_map && buffer_is_fully_dirty(buffer)) 969 { 970 ++buffer->full_conversion_count; 971 if (buffer->full_conversion_count > VB_MAXFULLCONVERSIONS) 972 { 973 FIXME("Too many full buffer conversions, stopping converting.\n"); 974 wined3d_buffer_drop_bo(buffer); 975 return; 976 } 977 } 978 else 979 { 980 ++buffer->draw_count; 981 if (buffer->draw_count > VB_RESETDECLCHANGE) 982 buffer->decl_change_count = 0; 983 if (buffer->draw_count > VB_RESETFULLCONVS) 984 buffer->full_conversion_count = 0; 985 } 986 } 987 988 if (!wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER)) 989 ERR("Failed to load buffer location.\n"); 990 } 991 992 struct wined3d_resource * CDECL wined3d_buffer_get_resource(struct wined3d_buffer *buffer) 993 { 994 TRACE("buffer %p.\n", buffer); 995 996 return &buffer->resource; 997 } 998 999 static HRESULT wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UINT size, BYTE **data, DWORD flags) 1000 { 1001 struct wined3d_device *device = buffer->resource.device; 1002 struct wined3d_context *context; 1003 LONG count; 1004 BYTE *base; 1005 1006 TRACE("buffer %p, offset %u, size %u, data %p, flags %#x.\n", buffer, offset, size, data, flags); 1007 1008 count = ++buffer->resource.map_count; 1009 1010 if (buffer->buffer_object) 1011 { 1012 unsigned int dirty_offset = offset, dirty_size = size; 1013 1014 /* DISCARD invalidates the entire buffer, regardless of the specified 1015 * offset and size. Some applications also depend on the entire buffer 1016 * being uploaded in that case. Two such applications are Port Royale 1017 * and Darkstar One. */ 1018 if (flags & WINED3D_MAP_DISCARD) 1019 { 1020 dirty_offset = 0; 1021 dirty_size = 0; 1022 } 1023 1024 if (((flags & WINED3D_MAP_WRITE) && !(flags & (WINED3D_MAP_NOOVERWRITE | WINED3D_MAP_DISCARD))) 1025 || (!(flags & WINED3D_MAP_WRITE) && (buffer->locations & WINED3D_LOCATION_SYSMEM)) 1026 || buffer->flags & WINED3D_BUFFER_PIN_SYSMEM) 1027 { 1028 if (!(buffer->locations & WINED3D_LOCATION_SYSMEM)) 1029 { 1030 context = context_acquire(device, NULL, 0); 1031 wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM); 1032 context_release(context); 1033 } 1034 1035 if (flags & WINED3D_MAP_WRITE) 1036 wined3d_buffer_invalidate_range(buffer, WINED3D_LOCATION_BUFFER, dirty_offset, dirty_size); 1037 } 1038 else 1039 { 1040 const struct wined3d_gl_info *gl_info; 1041 1042 context = context_acquire(device, NULL, 0); 1043 gl_info = context->gl_info; 1044 1045 if (flags & WINED3D_MAP_DISCARD) 1046 wined3d_buffer_validate_location(buffer, WINED3D_LOCATION_BUFFER); 1047 else 1048 wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER); 1049 1050 if (flags & WINED3D_MAP_WRITE) 1051 buffer_invalidate_bo_range(buffer, dirty_offset, dirty_size); 1052 1053 if ((flags & WINED3D_MAP_DISCARD) && buffer->resource.heap_memory) 1054 wined3d_buffer_evict_sysmem(buffer); 1055 1056 if (count == 1) 1057 { 1058 buffer_bind(buffer, context); 1059 1060 /* Filter redundant WINED3D_MAP_DISCARD maps. The 3DMark2001 1061 * multitexture fill rate test seems to depend on this. When 1062 * we map a buffer with GL_MAP_INVALIDATE_BUFFER_BIT, the 1063 * driver is free to discard the previous contents of the 1064 * buffer. The r600g driver only does this when the buffer is 1065 * currently in use, while the proprietary NVIDIA driver 1066 * appears to do this unconditionally. */ 1067 if (buffer->flags & WINED3D_BUFFER_DISCARD) 1068 flags &= ~WINED3D_MAP_DISCARD; 1069 1070 if (gl_info->supported[ARB_MAP_BUFFER_RANGE]) 1071 { 1072 GLbitfield mapflags = wined3d_resource_gl_map_flags(flags); 1073 buffer->map_ptr = GL_EXTCALL(glMapBufferRange(buffer->buffer_type_hint, 1074 0, buffer->resource.size, mapflags)); 1075 checkGLcall("glMapBufferRange"); 1076 } 1077 else 1078 { 1079 if (buffer->flags & WINED3D_BUFFER_APPLESYNC) 1080 buffer_sync_apple(buffer, flags, gl_info); 1081 buffer->map_ptr = GL_EXTCALL(glMapBuffer(buffer->buffer_type_hint, 1082 GL_READ_WRITE)); 1083 checkGLcall("glMapBuffer"); 1084 } 1085 1086 if (((DWORD_PTR)buffer->map_ptr) & (RESOURCE_ALIGNMENT - 1)) 1087 { 1088 WARN("Pointer %p is not %u byte aligned.\n", buffer->map_ptr, RESOURCE_ALIGNMENT); 1089 1090 GL_EXTCALL(glUnmapBuffer(buffer->buffer_type_hint)); 1091 checkGLcall("glUnmapBuffer"); 1092 buffer->map_ptr = NULL; 1093 1094 if (buffer->resource.usage & WINED3DUSAGE_DYNAMIC) 1095 { 1096 /* The extra copy is more expensive than not using VBOs at 1097 * all on the Nvidia Linux driver, which is the only driver 1098 * that returns unaligned pointers. 1099 */ 1100 TRACE("Dynamic buffer, dropping VBO.\n"); 1101 wined3d_buffer_drop_bo(buffer); 1102 } 1103 else 1104 { 1105 TRACE("Falling back to doublebuffered operation.\n"); 1106 wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_SYSMEM); 1107 buffer->flags |= WINED3D_BUFFER_PIN_SYSMEM; 1108 } 1109 TRACE("New pointer is %p.\n", buffer->resource.heap_memory); 1110 } 1111 } 1112 1113 context_release(context); 1114 } 1115 1116 if (flags & WINED3D_MAP_DISCARD) 1117 buffer->flags |= WINED3D_BUFFER_DISCARD; 1118 } 1119 1120 base = buffer->map_ptr ? buffer->map_ptr : buffer->resource.heap_memory; 1121 *data = base + offset; 1122 1123 TRACE("Returning memory at %p (base %p, offset %u).\n", *data, base, offset); 1124 /* TODO: check Flags compatibility with buffer->currentDesc.Usage (see MSDN) */ 1125 1126 return WINED3D_OK; 1127 } 1128 1129 static void wined3d_buffer_unmap(struct wined3d_buffer *buffer) 1130 { 1131 ULONG i; 1132 1133 TRACE("buffer %p.\n", buffer); 1134 1135 /* In the case that the number of Unmap calls > the 1136 * number of Map calls, d3d returns always D3D_OK. 1137 * This is also needed to prevent Map from returning garbage on 1138 * the next call (this will happen if the lock_count is < 0). */ 1139 if (!buffer->resource.map_count) 1140 { 1141 WARN("Unmap called without a previous map call.\n"); 1142 return; 1143 } 1144 1145 if (--buffer->resource.map_count) 1146 { 1147 /* Delay loading the buffer until everything is unlocked */ 1148 TRACE("Ignoring unmap.\n"); 1149 return; 1150 } 1151 1152 if (buffer->map_ptr) 1153 { 1154 struct wined3d_device *device = buffer->resource.device; 1155 const struct wined3d_gl_info *gl_info; 1156 struct wined3d_context *context; 1157 1158 context = context_acquire(device, NULL, 0); 1159 gl_info = context->gl_info; 1160 1161 buffer_bind(buffer, context); 1162 1163 if (gl_info->supported[ARB_MAP_BUFFER_RANGE]) 1164 { 1165 for (i = 0; i < buffer->modified_areas; ++i) 1166 { 1167 GL_EXTCALL(glFlushMappedBufferRange(buffer->buffer_type_hint, 1168 buffer->maps[i].offset, buffer->maps[i].size)); 1169 checkGLcall("glFlushMappedBufferRange"); 1170 } 1171 } 1172 else if (buffer->flags & WINED3D_BUFFER_APPLESYNC) 1173 { 1174 for (i = 0; i < buffer->modified_areas; ++i) 1175 { 1176 GL_EXTCALL(glFlushMappedBufferRangeAPPLE(buffer->buffer_type_hint, 1177 buffer->maps[i].offset, buffer->maps[i].size)); 1178 checkGLcall("glFlushMappedBufferRangeAPPLE"); 1179 } 1180 } 1181 1182 GL_EXTCALL(glUnmapBuffer(buffer->buffer_type_hint)); 1183 context_release(context); 1184 1185 buffer_clear_dirty_areas(buffer); 1186 buffer->map_ptr = NULL; 1187 } 1188 } 1189 1190 void wined3d_buffer_copy(struct wined3d_buffer *dst_buffer, unsigned int dst_offset, 1191 struct wined3d_buffer *src_buffer, unsigned int src_offset, unsigned int size) 1192 { 1193 struct wined3d_bo_address dst, src; 1194 struct wined3d_context *context; 1195 DWORD dst_location; 1196 1197 buffer_mark_used(dst_buffer); 1198 buffer_mark_used(src_buffer); 1199 1200 dst_location = wined3d_buffer_get_memory(dst_buffer, &dst, dst_buffer->locations); 1201 dst.addr += dst_offset; 1202 1203 wined3d_buffer_get_memory(src_buffer, &src, src_buffer->locations); 1204 src.addr += src_offset; 1205 1206 context = context_acquire(dst_buffer->resource.device, NULL, 0); 1207 context_copy_bo_address(context, &dst, dst_buffer->buffer_type_hint, 1208 &src, src_buffer->buffer_type_hint, size); 1209 context_release(context); 1210 1211 wined3d_buffer_invalidate_range(dst_buffer, ~dst_location, dst_offset, size); 1212 } 1213 1214 void wined3d_buffer_upload_data(struct wined3d_buffer *buffer, struct wined3d_context *context, 1215 const struct wined3d_box *box, const void *data) 1216 { 1217 struct wined3d_map_range range; 1218 1219 if (box) 1220 { 1221 range.offset = box->left; 1222 range.size = box->right - box->left; 1223 } 1224 else 1225 { 1226 range.offset = 0; 1227 range.size = buffer->resource.size; 1228 } 1229 1230 wined3d_buffer_upload_ranges(buffer, context, data, range.offset, 1, &range); 1231 } 1232 1233 static ULONG buffer_resource_incref(struct wined3d_resource *resource) 1234 { 1235 return wined3d_buffer_incref(buffer_from_resource(resource)); 1236 } 1237 1238 static ULONG buffer_resource_decref(struct wined3d_resource *resource) 1239 { 1240 return wined3d_buffer_decref(buffer_from_resource(resource)); 1241 } 1242 1243 static void buffer_resource_preload(struct wined3d_resource *resource) 1244 { 1245 struct wined3d_context *context; 1246 1247 context = context_acquire(resource->device, NULL, 0); 1248 wined3d_buffer_load(buffer_from_resource(resource), context, NULL); 1249 context_release(context); 1250 } 1251 1252 static HRESULT buffer_resource_sub_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx, 1253 struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags) 1254 { 1255 struct wined3d_buffer *buffer = buffer_from_resource(resource); 1256 UINT offset, size; 1257 1258 if (sub_resource_idx) 1259 { 1260 WARN("Invalid sub_resource_idx %u.\n", sub_resource_idx); 1261 return E_INVALIDARG; 1262 } 1263 1264 if (box) 1265 { 1266 offset = box->left; 1267 size = box->right - box->left; 1268 } 1269 else 1270 { 1271 offset = size = 0; 1272 } 1273 1274 map_desc->row_pitch = map_desc->slice_pitch = buffer->desc.byte_width; 1275 return wined3d_buffer_map(buffer, offset, size, (BYTE **)&map_desc->data, flags); 1276 } 1277 1278 static HRESULT buffer_resource_sub_resource_map_info(struct wined3d_resource *resource, unsigned int sub_resource_idx, 1279 struct wined3d_map_info *info, DWORD flags) 1280 { 1281 struct wined3d_buffer *buffer = buffer_from_resource(resource); 1282 1283 if (sub_resource_idx) 1284 { 1285 WARN("Invalid sub_resource_idx %u.\n", sub_resource_idx); 1286 return E_INVALIDARG; 1287 } 1288 1289 info->row_pitch = buffer->desc.byte_width; 1290 info->slice_pitch = buffer->desc.byte_width; 1291 info->size = buffer->resource.size; 1292 1293 return WINED3D_OK; 1294 } 1295 1296 static HRESULT buffer_resource_sub_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx) 1297 { 1298 if (sub_resource_idx) 1299 { 1300 WARN("Invalid sub_resource_idx %u.\n", sub_resource_idx); 1301 return E_INVALIDARG; 1302 } 1303 1304 wined3d_buffer_unmap(buffer_from_resource(resource)); 1305 return WINED3D_OK; 1306 } 1307 1308 static const struct wined3d_resource_ops buffer_resource_ops = 1309 { 1310 buffer_resource_incref, 1311 buffer_resource_decref, 1312 buffer_resource_preload, 1313 buffer_unload, 1314 buffer_resource_sub_resource_map, 1315 buffer_resource_sub_resource_map_info, 1316 buffer_resource_sub_resource_unmap, 1317 }; 1318 1319 static GLenum buffer_type_hint_from_bind_flags(const struct wined3d_gl_info *gl_info, 1320 unsigned int bind_flags) 1321 { 1322 if (bind_flags == WINED3D_BIND_INDEX_BUFFER) 1323 return GL_ELEMENT_ARRAY_BUFFER; 1324 1325 if (bind_flags & (WINED3D_BIND_SHADER_RESOURCE | WINED3D_BIND_UNORDERED_ACCESS) 1326 && gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT]) 1327 return GL_TEXTURE_BUFFER; 1328 1329 if (bind_flags & WINED3D_BIND_CONSTANT_BUFFER) 1330 return GL_UNIFORM_BUFFER; 1331 1332 if (bind_flags & WINED3D_BIND_STREAM_OUTPUT) 1333 return GL_TRANSFORM_FEEDBACK_BUFFER; 1334 1335 if (bind_flags & ~(WINED3D_BIND_VERTEX_BUFFER | WINED3D_BIND_INDEX_BUFFER)) 1336 FIXME("Unhandled bind flags %#x.\n", bind_flags); 1337 1338 return GL_ARRAY_BUFFER; 1339 } 1340 1341 static HRESULT buffer_init(struct wined3d_buffer *buffer, struct wined3d_device *device, 1342 UINT size, DWORD usage, enum wined3d_format_id format_id, unsigned int access, unsigned int bind_flags, 1343 const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops) 1344 { 1345 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; 1346 const struct wined3d_format *format = wined3d_get_format(gl_info, format_id, usage); 1347 BOOL dynamic_buffer_ok; 1348 HRESULT hr; 1349 1350 if (!size) 1351 { 1352 WARN("Size 0 requested, returning E_INVALIDARG.\n"); 1353 return E_INVALIDARG; 1354 } 1355 1356 if (bind_flags & WINED3D_BIND_CONSTANT_BUFFER && size & (WINED3D_CONSTANT_BUFFER_ALIGNMENT - 1)) 1357 { 1358 WARN("Size %#x is not suitably aligned for constant buffers.\n", size); 1359 return E_INVALIDARG; 1360 } 1361 1362 if (data && !data->data) 1363 { 1364 WARN("Invalid sub-resource data specified.\n"); 1365 return E_INVALIDARG; 1366 } 1367 1368 if (FAILED(hr = resource_init(&buffer->resource, device, WINED3D_RTYPE_BUFFER, format, WINED3D_MULTISAMPLE_NONE, 1369 0, usage, access, size, 1, 1, size, parent, parent_ops, &buffer_resource_ops))) 1370 { 1371 WARN("Failed to initialize resource, hr %#x.\n", hr); 1372 return hr; 1373 } 1374 buffer->buffer_type_hint = buffer_type_hint_from_bind_flags(gl_info, bind_flags); 1375 buffer->bind_flags = bind_flags; 1376 buffer->locations = WINED3D_LOCATION_SYSMEM; 1377 1378 if (!wined3d_resource_allocate_sysmem(&buffer->resource)) 1379 return E_OUTOFMEMORY; 1380 1381 TRACE("buffer %p, size %#x, usage %#x, format %s, memory @ %p.\n", 1382 buffer, buffer->resource.size, buffer->resource.usage, 1383 debug_d3dformat(buffer->resource.format->id), buffer->resource.heap_memory); 1384 1385 if (device->create_parms.flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING 1386 || wined3d_resource_access_is_managed(access)) 1387 { 1388 /* SWvp and managed buffers always return the same pointer in buffer 1389 * maps and retain data in DISCARD maps. Keep a system memory copy of 1390 * the buffer to provide the same behavior to the application. */ 1391 TRACE("Using doublebuffer mode.\n"); 1392 buffer->flags |= WINED3D_BUFFER_PIN_SYSMEM; 1393 } 1394 1395 /* Observations show that draw_primitive_immediate_mode() is faster on 1396 * dynamic vertex buffers than converting + draw_primitive_arrays(). 1397 * (Half-Life 2 and others.) */ 1398 dynamic_buffer_ok = gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] || gl_info->supported[ARB_MAP_BUFFER_RANGE]; 1399 1400 if (!gl_info->supported[ARB_VERTEX_BUFFER_OBJECT]) 1401 { 1402 TRACE("Not creating a BO because GL_ARB_vertex_buffer is not supported.\n"); 1403 } 1404 else if (!(access & WINED3D_RESOURCE_ACCESS_GPU)) 1405 { 1406 TRACE("Not creating a BO because the buffer is not GPU accessible.\n"); 1407 } 1408 else if (!dynamic_buffer_ok && (buffer->resource.usage & WINED3DUSAGE_DYNAMIC)) 1409 { 1410 TRACE("Not creating a BO because the buffer has dynamic usage and no GL support.\n"); 1411 } 1412 else 1413 { 1414 buffer->flags |= WINED3D_BUFFER_USE_BO; 1415 } 1416 1417 if (!(buffer->maps = heap_alloc(sizeof(*buffer->maps)))) 1418 { 1419 ERR("Out of memory.\n"); 1420 buffer_unload(&buffer->resource); 1421 resource_cleanup(&buffer->resource); 1422 wined3d_resource_wait_idle(&buffer->resource); 1423 return E_OUTOFMEMORY; 1424 } 1425 buffer->maps_size = 1; 1426 1427 if (data) 1428 wined3d_device_update_sub_resource(device, &buffer->resource, 1429 0, NULL, data->data, data->row_pitch, data->slice_pitch, 0); 1430 1431 return WINED3D_OK; 1432 } 1433 1434 HRESULT CDECL wined3d_buffer_create(struct wined3d_device *device, const struct wined3d_buffer_desc *desc, 1435 const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops, 1436 struct wined3d_buffer **buffer) 1437 { 1438 struct wined3d_buffer *object; 1439 HRESULT hr; 1440 1441 TRACE("device %p, desc %p, data %p, parent %p, parent_ops %p, buffer %p.\n", 1442 device, desc, data, parent, parent_ops, buffer); 1443 1444 if (!(object = heap_alloc_zero(sizeof(*object)))) 1445 return E_OUTOFMEMORY; 1446 1447 if (FAILED(hr = buffer_init(object, device, desc->byte_width, desc->usage, WINED3DFMT_UNKNOWN, 1448 desc->access, desc->bind_flags, data, parent, parent_ops))) 1449 { 1450 WARN("Failed to initialize buffer, hr %#x.\n", hr); 1451 heap_free(object); 1452 return hr; 1453 } 1454 object->desc = *desc; 1455 1456 TRACE("Created buffer %p.\n", object); 1457 1458 *buffer = object; 1459 1460 return WINED3D_OK; 1461 } 1462