2 * Copyright 2002-2005 Jason Edmeades
3 * Copyright 2002-2005 Raphael Junqueira
4 * Copyright 2004 Christian Costa
5 * Copyright 2005 Oliver Stieber
6 * Copyright 2007 Stefan Dösinger for CodeWeavers
7 * Copyright 2009 Henri Verbeet for CodeWeavers
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.
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.
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
26 #include "wine/port.h"
28 #include "wined3d_private.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
32 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
34 #define VB_MAXDECLCHANGES 100 /* After that number we stop converting */
35 #define VB_RESETDECLCHANGE 1000 /* Reset the changecount after that number of draws */
37 /* Context activation is done by the caller. */
38 static void buffer_create_buffer_object(struct wined3d_buffer
*This
)
40 GLenum error
, gl_usage
;
42 TRACE("Creating an OpenGL vertex buffer object for IWineD3DVertexBuffer %p Usage(%s)\n",
43 This
, debug_d3dusage(This
->resource
.usage
));
47 /* Make sure that the gl error is cleared. Do not use checkGLcall
48 * here because checkGLcall just prints a fixme and continues. However,
49 * if an error during VBO creation occurs we can fall back to non-vbo operation
50 * with full functionality(but performance loss)
52 while (glGetError() != GL_NO_ERROR
);
54 /* Basically the FVF parameter passed to CreateVertexBuffer is no good
55 * It is the FVF set with IWineD3DDevice::SetFVF or the Vertex Declaration set with
56 * IWineD3DDevice::SetVertexDeclaration that decides how the vertices in the buffer
57 * look like. This means that on each DrawPrimitive call the vertex buffer has to be verified
58 * to check if the rhw and color values are in the correct format.
61 GL_EXTCALL(glGenBuffersARB(1, &This
->buffer_object
));
63 if (!This
->buffer_object
|| error
!= GL_NO_ERROR
)
65 ERR("Failed to create a VBO with error %s (%#x)\n", debug_glerror(error
), error
);
69 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
71 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
73 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
75 if (error
!= GL_NO_ERROR
)
77 ERR("Failed to bind the VBO with error %s (%#x)\n", debug_glerror(error
), error
);
81 /* Don't use static, because dx apps tend to update the buffer
82 * quite often even if they specify 0 usage. Because we always keep the local copy
83 * we never read from the vbo and can create a write only opengl buffer.
85 switch(This
->resource
.usage
& (WINED3DUSAGE_WRITEONLY
| WINED3DUSAGE_DYNAMIC
))
87 case WINED3DUSAGE_WRITEONLY
| WINED3DUSAGE_DYNAMIC
:
88 case WINED3DUSAGE_DYNAMIC
:
89 TRACE("Gl usage = GL_STREAM_DRAW\n");
90 gl_usage
= GL_STREAM_DRAW_ARB
;
93 case WINED3DUSAGE_WRITEONLY
:
95 TRACE("Gl usage = GL_DYNAMIC_DRAW\n");
96 gl_usage
= GL_DYNAMIC_DRAW_ARB
;
100 /* Reserve memory for the buffer. The amount of data won't change
101 * so we are safe with calling glBufferData once and
102 * calling glBufferSubData on updates. Upload the actual data in case
103 * we're not double buffering, so we can release the heap mem afterwards
105 GL_EXTCALL(glBufferDataARB(This
->buffer_type_hint
, This
->resource
.size
, This
->resource
.allocatedMemory
, gl_usage
));
106 error
= glGetError();
107 if (error
!= GL_NO_ERROR
)
109 ERR("glBufferDataARB failed with error %s (%#x)\n", debug_glerror(error
), error
);
115 This
->buffer_object_size
= This
->resource
.size
;
116 This
->buffer_object_usage
= gl_usage
;
117 This
->dirty_start
= 0;
118 This
->dirty_end
= This
->resource
.size
;
120 if(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
)
122 This
->flags
|= WINED3D_BUFFER_DIRTY
;
126 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
127 This
->resource
.allocatedMemory
= NULL
;
128 This
->resource
.heapMemory
= NULL
;
129 This
->flags
&= ~WINED3D_BUFFER_DIRTY
;
135 /* Clean up all vbo init, but continue because we can work without a vbo :-) */
136 ERR("Failed to create a vertex buffer object. Continuing, but performance issues may occur\n");
137 if (This
->buffer_object
) GL_EXTCALL(glDeleteBuffersARB(1, &This
->buffer_object
));
138 This
->buffer_object
= 0;
144 static BOOL
buffer_process_converted_attribute(struct wined3d_buffer
*This
,
145 const enum wined3d_buffer_conversion_type conversion_type
,
146 const struct wined3d_stream_info_element
*attrib
, DWORD
*stride_this_run
)
151 DWORD offset
= This
->resource
.wineD3DDevice
->stateBlock
->streamOffset
[attrib
->stream_idx
];
154 /* Check for some valid situations which cause us pain. One is if the buffer is used for
155 * constant attributes(stride = 0), the other one is if the buffer is used on two streams
156 * with different strides. In the 2nd case we might have to drop conversion entirely,
157 * it is possible that the same bytes are once read as FLOAT2 and once as UBYTE4N.
161 FIXME("%s used with stride 0, let's hope we get the vertex stride from somewhere else\n",
162 debug_d3dformat(attrib
->format_desc
->format
));
164 else if(attrib
->stride
!= *stride_this_run
&& *stride_this_run
)
166 FIXME("Got two concurrent strides, %d and %d\n", attrib
->stride
, *stride_this_run
);
170 *stride_this_run
= attrib
->stride
;
171 if (This
->stride
!= *stride_this_run
)
173 /* We rely that this happens only on the first converted attribute that is found,
174 * if at all. See above check
176 TRACE("Reconverting because converted attributes occur, and the stride changed\n");
177 This
->stride
= *stride_this_run
;
178 HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->conversion_map
);
179 This
->conversion_map
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
180 sizeof(*This
->conversion_map
) * This
->stride
);
185 data
= (((DWORD_PTR
)attrib
->data
) + offset
) % This
->stride
;
186 attrib_size
= attrib
->format_desc
->component_count
* attrib
->format_desc
->component_size
;
187 for (i
= 0; i
< attrib_size
; ++i
)
189 if (This
->conversion_map
[data
+ i
] != conversion_type
)
191 TRACE("Byte %ld in vertex changed\n", i
+ data
);
192 TRACE("It was type %d, is %d now\n", This
->conversion_map
[data
+ i
], conversion_type
);
194 This
->conversion_map
[data
+ i
] = conversion_type
;
201 static BOOL
buffer_check_attribute(struct wined3d_buffer
*This
, const struct wined3d_stream_info
*si
,
202 UINT attrib_idx
, const BOOL check_d3dcolor
, const BOOL is_ffp_position
, const BOOL is_ffp_color
,
203 DWORD
*stride_this_run
, BOOL
*float16_used
)
205 const struct wined3d_stream_info_element
*attrib
= &si
->elements
[attrib_idx
];
206 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
207 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
209 WINED3DFORMAT format
;
211 /* Ignore attributes that do not have our vbo. After that check we can be sure that the attribute is
212 * there, on nonexistent attribs the vbo is 0.
214 if (!(si
->use_map
& (1 << attrib_idx
))
215 || attrib
->buffer_object
!= This
->buffer_object
)
218 format
= attrib
->format_desc
->format
;
219 /* Look for newly appeared conversion */
220 if (!gl_info
->supported
[ARB_HALF_FLOAT_VERTEX
]
221 && (format
== WINED3DFMT_R16G16_FLOAT
|| format
== WINED3DFMT_R16G16B16A16_FLOAT
))
223 ret
= buffer_process_converted_attribute(This
, CONV_FLOAT16_2
, attrib
, stride_this_run
);
225 if (is_ffp_position
) FIXME("Test FLOAT16 fixed function processing positions\n");
226 else if (is_ffp_color
) FIXME("test FLOAT16 fixed function processing colors\n");
227 *float16_used
= TRUE
;
229 else if (check_d3dcolor
&& format
== WINED3DFMT_B8G8R8A8_UNORM
)
231 ret
= buffer_process_converted_attribute(This
, CONV_D3DCOLOR
, attrib
, stride_this_run
);
233 if (!is_ffp_color
) FIXME("Test for non-color fixed function WINED3DFMT_B8G8R8A8_UNORM format\n");
235 else if (is_ffp_position
&& format
== WINED3DFMT_R32G32B32A32_FLOAT
)
237 ret
= buffer_process_converted_attribute(This
, CONV_POSITIONT
, attrib
, stride_this_run
);
239 else if (This
->conversion_map
)
241 ret
= buffer_process_converted_attribute(This
, CONV_NONE
, attrib
, stride_this_run
);
247 static UINT
*find_conversion_shift(struct wined3d_buffer
*This
,
248 const struct wined3d_stream_info
*strided
, UINT stride
)
250 UINT
*ret
, i
, j
, shift
, orig_type_size
;
258 This
->conversion_stride
= stride
;
259 ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(DWORD
) * stride
);
260 for (i
= 0; i
< MAX_ATTRIBS
; ++i
)
262 WINED3DFORMAT format
;
264 if (!(strided
->use_map
& (1 << i
)) || strided
->elements
[i
].buffer_object
!= This
->buffer_object
) continue;
266 format
= strided
->elements
[i
].format_desc
->format
;
267 if (format
== WINED3DFMT_R16G16_FLOAT
)
271 else if (format
== WINED3DFMT_R16G16B16A16_FLOAT
)
274 /* Pre-shift the last 4 bytes in the FLOAT16_4 by 4 bytes - this makes FLOAT16_2 and FLOAT16_4 conversions
277 for (j
= 4; j
< 8; ++j
)
279 ret
[(DWORD_PTR
)strided
->elements
[i
].data
+ j
] += 4;
286 This
->conversion_stride
+= shift
;
290 orig_type_size
= strided
->elements
[i
].format_desc
->component_count
291 * strided
->elements
[i
].format_desc
->component_size
;
292 for (j
= (DWORD_PTR
)strided
->elements
[i
].data
+ orig_type_size
; j
< stride
; ++j
)
301 TRACE("Dumping conversion shift:\n");
302 for (i
= 0; i
< stride
; ++i
)
304 TRACE("[%d]", ret
[i
]);
312 static BOOL
buffer_find_decl(struct wined3d_buffer
*This
)
314 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
315 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
316 const struct wined3d_stream_info
*si
= &device
->strided_streams
;
317 UINT stride_this_run
= 0;
318 BOOL float16_used
= FALSE
;
322 /* In d3d7 the vertex buffer declaration NEVER changes because it is stored in the d3d7 vertex buffer.
323 * Once we have our declaration there is no need to look it up again. Index buffers also never need
324 * conversion, so once the (empty) conversion structure is created don't bother checking again
326 if (This
->flags
& WINED3D_BUFFER_HASDESC
)
328 if(((IWineD3DImpl
*)device
->wineD3D
)->dxVersion
== 7 ||
329 This
->resource
.format_desc
->format
!= WINED3DFMT_VERTEXDATA
) return FALSE
;
332 TRACE("Finding vertex buffer conversion information\n");
333 /* Certain declaration types need some fixups before we can pass them to
334 * opengl. This means D3DCOLOR attributes with fixed function vertex
335 * processing, FLOAT4 POSITIONT with fixed function, and FLOAT16 if
336 * GL_ARB_half_float_vertex is not supported.
338 * Note for d3d8 and d3d9:
339 * The vertex buffer FVF doesn't help with finding them, we have to use
340 * the decoded vertex declaration and pick the things that concern the
341 * current buffer. A problem with this is that this can change between
342 * draws, so we have to validate the information and reprocess the buffer
343 * if it changes, and avoid false positives for performance reasons.
344 * WineD3D doesn't even know the vertex buffer any more, it is managed
345 * by the client libraries and passed to SetStreamSource and ProcessVertices
348 * We have to distinguish between vertex shaders and fixed function to
349 * pick the way we access the strided vertex information.
351 * This code sets up a per-byte array with the size of the detected
352 * stride of the arrays in the buffer. For each byte we have a field
353 * that marks the conversion needed on this byte. For example, the
354 * following declaration with fixed function vertex processing:
362 * { POSITIONT }{ NORMAL }{ DIFFUSE }{SPECULAR }
363 * [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]
365 * Where in this example map P means 4 component position conversion, 0
366 * means no conversion, F means FLOAT16_2 conversion and C means D3DCOLOR
367 * conversion (red / blue swizzle).
369 * If we're doing conversion and the stride changes we have to reconvert
370 * the whole buffer. Note that we do not mind if the semantic changes,
371 * we only care for the conversion type. So if the NORMAL is replaced
372 * with a TEXCOORD, nothing has to be done, or if the DIFFUSE is replaced
373 * with a D3DCOLOR BLENDWEIGHT we can happily dismiss the change. Some
374 * conversion types depend on the semantic as well, for example a FLOAT4
375 * texcoord needs no conversion while a FLOAT4 positiont needs one
377 if (use_vs(device
->stateBlock
))
380 /* If the current vertex declaration is marked for no half float conversion don't bother to
381 * analyse the strided streams in depth, just set them up for no conversion. Return decl changed
382 * if we used conversion before
384 if (!((IWineD3DVertexDeclarationImpl
*) device
->stateBlock
->vertexDecl
)->half_float_conv_needed
)
386 if (This
->conversion_map
)
388 TRACE("Now using shaders without conversion, but conversion used before\n");
389 HeapFree(GetProcessHeap(), 0, This
->conversion_map
);
390 HeapFree(GetProcessHeap(), 0, This
->conversion_shift
);
391 This
->conversion_map
= NULL
;
393 This
->conversion_shift
= NULL
;
394 This
->conversion_stride
= 0;
402 for (i
= 0; i
< MAX_ATTRIBS
; ++i
)
404 ret
= buffer_check_attribute(This
, si
, i
, FALSE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
407 /* Recalculate the conversion shift map if the declaration has changed,
408 * and we're using float16 conversion or used it on the last run
410 if (ret
&& (float16_used
|| This
->conversion_map
))
412 HeapFree(GetProcessHeap(), 0, This
->conversion_shift
);
413 This
->conversion_shift
= find_conversion_shift(This
, si
, This
->stride
);
418 /* Fixed function is a bit trickier. We have to take care for D3DCOLOR types, FLOAT4 positions and of course
419 * FLOAT16s if not supported. Also, we can't iterate over the array, so use macros to generate code for all
420 * the attributes that our current fixed function pipeline implementation cares for.
422 BOOL support_d3dcolor
= gl_info
->supported
[EXT_VERTEX_ARRAY_BGRA
];
423 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_POSITION
,
424 TRUE
, TRUE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
425 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_NORMAL
,
426 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
427 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_DIFFUSE
,
428 !support_d3dcolor
, FALSE
, TRUE
, &stride_this_run
, &float16_used
) || ret
;
429 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_SPECULAR
,
430 !support_d3dcolor
, FALSE
, TRUE
, &stride_this_run
, &float16_used
) || ret
;
431 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD0
,
432 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
433 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD1
,
434 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
435 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD2
,
436 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
437 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD3
,
438 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
439 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD4
,
440 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
441 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD5
,
442 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
443 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD6
,
444 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
445 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD7
,
446 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
448 if (float16_used
) FIXME("Float16 conversion used with fixed function vertex processing\n");
451 if (stride_this_run
== 0 && This
->conversion_map
)
454 if (!ret
) ERR("no converted attributes found, old conversion map exists, and no declaration change?\n");
455 HeapFree(GetProcessHeap(), 0, This
->conversion_map
);
456 This
->conversion_map
= NULL
;
460 if (ret
) TRACE("Conversion information changed\n");
465 /* Context activation is done by the caller. */
466 static void buffer_check_buffer_object_size(struct wined3d_buffer
*This
)
468 UINT size
= This
->conversion_stride
?
469 This
->conversion_stride
* (This
->resource
.size
/ This
->stride
) : This
->resource
.size
;
470 if (This
->buffer_object_size
!= size
)
472 TRACE("Old size %u, creating new size %u\n", This
->buffer_object_size
, size
);
474 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
476 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
479 /* Rescue the data before resizing the buffer object if we do not have our backup copy */
480 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
))
482 buffer_get_sysmem(This
);
486 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
487 checkGLcall("glBindBufferARB");
488 GL_EXTCALL(glBufferDataARB(This
->buffer_type_hint
, size
, NULL
, This
->buffer_object_usage
));
489 This
->buffer_object_size
= size
;
490 checkGLcall("glBufferDataARB");
495 static inline void fixup_d3dcolor(DWORD
*dst_color
)
497 DWORD src_color
= *dst_color
;
499 /* Color conversion like in drawStridedSlow. watch out for little endianity
500 * If we want that stuff to work on big endian machines too we have to consider more things
502 * 0xff000000: Alpha mask
503 * 0x00ff0000: Blue mask
504 * 0x0000ff00: Green mask
505 * 0x000000ff: Red mask
508 *dst_color
|= (src_color
& 0xff00ff00); /* Alpha Green */
509 *dst_color
|= (src_color
& 0x00ff0000) >> 16; /* Red */
510 *dst_color
|= (src_color
& 0x000000ff) << 16; /* Blue */
513 static inline void fixup_transformed_pos(float *p
)
515 /* rhw conversion like in position_float4(). */
516 if (p
[3] != 1.0f
&& p
[3] != 0.0f
)
518 float w
= 1.0f
/ p
[3];
526 /* Context activation is done by the caller. */
527 const BYTE
*buffer_get_memory(IWineD3DBuffer
*iface
, UINT offset
, GLuint
*buffer_object
)
529 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
531 *buffer_object
= This
->buffer_object
;
532 if (!This
->buffer_object
)
534 if (This
->flags
& WINED3D_BUFFER_CREATEBO
)
536 buffer_create_buffer_object(This
);
537 This
->flags
&= ~WINED3D_BUFFER_CREATEBO
;
538 if (This
->buffer_object
)
540 *buffer_object
= This
->buffer_object
;
541 return (const BYTE
*)offset
;
544 return This
->resource
.allocatedMemory
+ offset
;
548 return (const BYTE
*)offset
;
552 /* IUnknown methods */
554 static HRESULT STDMETHODCALLTYPE
buffer_QueryInterface(IWineD3DBuffer
*iface
,
555 REFIID riid
, void **object
)
557 TRACE("iface %p, riid %s, object %p\n", iface
, debugstr_guid(riid
), object
);
559 if (IsEqualGUID(riid
, &IID_IWineD3DBuffer
)
560 || IsEqualGUID(riid
, &IID_IWineD3DResource
)
561 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
562 || IsEqualGUID(riid
, &IID_IUnknown
))
564 IUnknown_AddRef(iface
);
569 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
573 return E_NOINTERFACE
;
576 static ULONG STDMETHODCALLTYPE
buffer_AddRef(IWineD3DBuffer
*iface
)
578 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
579 ULONG refcount
= InterlockedIncrement(&This
->resource
.ref
);
581 TRACE("%p increasing refcount to %u\n", This
, refcount
);
586 /* Context activation is done by the caller. */
587 BYTE
*buffer_get_sysmem(struct wined3d_buffer
*This
)
589 /* AllocatedMemory exists if the buffer is double buffered or has no buffer object at all */
590 if(This
->resource
.allocatedMemory
) return This
->resource
.allocatedMemory
;
592 This
->resource
.heapMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->resource
.size
+ RESOURCE_ALIGNMENT
);
593 This
->resource
.allocatedMemory
= (BYTE
*)(((ULONG_PTR
)This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
595 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
596 GL_EXTCALL(glGetBufferSubDataARB(This
->buffer_type_hint
, 0, This
->resource
.size
, This
->resource
.allocatedMemory
));
598 This
->flags
|= WINED3D_BUFFER_DOUBLEBUFFER
;
600 return This
->resource
.allocatedMemory
;
603 static void STDMETHODCALLTYPE
buffer_UnLoad(IWineD3DBuffer
*iface
)
605 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
607 TRACE("iface %p\n", iface
);
609 if (This
->buffer_object
)
611 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
612 struct wined3d_context
*context
;
614 context
= context_acquire(device
, NULL
, CTXUSAGE_RESOURCELOAD
);
616 /* Download the buffer, but don't permanently enable double buffering */
617 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
))
619 buffer_get_sysmem(This
);
620 This
->flags
&= ~WINED3D_BUFFER_DOUBLEBUFFER
;
624 GL_EXTCALL(glDeleteBuffersARB(1, &This
->buffer_object
));
625 checkGLcall("glDeleteBuffersARB");
627 This
->buffer_object
= 0;
628 This
->flags
|= WINED3D_BUFFER_CREATEBO
; /* Recreate the buffer object next load */
630 context_release(context
);
634 static ULONG STDMETHODCALLTYPE
buffer_Release(IWineD3DBuffer
*iface
)
636 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
637 ULONG refcount
= InterlockedDecrement(&This
->resource
.ref
);
639 TRACE("%p decreasing refcount to %u\n", This
, refcount
);
643 buffer_UnLoad(iface
);
644 resource_cleanup((IWineD3DResource
*)iface
);
645 This
->resource
.parent_ops
->wined3d_object_destroyed(This
->resource
.parent
);
646 HeapFree(GetProcessHeap(), 0, This
);
652 /* IWineD3DBase methods */
654 static HRESULT STDMETHODCALLTYPE
buffer_GetParent(IWineD3DBuffer
*iface
, IUnknown
**parent
)
656 return resource_get_parent((IWineD3DResource
*)iface
, parent
);
659 /* IWineD3DResource methods */
661 static HRESULT STDMETHODCALLTYPE
buffer_GetDevice(IWineD3DBuffer
*iface
, IWineD3DDevice
**device
)
663 return resource_get_device((IWineD3DResource
*)iface
, device
);
666 static HRESULT STDMETHODCALLTYPE
buffer_SetPrivateData(IWineD3DBuffer
*iface
,
667 REFGUID guid
, const void *data
, DWORD data_size
, DWORD flags
)
669 return resource_set_private_data((IWineD3DResource
*)iface
, guid
, data
, data_size
, flags
);
672 static HRESULT STDMETHODCALLTYPE
buffer_GetPrivateData(IWineD3DBuffer
*iface
,
673 REFGUID guid
, void *data
, DWORD
*data_size
)
675 return resource_get_private_data((IWineD3DResource
*)iface
, guid
, data
, data_size
);
678 static HRESULT STDMETHODCALLTYPE
buffer_FreePrivateData(IWineD3DBuffer
*iface
, REFGUID guid
)
680 return resource_free_private_data((IWineD3DResource
*)iface
, guid
);
683 static DWORD STDMETHODCALLTYPE
buffer_SetPriority(IWineD3DBuffer
*iface
, DWORD priority
)
685 return resource_set_priority((IWineD3DResource
*)iface
, priority
);
688 static DWORD STDMETHODCALLTYPE
buffer_GetPriority(IWineD3DBuffer
*iface
)
690 return resource_get_priority((IWineD3DResource
*)iface
);
693 static void STDMETHODCALLTYPE
buffer_PreLoad(IWineD3DBuffer
*iface
)
695 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
696 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
697 UINT start
= 0, end
= 0, vertices
;
698 struct wined3d_context
*context
;
699 BOOL decl_changed
= FALSE
;
703 TRACE("iface %p\n", iface
);
705 context
= context_acquire(device
, NULL
, CTXUSAGE_RESOURCELOAD
);
707 if (!This
->buffer_object
)
709 /* TODO: Make converting independent from VBOs */
710 if (This
->flags
& WINED3D_BUFFER_CREATEBO
)
712 buffer_create_buffer_object(This
);
713 This
->flags
&= ~WINED3D_BUFFER_CREATEBO
;
717 context_release(context
);
718 return; /* Not doing any conversion */
722 /* Reading the declaration makes only sense if the stateblock is finalized and the buffer bound to a stream */
723 if (device
->isInDraw
&& This
->bind_count
> 0)
725 decl_changed
= buffer_find_decl(This
);
726 This
->flags
|= WINED3D_BUFFER_HASDESC
;
729 if (!decl_changed
&& !(This
->flags
& WINED3D_BUFFER_HASDESC
&& This
->flags
& WINED3D_BUFFER_DIRTY
))
731 context_release(context
);
735 /* If applications change the declaration over and over, reconverting all the time is a huge
736 * performance hit. So count the declaration changes and release the VBO if there are too many
737 * of them (and thus stop converting)
741 ++This
->conversion_count
;
742 This
->draw_count
= 0;
744 if (This
->conversion_count
> VB_MAXDECLCHANGES
)
746 FIXME("Too many declaration changes, stopping converting\n");
749 GL_EXTCALL(glDeleteBuffersARB(1, &This
->buffer_object
));
750 checkGLcall("glDeleteBuffersARB");
752 This
->buffer_object
= 0;
753 HeapFree(GetProcessHeap(), 0, This
->conversion_shift
);
755 /* The stream source state handler might have read the memory of the vertex buffer already
756 * and got the memory in the vbo which is not valid any longer. Dirtify the stream source
757 * to force a reload. This happens only once per changed vertexbuffer and should occur rather
760 IWineD3DDeviceImpl_MarkStateDirty(device
, STATE_STREAMSRC
);
761 context_release(context
);
764 buffer_check_buffer_object_size(This
);
768 /* However, it is perfectly fine to change the declaration every now and then. We don't want a game that
769 * changes it every minute drop the VBO after VB_MAX_DECL_CHANGES minutes. So count draws without
770 * decl changes and reset the decl change count after a specific number of them
773 if (This
->draw_count
> VB_RESETDECLCHANGE
) This
->conversion_count
= 0;
778 /* The declaration changed, reload the whole buffer */
779 WARN("Reloading buffer because of decl change\n");
781 end
= This
->resource
.size
;
785 /* No decl change, but dirty data, reload the changed stuff */
786 if (This
->conversion_shift
)
788 if (This
->dirty_start
!= 0 || This
->dirty_end
!= 0)
790 FIXME("Implement partial buffer loading with shifted conversion\n");
793 start
= This
->dirty_start
;
794 end
= This
->dirty_end
;
797 /* Mark the buffer clean */
798 This
->flags
&= ~WINED3D_BUFFER_DIRTY
;
799 This
->dirty_start
= 0;
802 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
804 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
807 if (!This
->conversion_map
)
809 /* That means that there is nothing to fixup. Just upload from This->resource.allocatedMemory
810 * directly into the vbo. Do not free the system memory copy because drawPrimitive may need it if
811 * the stride is 0, for instancing emulation, vertex blending emulation or shader emulation.
813 TRACE("No conversion needed\n");
815 /* Nothing to do because we locked directly into the vbo */
816 if (!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
))
818 context_release(context
);
823 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
824 checkGLcall("glBindBufferARB");
825 GL_EXTCALL(glBufferSubDataARB(This
->buffer_type_hint
, start
, end
-start
, This
->resource
.allocatedMemory
+ start
));
826 checkGLcall("glBufferSubDataARB");
829 context_release(context
);
833 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
))
835 buffer_get_sysmem(This
);
838 /* Now for each vertex in the buffer that needs conversion */
839 vertices
= This
->resource
.size
/ This
->stride
;
841 if (This
->conversion_shift
)
843 TRACE("Shifted conversion\n");
844 data
= HeapAlloc(GetProcessHeap(), 0, vertices
* This
->conversion_stride
);
846 for (i
= start
/ This
->stride
; i
< min((end
/ This
->stride
) + 1, vertices
); ++i
)
848 for (j
= 0; j
< This
->stride
; ++j
)
850 switch(This
->conversion_map
[j
])
853 data
[This
->conversion_stride
* i
+ j
+ This
->conversion_shift
[j
]]
854 = This
->resource
.allocatedMemory
[This
->stride
* i
+ j
];
859 float *out
= (float *)(&data
[This
->conversion_stride
* i
+ j
+ This
->conversion_shift
[j
]]);
860 const WORD
*in
= (WORD
*)(&This
->resource
.allocatedMemory
[i
* This
->stride
+ j
]);
862 out
[1] = float_16_to_32(in
+ 1);
863 out
[0] = float_16_to_32(in
+ 0);
864 j
+= 3; /* Skip 3 additional bytes,as a FLOAT16_2 has 4 bytes */
869 FIXME("Unimplemented conversion %d in shifted conversion\n", This
->conversion_map
[j
]);
876 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
877 checkGLcall("glBindBufferARB");
878 GL_EXTCALL(glBufferSubDataARB(This
->buffer_type_hint
, 0, vertices
* This
->conversion_stride
, data
));
879 checkGLcall("glBufferSubDataARB");
884 data
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
);
885 memcpy(data
+ start
, This
->resource
.allocatedMemory
+ start
, end
- start
);
886 for (i
= start
/ This
->stride
; i
< min((end
/ This
->stride
) + 1, vertices
); ++i
)
888 for (j
= 0; j
< This
->stride
; ++j
)
890 switch(This
->conversion_map
[j
])
897 fixup_d3dcolor((DWORD
*) (data
+ i
* This
->stride
+ j
));
902 fixup_transformed_pos((float *) (data
+ i
* This
->stride
+ j
));
907 ERR("Did not expect FLOAT16 conversion in unshifted conversion\n");
909 FIXME("Unimplemented conversion %d in shifted conversion\n", This
->conversion_map
[j
]);
915 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
916 checkGLcall("glBindBufferARB");
917 GL_EXTCALL(glBufferSubDataARB(This
->buffer_type_hint
, start
, end
- start
, data
+ start
));
918 checkGLcall("glBufferSubDataARB");
922 HeapFree(GetProcessHeap(), 0, data
);
923 context_release(context
);
926 static WINED3DRESOURCETYPE STDMETHODCALLTYPE
buffer_GetType(IWineD3DBuffer
*iface
)
928 return resource_get_type((IWineD3DResource
*)iface
);
931 /* IWineD3DBuffer methods */
933 static HRESULT STDMETHODCALLTYPE
buffer_Map(IWineD3DBuffer
*iface
, UINT offset
, UINT size
, BYTE
**data
, DWORD flags
)
935 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
938 TRACE("iface %p, offset %u, size %u, data %p, flags %#x\n", iface
, offset
, size
, data
, flags
);
940 count
= InterlockedIncrement(&This
->lock_count
);
942 if (This
->flags
& WINED3D_BUFFER_DIRTY
)
944 if (This
->dirty_start
> offset
) This
->dirty_start
= offset
;
948 if (This
->dirty_end
< offset
+ size
) This
->dirty_end
= offset
+ size
;
952 This
->dirty_end
= This
->resource
.size
;
957 This
->dirty_start
= offset
;
958 if (size
) This
->dirty_end
= offset
+ size
;
959 else This
->dirty_end
= This
->resource
.size
;
962 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
) && This
->buffer_object
)
966 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
967 struct wined3d_context
*context
;
969 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
971 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
974 context
= context_acquire(device
, NULL
, CTXUSAGE_RESOURCELOAD
);
976 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
977 This
->resource
.allocatedMemory
= GL_EXTCALL(glMapBufferARB(This
->buffer_type_hint
, GL_READ_WRITE_ARB
));
979 context_release(context
);
984 This
->flags
|= WINED3D_BUFFER_DIRTY
;
987 *data
= This
->resource
.allocatedMemory
+ offset
;
989 TRACE("Returning memory at %p (base %p, offset %u)\n", *data
, This
->resource
.allocatedMemory
, offset
);
990 /* TODO: check Flags compatibility with This->currentDesc.Usage (see MSDN) */
995 static HRESULT STDMETHODCALLTYPE
buffer_Unmap(IWineD3DBuffer
*iface
)
997 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
999 TRACE("(%p)\n", This
);
1001 /* In the case that the number of Unmap calls > the
1002 * number of Map calls, d3d returns always D3D_OK.
1003 * This is also needed to prevent Map from returning garbage on
1004 * the next call (this will happen if the lock_count is < 0). */
1005 if(This
->lock_count
== 0)
1007 TRACE("Unmap called without a previous Map call!\n");
1011 if (InterlockedDecrement(&This
->lock_count
))
1013 /* Delay loading the buffer until everything is unlocked */
1014 TRACE("Ignoring unlock\n");
1018 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
) && This
->buffer_object
)
1020 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1021 struct wined3d_context
*context
;
1023 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
1025 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
1028 context
= context_acquire(device
, NULL
, CTXUSAGE_RESOURCELOAD
);
1030 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
1031 GL_EXTCALL(glUnmapBufferARB(This
->buffer_type_hint
));
1033 context_release(context
);
1035 This
->resource
.allocatedMemory
= NULL
;
1037 else if (This
->flags
& WINED3D_BUFFER_HASDESC
)
1039 buffer_PreLoad(iface
);
1045 static HRESULT STDMETHODCALLTYPE
buffer_GetDesc(IWineD3DBuffer
*iface
, WINED3DBUFFER_DESC
*desc
)
1047 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
1049 TRACE("(%p)\n", This
);
1051 desc
->Type
= This
->resource
.resourceType
;
1052 desc
->Usage
= This
->resource
.usage
;
1053 desc
->Pool
= This
->resource
.pool
;
1054 desc
->Size
= This
->resource
.size
;
1059 static const struct IWineD3DBufferVtbl wined3d_buffer_vtbl
=
1061 /* IUnknown methods */
1062 buffer_QueryInterface
,
1065 /* IWineD3DBase methods */
1067 /* IWineD3DResource methods */
1069 buffer_SetPrivateData
,
1070 buffer_GetPrivateData
,
1071 buffer_FreePrivateData
,
1077 /* IWineD3DBuffer methods */
1083 HRESULT
buffer_init(struct wined3d_buffer
*buffer
, IWineD3DDeviceImpl
*device
,
1084 UINT size
, DWORD usage
, WINED3DFORMAT format
, WINED3DPOOL pool
, GLenum bind_hint
,
1085 const char *data
, IUnknown
*parent
, const struct wined3d_parent_ops
*parent_ops
)
1087 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(format
, &device
->adapter
->gl_info
);
1092 WARN("Size 0 requested, returning WINED3DERR_INVALIDCALL\n");
1093 return WINED3DERR_INVALIDCALL
;
1096 buffer
->vtbl
= &wined3d_buffer_vtbl
;
1098 hr
= resource_init((IWineD3DResource
*)buffer
, WINED3DRTYPE_BUFFER
,
1099 device
, size
, usage
, format_desc
, pool
, parent
, parent_ops
);
1102 WARN("Failed to initialize resource, hr %#x\n", hr
);
1105 buffer
->buffer_type_hint
= bind_hint
;
1107 TRACE("size %#x, usage %#x, format %s, memory @ %p, iface @ %p.\n", buffer
->resource
.size
, buffer
->resource
.usage
,
1108 debug_d3dformat(buffer
->resource
.format_desc
->format
), buffer
->resource
.allocatedMemory
, buffer
);
1114 hr
= IWineD3DBuffer_Map((IWineD3DBuffer
*)buffer
, 0, size
, &ptr
, 0);
1117 ERR("Failed to map buffer, hr %#x\n", hr
);
1118 buffer_UnLoad((IWineD3DBuffer
*)buffer
);
1119 resource_cleanup((IWineD3DResource
*)buffer
);
1123 memcpy(ptr
, data
, size
);
1125 hr
= IWineD3DBuffer_Unmap((IWineD3DBuffer
*)buffer
);
1128 ERR("Failed to unmap buffer, hr %#x\n", hr
);
1129 buffer_UnLoad((IWineD3DBuffer
*)buffer
);
1130 resource_cleanup((IWineD3DResource
*)buffer
);