2 * IDirect3DDevice8 implementation
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2004 Christian Costa
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
33 #include "wine/debug.h"
35 #include "d3d8_private.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(d3d8
);
39 static HRESULT WINAPI
D3D8CB_CreateSurface(IUnknown
*,IUnknown
*,UINT
,UINT
,WINED3DFORMAT
,DWORD
,WINED3DPOOL
,UINT
,WINED3DCUBEMAP_FACES
,IWineD3DSurface
**,HANDLE
*);
42 /* Shader handle functions */
43 static shader_handle
*alloc_shader_handle(IDirect3DDevice8Impl
*This
) {
44 if (This
->free_shader_handles
) {
45 /* Use a free handle */
46 shader_handle
*handle
= This
->free_shader_handles
;
47 This
->free_shader_handles
= *handle
;
50 if (!(This
->allocated_shader_handles
< This
->shader_handle_table_size
)) {
52 DWORD new_size
= This
->shader_handle_table_size
+ (This
->shader_handle_table_size
>> 1);
53 shader_handle
*new_handles
= HeapReAlloc(GetProcessHeap(), 0, This
->shader_handles
, new_size
* sizeof(shader_handle
));
54 if (!new_handles
) return NULL
;
55 This
->shader_handles
= new_handles
;
56 This
->shader_handle_table_size
= new_size
;
59 return &This
->shader_handles
[This
->allocated_shader_handles
++];
62 static void free_shader_handle(IDirect3DDevice8Impl
*This
, shader_handle
*handle
) {
63 *handle
= This
->free_shader_handles
;
64 This
->free_shader_handles
= handle
;
67 /* IDirect3D IUnknown parts follow: */
68 static HRESULT WINAPI
IDirect3DDevice8Impl_QueryInterface(LPDIRECT3DDEVICE8 iface
,REFIID riid
,LPVOID
*ppobj
)
70 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
72 if (IsEqualGUID(riid
, &IID_IUnknown
)
73 || IsEqualGUID(riid
, &IID_IDirect3DDevice8
)) {
74 IUnknown_AddRef(iface
);
79 WARN("(%p)->(%s,%p),not found\n", This
, debugstr_guid(riid
), ppobj
);
84 static ULONG WINAPI
IDirect3DDevice8Impl_AddRef(LPDIRECT3DDEVICE8 iface
) {
85 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
86 ULONG ref
= InterlockedIncrement(&This
->ref
);
88 TRACE("(%p) : AddRef from %d\n", This
, ref
- 1);
93 static ULONG WINAPI
IDirect3DDevice8Impl_Release(LPDIRECT3DDEVICE8 iface
) {
94 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
97 if (This
->inDestruction
) return 0;
98 ref
= InterlockedDecrement(&This
->ref
);
100 TRACE("(%p) : ReleaseRef to %d\n", This
, ref
);
105 TRACE("Releasing wined3d device %p\n", This
->WineD3DDevice
);
106 EnterCriticalSection(&d3d8_cs
);
107 This
->inDestruction
= TRUE
;
109 for(i
= 0; i
< This
->numConvertedDecls
; i
++) {
110 IDirect3DVertexDeclaration8_Release(This
->decls
[i
].decl
);
112 HeapFree(GetProcessHeap(), 0, This
->decls
);
114 IWineD3DDevice_Uninit3D(This
->WineD3DDevice
, D3D8CB_DestroyDepthStencilSurface
, D3D8CB_DestroySwapChain
);
115 IWineD3DDevice_Release(This
->WineD3DDevice
);
116 HeapFree(GetProcessHeap(), 0, This
->shader_handles
);
117 HeapFree(GetProcessHeap(), 0, This
);
118 LeaveCriticalSection(&d3d8_cs
);
123 /* IDirect3DDevice Interface follow: */
124 static HRESULT WINAPI
IDirect3DDevice8Impl_TestCooperativeLevel(LPDIRECT3DDEVICE8 iface
) {
125 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
128 TRACE("(%p) : Relay\n", This
);
129 EnterCriticalSection(&d3d8_cs
);
130 hr
= IWineD3DDevice_TestCooperativeLevel(This
->WineD3DDevice
);
131 LeaveCriticalSection(&d3d8_cs
);
135 static UINT WINAPI
IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface
) {
136 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
139 TRACE("(%p) Relay\n", This
);
140 EnterCriticalSection(&d3d8_cs
);
141 hr
= IWineD3DDevice_GetAvailableTextureMem(This
->WineD3DDevice
);
142 LeaveCriticalSection(&d3d8_cs
);
146 static HRESULT WINAPI
IDirect3DDevice8Impl_ResourceManagerDiscardBytes(LPDIRECT3DDEVICE8 iface
, DWORD Bytes
) {
147 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
150 TRACE("(%p) : Relay bytes(%d)\n", This
, Bytes
);
151 EnterCriticalSection(&d3d8_cs
);
152 hr
= IWineD3DDevice_EvictManagedResources(This
->WineD3DDevice
);
153 LeaveCriticalSection(&d3d8_cs
);
157 static HRESULT WINAPI
IDirect3DDevice8Impl_GetDirect3D(LPDIRECT3DDEVICE8 iface
, IDirect3D8
** ppD3D8
) {
158 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
162 TRACE("(%p) Relay\n", This
);
164 if (NULL
== ppD3D8
) {
165 return D3DERR_INVALIDCALL
;
168 EnterCriticalSection(&d3d8_cs
);
169 hr
= IWineD3DDevice_GetDirect3D(This
->WineD3DDevice
, &pWineD3D
);
170 if (hr
== D3D_OK
&& pWineD3D
!= NULL
)
172 IWineD3D_GetParent(pWineD3D
,(IUnknown
**)ppD3D8
);
173 IWineD3D_Release(pWineD3D
);
175 FIXME("Call to IWineD3DDevice_GetDirect3D failed\n");
178 TRACE("(%p) returning %p\n",This
, *ppD3D8
);
179 LeaveCriticalSection(&d3d8_cs
);
184 static HRESULT WINAPI
IDirect3DDevice8Impl_GetDeviceCaps(LPDIRECT3DDEVICE8 iface
, D3DCAPS8
* pCaps
) {
185 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
186 HRESULT hrc
= D3D_OK
;
187 WINED3DCAPS
*pWineCaps
;
189 TRACE("(%p) : Relay pCaps %p\n", This
, pCaps
);
191 return D3DERR_INVALIDCALL
;
193 pWineCaps
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(WINED3DCAPS
));
194 if(pWineCaps
== NULL
){
195 return D3DERR_INVALIDCALL
; /* well this is what MSDN says to return */
198 EnterCriticalSection(&d3d8_cs
);
199 hrc
= IWineD3DDevice_GetDeviceCaps(This
->WineD3DDevice
, pWineCaps
);
200 LeaveCriticalSection(&d3d8_cs
);
201 WINECAPSTOD3D8CAPS(pCaps
, pWineCaps
)
202 HeapFree(GetProcessHeap(), 0, pWineCaps
);
204 /* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
205 if(pCaps
->PixelShaderVersion
> D3DPS_VERSION(1,4)){
206 pCaps
->PixelShaderVersion
= D3DPS_VERSION(1,4);
208 if(pCaps
->VertexShaderVersion
> D3DVS_VERSION(1,1)){
209 pCaps
->VertexShaderVersion
= D3DVS_VERSION(1,1);
212 TRACE("Returning %p %p\n", This
, pCaps
);
216 static HRESULT WINAPI
IDirect3DDevice8Impl_GetDisplayMode(LPDIRECT3DDEVICE8 iface
, D3DDISPLAYMODE
* pMode
) {
217 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
219 TRACE("(%p) Relay\n", This
);
221 EnterCriticalSection(&d3d8_cs
);
222 hr
= IWineD3DDevice_GetDisplayMode(This
->WineD3DDevice
, 0, (WINED3DDISPLAYMODE
*) pMode
);
223 LeaveCriticalSection(&d3d8_cs
);
227 static HRESULT WINAPI
IDirect3DDevice8Impl_GetCreationParameters(LPDIRECT3DDEVICE8 iface
, D3DDEVICE_CREATION_PARAMETERS
*pParameters
) {
228 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
230 TRACE("(%p) Relay\n", This
);
232 EnterCriticalSection(&d3d8_cs
);
233 hr
= IWineD3DDevice_GetCreationParameters(This
->WineD3DDevice
, (WINED3DDEVICE_CREATION_PARAMETERS
*) pParameters
);
234 LeaveCriticalSection(&d3d8_cs
);
238 static HRESULT WINAPI
IDirect3DDevice8Impl_SetCursorProperties(LPDIRECT3DDEVICE8 iface
, UINT XHotSpot
, UINT YHotSpot
, IDirect3DSurface8
* pCursorBitmap
) {
239 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
240 IDirect3DSurface8Impl
*pSurface
= (IDirect3DSurface8Impl
*)pCursorBitmap
;
242 TRACE("(%p) Relay\n", This
);
244 WARN("No cursor bitmap, returning WINED3DERR_INVALIDCALL\n");
245 return WINED3DERR_INVALIDCALL
;
248 EnterCriticalSection(&d3d8_cs
);
249 hr
= IWineD3DDevice_SetCursorProperties(This
->WineD3DDevice
,XHotSpot
,YHotSpot
,pSurface
->wineD3DSurface
);
250 LeaveCriticalSection(&d3d8_cs
);
254 static void WINAPI
IDirect3DDevice8Impl_SetCursorPosition(LPDIRECT3DDEVICE8 iface
, UINT XScreenSpace
, UINT YScreenSpace
, DWORD Flags
) {
255 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
256 TRACE("(%p) Relay\n", This
);
258 EnterCriticalSection(&d3d8_cs
);
259 IWineD3DDevice_SetCursorPosition(This
->WineD3DDevice
, XScreenSpace
, YScreenSpace
, Flags
);
260 LeaveCriticalSection(&d3d8_cs
);
263 static BOOL WINAPI
IDirect3DDevice8Impl_ShowCursor(LPDIRECT3DDEVICE8 iface
, BOOL bShow
) {
264 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
266 TRACE("(%p) Relay\n", This
);
268 EnterCriticalSection(&d3d8_cs
);
269 ret
= IWineD3DDevice_ShowCursor(This
->WineD3DDevice
, bShow
);
270 LeaveCriticalSection(&d3d8_cs
);
274 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE8 iface
, D3DPRESENT_PARAMETERS
* pPresentationParameters
, IDirect3DSwapChain8
** pSwapChain
) {
275 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
276 IDirect3DSwapChain8Impl
* object
;
277 HRESULT hrc
= D3D_OK
;
278 WINED3DPRESENT_PARAMETERS localParameters
;
280 TRACE("(%p) Relay\n", This
);
282 /* Fix the back buffer count */
283 if(pPresentationParameters
->BackBufferCount
== 0) {
284 pPresentationParameters
->BackBufferCount
= 1;
287 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
288 if (NULL
== object
) {
289 FIXME("Allocation of memory failed\n");
291 return D3DERR_OUTOFVIDEOMEMORY
;
294 object
->lpVtbl
= &Direct3DSwapChain8_Vtbl
;
296 /* Allocate an associated WineD3DDevice object */
297 localParameters
.BackBufferWidth
= pPresentationParameters
->BackBufferWidth
;
298 localParameters
.BackBufferHeight
= pPresentationParameters
->BackBufferHeight
;
299 localParameters
.BackBufferFormat
= pPresentationParameters
->BackBufferFormat
;
300 localParameters
.BackBufferCount
= pPresentationParameters
->BackBufferCount
;
301 localParameters
.MultiSampleType
= pPresentationParameters
->MultiSampleType
;
302 localParameters
.MultiSampleQuality
= 0; /* d3d9 only */
303 localParameters
.SwapEffect
= pPresentationParameters
->SwapEffect
;
304 localParameters
.hDeviceWindow
= pPresentationParameters
->hDeviceWindow
;
305 localParameters
.Windowed
= pPresentationParameters
->Windowed
;
306 localParameters
.EnableAutoDepthStencil
= pPresentationParameters
->EnableAutoDepthStencil
;
307 localParameters
.AutoDepthStencilFormat
= pPresentationParameters
->AutoDepthStencilFormat
;
308 localParameters
.Flags
= pPresentationParameters
->Flags
;
309 localParameters
.FullScreen_RefreshRateInHz
= pPresentationParameters
->FullScreen_RefreshRateInHz
;
310 localParameters
.PresentationInterval
= pPresentationParameters
->FullScreen_PresentationInterval
;
311 localParameters
.AutoRestoreDisplayMode
= TRUE
;
313 EnterCriticalSection(&d3d8_cs
);
314 hrc
= IWineD3DDevice_CreateSwapChain(This
->WineD3DDevice
, &localParameters
, &object
->wineD3DSwapChain
, (IUnknown
*)object
, D3D8CB_CreateRenderTarget
, D3D8CB_CreateDepthStencilSurface
, SURFACE_OPENGL
);
315 LeaveCriticalSection(&d3d8_cs
);
317 pPresentationParameters
->BackBufferWidth
= localParameters
.BackBufferWidth
;
318 pPresentationParameters
->BackBufferHeight
= localParameters
.BackBufferHeight
;
319 pPresentationParameters
->BackBufferFormat
= localParameters
.BackBufferFormat
;
320 pPresentationParameters
->BackBufferCount
= localParameters
.BackBufferCount
;
321 pPresentationParameters
->MultiSampleType
= localParameters
.MultiSampleType
;
322 pPresentationParameters
->SwapEffect
= localParameters
.SwapEffect
;
323 pPresentationParameters
->hDeviceWindow
= localParameters
.hDeviceWindow
;
324 pPresentationParameters
->Windowed
= localParameters
.Windowed
;
325 pPresentationParameters
->EnableAutoDepthStencil
= localParameters
.EnableAutoDepthStencil
;
326 pPresentationParameters
->AutoDepthStencilFormat
= localParameters
.AutoDepthStencilFormat
;
327 pPresentationParameters
->Flags
= localParameters
.Flags
;
328 pPresentationParameters
->FullScreen_RefreshRateInHz
= localParameters
.FullScreen_RefreshRateInHz
;
329 pPresentationParameters
->FullScreen_PresentationInterval
= localParameters
.PresentationInterval
;
332 FIXME("(%p) call to IWineD3DDevice_CreateSwapChain failed\n", This
);
333 HeapFree(GetProcessHeap(), 0 , object
);
336 IUnknown_AddRef(iface
);
337 object
->parentDevice
= iface
;
338 *pSwapChain
= (IDirect3DSwapChain8
*)object
;
340 TRACE("(%p) returning %p\n", This
, *pSwapChain
);
344 static HRESULT WINAPI
IDirect3DDevice8Impl_Reset(LPDIRECT3DDEVICE8 iface
, D3DPRESENT_PARAMETERS
* pPresentationParameters
) {
345 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
346 WINED3DPRESENT_PARAMETERS localParameters
;
349 TRACE("(%p) Relay pPresentationParameters(%p)\n", This
, pPresentationParameters
);
351 localParameters
.BackBufferWidth
= pPresentationParameters
->BackBufferWidth
;
352 localParameters
.BackBufferHeight
= pPresentationParameters
->BackBufferHeight
;
353 localParameters
.BackBufferFormat
= pPresentationParameters
->BackBufferFormat
;
354 localParameters
.BackBufferCount
= pPresentationParameters
->BackBufferCount
;
355 localParameters
.MultiSampleType
= pPresentationParameters
->MultiSampleType
;
356 localParameters
.MultiSampleQuality
= 0; /* d3d9 only */
357 localParameters
.SwapEffect
= pPresentationParameters
->SwapEffect
;
358 localParameters
.hDeviceWindow
= pPresentationParameters
->hDeviceWindow
;
359 localParameters
.Windowed
= pPresentationParameters
->Windowed
;
360 localParameters
.EnableAutoDepthStencil
= pPresentationParameters
->EnableAutoDepthStencil
;
361 localParameters
.AutoDepthStencilFormat
= pPresentationParameters
->AutoDepthStencilFormat
;
362 localParameters
.Flags
= pPresentationParameters
->Flags
;
363 localParameters
.FullScreen_RefreshRateInHz
= pPresentationParameters
->FullScreen_RefreshRateInHz
;
364 localParameters
.PresentationInterval
= pPresentationParameters
->FullScreen_PresentationInterval
;
365 localParameters
.AutoRestoreDisplayMode
= TRUE
;
367 EnterCriticalSection(&d3d8_cs
);
368 hr
= IWineD3DDevice_Reset(This
->WineD3DDevice
, &localParameters
);
369 LeaveCriticalSection(&d3d8_cs
);
371 pPresentationParameters
->BackBufferWidth
= localParameters
.BackBufferWidth
;
372 pPresentationParameters
->BackBufferHeight
= localParameters
.BackBufferHeight
;
373 pPresentationParameters
->BackBufferFormat
= localParameters
.BackBufferFormat
;
374 pPresentationParameters
->BackBufferCount
= localParameters
.BackBufferCount
;
375 pPresentationParameters
->MultiSampleType
= localParameters
.MultiSampleType
;
376 pPresentationParameters
->SwapEffect
= localParameters
.SwapEffect
;
377 pPresentationParameters
->hDeviceWindow
= localParameters
.hDeviceWindow
;
378 pPresentationParameters
->Windowed
= localParameters
.Windowed
;
379 pPresentationParameters
->EnableAutoDepthStencil
= localParameters
.EnableAutoDepthStencil
;
380 pPresentationParameters
->AutoDepthStencilFormat
= localParameters
.AutoDepthStencilFormat
;
381 pPresentationParameters
->Flags
= localParameters
.Flags
;
382 pPresentationParameters
->FullScreen_RefreshRateInHz
= localParameters
.FullScreen_RefreshRateInHz
;
383 pPresentationParameters
->FullScreen_PresentationInterval
= localParameters
.PresentationInterval
;
388 static HRESULT WINAPI
IDirect3DDevice8Impl_Present(LPDIRECT3DDEVICE8 iface
, CONST RECT
* pSourceRect
,CONST RECT
* pDestRect
,HWND hDestWindowOverride
,CONST RGNDATA
* pDirtyRegion
) {
389 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
391 TRACE("(%p) Relay\n", This
);
393 EnterCriticalSection(&d3d8_cs
);
394 hr
= IWineD3DDevice_Present(This
->WineD3DDevice
, pSourceRect
, pDestRect
, hDestWindowOverride
, pDirtyRegion
);
395 LeaveCriticalSection(&d3d8_cs
);
399 static HRESULT WINAPI
IDirect3DDevice8Impl_GetBackBuffer(LPDIRECT3DDEVICE8 iface
, UINT BackBuffer
, D3DBACKBUFFER_TYPE Type
, IDirect3DSurface8
** ppBackBuffer
) {
400 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
401 IWineD3DSurface
*retSurface
= NULL
;
404 TRACE("(%p) Relay\n", This
);
406 EnterCriticalSection(&d3d8_cs
);
407 rc
= IWineD3DDevice_GetBackBuffer(This
->WineD3DDevice
, 0, BackBuffer
, (WINED3DBACKBUFFER_TYPE
) Type
, &retSurface
);
408 if (rc
== D3D_OK
&& NULL
!= retSurface
&& NULL
!= ppBackBuffer
) {
409 IWineD3DSurface_GetParent(retSurface
, (IUnknown
**)ppBackBuffer
);
410 IWineD3DSurface_Release(retSurface
);
412 LeaveCriticalSection(&d3d8_cs
);
416 static HRESULT WINAPI
IDirect3DDevice8Impl_GetRasterStatus(LPDIRECT3DDEVICE8 iface
, D3DRASTER_STATUS
* pRasterStatus
) {
417 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
419 TRACE("(%p) Relay\n", This
);
421 EnterCriticalSection(&d3d8_cs
);
422 hr
= IWineD3DDevice_GetRasterStatus(This
->WineD3DDevice
, 0, (WINED3DRASTER_STATUS
*) pRasterStatus
);
423 LeaveCriticalSection(&d3d8_cs
);
427 static void WINAPI
IDirect3DDevice8Impl_SetGammaRamp(LPDIRECT3DDEVICE8 iface
, DWORD Flags
, CONST D3DGAMMARAMP
* pRamp
) {
428 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
429 TRACE("(%p) Relay\n", This
);
431 /* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
432 EnterCriticalSection(&d3d8_cs
);
433 IWineD3DDevice_SetGammaRamp(This
->WineD3DDevice
, 0, Flags
, (CONST WINED3DGAMMARAMP
*) pRamp
);
434 LeaveCriticalSection(&d3d8_cs
);
437 static void WINAPI
IDirect3DDevice8Impl_GetGammaRamp(LPDIRECT3DDEVICE8 iface
, D3DGAMMARAMP
* pRamp
) {
438 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
439 TRACE("(%p) Relay\n", This
);
441 /* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
442 EnterCriticalSection(&d3d8_cs
);
443 IWineD3DDevice_GetGammaRamp(This
->WineD3DDevice
, 0, (WINED3DGAMMARAMP
*) pRamp
);
444 LeaveCriticalSection(&d3d8_cs
);
447 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateTexture(LPDIRECT3DDEVICE8 iface
, UINT Width
, UINT Height
, UINT Levels
, DWORD Usage
,
448 D3DFORMAT Format
, D3DPOOL Pool
, IDirect3DTexture8
**ppTexture
) {
449 IDirect3DTexture8Impl
*object
;
450 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
451 HRESULT hrc
= D3D_OK
;
453 TRACE("(%p) : W(%d) H(%d), Lvl(%d) d(%d), Fmt(%u), Pool(%d)\n", This
, Width
, Height
, Levels
, Usage
, Format
, Pool
);
455 /* Allocate the storage for the device */
456 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(IDirect3DTexture8Impl
));
458 if (NULL
== object
) {
459 FIXME("Allocation of memory failed\n");
460 /* *ppTexture = NULL; */
461 return D3DERR_OUTOFVIDEOMEMORY
;
464 object
->lpVtbl
= &Direct3DTexture8_Vtbl
;
466 EnterCriticalSection(&d3d8_cs
);
467 hrc
= IWineD3DDevice_CreateTexture(This
->WineD3DDevice
, Width
, Height
, Levels
, Usage
& WINED3DUSAGE_MASK
,
468 (WINED3DFORMAT
)Format
, (WINED3DPOOL
) Pool
, &object
->wineD3DTexture
, NULL
, (IUnknown
*)object
, D3D8CB_CreateSurface
);
469 LeaveCriticalSection(&d3d8_cs
);
473 FIXME("(%p) call to IWineD3DDevice_CreateTexture failed\n", This
);
474 HeapFree(GetProcessHeap(), 0, object
);
475 /* *ppTexture = NULL; */
477 IUnknown_AddRef(iface
);
478 object
->parentDevice
= iface
;
479 *ppTexture
= (LPDIRECT3DTEXTURE8
) object
;
480 TRACE("(%p) Created Texture %p, %p\n",This
,object
,object
->wineD3DTexture
);
486 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateVolumeTexture(LPDIRECT3DDEVICE8 iface
,
487 UINT Width
, UINT Height
, UINT Depth
, UINT Levels
, DWORD Usage
,
488 D3DFORMAT Format
, D3DPOOL Pool
, IDirect3DVolumeTexture8
** ppVolumeTexture
) {
490 IDirect3DVolumeTexture8Impl
*object
;
491 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
492 HRESULT hrc
= D3D_OK
;
494 TRACE("(%p) Relay\n", This
);
496 /* Allocate the storage for the device */
497 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(IDirect3DVolumeTexture8Impl
));
498 if (NULL
== object
) {
499 FIXME("(%p) allocation of memory failed\n", This
);
500 *ppVolumeTexture
= NULL
;
501 return D3DERR_OUTOFVIDEOMEMORY
;
504 object
->lpVtbl
= &Direct3DVolumeTexture8_Vtbl
;
506 EnterCriticalSection(&d3d8_cs
);
507 hrc
= IWineD3DDevice_CreateVolumeTexture(This
->WineD3DDevice
, Width
, Height
, Depth
, Levels
, Usage
& WINED3DUSAGE_MASK
,
508 (WINED3DFORMAT
)Format
, (WINED3DPOOL
) Pool
, &object
->wineD3DVolumeTexture
, NULL
,
509 (IUnknown
*)object
, D3D8CB_CreateVolume
);
510 LeaveCriticalSection(&d3d8_cs
);
515 FIXME("(%p) call to IWineD3DDevice_CreateVolumeTexture failed\n", This
);
516 HeapFree(GetProcessHeap(), 0, object
);
517 *ppVolumeTexture
= NULL
;
519 IUnknown_AddRef(iface
);
520 object
->parentDevice
= iface
;
521 *ppVolumeTexture
= (LPDIRECT3DVOLUMETEXTURE8
) object
;
523 TRACE("(%p) returning %p\n", This
, *ppVolumeTexture
);
527 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateCubeTexture(LPDIRECT3DDEVICE8 iface
, UINT EdgeLength
, UINT Levels
, DWORD Usage
,
528 D3DFORMAT Format
, D3DPOOL Pool
, IDirect3DCubeTexture8
** ppCubeTexture
) {
530 IDirect3DCubeTexture8Impl
*object
;
531 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
534 TRACE("(%p) : ELen(%d) Lvl(%d) Usage(%d) fmt(%u), Pool(%d)\n" , This
, EdgeLength
, Levels
, Usage
, Format
, Pool
);
536 /* Allocate the storage for the device */
537 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
539 if (NULL
== object
) {
540 FIXME("(%p) allocation of CubeTexture failed\n", This
);
541 *ppCubeTexture
= NULL
;
542 return D3DERR_OUTOFVIDEOMEMORY
;
545 object
->lpVtbl
= &Direct3DCubeTexture8_Vtbl
;
547 EnterCriticalSection(&d3d8_cs
);
548 hr
= IWineD3DDevice_CreateCubeTexture(This
->WineD3DDevice
, EdgeLength
, Levels
, Usage
& WINED3DUSAGE_MASK
,
549 (WINED3DFORMAT
)Format
, (WINED3DPOOL
) Pool
, &object
->wineD3DCubeTexture
, NULL
, (IUnknown
*)object
,
550 D3D8CB_CreateSurface
);
551 LeaveCriticalSection(&d3d8_cs
);
556 FIXME("(%p) call to IWineD3DDevice_CreateCubeTexture failed\n", This
);
557 HeapFree(GetProcessHeap(), 0, object
);
558 *ppCubeTexture
= NULL
;
560 IUnknown_AddRef(iface
);
561 object
->parentDevice
= iface
;
562 *ppCubeTexture
= (LPDIRECT3DCUBETEXTURE8
) object
;
565 TRACE("(%p) returning %p\n",This
, *ppCubeTexture
);
569 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateVertexBuffer(LPDIRECT3DDEVICE8 iface
, UINT Size
, DWORD Usage
, DWORD FVF
, D3DPOOL Pool
, IDirect3DVertexBuffer8
** ppVertexBuffer
) {
570 IDirect3DVertexBuffer8Impl
*object
;
571 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
572 HRESULT hrc
= D3D_OK
;
574 TRACE("(%p) Relay\n", This
);
575 /* Allocate the storage for the device */
576 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(IDirect3DVertexBuffer8Impl
));
577 if (NULL
== object
) {
578 FIXME("Allocation of memory failed\n");
579 *ppVertexBuffer
= NULL
;
580 return D3DERR_OUTOFVIDEOMEMORY
;
583 object
->lpVtbl
= &Direct3DVertexBuffer8_Vtbl
;
585 EnterCriticalSection(&d3d8_cs
);
586 hrc
= IWineD3DDevice_CreateVertexBuffer(This
->WineD3DDevice
, Size
, Usage
& WINED3DUSAGE_MASK
, FVF
, (WINED3DPOOL
) Pool
, &(object
->wineD3DVertexBuffer
), NULL
, (IUnknown
*)object
);
587 LeaveCriticalSection(&d3d8_cs
);
592 FIXME("(%p) call to IWineD3DDevice_CreateVertexBuffer failed\n", This
);
593 HeapFree(GetProcessHeap(), 0, object
);
594 *ppVertexBuffer
= NULL
;
596 IUnknown_AddRef(iface
);
597 object
->parentDevice
= iface
;
598 *ppVertexBuffer
= (LPDIRECT3DVERTEXBUFFER8
) object
;
603 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateIndexBuffer(LPDIRECT3DDEVICE8 iface
, UINT Length
, DWORD Usage
, D3DFORMAT Format
, D3DPOOL Pool
, IDirect3DIndexBuffer8
** ppIndexBuffer
) {
604 IDirect3DIndexBuffer8Impl
*object
;
605 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
606 HRESULT hrc
= D3D_OK
;
608 TRACE("(%p) Relay\n", This
);
609 /* Allocate the storage for the device */
610 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
611 if (NULL
== object
) {
612 FIXME("Allocation of memory failed\n");
613 *ppIndexBuffer
= NULL
;
614 return D3DERR_OUTOFVIDEOMEMORY
;
617 object
->lpVtbl
= &Direct3DIndexBuffer8_Vtbl
;
619 TRACE("Calling wined3d create index buffer\n");
620 EnterCriticalSection(&d3d8_cs
);
621 hrc
= IWineD3DDevice_CreateIndexBuffer(This
->WineD3DDevice
, Length
, Usage
& WINED3DUSAGE_MASK
, Format
, (WINED3DPOOL
) Pool
, &object
->wineD3DIndexBuffer
, NULL
, (IUnknown
*)object
);
622 LeaveCriticalSection(&d3d8_cs
);
627 FIXME("(%p) call to IWineD3DDevice_CreateIndexBuffer failed\n", This
);
628 HeapFree(GetProcessHeap(), 0, object
);
629 *ppIndexBuffer
= NULL
;
631 IUnknown_AddRef(iface
);
632 object
->parentDevice
= iface
;
633 *ppIndexBuffer
= (LPDIRECT3DINDEXBUFFER8
)object
;
638 static HRESULT
IDirect3DDevice8Impl_CreateSurface(LPDIRECT3DDEVICE8 iface
, UINT Width
, UINT Height
, D3DFORMAT Format
, BOOL Lockable
, BOOL Discard
, UINT Level
, IDirect3DSurface8
**ppSurface
,D3DRESOURCETYPE Type
, UINT Usage
,D3DPOOL Pool
, D3DMULTISAMPLE_TYPE MultiSample
, DWORD MultisampleQuality
) {
640 IDirect3DSurface8Impl
*object
;
641 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
642 TRACE("(%p) Relay\n", This
);
644 if(MultisampleQuality
> 0){
645 FIXME("MultisampleQuality set to %d, substituting 0\n" , MultisampleQuality
);
648 [in] Quality level. The valid range is between zero and one less than the level returned by pQualityLevels used by IDirect3D8::CheckDeviceMultiSampleType. Passing a larger value returns the error D3DERR_INVALIDCALL. The MultisampleQuality values of paired render targets, depth stencil surfaces, and the MultiSample type must all match.
650 MultisampleQuality
=0;
652 /*FIXME: Check MAX bounds of MultisampleQuality*/
654 /* Allocate the storage for the device */
655 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(IDirect3DSurface8Impl
));
656 if (NULL
== object
) {
657 FIXME("Allocation of memory failed\n");
659 return D3DERR_OUTOFVIDEOMEMORY
;
662 object
->lpVtbl
= &Direct3DSurface8_Vtbl
;
665 TRACE("(%p) : w(%d) h(%d) fmt(%d) surf@%p\n", This
, Width
, Height
, Format
, *ppSurface
);
667 /* Not called from the VTable, no locking needed */
668 hrc
= IWineD3DDevice_CreateSurface(This
->WineD3DDevice
, Width
, Height
, Format
, Lockable
, Discard
, Level
, &object
->wineD3DSurface
, Type
, Usage
& WINED3DUSAGE_MASK
, (WINED3DPOOL
) Pool
,MultiSample
,MultisampleQuality
, NULL
, SURFACE_OPENGL
, (IUnknown
*)object
);
669 if (hrc
!= D3D_OK
|| NULL
== object
->wineD3DSurface
) {
671 FIXME("(%p) call to IWineD3DDevice_CreateSurface failed\n", This
);
672 HeapFree(GetProcessHeap(), 0, object
);
675 IUnknown_AddRef(iface
);
676 object
->parentDevice
= iface
;
677 *ppSurface
= (LPDIRECT3DSURFACE8
) object
;
682 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateRenderTarget(LPDIRECT3DDEVICE8 iface
, UINT Width
, UINT Height
, D3DFORMAT Format
, D3DMULTISAMPLE_TYPE MultiSample
, BOOL Lockable
, IDirect3DSurface8
** ppSurface
) {
686 EnterCriticalSection(&d3d8_cs
);
687 hr
= IDirect3DDevice8Impl_CreateSurface(iface
, Width
, Height
, Format
, Lockable
, FALSE
/* Discard */, 0 /* Level */ , ppSurface
, D3DRTYPE_SURFACE
, D3DUSAGE_RENDERTARGET
, D3DPOOL_DEFAULT
, MultiSample
, 0);
688 LeaveCriticalSection(&d3d8_cs
);
692 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE8 iface
, UINT Width
, UINT Height
, D3DFORMAT Format
, D3DMULTISAMPLE_TYPE MultiSample
, IDirect3DSurface8
** ppSurface
) {
696 /* TODO: Verify that Discard is false */
697 EnterCriticalSection(&d3d8_cs
);
698 hr
= IDirect3DDevice8Impl_CreateSurface(iface
, Width
, Height
, Format
, TRUE
/* Lockable */, FALSE
, 0 /* Level */
699 ,ppSurface
, D3DRTYPE_SURFACE
, D3DUSAGE_DEPTHSTENCIL
,
700 D3DPOOL_DEFAULT
, MultiSample
, 0);
701 LeaveCriticalSection(&d3d8_cs
);
705 /* IDirect3DDevice8Impl::CreateImageSurface returns surface with pool type SYSTEMMEM */
706 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateImageSurface(LPDIRECT3DDEVICE8 iface
, UINT Width
, UINT Height
, D3DFORMAT Format
, IDirect3DSurface8
** ppSurface
) {
710 EnterCriticalSection(&d3d8_cs
);
711 hr
= IDirect3DDevice8Impl_CreateSurface(iface
, Width
, Height
, Format
, TRUE
/* Loackable */ , FALSE
/*Discard*/ , 0 /* Level */ , ppSurface
,
712 D3DRTYPE_SURFACE
, 0 /* Usage (undefined/none) */ , D3DPOOL_SYSTEMMEM
, D3DMULTISAMPLE_NONE
, 0 /* MultisampleQuality */);
713 LeaveCriticalSection(&d3d8_cs
);
717 static HRESULT WINAPI
IDirect3DDevice8Impl_CopyRects(LPDIRECT3DDEVICE8 iface
, IDirect3DSurface8
*pSourceSurface
, CONST RECT
*pSourceRects
, UINT cRects
, IDirect3DSurface8
*pDestinationSurface
, CONST POINT
*pDestPoints
) {
718 IDirect3DSurface8Impl
*Source
= (IDirect3DSurface8Impl
*) pSourceSurface
;
719 IDirect3DSurface8Impl
*Dest
= (IDirect3DSurface8Impl
*) pDestinationSurface
;
721 HRESULT hr
= WINED3D_OK
;
722 WINED3DFORMAT srcFormat
, destFormat
;
723 UINT srcWidth
, destWidth
;
724 UINT srcHeight
, destHeight
;
726 WINED3DSURFACE_DESC winedesc
;
728 TRACE("(%p) pSrcSur=%p, pSourceRects=%p, cRects=%d, pDstSur=%p, pDestPtsArr=%p\n", iface
,
729 pSourceSurface
, pSourceRects
, cRects
, pDestinationSurface
, pDestPoints
);
732 /* Check that the source texture is in WINED3DPOOL_SYSTEMMEM and the destination texture is in WINED3DPOOL_DEFAULT */
733 memset(&winedesc
, 0, sizeof(winedesc
));
735 winedesc
.Format
= &srcFormat
;
736 winedesc
.Width
= &srcWidth
;
737 winedesc
.Height
= &srcHeight
;
738 winedesc
.Size
= &srcSize
;
739 IWineD3DSurface_GetDesc(Source
->wineD3DSurface
, &winedesc
);
741 winedesc
.Format
= &destFormat
;
742 winedesc
.Width
= &destWidth
;
743 winedesc
.Height
= &destHeight
;
744 winedesc
.Size
= NULL
;
745 EnterCriticalSection(&d3d8_cs
);
746 IWineD3DSurface_GetDesc(Dest
->wineD3DSurface
, &winedesc
);
748 /* Check that the source and destination formats match */
749 if (srcFormat
!= destFormat
&& WINED3DFMT_UNKNOWN
!= destFormat
) {
750 WARN("(%p) source %p format must match the dest %p format, returning WINED3DERR_INVALIDCALL\n", iface
, pSourceSurface
, pDestinationSurface
);
751 LeaveCriticalSection(&d3d8_cs
);
752 return WINED3DERR_INVALIDCALL
;
753 } else if (WINED3DFMT_UNKNOWN
== destFormat
) {
754 TRACE("(%p) : Converting destination surface from WINED3DFMT_UNKNOWN to the source format\n", iface
);
755 IWineD3DSurface_SetFormat(Dest
->wineD3DSurface
, srcFormat
);
756 destFormat
= srcFormat
;
759 /* Quick if complete copy ... */
760 if (cRects
== 0 && pSourceRects
== NULL
&& pDestPoints
== NULL
) {
761 IWineD3DSurface_BltFast(Dest
->wineD3DSurface
, 0, 0, Source
->wineD3DSurface
, NULL
, WINEDDBLTFAST_NOCOLORKEY
);
764 /* Copy rect by rect */
765 if (NULL
!= pSourceRects
&& NULL
!= pDestPoints
) {
766 for (i
= 0; i
< cRects
; ++i
) {
767 IWineD3DSurface_BltFast(Dest
->wineD3DSurface
, pDestPoints
[i
].x
, pDestPoints
[i
].y
, Source
->wineD3DSurface
, (RECT
*) &pSourceRects
[i
], WINEDDBLTFAST_NOCOLORKEY
);
770 for (i
= 0; i
< cRects
; ++i
) {
771 IWineD3DSurface_BltFast(Dest
->wineD3DSurface
, 0, 0, Source
->wineD3DSurface
, (RECT
*) &pSourceRects
[i
], WINEDDBLTFAST_NOCOLORKEY
);
775 LeaveCriticalSection(&d3d8_cs
);
780 static HRESULT WINAPI
IDirect3DDevice8Impl_UpdateTexture(LPDIRECT3DDEVICE8 iface
, IDirect3DBaseTexture8
* pSourceTexture
, IDirect3DBaseTexture8
* pDestinationTexture
) {
781 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
783 TRACE("(%p) Relay\n" , This
);
785 EnterCriticalSection(&d3d8_cs
);
786 hr
= IWineD3DDevice_UpdateTexture(This
->WineD3DDevice
, ((IDirect3DBaseTexture8Impl
*)pSourceTexture
)->wineD3DBaseTexture
, ((IDirect3DBaseTexture8Impl
*)pDestinationTexture
)->wineD3DBaseTexture
);
787 LeaveCriticalSection(&d3d8_cs
);
791 static HRESULT WINAPI
IDirect3DDevice8Impl_GetFrontBuffer(LPDIRECT3DDEVICE8 iface
, IDirect3DSurface8
* pDestSurface
) {
792 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
793 IDirect3DSurface8Impl
*destSurface
= (IDirect3DSurface8Impl
*)pDestSurface
;
796 TRACE("(%p) Relay\n" , This
);
798 if (pDestSurface
== NULL
) {
799 WARN("(%p) : Caller passed NULL as pDestSurface returning D3DERR_INVALIDCALL\n", This
);
800 return D3DERR_INVALIDCALL
;
803 EnterCriticalSection(&d3d8_cs
);
804 hr
= IWineD3DDevice_GetFrontBufferData(This
->WineD3DDevice
, 0, destSurface
->wineD3DSurface
);
805 LeaveCriticalSection(&d3d8_cs
);
809 static HRESULT WINAPI
IDirect3DDevice8Impl_SetRenderTarget(LPDIRECT3DDEVICE8 iface
, IDirect3DSurface8
* pRenderTarget
, IDirect3DSurface8
* pNewZStencil
) {
810 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
811 IDirect3DSurface8Impl
*pSurface
= (IDirect3DSurface8Impl
*)pRenderTarget
;
812 IDirect3DSurface8Impl
*pZSurface
= (IDirect3DSurface8Impl
*)pNewZStencil
;
813 IWineD3DSurface
*original_ds
= NULL
;
815 TRACE("(%p) Relay\n" , This
);
817 EnterCriticalSection(&d3d8_cs
);
819 hr
= IWineD3DDevice_GetDepthStencilSurface(This
->WineD3DDevice
, &original_ds
);
820 if (hr
== WINED3D_OK
|| hr
== WINED3DERR_NOTFOUND
)
822 hr
= IWineD3DDevice_SetDepthStencilSurface(This
->WineD3DDevice
, pZSurface
? pZSurface
->wineD3DSurface
: NULL
);
823 if (SUCCEEDED(hr
) && pSurface
)
824 hr
= IWineD3DDevice_SetRenderTarget(This
->WineD3DDevice
, 0, pSurface
->wineD3DSurface
);
825 if (FAILED(hr
)) IWineD3DDevice_SetDepthStencilSurface(This
->WineD3DDevice
, original_ds
);
827 if (original_ds
) IWineD3DSurface_Release(original_ds
);
829 LeaveCriticalSection(&d3d8_cs
);
833 static HRESULT WINAPI
IDirect3DDevice8Impl_GetRenderTarget(LPDIRECT3DDEVICE8 iface
, IDirect3DSurface8
** ppRenderTarget
) {
834 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
836 IWineD3DSurface
*pRenderTarget
;
838 TRACE("(%p) Relay\n" , This
);
840 if (ppRenderTarget
== NULL
) {
841 return D3DERR_INVALIDCALL
;
843 EnterCriticalSection(&d3d8_cs
);
844 hr
= IWineD3DDevice_GetRenderTarget(This
->WineD3DDevice
, 0, &pRenderTarget
);
846 if (hr
== D3D_OK
&& pRenderTarget
!= NULL
) {
847 IWineD3DSurface_GetParent(pRenderTarget
,(IUnknown
**)ppRenderTarget
);
848 IWineD3DSurface_Release(pRenderTarget
);
850 FIXME("Call to IWineD3DDevice_GetRenderTarget failed\n");
851 *ppRenderTarget
= NULL
;
853 LeaveCriticalSection(&d3d8_cs
);
858 static HRESULT WINAPI
IDirect3DDevice8Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE8 iface
, IDirect3DSurface8
** ppZStencilSurface
) {
859 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
861 IWineD3DSurface
*pZStencilSurface
;
863 TRACE("(%p) Relay\n" , This
);
864 if(ppZStencilSurface
== NULL
){
865 return D3DERR_INVALIDCALL
;
868 EnterCriticalSection(&d3d8_cs
);
869 hr
=IWineD3DDevice_GetDepthStencilSurface(This
->WineD3DDevice
,&pZStencilSurface
);
870 if (hr
== WINED3D_OK
) {
871 IWineD3DSurface_GetParent(pZStencilSurface
,(IUnknown
**)ppZStencilSurface
);
872 IWineD3DSurface_Release(pZStencilSurface
);
874 if (hr
!= WINED3DERR_NOTFOUND
)
875 FIXME("Call to IWineD3DDevice_GetDepthStencilSurface failed with 0x%08x\n", hr
);
876 *ppZStencilSurface
= NULL
;
878 LeaveCriticalSection(&d3d8_cs
);
883 static HRESULT WINAPI
IDirect3DDevice8Impl_BeginScene(LPDIRECT3DDEVICE8 iface
) {
884 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
886 TRACE("(%p) Relay\n" , This
);
888 EnterCriticalSection(&d3d8_cs
);
889 hr
= IWineD3DDevice_BeginScene(This
->WineD3DDevice
);
890 LeaveCriticalSection(&d3d8_cs
);
894 static HRESULT WINAPI
IDirect3DDevice8Impl_EndScene(LPDIRECT3DDEVICE8 iface
) {
895 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
897 TRACE("(%p) Relay\n" , This
);
899 EnterCriticalSection(&d3d8_cs
);
900 hr
= IWineD3DDevice_EndScene(This
->WineD3DDevice
);
901 LeaveCriticalSection(&d3d8_cs
);
905 static HRESULT WINAPI
IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface
, DWORD Count
, CONST D3DRECT
* pRects
, DWORD Flags
, D3DCOLOR Color
, float Z
, DWORD Stencil
) {
906 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
908 TRACE("(%p) Relay\n" , This
);
910 /* Note: D3DRECT is compatible with WINED3DRECT */
911 EnterCriticalSection(&d3d8_cs
);
912 hr
= IWineD3DDevice_Clear(This
->WineD3DDevice
, Count
, (CONST WINED3DRECT
*) pRects
, Flags
, Color
, Z
, Stencil
);
913 LeaveCriticalSection(&d3d8_cs
);
917 static HRESULT WINAPI
IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface
, D3DTRANSFORMSTATETYPE State
, CONST D3DMATRIX
* lpMatrix
) {
918 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
920 TRACE("(%p) Relay\n" , This
);
922 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
923 EnterCriticalSection(&d3d8_cs
);
924 hr
= IWineD3DDevice_SetTransform(This
->WineD3DDevice
, State
, (CONST WINED3DMATRIX
*) lpMatrix
);
925 LeaveCriticalSection(&d3d8_cs
);
929 static HRESULT WINAPI
IDirect3DDevice8Impl_GetTransform(LPDIRECT3DDEVICE8 iface
, D3DTRANSFORMSTATETYPE State
,D3DMATRIX
* pMatrix
) {
930 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
932 TRACE("(%p) Relay\n" , This
);
934 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
935 EnterCriticalSection(&d3d8_cs
);
936 hr
= IWineD3DDevice_GetTransform(This
->WineD3DDevice
, State
, (WINED3DMATRIX
*) pMatrix
);
937 LeaveCriticalSection(&d3d8_cs
);
941 static HRESULT WINAPI
IDirect3DDevice8Impl_MultiplyTransform(LPDIRECT3DDEVICE8 iface
, D3DTRANSFORMSTATETYPE State
, CONST D3DMATRIX
* pMatrix
) {
942 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
944 TRACE("(%p) Relay\n" , This
);
946 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
947 EnterCriticalSection(&d3d8_cs
);
948 hr
= IWineD3DDevice_MultiplyTransform(This
->WineD3DDevice
, State
, (CONST WINED3DMATRIX
*) pMatrix
);
949 LeaveCriticalSection(&d3d8_cs
);
953 static HRESULT WINAPI
IDirect3DDevice8Impl_SetViewport(LPDIRECT3DDEVICE8 iface
, CONST D3DVIEWPORT8
* pViewport
) {
954 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
956 TRACE("(%p) Relay\n" , This
);
958 /* Note: D3DVIEWPORT8 is compatible with WINED3DVIEWPORT */
959 EnterCriticalSection(&d3d8_cs
);
960 hr
= IWineD3DDevice_SetViewport(This
->WineD3DDevice
, (const WINED3DVIEWPORT
*)pViewport
);
961 LeaveCriticalSection(&d3d8_cs
);
965 static HRESULT WINAPI
IDirect3DDevice8Impl_GetViewport(LPDIRECT3DDEVICE8 iface
, D3DVIEWPORT8
* pViewport
) {
966 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
968 TRACE("(%p) Relay\n" , This
);
970 /* Note: D3DVIEWPORT8 is compatible with WINED3DVIEWPORT */
971 EnterCriticalSection(&d3d8_cs
);
972 hr
= IWineD3DDevice_GetViewport(This
->WineD3DDevice
, (WINED3DVIEWPORT
*)pViewport
);
973 LeaveCriticalSection(&d3d8_cs
);
977 static HRESULT WINAPI
IDirect3DDevice8Impl_SetMaterial(LPDIRECT3DDEVICE8 iface
, CONST D3DMATERIAL8
* pMaterial
) {
978 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
980 TRACE("(%p) Relay\n" , This
);
982 /* Note: D3DMATERIAL8 is compatible with WINED3DMATERIAL */
983 EnterCriticalSection(&d3d8_cs
);
984 hr
= IWineD3DDevice_SetMaterial(This
->WineD3DDevice
, (const WINED3DMATERIAL
*)pMaterial
);
985 LeaveCriticalSection(&d3d8_cs
);
989 static HRESULT WINAPI
IDirect3DDevice8Impl_GetMaterial(LPDIRECT3DDEVICE8 iface
, D3DMATERIAL8
* pMaterial
) {
990 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
992 TRACE("(%p) Relay\n" , This
);
994 /* Note: D3DMATERIAL8 is compatible with WINED3DMATERIAL */
995 EnterCriticalSection(&d3d8_cs
);
996 hr
= IWineD3DDevice_GetMaterial(This
->WineD3DDevice
, (WINED3DMATERIAL
*)pMaterial
);
997 LeaveCriticalSection(&d3d8_cs
);
1001 static HRESULT WINAPI
IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface
, DWORD Index
, CONST D3DLIGHT8
* pLight
) {
1002 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1004 TRACE("(%p) Relay\n" , This
);
1006 /* Note: D3DLIGHT8 is compatible with WINED3DLIGHT */
1007 EnterCriticalSection(&d3d8_cs
);
1008 hr
= IWineD3DDevice_SetLight(This
->WineD3DDevice
, Index
, (const WINED3DLIGHT
*)pLight
);
1009 LeaveCriticalSection(&d3d8_cs
);
1013 static HRESULT WINAPI
IDirect3DDevice8Impl_GetLight(LPDIRECT3DDEVICE8 iface
, DWORD Index
,D3DLIGHT8
* pLight
) {
1014 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1016 TRACE("(%p) Relay\n" , This
);
1018 /* Note: D3DLIGHT8 is compatible with WINED3DLIGHT */
1019 EnterCriticalSection(&d3d8_cs
);
1020 hr
= IWineD3DDevice_GetLight(This
->WineD3DDevice
, Index
, (WINED3DLIGHT
*)pLight
);
1021 LeaveCriticalSection(&d3d8_cs
);
1025 static HRESULT WINAPI
IDirect3DDevice8Impl_LightEnable(LPDIRECT3DDEVICE8 iface
, DWORD Index
,BOOL Enable
) {
1026 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1028 TRACE("(%p) Relay\n" , This
);
1030 EnterCriticalSection(&d3d8_cs
);
1031 hr
= IWineD3DDevice_SetLightEnable(This
->WineD3DDevice
, Index
, Enable
);
1032 LeaveCriticalSection(&d3d8_cs
);
1036 static HRESULT WINAPI
IDirect3DDevice8Impl_GetLightEnable(LPDIRECT3DDEVICE8 iface
, DWORD Index
,BOOL
* pEnable
) {
1037 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1039 TRACE("(%p) Relay\n" , This
);
1041 EnterCriticalSection(&d3d8_cs
);
1042 hr
= IWineD3DDevice_GetLightEnable(This
->WineD3DDevice
, Index
, pEnable
);
1043 LeaveCriticalSection(&d3d8_cs
);
1047 static HRESULT WINAPI
IDirect3DDevice8Impl_SetClipPlane(LPDIRECT3DDEVICE8 iface
, DWORD Index
,CONST
float* pPlane
) {
1048 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1050 TRACE("(%p) Relay\n" , This
);
1052 EnterCriticalSection(&d3d8_cs
);
1053 hr
= IWineD3DDevice_SetClipPlane(This
->WineD3DDevice
, Index
, pPlane
);
1054 LeaveCriticalSection(&d3d8_cs
);
1058 static HRESULT WINAPI
IDirect3DDevice8Impl_GetClipPlane(LPDIRECT3DDEVICE8 iface
, DWORD Index
,float* pPlane
) {
1059 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1061 TRACE("(%p) Relay\n" , This
);
1063 EnterCriticalSection(&d3d8_cs
);
1064 hr
= IWineD3DDevice_GetClipPlane(This
->WineD3DDevice
, Index
, pPlane
);
1065 LeaveCriticalSection(&d3d8_cs
);
1069 static HRESULT WINAPI
IDirect3DDevice8Impl_SetRenderState(LPDIRECT3DDEVICE8 iface
, D3DRENDERSTATETYPE State
,DWORD Value
) {
1070 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1072 TRACE("(%p) Relay\n" , This
);
1074 EnterCriticalSection(&d3d8_cs
);
1075 hr
= IWineD3DDevice_SetRenderState(This
->WineD3DDevice
, State
, Value
);
1076 LeaveCriticalSection(&d3d8_cs
);
1080 static HRESULT WINAPI
IDirect3DDevice8Impl_GetRenderState(LPDIRECT3DDEVICE8 iface
, D3DRENDERSTATETYPE State
,DWORD
* pValue
) {
1081 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1083 TRACE("(%p) Relay\n" , This
);
1085 EnterCriticalSection(&d3d8_cs
);
1086 hr
= IWineD3DDevice_GetRenderState(This
->WineD3DDevice
, State
, pValue
);
1087 LeaveCriticalSection(&d3d8_cs
);
1091 static HRESULT WINAPI
IDirect3DDevice8Impl_BeginStateBlock(LPDIRECT3DDEVICE8 iface
) {
1092 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1094 TRACE("(%p)\n", This
);
1096 EnterCriticalSection(&d3d8_cs
);
1097 hr
= IWineD3DDevice_BeginStateBlock(This
->WineD3DDevice
);
1098 LeaveCriticalSection(&d3d8_cs
);
1102 static HRESULT WINAPI
IDirect3DDevice8Impl_EndStateBlock(LPDIRECT3DDEVICE8 iface
, DWORD
* pToken
) {
1103 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1105 IWineD3DStateBlock
* wineD3DStateBlock
;
1106 IDirect3DStateBlock8Impl
* object
;
1108 TRACE("(%p) Relay\n", This
);
1110 /* Tell wineD3D to endstateblock before anything else (in case we run out
1111 * of memory later and cause locking problems)
1113 EnterCriticalSection(&d3d8_cs
);
1114 hr
= IWineD3DDevice_EndStateBlock(This
->WineD3DDevice
, &wineD3DStateBlock
);
1116 WARN("IWineD3DDevice_EndStateBlock returned an error\n");
1117 LeaveCriticalSection(&d3d8_cs
);
1121 /* allocate a new IDirectD3DStateBlock */
1122 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,sizeof(IDirect3DStateBlock8Impl
));
1124 object
->lpVtbl
= &Direct3DStateBlock8_Vtbl
;
1126 object
->wineD3DStateBlock
= wineD3DStateBlock
;
1128 *pToken
= (DWORD
)object
;
1129 TRACE("(%p)Returning %p %p\n", This
, object
, wineD3DStateBlock
);
1131 LeaveCriticalSection(&d3d8_cs
);
1135 static HRESULT WINAPI
IDirect3DDevice8Impl_ApplyStateBlock(LPDIRECT3DDEVICE8 iface
, DWORD Token
) {
1136 IDirect3DStateBlock8Impl
*pSB
= (IDirect3DStateBlock8Impl
*) Token
;
1137 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1140 TRACE("(%p) %p Relay\n", This
, pSB
);
1142 EnterCriticalSection(&d3d8_cs
);
1143 hr
= IWineD3DStateBlock_Apply(pSB
->wineD3DStateBlock
);
1144 LeaveCriticalSection(&d3d8_cs
);
1148 static HRESULT WINAPI
IDirect3DDevice8Impl_CaptureStateBlock(LPDIRECT3DDEVICE8 iface
, DWORD Token
) {
1149 IDirect3DStateBlock8Impl
* pSB
= (IDirect3DStateBlock8Impl
*)Token
;
1150 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1153 TRACE("(%p) %p Relay\n", This
, pSB
);
1155 EnterCriticalSection(&d3d8_cs
);
1156 hr
= IWineD3DStateBlock_Capture(pSB
->wineD3DStateBlock
);
1157 LeaveCriticalSection(&d3d8_cs
);
1161 static HRESULT WINAPI
IDirect3DDevice8Impl_DeleteStateBlock(LPDIRECT3DDEVICE8 iface
, DWORD Token
) {
1162 IDirect3DStateBlock8Impl
* pSB
= (IDirect3DStateBlock8Impl
*)Token
;
1163 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1165 TRACE("(%p) Relay\n", This
);
1167 EnterCriticalSection(&d3d8_cs
);
1168 while(IUnknown_Release((IUnknown
*)pSB
));
1169 LeaveCriticalSection(&d3d8_cs
);
1174 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateStateBlock(LPDIRECT3DDEVICE8 iface
, D3DSTATEBLOCKTYPE Type
, DWORD
* pToken
) {
1175 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1176 IDirect3DStateBlock8Impl
*object
;
1177 HRESULT hrc
= D3D_OK
;
1179 TRACE("(%p) Relay\n", This
);
1181 if(Type
!= D3DSBT_ALL
&& Type
!= D3DSBT_PIXELSTATE
&&
1182 Type
!= D3DSBT_VERTEXSTATE
) {
1183 WARN("Unexpected stateblock type, returning D3DERR_INVALIDCALL\n");
1184 return D3DERR_INVALIDCALL
;
1187 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(IDirect3DStateBlock8Impl
));
1188 if (NULL
== object
) {
1190 return E_OUTOFMEMORY
;
1192 object
->lpVtbl
= &Direct3DStateBlock8_Vtbl
;
1195 EnterCriticalSection(&d3d8_cs
);
1196 hrc
= IWineD3DDevice_CreateStateBlock(This
->WineD3DDevice
, (WINED3DSTATEBLOCKTYPE
)Type
, &object
->wineD3DStateBlock
, (IUnknown
*)object
);
1197 LeaveCriticalSection(&d3d8_cs
);
1199 FIXME("(%p) Call to IWineD3DDevice_CreateStateBlock failed.\n", This
);
1200 HeapFree(GetProcessHeap(), 0, object
);
1203 *pToken
= (DWORD
)object
;
1204 TRACE("(%p) returning token (ptr to stateblock) of %p\n", This
, object
);
1210 static HRESULT WINAPI
IDirect3DDevice8Impl_SetClipStatus(LPDIRECT3DDEVICE8 iface
, CONST D3DCLIPSTATUS8
* pClipStatus
) {
1211 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1213 TRACE("(%p) Relay\n" , This
);
1214 /* FIXME: Verify that D3DCLIPSTATUS8 ~= WINED3DCLIPSTATUS */
1215 EnterCriticalSection(&d3d8_cs
);
1216 hr
= IWineD3DDevice_SetClipStatus(This
->WineD3DDevice
, (const WINED3DCLIPSTATUS
*)pClipStatus
);
1217 LeaveCriticalSection(&d3d8_cs
);
1221 static HRESULT WINAPI
IDirect3DDevice8Impl_GetClipStatus(LPDIRECT3DDEVICE8 iface
, D3DCLIPSTATUS8
* pClipStatus
) {
1222 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1224 TRACE("(%p) Relay\n" , This
);
1226 EnterCriticalSection(&d3d8_cs
);
1227 hr
= IWineD3DDevice_GetClipStatus(This
->WineD3DDevice
, (WINED3DCLIPSTATUS
*)pClipStatus
);
1228 LeaveCriticalSection(&d3d8_cs
);
1232 static HRESULT WINAPI
IDirect3DDevice8Impl_GetTexture(LPDIRECT3DDEVICE8 iface
, DWORD Stage
,IDirect3DBaseTexture8
** ppTexture
) {
1233 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1234 IWineD3DBaseTexture
*retTexture
= NULL
;
1235 HRESULT rc
= D3D_OK
;
1237 TRACE("(%p) Relay\n" , This
);
1239 if(ppTexture
== NULL
){
1240 return D3DERR_INVALIDCALL
;
1243 EnterCriticalSection(&d3d8_cs
);
1244 rc
= IWineD3DDevice_GetTexture(This
->WineD3DDevice
, Stage
, &retTexture
);
1245 if (rc
== D3D_OK
&& NULL
!= retTexture
) {
1246 IWineD3DBaseTexture_GetParent(retTexture
, (IUnknown
**)ppTexture
);
1247 IWineD3DBaseTexture_Release(retTexture
);
1249 FIXME("Call to get texture (%d) failed (%p)\n", Stage
, retTexture
);
1252 LeaveCriticalSection(&d3d8_cs
);
1257 static HRESULT WINAPI
IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface
, DWORD Stage
, IDirect3DBaseTexture8
* pTexture
) {
1258 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1260 TRACE("(%p) Relay %d %p\n" , This
, Stage
, pTexture
);
1262 EnterCriticalSection(&d3d8_cs
);
1263 hr
= IWineD3DDevice_SetTexture(This
->WineD3DDevice
, Stage
,
1264 pTexture
==NULL
? NULL
: ((IDirect3DBaseTexture8Impl
*)pTexture
)->wineD3DBaseTexture
);
1265 LeaveCriticalSection(&d3d8_cs
);
1269 static const struct tss_lookup
1276 {FALSE
, WINED3DTSS_FORCE_DWORD
}, /* 0, unused */
1277 {FALSE
, WINED3DTSS_COLOROP
}, /* 1, D3DTSS_COLOROP */
1278 {FALSE
, WINED3DTSS_COLORARG1
}, /* 2, D3DTSS_COLORARG1 */
1279 {FALSE
, WINED3DTSS_COLORARG2
}, /* 3, D3DTSS_COLORARG2 */
1280 {FALSE
, WINED3DTSS_ALPHAOP
}, /* 4, D3DTSS_ALPHAOP */
1281 {FALSE
, WINED3DTSS_ALPHAARG1
}, /* 5, D3DTSS_ALPHAARG1 */
1282 {FALSE
, WINED3DTSS_ALPHAARG2
}, /* 6, D3DTSS_ALPHAARG2 */
1283 {FALSE
, WINED3DTSS_BUMPENVMAT00
}, /* 7, D3DTSS_BUMPENVMAT00 */
1284 {FALSE
, WINED3DTSS_BUMPENVMAT01
}, /* 8, D3DTSS_BUMPENVMAT01 */
1285 {FALSE
, WINED3DTSS_BUMPENVMAT10
}, /* 9, D3DTSS_BUMPENVMAT10 */
1286 {FALSE
, WINED3DTSS_BUMPENVMAT11
}, /* 10, D3DTSS_BUMPENVMAT11 */
1287 {FALSE
, WINED3DTSS_TEXCOORDINDEX
}, /* 11, D3DTSS_TEXCOORDINDEX */
1288 {FALSE
, WINED3DTSS_FORCE_DWORD
}, /* 12, unused */
1289 {TRUE
, WINED3DSAMP_ADDRESSU
}, /* 13, D3DTSS_ADDRESSU */
1290 {TRUE
, WINED3DSAMP_ADDRESSV
}, /* 14, D3DTSS_ADDRESSV */
1291 {TRUE
, WINED3DSAMP_BORDERCOLOR
}, /* 15, D3DTSS_BORDERCOLOR */
1292 {TRUE
, WINED3DSAMP_MAGFILTER
}, /* 16, D3DTSS_MAGFILTER */
1293 {TRUE
, WINED3DSAMP_MINFILTER
}, /* 17, D3DTSS_MINFILTER */
1294 {TRUE
, WINED3DSAMP_MIPFILTER
}, /* 18, D3DTSS_MIPFILTER */
1295 {TRUE
, WINED3DSAMP_MIPMAPLODBIAS
}, /* 19, D3DTSS_MIPMAPLODBIAS */
1296 {TRUE
, WINED3DSAMP_MAXMIPLEVEL
}, /* 20, D3DTSS_MAXMIPLEVEL */
1297 {TRUE
, WINED3DSAMP_MAXANISOTROPY
}, /* 21, D3DTSS_MAXANISOTROPY */
1298 {FALSE
, WINED3DTSS_BUMPENVLSCALE
}, /* 22, D3DTSS_BUMPENVLSCALE */
1299 {FALSE
, WINED3DTSS_BUMPENVLOFFSET
}, /* 23, D3DTSS_BUMPENVLOFFSET */
1300 {FALSE
, WINED3DTSS_TEXTURETRANSFORMFLAGS
}, /* 24, D3DTSS_TEXTURETRANSFORMFLAGS */
1301 {TRUE
, WINED3DSAMP_ADDRESSW
}, /* 25, D3DTSS_ADDRESSW */
1302 {FALSE
, WINED3DTSS_COLORARG0
}, /* 26, D3DTSS_COLORARG0 */
1303 {FALSE
, WINED3DTSS_ALPHAARG0
}, /* 27, D3DTSS_ALPHAARG0 */
1304 {FALSE
, WINED3DTSS_RESULTARG
}, /* 28, D3DTSS_RESULTARG */
1307 static HRESULT WINAPI
IDirect3DDevice8Impl_GetTextureStageState(LPDIRECT3DDEVICE8 iface
, DWORD Stage
,D3DTEXTURESTAGESTATETYPE Type
,DWORD
* pValue
) {
1308 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1309 const struct tss_lookup
*l
= &tss_lookup
[Type
];
1311 TRACE("(%p) Relay\n" , This
);
1313 EnterCriticalSection(&d3d8_cs
);
1315 if (l
->sampler_state
) hr
= IWineD3DDevice_GetSamplerState(This
->WineD3DDevice
, Stage
, l
->state
, pValue
);
1316 else hr
= IWineD3DDevice_GetTextureStageState(This
->WineD3DDevice
, Stage
, l
->state
, pValue
);
1318 LeaveCriticalSection(&d3d8_cs
);
1322 static HRESULT WINAPI
IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface
, DWORD Stage
, D3DTEXTURESTAGESTATETYPE Type
, DWORD Value
) {
1323 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1324 const struct tss_lookup
*l
= &tss_lookup
[Type
];
1326 TRACE("(%p) Relay\n" , This
);
1328 EnterCriticalSection(&d3d8_cs
);
1330 if (l
->sampler_state
) hr
= IWineD3DDevice_SetSamplerState(This
->WineD3DDevice
, Stage
, l
->state
, Value
);
1331 else hr
= IWineD3DDevice_SetTextureStageState(This
->WineD3DDevice
, Stage
, l
->state
, Value
);
1333 LeaveCriticalSection(&d3d8_cs
);
1337 static HRESULT WINAPI
IDirect3DDevice8Impl_ValidateDevice(LPDIRECT3DDEVICE8 iface
, DWORD
* pNumPasses
) {
1338 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1340 TRACE("(%p) Relay\n" , This
);
1342 EnterCriticalSection(&d3d8_cs
);
1343 hr
= IWineD3DDevice_ValidateDevice(This
->WineD3DDevice
, pNumPasses
);
1344 LeaveCriticalSection(&d3d8_cs
);
1348 static HRESULT WINAPI
IDirect3DDevice8Impl_GetInfo(LPDIRECT3DDEVICE8 iface
, DWORD DevInfoID
, void* pDevInfoStruct
, DWORD DevInfoStructSize
) {
1349 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1350 FIXME("(%p) : stub\n", This
);
1354 static HRESULT WINAPI
IDirect3DDevice8Impl_SetPaletteEntries(LPDIRECT3DDEVICE8 iface
, UINT PaletteNumber
, CONST PALETTEENTRY
* pEntries
) {
1355 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1357 TRACE("(%p) Relay\n" , This
);
1359 EnterCriticalSection(&d3d8_cs
);
1360 hr
= IWineD3DDevice_SetPaletteEntries(This
->WineD3DDevice
, PaletteNumber
, pEntries
);
1361 LeaveCriticalSection(&d3d8_cs
);
1365 static HRESULT WINAPI
IDirect3DDevice8Impl_GetPaletteEntries(LPDIRECT3DDEVICE8 iface
, UINT PaletteNumber
, PALETTEENTRY
* pEntries
) {
1366 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1368 TRACE("(%p) Relay\n" , This
);
1370 EnterCriticalSection(&d3d8_cs
);
1371 hr
= IWineD3DDevice_GetPaletteEntries(This
->WineD3DDevice
, PaletteNumber
, pEntries
);
1372 LeaveCriticalSection(&d3d8_cs
);
1376 static HRESULT WINAPI
IDirect3DDevice8Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface
, UINT PaletteNumber
) {
1377 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1379 TRACE("(%p) Relay\n" , This
);
1381 EnterCriticalSection(&d3d8_cs
);
1382 hr
= IWineD3DDevice_SetCurrentTexturePalette(This
->WineD3DDevice
, PaletteNumber
);
1383 LeaveCriticalSection(&d3d8_cs
);
1387 static HRESULT WINAPI
IDirect3DDevice8Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface
, UINT
*PaletteNumber
) {
1388 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1390 TRACE("(%p) Relay\n" , This
);
1392 EnterCriticalSection(&d3d8_cs
);
1393 hr
= IWineD3DDevice_GetCurrentTexturePalette(This
->WineD3DDevice
, PaletteNumber
);
1394 LeaveCriticalSection(&d3d8_cs
);
1398 static HRESULT WINAPI
IDirect3DDevice8Impl_DrawPrimitive(LPDIRECT3DDEVICE8 iface
, D3DPRIMITIVETYPE PrimitiveType
, UINT StartVertex
, UINT PrimitiveCount
) {
1399 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1401 TRACE("(%p) Relay\n" , This
);
1403 EnterCriticalSection(&d3d8_cs
);
1404 hr
= IWineD3DDevice_DrawPrimitive(This
->WineD3DDevice
, PrimitiveType
, StartVertex
, PrimitiveCount
);
1405 LeaveCriticalSection(&d3d8_cs
);
1409 static HRESULT WINAPI
IDirect3DDevice8Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE8 iface
, D3DPRIMITIVETYPE PrimitiveType
,
1410 UINT MinVertexIndex
,UINT NumVertices
,UINT startIndex
,UINT primCount
) {
1411 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1413 TRACE("(%p) Relay\n" , This
);
1415 EnterCriticalSection(&d3d8_cs
);
1416 hr
= IWineD3DDevice_DrawIndexedPrimitive(This
->WineD3DDevice
, PrimitiveType
, MinVertexIndex
, NumVertices
, startIndex
, primCount
);
1417 LeaveCriticalSection(&d3d8_cs
);
1421 static HRESULT WINAPI
IDirect3DDevice8Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE8 iface
, D3DPRIMITIVETYPE PrimitiveType
,UINT PrimitiveCount
,CONST
void* pVertexStreamZeroData
,UINT VertexStreamZeroStride
) {
1422 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1424 TRACE("(%p) Relay\n" , This
);
1426 EnterCriticalSection(&d3d8_cs
);
1427 hr
= IWineD3DDevice_DrawPrimitiveUP(This
->WineD3DDevice
, PrimitiveType
, PrimitiveCount
, pVertexStreamZeroData
, VertexStreamZeroStride
);
1428 LeaveCriticalSection(&d3d8_cs
);
1432 static HRESULT WINAPI
IDirect3DDevice8Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE8 iface
, D3DPRIMITIVETYPE PrimitiveType
,UINT MinVertexIndex
,
1433 UINT NumVertexIndices
,UINT PrimitiveCount
,CONST
void* pIndexData
,
1434 D3DFORMAT IndexDataFormat
,CONST
void* pVertexStreamZeroData
,
1435 UINT VertexStreamZeroStride
) {
1436 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1438 TRACE("(%p) Relay\n" , This
);
1440 EnterCriticalSection(&d3d8_cs
);
1441 hr
= IWineD3DDevice_DrawIndexedPrimitiveUP(This
->WineD3DDevice
, PrimitiveType
, MinVertexIndex
, NumVertexIndices
, PrimitiveCount
,
1442 pIndexData
, IndexDataFormat
, pVertexStreamZeroData
, VertexStreamZeroStride
);
1443 LeaveCriticalSection(&d3d8_cs
);
1447 static HRESULT WINAPI
IDirect3DDevice8Impl_ProcessVertices(LPDIRECT3DDEVICE8 iface
, UINT SrcStartIndex
,UINT DestIndex
,UINT VertexCount
,IDirect3DVertexBuffer8
* pDestBuffer
,DWORD Flags
) {
1448 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1450 TRACE("(%p) Relay\n" , This
);
1452 EnterCriticalSection(&d3d8_cs
);
1453 hr
= IWineD3DDevice_ProcessVertices(This
->WineD3DDevice
,SrcStartIndex
, DestIndex
, VertexCount
, ((IDirect3DVertexBuffer8Impl
*)pDestBuffer
)->wineD3DVertexBuffer
, NULL
, Flags
);
1454 LeaveCriticalSection(&d3d8_cs
);
1458 static HRESULT
IDirect3DDevice8Impl_CreateVertexDeclaration(IDirect3DDevice8
*iface
, CONST DWORD
*declaration
, IDirect3DVertexDeclaration8
**decl_ptr
) {
1459 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1460 IDirect3DVertexDeclaration8Impl
*object
;
1461 WINED3DVERTEXELEMENT
*wined3d_elements
;
1462 UINT wined3d_element_count
;
1463 HRESULT hr
= D3D_OK
;
1465 TRACE("(%p) : declaration %p\n", This
, declaration
);
1467 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
1469 ERR("Memory allocation failed\n");
1471 return D3DERR_OUTOFVIDEOMEMORY
;
1474 object
->ref_count
= 1;
1475 object
->lpVtbl
= &Direct3DVertexDeclaration8_Vtbl
;
1477 wined3d_element_count
= convert_to_wined3d_declaration(declaration
, &object
->elements_size
, &wined3d_elements
);
1478 object
->elements
= HeapAlloc(GetProcessHeap(), 0, object
->elements_size
);
1479 if (!object
->elements
) {
1480 ERR("Memory allocation failed\n");
1481 HeapFree(GetProcessHeap(), 0, wined3d_elements
);
1482 HeapFree(GetProcessHeap(), 0, object
);
1484 return D3DERR_OUTOFVIDEOMEMORY
;
1487 CopyMemory(object
->elements
, declaration
, object
->elements_size
);
1489 EnterCriticalSection(&d3d8_cs
);
1490 hr
= IWineD3DDevice_CreateVertexDeclaration(This
->WineD3DDevice
, &object
->wined3d_vertex_declaration
,
1491 (IUnknown
*)object
, wined3d_elements
, wined3d_element_count
);
1492 LeaveCriticalSection(&d3d8_cs
);
1493 HeapFree(GetProcessHeap(), 0, wined3d_elements
);
1496 ERR("(%p) : IWineD3DDevice_CreateVertexDeclaration call failed\n", This
);
1497 HeapFree(GetProcessHeap(), 0, object
->elements
);
1498 HeapFree(GetProcessHeap(), 0, object
);
1500 *decl_ptr
= (IDirect3DVertexDeclaration8
*)object
;
1501 TRACE("(%p) : Created vertex declaration %p\n", This
, object
);
1507 static HRESULT WINAPI
IDirect3DDevice8Impl_CreateVertexShader(LPDIRECT3DDEVICE8 iface
, CONST DWORD
* pDeclaration
, CONST DWORD
* pFunction
, DWORD
* ppShader
, DWORD Usage
) {
1508 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1509 HRESULT hrc
= D3D_OK
;
1510 IDirect3DVertexShader8Impl
*object
;
1511 IWineD3DVertexDeclaration
*wined3d_vertex_declaration
;
1512 const DWORD
*token
= pDeclaration
;
1513 shader_handle
*handle
;
1515 /* Test if the vertex declaration is valid */
1516 while (D3DVSD_END() != *token
) {
1517 D3DVSD_TOKENTYPE token_type
= ((*token
& D3DVSD_TOKENTYPEMASK
) >> D3DVSD_TOKENTYPESHIFT
);
1519 if (token_type
== D3DVSD_TOKEN_STREAMDATA
&& !(token_type
& 0x10000000)) {
1520 DWORD type
= ((*token
& D3DVSD_DATATYPEMASK
) >> D3DVSD_DATATYPESHIFT
);
1521 DWORD reg
= ((*token
& D3DVSD_VERTEXREGMASK
) >> D3DVSD_VERTEXREGSHIFT
);
1523 if(reg
== D3DVSDE_NORMAL
&& type
!= D3DVSDT_FLOAT3
&& !pFunction
) {
1524 WARN("Attempt to use a non-FLOAT3 normal with the fixed function function\n");
1525 return D3DERR_INVALIDCALL
;
1528 token
+= parse_token(token
);
1531 /* Setup a stub object for now */
1532 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
1533 TRACE("(%p) : pFunction(%p), ppShader(%p)\n", This
, pFunction
, ppShader
);
1534 if (NULL
== object
) {
1535 FIXME("Allocation of memory failed\n");
1537 return D3DERR_OUTOFVIDEOMEMORY
;
1541 object
->lpVtbl
= &Direct3DVertexShader8_Vtbl
;
1543 EnterCriticalSection(&d3d8_cs
);
1544 hrc
= IDirect3DDevice8Impl_CreateVertexDeclaration(iface
, pDeclaration
, &object
->vertex_declaration
);
1546 ERR("(%p) : IDirect3DDeviceImpl_CreateVertexDeclaration call failed\n", This
);
1547 LeaveCriticalSection(&d3d8_cs
);
1548 HeapFree(GetProcessHeap(), 0, object
);
1550 return D3DERR_INVALIDCALL
;
1553 handle
= alloc_shader_handle(This
);
1556 ERR("Failed to allocate shader handle\n");
1557 LeaveCriticalSection(&d3d8_cs
);
1558 IDirect3DVertexDeclaration8_Release(object
->vertex_declaration
);
1559 HeapFree(GetProcessHeap(), 0, object
);
1561 return E_OUTOFMEMORY
;
1565 DWORD shader_handle
= (handle
- This
->shader_handles
) + VS_HIGHESTFIXEDFXF
+ 1;
1567 *ppShader
= ((IDirect3DVertexDeclaration8Impl
*)object
->vertex_declaration
)->shader_handle
= shader_handle
;
1570 wined3d_vertex_declaration
= ((IDirect3DVertexDeclaration8Impl
*)object
->vertex_declaration
)->wined3d_vertex_declaration
;
1574 /* Usage is missing ... Use SetRenderState to set the sw vp render state in SetVertexShader */
1575 hrc
= IWineD3DDevice_CreateVertexShader(This
->WineD3DDevice
, wined3d_vertex_declaration
,
1576 pFunction
, &object
->wineD3DVertexShader
, (IUnknown
*)object
);
1580 /* free up object */
1581 FIXME("Call to IWineD3DDevice_CreateVertexShader failed\n");
1582 free_shader_handle(This
, handle
);
1583 IDirect3DVertexDeclaration8_Release(object
->vertex_declaration
);
1584 HeapFree(GetProcessHeap(), 0, object
);
1589 load_local_constants(pDeclaration
, object
->wineD3DVertexShader
);
1590 TRACE("(%p) : returning %p (handle %#x)\n", This
, object
, *ppShader
);
1594 LeaveCriticalSection(&d3d8_cs
);
1599 static IDirect3DVertexDeclaration8Impl
*IDirect3DDevice8Impl_FindDecl(IDirect3DDevice8Impl
*This
, DWORD fvf
)
1601 IDirect3DVertexDeclaration8Impl
*d3d8_declaration
;
1603 int p
, low
, high
; /* deliberately signed */
1604 struct FvfToDecl
*convertedDecls
= This
->decls
;
1606 TRACE("Searching for declaration for fvf %08x... ", fvf
);
1609 high
= This
->numConvertedDecls
- 1;
1610 while(low
<= high
) {
1611 p
= (low
+ high
) >> 1;
1613 if(convertedDecls
[p
].fvf
== fvf
) {
1614 TRACE("found %p\n", convertedDecls
[p
].decl
);
1615 return (IDirect3DVertexDeclaration8Impl
*)convertedDecls
[p
].decl
;
1616 } else if(convertedDecls
[p
].fvf
< fvf
) {
1622 TRACE("not found. Creating and inserting at position %d.\n", low
);
1624 d3d8_declaration
= HeapAlloc(GetProcessHeap(), 0, sizeof(*d3d8_declaration
));
1625 if (!d3d8_declaration
)
1627 ERR("Memory allocation failed.\n");
1631 d3d8_declaration
->ref_count
= 1;
1632 d3d8_declaration
->lpVtbl
= &Direct3DVertexDeclaration8_Vtbl
;
1633 d3d8_declaration
->elements
= NULL
;
1634 d3d8_declaration
->elements_size
= 0;
1635 d3d8_declaration
->shader_handle
= fvf
;
1637 hr
= IWineD3DDevice_CreateVertexDeclarationFromFVF(This
->WineD3DDevice
,
1638 &d3d8_declaration
->wined3d_vertex_declaration
, (IUnknown
*)d3d8_declaration
, fvf
);
1641 ERR("Failed to create wined3d vertex declaration.\n");
1642 HeapFree(GetProcessHeap(), 0, d3d8_declaration
);
1646 if(This
->declArraySize
== This
->numConvertedDecls
) {
1647 int grow
= This
->declArraySize
/ 2;
1648 convertedDecls
= HeapReAlloc(GetProcessHeap(), 0, convertedDecls
,
1649 sizeof(convertedDecls
[0]) * (This
->numConvertedDecls
+ grow
));
1650 if(!convertedDecls
) {
1651 /* This will destroy it */
1652 IDirect3DVertexDeclaration8_Release((IDirect3DVertexDeclaration8
*)d3d8_declaration
);
1655 This
->decls
= convertedDecls
;
1656 This
->declArraySize
+= grow
;
1659 memmove(convertedDecls
+ low
+ 1, convertedDecls
+ low
, sizeof(convertedDecls
[0]) * (This
->numConvertedDecls
- low
));
1660 convertedDecls
[low
].decl
= (IDirect3DVertexDeclaration8
*)d3d8_declaration
;
1661 convertedDecls
[low
].fvf
= fvf
;
1662 This
->numConvertedDecls
++;
1664 TRACE("Returning %p. %u decls in array\n", d3d8_declaration
, This
->numConvertedDecls
);
1665 return d3d8_declaration
;
1668 static HRESULT WINAPI
IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface
, DWORD pShader
) {
1669 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1670 HRESULT hrc
= D3D_OK
;
1672 TRACE("(%p) : Relay\n", This
);
1673 EnterCriticalSection(&d3d8_cs
);
1674 if (VS_HIGHESTFIXEDFXF
>= pShader
) {
1675 TRACE("Setting FVF, %#x\n", pShader
);
1676 IWineD3DDevice_SetVertexDeclaration(This
->WineD3DDevice
,
1677 IDirect3DDevice8Impl_FindDecl(This
, pShader
)->wined3d_vertex_declaration
);
1678 IWineD3DDevice_SetVertexShader(This
->WineD3DDevice
, NULL
);
1680 TRACE("Setting shader\n");
1681 if (This
->allocated_shader_handles
<= pShader
- (VS_HIGHESTFIXEDFXF
+ 1)) {
1682 FIXME("(%p) : Number of shaders exceeds the maximum number of possible shaders\n", This
);
1683 hrc
= D3DERR_INVALIDCALL
;
1685 IDirect3DVertexShader8Impl
*shader
= This
->shader_handles
[pShader
- (VS_HIGHESTFIXEDFXF
+ 1)];
1689 hrc
= IWineD3DDevice_SetVertexDeclaration(This
->WineD3DDevice
,
1690 ((IDirect3DVertexDeclaration8Impl
*)shader
->vertex_declaration
)->wined3d_vertex_declaration
);
1692 hrc
= IWineD3DDevice_SetVertexShader(This
->WineD3DDevice
, shader
->wineD3DVertexShader
);
1696 hrc
= IWineD3DDevice_SetVertexDeclaration(This
->WineD3DDevice
, NULL
);
1697 if (SUCCEEDED(hrc
)) hrc
= IWineD3DDevice_SetVertexShader(This
->WineD3DDevice
, NULL
);
1701 TRACE("(%p) : returning hr(%u)\n", This
, hrc
);
1702 LeaveCriticalSection(&d3d8_cs
);
1707 static HRESULT WINAPI
IDirect3DDevice8Impl_GetVertexShader(LPDIRECT3DDEVICE8 iface
, DWORD
* ppShader
) {
1708 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1709 IWineD3DVertexDeclaration
*wined3d_declaration
;
1712 TRACE("(%p) : Relay device@%p\n", This
, This
->WineD3DDevice
);
1713 EnterCriticalSection(&d3d8_cs
);
1715 hrc
= IWineD3DDevice_GetVertexDeclaration(This
->WineD3DDevice
, &wined3d_declaration
);
1718 if (wined3d_declaration
)
1720 IDirect3DVertexDeclaration8
*d3d8_declaration
;
1721 hrc
= IWineD3DVertexDeclaration_GetParent(wined3d_declaration
, (IUnknown
**)&d3d8_declaration
);
1722 IWineD3DVertexDeclaration_Release(wined3d_declaration
);
1725 *ppShader
= ((IDirect3DVertexDeclaration8Impl
*)d3d8_declaration
)->shader_handle
;
1726 IDirect3DVertexDeclaration8_Release(d3d8_declaration
);
1737 WARN("(%p) : Call to IWineD3DDevice_GetVertexDeclaration failed %#x (device %p)\n",
1738 This
, hrc
, This
->WineD3DDevice
);
1740 TRACE("(%p) : returning %#x\n", This
, *ppShader
);
1741 LeaveCriticalSection(&d3d8_cs
);
1746 static HRESULT WINAPI
IDirect3DDevice8Impl_DeleteVertexShader(LPDIRECT3DDEVICE8 iface
, DWORD pShader
) {
1747 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1749 TRACE("(%p) : pShader %#x\n", This
, pShader
);
1751 EnterCriticalSection(&d3d8_cs
);
1752 if (pShader
<= VS_HIGHESTFIXEDFXF
|| This
->allocated_shader_handles
<= pShader
- (VS_HIGHESTFIXEDFXF
+ 1)) {
1753 ERR("(%p) : Trying to delete an invalid handle\n", This
);
1754 LeaveCriticalSection(&d3d8_cs
);
1755 return D3DERR_INVALIDCALL
;
1757 IWineD3DVertexShader
*cur
= NULL
;
1758 shader_handle
*handle
= &This
->shader_handles
[pShader
- (VS_HIGHESTFIXEDFXF
+ 1)];
1759 IDirect3DVertexShader8Impl
*shader
= *handle
;
1761 IWineD3DDevice_GetVertexShader(This
->WineD3DDevice
, &cur
);
1763 if(cur
== shader
->wineD3DVertexShader
) IDirect3DDevice8_SetVertexShader(iface
, 0);
1764 IWineD3DVertexShader_Release(cur
);
1767 while(IUnknown_Release((IUnknown
*)shader
));
1768 free_shader_handle(This
, handle
);
1770 LeaveCriticalSection(&d3d8_cs
);
1775 static HRESULT WINAPI
IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface
, DWORD Register
, CONST
void* pConstantData
, DWORD ConstantCount
) {
1776 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1778 TRACE("(%p) : Relay\n", This
);
1780 EnterCriticalSection(&d3d8_cs
);
1781 hr
= IWineD3DDevice_SetVertexShaderConstantF(This
->WineD3DDevice
, Register
, (CONST
float *)pConstantData
, ConstantCount
);
1782 LeaveCriticalSection(&d3d8_cs
);
1786 static HRESULT WINAPI
IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8 iface
, DWORD Register
, void* pConstantData
, DWORD ConstantCount
) {
1787 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1789 TRACE("(%p) : Relay\n", This
);
1791 EnterCriticalSection(&d3d8_cs
);
1792 hr
= IWineD3DDevice_GetVertexShaderConstantF(This
->WineD3DDevice
, Register
, (float *)pConstantData
, ConstantCount
);
1793 LeaveCriticalSection(&d3d8_cs
);
1797 static HRESULT WINAPI
IDirect3DDevice8Impl_GetVertexShaderDeclaration(LPDIRECT3DDEVICE8 iface
, DWORD pVertexShader
, void* pData
, DWORD
* pSizeOfData
) {
1798 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1799 IDirect3DVertexDeclaration8Impl
*declaration
;
1800 IDirect3DVertexShader8Impl
*shader
= NULL
;
1802 TRACE("(%p) : pVertexShader 0x%08x, pData %p, *pSizeOfData %u\n", This
, pVertexShader
, pData
, *pSizeOfData
);
1804 EnterCriticalSection(&d3d8_cs
);
1805 if (pVertexShader
<= VS_HIGHESTFIXEDFXF
|| This
->allocated_shader_handles
<= pVertexShader
- (VS_HIGHESTFIXEDFXF
+ 1)) {
1806 ERR("Passed an invalid shader handle.\n");
1807 LeaveCriticalSection(&d3d8_cs
);
1808 return D3DERR_INVALIDCALL
;
1811 shader
= This
->shader_handles
[pVertexShader
- (VS_HIGHESTFIXEDFXF
+ 1)];
1812 declaration
= (IDirect3DVertexDeclaration8Impl
*)shader
->vertex_declaration
;
1814 /* If pData is NULL, we just return the required size of the buffer. */
1816 *pSizeOfData
= declaration
->elements_size
;
1817 LeaveCriticalSection(&d3d8_cs
);
1821 /* MSDN claims that if *pSizeOfData is smaller than the required size
1822 * we should write the required size and return D3DERR_MOREDATA.
1823 * That's not actually true. */
1824 if (*pSizeOfData
< declaration
->elements_size
) {
1825 LeaveCriticalSection(&d3d8_cs
);
1826 return D3DERR_INVALIDCALL
;
1829 CopyMemory(pData
, declaration
->elements
, declaration
->elements_size
);
1830 LeaveCriticalSection(&d3d8_cs
);
1835 static HRESULT WINAPI
IDirect3DDevice8Impl_GetVertexShaderFunction(LPDIRECT3DDEVICE8 iface
, DWORD pVertexShader
, void* pData
, DWORD
* pSizeOfData
) {
1836 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1837 IDirect3DVertexShader8Impl
*shader
= NULL
;
1840 TRACE("(%p) : pVertexShader %#x, pData %p, pSizeOfData %p\n", This
, pVertexShader
, pData
, pSizeOfData
);
1842 EnterCriticalSection(&d3d8_cs
);
1843 if (pVertexShader
<= VS_HIGHESTFIXEDFXF
|| This
->allocated_shader_handles
<= pVertexShader
- (VS_HIGHESTFIXEDFXF
+ 1)) {
1844 ERR("Passed an invalid shader handle.\n");
1845 LeaveCriticalSection(&d3d8_cs
);
1846 return D3DERR_INVALIDCALL
;
1849 shader
= This
->shader_handles
[pVertexShader
- (VS_HIGHESTFIXEDFXF
+ 1)];
1850 if (shader
->wineD3DVertexShader
)
1852 hr
= IWineD3DVertexShader_GetFunction(shader
->wineD3DVertexShader
, pData
, pSizeOfData
);
1860 LeaveCriticalSection(&d3d8_cs
);
1864 static HRESULT WINAPI
IDirect3DDevice8Impl_SetIndices(LPDIRECT3DDEVICE8 iface
, IDirect3DIndexBuffer8
* pIndexData
, UINT baseVertexIndex
) {
1865 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1867 TRACE("(%p) Relay\n", This
);
1869 EnterCriticalSection(&d3d8_cs
);
1870 /* WineD3D takes an INT(due to d3d9), but d3d8 uses UINTs. Do I have to add a check here that
1871 * the UINT doesn't cause an overflow in the INT? It seems rather unlikely because such large
1872 * vertex buffers can't be created to address them with an index that requires the 32nd bit
1873 * (4 Byte minimum vertex size * 2^31-1 -> 8 gb buffer. The index sign would be the least
1876 IWineD3DDevice_SetBaseVertexIndex(This
->WineD3DDevice
, baseVertexIndex
);
1877 hr
= IWineD3DDevice_SetIndices(This
->WineD3DDevice
,
1878 pIndexData
? ((IDirect3DIndexBuffer8Impl
*)pIndexData
)->wineD3DIndexBuffer
: NULL
);
1879 LeaveCriticalSection(&d3d8_cs
);
1883 static HRESULT WINAPI
IDirect3DDevice8Impl_GetIndices(LPDIRECT3DDEVICE8 iface
, IDirect3DIndexBuffer8
** ppIndexData
,UINT
* pBaseVertexIndex
) {
1884 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1885 IWineD3DIndexBuffer
*retIndexData
= NULL
;
1886 HRESULT rc
= D3D_OK
;
1888 TRACE("(%p) Relay\n", This
);
1890 if(ppIndexData
== NULL
){
1891 return D3DERR_INVALIDCALL
;
1894 EnterCriticalSection(&d3d8_cs
);
1895 /* The case from UINT to INT is safe because d3d8 will never set negative values */
1896 IWineD3DDevice_GetBaseVertexIndex(This
->WineD3DDevice
, (INT
*) pBaseVertexIndex
);
1897 rc
= IWineD3DDevice_GetIndices(This
->WineD3DDevice
, &retIndexData
);
1898 if (SUCCEEDED(rc
) && retIndexData
) {
1899 IWineD3DIndexBuffer_GetParent(retIndexData
, (IUnknown
**)ppIndexData
);
1900 IWineD3DIndexBuffer_Release(retIndexData
);
1902 if (FAILED(rc
)) FIXME("Call to GetIndices failed\n");
1903 *ppIndexData
= NULL
;
1905 LeaveCriticalSection(&d3d8_cs
);
1909 static HRESULT WINAPI
IDirect3DDevice8Impl_CreatePixelShader(LPDIRECT3DDEVICE8 iface
, CONST DWORD
* pFunction
, DWORD
* ppShader
) {
1910 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1911 IDirect3DPixelShader8Impl
*object
;
1912 HRESULT hrc
= D3D_OK
;
1914 TRACE("(%p) : pFunction(%p), ppShader(%p)\n", This
, pFunction
, ppShader
);
1916 if (NULL
== ppShader
) {
1917 TRACE("(%p) Invalid call\n", This
);
1918 return D3DERR_INVALIDCALL
;
1920 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
1922 if (NULL
== object
) {
1923 return E_OUTOFMEMORY
;
1925 EnterCriticalSection(&d3d8_cs
);
1928 object
->lpVtbl
= &Direct3DPixelShader8_Vtbl
;
1929 hrc
= IWineD3DDevice_CreatePixelShader(This
->WineD3DDevice
, pFunction
, &object
->wineD3DPixelShader
, (IUnknown
*)object
);
1930 if (D3D_OK
!= hrc
) {
1931 FIXME("(%p) call to IWineD3DDevice_CreatePixelShader failed\n", This
);
1932 HeapFree(GetProcessHeap(), 0 , object
);
1935 shader_handle
*handle
= alloc_shader_handle(This
);
1937 ERR("Failed to allocate shader handle\n");
1938 IDirect3DVertexShader8_Release((IUnknown
*)object
);
1939 hrc
= E_OUTOFMEMORY
;
1942 object
->handle
= (handle
- This
->shader_handles
) + VS_HIGHESTFIXEDFXF
+ 1;
1943 *ppShader
= object
->handle
;
1944 TRACE("(%p) : returning %p (handle %#x)\n", This
, object
, *ppShader
);
1947 LeaveCriticalSection(&d3d8_cs
);
1953 static HRESULT WINAPI
IDirect3DDevice8Impl_SetPixelShader(LPDIRECT3DDEVICE8 iface
, DWORD pShader
) {
1954 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1955 IDirect3DPixelShader8Impl
*shader
= NULL
;
1958 TRACE("(%p) : pShader %#x\n", This
, pShader
);
1960 EnterCriticalSection(&d3d8_cs
);
1961 if (pShader
> VS_HIGHESTFIXEDFXF
&& This
->allocated_shader_handles
> pShader
- (VS_HIGHESTFIXEDFXF
+ 1)) {
1962 shader
= This
->shader_handles
[pShader
- (VS_HIGHESTFIXEDFXF
+ 1)];
1963 } else if (pShader
) {
1964 ERR("Trying to set an invalid handle.\n");
1967 TRACE("(%p) : Setting shader %p\n", This
, shader
);
1968 hr
= IWineD3DDevice_SetPixelShader(This
->WineD3DDevice
, shader
== NULL
? NULL
:shader
->wineD3DPixelShader
);
1969 LeaveCriticalSection(&d3d8_cs
);
1973 static HRESULT WINAPI
IDirect3DDevice8Impl_GetPixelShader(LPDIRECT3DDEVICE8 iface
, DWORD
* ppShader
) {
1974 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
1975 IWineD3DPixelShader
*object
;
1977 HRESULT hrc
= D3D_OK
;
1978 TRACE("(%p) Relay\n", This
);
1979 if (NULL
== ppShader
) {
1980 TRACE("(%p) Invalid call\n", This
);
1981 return D3DERR_INVALIDCALL
;
1984 EnterCriticalSection(&d3d8_cs
);
1985 hrc
= IWineD3DDevice_GetPixelShader(This
->WineD3DDevice
, &object
);
1986 if (D3D_OK
== hrc
&& NULL
!= object
) {
1987 IDirect3DPixelShader8Impl
*d3d8_shader
;
1988 hrc
= IWineD3DPixelShader_GetParent(object
, (IUnknown
**)&d3d8_shader
);
1989 IWineD3DPixelShader_Release(object
);
1990 *ppShader
= d3d8_shader
->handle
;
1995 TRACE("(%p) : returning %#x\n", This
, *ppShader
);
1996 LeaveCriticalSection(&d3d8_cs
);
2000 static HRESULT WINAPI
IDirect3DDevice8Impl_DeletePixelShader(LPDIRECT3DDEVICE8 iface
, DWORD pShader
) {
2001 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2003 TRACE("(%p) : pShader %#x\n", This
, pShader
);
2005 EnterCriticalSection(&d3d8_cs
);
2006 if (pShader
<= VS_HIGHESTFIXEDFXF
|| This
->allocated_shader_handles
<= pShader
- (VS_HIGHESTFIXEDFXF
+ 1)) {
2007 ERR("(%p) : Trying to delete an invalid handle\n", This
);
2008 LeaveCriticalSection(&d3d8_cs
);
2009 return D3DERR_INVALIDCALL
;
2011 IWineD3DPixelShader
*cur
= NULL
;
2012 shader_handle
*handle
= &This
->shader_handles
[pShader
- (VS_HIGHESTFIXEDFXF
+ 1)];
2013 IDirect3DPixelShader8Impl
*shader
= *handle
;
2015 IWineD3DDevice_GetPixelShader(This
->WineD3DDevice
, &cur
);
2017 if(cur
== shader
->wineD3DPixelShader
) IDirect3DDevice8_SetPixelShader(iface
, 0);
2018 IWineD3DPixelShader_Release(cur
);
2021 while(IUnknown_Release((IUnknown
*)shader
));
2022 free_shader_handle(This
, handle
);
2024 LeaveCriticalSection(&d3d8_cs
);
2029 static HRESULT WINAPI
IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface
, DWORD Register
, CONST
void* pConstantData
, DWORD ConstantCount
) {
2030 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2032 TRACE("(%p) Relay\n", This
);
2034 EnterCriticalSection(&d3d8_cs
);
2035 hr
= IWineD3DDevice_SetPixelShaderConstantF(This
->WineD3DDevice
, Register
, (CONST
float *)pConstantData
, ConstantCount
);
2036 LeaveCriticalSection(&d3d8_cs
);
2040 static HRESULT WINAPI
IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface
, DWORD Register
, void* pConstantData
, DWORD ConstantCount
) {
2041 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2043 TRACE("(%p) Relay\n", This
);
2045 EnterCriticalSection(&d3d8_cs
);
2046 hr
= IWineD3DDevice_GetPixelShaderConstantF(This
->WineD3DDevice
, Register
, (float *)pConstantData
, ConstantCount
);
2047 LeaveCriticalSection(&d3d8_cs
);
2051 static HRESULT WINAPI
IDirect3DDevice8Impl_GetPixelShaderFunction(LPDIRECT3DDEVICE8 iface
, DWORD pPixelShader
, void* pData
, DWORD
* pSizeOfData
) {
2052 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2053 IDirect3DPixelShader8Impl
*shader
= NULL
;
2056 TRACE("(%p) : pPixelShader %#x, pData %p, pSizeOfData %p\n", This
, pPixelShader
, pData
, pSizeOfData
);
2058 EnterCriticalSection(&d3d8_cs
);
2059 if (pPixelShader
<= VS_HIGHESTFIXEDFXF
|| This
->allocated_shader_handles
<= pPixelShader
- (VS_HIGHESTFIXEDFXF
+ 1)) {
2060 ERR("Passed an invalid shader handle.\n");
2061 LeaveCriticalSection(&d3d8_cs
);
2062 return D3DERR_INVALIDCALL
;
2065 shader
= This
->shader_handles
[pPixelShader
- (VS_HIGHESTFIXEDFXF
+ 1)];
2066 hr
= IWineD3DPixelShader_GetFunction(shader
->wineD3DPixelShader
, pData
, pSizeOfData
);
2067 LeaveCriticalSection(&d3d8_cs
);
2071 static HRESULT WINAPI
IDirect3DDevice8Impl_DrawRectPatch(LPDIRECT3DDEVICE8 iface
, UINT Handle
,CONST
float* pNumSegs
,CONST D3DRECTPATCH_INFO
* pRectPatchInfo
) {
2072 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2074 TRACE("(%p) Relay\n", This
);
2076 EnterCriticalSection(&d3d8_cs
);
2077 hr
= IWineD3DDevice_DrawRectPatch(This
->WineD3DDevice
, Handle
, pNumSegs
, (CONST WINED3DRECTPATCH_INFO
*)pRectPatchInfo
);
2078 LeaveCriticalSection(&d3d8_cs
);
2082 static HRESULT WINAPI
IDirect3DDevice8Impl_DrawTriPatch(LPDIRECT3DDEVICE8 iface
, UINT Handle
,CONST
float* pNumSegs
,CONST D3DTRIPATCH_INFO
* pTriPatchInfo
) {
2083 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2085 TRACE("(%p) Relay\n", This
);
2087 EnterCriticalSection(&d3d8_cs
);
2088 hr
= IWineD3DDevice_DrawTriPatch(This
->WineD3DDevice
, Handle
, pNumSegs
, (CONST WINED3DTRIPATCH_INFO
*)pTriPatchInfo
);
2089 LeaveCriticalSection(&d3d8_cs
);
2093 static HRESULT WINAPI
IDirect3DDevice8Impl_DeletePatch(LPDIRECT3DDEVICE8 iface
, UINT Handle
) {
2094 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2096 TRACE("(%p) Relay\n", This
);
2098 EnterCriticalSection(&d3d8_cs
);
2099 hr
= IWineD3DDevice_DeletePatch(This
->WineD3DDevice
, Handle
);
2100 LeaveCriticalSection(&d3d8_cs
);
2104 static HRESULT WINAPI
IDirect3DDevice8Impl_SetStreamSource(LPDIRECT3DDEVICE8 iface
, UINT StreamNumber
,IDirect3DVertexBuffer8
* pStreamData
,UINT Stride
) {
2105 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2107 TRACE("(%p) Relay\n" , This
);
2109 EnterCriticalSection(&d3d8_cs
);
2110 hr
= IWineD3DDevice_SetStreamSource(This
->WineD3DDevice
, StreamNumber
,
2111 NULL
== pStreamData
? NULL
: ((IDirect3DVertexBuffer8Impl
*)pStreamData
)->wineD3DVertexBuffer
,
2112 0/* Offset in bytes */, Stride
);
2113 LeaveCriticalSection(&d3d8_cs
);
2117 static HRESULT WINAPI
IDirect3DDevice8Impl_GetStreamSource(LPDIRECT3DDEVICE8 iface
, UINT StreamNumber
,IDirect3DVertexBuffer8
** pStream
,UINT
* pStride
) {
2118 IDirect3DDevice8Impl
*This
= (IDirect3DDevice8Impl
*)iface
;
2119 IWineD3DVertexBuffer
*retStream
= NULL
;
2120 HRESULT rc
= D3D_OK
;
2122 TRACE("(%p) Relay\n" , This
);
2124 if(pStream
== NULL
){
2125 return D3DERR_INVALIDCALL
;
2128 EnterCriticalSection(&d3d8_cs
);
2129 rc
= IWineD3DDevice_GetStreamSource(This
->WineD3DDevice
, StreamNumber
, &retStream
, 0 /* Offset in bytes */, pStride
);
2130 if (rc
== D3D_OK
&& NULL
!= retStream
) {
2131 IWineD3DVertexBuffer_GetParent(retStream
, (IUnknown
**)pStream
);
2132 IWineD3DVertexBuffer_Release(retStream
);
2135 FIXME("Call to GetStreamSource failed %p\n", pStride
);
2139 LeaveCriticalSection(&d3d8_cs
);
2145 const IDirect3DDevice8Vtbl Direct3DDevice8_Vtbl
=
2147 IDirect3DDevice8Impl_QueryInterface
,
2148 IDirect3DDevice8Impl_AddRef
,
2149 IDirect3DDevice8Impl_Release
,
2150 IDirect3DDevice8Impl_TestCooperativeLevel
,
2151 IDirect3DDevice8Impl_GetAvailableTextureMem
,
2152 IDirect3DDevice8Impl_ResourceManagerDiscardBytes
,
2153 IDirect3DDevice8Impl_GetDirect3D
,
2154 IDirect3DDevice8Impl_GetDeviceCaps
,
2155 IDirect3DDevice8Impl_GetDisplayMode
,
2156 IDirect3DDevice8Impl_GetCreationParameters
,
2157 IDirect3DDevice8Impl_SetCursorProperties
,
2158 IDirect3DDevice8Impl_SetCursorPosition
,
2159 IDirect3DDevice8Impl_ShowCursor
,
2160 IDirect3DDevice8Impl_CreateAdditionalSwapChain
,
2161 IDirect3DDevice8Impl_Reset
,
2162 IDirect3DDevice8Impl_Present
,
2163 IDirect3DDevice8Impl_GetBackBuffer
,
2164 IDirect3DDevice8Impl_GetRasterStatus
,
2165 IDirect3DDevice8Impl_SetGammaRamp
,
2166 IDirect3DDevice8Impl_GetGammaRamp
,
2167 IDirect3DDevice8Impl_CreateTexture
,
2168 IDirect3DDevice8Impl_CreateVolumeTexture
,
2169 IDirect3DDevice8Impl_CreateCubeTexture
,
2170 IDirect3DDevice8Impl_CreateVertexBuffer
,
2171 IDirect3DDevice8Impl_CreateIndexBuffer
,
2172 IDirect3DDevice8Impl_CreateRenderTarget
,
2173 IDirect3DDevice8Impl_CreateDepthStencilSurface
,
2174 IDirect3DDevice8Impl_CreateImageSurface
,
2175 IDirect3DDevice8Impl_CopyRects
,
2176 IDirect3DDevice8Impl_UpdateTexture
,
2177 IDirect3DDevice8Impl_GetFrontBuffer
,
2178 IDirect3DDevice8Impl_SetRenderTarget
,
2179 IDirect3DDevice8Impl_GetRenderTarget
,
2180 IDirect3DDevice8Impl_GetDepthStencilSurface
,
2181 IDirect3DDevice8Impl_BeginScene
,
2182 IDirect3DDevice8Impl_EndScene
,
2183 IDirect3DDevice8Impl_Clear
,
2184 IDirect3DDevice8Impl_SetTransform
,
2185 IDirect3DDevice8Impl_GetTransform
,
2186 IDirect3DDevice8Impl_MultiplyTransform
,
2187 IDirect3DDevice8Impl_SetViewport
,
2188 IDirect3DDevice8Impl_GetViewport
,
2189 IDirect3DDevice8Impl_SetMaterial
,
2190 IDirect3DDevice8Impl_GetMaterial
,
2191 IDirect3DDevice8Impl_SetLight
,
2192 IDirect3DDevice8Impl_GetLight
,
2193 IDirect3DDevice8Impl_LightEnable
,
2194 IDirect3DDevice8Impl_GetLightEnable
,
2195 IDirect3DDevice8Impl_SetClipPlane
,
2196 IDirect3DDevice8Impl_GetClipPlane
,
2197 IDirect3DDevice8Impl_SetRenderState
,
2198 IDirect3DDevice8Impl_GetRenderState
,
2199 IDirect3DDevice8Impl_BeginStateBlock
,
2200 IDirect3DDevice8Impl_EndStateBlock
,
2201 IDirect3DDevice8Impl_ApplyStateBlock
,
2202 IDirect3DDevice8Impl_CaptureStateBlock
,
2203 IDirect3DDevice8Impl_DeleteStateBlock
,
2204 IDirect3DDevice8Impl_CreateStateBlock
,
2205 IDirect3DDevice8Impl_SetClipStatus
,
2206 IDirect3DDevice8Impl_GetClipStatus
,
2207 IDirect3DDevice8Impl_GetTexture
,
2208 IDirect3DDevice8Impl_SetTexture
,
2209 IDirect3DDevice8Impl_GetTextureStageState
,
2210 IDirect3DDevice8Impl_SetTextureStageState
,
2211 IDirect3DDevice8Impl_ValidateDevice
,
2212 IDirect3DDevice8Impl_GetInfo
,
2213 IDirect3DDevice8Impl_SetPaletteEntries
,
2214 IDirect3DDevice8Impl_GetPaletteEntries
,
2215 IDirect3DDevice8Impl_SetCurrentTexturePalette
,
2216 IDirect3DDevice8Impl_GetCurrentTexturePalette
,
2217 IDirect3DDevice8Impl_DrawPrimitive
,
2218 IDirect3DDevice8Impl_DrawIndexedPrimitive
,
2219 IDirect3DDevice8Impl_DrawPrimitiveUP
,
2220 IDirect3DDevice8Impl_DrawIndexedPrimitiveUP
,
2221 IDirect3DDevice8Impl_ProcessVertices
,
2222 IDirect3DDevice8Impl_CreateVertexShader
,
2223 IDirect3DDevice8Impl_SetVertexShader
,
2224 IDirect3DDevice8Impl_GetVertexShader
,
2225 IDirect3DDevice8Impl_DeleteVertexShader
,
2226 IDirect3DDevice8Impl_SetVertexShaderConstant
,
2227 IDirect3DDevice8Impl_GetVertexShaderConstant
,
2228 IDirect3DDevice8Impl_GetVertexShaderDeclaration
,
2229 IDirect3DDevice8Impl_GetVertexShaderFunction
,
2230 IDirect3DDevice8Impl_SetStreamSource
,
2231 IDirect3DDevice8Impl_GetStreamSource
,
2232 IDirect3DDevice8Impl_SetIndices
,
2233 IDirect3DDevice8Impl_GetIndices
,
2234 IDirect3DDevice8Impl_CreatePixelShader
,
2235 IDirect3DDevice8Impl_SetPixelShader
,
2236 IDirect3DDevice8Impl_GetPixelShader
,
2237 IDirect3DDevice8Impl_DeletePixelShader
,
2238 IDirect3DDevice8Impl_SetPixelShaderConstant
,
2239 IDirect3DDevice8Impl_GetPixelShaderConstant
,
2240 IDirect3DDevice8Impl_GetPixelShaderFunction
,
2241 IDirect3DDevice8Impl_DrawRectPatch
,
2242 IDirect3DDevice8Impl_DrawTriPatch
,
2243 IDirect3DDevice8Impl_DeletePatch
2246 /* Internal function called back during the CreateDevice to create a render target */
2247 static HRESULT WINAPI
D3D8CB_CreateSurface(IUnknown
*device
, IUnknown
*pSuperior
, UINT Width
, UINT Height
,
2248 WINED3DFORMAT Format
, DWORD Usage
, WINED3DPOOL Pool
, UINT Level
,
2249 WINED3DCUBEMAP_FACES Face
, IWineD3DSurface
**ppSurface
,
2250 HANDLE
*pSharedHandle
) {
2252 HRESULT res
= D3D_OK
;
2253 IDirect3DSurface8Impl
*d3dSurface
= NULL
;
2254 BOOL Lockable
= TRUE
;
2256 if((WINED3DPOOL_DEFAULT
== Pool
&& WINED3DUSAGE_DYNAMIC
!= Usage
))
2260 res
= IDirect3DDevice8Impl_CreateSurface((IDirect3DDevice8
*)device
, Width
, Height
, (D3DFORMAT
)Format
, Lockable
, FALSE
/*Discard*/, Level
, (IDirect3DSurface8
**)&d3dSurface
, D3DRTYPE_SURFACE
, Usage
, Pool
, D3DMULTISAMPLE_NONE
, 0 /* MultisampleQuality */);
2262 if (SUCCEEDED(res
)) {
2263 *ppSurface
= d3dSurface
->wineD3DSurface
;
2264 d3dSurface
->container
= pSuperior
;
2265 IUnknown_Release(d3dSurface
->parentDevice
);
2266 d3dSurface
->parentDevice
= NULL
;
2267 d3dSurface
->forwardReference
= pSuperior
;
2269 FIXME("(%p) IDirect3DDevice8_CreateSurface failed\n", device
);
2274 ULONG WINAPI
D3D8CB_DestroySurface(IWineD3DSurface
*pSurface
) {
2275 IDirect3DSurface8Impl
* surfaceParent
;
2276 TRACE("(%p) call back\n", pSurface
);
2278 IWineD3DSurface_GetParent(pSurface
, (IUnknown
**) &surfaceParent
);
2279 /* GetParent's AddRef was forwarded to an object in destruction.
2280 * Releasing it here again would cause an endless recursion. */
2281 surfaceParent
->forwardReference
= NULL
;
2282 return IDirect3DSurface8_Release((IDirect3DSurface8
*) surfaceParent
);