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 ((IWineD3DImpl *)(((IWineD3DDeviceImpl *)This->resource.wineD3DDevice)->wineD3D))->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);
66 GL_EXTCALL(glDeleteBuffersARB(1, &This
->vbo
));
67 checkGLcall("glDeleteBuffersARB");
71 IWineD3DResourceImpl_CleanUp((IWineD3DResource
*)iface
);
72 HeapFree(GetProcessHeap(), 0, This
);
77 /* ****************************************************
78 IWineD3DVertexBuffer IWineD3DResource parts follow
79 **************************************************** */
80 static HRESULT WINAPI
IWineD3DVertexBufferImpl_GetDevice(IWineD3DVertexBuffer
*iface
, IWineD3DDevice
** ppDevice
) {
81 return IWineD3DResourceImpl_GetDevice((IWineD3DResource
*)iface
, ppDevice
);
84 static HRESULT WINAPI
IWineD3DVertexBufferImpl_SetPrivateData(IWineD3DVertexBuffer
*iface
, REFGUID refguid
, CONST
void* pData
, DWORD SizeOfData
, DWORD Flags
) {
85 return IWineD3DResourceImpl_SetPrivateData((IWineD3DResource
*)iface
, refguid
, pData
, SizeOfData
, Flags
);
88 static HRESULT WINAPI
IWineD3DVertexBufferImpl_GetPrivateData(IWineD3DVertexBuffer
*iface
, REFGUID refguid
, void* pData
, DWORD
* pSizeOfData
) {
89 return IWineD3DResourceImpl_GetPrivateData((IWineD3DResource
*)iface
, refguid
, pData
, pSizeOfData
);
92 static HRESULT WINAPI
IWineD3DVertexBufferImpl_FreePrivateData(IWineD3DVertexBuffer
*iface
, REFGUID refguid
) {
93 return IWineD3DResourceImpl_FreePrivateData((IWineD3DResource
*)iface
, refguid
);
96 static DWORD WINAPI
IWineD3DVertexBufferImpl_SetPriority(IWineD3DVertexBuffer
*iface
, DWORD PriorityNew
) {
97 return IWineD3DResourceImpl_SetPriority((IWineD3DResource
*)iface
, PriorityNew
);
100 static DWORD WINAPI
IWineD3DVertexBufferImpl_GetPriority(IWineD3DVertexBuffer
*iface
) {
101 return IWineD3DResourceImpl_GetPriority((IWineD3DResource
*)iface
);
104 static void fixup_vertices(BYTE
*src
, BYTE
*dst
, int stride
, int num
, BYTE
*pos
, BOOL haspos
, BYTE
*diffuse
, BOOL hasdiffuse
, BYTE
*specular
, BOOL hasspecular
) {
108 for(i
= num
- 1; i
>= 0; i
--) {
110 float *p
= (float *) (((int) src
+ (int) pos
) + i
* stride
);
112 /* rhw conversion like in drawStridedSlow */
113 if(p
[3] == 1.0 || ((p
[3] < eps
) && (p
[3] > -eps
))) {
124 p
= (float *) ((int) dst
+ i
* stride
+ (int) pos
);
131 DWORD srcColor
, *dstColor
= (DWORD
*) (dst
+ i
* stride
+ (int) diffuse
);
132 srcColor
= * (DWORD
*) ( ((int) src
+ (int) diffuse
) + i
* stride
);
134 /* Color conversion like in drawStridedSlow. watch out for little endianity
135 * If we want that stuff to work on big endian machines too we have to consider more things
137 * 0xff000000: Alpha mask
138 * 0x00ff0000: Blue mask
139 * 0x0000ff00: Green mask
140 * 0x000000ff: Red mask
144 *dstColor
|= (srcColor
& 0xff00ff00) ; /* Alpha Green */
145 *dstColor
|= (srcColor
& 0x00ff0000) >> 16; /* Red */
146 *dstColor
|= (srcColor
& 0x000000ff) << 16; /* Blue */
149 DWORD srcColor
, *dstColor
= (DWORD
*) (dst
+ i
* stride
+ (int) specular
);
150 srcColor
= * (DWORD
*) ( ((int) src
+ (int) specular
) + i
* stride
);
152 /* Similar to diffuse
153 * TODO: Write the alpha value out for fog coords
156 *dstColor
|= (srcColor
& 0xff00ff00) ; /* Alpha Green */
157 *dstColor
|= (srcColor
& 0x00ff0000) >> 16; /* Red */
158 *dstColor
|= (srcColor
& 0x000000ff) << 16; /* Blue */
163 inline BOOL WINAPI
IWineD3DVertexBufferImpl_FindDecl(IWineD3DVertexBufferImpl
*This
)
165 WineDirect3DVertexStridedData strided
;
166 IWineD3DDeviceImpl
*device
= This
->resource
.wineD3DDevice
;
169 memset(&strided
, 0, sizeof(strided
));
170 /* There are certain vertex data types that need to be fixed up. The Vertex Buffers FVF doesn't
171 * help finding them, only the vertex declaration or the device FVF can determine that at drawPrim
172 * time. Rules are as follows:
174 * -> No modification when Vertex Shaders are used
175 * -> Fix up position1 and position 2 if they are XYZRHW
176 * -> Fix up diffuse color
177 * -> Fix up specular color
179 * The Declaration is only known at drawing time, and it can change from draw to draw. If any converted values
180 * are changed, the whole buffer has to be reconverted and reloaded. (Converting is SLOW, so if this happens too
181 * often PreLoad stops converting entirely and falls back to drawStridedSlow).
184 * -> New semantics that have to be converted appear
185 * -> The position of semantics that have to be converted changes
186 * -> The stride of the vertex changed AND there is stuff that needs conversion
187 * -> (If a vertex buffer is bound and in use assume that nothing that needs conversion is there)
190 * TRUE: Reload is needed
194 if(device
->stateBlock
->vertexShader
!= NULL
&& wined3d_settings
.vs_mode
!= VS_NONE
195 &&((IWineD3DVertexShaderImpl
*)device
->stateBlock
->vertexShader
)->baseShader
.function
!= NULL
196 && GL_SUPPORT(ARB_VERTEX_PROGRAM
)) {
197 /* Case 1: Vertex Shader: No conversion */
198 TRACE("Vertex Shader, no conversion needed\n");
199 } else if(device
->stateBlock
->vertexDecl
|| device
->stateBlock
->vertexShader
) {
200 /* Case 2: Vertex Declaration */
201 TRACE("Using vertex declaration\n");
203 This
->Flags
|= VBFLAG_LOAD
;
204 primitiveDeclarationConvertToStridedData((IWineD3DDevice
*) device
,
208 &ret
/* buffer contains fixed data, ignored here */);
209 This
->Flags
&= ~VBFLAG_LOAD
;
213 if(!(This
->Flags
& VBFLAG_STREAM
) ) {
214 TRACE("No vertex decl used and buffer is not bound to a stream\n");
215 /* No reload needed */
218 This
->Flags
|= VBFLAG_LOAD
;
219 primitiveConvertFVFtoOffset(device
->stateBlock
->fvf
,
220 device
->stateBlock
->streamStride
[This
->stream
],
224 This
->Flags
&= ~VBFLAG_LOAD
;
225 /* Data can only come from this buffer */
229 /* Filter out data that does not come from this VBO */
230 if(strided
.u
.s
.position
.VBO
!= This
->vbo
) memset(&strided
.u
.s
.position
, 0, sizeof(strided
.u
.s
.position
));
231 if(strided
.u
.s
.diffuse
.VBO
!= This
->vbo
) memset(&strided
.u
.s
.diffuse
, 0, sizeof(strided
.u
.s
.diffuse
));
232 if(strided
.u
.s
.specular
.VBO
!= This
->vbo
) memset(&strided
.u
.s
.specular
, 0, sizeof(strided
.u
.s
.specular
));
233 if(strided
.u
.s
.position2
.VBO
!= This
->vbo
) memset(&strided
.u
.s
.position2
, 0, sizeof(strided
.u
.s
.position2
));
235 /* We have a declaration now in the buffer */
236 This
->Flags
|= VBFLAG_HASDESC
;
238 /* Find out if reload is needed
239 * 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.
241 * 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
242 * and does not exist now all 3 values will be equal(=0).
244 * 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
245 * 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
246 * buffers at the same time and get the position from one and the color from the other buffer.
248 if( /* Position transformed vs untransformed */
249 ((This
->strided
.u
.s
.position_transformed
|| strided
.u
.s
.position_transformed
) &&
250 This
->strided
.u
.s
.position
.lpData
!= strided
.u
.s
.position
.lpData
) ||
251 /* Diffuse position and data type */
252 This
->strided
.u
.s
.diffuse
.lpData
!= strided
.u
.s
.diffuse
.lpData
|| This
->strided
.u
.s
.diffuse
.dwStride
!= strided
.u
.s
.diffuse
.dwStride
||
253 This
->strided
.u
.s
.diffuse
.dwType
!= strided
.u
.s
.diffuse
.dwType
||
254 /* Specular position and data type */
255 This
->strided
.u
.s
.specular
.lpData
!= strided
.u
.s
.specular
.lpData
|| This
->strided
.u
.s
.specular
.dwStride
!= strided
.u
.s
.specular
.dwStride
||
256 This
->strided
.u
.s
.specular
.dwType
!= strided
.u
.s
.specular
.dwType
) {
258 TRACE("Declaration changed, reloading buffer\n");
259 /* Set the new description */
260 memcpy(&This
->strided
, &strided
, sizeof(strided
));
267 static void WINAPI
IWineD3DVertexBufferImpl_PreLoad(IWineD3DVertexBuffer
*iface
) {
268 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*) iface
;
270 UINT start
= 0, end
= 0, stride
= 0;
271 BOOL declChanged
= FALSE
;
272 TRACE("(%p)->()\n", This
);
274 if(This
->Flags
& VBFLAG_LOAD
) {
275 return; /* Already doing that stuff */
279 /* TODO: Make converting independent from VBOs */
280 return; /* Not doing any conversion */
283 declChanged
= IWineD3DVertexBufferImpl_FindDecl(This
);
285 /* If applications change the declaration over and over, reconverting all the time is a huge
286 * performance hit. So count the declaration changes and release the VBO if there are too much
287 * of them(and thus stop converting)
293 if(This
->declChanges
> VB_MAXDECLCHANGES
) {
294 if(This
->resource
.allocatedMemory
) {
295 FIXME("Too much declaration changes, stopping converting\n");
297 GL_EXTCALL(glDeleteBuffersARB(1, &This
->vbo
));
298 checkGLcall("glDeleteBuffersARB");
303 /* Otherwise do not bother to release the VBO. If we're doing direct locking now,
304 * and the declarations changed the code below will fetch the VBO's contents, convert
305 * and on the next decl change the data will be in sysmem too and we can just release the VBO
309 /* However, it is perfectly fine to change the declaration every now and then. We don't want a game that
310 * changes it every minute drop the VBO after VB_MAX_DECL_CHANGES minutes. So count draws without
311 * decl changes and reset the decl change count after a specific number of them
314 if(This
->draws
> VB_RESETDECLCHANGE
) This
->declChanges
= 0;
318 /* The declaration changed, reload the whole buffer */
319 WARN("Reloading buffer because of decl change\n");
321 end
= This
->resource
.size
;
322 } else if(This
->Flags
& VBFLAG_DIRTY
) {
323 /* No decl change, but dirty data, reload the changed stuff */
324 start
= This
->dirtystart
;
325 end
= This
->dirtyend
;
327 /* Desc not changed, buffer not dirty, nothing to do :-) */
331 /* Mark the buffer clean */
332 This
->Flags
&= ~VBFLAG_DIRTY
;
333 This
->dirtystart
= 0;
336 /* If there was no conversion done before, then resource.allocatedMemory does not exist
337 * because locking was done directly into the VBO. In this case get the data out
339 if(declChanged
&& !This
->resource
.allocatedMemory
) {
341 This
->resource
.allocatedMemory
= HeapAlloc(GetProcessHeap(), 0, This
->resource
.size
);
342 if(!This
->resource
.allocatedMemory
) {
343 ERR("Out of memory when allocating memory for a vertex buffer\n");
346 ERR("Was locking directly into the VBO, reading data back because conv is needed\n");
349 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, This
->vbo
));
350 checkGLcall("glBindBufferARB");
351 data
= GL_EXTCALL(glMapBufferARB(GL_ARRAY_BUFFER_ARB
, GL_READ_WRITE_ARB
));
353 ERR("glMapBuffer failed!\n");
357 memcpy(This
->resource
.allocatedMemory
, data
, This
->resource
.size
);
358 GL_EXTCALL(glUnmapBufferARB(GL_ARRAY_BUFFER_ARB
));
359 checkGLcall("glUnmapBufferARB");
363 if (This
->strided
.u
.s
.position
.dwStride
) stride
= This
->strided
.u
.s
.position
.dwStride
;
364 else if(This
->strided
.u
.s
.specular
.dwStride
) stride
= This
->strided
.u
.s
.specular
.dwStride
;
365 else if(This
->strided
.u
.s
.diffuse
.dwStride
) stride
= This
->strided
.u
.s
.diffuse
.dwStride
;
367 /* That means that there is nothing to fixup. Upload everything into the VBO and
368 * free This->resource.allocatedMemory
370 TRACE("No conversion needed, locking directly into the VBO in future\n");
373 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, This
->vbo
));
374 checkGLcall("glBindBufferARB");
375 GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB
, 0, This
->resource
.size
, This
->resource
.allocatedMemory
));
376 checkGLcall("glBufferSubDataARB");
381 /* OK, we have the original data from the app, the description of the buffer and the dirty area.
382 * so convert the stuff
384 data
= HeapAlloc(GetProcessHeap(), 0, end
-start
);
386 ERR("Out of memory\n");
389 memcpy(data
, This
->resource
.allocatedMemory
+ start
, end
- start
);
391 fixup_vertices(data
, data
, stride
, ( end
- start
) / stride
,
393 This
->strided
.u
.s
.position
.lpData
, /* Data location */
394 This
->strided
.u
.s
.position_transformed
, /* Do convert? */
396 This
->strided
.u
.s
.diffuse
.lpData
, /* Location */
397 This
->strided
.u
.s
.diffuse
.dwType
== WINED3DDECLTYPE_SHORT4
|| This
->strided
.u
.s
.diffuse
.dwType
== WINED3DDECLTYPE_D3DCOLOR
, /* Convert? */
399 This
->strided
.u
.s
.specular
.lpData
, /* location */
400 This
->strided
.u
.s
.specular
.dwType
== WINED3DDECLTYPE_SHORT4
|| This
->strided
.u
.s
.specular
.dwType
== WINED3DDECLTYPE_D3DCOLOR
);
403 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, This
->vbo
));
404 checkGLcall("glBindBufferARB");
405 GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB
, start
, end
- start
, data
));
406 checkGLcall("glBufferSubDataARB");
409 HeapFree(GetProcessHeap(), 0, data
);
412 static WINED3DRESOURCETYPE WINAPI
IWineD3DVertexBufferImpl_GetType(IWineD3DVertexBuffer
*iface
) {
413 return IWineD3DResourceImpl_GetType((IWineD3DResource
*)iface
);
416 static HRESULT WINAPI
IWineD3DVertexBufferImpl_GetParent(IWineD3DVertexBuffer
*iface
, IUnknown
**pParent
) {
417 return IWineD3DResourceImpl_GetParent((IWineD3DResource
*)iface
, pParent
);
420 /* ******************************************************
421 IWineD3DVertexBuffer IWineD3DVertexBuffer parts follow
422 ****************************************************** */
423 static HRESULT WINAPI
IWineD3DVertexBufferImpl_Lock(IWineD3DVertexBuffer
*iface
, UINT OffsetToLock
, UINT SizeToLock
, BYTE
** ppbData
, DWORD Flags
) {
424 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
426 TRACE("(%p)->%d, %d, %p, %08x\n", This
, OffsetToLock
, SizeToLock
, ppbData
, Flags
);
428 InterlockedIncrement(&This
->lockcount
);
430 if(This
->Flags
& VBFLAG_DIRTY
) {
431 if(This
->dirtystart
> OffsetToLock
) This
->dirtystart
= OffsetToLock
;
433 if(This
->dirtyend
< OffsetToLock
+ SizeToLock
) This
->dirtyend
= OffsetToLock
+ SizeToLock
;
435 This
->dirtyend
= This
->resource
.size
;
438 This
->dirtystart
= OffsetToLock
;
440 This
->dirtyend
= OffsetToLock
+ SizeToLock
;
442 This
->dirtyend
= OffsetToLock
+ This
->resource
.size
;
445 if(This
->resource
.allocatedMemory
) {
446 data
= This
->resource
.allocatedMemory
;
447 This
->Flags
|= VBFLAG_DIRTY
;
449 GLenum mode
= GL_READ_WRITE_ARB
;
450 /* Return data to the VBO */
452 TRACE("Locking directly into the buffer\n");
454 if((This
->resource
.usage
& WINED3DUSAGE_WRITEONLY
) || ( Flags
& WINED3DLOCK_DISCARD
) ) {
455 mode
= GL_WRITE_ONLY_ARB
;
456 } else if( Flags
& (WINED3DLOCK_READONLY
| WINED3DLOCK_NO_DIRTY_UPDATE
) ) {
457 mode
= GL_READ_ONLY_ARB
;
461 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, This
->vbo
));
462 checkGLcall("glBindBufferARB");
463 data
= GL_EXTCALL(glMapBufferARB(GL_ARRAY_BUFFER_ARB
, mode
));
466 ERR("glMapBuffer failed\n");
467 return WINED3DERR_INVALIDCALL
;
470 *ppbData
= data
+ OffsetToLock
;
472 TRACE("(%p) : returning memory of %p (base:%p,offset:%u)\n", This
, data
+ OffsetToLock
, data
, OffsetToLock
);
473 /* TODO: check Flags compatibility with This->currentDesc.Usage (see MSDN) */
476 HRESULT WINAPI
IWineD3DVertexBufferImpl_Unlock(IWineD3DVertexBuffer
*iface
) {
477 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*) iface
;
479 TRACE("(%p)\n", This
);
481 lockcount
= InterlockedDecrement(&This
->lockcount
);
483 /* Delay loading the buffer until everything is unlocked */
484 TRACE("Ignoring the unlock\n");
488 if(!This
->resource
.allocatedMemory
) {
490 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, This
->vbo
));
491 checkGLcall("glBindBufferARB");
492 GL_EXTCALL(glUnmapBufferARB(GL_ARRAY_BUFFER_ARB
));
493 checkGLcall("glUnmapBufferARB");
495 } else if(This
->Flags
& VBFLAG_HASDESC
){
496 IWineD3DVertexBufferImpl_PreLoad(iface
);
500 static HRESULT WINAPI
IWineD3DVertexBufferImpl_GetDesc(IWineD3DVertexBuffer
*iface
, WINED3DVERTEXBUFFER_DESC
*pDesc
) {
501 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
503 TRACE("(%p)\n", This
);
504 pDesc
->Format
= This
->resource
.format
;
505 pDesc
->Type
= This
->resource
.resourceType
;
506 pDesc
->Usage
= This
->resource
.usage
;
507 pDesc
->Pool
= This
->resource
.pool
;
508 pDesc
->Size
= This
->resource
.size
;
509 pDesc
->FVF
= This
->fvf
;
513 const IWineD3DVertexBufferVtbl IWineD3DVertexBuffer_Vtbl
=
516 IWineD3DVertexBufferImpl_QueryInterface
,
517 IWineD3DVertexBufferImpl_AddRef
,
518 IWineD3DVertexBufferImpl_Release
,
519 /* IWineD3DResource */
520 IWineD3DVertexBufferImpl_GetParent
,
521 IWineD3DVertexBufferImpl_GetDevice
,
522 IWineD3DVertexBufferImpl_SetPrivateData
,
523 IWineD3DVertexBufferImpl_GetPrivateData
,
524 IWineD3DVertexBufferImpl_FreePrivateData
,
525 IWineD3DVertexBufferImpl_SetPriority
,
526 IWineD3DVertexBufferImpl_GetPriority
,
527 IWineD3DVertexBufferImpl_PreLoad
,
528 IWineD3DVertexBufferImpl_GetType
,
529 /* IWineD3DVertexBuffer */
530 IWineD3DVertexBufferImpl_Lock
,
531 IWineD3DVertexBufferImpl_Unlock
,
532 IWineD3DVertexBufferImpl_GetDesc
535 BYTE
* WINAPI
IWineD3DVertexBufferImpl_GetMemory(IWineD3DVertexBuffer
* iface
, DWORD iOffset
, GLint
*vbo
) {
536 IWineD3DVertexBufferImpl
*This
= (IWineD3DVertexBufferImpl
*)iface
;
540 return This
->resource
.allocatedMemory
+ iOffset
;
542 return (BYTE
*) iOffset
;
546 HRESULT WINAPI
IWineD3DVertexBufferImpl_ReleaseMemory(IWineD3DVertexBuffer
* iface
) {