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