2 * IWineD3DVertexBuffer Implementation
4 * Copyright 2002-2005 Jason Edmeades
6 * Copyright 2004 Christian Costa
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wined3d_private.h"
26 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
27 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
29 #define VB_MAXDECLCHANGES 100 /* After that number we stop converting */
30 #define VB_RESETDECLCHANGE 1000 /* Reset the changecount after that number of draws */
32 /* *******************************************
33 IWineD3DVertexBuffer IUnknown parts follow
34 ******************************************* */
35 static HRESULT WINAPI
IWineD3DVertexBufferImpl_QueryInterface(IWineD3DVertexBuffer
*iface
, REFIID riid
, LPVOID
*ppobj
)
37 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
38 TRACE("(%p)->(%s,%p)\n",This
,debugstr_guid(riid
),ppobj
);
39 if (IsEqualGUID(riid
, &IID_IUnknown
)
40 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
41 || IsEqualGUID(riid
, &IID_IWineD3DResource
)
42 || IsEqualGUID(riid
, &IID_IWineD3DVertexBuffer
)){
43 IUnknown_AddRef(iface
);
51 static ULONG WINAPI
IWineD3DVertexBufferImpl_AddRef(IWineD3DVertexBuffer
*iface
) {
52 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
53 ULONG ref
= InterlockedIncrement(&This
->resource
.ref
);
54 TRACE("(%p) : AddRef increasing from %d\n", This
, ref
- 1);
58 static ULONG WINAPI
IWineD3DVertexBufferImpl_Release(IWineD3DVertexBuffer
*iface
) {
59 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
60 ULONG ref
= InterlockedDecrement(&This
->resource
.ref
);
61 TRACE("(%p) : Releasing from %d\n", This
, ref
+ 1);
65 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
68 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
69 GL_EXTCALL(glDeleteBuffersARB(1, &This
->vbo
));
70 checkGLcall("glDeleteBuffersARB");
74 IWineD3DResourceImpl_CleanUp((IWineD3DResource
*)iface
);
75 HeapFree(GetProcessHeap(), 0, This
);
80 /* ****************************************************
81 IWineD3DVertexBuffer IWineD3DResource parts follow
82 **************************************************** */
83 static HRESULT WINAPI
IWineD3DVertexBufferImpl_GetDevice(IWineD3DVertexBuffer
*iface
, IWineD3DDevice
** ppDevice
) {
84 return IWineD3DResourceImpl_GetDevice((IWineD3DResource
*)iface
, ppDevice
);
87 static HRESULT WINAPI
IWineD3DVertexBufferImpl_SetPrivateData(IWineD3DVertexBuffer
*iface
, REFGUID refguid
, CONST
void* pData
, DWORD SizeOfData
, DWORD Flags
) {
88 return IWineD3DResourceImpl_SetPrivateData((IWineD3DResource
*)iface
, refguid
, pData
, SizeOfData
, Flags
);
91 static HRESULT WINAPI
IWineD3DVertexBufferImpl_GetPrivateData(IWineD3DVertexBuffer
*iface
, REFGUID refguid
, void* pData
, DWORD
* pSizeOfData
) {
92 return IWineD3DResourceImpl_GetPrivateData((IWineD3DResource
*)iface
, refguid
, pData
, pSizeOfData
);
95 static HRESULT WINAPI
IWineD3DVertexBufferImpl_FreePrivateData(IWineD3DVertexBuffer
*iface
, REFGUID refguid
) {
96 return IWineD3DResourceImpl_FreePrivateData((IWineD3DResource
*)iface
, refguid
);
99 static DWORD WINAPI
IWineD3DVertexBufferImpl_SetPriority(IWineD3DVertexBuffer
*iface
, DWORD PriorityNew
) {
100 return IWineD3DResourceImpl_SetPriority((IWineD3DResource
*)iface
, PriorityNew
);
103 static DWORD WINAPI
IWineD3DVertexBufferImpl_GetPriority(IWineD3DVertexBuffer
*iface
) {
104 return IWineD3DResourceImpl_GetPriority((IWineD3DResource
*)iface
);
107 static void fixup_vertices(
108 BYTE
*src
, BYTE
*dst
,
111 int pos
, BOOL haspos
,
112 int diffuse
, BOOL hasdiffuse
,
113 int specular
, BOOL hasspecular
118 for(i
= num
- 1; i
>= 0; i
--) {
120 float *p
= (float *) ((src
+ pos
) + i
* stride
);
122 /* rhw conversion like in drawStridedSlow */
123 if(p
[3] == 1.0 || ((p
[3] < eps
) && (p
[3] > -eps
))) {
134 p
= (float *) (dst
+ i
* stride
+ pos
);
141 DWORD srcColor
, *dstColor
= (DWORD
*) (dst
+ i
* stride
+ diffuse
);
142 srcColor
= * (DWORD
*) ( (src
+ diffuse
) + i
* stride
);
144 /* Color conversion like in drawStridedSlow. watch out for little endianity
145 * If we want that stuff to work on big endian machines too we have to consider more things
147 * 0xff000000: Alpha mask
148 * 0x00ff0000: Blue mask
149 * 0x0000ff00: Green mask
150 * 0x000000ff: Red mask
154 *dstColor
|= (srcColor
& 0xff00ff00) ; /* Alpha Green */
155 *dstColor
|= (srcColor
& 0x00ff0000) >> 16; /* Red */
156 *dstColor
|= (srcColor
& 0x000000ff) << 16; /* Blue */
159 DWORD srcColor
, *dstColor
= (DWORD
*) (dst
+ i
* stride
+ specular
);
160 srcColor
= * (DWORD
*) ( (src
+ specular
) + i
* stride
);
162 /* Similar to diffuse
163 * TODO: Write the alpha value out for fog coords
166 *dstColor
|= (srcColor
& 0xff00ff00) ; /* Alpha Green */
167 *dstColor
|= (srcColor
& 0x00ff0000) >> 16; /* Red */
168 *dstColor
|= (srcColor
& 0x000000ff) << 16; /* Blue */
173 inline BOOL WINAPI
IWineD3DVertexBufferImpl_FindDecl(IWineD3DVertexBufferImpl
*This
)
175 WineDirect3DVertexStridedData strided
;
176 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
178 /* In d3d7 the vertex buffer declaration NEVER changes because it is stored in the d3d7 vertex buffer.
179 * Once we have our declaration there is no need to look it up again.
181 if(((IWineD3DImpl
*)device
->wineD3D
)->dxVersion
== 7 && This
->Flags
& VBFLAG_HASDESC
) {
185 /* There are certain vertex data types that need to be fixed up. The Vertex Buffers FVF doesn't
186 * help finding them, only the vertex declaration or the device FVF can determine that at drawPrim
187 * time. Rules are as follows:
189 * -> No modification when Vertex Shaders are used
190 * -> Fix up position1 and position 2 if they are XYZRHW
191 * -> Fix up diffuse color
192 * -> Fix up specular color
194 * The Declaration is only known at drawing time, and it can change from draw to draw. If any converted values
195 * are changed, the whole buffer has to be reconverted and reloaded. (Converting is SLOW, so if this happens too
196 * often PreLoad stops converting entirely and falls back to drawStridedSlow).
199 * -> New semantics that have to be converted appear
200 * -> The position of semantics that have to be converted changes
201 * -> The stride of the vertex changed AND there is stuff that needs conversion
202 * -> (If a vertex shader is bound and in use assume that nothing that needs conversion is there)
205 * TRUE: Reload is needed
209 if (use_vs(device
)) {
210 /* Assume no conversion */
211 memset(&strided
, 0, sizeof(strided
));
213 /* we need a copy because we modify some params */
214 memcpy(&strided
, &device
->strided_streams
, sizeof(strided
));
216 /* Filter out data that does not come from this VBO */
217 if(strided
.u
.s
.position
.VBO
!= This
->vbo
) memset(&strided
.u
.s
.position
, 0, sizeof(strided
.u
.s
.position
));
218 if(strided
.u
.s
.diffuse
.VBO
!= This
->vbo
) memset(&strided
.u
.s
.diffuse
, 0, sizeof(strided
.u
.s
.diffuse
));
219 if(strided
.u
.s
.specular
.VBO
!= This
->vbo
) memset(&strided
.u
.s
.specular
, 0, sizeof(strided
.u
.s
.specular
));
220 if(strided
.u
.s
.position2
.VBO
!= This
->vbo
) memset(&strided
.u
.s
.position2
, 0, sizeof(strided
.u
.s
.position2
));
223 /* We have a declaration now in the buffer */
224 This
->Flags
|= VBFLAG_HASDESC
;
226 /* Find out if reload is needed
227 * Position of the semantic in the vertex and the stride must be equal to the stored type. Don't mind if only unconverted stuff changed.
229 * If some stuff does not exist in the buffer, then lpData, dwStride and dwType are memsetted to 0. So if the semantic didn't exist before
230 * and does not exist now all 3 values will be equal(=0).
232 * Checking the lpData field alone is not enough, because data may appear at offset 0 in the buffer. This is the same location as nonexistent
233 * data uses, so we have to check the type and stride too. Colors can be at offset 0 too, because it is perfectly fine to render from 2 or more
234 * buffers at the same time and get the position from one and the color from the other buffer.
236 if( /* Position transformed vs untransformed */
237 ((This
->strided
.u
.s
.position_transformed
|| strided
.u
.s
.position_transformed
) &&
238 This
->strided
.u
.s
.position
.lpData
!= strided
.u
.s
.position
.lpData
) ||
239 /* Diffuse position and data type */
240 This
->strided
.u
.s
.diffuse
.lpData
!= strided
.u
.s
.diffuse
.lpData
|| This
->strided
.u
.s
.diffuse
.dwStride
!= strided
.u
.s
.diffuse
.dwStride
||
241 This
->strided
.u
.s
.diffuse
.dwType
!= strided
.u
.s
.diffuse
.dwType
||
242 /* Specular position and data type */
243 This
->strided
.u
.s
.specular
.lpData
!= strided
.u
.s
.specular
.lpData
|| This
->strided
.u
.s
.specular
.dwStride
!= strided
.u
.s
.specular
.dwStride
||
244 This
->strided
.u
.s
.specular
.dwType
!= strided
.u
.s
.specular
.dwType
) {
246 TRACE("Declaration changed, reloading buffer\n");
247 /* Set the new description */
248 memcpy(&This
->strided
, &strided
, sizeof(strided
));
255 static void WINAPI
IWineD3DVertexBufferImpl_PreLoad(IWineD3DVertexBuffer
*iface
) {
256 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*) iface
;
257 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
259 UINT start
= 0, end
= 0, stride
= 0;
260 BOOL declChanged
= FALSE
;
261 TRACE("(%p)->()\n", This
);
263 if(This
->Flags
& VBFLAG_LOAD
) {
264 return; /* Already doing that stuff */
268 /* TODO: Make converting independent from VBOs */
269 return; /* Not doing any conversion */
272 /* Reading the declaration makes only sense if the stateblock is finalized and the buffer bound to a stream */
273 if(device
->isInDraw
&& This
->bindCount
> 0) {
274 declChanged
= IWineD3DVertexBufferImpl_FindDecl(This
);
275 } else if(This
->Flags
& VBFLAG_HASDESC
) {
276 /* Reuse the declaration stored in the buffer. It will most likely not change, and if it does
277 * the stream source state handler will call PreLoad again and the change will be cought
280 /* Cannot get a declaration, and no declaration is stored in the buffer. It is pointless to preload
281 * now. When the buffer is used, PreLoad will be called by the stream source state handler and a valid
282 * declaration for the buffer can be found
287 /* If applications change the declaration over and over, reconverting all the time is a huge
288 * performance hit. So count the declaration changes and release the VBO if there are too much
289 * of them(and thus stop converting)
295 if(This
->declChanges
> VB_MAXDECLCHANGES
) {
296 FIXME("Too much declaration changes, stopping converting\n");
298 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
299 GL_EXTCALL(glDeleteBuffersARB(1, &This
->vbo
));
300 checkGLcall("glDeleteBuffersARB");
304 /* The stream source state handler might have read the memory of the vertex buffer already
305 * and got the memory in the vbo which is not valid any longer. Dirtify the stream source
306 * to force a reload. This happens only once per changed vertexbuffer and should occur rather
309 IWineD3DDeviceImpl_MarkStateDirty(device
, STATE_STREAMSRC
);
314 /* However, it is perfectly fine to change the declaration every now and then. We don't want a game that
315 * changes it every minute drop the VBO after VB_MAX_DECL_CHANGES minutes. So count draws without
316 * decl changes and reset the decl change count after a specific number of them
319 if(This
->draws
> VB_RESETDECLCHANGE
) This
->declChanges
= 0;
323 /* The declaration changed, reload the whole buffer */
324 WARN("Reloading buffer because of decl change\n");
326 end
= This
->resource
.size
;
327 } else if(This
->Flags
& VBFLAG_DIRTY
) {
328 /* No decl change, but dirty data, reload the changed stuff */
329 start
= This
->dirtystart
;
330 end
= This
->dirtyend
;
332 /* Desc not changed, buffer not dirty, nothing to do :-) */
336 /* Mark the buffer clean */
337 This
->Flags
&= ~VBFLAG_DIRTY
;
338 This
->dirtystart
= 0;
341 if (This
->strided
.u
.s
.position
.dwStride
) stride
= This
->strided
.u
.s
.position
.dwStride
;
342 else if(This
->strided
.u
.s
.specular
.dwStride
) stride
= This
->strided
.u
.s
.specular
.dwStride
;
343 else if(This
->strided
.u
.s
.diffuse
.dwStride
) stride
= This
->strided
.u
.s
.diffuse
.dwStride
;
345 /* That means that there is nothing to fixup. Just upload from This->resource.allocatedMemory
346 * directly into the vbo. Do not free the system memory copy because drawPrimitive may need it if
347 * the stride is 0, for instancing emulation, vertex blending emulation or shader emulation.
349 TRACE("No conversion needed, locking directly into the VBO in future\n");
352 if(!device
->isInDraw
) {
353 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
355 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, This
->vbo
));
356 checkGLcall("glBindBufferARB");
357 GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB
, start
, end
-start
, This
->resource
.allocatedMemory
+ start
));
358 checkGLcall("glBufferSubDataARB");
363 /* OK, we have the original data from the app, the description of the buffer and the dirty area.
364 * so convert the stuff
366 data
= HeapAlloc(GetProcessHeap(), 0, end
-start
);
368 ERR("Out of memory\n");
371 memcpy(data
, This
->resource
.allocatedMemory
+ start
, end
- start
);
373 fixup_vertices(data
, data
, stride
, ( end
- start
) / stride
,
375 (int)This
->strided
.u
.s
.position
.lpData
, /* Data location */
376 This
->strided
.u
.s
.position_transformed
, /* Do convert? */
378 (int)This
->strided
.u
.s
.diffuse
.lpData
, /* Location */
379 This
->strided
.u
.s
.diffuse
.dwType
== WINED3DDECLTYPE_SHORT4
|| This
->strided
.u
.s
.diffuse
.dwType
== WINED3DDECLTYPE_D3DCOLOR
, /* Convert? */
381 (int)This
->strided
.u
.s
.specular
.lpData
, /* location */
382 This
->strided
.u
.s
.specular
.dwType
== WINED3DDECLTYPE_SHORT4
|| This
->strided
.u
.s
.specular
.dwType
== WINED3DDECLTYPE_D3DCOLOR
);
385 if(!device
->isInDraw
) {
386 ActivateContext(device
, device
->lastActiveRenderTarget
, CTXUSAGE_RESOURCELOAD
);
388 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, This
->vbo
));
389 checkGLcall("glBindBufferARB");
390 GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB
, start
, end
- start
, data
));
391 checkGLcall("glBufferSubDataARB");
394 HeapFree(GetProcessHeap(), 0, data
);
397 static WINED3DRESOURCETYPE WINAPI
IWineD3DVertexBufferImpl_GetType(IWineD3DVertexBuffer
*iface
) {
398 return IWineD3DResourceImpl_GetType((IWineD3DResource
*)iface
);
401 static HRESULT WINAPI
IWineD3DVertexBufferImpl_GetParent(IWineD3DVertexBuffer
*iface
, IUnknown
**pParent
) {
402 return IWineD3DResourceImpl_GetParent((IWineD3DResource
*)iface
, pParent
);
405 /* ******************************************************
406 IWineD3DVertexBuffer IWineD3DVertexBuffer parts follow
407 ****************************************************** */
408 static HRESULT WINAPI
IWineD3DVertexBufferImpl_Lock(IWineD3DVertexBuffer
*iface
, UINT OffsetToLock
, UINT SizeToLock
, BYTE
** ppbData
, DWORD Flags
) {
409 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
411 TRACE("(%p)->%d, %d, %p, %08x\n", This
, OffsetToLock
, SizeToLock
, ppbData
, Flags
);
413 InterlockedIncrement(&This
->lockcount
);
415 if(This
->Flags
& VBFLAG_DIRTY
) {
416 if(This
->dirtystart
> OffsetToLock
) This
->dirtystart
= OffsetToLock
;
418 if(This
->dirtyend
< OffsetToLock
+ SizeToLock
) This
->dirtyend
= OffsetToLock
+ SizeToLock
;
420 This
->dirtyend
= This
->resource
.size
;
423 This
->dirtystart
= OffsetToLock
;
425 This
->dirtyend
= OffsetToLock
+ SizeToLock
;
427 This
->dirtyend
= This
->resource
.size
;
430 data
= This
->resource
.allocatedMemory
;
431 This
->Flags
|= VBFLAG_DIRTY
;
432 *ppbData
= data
+ OffsetToLock
;
434 TRACE("(%p) : returning memory of %p (base:%p,offset:%u)\n", This
, data
+ OffsetToLock
, data
, OffsetToLock
);
435 /* TODO: check Flags compatibility with This->currentDesc.Usage (see MSDN) */
438 HRESULT WINAPI
IWineD3DVertexBufferImpl_Unlock(IWineD3DVertexBuffer
*iface
) {
439 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*) iface
;
441 TRACE("(%p)\n", This
);
443 lockcount
= InterlockedDecrement(&This
->lockcount
);
445 /* Delay loading the buffer until everything is unlocked */
446 TRACE("Ignoring the unlock\n");
450 if(This
->Flags
& VBFLAG_HASDESC
) {
451 IWineD3DVertexBufferImpl_PreLoad(iface
);
455 static HRESULT WINAPI
IWineD3DVertexBufferImpl_GetDesc(IWineD3DVertexBuffer
*iface
, WINED3DVERTEXBUFFER_DESC
*pDesc
) {
456 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
458 TRACE("(%p)\n", This
);
459 pDesc
->Format
= This
->resource
.format
;
460 pDesc
->Type
= This
->resource
.resourceType
;
461 pDesc
->Usage
= This
->resource
.usage
;
462 pDesc
->Pool
= This
->resource
.pool
;
463 pDesc
->Size
= This
->resource
.size
;
464 pDesc
->FVF
= This
->fvf
;
468 const IWineD3DVertexBufferVtbl IWineD3DVertexBuffer_Vtbl
=
471 IWineD3DVertexBufferImpl_QueryInterface
,
472 IWineD3DVertexBufferImpl_AddRef
,
473 IWineD3DVertexBufferImpl_Release
,
474 /* IWineD3DResource */
475 IWineD3DVertexBufferImpl_GetParent
,
476 IWineD3DVertexBufferImpl_GetDevice
,
477 IWineD3DVertexBufferImpl_SetPrivateData
,
478 IWineD3DVertexBufferImpl_GetPrivateData
,
479 IWineD3DVertexBufferImpl_FreePrivateData
,
480 IWineD3DVertexBufferImpl_SetPriority
,
481 IWineD3DVertexBufferImpl_GetPriority
,
482 IWineD3DVertexBufferImpl_PreLoad
,
483 IWineD3DVertexBufferImpl_GetType
,
484 /* IWineD3DVertexBuffer */
485 IWineD3DVertexBufferImpl_Lock
,
486 IWineD3DVertexBufferImpl_Unlock
,
487 IWineD3DVertexBufferImpl_GetDesc
490 BYTE
* WINAPI
IWineD3DVertexBufferImpl_GetMemory(IWineD3DVertexBuffer
* iface
, DWORD iOffset
, GLint
*vbo
) {
491 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
495 return This
->resource
.allocatedMemory
+ iOffset
;
497 return (BYTE
*) iOffset
;
501 HRESULT WINAPI
IWineD3DVertexBufferImpl_ReleaseMemory(IWineD3DVertexBuffer
* iface
) {