git.oblomov.eu Git - wine/blob - dlls/wined3d/buffer.c

   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-2010 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 VB_MAXDECLCHANGES     100     /* After that number of decl changes we stop converting */
  33 #define VB_RESETDECLCHANGE    1000    /* Reset the decl changecount after that number of draws */
  34 #define VB_MAXFULLCONVERSIONS 5       /* Number of full conversions before we stop converting */
  35 #define VB_RESETFULLCONVS     20      /* Reset full conversion counts after that number of draws */
  36
  37 static inline BOOL buffer_add_dirty_area(struct wined3d_buffer *This, UINT offset, UINT size)
  38 {
  39     if (!This->buffer_object) return TRUE;
  40
  41     if (This->maps_size <= This->modified_areas)
  42     {
  43         void *new = HeapReAlloc(GetProcessHeap(), 0, This->maps,
  44                                 This->maps_size * 2 * sizeof(*This->maps));
  45         if (!new)
  46         {
  47             ERR("Out of memory\n");
  48             return FALSE;
  49         }
  50         else
  51         {
  52             This->maps = new;
  53             This->maps_size *= 2;
  54         }
  55     }
  56
  57     if(offset > This->resource.size || offset + size > This->resource.size)
  58     {
  59         WARN("Invalid range dirtified, marking entire buffer dirty\n");
  60         offset = 0;
  61         size = This->resource.size;
  62     }
  63     else if(!offset && !size)
  64     {
  65         size = This->resource.size;
  66     }
  67
  68     This->maps[This->modified_areas].offset = offset;
  69     This->maps[This->modified_areas].size = size;
  70     This->modified_areas++;
  71     return TRUE;
  72 }
  73
  74 static inline void buffer_clear_dirty_areas(struct wined3d_buffer *This)
  75 {
  76     This->modified_areas = 0;
  77 }
  78
  79 static BOOL buffer_is_dirty(const struct wined3d_buffer *buffer)
  80 {
  81     return !!buffer->modified_areas;
  82 }
  83
  84 static BOOL buffer_is_fully_dirty(const struct wined3d_buffer *buffer)
  85 {
  86     unsigned int i;
  87
  88     for (i = 0; i < buffer->modified_areas; ++i)
  89     {
  90         if (!buffer->maps[i].offset && buffer->maps[i].size == buffer->resource.size)
  91             return TRUE;
  92     }
  93     return FALSE;
  94 }
  95
  96 /* Context activation is done by the caller */
  97 static void delete_gl_buffer(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info)
  98 {
  99     if(!This->buffer_object) return;
 100
 101     GL_EXTCALL(glDeleteBuffersARB(1, &This->buffer_object));
 102     checkGLcall("glDeleteBuffersARB");
 103     This->buffer_object = 0;
 104
 105     if(This->query)
 106     {
 107         wined3d_event_query_destroy(This->query);
 108         This->query = NULL;
 109     }
 110     This->flags &= ~WINED3D_BUFFER_APPLESYNC;
 111 }
 112
 113 /* Context activation is done by the caller. */
 114 static void buffer_create_buffer_object(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info)
 115 {
 116     GLenum error, gl_usage;
 117
 118     TRACE("Creating an OpenGL vertex buffer object for wined3d_buffer %p with usage %s.\n",
 119             This, debug_d3dusage(This->resource.usage));
 120
 121     /* Make sure that the gl error is cleared. Do not use checkGLcall
 122     * here because checkGLcall just prints a fixme and continues. However,
 123     * if an error during VBO creation occurs we can fall back to non-vbo operation
 124     * with full functionality(but performance loss)
 125     */
 126     while (gl_info->gl_ops.gl.p_glGetError() != GL_NO_ERROR);
 127
 128     /* Basically the FVF parameter passed to CreateVertexBuffer is no good.
 129      * The vertex declaration from the device determines how the data in the
 130      * buffer is interpreted. This means that on each draw call the buffer has
 131      * to be verified to check if the rhw and color values are in the correct
 132      * format. */
 133
 134     GL_EXTCALL(glGenBuffersARB(1, &This->buffer_object));
 135     error = gl_info->gl_ops.gl.p_glGetError();
 136     if (!This->buffer_object || error != GL_NO_ERROR)
 137     {
 138         ERR("Failed to create a VBO with error %s (%#x)\n", debug_glerror(error), error);
 139         goto fail;
 140     }
 141
 142     if (This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
 143         device_invalidate_state(This->resource.device, STATE_INDEXBUFFER);
 144     GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 145     error = gl_info->gl_ops.gl.p_glGetError();
 146     if (error != GL_NO_ERROR)
 147     {
 148         ERR("Failed to bind the VBO with error %s (%#x)\n", debug_glerror(error), error);
 149         goto fail;
 150     }
 151
 152     /* Don't use static, because dx apps tend to update the buffer
 153      * quite often even if they specify 0 usage.
 154      */
 155     if(This->resource.usage & WINED3DUSAGE_DYNAMIC)
 156     {
 157         TRACE("Gl usage = GL_STREAM_DRAW_ARB\n");
 158         gl_usage = GL_STREAM_DRAW_ARB;
 159
 160         if(gl_info->supported[APPLE_FLUSH_BUFFER_RANGE])
 161         {
 162             GL_EXTCALL(glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE));
 163             checkGLcall("glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE)");
 164             This->flags |= WINED3D_BUFFER_FLUSH;
 165
 166             GL_EXTCALL(glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE));
 167             checkGLcall("glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_FALSE)");
 168             This->flags |= WINED3D_BUFFER_APPLESYNC;
 169         }
 170         /* No setup is needed here for GL_ARB_map_buffer_range */
 171     }
 172     else
 173     {
 174         TRACE("Gl usage = GL_DYNAMIC_DRAW_ARB\n");
 175         gl_usage = GL_DYNAMIC_DRAW_ARB;
 176     }
 177
 178     /* Reserve memory for the buffer. The amount of data won't change
 179      * so we are safe with calling glBufferData once and
 180      * calling glBufferSubData on updates. Upload the actual data in case
 181      * we're not double buffering, so we can release the heap mem afterwards
 182      */
 183     GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, This->resource.size, This->resource.allocatedMemory, gl_usage));
 184     error = gl_info->gl_ops.gl.p_glGetError();
 185     if (error != GL_NO_ERROR)
 186     {
 187         ERR("glBufferDataARB failed with error %s (%#x)\n", debug_glerror(error), error);
 188         goto fail;
 189     }
 190
 191     This->buffer_object_size = This->resource.size;
 192     This->buffer_object_usage = gl_usage;
 193
 194     if(This->flags & WINED3D_BUFFER_DOUBLEBUFFER)
 195     {
 196         if(!buffer_add_dirty_area(This, 0, 0))
 197         {
 198             ERR("buffer_add_dirty_area failed, this is not expected\n");
 199             goto fail;
 200         }
 201     }
 202     else
 203     {
 204         HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
 205         This->resource.allocatedMemory = NULL;
 206         This->resource.heapMemory = NULL;
 207     }
 208
 209     return;
 210
 211 fail:
 212     /* Clean up all vbo init, but continue because we can work without a vbo :-) */
 213     ERR("Failed to create a vertex buffer object. Continuing, but performance issues may occur\n");
 214     delete_gl_buffer(This, gl_info);
 215     buffer_clear_dirty_areas(This);
 216 }
 217
 218 static BOOL buffer_process_converted_attribute(struct wined3d_buffer *This,
 219         const enum wined3d_buffer_conversion_type conversion_type,
 220         const struct wined3d_stream_info_element *attrib, DWORD *stride_this_run)
 221 {
 222     DWORD attrib_size;
 223     BOOL ret = FALSE;
 224     unsigned int i;
 225     DWORD_PTR data;
 226
 227     /* Check for some valid situations which cause us pain. One is if the buffer is used for
 228      * constant attributes(stride = 0), the other one is if the buffer is used on two streams
 229      * with different strides. In the 2nd case we might have to drop conversion entirely,
 230      * it is possible that the same bytes are once read as FLOAT2 and once as UBYTE4N.
 231      */
 232     if (!attrib->stride)
 233     {
 234         FIXME("%s used with stride 0, let's hope we get the vertex stride from somewhere else\n",
 235                 debug_d3dformat(attrib->format->id));
 236     }
 237     else if(attrib->stride != *stride_this_run && *stride_this_run)
 238     {
 239         FIXME("Got two concurrent strides, %d and %d\n", attrib->stride, *stride_this_run);
 240     }
 241     else
 242     {
 243         *stride_this_run = attrib->stride;
 244         if (This->stride != *stride_this_run)
 245         {
 246             /* We rely that this happens only on the first converted attribute that is found,
 247              * if at all. See above check
 248              */
 249             TRACE("Reconverting because converted attributes occur, and the stride changed\n");
 250             This->stride = *stride_this_run;
 251             HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, This->conversion_map);
 252             This->conversion_map = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 253                     sizeof(*This->conversion_map) * This->stride);
 254             ret = TRUE;
 255         }
 256     }
 257
 258     data = ((DWORD_PTR)attrib->data.addr) % This->stride;
 259     attrib_size = attrib->format->component_count * attrib->format->component_size;
 260     for (i = 0; i < attrib_size; ++i)
 261     {
 262         DWORD_PTR idx = (data + i) % This->stride;
 263         if (This->conversion_map[idx] != conversion_type)
 264         {
 265             TRACE("Byte %ld in vertex changed\n", idx);
 266             TRACE("It was type %d, is %d now\n", This->conversion_map[idx], conversion_type);
 267             ret = TRUE;
 268             This->conversion_map[idx] = conversion_type;
 269         }
 270     }
 271
 272     return ret;
 273 }
 274
 275 static BOOL buffer_check_attribute(struct wined3d_buffer *This, const struct wined3d_stream_info *si,
 276         UINT attrib_idx, const BOOL check_d3dcolor, const BOOL is_ffp_position, const BOOL is_ffp_color,
 277         DWORD *stride_this_run)
 278 {
 279     const struct wined3d_stream_info_element *attrib = &si->elements[attrib_idx];
 280     enum wined3d_format_id format;
 281     BOOL ret = FALSE;
 282
 283     /* Ignore attributes that do not have our vbo. After that check we can be sure that the attribute is
 284      * there, on nonexistent attribs the vbo is 0.
 285      */
 286     if (!(si->use_map & (1 << attrib_idx))
 287             || attrib->data.buffer_object != This->buffer_object)
 288         return FALSE;
 289
 290     format = attrib->format->id;
 291     /* Look for newly appeared conversion */
 292     if (check_d3dcolor && format == WINED3DFMT_B8G8R8A8_UNORM)
 293     {
 294         ret = buffer_process_converted_attribute(This, CONV_D3DCOLOR, attrib, stride_this_run);
 295
 296         if (!is_ffp_color) FIXME("Test for non-color fixed function WINED3DFMT_B8G8R8A8_UNORM format\n");
 297     }
 298     else if (is_ffp_position && si->position_transformed)
 299     {
 300         if (format != WINED3DFMT_R32G32B32A32_FLOAT)
 301         {
 302             FIXME("Unexpected format %s for transformed position.\n", debug_d3dformat(format));
 303             return FALSE;
 304         }
 305
 306         ret = buffer_process_converted_attribute(This, CONV_POSITIONT, attrib, stride_this_run);
 307     }
 308     else if (This->conversion_map)
 309     {
 310         ret = buffer_process_converted_attribute(This, CONV_NONE, attrib, stride_this_run);
 311     }
 312
 313     return ret;
 314 }
 315
 316 static BOOL buffer_find_decl(struct wined3d_buffer *This)
 317 {
 318     struct wined3d_device *device = This->resource.device;
 319     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 320     const struct wined3d_stream_info *si = &device->strided_streams;
 321     const struct wined3d_state *state = &device->stateBlock->state;
 322     UINT stride_this_run = 0;
 323     BOOL ret = FALSE;
 324     BOOL support_d3dcolor = gl_info->supported[ARB_VERTEX_ARRAY_BGRA];
 325
 326     /* In d3d7 the vertex buffer declaration NEVER changes because it is stored in the d3d7 vertex buffer.
 327      * Once we have our declaration there is no need to look it up again. Index buffers also never need
 328      * conversion, so once the (empty) conversion structure is created don't bother checking again
 329      */
 330     if (This->flags & WINED3D_BUFFER_HASDESC)
 331     {
 332         if(This->resource.usage & WINED3DUSAGE_STATICDECL) return FALSE;
 333     }
 334
 335     if (use_vs(state))
 336     {
 337         TRACE("Vertex shaders used, no VBO conversion is needed\n");
 338         if(This->conversion_map)
 339         {
 340             HeapFree(GetProcessHeap(), 0, This->conversion_map);
 341             This->conversion_map = NULL;
 342             This->stride = 0;
 343             return TRUE;
 344         }
 345
 346         return FALSE;
 347     }
 348
 349     TRACE("Finding vertex buffer conversion information\n");
 350     /* Certain declaration types need some fixups before we can pass them to
 351      * opengl. This means D3DCOLOR attributes with fixed function vertex
 352      * processing, FLOAT4 POSITIONT with fixed function, and FLOAT16 if
 353      * GL_ARB_half_float_vertex is not supported.
 354      *
 355      * Note for d3d8 and d3d9:
 356      * The vertex buffer FVF doesn't help with finding them, we have to use
 357      * the decoded vertex declaration and pick the things that concern the
 358      * current buffer. A problem with this is that this can change between
 359      * draws, so we have to validate the information and reprocess the buffer
 360      * if it changes, and avoid false positives for performance reasons.
 361      * WineD3D doesn't even know the vertex buffer any more, it is managed
 362      * by the client libraries and passed to SetStreamSource and ProcessVertices
 363      * as needed.
 364      *
 365      * We have to distinguish between vertex shaders and fixed function to
 366      * pick the way we access the strided vertex information.
 367      *
 368      * This code sets up a per-byte array with the size of the detected
 369      * stride of the arrays in the buffer. For each byte we have a field
 370      * that marks the conversion needed on this byte. For example, the
 371      * following declaration with fixed function vertex processing:
 372      *
 373      *      POSITIONT, FLOAT4
 374      *      NORMAL, FLOAT3
 375      *      DIFFUSE, FLOAT16_4
 376      *      SPECULAR, D3DCOLOR
 377      *
 378      * Will result in
 379      * {                 POSITIONT                    }{             NORMAL                }{    DIFFUSE          }{SPECULAR }
 380      * [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]
 381      *
 382      * Where in this example map P means 4 component position conversion, 0
 383      * means no conversion, F means FLOAT16_2 conversion and C means D3DCOLOR
 384      * conversion (red / blue swizzle).
 385      *
 386      * If we're doing conversion and the stride changes we have to reconvert
 387      * the whole buffer. Note that we do not mind if the semantic changes,
 388      * we only care for the conversion type. So if the NORMAL is replaced
 389      * with a TEXCOORD, nothing has to be done, or if the DIFFUSE is replaced
 390      * with a D3DCOLOR BLENDWEIGHT we can happily dismiss the change. Some
 391      * conversion types depend on the semantic as well, for example a FLOAT4
 392      * texcoord needs no conversion while a FLOAT4 positiont needs one
 393      */
 394
 395     ret = buffer_check_attribute(This, si, WINED3D_FFP_POSITION,
 396             TRUE, TRUE,  FALSE, &stride_this_run) || ret;
 397     ret = buffer_check_attribute(This, si, WINED3D_FFP_NORMAL,
 398             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 399     ret = buffer_check_attribute(This, si, WINED3D_FFP_DIFFUSE,
 400             !support_d3dcolor, FALSE, TRUE,  &stride_this_run) || ret;
 401     ret = buffer_check_attribute(This, si, WINED3D_FFP_SPECULAR,
 402             !support_d3dcolor, FALSE, TRUE,  &stride_this_run) || ret;
 403     ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD0,
 404             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 405     ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD1,
 406             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 407     ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD2,
 408             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 409     ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD3,
 410             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 411     ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD4,
 412             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 413     ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD5,
 414             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 415     ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD6,
 416             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 417     ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD7,
 418             TRUE, FALSE, FALSE, &stride_this_run) || ret;
 419
 420     if (!stride_this_run && This->conversion_map)
 421     {
 422         /* Sanity test */
 423         if (!ret) ERR("no converted attributes found, old conversion map exists, and no declaration change?\n");
 424         HeapFree(GetProcessHeap(), 0, This->conversion_map);
 425         This->conversion_map = NULL;
 426         This->stride = 0;
 427     }
 428
 429     if (ret) TRACE("Conversion information changed\n");
 430
 431     return ret;
 432 }
 433
 434 static inline void fixup_d3dcolor(DWORD *dst_color)
 435 {
 436     DWORD src_color = *dst_color;
 437
 438     /* Color conversion like in drawStridedSlow. watch out for little endianity
 439      * If we want that stuff to work on big endian machines too we have to consider more things
 440      *
 441      * 0xff000000: Alpha mask
 442      * 0x00ff0000: Blue mask
 443      * 0x0000ff00: Green mask
 444      * 0x000000ff: Red mask
 445      */
 446     *dst_color = 0;
 447     *dst_color |= (src_color & 0xff00ff00);         /* Alpha Green */
 448     *dst_color |= (src_color & 0x00ff0000) >> 16;   /* Red */
 449     *dst_color |= (src_color & 0x000000ff) << 16;   /* Blue */
 450 }
 451
 452 static inline void fixup_transformed_pos(float *p)
 453 {
 454     /* rhw conversion like in position_float4(). */
 455     if (p[3] != 1.0f && p[3] != 0.0f)
 456     {
 457         float w = 1.0f / p[3];
 458         p[0] *= w;
 459         p[1] *= w;
 460         p[2] *= w;
 461         p[3] = w;
 462     }
 463 }
 464
 465 /* Context activation is done by the caller. */
 466 void buffer_get_memory(struct wined3d_buffer *buffer, const struct wined3d_gl_info *gl_info,
 467         struct wined3d_bo_address *data)
 468 {
 469     data->buffer_object = buffer->buffer_object;
 470     if (!buffer->buffer_object)
 471     {
 472         if ((buffer->flags & WINED3D_BUFFER_CREATEBO) && !buffer->resource.map_count)
 473         {
 474             buffer_create_buffer_object(buffer, gl_info);
 475             buffer->flags &= ~WINED3D_BUFFER_CREATEBO;
 476             if (buffer->buffer_object)
 477             {
 478                 data->buffer_object = buffer->buffer_object;
 479                 data->addr = NULL;
 480                 return;
 481             }
 482         }
 483         data->addr = buffer->resource.allocatedMemory;
 484     }
 485     else
 486     {
 487         data->addr = NULL;
 488     }
 489 }
 490
 491 ULONG CDECL wined3d_buffer_incref(struct wined3d_buffer *buffer)
 492 {
 493     ULONG refcount = InterlockedIncrement(&buffer->resource.ref);
 494
 495     TRACE("%p increasing refcount to %u.\n", buffer, refcount);
 496
 497     return refcount;
 498 }
 499
 500 /* Context activation is done by the caller. */
 501 BYTE *buffer_get_sysmem(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info)
 502 {
 503     /* AllocatedMemory exists if the buffer is double buffered or has no buffer object at all */
 504     if(This->resource.allocatedMemory) return This->resource.allocatedMemory;
 505
 506     This->resource.heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->resource.size + RESOURCE_ALIGNMENT);
 507     This->resource.allocatedMemory = (BYTE *)(((ULONG_PTR)This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
 508
 509     if (This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
 510         device_invalidate_state(This->resource.device, STATE_INDEXBUFFER);
 511
 512     GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 513     GL_EXTCALL(glGetBufferSubDataARB(This->buffer_type_hint, 0, This->resource.size, This->resource.allocatedMemory));
 514     This->flags |= WINED3D_BUFFER_DOUBLEBUFFER;
 515
 516     return This->resource.allocatedMemory;
 517 }
 518
 519 /* Do not call while under the GL lock. */
 520 static void buffer_unload(struct wined3d_resource *resource)
 521 {
 522     struct wined3d_buffer *buffer = buffer_from_resource(resource);
 523
 524     TRACE("buffer %p.\n", buffer);
 525
 526     if (buffer->buffer_object)
 527     {
 528         struct wined3d_device *device = resource->device;
 529         struct wined3d_context *context;
 530
 531         context = context_acquire(device, NULL);
 532
 533         /* Download the buffer, but don't permanently enable double buffering */
 534         if (!(buffer->flags & WINED3D_BUFFER_DOUBLEBUFFER))
 535         {
 536             buffer_get_sysmem(buffer, context->gl_info);
 537             buffer->flags &= ~WINED3D_BUFFER_DOUBLEBUFFER;
 538         }
 539
 540         delete_gl_buffer(buffer, context->gl_info);
 541         buffer->flags |= WINED3D_BUFFER_CREATEBO; /* Recreate the buffer object next load */
 542         buffer_clear_dirty_areas(buffer);
 543
 544         context_release(context);
 545
 546         HeapFree(GetProcessHeap(), 0, buffer->conversion_map);
 547         buffer->conversion_map = NULL;
 548         buffer->stride = 0;
 549         buffer->conversion_stride = 0;
 550         buffer->flags &= ~WINED3D_BUFFER_HASDESC;
 551     }
 552
 553     resource_unload(resource);
 554 }
 555
 556 /* Do not call while under the GL lock. */
 557 ULONG CDECL wined3d_buffer_decref(struct wined3d_buffer *buffer)
 558 {
 559     ULONG refcount = InterlockedDecrement(&buffer->resource.ref);
 560
 561     TRACE("%p decreasing refcount to %u.\n", buffer, refcount);
 562
 563     if (!refcount)
 564     {
 565         buffer_unload(&buffer->resource);
 566         resource_cleanup(&buffer->resource);
 567         buffer->resource.parent_ops->wined3d_object_destroyed(buffer->resource.parent);
 568         HeapFree(GetProcessHeap(), 0, buffer->maps);
 569         HeapFree(GetProcessHeap(), 0, buffer);
 570     }
 571
 572     return refcount;
 573 }
 574
 575 void * CDECL wined3d_buffer_get_parent(const struct wined3d_buffer *buffer)
 576 {
 577     TRACE("buffer %p.\n", buffer);
 578
 579     return buffer->resource.parent;
 580 }
 581
 582 DWORD CDECL wined3d_buffer_set_priority(struct wined3d_buffer *buffer, DWORD priority)
 583 {
 584     return resource_set_priority(&buffer->resource, priority);
 585 }
 586
 587 DWORD CDECL wined3d_buffer_get_priority(const struct wined3d_buffer *buffer)
 588 {
 589     return resource_get_priority(&buffer->resource);
 590 }
 591
 592 /* The caller provides a context and binds the buffer */
 593 static void buffer_sync_apple(struct wined3d_buffer *This, DWORD flags, const struct wined3d_gl_info *gl_info)
 594 {
 595     enum wined3d_event_query_result ret;
 596
 597     /* No fencing needs to be done if the app promises not to overwrite
 598      * existing data. */
 599     if (flags & WINED3D_MAP_NOOVERWRITE)
 600         return;
 601
 602     if (flags & WINED3D_MAP_DISCARD)
 603     {
 604         GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, This->resource.size, NULL, This->buffer_object_usage));
 605         checkGLcall("glBufferDataARB\n");
 606         return;
 607     }
 608
 609     if(!This->query)
 610     {
 611         TRACE("Creating event query for buffer %p\n", This);
 612
 613         if (!wined3d_event_query_supported(gl_info))
 614         {
 615             FIXME("Event queries not supported, dropping async buffer locks.\n");
 616             goto drop_query;
 617         }
 618
 619         This->query = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This->query));
 620         if (!This->query)
 621         {
 622             ERR("Failed to allocate event query memory, dropping async buffer locks.\n");
 623             goto drop_query;
 624         }
 625
 626         /* Since we don't know about old draws a glFinish is needed once */
 627         gl_info->gl_ops.gl.p_glFinish();
 628         return;
 629     }
 630     TRACE("Synchronizing buffer %p\n", This);
 631     ret = wined3d_event_query_finish(This->query, This->resource.device);
 632     switch(ret)
 633     {
 634         case WINED3D_EVENT_QUERY_NOT_STARTED:
 635         case WINED3D_EVENT_QUERY_OK:
 636             /* All done */
 637             return;
 638
 639         case WINED3D_EVENT_QUERY_WRONG_THREAD:
 640             WARN("Cannot synchronize buffer lock due to a thread conflict\n");
 641             goto drop_query;
 642
 643         default:
 644             ERR("wined3d_event_query_finish returned %u, dropping async buffer locks\n", ret);
 645             goto drop_query;
 646     }
 647
 648 drop_query:
 649     if(This->query)
 650     {
 651         wined3d_event_query_destroy(This->query);
 652         This->query = NULL;
 653     }
 654
 655     gl_info->gl_ops.gl.p_glFinish();
 656     GL_EXTCALL(glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE));
 657     checkGLcall("glBufferParameteriAPPLE(This->buffer_type_hint, GL_BUFFER_SERIALIZED_MODIFY_APPLE, GL_TRUE)");
 658     This->flags &= ~WINED3D_BUFFER_APPLESYNC;
 659 }
 660
 661 /* The caller provides a GL context */
 662 static void buffer_direct_upload(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info, DWORD flags)
 663 {
 664     BYTE *map;
 665     UINT start = 0, len = 0;
 666
 667     /* This potentially invalidates the element array buffer binding, but the
 668      * caller always takes care of this. */
 669     GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 670     checkGLcall("glBindBufferARB");
 671     if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
 672     {
 673         GLbitfield mapflags;
 674         mapflags = GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT;
 675         if (flags & WINED3D_BUFFER_DISCARD)
 676             mapflags |= GL_MAP_INVALIDATE_BUFFER_BIT;
 677         if (flags & WINED3D_BUFFER_NOSYNC)
 678             mapflags |= GL_MAP_UNSYNCHRONIZED_BIT;
 679         map = GL_EXTCALL(glMapBufferRange(This->buffer_type_hint, 0,
 680                     This->resource.size, mapflags));
 681         checkGLcall("glMapBufferRange");
 682     }
 683     else
 684     {
 685         if (This->flags & WINED3D_BUFFER_APPLESYNC)
 686         {
 687             DWORD syncflags = 0;
 688             if (flags & WINED3D_BUFFER_DISCARD)
 689                 syncflags |= WINED3D_MAP_DISCARD;
 690             if (flags & WINED3D_BUFFER_NOSYNC)
 691                 syncflags |= WINED3D_MAP_NOOVERWRITE;
 692             buffer_sync_apple(This, syncflags, gl_info);
 693         }
 694         map = GL_EXTCALL(glMapBufferARB(This->buffer_type_hint, GL_WRITE_ONLY_ARB));
 695         checkGLcall("glMapBufferARB");
 696     }
 697     if (!map)
 698     {
 699         ERR("Failed to map opengl buffer\n");
 700         return;
 701     }
 702
 703     while (This->modified_areas)
 704     {
 705         This->modified_areas--;
 706         start = This->maps[This->modified_areas].offset;
 707         len = This->maps[This->modified_areas].size;
 708
 709         memcpy(map + start, This->resource.allocatedMemory + start, len);
 710
 711         if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
 712         {
 713             GL_EXTCALL(glFlushMappedBufferRange(This->buffer_type_hint, start, len));
 714             checkGLcall("glFlushMappedBufferRange");
 715         }
 716         else if (This->flags & WINED3D_BUFFER_FLUSH)
 717         {
 718             GL_EXTCALL(glFlushMappedBufferRangeAPPLE(This->buffer_type_hint, start, len));
 719             checkGLcall("glFlushMappedBufferRangeAPPLE");
 720         }
 721     }
 722     GL_EXTCALL(glUnmapBufferARB(This->buffer_type_hint));
 723     checkGLcall("glUnmapBufferARB");
 724 }
 725
 726 /* Do not call while under the GL lock. */
 727 void CDECL wined3d_buffer_preload(struct wined3d_buffer *buffer)
 728 {
 729     DWORD flags = buffer->flags & (WINED3D_BUFFER_NOSYNC | WINED3D_BUFFER_DISCARD);
 730     struct wined3d_device *device = buffer->resource.device;
 731     UINT start = 0, end = 0, len = 0, vertices;
 732     const struct wined3d_gl_info *gl_info;
 733     struct wined3d_context *context;
 734     BOOL decl_changed = FALSE;
 735     unsigned int i, j;
 736     BYTE *data;
 737
 738     TRACE("buffer %p.\n", buffer);
 739
 740     if (buffer->resource.map_count)
 741     {
 742         WARN("Buffer is mapped, skipping preload.\n");
 743         return;
 744     }
 745
 746     buffer->flags &= ~(WINED3D_BUFFER_NOSYNC | WINED3D_BUFFER_DISCARD);
 747
 748     if (!buffer->buffer_object)
 749     {
 750         /* TODO: Make converting independent from VBOs */
 751         if (buffer->flags & WINED3D_BUFFER_CREATEBO)
 752         {
 753             context = context_acquire(device, NULL);
 754             buffer_create_buffer_object(buffer, context->gl_info);
 755             context_release(context);
 756             buffer->flags &= ~WINED3D_BUFFER_CREATEBO;
 757         }
 758         else
 759         {
 760             /* Not doing any conversion */
 761             return;
 762         }
 763     }
 764
 765     /* Reading the declaration makes only sense if the stateblock is finalized and the buffer bound to a stream */
 766     if (device->isInDraw && buffer->resource.bind_count > 0)
 767     {
 768         decl_changed = buffer_find_decl(buffer);
 769         buffer->flags |= WINED3D_BUFFER_HASDESC;
 770     }
 771
 772     if (!decl_changed && !(buffer->flags & WINED3D_BUFFER_HASDESC && buffer_is_dirty(buffer)))
 773     {
 774         ++buffer->draw_count;
 775         if (buffer->draw_count > VB_RESETDECLCHANGE)
 776             buffer->decl_change_count = 0;
 777         if (buffer->draw_count > VB_RESETFULLCONVS)
 778             buffer->full_conversion_count = 0;
 779         return;
 780     }
 781
 782     /* If applications change the declaration over and over, reconverting all the time is a huge
 783      * performance hit. So count the declaration changes and release the VBO if there are too many
 784      * of them (and thus stop converting)
 785      */
 786     if (decl_changed)
 787     {
 788         ++buffer->decl_change_count;
 789         buffer->draw_count = 0;
 790
 791         if (buffer->decl_change_count > VB_MAXDECLCHANGES
 792                 || (buffer->conversion_map && (buffer->resource.usage & WINED3DUSAGE_DYNAMIC)))
 793         {
 794             FIXME("Too many declaration changes or converting dynamic buffer, stopping converting\n");
 795
 796             buffer_unload(&buffer->resource);
 797             buffer->flags &= ~WINED3D_BUFFER_CREATEBO;
 798
 799             /* The stream source state handler might have read the memory of
 800              * the vertex buffer already and got the memory in the vbo which
 801              * is not valid any longer. Dirtify the stream source to force a
 802              * reload. This happens only once per changed vertexbuffer and
 803              * should occur rather rarely. */
 804             device_invalidate_state(device, STATE_STREAMSRC);
 805             return;
 806         }
 807
 808         /* The declaration changed, reload the whole buffer */
 809         WARN("Reloading buffer because of decl change\n");
 810         buffer_clear_dirty_areas(buffer);
 811         if (!buffer_add_dirty_area(buffer, 0, 0))
 812         {
 813             ERR("buffer_add_dirty_area failed, this is not expected\n");
 814             return;
 815         }
 816         /* Avoid unfenced updates, we might overwrite more areas of the buffer than the application
 817          * cleared for unsynchronized updates
 818          */
 819         flags = 0;
 820     }
 821     else
 822     {
 823         /* However, it is perfectly fine to change the declaration every now and then. We don't want a game that
 824          * changes it every minute drop the VBO after VB_MAX_DECL_CHANGES minutes. So count draws without
 825          * decl changes and reset the decl change count after a specific number of them
 826          */
 827         if (buffer->conversion_map && buffer_is_fully_dirty(buffer))
 828         {
 829             ++buffer->full_conversion_count;
 830             if (buffer->full_conversion_count > VB_MAXFULLCONVERSIONS)
 831             {
 832                 FIXME("Too many full buffer conversions, stopping converting.\n");
 833                 buffer_unload(&buffer->resource);
 834                 buffer->flags &= ~WINED3D_BUFFER_CREATEBO;
 835                 if (buffer->resource.bind_count)
 836                     device_invalidate_state(device, STATE_STREAMSRC);
 837                 return;
 838             }
 839         }
 840         else
 841         {
 842             ++buffer->draw_count;
 843             if (buffer->draw_count > VB_RESETDECLCHANGE)
 844                 buffer->decl_change_count = 0;
 845             if (buffer->draw_count > VB_RESETFULLCONVS)
 846                 buffer->full_conversion_count = 0;
 847         }
 848     }
 849
 850     if (buffer->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
 851         device_invalidate_state(device, STATE_INDEXBUFFER);
 852
 853     if (!buffer->conversion_map)
 854     {
 855         /* That means that there is nothing to fixup. Just upload from
 856          * buffer->resource.allocatedMemory directly into the vbo. Do not
 857          * free the system memory copy because drawPrimitive may need it if
 858          * the stride is 0, for instancing emulation, vertex blending
 859          * emulation or shader emulation. */
 860         TRACE("No conversion needed.\n");
 861
 862         /* Nothing to do because we locked directly into the vbo */
 863         if (!(buffer->flags & WINED3D_BUFFER_DOUBLEBUFFER))
 864         {
 865             return;
 866         }
 867
 868         context = context_acquire(device, NULL);
 869         buffer_direct_upload(buffer, context->gl_info, flags);
 870
 871         context_release(context);
 872         return;
 873     }
 874
 875     context = context_acquire(device, NULL);
 876     gl_info = context->gl_info;
 877
 878     if(!(buffer->flags & WINED3D_BUFFER_DOUBLEBUFFER))
 879     {
 880         buffer_get_sysmem(buffer, gl_info);
 881     }
 882
 883     /* Now for each vertex in the buffer that needs conversion */
 884     vertices = buffer->resource.size / buffer->stride;
 885
 886     data = HeapAlloc(GetProcessHeap(), 0, buffer->resource.size);
 887
 888     while(buffer->modified_areas)
 889     {
 890         buffer->modified_areas--;
 891         start = buffer->maps[buffer->modified_areas].offset;
 892         len = buffer->maps[buffer->modified_areas].size;
 893         end = start + len;
 894
 895         memcpy(data + start, buffer->resource.allocatedMemory + start, end - start);
 896         for (i = start / buffer->stride; i < min((end / buffer->stride) + 1, vertices); ++i)
 897         {
 898             for (j = 0; j < buffer->stride; ++j)
 899             {
 900                 switch (buffer->conversion_map[j])
 901                 {
 902                     case CONV_NONE:
 903                         /* Done already */
 904                         j += 3;
 905                         break;
 906                     case CONV_D3DCOLOR:
 907                         fixup_d3dcolor((DWORD *) (data + i * buffer->stride + j));
 908                         j += 3;
 909                         break;
 910
 911                     case CONV_POSITIONT:
 912                         fixup_transformed_pos((float *) (data + i * buffer->stride + j));
 913                         j += 15;
 914                         break;
 915                     default:
 916                         FIXME("Unimplemented conversion %d in shifted conversion\n", buffer->conversion_map[j]);
 917                 }
 918             }
 919         }
 920
 921         GL_EXTCALL(glBindBufferARB(buffer->buffer_type_hint, buffer->buffer_object));
 922         checkGLcall("glBindBufferARB");
 923         GL_EXTCALL(glBufferSubDataARB(buffer->buffer_type_hint, start, len, data + start));
 924         checkGLcall("glBufferSubDataARB");
 925     }
 926
 927     HeapFree(GetProcessHeap(), 0, data);
 928     context_release(context);
 929 }
 930
 931 static DWORD buffer_sanitize_flags(const struct wined3d_buffer *buffer, DWORD flags)
 932 {
 933     /* Not all flags make sense together, but Windows never returns an error.
 934      * Catch the cases that could cause issues. */
 935     if (flags & WINED3D_MAP_READONLY)
 936     {
 937         if (flags & WINED3D_MAP_DISCARD)
 938         {
 939             WARN("WINED3D_MAP_READONLY combined with WINED3D_MAP_DISCARD, ignoring flags.\n");
 940             return 0;
 941         }
 942         if (flags & WINED3D_MAP_NOOVERWRITE)
 943         {
 944             WARN("WINED3D_MAP_READONLY combined with WINED3D_MAP_NOOVERWRITE, ignoring flags.\n");
 945             return 0;
 946         }
 947     }
 948     else if ((flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE))
 949             == (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE))
 950     {
 951         WARN("WINED3D_MAP_DISCARD and WINED3D_MAP_NOOVERWRITE used together, ignoring.\n");
 952         return 0;
 953     }
 954     else if (flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE)
 955             && !(buffer->resource.usage & WINED3DUSAGE_DYNAMIC))
 956     {
 957         WARN("DISCARD or NOOVERWRITE map on non-dynamic buffer, ignoring.\n");
 958         return 0;
 959     }
 960
 961     return flags;
 962 }
 963
 964 static GLbitfield buffer_gl_map_flags(DWORD d3d_flags)
 965 {
 966     GLbitfield ret = 0;
 967
 968     if (!(d3d_flags & WINED3D_MAP_READONLY))
 969         ret |= GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT;
 970     if (!(d3d_flags & (WINED3D_MAP_DISCARD | WINED3D_MAP_NOOVERWRITE)))
 971         ret |= GL_MAP_READ_BIT;
 972
 973     if (d3d_flags & WINED3D_MAP_DISCARD)
 974         ret |= GL_MAP_INVALIDATE_BUFFER_BIT;
 975     if (d3d_flags & WINED3D_MAP_NOOVERWRITE)
 976         ret |= GL_MAP_UNSYNCHRONIZED_BIT;
 977
 978     return ret;
 979 }
 980
 981 struct wined3d_resource * CDECL wined3d_buffer_get_resource(struct wined3d_buffer *buffer)
 982 {
 983     TRACE("buffer %p.\n", buffer);
 984
 985     return &buffer->resource;
 986 }
 987
 988 HRESULT CDECL wined3d_buffer_map(struct wined3d_buffer *buffer, UINT offset, UINT size, BYTE **data, DWORD flags)
 989 {
 990     BOOL dirty = buffer_is_dirty(buffer);
 991     LONG count;
 992
 993     TRACE("buffer %p, offset %u, size %u, data %p, flags %#x\n", buffer, offset, size, data, flags);
 994
 995     flags = buffer_sanitize_flags(buffer, flags);
 996     if (!(flags & WINED3D_MAP_READONLY))
 997     {
 998         if (flags & WINED3D_MAP_DISCARD)
 999         {
1000             /* DISCARD invalidates the entire buffer, regardless of the
1001              * specified offset and size. Some applications also depend on the
1002              * entire buffer being uploaded in that case. Two such
1003              * applications are Port Royale and Darkstar One. */
1004             if (!buffer_add_dirty_area(buffer, 0, 0))
1005                 return E_OUTOFMEMORY;
1006         }
1007         else
1008         {
1009             if (!buffer_add_dirty_area(buffer, offset, size))
1010                 return E_OUTOFMEMORY;
1011         }
1012     }
1013
1014     count = ++buffer->resource.map_count;
1015
1016     if (buffer->buffer_object)
1017     {
1018         if (!(buffer->flags & WINED3D_BUFFER_DOUBLEBUFFER))
1019         {
1020             if (count == 1)
1021             {
1022                 struct wined3d_device *device = buffer->resource.device;
1023                 struct wined3d_context *context;
1024                 const struct wined3d_gl_info *gl_info;
1025
1026                 context = context_acquire(device, NULL);
1027                 gl_info = context->gl_info;
1028
1029                 if (buffer->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
1030                     context_invalidate_state(context, STATE_INDEXBUFFER);
1031                 GL_EXTCALL(glBindBufferARB(buffer->buffer_type_hint, buffer->buffer_object));
1032
1033                 if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
1034                 {
1035                     GLbitfield mapflags = buffer_gl_map_flags(flags);
1036                     buffer->resource.allocatedMemory = GL_EXTCALL(glMapBufferRange(buffer->buffer_type_hint,
1037                             0, buffer->resource.size, mapflags));
1038                     checkGLcall("glMapBufferRange");
1039                 }
1040                 else
1041                 {
1042                     if (buffer->flags & WINED3D_BUFFER_APPLESYNC)
1043                         buffer_sync_apple(buffer, flags, gl_info);
1044                     buffer->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(buffer->buffer_type_hint,
1045                             GL_READ_WRITE_ARB));
1046                     checkGLcall("glMapBufferARB");
1047                 }
1048
1049                 if (((DWORD_PTR)buffer->resource.allocatedMemory) & (RESOURCE_ALIGNMENT - 1))
1050                 {
1051                     WARN("Pointer %p is not %u byte aligned.\n", buffer->resource.allocatedMemory, RESOURCE_ALIGNMENT);
1052
1053                     GL_EXTCALL(glUnmapBufferARB(buffer->buffer_type_hint));
1054                     checkGLcall("glUnmapBufferARB");
1055                     buffer->resource.allocatedMemory = NULL;
1056
1057                     if (buffer->resource.usage & WINED3DUSAGE_DYNAMIC)
1058                     {
1059                         /* The extra copy is more expensive than not using VBOs at
1060                          * all on the Nvidia Linux driver, which is the only driver
1061                          * that returns unaligned pointers
1062                          */
1063                         TRACE("Dynamic buffer, dropping VBO\n");
1064                         buffer_unload(&buffer->resource);
1065                         buffer->flags &= ~WINED3D_BUFFER_CREATEBO;
1066                         if (buffer->resource.bind_count)
1067                             device_invalidate_state(device, STATE_STREAMSRC);
1068                     }
1069                     else
1070                     {
1071                         TRACE("Falling back to doublebuffered operation\n");
1072                         buffer_get_sysmem(buffer, gl_info);
1073                     }
1074                     TRACE("New pointer is %p.\n", buffer->resource.allocatedMemory);
1075                 }
1076                 context_release(context);
1077             }
1078         }
1079         else
1080         {
1081             if (dirty)
1082             {
1083                 if (buffer->flags & WINED3D_BUFFER_NOSYNC && !(flags & WINED3D_MAP_NOOVERWRITE))
1084                 {
1085                     buffer->flags &= ~WINED3D_BUFFER_NOSYNC;
1086                 }
1087             }
1088             else if(flags & WINED3D_MAP_NOOVERWRITE)
1089             {
1090                 buffer->flags |= WINED3D_BUFFER_NOSYNC;
1091             }
1092
1093             if (flags & WINED3D_MAP_DISCARD)
1094             {
1095                 buffer->flags |= WINED3D_BUFFER_DISCARD;
1096             }
1097         }
1098     }
1099
1100     *data = buffer->resource.allocatedMemory + offset;
1101
1102     TRACE("Returning memory at %p (base %p, offset %u).\n", *data, buffer->resource.allocatedMemory, offset);
1103     /* TODO: check Flags compatibility with buffer->currentDesc.Usage (see MSDN) */
1104
1105     return WINED3D_OK;
1106 }
1107
1108 void CDECL wined3d_buffer_unmap(struct wined3d_buffer *buffer)
1109 {
1110     ULONG i;
1111
1112     TRACE("buffer %p.\n", buffer);
1113
1114     /* In the case that the number of Unmap calls > the
1115      * number of Map calls, d3d returns always D3D_OK.
1116      * This is also needed to prevent Map from returning garbage on
1117      * the next call (this will happen if the lock_count is < 0). */
1118     if (!buffer->resource.map_count)
1119     {
1120         WARN("Unmap called without a previous map call.\n");
1121         return;
1122     }
1123
1124     if (--buffer->resource.map_count)
1125     {
1126         /* Delay loading the buffer until everything is unlocked */
1127         TRACE("Ignoring unmap.\n");
1128         return;
1129     }
1130
1131     if (!(buffer->flags & WINED3D_BUFFER_DOUBLEBUFFER) && buffer->buffer_object)
1132     {
1133         struct wined3d_device *device = buffer->resource.device;
1134         const struct wined3d_gl_info *gl_info;
1135         struct wined3d_context *context;
1136
1137         context = context_acquire(device, NULL);
1138         gl_info = context->gl_info;
1139
1140         if (buffer->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
1141             context_invalidate_state(context, STATE_INDEXBUFFER);
1142         GL_EXTCALL(glBindBufferARB(buffer->buffer_type_hint, buffer->buffer_object));
1143
1144         if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
1145         {
1146             for (i = 0; i < buffer->modified_areas; ++i)
1147             {
1148                 GL_EXTCALL(glFlushMappedBufferRange(buffer->buffer_type_hint,
1149                         buffer->maps[i].offset, buffer->maps[i].size));
1150                 checkGLcall("glFlushMappedBufferRange");
1151             }
1152         }
1153         else if (buffer->flags & WINED3D_BUFFER_FLUSH)
1154         {
1155             for (i = 0; i < buffer->modified_areas; ++i)
1156             {
1157                 GL_EXTCALL(glFlushMappedBufferRangeAPPLE(buffer->buffer_type_hint,
1158                         buffer->maps[i].offset, buffer->maps[i].size));
1159                 checkGLcall("glFlushMappedBufferRangeAPPLE");
1160             }
1161         }
1162
1163         GL_EXTCALL(glUnmapBufferARB(buffer->buffer_type_hint));
1164         if (wined3d_settings.strict_draw_ordering)
1165             gl_info->gl_ops.gl.p_glFlush(); /* Flush to ensure ordering across contexts. */
1166         context_release(context);
1167
1168         buffer->resource.allocatedMemory = NULL;
1169         buffer_clear_dirty_areas(buffer);
1170     }
1171     else if (buffer->flags & WINED3D_BUFFER_HASDESC)
1172     {
1173         wined3d_buffer_preload(buffer);
1174     }
1175 }
1176
1177 static const struct wined3d_resource_ops buffer_resource_ops =
1178 {
1179     buffer_unload,
1180 };
1181
1182 static HRESULT buffer_init(struct wined3d_buffer *buffer, struct wined3d_device *device,
1183         UINT size, DWORD usage, enum wined3d_format_id format_id, enum wined3d_pool pool, GLenum bind_hint,
1184         const char *data, void *parent, const struct wined3d_parent_ops *parent_ops)
1185 {
1186     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1187     const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
1188     HRESULT hr;
1189     BOOL dynamic_buffer_ok;
1190
1191     if (!size)
1192     {
1193         WARN("Size 0 requested, returning WINED3DERR_INVALIDCALL\n");
1194         return WINED3DERR_INVALIDCALL;
1195     }
1196
1197     hr = resource_init(&buffer->resource, device, WINED3D_RTYPE_BUFFER, format,
1198             WINED3D_MULTISAMPLE_NONE, 0, usage, pool, size, 1, 1, size,
1199             parent, parent_ops, &buffer_resource_ops);
1200     if (FAILED(hr))
1201     {
1202         WARN("Failed to initialize resource, hr %#x\n", hr);
1203         return hr;
1204     }
1205     buffer->buffer_type_hint = bind_hint;
1206
1207     TRACE("size %#x, usage %#x, format %s, memory @ %p, iface @ %p.\n", buffer->resource.size, buffer->resource.usage,
1208             debug_d3dformat(buffer->resource.format->id), buffer->resource.allocatedMemory, buffer);
1209
1210     if (device->create_parms.flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING)
1211     {
1212         /* SWvp always returns the same pointer in buffer maps and retains data in DISCARD maps.
1213          * Keep a system memory copy of the buffer to provide the same behavior to the application.
1214          * Still use a VBO to support OpenGL 3 core contexts. */
1215         TRACE("Using doublebuffer mode because of software vertex processing\n");
1216         buffer->flags |= WINED3D_BUFFER_DOUBLEBUFFER;
1217     }
1218
1219     dynamic_buffer_ok = gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] || gl_info->supported[ARB_MAP_BUFFER_RANGE];
1220
1221     /* Observations show that drawStridedSlow is faster on dynamic VBs than converting +
1222      * drawStridedFast (half-life 2 and others).
1223      *
1224      * Basically converting the vertices in the buffer is quite expensive, and observations
1225      * show that drawStridedSlow is faster than converting + uploading + drawStridedFast.
1226      * Therefore do not create a VBO for WINED3DUSAGE_DYNAMIC buffers.
1227      */
1228     if (!gl_info->supported[ARB_VERTEX_BUFFER_OBJECT])
1229     {
1230         TRACE("Not creating a vbo because GL_ARB_vertex_buffer is not supported\n");
1231     }
1232     else if(buffer->resource.pool == WINED3D_POOL_SYSTEM_MEM)
1233     {
1234         TRACE("Not creating a vbo because the vertex buffer is in system memory\n");
1235     }
1236     else if(!dynamic_buffer_ok && (buffer->resource.usage & WINED3DUSAGE_DYNAMIC))
1237     {
1238         TRACE("Not creating a vbo because the buffer has dynamic usage and no GL support\n");
1239     }
1240     else
1241     {
1242         buffer->flags |= WINED3D_BUFFER_CREATEBO;
1243     }
1244
1245     if (data)
1246     {
1247         BYTE *ptr;
1248
1249         hr = wined3d_buffer_map(buffer, 0, size, &ptr, 0);
1250         if (FAILED(hr))
1251         {
1252             ERR("Failed to map buffer, hr %#x\n", hr);
1253             buffer_unload(&buffer->resource);
1254             resource_cleanup(&buffer->resource);
1255             return hr;
1256         }
1257
1258         memcpy(ptr, data, size);
1259
1260         wined3d_buffer_unmap(buffer);
1261     }
1262
1263     buffer->maps = HeapAlloc(GetProcessHeap(), 0, sizeof(*buffer->maps));
1264     if (!buffer->maps)
1265     {
1266         ERR("Out of memory\n");
1267         buffer_unload(&buffer->resource);
1268         resource_cleanup(&buffer->resource);
1269         return E_OUTOFMEMORY;
1270     }
1271     buffer->maps_size = 1;
1272
1273     return WINED3D_OK;
1274 }
1275
1276 HRESULT CDECL wined3d_buffer_create(struct wined3d_device *device, struct wined3d_buffer_desc *desc, const void *data,
1277         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_buffer **buffer)
1278 {
1279     struct wined3d_buffer *object;
1280     HRESULT hr;
1281
1282     TRACE("device %p, desc %p, data %p, parent %p, buffer %p\n", device, desc, data, parent, buffer);
1283
1284     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1285     if (!object)
1286     {
1287         ERR("Failed to allocate memory\n");
1288         return E_OUTOFMEMORY;
1289     }
1290
1291     FIXME("Ignoring access flags (pool)\n");
1292
1293     hr = buffer_init(object, device, desc->byte_width, desc->usage, WINED3DFMT_UNKNOWN,
1294             WINED3D_POOL_MANAGED, GL_ARRAY_BUFFER_ARB, data, parent, parent_ops);
1295     if (FAILED(hr))
1296     {
1297         WARN("Failed to initialize buffer, hr %#x.\n", hr);
1298         HeapFree(GetProcessHeap(), 0, object);
1299         return hr;
1300     }
1301     object->desc = *desc;
1302
1303     TRACE("Created buffer %p.\n", object);
1304
1305     *buffer = object;
1306
1307     return WINED3D_OK;
1308 }
1309
1310 HRESULT CDECL wined3d_buffer_create_vb(struct wined3d_device *device, UINT size, DWORD usage, enum wined3d_pool pool,
1311         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_buffer **buffer)
1312 {
1313     struct wined3d_buffer *object;
1314     HRESULT hr;
1315
1316     TRACE("device %p, size %u, usage %#x, pool %#x, parent %p, parent_ops %p, buffer %p.\n",
1317             device, size, usage, pool, parent, parent_ops, buffer);
1318
1319     if (pool == WINED3D_POOL_SCRATCH)
1320     {
1321         /* The d3d9 tests shows that this is not allowed. It doesn't make much
1322          * sense anyway, SCRATCH buffers wouldn't be usable anywhere. */
1323         WARN("Vertex buffer in WINED3D_POOL_SCRATCH requested, returning WINED3DERR_INVALIDCALL.\n");
1324         *buffer = NULL;
1325         return WINED3DERR_INVALIDCALL;
1326     }
1327
1328     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1329     if (!object)
1330     {
1331         ERR("Out of memory\n");
1332         *buffer = NULL;
1333         return WINED3DERR_OUTOFVIDEOMEMORY;
1334     }
1335
1336     hr = buffer_init(object, device, size, usage, WINED3DFMT_VERTEXDATA,
1337             pool, GL_ARRAY_BUFFER_ARB, NULL, parent, parent_ops);
1338     if (FAILED(hr))
1339     {
1340         WARN("Failed to initialize buffer, hr %#x.\n", hr);
1341         HeapFree(GetProcessHeap(), 0, object);
1342         return hr;
1343     }
1344
1345     TRACE("Created buffer %p.\n", object);
1346     *buffer = object;
1347
1348     return WINED3D_OK;
1349 }
1350
1351 HRESULT CDECL wined3d_buffer_create_ib(struct wined3d_device *device, UINT size, DWORD usage, enum wined3d_pool pool,
1352         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_buffer **buffer)
1353 {
1354     struct wined3d_buffer *object;
1355     HRESULT hr;
1356
1357     TRACE("device %p, size %u, usage %#x, pool %#x, parent %p, parent_ops %p, buffer %p.\n",
1358             device, size, usage, pool, parent, parent_ops, buffer);
1359
1360     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1361     if (!object)
1362     {
1363         ERR("Out of memory\n");
1364         *buffer = NULL;
1365         return WINED3DERR_OUTOFVIDEOMEMORY;
1366     }
1367
1368     hr = buffer_init(object, device, size, usage | WINED3DUSAGE_STATICDECL,
1369             WINED3DFMT_UNKNOWN, pool, GL_ELEMENT_ARRAY_BUFFER_ARB, NULL,
1370             parent, parent_ops);
1371     if (FAILED(hr))
1372     {
1373         WARN("Failed to initialize buffer, hr %#x\n", hr);
1374         HeapFree(GetProcessHeap(), 0, object);
1375         return hr;
1376     }
1377
1378     TRACE("Created buffer %p.\n", object);
1379     *buffer = object;
1380
1381     return WINED3D_OK;
1382 }