reactos/dll/directx/wine/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 Stefan Dösinger for CodeWeavers
   7  * Copyright 2009 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 GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
  33
  34 #define VB_MAXDECLCHANGES     100     /* After that number we stop converting */
  35 #define VB_RESETDECLCHANGE    1000    /* Reset the changecount after that number of draws */
  36
  37 static void buffer_create_buffer_object(struct wined3d_buffer *This)
  38 {
  39     GLenum error, gl_usage;
  40     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
  41
  42     TRACE("Creating an OpenGL vertex buffer object for IWineD3DVertexBuffer %p Usage(%s)\n",
  43             This, debug_d3dusage(This->resource.usage));
  44
  45     /* Make sure that a context is there. Needed in a multithreaded environment. Otherwise this call is a nop */
  46     ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
  47     ENTER_GL();
  48
  49     /* Make sure that the gl error is cleared. Do not use checkGLcall
  50     * here because checkGLcall just prints a fixme and continues. However,
  51     * if an error during VBO creation occurs we can fall back to non-vbo operation
  52     * with full functionality(but performance loss)
  53     */
  54     while (glGetError() != GL_NO_ERROR);
  55
  56     /* Basically the FVF parameter passed to CreateVertexBuffer is no good
  57      * It is the FVF set with IWineD3DDevice::SetFVF or the Vertex Declaration set with
  58      * IWineD3DDevice::SetVertexDeclaration that decides how the vertices in the buffer
  59      * look like. This means that on each DrawPrimitive call the vertex buffer has to be verified
  60      * to check if the rhw and color values are in the correct format.
  61      */
  62
  63     GL_EXTCALL(glGenBuffersARB(1, &This->buffer_object));
  64     error = glGetError();
  65     if (!This->buffer_object || error != GL_NO_ERROR)
  66     {
  67         ERR("Failed to create a VBO with error %s (%#x)\n", debug_glerror(error), error);
  68         goto fail;
  69     }
  70
  71     if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
  72     {
  73         IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
  74     }
  75     GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
  76     error = glGetError();
  77     if (error != GL_NO_ERROR)
  78     {
  79         ERR("Failed to bind the VBO with error %s (%#x)\n", debug_glerror(error), error);
  80         goto fail;
  81     }
  82
  83     /* Don't use static, because dx apps tend to update the buffer
  84     * quite often even if they specify 0 usage. Because we always keep the local copy
  85     * we never read from the vbo and can create a write only opengl buffer.
  86     */
  87     switch(This->resource.usage & (WINED3DUSAGE_WRITEONLY | WINED3DUSAGE_DYNAMIC))
  88     {
  89         case WINED3DUSAGE_WRITEONLY | WINED3DUSAGE_DYNAMIC:
  90         case WINED3DUSAGE_DYNAMIC:
  91             TRACE("Gl usage = GL_STREAM_DRAW\n");
  92             gl_usage = GL_STREAM_DRAW_ARB;
  93             break;
  94
  95         case WINED3DUSAGE_WRITEONLY:
  96         default:
  97             TRACE("Gl usage = GL_DYNAMIC_DRAW\n");
  98             gl_usage = GL_DYNAMIC_DRAW_ARB;
  99             break;
 100     }
 101
 102     /* Reserve memory for the buffer. The amount of data won't change
 103      * so we are safe with calling glBufferData once and
 104      * calling glBufferSubData on updates. Upload the actual data in case
 105      * we're not double buffering, so we can release the heap mem afterwards
 106      */
 107     GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, This->resource.size, This->resource.allocatedMemory, gl_usage));
 108     error = glGetError();
 109     if (error != GL_NO_ERROR)
 110     {
 111         ERR("glBufferDataARB failed with error %s (%#x)\n", debug_glerror(error), error);
 112         goto fail;
 113     }
 114
 115     LEAVE_GL();
 116
 117     This->buffer_object_size = This->resource.size;
 118     This->buffer_object_usage = gl_usage;
 119     This->dirty_start = 0;
 120     This->dirty_end = This->resource.size;
 121
 122     if(This->flags & WINED3D_BUFFER_DOUBLEBUFFER)
 123     {
 124         This->flags |= WINED3D_BUFFER_DIRTY;
 125     }
 126     else
 127     {
 128         HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
 129         This->resource.allocatedMemory = NULL;
 130         This->resource.heapMemory = NULL;
 131         This->flags &= ~WINED3D_BUFFER_DIRTY;
 132     }
 133
 134     return;
 135
 136 fail:
 137     /* Clean up all vbo init, but continue because we can work without a vbo :-) */
 138     ERR("Failed to create a vertex buffer object. Continuing, but performance issues may occur\n");
 139     if (This->buffer_object) GL_EXTCALL(glDeleteBuffersARB(1, &This->buffer_object));
 140     This->buffer_object = 0;
 141     LEAVE_GL();
 142
 143     return;
 144 }
 145
 146 static BOOL buffer_process_converted_attribute(struct wined3d_buffer *This,
 147         const enum wined3d_buffer_conversion_type conversion_type,
 148         const struct wined3d_stream_info_element *attrib, DWORD *stride_this_run)
 149 {
 150     DWORD attrib_size;
 151     BOOL ret = FALSE;
 152     unsigned int i;
 153     DWORD offset = This->resource.wineD3DDevice->stateBlock->streamOffset[attrib->stream_idx];
 154     DWORD_PTR data;
 155
 156     /* Check for some valid situations which cause us pain. One is if the buffer is used for
 157      * constant attributes(stride = 0), the other one is if the buffer is used on two streams
 158      * with different strides. In the 2nd case we might have to drop conversion entirely,
 159      * it is possible that the same bytes are once read as FLOAT2 and once as UBYTE4N.
 160      */
 161     if (!attrib->stride)
 162     {
 163         FIXME("%s used with stride 0, let's hope we get the vertex stride from somewhere else\n",
 164                 debug_d3dformat(attrib->format_desc->format));
 165     }
 166     else if(attrib->stride != *stride_this_run && *stride_this_run)
 167     {
 168         FIXME("Got two concurrent strides, %d and %d\n", attrib->stride, *stride_this_run);
 169     }
 170     else
 171     {
 172         *stride_this_run = attrib->stride;
 173         if (This->stride != *stride_this_run)
 174         {
 175             /* We rely that this happens only on the first converted attribute that is found,
 176              * if at all. See above check
 177              */
 178             TRACE("Reconverting because converted attributes occur, and the stride changed\n");
 179             This->stride = *stride_this_run;
 180             HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, This->conversion_map);
 181             This->conversion_map = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 182                     sizeof(*This->conversion_map) * This->stride);
 183             ret = TRUE;
 184         }
 185     }
 186
 187     data = (((DWORD_PTR)attrib->data) + offset) % This->stride;
 188     attrib_size = attrib->format_desc->component_count * attrib->format_desc->component_size;
 189     for (i = 0; i < attrib_size; ++i)
 190     {
 191         if (This->conversion_map[data + i] != conversion_type)
 192         {
 193             TRACE("Byte %ld in vertex changed\n", i + data);
 194             TRACE("It was type %d, is %d now\n", This->conversion_map[data + i], conversion_type);
 195             ret = TRUE;
 196             This->conversion_map[data + i] = conversion_type;
 197         }
 198     }
 199
 200     return ret;
 201 }
 202
 203 static BOOL buffer_check_attribute(struct wined3d_buffer *This,
 204         const struct wined3d_stream_info_element *attrib, const BOOL check_d3dcolor, const BOOL is_ffp_position,
 205         const BOOL is_ffp_color, DWORD *stride_this_run, BOOL *float16_used)
 206 {
 207     BOOL ret = FALSE;
 208     WINED3DFORMAT format;
 209
 210     /* Ignore attributes that do not have our vbo. After that check we can be sure that the attribute is
 211      * there, on nonexistent attribs the vbo is 0.
 212      */
 213     if (attrib->buffer_object != This->buffer_object) return FALSE;
 214
 215     format = attrib->format_desc->format;
 216     /* Look for newly appeared conversion */
 217     if (!GL_SUPPORT(NV_HALF_FLOAT) && (format == WINED3DFMT_R16G16_FLOAT || format == WINED3DFMT_R16G16B16A16_FLOAT))
 218     {
 219         ret = buffer_process_converted_attribute(This, CONV_FLOAT16_2, attrib, stride_this_run);
 220
 221         if (is_ffp_position) FIXME("Test FLOAT16 fixed function processing positions\n");
 222         else if (is_ffp_color) FIXME("test FLOAT16 fixed function processing colors\n");
 223         *float16_used = TRUE;
 224     }
 225     else if (check_d3dcolor && format == WINED3DFMT_A8R8G8B8)
 226     {
 227         ret = buffer_process_converted_attribute(This, CONV_D3DCOLOR, attrib, stride_this_run);
 228
 229         if (!is_ffp_color) FIXME("Test for non-color fixed function WINED3DFMT_A8R8G8B8 format\n");
 230     }
 231     else if (is_ffp_position && format == WINED3DFMT_R32G32B32A32_FLOAT)
 232     {
 233         ret = buffer_process_converted_attribute(This, CONV_POSITIONT, attrib, stride_this_run);
 234     }
 235     else if (This->conversion_map)
 236     {
 237         ret = buffer_process_converted_attribute(This, CONV_NONE, attrib, stride_this_run);
 238     }
 239
 240     return ret;
 241 }
 242
 243 static UINT *find_conversion_shift(struct wined3d_buffer *This,
 244         const struct wined3d_stream_info *strided, UINT stride)
 245 {
 246     UINT *ret, i, j, shift, orig_type_size;
 247
 248     if (!stride)
 249     {
 250         TRACE("No shift\n");
 251         return NULL;
 252     }
 253
 254     This->conversion_stride = stride;
 255     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DWORD) * stride);
 256     for (i = 0; i < MAX_ATTRIBS; ++i)
 257     {
 258         WINED3DFORMAT format;
 259
 260         if (strided->elements[i].buffer_object != This->buffer_object) continue;
 261
 262         format = strided->elements[i].format_desc->format;
 263         if (format == WINED3DFMT_R16G16_FLOAT)
 264         {
 265             shift = 4;
 266         }
 267         else if (format == WINED3DFMT_R16G16B16A16_FLOAT)
 268         {
 269             shift = 8;
 270             /* Pre-shift the last 4 bytes in the FLOAT16_4 by 4 bytes - this makes FLOAT16_2 and FLOAT16_4 conversions
 271              * compatible
 272              */
 273             for (j = 4; j < 8; ++j)
 274             {
 275                 ret[(DWORD_PTR)strided->elements[i].data + j] += 4;
 276             }
 277         }
 278         else
 279         {
 280             shift = 0;
 281         }
 282         This->conversion_stride += shift;
 283
 284         if (shift)
 285         {
 286             orig_type_size = strided->elements[i].format_desc->component_count
 287                     * strided->elements[i].format_desc->component_size;
 288             for (j = (DWORD_PTR)strided->elements[i].data + orig_type_size; j < stride; ++j)
 289             {
 290                 ret[j] += shift;
 291             }
 292         }
 293     }
 294
 295     if (TRACE_ON(d3d))
 296     {
 297         TRACE("Dumping conversion shift:\n");
 298         for (i = 0; i < stride; ++i)
 299         {
 300             TRACE("[%d]", ret[i]);
 301         }
 302         TRACE("\n");
 303     }
 304
 305     return ret;
 306 }
 307
 308 static BOOL buffer_find_decl(struct wined3d_buffer *This)
 309 {
 310     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
 311     UINT stride_this_run = 0;
 312     BOOL float16_used = FALSE;
 313     BOOL ret = FALSE;
 314     unsigned int i;
 315
 316     /* In d3d7 the vertex buffer declaration NEVER changes because it is stored in the d3d7 vertex buffer.
 317      * Once we have our declaration there is no need to look it up again. Index buffers also never need
 318      * conversion, so once the (empty) conversion structure is created don't bother checking again
 319      */
 320     if (This->flags & WINED3D_BUFFER_HASDESC)
 321     {
 322         if(((IWineD3DImpl *)device->wineD3D)->dxVersion == 7 ||
 323              This->resource.format_desc->format != WINED3DFMT_VERTEXDATA) return FALSE;
 324     }
 325
 326     TRACE("Finding vertex buffer conversion information\n");
 327     /* Certain declaration types need some fixups before we can pass them to
 328      * opengl. This means D3DCOLOR attributes with fixed function vertex
 329      * processing, FLOAT4 POSITIONT with fixed function, and FLOAT16 if
 330      * GL_NV_half_float is not supported.
 331      *
 332      * Note for d3d8 and d3d9:
 333      * The vertex buffer FVF doesn't help with finding them, we have to use
 334      * the decoded vertex declaration and pick the things that concern the
 335      * current buffer. A problem with this is that this can change between
 336      * draws, so we have to validate the information and reprocess the buffer
 337      * if it changes, and avoid false positives for performance reasons.
 338      * WineD3D doesn't even know the vertex buffer any more, it is managed
 339      * by the client libraries and passed to SetStreamSource and ProcessVertices
 340      * as needed.
 341      *
 342      * We have to distinguish between vertex shaders and fixed function to
 343      * pick the way we access the strided vertex information.
 344      *
 345      * This code sets up a per-byte array with the size of the detected
 346      * stride of the arrays in the buffer. For each byte we have a field
 347      * that marks the conversion needed on this byte. For example, the
 348      * following declaration with fixed function vertex processing:
 349      *
 350      *      POSITIONT, FLOAT4
 351      *      NORMAL, FLOAT3
 352      *      DIFFUSE, FLOAT16_4
 353      *      SPECULAR, D3DCOLOR
 354      *
 355      * Will result in
 356      * {                 POSITIONT                    }{             NORMAL                }{    DIFFUSE          }{SPECULAR }
 357      * [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]
 358      *
 359      * Where in this example map P means 4 component position conversion, 0
 360      * means no conversion, F means FLOAT16_2 conversion and C means D3DCOLOR
 361      * conversion (red / blue swizzle).
 362      *
 363      * If we're doing conversion and the stride changes we have to reconvert
 364      * the whole buffer. Note that we do not mind if the semantic changes,
 365      * we only care for the conversion type. So if the NORMAL is replaced
 366      * with a TEXCOORD, nothing has to be done, or if the DIFFUSE is replaced
 367      * with a D3DCOLOR BLENDWEIGHT we can happily dismiss the change. Some
 368      * conversion types depend on the semantic as well, for example a FLOAT4
 369      * texcoord needs no conversion while a FLOAT4 positiont needs one
 370      */
 371     if (use_vs(device->stateBlock))
 372     {
 373         TRACE("vshader\n");
 374         /* If the current vertex declaration is marked for no half float conversion don't bother to
 375          * analyse the strided streams in depth, just set them up for no conversion. Return decl changed
 376          * if we used conversion before
 377          */
 378         if (!((IWineD3DVertexDeclarationImpl *) device->stateBlock->vertexDecl)->half_float_conv_needed)
 379         {
 380             if (This->conversion_map)
 381             {
 382                 TRACE("Now using shaders without conversion, but conversion used before\n");
 383                 HeapFree(GetProcessHeap(), 0, This->conversion_map);
 384                 HeapFree(GetProcessHeap(), 0, This->conversion_shift);
 385                 This->conversion_map = NULL;
 386                 This->stride = 0;
 387                 This->conversion_shift = NULL;
 388                 This->conversion_stride = 0;
 389                 return TRUE;
 390             }
 391             else
 392             {
 393                 return FALSE;
 394             }
 395         }
 396         for (i = 0; i < MAX_ATTRIBS; ++i)
 397         {
 398             ret = buffer_check_attribute(This, &device->strided_streams.elements[i],
 399                     FALSE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 400         }
 401
 402         /* Recalculate the conversion shift map if the declaration has changed,
 403          * and we're using float16 conversion or used it on the last run
 404          */
 405         if (ret && (float16_used || This->conversion_map))
 406         {
 407             HeapFree(GetProcessHeap(), 0, This->conversion_shift);
 408             This->conversion_shift = find_conversion_shift(This, &device->strided_streams, This->stride);
 409         }
 410     }
 411     else
 412     {
 413         /* Fixed function is a bit trickier. We have to take care for D3DCOLOR types, FLOAT4 positions and of course
 414          * FLOAT16s if not supported. Also, we can't iterate over the array, so use macros to generate code for all
 415          * the attributes that our current fixed function pipeline implementation cares for.
 416          */
 417         BOOL support_d3dcolor = GL_SUPPORT(EXT_VERTEX_ARRAY_BGRA);
 418         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_POSITION],
 419                 TRUE, TRUE,  FALSE, &stride_this_run, &float16_used) || ret;
 420         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_NORMAL],
 421                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 422         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_DIFFUSE],
 423                 !support_d3dcolor, FALSE, TRUE,  &stride_this_run, &float16_used) || ret;
 424         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_SPECULAR],
 425                 !support_d3dcolor, FALSE, TRUE,  &stride_this_run, &float16_used) || ret;
 426         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_TEXCOORD0],
 427                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 428         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_TEXCOORD1],
 429                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 430         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_TEXCOORD2],
 431                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 432         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_TEXCOORD3],
 433                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 434         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_TEXCOORD4],
 435                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 436         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_TEXCOORD5],
 437                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 438         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_TEXCOORD6],
 439                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 440         ret = buffer_check_attribute(This, &device->strided_streams.elements[WINED3D_FFP_TEXCOORD7],
 441                 TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret;
 442
 443         if (float16_used) FIXME("Float16 conversion used with fixed function vertex processing\n");
 444     }
 445
 446     if (stride_this_run == 0 && This->conversion_map)
 447     {
 448         /* Sanity test */
 449         if (!ret) ERR("no converted attributes found, old conversion map exists, and no declaration change?\n");
 450         HeapFree(GetProcessHeap(), 0, This->conversion_map);
 451         This->conversion_map = NULL;
 452         This->stride = 0;
 453     }
 454
 455     if (ret) TRACE("Conversion information changed\n");
 456
 457     return ret;
 458 }
 459
 460 static void buffer_check_buffer_object_size(struct wined3d_buffer *This)
 461 {
 462     UINT size = This->conversion_stride ?
 463             This->conversion_stride * (This->resource.size / This->stride) : This->resource.size;
 464     if (This->buffer_object_size != size)
 465     {
 466         TRACE("Old size %u, creating new size %u\n", This->buffer_object_size, size);
 467
 468         if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
 469         {
 470             IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
 471         }
 472
 473         /* Rescue the data before resizing the buffer object if we do not have our backup copy */
 474         if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
 475         {
 476             buffer_get_sysmem(This);
 477         }
 478
 479         ENTER_GL();
 480         GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 481         checkGLcall("glBindBufferARB");
 482         GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, size, NULL, This->buffer_object_usage));
 483         This->buffer_object_size = size;
 484         checkGLcall("glBufferDataARB");
 485         LEAVE_GL();
 486     }
 487 }
 488
 489 static inline void fixup_d3dcolor(DWORD *dst_color)
 490 {
 491     DWORD src_color = *dst_color;
 492
 493     /* Color conversion like in drawStridedSlow. watch out for little endianity
 494      * If we want that stuff to work on big endian machines too we have to consider more things
 495      *
 496      * 0xff000000: Alpha mask
 497      * 0x00ff0000: Blue mask
 498      * 0x0000ff00: Green mask
 499      * 0x000000ff: Red mask
 500      */
 501     *dst_color = 0;
 502     *dst_color |= (src_color & 0xff00ff00);         /* Alpha Green */
 503     *dst_color |= (src_color & 0x00ff0000) >> 16;   /* Red */
 504     *dst_color |= (src_color & 0x000000ff) << 16;   /* Blue */
 505 }
 506
 507 static inline void fixup_transformed_pos(float *p)
 508 {
 509     float x, y, z, w;
 510
 511     /* rhw conversion like in drawStridedSlow */
 512     if (p[3] == 1.0 || ((p[3] < eps) && (p[3] > -eps)))
 513     {
 514         x = p[0];
 515         y = p[1];
 516         z = p[2];
 517         w = 1.0;
 518     }
 519     else
 520     {
 521         w = 1.0 / p[3];
 522         x = p[0] * w;
 523         y = p[1] * w;
 524         z = p[2] * w;
 525     }
 526     p[0] = x;
 527     p[1] = y;
 528     p[2] = z;
 529     p[3] = w;
 530 }
 531
 532 const BYTE *buffer_get_memory(IWineD3DBuffer *iface, UINT offset, GLuint *buffer_object)
 533 {
 534     struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
 535
 536     *buffer_object = This->buffer_object;
 537     if (!This->buffer_object)
 538     {
 539         if (This->flags & WINED3D_BUFFER_CREATEBO)
 540         {
 541             buffer_create_buffer_object(This);
 542             This->flags &= ~WINED3D_BUFFER_CREATEBO;
 543             if (This->buffer_object)
 544             {
 545                 *buffer_object = This->buffer_object;
 546                 return (const BYTE *)offset;
 547             }
 548         }
 549         return This->resource.allocatedMemory + offset;
 550     }
 551     else
 552     {
 553         return (const BYTE *)offset;
 554     }
 555 }
 556
 557 /* IUnknown methods */
 558
 559 static HRESULT STDMETHODCALLTYPE buffer_QueryInterface(IWineD3DBuffer *iface,
 560         REFIID riid, void **object)
 561 {
 562     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 563
 564     if (IsEqualGUID(riid, &IID_IWineD3DBuffer)
 565             || IsEqualGUID(riid, &IID_IWineD3DResource)
 566             || IsEqualGUID(riid, &IID_IWineD3DBase)
 567             || IsEqualGUID(riid, &IID_IUnknown))
 568     {
 569         IUnknown_AddRef(iface);
 570         *object = iface;
 571         return S_OK;
 572     }
 573
 574     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 575
 576     *object = NULL;
 577
 578     return E_NOINTERFACE;
 579 }
 580
 581 static ULONG STDMETHODCALLTYPE buffer_AddRef(IWineD3DBuffer *iface)
 582 {
 583     struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
 584     ULONG refcount = InterlockedIncrement(&This->resource.ref);
 585
 586     TRACE("%p increasing refcount to %u\n", This, refcount);
 587
 588     return refcount;
 589 }
 590
 591 const BYTE *buffer_get_sysmem(struct wined3d_buffer *This)
 592 {
 593     if(This->flags & WINED3D_BUFFER_DOUBLEBUFFER) return This->resource.allocatedMemory;
 594
 595     This->resource.heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->resource.size + RESOURCE_ALIGNMENT);
 596     This->resource.allocatedMemory = (BYTE *)(((ULONG_PTR)This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
 597     ENTER_GL();
 598     GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 599     GL_EXTCALL(glGetBufferSubDataARB(This->buffer_type_hint, 0, This->resource.size, This->resource.allocatedMemory));
 600     LEAVE_GL();
 601     This->flags |= WINED3D_BUFFER_DOUBLEBUFFER;
 602
 603     return This->resource.allocatedMemory;
 604 }
 605
 606 static void STDMETHODCALLTYPE buffer_UnLoad(IWineD3DBuffer *iface)
 607 {
 608     struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
 609
 610     TRACE("iface %p\n", iface);
 611
 612     if (This->buffer_object)
 613     {
 614         IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
 615
 616         ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 617
 618         /* Download the buffer, but don't permanently enable double buffering */
 619         if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
 620         {
 621             buffer_get_sysmem(This);
 622             This->flags &= ~WINED3D_BUFFER_DOUBLEBUFFER;
 623         }
 624
 625         ENTER_GL();
 626         GL_EXTCALL(glDeleteBuffersARB(1, &This->buffer_object));
 627         checkGLcall("glDeleteBuffersARB");
 628         LEAVE_GL();
 629         This->buffer_object = 0;
 630         This->flags |= WINED3D_BUFFER_CREATEBO; /* Recreate the buffer object next load */
 631     }
 632 }
 633
 634 static ULONG STDMETHODCALLTYPE buffer_Release(IWineD3DBuffer *iface)
 635 {
 636     struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
 637     ULONG refcount = InterlockedDecrement(&This->resource.ref);
 638
 639     TRACE("%p decreasing refcount to %u\n", This, refcount);
 640
 641     if (!refcount)
 642     {
 643         buffer_UnLoad(iface);
 644         resource_cleanup((IWineD3DResource *)iface);
 645         HeapFree(GetProcessHeap(), 0, This);
 646     }
 647
 648     return refcount;
 649 }
 650
 651 /* IWineD3DBase methods */
 652
 653 static HRESULT STDMETHODCALLTYPE buffer_GetParent(IWineD3DBuffer *iface, IUnknown **parent)
 654 {
 655     return resource_get_parent((IWineD3DResource *)iface, parent);
 656 }
 657
 658 /* IWineD3DResource methods */
 659
 660 static HRESULT STDMETHODCALLTYPE buffer_GetDevice(IWineD3DBuffer *iface, IWineD3DDevice **device)
 661 {
 662     return resource_get_device((IWineD3DResource *)iface, device);
 663 }
 664
 665 static HRESULT STDMETHODCALLTYPE buffer_SetPrivateData(IWineD3DBuffer *iface,
 666         REFGUID guid, const void *data, DWORD data_size, DWORD flags)
 667 {
 668     return resource_set_private_data((IWineD3DResource *)iface, guid, data, data_size, flags);
 669 }
 670
 671 static HRESULT STDMETHODCALLTYPE buffer_GetPrivateData(IWineD3DBuffer *iface,
 672         REFGUID guid, void *data, DWORD *data_size)
 673 {
 674     return resource_get_private_data((IWineD3DResource *)iface, guid, data, data_size);
 675 }
 676
 677 static HRESULT STDMETHODCALLTYPE buffer_FreePrivateData(IWineD3DBuffer *iface, REFGUID guid)
 678 {
 679     return resource_free_private_data((IWineD3DResource *)iface, guid);
 680 }
 681
 682 static DWORD STDMETHODCALLTYPE buffer_SetPriority(IWineD3DBuffer *iface, DWORD priority)
 683 {
 684     return resource_set_priority((IWineD3DResource *)iface, priority);
 685 }
 686
 687 static DWORD STDMETHODCALLTYPE buffer_GetPriority(IWineD3DBuffer *iface)
 688 {
 689     return resource_get_priority((IWineD3DResource *)iface);
 690 }
 691
 692 static void STDMETHODCALLTYPE buffer_PreLoad(IWineD3DBuffer *iface)
 693 {
 694     struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
 695     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
 696     UINT start = 0, end = 0, vertices;
 697     BOOL decl_changed = FALSE;
 698     unsigned int i, j;
 699     BYTE *data;
 700
 701     TRACE("iface %p\n", iface);
 702
 703     if (!This->buffer_object)
 704     {
 705         /* TODO: Make converting independent from VBOs */
 706         if (This->flags & WINED3D_BUFFER_CREATEBO)
 707         {
 708             buffer_create_buffer_object(This);
 709             This->flags &= ~WINED3D_BUFFER_CREATEBO;
 710         }
 711         else
 712         {
 713             return; /* Not doing any conversion */
 714         }
 715     }
 716
 717     /* Reading the declaration makes only sense if the stateblock is finalized and the buffer bound to a stream */
 718     if (device->isInDraw && This->bind_count > 0)
 719     {
 720         decl_changed = buffer_find_decl(This);
 721         This->flags |= WINED3D_BUFFER_HASDESC;
 722     }
 723
 724     if (!decl_changed && !(This->flags & WINED3D_BUFFER_HASDESC && This->flags & WINED3D_BUFFER_DIRTY)) return;
 725
 726     /* If applications change the declaration over and over, reconverting all the time is a huge
 727      * performance hit. So count the declaration changes and release the VBO if there are too many
 728      * of them (and thus stop converting)
 729      */
 730     if (decl_changed)
 731     {
 732         ++This->conversion_count;
 733         This->draw_count = 0;
 734
 735         if (This->conversion_count > VB_MAXDECLCHANGES)
 736         {
 737             FIXME("Too many declaration changes, stopping converting\n");
 738             ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 739             ENTER_GL();
 740             GL_EXTCALL(glDeleteBuffersARB(1, &This->buffer_object));
 741             checkGLcall("glDeleteBuffersARB");
 742             LEAVE_GL();
 743             This->buffer_object = 0;
 744             HeapFree(GetProcessHeap(), 0, This->conversion_shift);
 745
 746             /* The stream source state handler might have read the memory of the vertex buffer already
 747              * and got the memory in the vbo which is not valid any longer. Dirtify the stream source
 748              * to force a reload. This happens only once per changed vertexbuffer and should occur rather
 749              * rarely
 750              */
 751             IWineD3DDeviceImpl_MarkStateDirty(device, STATE_STREAMSRC);
 752
 753             return;
 754         }
 755         buffer_check_buffer_object_size(This);
 756     }
 757     else
 758     {
 759         /* However, it is perfectly fine to change the declaration every now and then. We don't want a game that
 760          * changes it every minute drop the VBO after VB_MAX_DECL_CHANGES minutes. So count draws without
 761          * decl changes and reset the decl change count after a specific number of them
 762          */
 763         ++This->draw_count;
 764         if (This->draw_count > VB_RESETDECLCHANGE) This->conversion_count = 0;
 765     }
 766
 767     if (decl_changed)
 768     {
 769         /* The declaration changed, reload the whole buffer */
 770         WARN("Reloading buffer because of decl change\n");
 771         start = 0;
 772         end = This->resource.size;
 773     }
 774     else
 775     {
 776         /* No decl change, but dirty data, reload the changed stuff */
 777         if (This->conversion_shift)
 778         {
 779             if (This->dirty_start != 0 || This->dirty_end != 0)
 780             {
 781                 FIXME("Implement partial buffer loading with shifted conversion\n");
 782             }
 783         }
 784         start = This->dirty_start;
 785         end = This->dirty_end;
 786     }
 787
 788     /* Mark the buffer clean */
 789     This->flags &= ~WINED3D_BUFFER_DIRTY;
 790     This->dirty_start = 0;
 791     This->dirty_end = 0;
 792
 793     if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
 794     {
 795         IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
 796     }
 797
 798     if (!This->conversion_map)
 799     {
 800         /* That means that there is nothing to fixup. Just upload from This->resource.allocatedMemory
 801          * directly into the vbo. Do not free the system memory copy because drawPrimitive may need it if
 802          * the stride is 0, for instancing emulation, vertex blending emulation or shader emulation.
 803          */
 804         TRACE("No conversion needed\n");
 805
 806         /* Nothing to do because we locked directly into the vbo */
 807         if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER)) return;
 808
 809         if (!device->isInDraw)
 810         {
 811             ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 812         }
 813         ENTER_GL();
 814         GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 815         checkGLcall("glBindBufferARB");
 816         GL_EXTCALL(glBufferSubDataARB(This->buffer_type_hint, start, end-start, This->resource.allocatedMemory + start));
 817         checkGLcall("glBufferSubDataARB");
 818         LEAVE_GL();
 819         return;
 820     }
 821
 822     if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER))
 823     {
 824         buffer_get_sysmem(This);
 825     }
 826
 827     /* Now for each vertex in the buffer that needs conversion */
 828     vertices = This->resource.size / This->stride;
 829
 830     if (This->conversion_shift)
 831     {
 832         TRACE("Shifted conversion\n");
 833         data = HeapAlloc(GetProcessHeap(), 0, vertices * This->conversion_stride);
 834
 835         for (i = start / This->stride; i < min((end / This->stride) + 1, vertices); ++i)
 836         {
 837             for (j = 0; j < This->stride; ++j)
 838             {
 839                 switch(This->conversion_map[j])
 840                 {
 841                     case CONV_NONE:
 842                         data[This->conversion_stride * i + j + This->conversion_shift[j]]
 843                                 = This->resource.allocatedMemory[This->stride * i + j];
 844                         break;
 845
 846                     case CONV_FLOAT16_2:
 847                     {
 848                         float *out = (float *)(&data[This->conversion_stride * i + j + This->conversion_shift[j]]);
 849                         const WORD *in = (WORD *)(&This->resource.allocatedMemory[i * This->stride + j]);
 850
 851                         out[1] = float_16_to_32(in + 1);
 852                         out[0] = float_16_to_32(in + 0);
 853                         j += 3;    /* Skip 3 additional bytes,as a FLOAT16_2 has 4 bytes */
 854                         break;
 855                     }
 856
 857                     default:
 858                         FIXME("Unimplemented conversion %d in shifted conversion\n", This->conversion_map[j]);
 859                         break;
 860                 }
 861             }
 862         }
 863
 864         ENTER_GL();
 865         GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 866         checkGLcall("glBindBufferARB");
 867         GL_EXTCALL(glBufferSubDataARB(This->buffer_type_hint, 0, vertices * This->conversion_stride, data));
 868         checkGLcall("glBufferSubDataARB");
 869         LEAVE_GL();
 870     }
 871     else
 872     {
 873         data = HeapAlloc(GetProcessHeap(), 0, This->resource.size);
 874         memcpy(data + start, This->resource.allocatedMemory + start, end - start);
 875         for (i = start / This->stride; i < min((end / This->stride) + 1, vertices); ++i)
 876         {
 877             for (j = 0; j < This->stride; ++j)
 878             {
 879                 switch(This->conversion_map[j])
 880                 {
 881                     case CONV_NONE:
 882                         /* Done already */
 883                         j += 3;
 884                         break;
 885                     case CONV_D3DCOLOR:
 886                         fixup_d3dcolor((DWORD *) (data + i * This->stride + j));
 887                         j += 3;
 888                         break;
 889
 890                     case CONV_POSITIONT:
 891                         fixup_transformed_pos((float *) (data + i * This->stride + j));
 892                         j += 15;
 893                         break;
 894
 895                     case CONV_FLOAT16_2:
 896                         ERR("Did not expect FLOAT16 conversion in unshifted conversion\n");
 897                     default:
 898                         FIXME("Unimplemented conversion %d in shifted conversion\n", This->conversion_map[j]);
 899                 }
 900             }
 901         }
 902
 903         ENTER_GL();
 904         GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 905         checkGLcall("glBindBufferARB");
 906         GL_EXTCALL(glBufferSubDataARB(This->buffer_type_hint, start, end - start, data + start));
 907         checkGLcall("glBufferSubDataARB");
 908         LEAVE_GL();
 909     }
 910
 911     HeapFree(GetProcessHeap(), 0, data);
 912 }
 913
 914 static WINED3DRESOURCETYPE STDMETHODCALLTYPE buffer_GetType(IWineD3DBuffer *iface)
 915 {
 916     return resource_get_type((IWineD3DResource *)iface);
 917 }
 918
 919 /* IWineD3DBuffer methods */
 920
 921 static HRESULT STDMETHODCALLTYPE buffer_Map(IWineD3DBuffer *iface, UINT offset, UINT size, BYTE **data, DWORD flags)
 922 {
 923     struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
 924     LONG count;
 925
 926     TRACE("iface %p, offset %u, size %u, data %p, flags %#x\n", iface, offset, size, data, flags);
 927
 928     count = InterlockedIncrement(&This->lock_count);
 929
 930     if (This->flags & WINED3D_BUFFER_DIRTY)
 931     {
 932         if (This->dirty_start > offset) This->dirty_start = offset;
 933
 934         if (size)
 935         {
 936             if (This->dirty_end < offset + size) This->dirty_end = offset + size;
 937         }
 938         else
 939         {
 940             This->dirty_end = This->resource.size;
 941         }
 942     }
 943     else
 944     {
 945         This->dirty_start = offset;
 946         if (size) This->dirty_end = offset + size;
 947         else This->dirty_end = This->resource.size;
 948     }
 949
 950     if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER) && This->buffer_object)
 951     {
 952         if(count == 1)
 953         {
 954             if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
 955             {
 956                 IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
 957             }
 958             GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 959             This->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(This->buffer_type_hint, GL_READ_WRITE_ARB));
 960         }
 961     }
 962     else
 963     {
 964         This->flags |= WINED3D_BUFFER_DIRTY;
 965     }
 966
 967     *data = This->resource.allocatedMemory + offset;
 968
 969     TRACE("Returning memory at %p (base %p, offset %u)\n", *data, This->resource.allocatedMemory, offset);
 970     /* TODO: check Flags compatibility with This->currentDesc.Usage (see MSDN) */
 971
 972     return WINED3D_OK;
 973 }
 974
 975 static HRESULT STDMETHODCALLTYPE buffer_Unmap(IWineD3DBuffer *iface)
 976 {
 977     struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
 978
 979     TRACE("(%p)\n", This);
 980
 981     if (InterlockedDecrement(&This->lock_count))
 982     {
 983         /* Delay loading the buffer until everything is unlocked */
 984         TRACE("Ignoring unlock\n");
 985         return WINED3D_OK;
 986     }
 987
 988     if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER) && This->buffer_object)
 989     {
 990         if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB)
 991         {
 992             IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_INDEXBUFFER);
 993         }
 994         GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object));
 995         GL_EXTCALL(glUnmapBufferARB(This->buffer_type_hint));
 996         This->resource.allocatedMemory = NULL;
 997     }
 998     else if (This->flags & WINED3D_BUFFER_HASDESC)
 999     {
1000         buffer_PreLoad(iface);
1001     }
1002
1003     return WINED3D_OK;
1004 }
1005
1006 static HRESULT STDMETHODCALLTYPE buffer_GetDesc(IWineD3DBuffer *iface, WINED3DBUFFER_DESC *desc)
1007 {
1008     struct wined3d_buffer *This = (struct wined3d_buffer *)iface;
1009
1010     TRACE("(%p)\n", This);
1011
1012     desc->Type = This->resource.resourceType;
1013     desc->Usage = This->resource.usage;
1014     desc->Pool = This->resource.pool;
1015     desc->Size = This->resource.size;
1016
1017     return WINED3D_OK;
1018 }
1019
1020 const struct IWineD3DBufferVtbl wined3d_buffer_vtbl =
1021 {
1022     /* IUnknown methods */
1023     buffer_QueryInterface,
1024     buffer_AddRef,
1025     buffer_Release,
1026     /* IWineD3DBase methods */
1027     buffer_GetParent,
1028     /* IWineD3DResource methods */
1029     buffer_GetDevice,
1030     buffer_SetPrivateData,
1031     buffer_GetPrivateData,
1032     buffer_FreePrivateData,
1033     buffer_SetPriority,
1034     buffer_GetPriority,
1035     buffer_PreLoad,
1036     buffer_UnLoad,
1037     buffer_GetType,
1038     /* IWineD3DBuffer methods */
1039     buffer_Map,
1040     buffer_Unmap,
1041     buffer_GetDesc,
1042 };