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(This
->resource
.usage
& WINED3DUSAGE_STATICDECL
) return FALSE
;
331 TRACE("Finding vertex buffer conversion information\n");
332 /* Certain declaration types need some fixups before we can pass them to
333 * opengl. This means D3DCOLOR attributes with fixed function vertex
334 * processing, FLOAT4 POSITIONT with fixed function, and FLOAT16 if
335 * GL_ARB_half_float_vertex is not supported.
337 * Note for d3d8 and d3d9:
338 * The vertex buffer FVF doesn't help with finding them, we have to use
339 * the decoded vertex declaration and pick the things that concern the
340 * current buffer. A problem with this is that this can change between
341 * draws, so we have to validate the information and reprocess the buffer
342 * if it changes, and avoid false positives for performance reasons.
343 * WineD3D doesn't even know the vertex buffer any more, it is managed
344 * by the client libraries and passed to SetStreamSource and ProcessVertices
347 * We have to distinguish between vertex shaders and fixed function to
348 * pick the way we access the strided vertex information.
350 * This code sets up a per-byte array with the size of the detected
351 * stride of the arrays in the buffer. For each byte we have a field
352 * that marks the conversion needed on this byte. For example, the
353 * following declaration with fixed function vertex processing:
361 * { POSITIONT }{ NORMAL }{ DIFFUSE }{SPECULAR }
362 * [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]
364 * Where in this example map P means 4 component position conversion, 0
365 * means no conversion, F means FLOAT16_2 conversion and C means D3DCOLOR
366 * conversion (red / blue swizzle).
368 * If we're doing conversion and the stride changes we have to reconvert
369 * the whole buffer. Note that we do not mind if the semantic changes,
370 * we only care for the conversion type. So if the NORMAL is replaced
371 * with a TEXCOORD, nothing has to be done, or if the DIFFUSE is replaced
372 * with a D3DCOLOR BLENDWEIGHT we can happily dismiss the change. Some
373 * conversion types depend on the semantic as well, for example a FLOAT4
374 * texcoord needs no conversion while a FLOAT4 positiont needs one
376 if (use_vs(device
->stateBlock
))
379 /* If the current vertex declaration is marked for no half float conversion don't bother to
380 * analyse the strided streams in depth, just set them up for no conversion. Return decl changed
381 * if we used conversion before
383 if (!((IWineD3DVertexDeclarationImpl
*) device
->stateBlock
->vertexDecl
)->half_float_conv_needed
)
385 if (This
->conversion_map
)
387 TRACE("Now using shaders without conversion, but conversion used before\n");
388 HeapFree(GetProcessHeap(), 0, This
->conversion_map
);
389 HeapFree(GetProcessHeap(), 0, This
->conversion_shift
);
390 This
->conversion_map
= NULL
;
392 This
->conversion_shift
= NULL
;
393 This
->conversion_stride
= 0;
401 for (i
= 0; i
< MAX_ATTRIBS
; ++i
)
403 ret
= buffer_check_attribute(This
, si
, i
, FALSE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
406 /* Recalculate the conversion shift map if the declaration has changed,
407 * and we're using float16 conversion or used it on the last run
409 if (ret
&& (float16_used
|| This
->conversion_map
))
411 HeapFree(GetProcessHeap(), 0, This
->conversion_shift
);
412 This
->conversion_shift
= find_conversion_shift(This
, si
, This
->stride
);
417 /* Fixed function is a bit trickier. We have to take care for D3DCOLOR types, FLOAT4 positions and of course
418 * FLOAT16s if not supported. Also, we can't iterate over the array, so use macros to generate code for all
419 * the attributes that our current fixed function pipeline implementation cares for.
421 BOOL support_d3dcolor
= gl_info
->supported
[EXT_VERTEX_ARRAY_BGRA
];
422 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_POSITION
,
423 TRUE
, TRUE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
424 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_NORMAL
,
425 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
426 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_DIFFUSE
,
427 !support_d3dcolor
, FALSE
, TRUE
, &stride_this_run
, &float16_used
) || ret
;
428 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_SPECULAR
,
429 !support_d3dcolor
, FALSE
, TRUE
, &stride_this_run
, &float16_used
) || ret
;
430 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD0
,
431 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
432 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD1
,
433 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
434 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD2
,
435 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
436 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD3
,
437 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
438 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD4
,
439 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
440 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD5
,
441 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
442 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD6
,
443 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
444 ret
= buffer_check_attribute(This
, si
, WINED3D_FFP_TEXCOORD7
,
445 TRUE
, FALSE
, FALSE
, &stride_this_run
, &float16_used
) || ret
;
447 if (float16_used
) FIXME("Float16 conversion used with fixed function vertex processing\n");
450 if (stride_this_run
== 0 && This
->conversion_map
)
453 if (!ret
) ERR("no converted attributes found, old conversion map exists, and no declaration change?\n");
454 HeapFree(GetProcessHeap(), 0, This
->conversion_map
);
455 This
->conversion_map
= NULL
;
459 if (ret
) TRACE("Conversion information changed\n");
464 /* Context activation is done by the caller. */
465 static void buffer_check_buffer_object_size(struct wined3d_buffer
*This
)
467 UINT size
= This
->conversion_stride
?
468 This
->conversion_stride
* (This
->resource
.size
/ This
->stride
) : This
->resource
.size
;
469 if (This
->buffer_object_size
!= size
)
471 TRACE("Old size %u, creating new size %u\n", This
->buffer_object_size
, size
);
473 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
475 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
478 /* Rescue the data before resizing the buffer object if we do not have our backup copy */
479 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
))
481 buffer_get_sysmem(This
);
485 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
486 checkGLcall("glBindBufferARB");
487 GL_EXTCALL(glBufferDataARB(This
->buffer_type_hint
, size
, NULL
, This
->buffer_object_usage
));
488 This
->buffer_object_size
= size
;
489 checkGLcall("glBufferDataARB");
494 static inline void fixup_d3dcolor(DWORD
*dst_color
)
496 DWORD src_color
= *dst_color
;
498 /* Color conversion like in drawStridedSlow. watch out for little endianity
499 * If we want that stuff to work on big endian machines too we have to consider more things
501 * 0xff000000: Alpha mask
502 * 0x00ff0000: Blue mask
503 * 0x0000ff00: Green mask
504 * 0x000000ff: Red mask
507 *dst_color
|= (src_color
& 0xff00ff00); /* Alpha Green */
508 *dst_color
|= (src_color
& 0x00ff0000) >> 16; /* Red */
509 *dst_color
|= (src_color
& 0x000000ff) << 16; /* Blue */
512 static inline void fixup_transformed_pos(float *p
)
514 /* rhw conversion like in position_float4(). */
515 if (p
[3] != 1.0f
&& p
[3] != 0.0f
)
517 float w
= 1.0f
/ p
[3];
525 /* Context activation is done by the caller. */
526 const BYTE
*buffer_get_memory(IWineD3DBuffer
*iface
, UINT offset
, GLuint
*buffer_object
)
528 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
530 *buffer_object
= This
->buffer_object
;
531 if (!This
->buffer_object
)
533 if (This
->flags
& WINED3D_BUFFER_CREATEBO
)
535 buffer_create_buffer_object(This
);
536 This
->flags
&= ~WINED3D_BUFFER_CREATEBO
;
537 if (This
->buffer_object
)
539 *buffer_object
= This
->buffer_object
;
540 return (const BYTE
*)offset
;
543 return This
->resource
.allocatedMemory
+ offset
;
547 return (const BYTE
*)offset
;
551 /* IUnknown methods */
553 static HRESULT STDMETHODCALLTYPE
buffer_QueryInterface(IWineD3DBuffer
*iface
,
554 REFIID riid
, void **object
)
556 TRACE("iface %p, riid %s, object %p\n", iface
, debugstr_guid(riid
), object
);
558 if (IsEqualGUID(riid
, &IID_IWineD3DBuffer
)
559 || IsEqualGUID(riid
, &IID_IWineD3DResource
)
560 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
561 || IsEqualGUID(riid
, &IID_IUnknown
))
563 IUnknown_AddRef(iface
);
568 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid
));
572 return E_NOINTERFACE
;
575 static ULONG STDMETHODCALLTYPE
buffer_AddRef(IWineD3DBuffer
*iface
)
577 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
578 ULONG refcount
= InterlockedIncrement(&This
->resource
.ref
);
580 TRACE("%p increasing refcount to %u\n", This
, refcount
);
585 /* Context activation is done by the caller. */
586 BYTE
*buffer_get_sysmem(struct wined3d_buffer
*This
)
588 /* AllocatedMemory exists if the buffer is double buffered or has no buffer object at all */
589 if(This
->resource
.allocatedMemory
) return This
->resource
.allocatedMemory
;
591 This
->resource
.heapMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->resource
.size
+ RESOURCE_ALIGNMENT
);
592 This
->resource
.allocatedMemory
= (BYTE
*)(((ULONG_PTR
)This
->resource
.heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
594 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
595 GL_EXTCALL(glGetBufferSubDataARB(This
->buffer_type_hint
, 0, This
->resource
.size
, This
->resource
.allocatedMemory
));
597 This
->flags
|= WINED3D_BUFFER_DOUBLEBUFFER
;
599 return This
->resource
.allocatedMemory
;
602 static void STDMETHODCALLTYPE
buffer_UnLoad(IWineD3DBuffer
*iface
)
604 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
606 TRACE("iface %p\n", iface
);
608 if (This
->buffer_object
)
610 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
611 struct wined3d_context
*context
;
613 context
= context_acquire(device
, NULL
, CTXUSAGE_RESOURCELOAD
);
615 /* Download the buffer, but don't permanently enable double buffering */
616 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
))
618 buffer_get_sysmem(This
);
619 This
->flags
&= ~WINED3D_BUFFER_DOUBLEBUFFER
;
623 GL_EXTCALL(glDeleteBuffersARB(1, &This
->buffer_object
));
624 checkGLcall("glDeleteBuffersARB");
626 This
->buffer_object
= 0;
627 This
->flags
|= WINED3D_BUFFER_CREATEBO
; /* Recreate the buffer object next load */
629 context_release(context
);
633 static ULONG STDMETHODCALLTYPE
buffer_Release(IWineD3DBuffer
*iface
)
635 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
636 ULONG refcount
= InterlockedDecrement(&This
->resource
.ref
);
638 TRACE("%p decreasing refcount to %u\n", This
, refcount
);
642 buffer_UnLoad(iface
);
643 resource_cleanup((IWineD3DResource
*)iface
);
644 This
->resource
.parent_ops
->wined3d_object_destroyed(This
->resource
.parent
);
645 HeapFree(GetProcessHeap(), 0, This
);
651 /* IWineD3DBase methods */
653 static HRESULT STDMETHODCALLTYPE
buffer_GetParent(IWineD3DBuffer
*iface
, IUnknown
**parent
)
655 return resource_get_parent((IWineD3DResource
*)iface
, parent
);
658 /* IWineD3DResource methods */
660 static HRESULT STDMETHODCALLTYPE
buffer_GetDevice(IWineD3DBuffer
*iface
, IWineD3DDevice
**device
)
662 return resource_get_device((IWineD3DResource
*)iface
, device
);
665 static HRESULT STDMETHODCALLTYPE
buffer_SetPrivateData(IWineD3DBuffer
*iface
,
666 REFGUID guid
, const void *data
, DWORD data_size
, DWORD flags
)
668 return resource_set_private_data((IWineD3DResource
*)iface
, guid
, data
, data_size
, flags
);
671 static HRESULT STDMETHODCALLTYPE
buffer_GetPrivateData(IWineD3DBuffer
*iface
,
672 REFGUID guid
, void *data
, DWORD
*data_size
)
674 return resource_get_private_data((IWineD3DResource
*)iface
, guid
, data
, data_size
);
677 static HRESULT STDMETHODCALLTYPE
buffer_FreePrivateData(IWineD3DBuffer
*iface
, REFGUID guid
)
679 return resource_free_private_data((IWineD3DResource
*)iface
, guid
);
682 static DWORD STDMETHODCALLTYPE
buffer_SetPriority(IWineD3DBuffer
*iface
, DWORD priority
)
684 return resource_set_priority((IWineD3DResource
*)iface
, priority
);
687 static DWORD STDMETHODCALLTYPE
buffer_GetPriority(IWineD3DBuffer
*iface
)
689 return resource_get_priority((IWineD3DResource
*)iface
);
692 static void STDMETHODCALLTYPE
buffer_PreLoad(IWineD3DBuffer
*iface
)
694 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
695 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
696 UINT start
= 0, end
= 0, vertices
;
697 struct wined3d_context
*context
;
698 BOOL decl_changed
= FALSE
;
702 TRACE("iface %p\n", iface
);
704 context
= context_acquire(device
, NULL
, CTXUSAGE_RESOURCELOAD
);
706 if (!This
->buffer_object
)
708 /* TODO: Make converting independent from VBOs */
709 if (This
->flags
& WINED3D_BUFFER_CREATEBO
)
711 buffer_create_buffer_object(This
);
712 This
->flags
&= ~WINED3D_BUFFER_CREATEBO
;
716 context_release(context
);
717 return; /* Not doing any conversion */
721 /* Reading the declaration makes only sense if the stateblock is finalized and the buffer bound to a stream */
722 if (device
->isInDraw
&& This
->bind_count
> 0)
724 decl_changed
= buffer_find_decl(This
);
725 This
->flags
|= WINED3D_BUFFER_HASDESC
;
728 if (!decl_changed
&& !(This
->flags
& WINED3D_BUFFER_HASDESC
&& This
->flags
& WINED3D_BUFFER_DIRTY
))
730 context_release(context
);
734 /* If applications change the declaration over and over, reconverting all the time is a huge
735 * performance hit. So count the declaration changes and release the VBO if there are too many
736 * of them (and thus stop converting)
740 ++This
->conversion_count
;
741 This
->draw_count
= 0;
743 if (This
->conversion_count
> VB_MAXDECLCHANGES
)
745 FIXME("Too many declaration changes, stopping converting\n");
748 GL_EXTCALL(glDeleteBuffersARB(1, &This
->buffer_object
));
749 checkGLcall("glDeleteBuffersARB");
751 This
->buffer_object
= 0;
752 HeapFree(GetProcessHeap(), 0, This
->conversion_shift
);
754 /* The stream source state handler might have read the memory of the vertex buffer already
755 * and got the memory in the vbo which is not valid any longer. Dirtify the stream source
756 * to force a reload. This happens only once per changed vertexbuffer and should occur rather
759 IWineD3DDeviceImpl_MarkStateDirty(device
, STATE_STREAMSRC
);
760 context_release(context
);
763 buffer_check_buffer_object_size(This
);
767 /* However, it is perfectly fine to change the declaration every now and then. We don't want a game that
768 * changes it every minute drop the VBO after VB_MAX_DECL_CHANGES minutes. So count draws without
769 * decl changes and reset the decl change count after a specific number of them
772 if (This
->draw_count
> VB_RESETDECLCHANGE
) This
->conversion_count
= 0;
777 /* The declaration changed, reload the whole buffer */
778 WARN("Reloading buffer because of decl change\n");
780 end
= This
->resource
.size
;
784 /* No decl change, but dirty data, reload the changed stuff */
785 if (This
->conversion_shift
)
787 if (This
->dirty_start
!= 0 || This
->dirty_end
!= 0)
789 FIXME("Implement partial buffer loading with shifted conversion\n");
792 start
= This
->dirty_start
;
793 end
= This
->dirty_end
;
796 /* Mark the buffer clean */
797 This
->flags
&= ~WINED3D_BUFFER_DIRTY
;
798 This
->dirty_start
= 0;
801 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
803 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
806 if (!This
->conversion_map
)
808 /* That means that there is nothing to fixup. Just upload from This->resource.allocatedMemory
809 * directly into the vbo. Do not free the system memory copy because drawPrimitive may need it if
810 * the stride is 0, for instancing emulation, vertex blending emulation or shader emulation.
812 TRACE("No conversion needed\n");
814 /* Nothing to do because we locked directly into the vbo */
815 if (!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
))
817 context_release(context
);
822 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
823 checkGLcall("glBindBufferARB");
824 GL_EXTCALL(glBufferSubDataARB(This
->buffer_type_hint
, start
, end
-start
, This
->resource
.allocatedMemory
+ start
));
825 checkGLcall("glBufferSubDataARB");
828 context_release(context
);
832 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
))
834 buffer_get_sysmem(This
);
837 /* Now for each vertex in the buffer that needs conversion */
838 vertices
= This
->resource
.size
/ This
->stride
;
840 if (This
->conversion_shift
)
842 TRACE("Shifted conversion\n");
843 data
= HeapAlloc(GetProcessHeap(), 0, vertices
* This
->conversion_stride
);
845 for (i
= start
/ This
->stride
; i
< min((end
/ This
->stride
) + 1, vertices
); ++i
)
847 for (j
= 0; j
< This
->stride
; ++j
)
849 switch(This
->conversion_map
[j
])
852 data
[This
->conversion_stride
* i
+ j
+ This
->conversion_shift
[j
]]
853 = This
->resource
.allocatedMemory
[This
->stride
* i
+ j
];
858 float *out
= (float *)(&data
[This
->conversion_stride
* i
+ j
+ This
->conversion_shift
[j
]]);
859 const WORD
*in
= (WORD
*)(&This
->resource
.allocatedMemory
[i
* This
->stride
+ j
]);
861 out
[1] = float_16_to_32(in
+ 1);
862 out
[0] = float_16_to_32(in
+ 0);
863 j
+= 3; /* Skip 3 additional bytes,as a FLOAT16_2 has 4 bytes */
868 FIXME("Unimplemented conversion %d in shifted conversion\n", This
->conversion_map
[j
]);
875 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
876 checkGLcall("glBindBufferARB");
877 GL_EXTCALL(glBufferSubDataARB(This
->buffer_type_hint
, 0, vertices
* This
->conversion_stride
, data
));
878 checkGLcall("glBufferSubDataARB");
883 data
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
);
884 memcpy(data
+ start
, This
->resource
.allocatedMemory
+ start
, end
- start
);
885 for (i
= start
/ This
->stride
; i
< min((end
/ This
->stride
) + 1, vertices
); ++i
)
887 for (j
= 0; j
< This
->stride
; ++j
)
889 switch(This
->conversion_map
[j
])
896 fixup_d3dcolor((DWORD
*) (data
+ i
* This
->stride
+ j
));
901 fixup_transformed_pos((float *) (data
+ i
* This
->stride
+ j
));
906 ERR("Did not expect FLOAT16 conversion in unshifted conversion\n");
908 FIXME("Unimplemented conversion %d in shifted conversion\n", This
->conversion_map
[j
]);
914 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
915 checkGLcall("glBindBufferARB");
916 GL_EXTCALL(glBufferSubDataARB(This
->buffer_type_hint
, start
, end
- start
, data
+ start
));
917 checkGLcall("glBufferSubDataARB");
921 HeapFree(GetProcessHeap(), 0, data
);
922 context_release(context
);
925 static WINED3DRESOURCETYPE STDMETHODCALLTYPE
buffer_GetType(IWineD3DBuffer
*iface
)
927 return resource_get_type((IWineD3DResource
*)iface
);
930 /* IWineD3DBuffer methods */
932 static HRESULT STDMETHODCALLTYPE
buffer_Map(IWineD3DBuffer
*iface
, UINT offset
, UINT size
, BYTE
**data
, DWORD flags
)
934 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
937 TRACE("iface %p, offset %u, size %u, data %p, flags %#x\n", iface
, offset
, size
, data
, flags
);
939 count
= InterlockedIncrement(&This
->lock_count
);
941 if (This
->flags
& WINED3D_BUFFER_DIRTY
)
943 if (This
->dirty_start
> offset
) This
->dirty_start
= offset
;
947 if (This
->dirty_end
< offset
+ size
) This
->dirty_end
= offset
+ size
;
951 This
->dirty_end
= This
->resource
.size
;
956 This
->dirty_start
= offset
;
957 if (size
) This
->dirty_end
= offset
+ size
;
958 else This
->dirty_end
= This
->resource
.size
;
961 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
) && This
->buffer_object
)
965 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
966 struct wined3d_context
*context
;
968 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
970 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
973 context
= context_acquire(device
, NULL
, CTXUSAGE_RESOURCELOAD
);
975 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
976 This
->resource
.allocatedMemory
= GL_EXTCALL(glMapBufferARB(This
->buffer_type_hint
, GL_READ_WRITE_ARB
));
978 context_release(context
);
983 This
->flags
|= WINED3D_BUFFER_DIRTY
;
986 *data
= This
->resource
.allocatedMemory
+ offset
;
988 TRACE("Returning memory at %p (base %p, offset %u)\n", *data
, This
->resource
.allocatedMemory
, offset
);
989 /* TODO: check Flags compatibility with This->currentDesc.Usage (see MSDN) */
994 static HRESULT STDMETHODCALLTYPE
buffer_Unmap(IWineD3DBuffer
*iface
)
996 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
998 TRACE("(%p)\n", This
);
1000 /* In the case that the number of Unmap calls > the
1001 * number of Map calls, d3d returns always D3D_OK.
1002 * This is also needed to prevent Map from returning garbage on
1003 * the next call (this will happen if the lock_count is < 0). */
1004 if(This
->lock_count
== 0)
1006 TRACE("Unmap called without a previous Map call!\n");
1010 if (InterlockedDecrement(&This
->lock_count
))
1012 /* Delay loading the buffer until everything is unlocked */
1013 TRACE("Ignoring unlock\n");
1017 if(!(This
->flags
& WINED3D_BUFFER_DOUBLEBUFFER
) && This
->buffer_object
)
1019 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
1020 struct wined3d_context
*context
;
1022 if(This
->buffer_type_hint
== GL_ELEMENT_ARRAY_BUFFER_ARB
)
1024 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_INDEXBUFFER
);
1027 context
= context_acquire(device
, NULL
, CTXUSAGE_RESOURCELOAD
);
1029 GL_EXTCALL(glBindBufferARB(This
->buffer_type_hint
, This
->buffer_object
));
1030 GL_EXTCALL(glUnmapBufferARB(This
->buffer_type_hint
));
1032 context_release(context
);
1034 This
->resource
.allocatedMemory
= NULL
;
1036 else if (This
->flags
& WINED3D_BUFFER_HASDESC
)
1038 buffer_PreLoad(iface
);
1044 static HRESULT STDMETHODCALLTYPE
buffer_GetDesc(IWineD3DBuffer
*iface
, WINED3DBUFFER_DESC
*desc
)
1046 struct wined3d_buffer
*This
= (struct wined3d_buffer
*)iface
;
1048 TRACE("(%p)\n", This
);
1050 desc
->Type
= This
->resource
.resourceType
;
1051 desc
->Usage
= This
->resource
.usage
;
1052 desc
->Pool
= This
->resource
.pool
;
1053 desc
->Size
= This
->resource
.size
;
1058 static const struct IWineD3DBufferVtbl wined3d_buffer_vtbl
=
1060 /* IUnknown methods */
1061 buffer_QueryInterface
,
1064 /* IWineD3DBase methods */
1066 /* IWineD3DResource methods */
1068 buffer_SetPrivateData
,
1069 buffer_GetPrivateData
,
1070 buffer_FreePrivateData
,
1076 /* IWineD3DBuffer methods */
1082 HRESULT
buffer_init(struct wined3d_buffer
*buffer
, IWineD3DDeviceImpl
*device
,
1083 UINT size
, DWORD usage
, WINED3DFORMAT format
, WINED3DPOOL pool
, GLenum bind_hint
,
1084 const char *data
, IUnknown
*parent
, const struct wined3d_parent_ops
*parent_ops
)
1086 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(format
, &device
->adapter
->gl_info
);
1091 WARN("Size 0 requested, returning WINED3DERR_INVALIDCALL\n");
1092 return WINED3DERR_INVALIDCALL
;
1095 buffer
->vtbl
= &wined3d_buffer_vtbl
;
1097 hr
= resource_init((IWineD3DResource
*)buffer
, WINED3DRTYPE_BUFFER
,
1098 device
, size
, usage
, format_desc
, pool
, parent
, parent_ops
);
1101 WARN("Failed to initialize resource, hr %#x\n", hr
);
1104 buffer
->buffer_type_hint
= bind_hint
;
1106 TRACE("size %#x, usage %#x, format %s, memory @ %p, iface @ %p.\n", buffer
->resource
.size
, buffer
->resource
.usage
,
1107 debug_d3dformat(buffer
->resource
.format_desc
->format
), buffer
->resource
.allocatedMemory
, buffer
);
1113 hr
= IWineD3DBuffer_Map((IWineD3DBuffer
*)buffer
, 0, size
, &ptr
, 0);
1116 ERR("Failed to map buffer, hr %#x\n", hr
);
1117 buffer_UnLoad((IWineD3DBuffer
*)buffer
);
1118 resource_cleanup((IWineD3DResource
*)buffer
);
1122 memcpy(ptr
, data
, size
);
1124 hr
= IWineD3DBuffer_Unmap((IWineD3DBuffer
*)buffer
);
1127 ERR("Failed to unmap buffer, hr %#x\n", hr
);
1128 buffer_UnLoad((IWineD3DBuffer
*)buffer
);
1129 resource_cleanup((IWineD3DResource
*)buffer
);