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