ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ddraw: Get rid of IDirect3DExecuteBufferImpl.

This commit is contained in:
Henri Verbeet 2012-04-10 22:06:21 +02:00 committed by Alexandre Julliard
parent 53b3f9d40e
commit 4d1a659c3a
3 changed files with 95 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
dlls/ddraw/ddraw_private.h
View File

@ -40,7 +40,6 @@
extern const struct wined3d_parent_ops ddraw_null_wined3d_parent_ops DECLSPEC_HIDDEN;
/* Typdef the interfaces */
typedef struct IDirect3DExecuteBufferImpl IDirect3DExecuteBufferImpl;
typedef struct IDirect3DVertexBufferImpl IDirect3DVertexBufferImpl;
extern DWORD force_refresh_rate DECLSPEC_HIDDEN;
@ -488,7 +487,7 @@ void d3d_viewport_init(struct d3d_viewport *viewport, struct ddraw *ddraw) DECLS
/*****************************************************************************
* IDirect3DExecuteBuffer - Wraps to D3D7
*****************************************************************************/
struct IDirect3DExecuteBufferImpl
struct d3d_execute_buffer
{
IDirect3DExecuteBuffer IDirect3DExecuteBuffer_iface;
LONG ref;
@ -510,12 +509,12 @@ struct IDirect3DExecuteBufferImpl
BOOL need_free;
};
HRESULT d3d_execute_buffer_init(IDirect3DExecuteBufferImpl *execute_buffer,
HRESULT d3d_execute_buffer_init(struct d3d_execute_buffer *execute_buffer,
struct d3d_device *device, D3DEXECUTEBUFFERDESC *desc) DECLSPEC_HIDDEN;
IDirect3DExecuteBufferImpl *unsafe_impl_from_IDirect3DExecuteBuffer(IDirect3DExecuteBuffer *iface) DECLSPEC_HIDDEN;
struct d3d_execute_buffer *unsafe_impl_from_IDirect3DExecuteBuffer(IDirect3DExecuteBuffer *iface) DECLSPEC_HIDDEN;
/* The execute function */
HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *execute_buffer,
HRESULT d3d_execute_buffer_execute(struct d3d_execute_buffer *execute_buffer,
struct d3d_device *device, struct d3d_viewport *viewport) DECLSPEC_HIDDEN;
/*****************************************************************************

8
dlls/ddraw/device.c
View File

@ -659,7 +659,7 @@ static HRESULT WINAPI d3d_device1_CreateExecuteBuffer(IDirect3DDevice *iface,
D3DEXECUTEBUFFERDESC *buffer_desc, IDirect3DExecuteBuffer **ExecuteBuffer, IUnknown *outer_unknown)
{
struct d3d_device *device = impl_from_IDirect3DDevice(iface);
IDirect3DExecuteBufferImpl* object;
struct d3d_execute_buffer *object;
HRESULT hr;
TRACE("iface %p, buffer_desc %p, buffer %p, outer_unknown %p.\n",
@ -669,10 +669,10 @@ static HRESULT WINAPI d3d_device1_CreateExecuteBuffer(IDirect3DDevice *iface,
return CLASS_E_NOAGGREGATION;
/* Allocate the new Execute Buffer */
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DExecuteBufferImpl));
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if(!object)
{
ERR("Out of memory when allocating a IDirect3DExecuteBufferImpl structure\n");
ERR("Failed to allocate execute buffer memory.\n");
return DDERR_OUTOFMEMORY;
}
@ -710,7 +710,7 @@ static HRESULT WINAPI d3d_device1_Execute(IDirect3DDevice *iface,
IDirect3DExecuteBuffer *ExecuteBuffer, IDirect3DViewport *viewport, DWORD flags)
{
struct d3d_device *device = impl_from_IDirect3DDevice(iface);
IDirect3DExecuteBufferImpl *buffer = unsafe_impl_from_IDirect3DExecuteBuffer(ExecuteBuffer);
struct d3d_execute_buffer *buffer = unsafe_impl_from_IDirect3DExecuteBuffer(ExecuteBuffer);
struct d3d_viewport *viewport_impl = unsafe_impl_from_IDirect3DViewport(viewport);
HRESULT hr;

197
dlls/ddraw/executebuffer.c
View File

@ -50,34 +50,12 @@ static void _dump_D3DEXECUTEBUFFERDESC(const D3DEXECUTEBUFFERDESC *lpDesc) {
TRACE("lpData : %p\n", lpDesc->lpData);
}
/*****************************************************************************
* IDirect3DExecuteBufferImpl_Execute
*
* The main functionality of the execute buffer
* It transforms the vertices if necessary, and calls IDirect3DDevice7
* for drawing the vertices. It is called from
* IDirect3DDevice::Execute
*
* TODO: Perhaps some comments about the various opcodes wouldn't hurt
*
* Don't declare this static, as it's called from device.c,
* IDirect3DDevice::Execute
*
* Params:
* Device: 3D Device associated to use for drawing
* Viewport: Viewport for this operation
*
*****************************************************************************/
HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
HRESULT d3d_execute_buffer_execute(struct d3d_execute_buffer *buffer,
struct d3d_device *device, struct d3d_viewport *viewport)
{
/* DWORD bs = This->desc.dwBufferSize; */
DWORD vs = This->data.dwVertexOffset;
/* DWORD vc = This->data.dwVertexCount; */
DWORD is = This->data.dwInstructionOffset;
/* DWORD il = This->data.dwInstructionLength; */
char *instr = (char *)This->desc.lpData + is;
DWORD vs = buffer->data.dwVertexOffset;
DWORD is = buffer->data.dwInstructionOffset;
char *instr = (char *)buffer->desc.lpData + is;
if (viewport->active_device != device)
{
@ -91,7 +69,7 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
TRACE("ExecuteData :\n");
if (TRACE_ON(ddraw))
_dump_executedata(&(This->data));
_dump_executedata(&(buffer->data));
while (1) {
LPD3DINSTRUCTION current = (LPD3DINSTRUCTION) instr;
@ -115,15 +93,16 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
case D3DOP_TRIANGLE: {
int i;
D3DTLVERTEX *tl_vx = This->vertex_data;
D3DTLVERTEX *tl_vx = buffer->vertex_data;
TRACE("TRIANGLE (%d)\n", count);
if (count*3>This->nb_indices) {
This->nb_indices = count * 3;
HeapFree(GetProcessHeap(),0,This->indices);
This->indices = HeapAlloc(GetProcessHeap(),0,sizeof(WORD)*This->nb_indices);
}
if (buffer->nb_indices < count * 3)
{
buffer->nb_indices = count * 3;
HeapFree(GetProcessHeap(), 0, buffer->indices);
buffer->indices = HeapAlloc(GetProcessHeap(), 0, sizeof(*buffer->indices) * buffer->nb_indices);
}
for (i = 0; i < count; i++) {
LPD3DTRIANGLE ci = (LPD3DTRIANGLE) instr;
TRACE(" v1: %d v2: %d v3: %d\n",ci->u1.v1, ci->u2.v2, ci->u3.v3);
@ -148,9 +127,9 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
TRACE("STARTFLAT(%u) ", ci->wFlags);
TRACE("\n");
}
This->indices[(i * 3) ] = ci->u1.v1;
This->indices[(i * 3) + 1] = ci->u2.v2;
This->indices[(i * 3) + 2] = ci->u3.v3;
buffer->indices[(i * 3) ] = ci->u1.v1;
buffer->indices[(i * 3) + 1] = ci->u2.v2;
buffer->indices[(i * 3) + 2] = ci->u3.v3;
instr += size;
}
/* IDirect3DDevices have color keying always enabled -
@ -158,7 +137,7 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
* render state. */
wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_COLORKEYENABLE, 1);
IDirect3DDevice7_DrawIndexedPrimitive(&device->IDirect3DDevice7_iface,
D3DPT_TRIANGLELIST, D3DFVF_TLVERTEX, tl_vx, 0, This->indices, count * 3, 0);
D3DPT_TRIANGLELIST, D3DFVF_TLVERTEX, tl_vx, 0, buffer->indices, count * 3, 0);
} break;
case D3DOP_MATRIXLOAD:
@ -374,8 +353,8 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
/* Enough for the moment */
if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT) {
unsigned int nb;
D3DVERTEX *src = ((LPD3DVERTEX) ((char *)This->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (This->vertex_data)) + ci->wDest;
D3DVERTEX *src = ((D3DVERTEX *)((char *)buffer->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((D3DTLVERTEX *)buffer->vertex_data) + ci->wDest;
D3DVIEWPORT *Viewport = &viewport->viewports.vp1;
D3DMATRIX mat;
@ -419,8 +398,8 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
}
} else if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORM) {
unsigned int nb;
D3DLVERTEX *src = ((LPD3DLVERTEX) ((char *)This->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (This->vertex_data)) + ci->wDest;
D3DLVERTEX *src = ((D3DLVERTEX *)((char *)buffer->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((D3DTLVERTEX *)buffer->vertex_data) + ci->wDest;
D3DVIEWPORT *Viewport = &viewport->viewports.vp1;
D3DMATRIX mat;
@ -460,10 +439,12 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
src++;
dst++;
}
} else if (ci->dwFlags == D3DPROCESSVERTICES_COPY) {
D3DTLVERTEX *src = ((LPD3DTLVERTEX) ((char *)This->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (This->vertex_data)) + ci->wDest;
}
else if (ci->dwFlags == D3DPROCESSVERTICES_COPY)
{
D3DTLVERTEX *src = ((D3DTLVERTEX *)((char *)buffer->desc.lpData + vs)) + ci->wStart;
D3DTLVERTEX *dst = ((D3DTLVERTEX *)buffer->vertex_data) + ci->wDest;
memcpy(dst, src, ci->dwCount * sizeof(D3DTLVERTEX));
} else {
ERR("Unhandled vertex processing flag %#x.\n", ci->dwFlags);
@ -494,8 +475,10 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
for (i = 0; i < count; i++) {
LPD3DBRANCH ci = (LPD3DBRANCH) instr;
if ((This->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue) {
if (!ci->bNegate) {
if ((buffer->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue)
{
if (!ci->bNegate)
{
TRACE(" Branch to %d\n", ci->dwOffset);
if (ci->dwOffset) {
instr = (char*)current + ci->dwOffset;
@ -529,7 +512,7 @@ HRESULT d3d_execute_buffer_execute(IDirect3DExecuteBufferImpl *This,
for (i = 0; i < count; i++) {
LPD3DSTATUS ci = (LPD3DSTATUS) instr;
This->data.dsStatus = *ci;
buffer->data.dsStatus = *ci;
instr += size;
}
@ -547,9 +530,9 @@ end_of_buffer:
return D3D_OK;
}
static inline IDirect3DExecuteBufferImpl *impl_from_IDirect3DExecuteBuffer(IDirect3DExecuteBuffer *iface)
static inline struct d3d_execute_buffer *impl_from_IDirect3DExecuteBuffer(IDirect3DExecuteBuffer *iface)
{
return CONTAINING_RECORD(iface, IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer_iface);
return CONTAINING_RECORD(iface, struct d3d_execute_buffer, IDirect3DExecuteBuffer_iface);
}
/*****************************************************************************
@ -568,10 +551,7 @@ static inline IDirect3DExecuteBufferImpl *impl_from_IDirect3DExecuteBuffer(IDire
* (E_NOINTERFACE?? Don't know what I really need)
*
*****************************************************************************/
static HRESULT WINAPI
IDirect3DExecuteBufferImpl_QueryInterface(IDirect3DExecuteBuffer *iface,
REFIID riid,
void **obj)
static HRESULT WINAPI d3d_execute_buffer_QueryInterface(IDirect3DExecuteBuffer *iface, REFIID riid, void **obj)
{
TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), obj);
@ -603,12 +583,12 @@ IDirect3DExecuteBufferImpl_QueryInterface(IDirect3DExecuteBuffer *iface,
* The new refcount
*
*****************************************************************************/
static ULONG WINAPI IDirect3DExecuteBufferImpl_AddRef(IDirect3DExecuteBuffer *iface)
static ULONG WINAPI d3d_execute_buffer_AddRef(IDirect3DExecuteBuffer *iface)
{
IDirect3DExecuteBufferImpl *This = impl_from_IDirect3DExecuteBuffer(iface);
ULONG ref = InterlockedIncrement(&This->ref);
struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
ULONG ref = InterlockedIncrement(&buffer->ref);
TRACE("%p increasing refcount to %u.\n", This, ref);
TRACE("%p increasing refcount to %u.\n", buffer, ref);
return ref;
}
@ -622,20 +602,20 @@ static ULONG WINAPI IDirect3DExecuteBufferImpl_AddRef(IDirect3DExecuteBuffer *if
* The new refcount
*
*****************************************************************************/
static ULONG WINAPI IDirect3DExecuteBufferImpl_Release(IDirect3DExecuteBuffer *iface)
static ULONG WINAPI d3d_execute_buffer_Release(IDirect3DExecuteBuffer *iface)
{
IDirect3DExecuteBufferImpl *This = impl_from_IDirect3DExecuteBuffer(iface);
ULONG ref = InterlockedDecrement(&This->ref);
struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
ULONG ref = InterlockedDecrement(&buffer->ref);
TRACE("%p decreasing refcount to %u.\n", This, ref);
TRACE("%p decreasing refcount to %u.\n", buffer, ref);
if (!ref) {
if (This->need_free)
HeapFree(GetProcessHeap(),0,This->desc.lpData);
HeapFree(GetProcessHeap(),0,This->vertex_data);
HeapFree(GetProcessHeap(),0,This->indices);
HeapFree(GetProcessHeap(),0,This);
return 0;
if (!ref)
{
if (buffer->need_free)
HeapFree(GetProcessHeap(), 0, buffer->desc.lpData);
HeapFree(GetProcessHeap(), 0, buffer->vertex_data);
HeapFree(GetProcessHeap(), 0, buffer->indices);
HeapFree(GetProcessHeap(), 0, buffer);
}
return ref;
@ -651,7 +631,7 @@ static ULONG WINAPI IDirect3DExecuteBufferImpl_Release(IDirect3DExecuteBuffer *i
* D3D_OK
*
*****************************************************************************/
static HRESULT WINAPI IDirect3DExecuteBufferImpl_Initialize(IDirect3DExecuteBuffer *iface,
static HRESULT WINAPI d3d_execute_buffer_Initialize(IDirect3DExecuteBuffer *iface,
IDirect3DDevice *device, D3DEXECUTEBUFFERDESC *desc)
{
TRACE("iface %p, device %p, desc %p.\n", iface, device, desc);
@ -672,21 +652,20 @@ static HRESULT WINAPI IDirect3DExecuteBufferImpl_Initialize(IDirect3DExecuteBuff
* This implementation always returns D3D_OK
*
*****************************************************************************/
static HRESULT WINAPI IDirect3DExecuteBufferImpl_Lock(IDirect3DExecuteBuffer *iface,
D3DEXECUTEBUFFERDESC *lpDesc)
static HRESULT WINAPI d3d_execute_buffer_Lock(IDirect3DExecuteBuffer *iface, D3DEXECUTEBUFFERDESC *desc)
{
IDirect3DExecuteBufferImpl *This = impl_from_IDirect3DExecuteBuffer(iface);
struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
DWORD dwSize;
TRACE("iface %p, desc %p.\n", iface, lpDesc);
TRACE("iface %p, desc %p.\n", iface, desc);
dwSize = lpDesc->dwSize;
memcpy(lpDesc, &This->desc, dwSize);
dwSize = desc->dwSize;
memcpy(desc, &buffer->desc, dwSize);
if (TRACE_ON(ddraw))
{
TRACE(" Returning description :\n");
_dump_D3DEXECUTEBUFFERDESC(lpDesc);
_dump_D3DEXECUTEBUFFERDESC(desc);
}
return D3D_OK;
}
@ -700,7 +679,7 @@ static HRESULT WINAPI IDirect3DExecuteBufferImpl_Lock(IDirect3DExecuteBuffer *if
* This implementation always returns D3D_OK
*
*****************************************************************************/
static HRESULT WINAPI IDirect3DExecuteBufferImpl_Unlock(IDirect3DExecuteBuffer *iface)
static HRESULT WINAPI d3d_execute_buffer_Unlock(IDirect3DExecuteBuffer *iface)
{
TRACE("iface %p.\n", iface);
@ -721,25 +700,24 @@ static HRESULT WINAPI IDirect3DExecuteBufferImpl_Unlock(IDirect3DExecuteBuffer *
* DDERR_OUTOFMEMORY if the vertex buffer allocation failed
*
*****************************************************************************/
static HRESULT WINAPI IDirect3DExecuteBufferImpl_SetExecuteData(IDirect3DExecuteBuffer *iface,
D3DEXECUTEDATA *lpData)
static HRESULT WINAPI d3d_execute_buffer_SetExecuteData(IDirect3DExecuteBuffer *iface, D3DEXECUTEDATA *data)
{
IDirect3DExecuteBufferImpl *This = impl_from_IDirect3DExecuteBuffer(iface);
struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
DWORD nbvert;
TRACE("iface %p, data %p.\n", iface, lpData);
TRACE("iface %p, data %p.\n", iface, data);
memcpy(&This->data, lpData, lpData->dwSize);
memcpy(&buffer->data, data, data->dwSize);
/* Get the number of vertices in the execute buffer */
nbvert = This->data.dwVertexCount;
nbvert = buffer->data.dwVertexCount;
/* Prepares the transformed vertex buffer */
HeapFree(GetProcessHeap(), 0, This->vertex_data);
This->vertex_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nbvert * sizeof(D3DTLVERTEX));
HeapFree(GetProcessHeap(), 0, buffer->vertex_data);
buffer->vertex_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nbvert * sizeof(D3DTLVERTEX));
if (TRACE_ON(ddraw))
_dump_executedata(lpData);
_dump_executedata(data);
return D3D_OK;
}
@ -756,21 +734,20 @@ static HRESULT WINAPI IDirect3DExecuteBufferImpl_SetExecuteData(IDirect3DExecute
* D3D_OK on success
*
*****************************************************************************/
static HRESULT WINAPI IDirect3DExecuteBufferImpl_GetExecuteData(IDirect3DExecuteBuffer *iface,
D3DEXECUTEDATA *lpData)
static HRESULT WINAPI d3d_execute_buffer_GetExecuteData(IDirect3DExecuteBuffer *iface, D3DEXECUTEDATA *data)
{
IDirect3DExecuteBufferImpl *This = impl_from_IDirect3DExecuteBuffer(iface);
struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
DWORD dwSize;
TRACE("iface %p, data %p.\n", iface, lpData);
TRACE("iface %p, data %p.\n", iface, data);
dwSize = lpData->dwSize;
memcpy(lpData, &This->data, dwSize);
dwSize = data->dwSize;
memcpy(data, &buffer->data, dwSize);
if (TRACE_ON(ddraw))
{
TRACE("Returning data :\n");
_dump_executedata(lpData);
_dump_executedata(data);
}
return DD_OK;
@ -789,7 +766,7 @@ static HRESULT WINAPI IDirect3DExecuteBufferImpl_GetExecuteData(IDirect3DExecute
* DDERR_UNSUPPORTED, because it's not implemented in Windows.
*
*****************************************************************************/
static HRESULT WINAPI IDirect3DExecuteBufferImpl_Validate(IDirect3DExecuteBuffer *iface,
static HRESULT WINAPI d3d_execute_buffer_Validate(IDirect3DExecuteBuffer *iface,
DWORD *offset, LPD3DVALIDATECALLBACK callback, void *context, DWORD reserved)
{
TRACE("iface %p, offset %p, callback %p, context %p, reserved %#x.\n",
@ -813,7 +790,7 @@ static HRESULT WINAPI IDirect3DExecuteBufferImpl_Validate(IDirect3DExecuteBuffer
* DDERR_UNSUPPORTED, because it's not implemented in Windows.
*
*****************************************************************************/
static HRESULT WINAPI IDirect3DExecuteBufferImpl_Optimize(IDirect3DExecuteBuffer *iface, DWORD reserved)
static HRESULT WINAPI d3d_execute_buffer_Optimize(IDirect3DExecuteBuffer *iface, DWORD reserved)
{
TRACE("iface %p, reserved %#x.\n", iface, reserved);
@ -824,19 +801,19 @@ static HRESULT WINAPI IDirect3DExecuteBufferImpl_Optimize(IDirect3DExecuteBuffer
static const struct IDirect3DExecuteBufferVtbl d3d_execute_buffer_vtbl =
{
IDirect3DExecuteBufferImpl_QueryInterface,
IDirect3DExecuteBufferImpl_AddRef,
IDirect3DExecuteBufferImpl_Release,
IDirect3DExecuteBufferImpl_Initialize,
IDirect3DExecuteBufferImpl_Lock,
IDirect3DExecuteBufferImpl_Unlock,
IDirect3DExecuteBufferImpl_SetExecuteData,
IDirect3DExecuteBufferImpl_GetExecuteData,
IDirect3DExecuteBufferImpl_Validate,
IDirect3DExecuteBufferImpl_Optimize,
d3d_execute_buffer_QueryInterface,
d3d_execute_buffer_AddRef,
d3d_execute_buffer_Release,
d3d_execute_buffer_Initialize,
d3d_execute_buffer_Lock,
d3d_execute_buffer_Unlock,
d3d_execute_buffer_SetExecuteData,
d3d_execute_buffer_GetExecuteData,
d3d_execute_buffer_Validate,
d3d_execute_buffer_Optimize,
};
HRESULT d3d_execute_buffer_init(IDirect3DExecuteBufferImpl *execute_buffer,
HRESULT d3d_execute_buffer_init(struct d3d_execute_buffer *execute_buffer,
struct d3d_device *device, D3DEXECUTEBUFFERDESC *desc)
{
execute_buffer->IDirect3DExecuteBuffer_iface.lpVtbl = &d3d_execute_buffer_vtbl;
@ -871,7 +848,7 @@ HRESULT d3d_execute_buffer_init(IDirect3DExecuteBufferImpl *execute_buffer,
return D3D_OK;
}
IDirect3DExecuteBufferImpl *unsafe_impl_from_IDirect3DExecuteBuffer(IDirect3DExecuteBuffer *iface)
struct d3d_execute_buffer *unsafe_impl_from_IDirect3DExecuteBuffer(IDirect3DExecuteBuffer *iface)
{
if (!iface)
return NULL;