device.c File Reference

#include "config.h"
#include "wine/port.h"
#include "ddraw_private.h"

Include dependency graph for device.c:

Go to the source code of this file.

Classes
struct	tss_lookup

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ddraw)
	WINE_DECLARE_DEBUG_CHANNEL (winediag)
static void	set_fpu_control_word (WORD fpucw)
static WORD	d3d_fpu_setup (void)
static struct d3d_device *	impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	d3d_device_inner_QueryInterface (IUnknown *iface, REFIID riid, void **out)
static HRESULT WINAPI	d3d_device7_QueryInterface (IDirect3DDevice7 *iface, REFIID riid, void **out)
static HRESULT WINAPI	d3d_device3_QueryInterface (IDirect3DDevice3 *iface, REFIID riid, void **out)
static HRESULT WINAPI	d3d_device2_QueryInterface (IDirect3DDevice2 *iface, REFIID riid, void **out)
static HRESULT WINAPI	d3d_device1_QueryInterface (IDirect3DDevice *iface, REFIID riid, void **out)
static ULONG WINAPI	d3d_device_inner_AddRef (IUnknown *iface)
static ULONG WINAPI	d3d_device7_AddRef (IDirect3DDevice7 *iface)
static ULONG WINAPI	d3d_device3_AddRef (IDirect3DDevice3 *iface)
static ULONG WINAPI	d3d_device2_AddRef (IDirect3DDevice2 *iface)
static ULONG WINAPI	d3d_device1_AddRef (IDirect3DDevice *iface)
static ULONG WINAPI	d3d_device_inner_Release (IUnknown *iface)
static ULONG WINAPI	d3d_device7_Release (IDirect3DDevice7 *iface)
static ULONG WINAPI	d3d_device3_Release (IDirect3DDevice3 *iface)
static ULONG WINAPI	d3d_device2_Release (IDirect3DDevice2 *iface)
static ULONG WINAPI	d3d_device1_Release (IDirect3DDevice *iface)
static HRESULT WINAPI	d3d_device1_Initialize (IDirect3DDevice *iface, IDirect3D *d3d, GUID *guid, D3DDEVICEDESC *device_desc)
static HRESULT	d3d_device7_GetCaps (IDirect3DDevice7 *iface, D3DDEVICEDESC7 *device_desc)
static HRESULT WINAPI	d3d_device7_GetCaps_FPUSetup (IDirect3DDevice7 *iface, D3DDEVICEDESC7 *desc)
static HRESULT WINAPI	d3d_device7_GetCaps_FPUPreserve (IDirect3DDevice7 *iface, D3DDEVICEDESC7 *desc)
static BOOL	check_d3ddevicedesc_size (DWORD size)
static HRESULT WINAPI	d3d_device3_GetCaps (IDirect3DDevice3 *iface, D3DDEVICEDESC *HWDesc, D3DDEVICEDESC *HelDesc)
static HRESULT WINAPI	d3d_device2_GetCaps (IDirect3DDevice2 *iface, D3DDEVICEDESC *hw_desc, D3DDEVICEDESC *hel_desc)
static HRESULT WINAPI	d3d_device1_GetCaps (IDirect3DDevice *iface, D3DDEVICEDESC *hw_desc, D3DDEVICEDESC *hel_desc)
static HRESULT WINAPI	d3d_device2_SwapTextureHandles (IDirect3DDevice2 *iface, IDirect3DTexture2 *tex1, IDirect3DTexture2 *tex2)
static HRESULT WINAPI	d3d_device1_SwapTextureHandles (IDirect3DDevice *iface, IDirect3DTexture *tex1, IDirect3DTexture *tex2)
static HRESULT WINAPI	d3d_device3_GetStats (IDirect3DDevice3 *iface, D3DSTATS *Stats)
static HRESULT WINAPI	d3d_device2_GetStats (IDirect3DDevice2 *iface, D3DSTATS *stats)
static HRESULT WINAPI	d3d_device1_GetStats (IDirect3DDevice *iface, D3DSTATS *stats)
static HRESULT WINAPI	d3d_device1_CreateExecuteBuffer (IDirect3DDevice *iface, D3DEXECUTEBUFFERDESC *buffer_desc, IDirect3DExecuteBuffer **ExecuteBuffer, IUnknown *outer_unknown)
static HRESULT WINAPI	d3d_device1_Execute (IDirect3DDevice *iface, IDirect3DExecuteBuffer *ExecuteBuffer, IDirect3DViewport *viewport, DWORD flags)
static HRESULT WINAPI	d3d_device3_AddViewport (IDirect3DDevice3 *iface, IDirect3DViewport3 *viewport)
static HRESULT WINAPI	d3d_device2_AddViewport (IDirect3DDevice2 *iface, IDirect3DViewport2 *viewport)
static HRESULT WINAPI	d3d_device1_AddViewport (IDirect3DDevice *iface, IDirect3DViewport *viewport)
static HRESULT WINAPI	d3d_device3_DeleteViewport (IDirect3DDevice3 *iface, IDirect3DViewport3 *viewport)
static HRESULT WINAPI	d3d_device2_DeleteViewport (IDirect3DDevice2 *iface, IDirect3DViewport2 *viewport)
static HRESULT WINAPI	d3d_device1_DeleteViewport (IDirect3DDevice *iface, IDirect3DViewport *viewport)
static HRESULT WINAPI	d3d_device3_NextViewport (IDirect3DDevice3 *iface, IDirect3DViewport3 *Viewport3, IDirect3DViewport3 **lplpDirect3DViewport3, DWORD flags)
static HRESULT WINAPI	d3d_device2_NextViewport (IDirect3DDevice2 *iface, IDirect3DViewport2 *viewport, IDirect3DViewport2 **next, DWORD flags)
static HRESULT WINAPI	d3d_device1_NextViewport (IDirect3DDevice *iface, IDirect3DViewport *viewport, IDirect3DViewport **next, DWORD flags)
static HRESULT WINAPI	d3d_device1_Pick (IDirect3DDevice *iface, IDirect3DExecuteBuffer *buffer, IDirect3DViewport *viewport, DWORD flags, D3DRECT *rect)
static HRESULT WINAPI	d3d_device1_GetPickRecords (IDirect3DDevice *iface, DWORD *count, D3DPICKRECORD *records)
static HRESULT	d3d_device7_EnumTextureFormats (IDirect3DDevice7 *iface, LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
static HRESULT WINAPI	d3d_device7_EnumTextureFormats_FPUSetup (IDirect3DDevice7 *iface, LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
static HRESULT WINAPI	d3d_device7_EnumTextureFormats_FPUPreserve (IDirect3DDevice7 *iface, LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
static HRESULT WINAPI	d3d_device3_EnumTextureFormats (IDirect3DDevice3 *iface, LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
static HRESULT WINAPI	d3d_device2_EnumTextureFormats (IDirect3DDevice2 *iface, LPD3DENUMTEXTUREFORMATSCALLBACK callback, void *context)
static HRESULT WINAPI	d3d_device1_EnumTextureFormats (IDirect3DDevice *iface, LPD3DENUMTEXTUREFORMATSCALLBACK callback, void *context)
static HRESULT WINAPI	d3d_device1_CreateMatrix (IDirect3DDevice *iface, D3DMATRIXHANDLE *D3DMatHandle)
static HRESULT WINAPI	d3d_device1_SetMatrix (IDirect3DDevice *iface, D3DMATRIXHANDLE D3DMatHandle, D3DMATRIX *D3DMatrix)
static HRESULT WINAPI	d3d_device1_GetMatrix (IDirect3DDevice *iface, D3DMATRIXHANDLE D3DMatHandle, D3DMATRIX *D3DMatrix)
static HRESULT WINAPI	d3d_device1_DeleteMatrix (IDirect3DDevice *iface, D3DMATRIXHANDLE D3DMatHandle)
static HRESULT	d3d_device7_BeginScene (IDirect3DDevice7 *iface)
static HRESULT WINAPI	d3d_device7_BeginScene_FPUSetup (IDirect3DDevice7 *iface)
static HRESULT WINAPI	d3d_device7_BeginScene_FPUPreserve (IDirect3DDevice7 *iface)
static HRESULT WINAPI	d3d_device3_BeginScene (IDirect3DDevice3 *iface)
static HRESULT WINAPI	d3d_device2_BeginScene (IDirect3DDevice2 *iface)
static HRESULT WINAPI	d3d_device1_BeginScene (IDirect3DDevice *iface)
static HRESULT	d3d_device7_EndScene (IDirect3DDevice7 *iface)
static HRESULT WINAPI DECLSPEC_HOTPATCH	d3d_device7_EndScene_FPUSetup (IDirect3DDevice7 *iface)
static HRESULT WINAPI DECLSPEC_HOTPATCH	d3d_device7_EndScene_FPUPreserve (IDirect3DDevice7 *iface)
static HRESULT WINAPI DECLSPEC_HOTPATCH	d3d_device3_EndScene (IDirect3DDevice3 *iface)
static HRESULT WINAPI DECLSPEC_HOTPATCH	d3d_device2_EndScene (IDirect3DDevice2 *iface)
static HRESULT WINAPI DECLSPEC_HOTPATCH	d3d_device1_EndScene (IDirect3DDevice *iface)
static HRESULT WINAPI	d3d_device7_GetDirect3D (IDirect3DDevice7 *iface, IDirect3D7 **d3d)
static HRESULT WINAPI	d3d_device3_GetDirect3D (IDirect3DDevice3 *iface, IDirect3D3 **d3d)
static HRESULT WINAPI	d3d_device2_GetDirect3D (IDirect3DDevice2 *iface, IDirect3D2 **d3d)
static HRESULT WINAPI	d3d_device1_GetDirect3D (IDirect3DDevice *iface, IDirect3D **d3d)
static HRESULT WINAPI	d3d_device3_SetCurrentViewport (IDirect3DDevice3 *iface, IDirect3DViewport3 *Direct3DViewport3)
static HRESULT WINAPI	d3d_device2_SetCurrentViewport (IDirect3DDevice2 *iface, IDirect3DViewport2 *viewport)
static HRESULT WINAPI	d3d_device3_GetCurrentViewport (IDirect3DDevice3 *iface, IDirect3DViewport3 **viewport)
static HRESULT WINAPI	d3d_device2_GetCurrentViewport (IDirect3DDevice2 *iface, IDirect3DViewport2 **viewport)
static BOOL	validate_surface_palette (struct ddraw_surface *surface)
static HRESULT	d3d_device_set_render_target (struct d3d_device *device, struct ddraw_surface *target, IUnknown *rt_iface)
static HRESULT	d3d_device7_SetRenderTarget (IDirect3DDevice7 *iface, IDirectDrawSurface7 *target, DWORD flags)
static HRESULT WINAPI	d3d_device7_SetRenderTarget_FPUSetup (IDirect3DDevice7 *iface, IDirectDrawSurface7 *NewTarget, DWORD flags)
static HRESULT WINAPI	d3d_device7_SetRenderTarget_FPUPreserve (IDirect3DDevice7 *iface, IDirectDrawSurface7 *NewTarget, DWORD flags)
static HRESULT WINAPI	d3d_device3_SetRenderTarget (IDirect3DDevice3 *iface, IDirectDrawSurface4 *target, DWORD flags)
static HRESULT WINAPI	d3d_device2_SetRenderTarget (IDirect3DDevice2 *iface, IDirectDrawSurface *target, DWORD flags)
static HRESULT WINAPI	d3d_device7_GetRenderTarget (IDirect3DDevice7 *iface, IDirectDrawSurface7 **RenderTarget)
static HRESULT WINAPI	d3d_device3_GetRenderTarget (IDirect3DDevice3 *iface, IDirectDrawSurface4 **RenderTarget)
static HRESULT WINAPI	d3d_device2_GetRenderTarget (IDirect3DDevice2 *iface, IDirectDrawSurface **RenderTarget)
static HRESULT WINAPI	d3d_device3_Begin (IDirect3DDevice3 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, DWORD flags)
static HRESULT WINAPI	d3d_device2_Begin (IDirect3DDevice2 *iface, D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, DWORD flags)
static HRESULT WINAPI	d3d_device3_BeginIndexed (IDirect3DDevice3 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, DWORD flags)
static HRESULT WINAPI	d3d_device2_BeginIndexed (IDirect3DDevice2 *iface, D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, void *vertices, DWORD vertex_count, DWORD flags)
static HRESULT WINAPI	d3d_device3_Vertex (IDirect3DDevice3 *iface, void *vertex)
static HRESULT WINAPI	d3d_device2_Vertex (IDirect3DDevice2 *iface, void *vertex)
static HRESULT WINAPI	d3d_device3_Index (IDirect3DDevice3 *iface, WORD index)
static HRESULT WINAPI	d3d_device2_Index (IDirect3DDevice2 *iface, WORD index)
static HRESULT	d3d_device7_GetRenderState (IDirect3DDevice7 *iface, D3DRENDERSTATETYPE state, DWORD *value)
static HRESULT WINAPI	d3d_device7_GetRenderState_FPUSetup (IDirect3DDevice7 *iface, D3DRENDERSTATETYPE state, DWORD *value)
static HRESULT WINAPI	d3d_device7_GetRenderState_FPUPreserve (IDirect3DDevice7 *iface, D3DRENDERSTATETYPE state, DWORD *value)
static HRESULT WINAPI	d3d_device3_GetRenderState (IDirect3DDevice3 *iface, D3DRENDERSTATETYPE state, DWORD *value)
static HRESULT WINAPI	d3d_device2_GetRenderState (IDirect3DDevice2 *iface, D3DRENDERSTATETYPE state, DWORD *value)
static HRESULT	d3d_device7_SetRenderState (IDirect3DDevice7 *iface, D3DRENDERSTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device7_SetRenderState_FPUSetup (IDirect3DDevice7 *iface, D3DRENDERSTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device7_SetRenderState_FPUPreserve (IDirect3DDevice7 *iface, D3DRENDERSTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device3_SetRenderState (IDirect3DDevice3 *iface, D3DRENDERSTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device2_SetRenderState (IDirect3DDevice2 *iface, D3DRENDERSTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device3_SetLightState (IDirect3DDevice3 *iface, D3DLIGHTSTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device2_SetLightState (IDirect3DDevice2 *iface, D3DLIGHTSTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device3_GetLightState (IDirect3DDevice3 *iface, D3DLIGHTSTATETYPE state, DWORD *value)
static HRESULT WINAPI	d3d_device2_GetLightState (IDirect3DDevice2 *iface, D3DLIGHTSTATETYPE state, DWORD *value)
static HRESULT	d3d_device7_SetTransform (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device7_SetTransform_FPUSetup (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device7_SetTransform_FPUPreserve (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device3_SetTransform (IDirect3DDevice3 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device2_SetTransform (IDirect3DDevice2 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT	d3d_device7_GetTransform (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device7_GetTransform_FPUSetup (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device7_GetTransform_FPUPreserve (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device3_GetTransform (IDirect3DDevice3 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device2_GetTransform (IDirect3DDevice2 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT	d3d_device7_MultiplyTransform (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device7_MultiplyTransform_FPUSetup (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device7_MultiplyTransform_FPUPreserve (IDirect3DDevice7 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device3_MultiplyTransform (IDirect3DDevice3 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT WINAPI	d3d_device2_MultiplyTransform (IDirect3DDevice2 *iface, D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
static HRESULT	d3d_device_prepare_vertex_buffer (struct d3d_device *device, UINT min_size)
static HRESULT	d3d_device7_DrawPrimitive (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, DWORD flags)
static HRESULT WINAPI	d3d_device7_DrawPrimitive_FPUSetup (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, DWORD flags)
static HRESULT WINAPI	d3d_device7_DrawPrimitive_FPUPreserve (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, DWORD flags)
static void	setup_lighting (const struct d3d_device *device, DWORD fvf, DWORD flags)
static HRESULT WINAPI	d3d_device3_DrawPrimitive (IDirect3DDevice3 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, DWORD flags)
static HRESULT WINAPI	d3d_device2_DrawPrimitive (IDirect3DDevice2 *iface, D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, void *vertices, DWORD vertex_count, DWORD flags)
static HRESULT	d3d_device_prepare_index_buffer (struct d3d_device *device, UINT min_size)
static HRESULT	d3d_device7_DrawIndexedPrimitive (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
static HRESULT WINAPI	d3d_device7_DrawIndexedPrimitive_FPUSetup (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
static HRESULT WINAPI	d3d_device7_DrawIndexedPrimitive_FPUPreserve (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
static HRESULT WINAPI	d3d_device3_DrawIndexedPrimitive (IDirect3DDevice3 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
static HRESULT WINAPI	d3d_device2_DrawIndexedPrimitive (IDirect3DDevice2 *iface, D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, void *vertices, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
static HRESULT WINAPI	d3d_device3_End (IDirect3DDevice3 *iface, DWORD flags)
static HRESULT WINAPI	d3d_device2_End (IDirect3DDevice2 *iface, DWORD flags)
static HRESULT WINAPI	d3d_device7_SetClipStatus (IDirect3DDevice7 *iface, D3DCLIPSTATUS *clip_status)
static HRESULT WINAPI	d3d_device3_SetClipStatus (IDirect3DDevice3 *iface, D3DCLIPSTATUS *clip_status)
static HRESULT WINAPI	d3d_device2_SetClipStatus (IDirect3DDevice2 *iface, D3DCLIPSTATUS *clip_status)
static HRESULT WINAPI	d3d_device7_GetClipStatus (IDirect3DDevice7 *iface, D3DCLIPSTATUS *clip_status)
static HRESULT WINAPI	d3d_device3_GetClipStatus (IDirect3DDevice3 *iface, D3DCLIPSTATUS *clip_status)
static HRESULT WINAPI	d3d_device2_GetClipStatus (IDirect3DDevice2 *iface, D3DCLIPSTATUS *clip_status)
static void	pack_strided_data (BYTE *dst, DWORD count, const D3DDRAWPRIMITIVESTRIDEDDATA *src, DWORD fvf)
static HRESULT	d3d_device7_DrawPrimitiveStrided (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, D3DDRAWPRIMITIVESTRIDEDDATA *strided_data, DWORD vertex_count, DWORD flags)
static HRESULT WINAPI	d3d_device7_DrawPrimitiveStrided_FPUSetup (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, DWORD Flags)
static HRESULT WINAPI	d3d_device7_DrawPrimitiveStrided_FPUPreserve (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, DWORD Flags)
static HRESULT WINAPI	d3d_device3_DrawPrimitiveStrided (IDirect3DDevice3 *iface, D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, DWORD Flags)
static HRESULT	d3d_device7_DrawIndexedPrimitiveStrided (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, DWORD fvf, D3DDRAWPRIMITIVESTRIDEDDATA *strided_data, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
static HRESULT WINAPI	d3d_device7_DrawIndexedPrimitiveStrided_FPUSetup (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, WORD *Indices, DWORD IndexCount, DWORD Flags)
static HRESULT WINAPI	d3d_device7_DrawIndexedPrimitiveStrided_FPUPreserve (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, WORD *Indices, DWORD IndexCount, DWORD Flags)
static HRESULT WINAPI	d3d_device3_DrawIndexedPrimitiveStrided (IDirect3DDevice3 *iface, D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, WORD *Indices, DWORD IndexCount, DWORD Flags)
static HRESULT	d3d_device7_DrawPrimitiveVB (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, IDirect3DVertexBuffer7 *vb, DWORD start_vertex, DWORD vertex_count, DWORD flags)
static HRESULT WINAPI	d3d_device7_DrawPrimitiveVB_FPUSetup (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType, IDirect3DVertexBuffer7 *D3DVertexBuf, DWORD StartVertex, DWORD NumVertices, DWORD Flags)
static HRESULT WINAPI	d3d_device7_DrawPrimitiveVB_FPUPreserve (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType, IDirect3DVertexBuffer7 *D3DVertexBuf, DWORD StartVertex, DWORD NumVertices, DWORD Flags)
static HRESULT WINAPI	d3d_device3_DrawPrimitiveVB (IDirect3DDevice3 *iface, D3DPRIMITIVETYPE PrimitiveType, IDirect3DVertexBuffer *D3DVertexBuf, DWORD StartVertex, DWORD NumVertices, DWORD Flags)
static HRESULT	d3d_device7_DrawIndexedPrimitiveVB (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type, IDirect3DVertexBuffer7 *vb, DWORD start_vertex, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
static HRESULT WINAPI	d3d_device7_DrawIndexedPrimitiveVB_FPUSetup (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType, IDirect3DVertexBuffer7 *D3DVertexBuf, DWORD StartVertex, DWORD NumVertices, WORD *Indices, DWORD IndexCount, DWORD Flags)
static HRESULT WINAPI	d3d_device7_DrawIndexedPrimitiveVB_FPUPreserve (IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType, IDirect3DVertexBuffer7 *D3DVertexBuf, DWORD StartVertex, DWORD NumVertices, WORD *Indices, DWORD IndexCount, DWORD Flags)
static HRESULT WINAPI	d3d_device3_DrawIndexedPrimitiveVB (IDirect3DDevice3 *iface, D3DPRIMITIVETYPE PrimitiveType, IDirect3DVertexBuffer *D3DVertexBuf, WORD *Indices, DWORD IndexCount, DWORD Flags)
static DWORD	in_plane (UINT idx, struct wined3d_vec4 p, D3DVECTOR center, D3DVALUE radius, BOOL equality)
static void	prepare_clip_space_planes (struct d3d_device *device, struct wined3d_vec4 *plane)
static void	compute_sphere_visibility (struct wined3d_vec4 plane[12], DWORD enabled_planes, BOOL equality, D3DVECTOR *centers, D3DVALUE *radii, DWORD sphere_count, DWORD *return_values)
static HRESULT WINAPI	d3d_device7_ComputeSphereVisibility (IDirect3DDevice7 *iface, D3DVECTOR *centers, D3DVALUE *radii, DWORD sphere_count, DWORD flags, DWORD *return_values)
static HRESULT WINAPI	d3d_device3_ComputeSphereVisibility (IDirect3DDevice3 *iface, D3DVECTOR *centers, D3DVALUE *radii, DWORD sphere_count, DWORD flags, DWORD *return_values)
static HRESULT	d3d_device7_GetTexture (IDirect3DDevice7 *iface, DWORD stage, IDirectDrawSurface7 **texture)
static HRESULT WINAPI	d3d_device7_GetTexture_FPUSetup (IDirect3DDevice7 *iface, DWORD stage, IDirectDrawSurface7 **Texture)
static HRESULT WINAPI	d3d_device7_GetTexture_FPUPreserve (IDirect3DDevice7 *iface, DWORD stage, IDirectDrawSurface7 **Texture)
static HRESULT WINAPI	d3d_device3_GetTexture (IDirect3DDevice3 *iface, DWORD stage, IDirect3DTexture2 **Texture2)
static HRESULT	d3d_device7_SetTexture (IDirect3DDevice7 *iface, DWORD stage, IDirectDrawSurface7 *texture)
static HRESULT WINAPI	d3d_device7_SetTexture_FPUSetup (IDirect3DDevice7 *iface, DWORD stage, IDirectDrawSurface7 *texture)
static HRESULT WINAPI	d3d_device7_SetTexture_FPUPreserve (IDirect3DDevice7 *iface, DWORD stage, IDirectDrawSurface7 *texture)
static HRESULT WINAPI	d3d_device3_SetTexture (IDirect3DDevice3 *iface, DWORD stage, IDirect3DTexture2 *texture)
static HRESULT	d3d_device7_GetTextureStageState (IDirect3DDevice7 *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value)
static HRESULT WINAPI	d3d_device7_GetTextureStageState_FPUSetup (IDirect3DDevice7 *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value)
static HRESULT WINAPI	d3d_device7_GetTextureStageState_FPUPreserve (IDirect3DDevice7 *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value)
static HRESULT WINAPI	d3d_device3_GetTextureStageState (IDirect3DDevice3 *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value)
static HRESULT	d3d_device7_SetTextureStageState (IDirect3DDevice7 *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device7_SetTextureStageState_FPUSetup (IDirect3DDevice7 *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device7_SetTextureStageState_FPUPreserve (IDirect3DDevice7 *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value)
static HRESULT WINAPI	d3d_device3_SetTextureStageState (IDirect3DDevice3 *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value)
static HRESULT	d3d_device7_ValidateDevice (IDirect3DDevice7 *iface, DWORD *pass_count)
static HRESULT WINAPI	d3d_device7_ValidateDevice_FPUSetup (IDirect3DDevice7 *iface, DWORD *pass_count)
static HRESULT WINAPI	d3d_device7_ValidateDevice_FPUPreserve (IDirect3DDevice7 *iface, DWORD *pass_count)
static HRESULT WINAPI	d3d_device3_ValidateDevice (IDirect3DDevice3 *iface, DWORD *pass_count)
static HRESULT	d3d_device7_Clear (IDirect3DDevice7 *iface, DWORD count, D3DRECT *rects, DWORD flags, D3DCOLOR color, D3DVALUE z, DWORD stencil)
static HRESULT WINAPI	d3d_device7_Clear_FPUSetup (IDirect3DDevice7 *iface, DWORD count, D3DRECT *rects, DWORD flags, D3DCOLOR color, D3DVALUE z, DWORD stencil)
static HRESULT WINAPI	d3d_device7_Clear_FPUPreserve (IDirect3DDevice7 *iface, DWORD count, D3DRECT *rects, DWORD flags, D3DCOLOR color, D3DVALUE z, DWORD stencil)
static HRESULT	d3d_device7_SetViewport (IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
static HRESULT WINAPI	d3d_device7_SetViewport_FPUSetup (IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
static HRESULT WINAPI	d3d_device7_SetViewport_FPUPreserve (IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
static HRESULT	d3d_device7_GetViewport (IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
static HRESULT WINAPI	d3d_device7_GetViewport_FPUSetup (IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
static HRESULT WINAPI	d3d_device7_GetViewport_FPUPreserve (IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
static HRESULT	d3d_device7_SetMaterial (IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
static HRESULT WINAPI	d3d_device7_SetMaterial_FPUSetup (IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
static HRESULT WINAPI	d3d_device7_SetMaterial_FPUPreserve (IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
static HRESULT	d3d_device7_GetMaterial (IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
static HRESULT WINAPI	d3d_device7_GetMaterial_FPUSetup (IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
static HRESULT WINAPI	d3d_device7_GetMaterial_FPUPreserve (IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
static HRESULT	d3d_device7_SetLight (IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
static HRESULT WINAPI	d3d_device7_SetLight_FPUSetup (IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
static HRESULT WINAPI	d3d_device7_SetLight_FPUPreserve (IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
static HRESULT	d3d_device7_GetLight (IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
static HRESULT WINAPI	d3d_device7_GetLight_FPUSetup (IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
static HRESULT WINAPI	d3d_device7_GetLight_FPUPreserve (IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
static HRESULT	d3d_device7_BeginStateBlock (IDirect3DDevice7 *iface)
static HRESULT WINAPI	d3d_device7_BeginStateBlock_FPUSetup (IDirect3DDevice7 *iface)
static HRESULT WINAPI	d3d_device7_BeginStateBlock_FPUPreserve (IDirect3DDevice7 *iface)
static HRESULT	d3d_device7_EndStateBlock (IDirect3DDevice7 *iface, DWORD *stateblock)
static HRESULT WINAPI	d3d_device7_EndStateBlock_FPUSetup (IDirect3DDevice7 *iface, DWORD *stateblock)
static HRESULT WINAPI	d3d_device7_EndStateBlock_FPUPreserve (IDirect3DDevice7 *iface, DWORD *stateblock)
static HRESULT	d3d_device7_PreLoad (IDirect3DDevice7 *iface, IDirectDrawSurface7 *texture)
static HRESULT WINAPI	d3d_device7_PreLoad_FPUSetup (IDirect3DDevice7 *iface, IDirectDrawSurface7 *texture)
static HRESULT WINAPI	d3d_device7_PreLoad_FPUPreserve (IDirect3DDevice7 *iface, IDirectDrawSurface7 *texture)
static HRESULT	d3d_device7_ApplyStateBlock (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT WINAPI	d3d_device7_ApplyStateBlock_FPUSetup (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT WINAPI	d3d_device7_ApplyStateBlock_FPUPreserve (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT	d3d_device7_CaptureStateBlock (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT WINAPI	d3d_device7_CaptureStateBlock_FPUSetup (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT WINAPI	d3d_device7_CaptureStateBlock_FPUPreserve (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT	d3d_device7_DeleteStateBlock (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT WINAPI	d3d_device7_DeleteStateBlock_FPUSetup (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT WINAPI	d3d_device7_DeleteStateBlock_FPUPreserve (IDirect3DDevice7 *iface, DWORD stateblock)
static HRESULT	d3d_device7_CreateStateBlock (IDirect3DDevice7 *iface, D3DSTATEBLOCKTYPE type, DWORD *stateblock)
static HRESULT WINAPI	d3d_device7_CreateStateBlock_FPUSetup (IDirect3DDevice7 *iface, D3DSTATEBLOCKTYPE type, DWORD *stateblock)
static HRESULT WINAPI	d3d_device7_CreateStateBlock_FPUPreserve (IDirect3DDevice7 *iface, D3DSTATEBLOCKTYPE type, DWORD *stateblock)
static BOOL	is_mip_level_subset (struct ddraw_surface *dest, struct ddraw_surface *src)
static void	copy_mipmap_chain (struct d3d_device *device, struct ddraw_surface *dst, struct ddraw_surface *src, const POINT *DestPoint, const RECT *SrcRect)
static HRESULT	d3d_device7_Load (IDirect3DDevice7 *iface, IDirectDrawSurface7 *dst_texture, POINT *dst_pos, IDirectDrawSurface7 *src_texture, RECT *src_rect, DWORD flags)
static HRESULT WINAPI	d3d_device7_Load_FPUSetup (IDirect3DDevice7 *iface, IDirectDrawSurface7 *dst_texture, POINT *dst_pos, IDirectDrawSurface7 *src_texture, RECT *src_rect, DWORD flags)
static HRESULT WINAPI	d3d_device7_Load_FPUPreserve (IDirect3DDevice7 *iface, IDirectDrawSurface7 *dst_texture, POINT *dst_pos, IDirectDrawSurface7 *src_texture, RECT *src_rect, DWORD flags)
static HRESULT	d3d_device7_LightEnable (IDirect3DDevice7 *iface, DWORD light_idx, BOOL enabled)
static HRESULT WINAPI	d3d_device7_LightEnable_FPUSetup (IDirect3DDevice7 *iface, DWORD light_idx, BOOL enabled)
static HRESULT WINAPI	d3d_device7_LightEnable_FPUPreserve (IDirect3DDevice7 *iface, DWORD light_idx, BOOL enabled)
static HRESULT	d3d_device7_GetLightEnable (IDirect3DDevice7 *iface, DWORD light_idx, BOOL *enabled)
static HRESULT WINAPI	d3d_device7_GetLightEnable_FPUSetup (IDirect3DDevice7 *iface, DWORD light_idx, BOOL *enabled)
static HRESULT WINAPI	d3d_device7_GetLightEnable_FPUPreserve (IDirect3DDevice7 *iface, DWORD light_idx, BOOL *enabled)
static HRESULT	d3d_device7_SetClipPlane (IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
static HRESULT WINAPI	d3d_device7_SetClipPlane_FPUSetup (IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
static HRESULT WINAPI	d3d_device7_SetClipPlane_FPUPreserve (IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
static HRESULT	d3d_device7_GetClipPlane (IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
static HRESULT WINAPI	d3d_device7_GetClipPlane_FPUSetup (IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
static HRESULT WINAPI	d3d_device7_GetClipPlane_FPUPreserve (IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
static HRESULT WINAPI	d3d_device7_GetInfo (IDirect3DDevice7 *iface, DWORD info_id, void *info, DWORD info_size)
struct d3d_device *	unsafe_impl_from_IDirect3DDevice7 (IDirect3DDevice7 *iface)
struct d3d_device *	unsafe_impl_from_IDirect3DDevice3 (IDirect3DDevice3 *iface)
struct d3d_device *	unsafe_impl_from_IDirect3DDevice2 (IDirect3DDevice2 *iface)
struct d3d_device *	unsafe_impl_from_IDirect3DDevice (IDirect3DDevice *iface)
enum wined3d_depth_buffer_type	d3d_device_update_depth_stencil (struct d3d_device *device)
static HRESULT	d3d_device_init (struct d3d_device *device, struct ddraw *ddraw, BOOL hw, struct ddraw_surface *target, IUnknown *rt_iface, UINT version, IUnknown *outer_unknown)
HRESULT	d3d_device_create (struct ddraw *ddraw, const GUID *guid, struct ddraw_surface *target, IUnknown *rt_iface, UINT version, struct d3d_device **device, IUnknown *outer_unknown)

Variables
const GUID	IID_D3DDEVICE_WineD3D
static const struct tss_lookup	tss_lookup []
static const struct IDirect3DDevice7Vtbl	d3d_device7_fpu_setup_vtbl
static const struct IDirect3DDevice7Vtbl	d3d_device7_fpu_preserve_vtbl
static const struct IDirect3DDevice3Vtbl	d3d_device3_vtbl
static const struct IDirect3DDevice2Vtbl	d3d_device2_vtbl
static const struct IDirect3DDeviceVtbl	d3d_device1_vtbl
static const struct IUnknownVtbl	d3d_device_inner_vtbl

Function Documentation

check_d3ddevicedesc_size()

static BOOL check_d3ddevicedesc_size ( DWORD  size )

inlinestatic

Definition at line 461 of file device.c.

{
    if (size == FIELD_OFFSET(D3DDEVICEDESC, dwMinTextureWidth) /* 172 */
            || size == FIELD_OFFSET(D3DDEVICEDESC, dwMaxTextureRepeat) /* 204 */
            || size == sizeof(D3DDEVICEDESC) /* 252 */) return TRUE;
    return FALSE;
}

Referenced by d3d_device3_GetCaps().

compute_sphere_visibility()

static void compute_sphere_visibility ( struct wined3d_vec4  plane[12], DWORD  enabled_planes, BOOL  equality, D3DVECTOR *  centers, D3DVALUE *  radii, DWORD  sphere_count, DWORD *  return_values  )

static

Definition at line 4589 of file device.c.

{
    UINT i, j;
 
    for (i = 0; i < sphere_count; ++i)
    {
        return_values[i] = 0;
        for (j = 0; j < 12; ++j)
            if (enabled_planes & 1u << j)
                return_values[i] |= in_plane(j, plane[j], centers[i], radii[i], equality);
    }
}

Referenced by d3d_device3_ComputeSphereVisibility(), and d3d_device7_ComputeSphereVisibility().

copy_mipmap_chain()

static void copy_mipmap_chain ( struct d3d_device *  device, struct ddraw_surface *  dst, struct ddraw_surface *  src, const POINT *  DestPoint, const RECT *  SrcRect  )

static

Definition at line 6058 of file device.c.

{
    struct ddraw_surface *dst_level, *src_level;
    IDirectDrawSurface7 *temp;
    DDSURFACEDESC2 ddsd;
    POINT point;
    RECT src_rect;
    HRESULT hr;
    IDirectDrawPalette *pal = NULL, *pal_src = NULL;
    DWORD ckeyflag;
    DDCOLORKEY ddckey;
 
    /* Copy palette, if possible. */
    IDirectDrawSurface7_GetPalette(&src->IDirectDrawSurface7_iface, &pal_src);
    IDirectDrawSurface7_GetPalette(&dst->IDirectDrawSurface7_iface, &pal);
 
    if (pal_src != NULL && pal != NULL)
    {
        PALETTEENTRY palent[256];
 
        IDirectDrawPalette_GetEntries(pal_src, 0, 0, 256, palent);
        IDirectDrawPalette_SetEntries(pal, 0, 0, 256, palent);
    }
 
    if (pal) IDirectDrawPalette_Release(pal);
    if (pal_src) IDirectDrawPalette_Release(pal_src);
 
    /* Copy colorkeys, if present. */
    for (ckeyflag = DDCKEY_DESTBLT; ckeyflag <= DDCKEY_SRCOVERLAY; ckeyflag <<= 1)
    {
        hr = IDirectDrawSurface7_GetColorKey(&src->IDirectDrawSurface7_iface, ckeyflag, &ddckey);
 
        if (SUCCEEDED(hr))
        {
            IDirectDrawSurface7_SetColorKey(&dst->IDirectDrawSurface7_iface, ckeyflag, &ddckey);
        }
    }
 
    src_level = src;
    dst_level = dst;
 
    point = *DestPoint;
    src_rect = *SrcRect;
 
    for (;src_level && dst_level;)
    {
        if (src_level->surface_desc.dwWidth == dst_level->surface_desc.dwWidth
                && src_level->surface_desc.dwHeight == dst_level->surface_desc.dwHeight)
        {
            UINT src_w = src_rect.right - src_rect.left;
            UINT src_h = src_rect.bottom - src_rect.top;
            RECT dst_rect = {point.x, point.y, point.x + src_w, point.y + src_h};
 
            if (FAILED(hr = wined3d_texture_blt(dst_level->wined3d_texture, dst_level->sub_resource_idx, &dst_rect,
                    src_level->wined3d_texture, src_level->sub_resource_idx, &src_rect, 0, NULL, WINED3D_TEXF_POINT)))
                ERR("Blit failed, hr %#x.\n", hr);
 
            ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
            ddsd.ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
            IDirectDrawSurface7_GetAttachedSurface(&dst_level->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
 
            if (dst_level != dst)
                IDirectDrawSurface7_Release(&dst_level->IDirectDrawSurface7_iface);
 
            dst_level = unsafe_impl_from_IDirectDrawSurface7(temp);
        }
 
        ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
        ddsd.ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
        IDirectDrawSurface7_GetAttachedSurface(&src_level->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
 
        if (src_level != src) IDirectDrawSurface7_Release(&src_level->IDirectDrawSurface7_iface);
 
        src_level = unsafe_impl_from_IDirectDrawSurface7(temp);
 
        point.x /= 2;
        point.y /= 2;
 
        src_rect.top /= 2;
        src_rect.left /= 2;
        src_rect.right = (src_rect.right + 1) / 2;
        src_rect.bottom = (src_rect.bottom + 1) / 2;
    }
 
    if (src_level && src_level != src)
        IDirectDrawSurface7_Release(&src_level->IDirectDrawSurface7_iface);
    if (dst_level && dst_level != dst)
        IDirectDrawSurface7_Release(&dst_level->IDirectDrawSurface7_iface);
}

Referenced by d3d_device7_Load().

d3d_device1_AddRef()

static ULONG WINAPI d3d_device1_AddRef ( IDirect3DDevice *  iface )

static

Definition at line 214 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IUnknown_AddRef(device->outer_unknown);
}

d3d_device1_AddViewport()

static HRESULT WINAPI d3d_device1_AddViewport ( IDirect3DDevice *  iface, IDirect3DViewport *  viewport  )

static

Definition at line 772 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport(viewport);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    return d3d_device3_AddViewport(&device->IDirect3DDevice3_iface, &vp->IDirect3DViewport3_iface);
}

d3d_device1_BeginScene()

static HRESULT WINAPI d3d_device1_BeginScene ( IDirect3DDevice *  iface )

static

Definition at line 1516 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IDirect3DDevice7_BeginScene(&device->IDirect3DDevice7_iface);
}

d3d_device1_CreateExecuteBuffer()

static HRESULT WINAPI d3d_device1_CreateExecuteBuffer ( IDirect3DDevice *  iface, D3DEXECUTEBUFFERDESC *  buffer_desc, IDirect3DExecuteBuffer **  ExecuteBuffer, IUnknown *  outer_unknown  )

static

Definition at line 652 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    struct d3d_execute_buffer *object;
    HRESULT hr;
 
    TRACE("iface %p, buffer_desc %p, buffer %p, outer_unknown %p.\n",
            iface, buffer_desc, ExecuteBuffer, outer_unknown);
 
    if (outer_unknown)
        return CLASS_E_NOAGGREGATION;
 
    /* Allocate the new Execute Buffer */
    if (!(object = heap_alloc_zero(sizeof(*object))))
    {
        ERR("Failed to allocate execute buffer memory.\n");
        return DDERR_OUTOFMEMORY;
    }
 
    hr = d3d_execute_buffer_init(object, device, buffer_desc);
    if (FAILED(hr))
    {
        WARN("Failed to initialize execute buffer, hr %#x.\n", hr);
        heap_free(object);
        return hr;
    }
 
    *ExecuteBuffer = &object->IDirect3DExecuteBuffer_iface;
 
    TRACE(" Returning IDirect3DExecuteBuffer at %p, implementation is at %p\n", *ExecuteBuffer, object);
 
    return D3D_OK;
}

d3d_device1_CreateMatrix()

static HRESULT WINAPI d3d_device1_CreateMatrix ( IDirect3DDevice *  iface, D3DMATRIXHANDLE *  D3DMatHandle  )

static

Definition at line 1273 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    D3DMATRIX *matrix;
    DWORD h;
 
    TRACE("iface %p, matrix_handle %p.\n", iface, D3DMatHandle);
 
    if(!D3DMatHandle)
        return DDERR_INVALIDPARAMS;
 
    if (!(matrix = heap_alloc_zero(sizeof(*matrix))))
    {
        ERR("Out of memory when allocating a D3DMATRIX\n");
        return DDERR_OUTOFMEMORY;
    }
 
    wined3d_mutex_lock();
 
    h = ddraw_allocate_handle(&device->handle_table, matrix, DDRAW_HANDLE_MATRIX);
    if (h == DDRAW_INVALID_HANDLE)
    {
        ERR("Failed to allocate a matrix handle.\n");
        heap_free(matrix);
        wined3d_mutex_unlock();
        return DDERR_OUTOFMEMORY;
    }
 
    *D3DMatHandle = h + 1;
 
    TRACE(" returning matrix handle %d\n", *D3DMatHandle);
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

d3d_device1_DeleteMatrix()

static HRESULT WINAPI d3d_device1_DeleteMatrix ( IDirect3DDevice *  iface, D3DMATRIXHANDLE  D3DMatHandle  )

static

Definition at line 1428 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    D3DMATRIX *m;
 
    TRACE("iface %p, matrix_handle %#x.\n", iface, D3DMatHandle);
 
    wined3d_mutex_lock();
 
    m = ddraw_free_handle(&device->handle_table, D3DMatHandle - 1, DDRAW_HANDLE_MATRIX);
    if (!m)
    {
        WARN("Invalid matrix handle.\n");
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    wined3d_mutex_unlock();
 
    heap_free(m);
 
    return D3D_OK;
}

d3d_device1_DeleteViewport()

static HRESULT WINAPI d3d_device1_DeleteViewport ( IDirect3DDevice *  iface, IDirect3DViewport *  viewport  )

static

Definition at line 848 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport(viewport);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    return d3d_device3_DeleteViewport(&device->IDirect3DDevice3_iface,
            vp ? &vp->IDirect3DViewport3_iface : NULL);
}

d3d_device1_EndScene()

static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device1_EndScene ( IDirect3DDevice *  iface )

static

Definition at line 1589 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IDirect3DDevice7_EndScene(&device->IDirect3DDevice7_iface);
}

d3d_device1_EnumTextureFormats()

static HRESULT WINAPI d3d_device1_EnumTextureFormats ( IDirect3DDevice *  iface, LPD3DENUMTEXTUREFORMATSCALLBACK  callback, void *  context  )

static

Definition at line 1247 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
 
    return d3d_device2_EnumTextureFormats(&device->IDirect3DDevice2_iface, callback, context);
}

d3d_device1_Execute()

static HRESULT WINAPI d3d_device1_Execute ( IDirect3DDevice *  iface, IDirect3DExecuteBuffer *  ExecuteBuffer, IDirect3DViewport *  viewport, DWORD  flags  )

static

Definition at line 702 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    struct d3d_execute_buffer *buffer = unsafe_impl_from_IDirect3DExecuteBuffer(ExecuteBuffer);
    struct d3d_viewport *viewport_impl = unsafe_impl_from_IDirect3DViewport(viewport);
    HRESULT hr;
 
    TRACE("iface %p, buffer %p, viewport %p, flags %#x.\n", iface, ExecuteBuffer, viewport, flags);
 
    if(!buffer)
        return DDERR_INVALIDPARAMS;
 
    /* Execute... */
    wined3d_mutex_lock();
    hr = d3d_execute_buffer_execute(buffer, device, viewport_impl);
    wined3d_mutex_unlock();
 
    return hr;
}

d3d_device1_GetCaps()

static HRESULT WINAPI d3d_device1_GetCaps ( IDirect3DDevice *  iface, D3DDEVICEDESC *  hw_desc, D3DDEVICEDESC *  hel_desc  )

static

Definition at line 519 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p, hw_desc %p, hel_desc %p.\n", iface, hw_desc, hel_desc);
 
    return d3d_device3_GetCaps(&device->IDirect3DDevice3_iface, hw_desc, hel_desc);
}

d3d_device1_GetDirect3D()

static HRESULT WINAPI d3d_device1_GetDirect3D ( IDirect3DDevice *  iface, IDirect3D **  d3d  )

static

Definition at line 1660 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p, d3d %p.\n", iface, d3d);
 
    if (!d3d)
        return DDERR_INVALIDPARAMS;
 
    *d3d = &device->ddraw->IDirect3D_iface;
    IDirect3D_AddRef(*d3d);
 
    TRACE("Returning interface %p.\n", *d3d);
    return D3D_OK;
}

d3d_device1_GetMatrix()

static HRESULT WINAPI d3d_device1_GetMatrix ( IDirect3DDevice *  iface, D3DMATRIXHANDLE  D3DMatHandle, D3DMATRIX *  D3DMatrix  )

static

Definition at line 1386 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    D3DMATRIX *m;
 
    TRACE("iface %p, matrix_handle %#x, matrix %p.\n", iface, D3DMatHandle, D3DMatrix);
 
    if (!D3DMatrix) return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
 
    m = ddraw_get_object(&device->handle_table, D3DMatHandle - 1, DDRAW_HANDLE_MATRIX);
    if (!m)
    {
        WARN("Invalid matrix handle.\n");
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    *D3DMatrix = *m;
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

d3d_device1_GetPickRecords()

static HRESULT WINAPI d3d_device1_GetPickRecords ( IDirect3DDevice *  iface, DWORD *  count, D3DPICKRECORD *  records  )

static

Definition at line 1010 of file device.c.

{
    FIXME("iface %p, count %p, records %p stub!\n", iface, count, records);
 
    return D3D_OK;
}

d3d_device1_GetStats()

static HRESULT WINAPI d3d_device1_GetStats ( IDirect3DDevice *  iface, D3DSTATS *  stats  )

static

Definition at line 623 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p, stats %p.\n", iface, stats);
 
    return d3d_device3_GetStats(&device->IDirect3DDevice3_iface, stats);
}

d3d_device1_Initialize()

static HRESULT WINAPI d3d_device1_Initialize ( IDirect3DDevice *  iface, IDirect3D *  d3d, GUID *  guid, D3DDEVICEDESC *  device_desc  )

static

Definition at line 387 of file device.c.

{
    /* It shouldn't be crucial, but print a FIXME, I'm interested if
     * any game calls it and when. */
    FIXME("iface %p, d3d %p, guid %s, device_desc %p nop!\n",
            iface, d3d, debugstr_guid(guid), device_desc);
 
    return D3D_OK;
}

d3d_device1_NextViewport()

static HRESULT WINAPI d3d_device1_NextViewport ( IDirect3DDevice *  iface, IDirect3DViewport *  viewport, IDirect3DViewport **  next, DWORD  flags  )

static

Definition at line 947 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport(viewport);
    IDirect3DViewport3 *res;
    HRESULT hr;
 
    TRACE("iface %p, viewport %p, next %p, flags %#x.\n",
            iface, viewport, next, flags);
 
    hr = d3d_device3_NextViewport(&device->IDirect3DDevice3_iface,
            &vp->IDirect3DViewport3_iface, &res, flags);
    *next = (IDirect3DViewport *)res;
    return hr;
}

d3d_device1_Pick()

static HRESULT WINAPI d3d_device1_Pick ( IDirect3DDevice *  iface, IDirect3DExecuteBuffer *  buffer, IDirect3DViewport *  viewport, DWORD  flags, D3DRECT *  rect  )

static

Definition at line 985 of file device.c.

{
    FIXME("iface %p, buffer %p, viewport %p, flags %#x, rect %s stub!\n",
            iface, buffer, viewport, flags, wine_dbgstr_rect((RECT *)rect));
 
    return D3D_OK;
}

d3d_device1_QueryInterface()

static HRESULT WINAPI d3d_device1_QueryInterface ( IDirect3DDevice *  iface, REFIID  riid, void **  out  )

static

Definition at line 168 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 
    return IUnknown_QueryInterface(device->outer_unknown, riid, out);
}

d3d_device1_Release()

static ULONG WINAPI d3d_device1_Release ( IDirect3DDevice *  iface )

static

Definition at line 360 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IUnknown_Release(device->outer_unknown);
}

d3d_device1_SetMatrix()

static HRESULT WINAPI d3d_device1_SetMatrix ( IDirect3DDevice *  iface, D3DMATRIXHANDLE  D3DMatHandle, D3DMATRIX *  D3DMatrix  )

static

Definition at line 1328 of file device.c.

{
    struct d3d_device *This = impl_from_IDirect3DDevice(iface);
    D3DMATRIX *m;
 
    TRACE("iface %p, matrix_handle %#x, matrix %p.\n", iface, D3DMatHandle, D3DMatrix);
 
    if (!D3DMatrix) return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
 
    m = ddraw_get_object(&This->handle_table, D3DMatHandle - 1, DDRAW_HANDLE_MATRIX);
    if (!m)
    {
        WARN("Invalid matrix handle.\n");
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    if (TRACE_ON(ddraw))
        dump_D3DMATRIX(D3DMatrix);
 
    *m = *D3DMatrix;
 
    if (D3DMatHandle == This->world)
        wined3d_device_set_transform(This->wined3d_device,
                WINED3D_TS_WORLD_MATRIX(0), (struct wined3d_matrix *)D3DMatrix);
 
    if (D3DMatHandle == This->view)
        wined3d_device_set_transform(This->wined3d_device,
                WINED3D_TS_VIEW, (struct wined3d_matrix *)D3DMatrix);
 
    if (D3DMatHandle == This->proj)
        wined3d_device_set_transform(This->wined3d_device,
                WINED3D_TS_PROJECTION, (struct wined3d_matrix *)D3DMatrix);
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

d3d_device1_SwapTextureHandles()

static HRESULT WINAPI d3d_device1_SwapTextureHandles ( IDirect3DDevice *  iface, IDirect3DTexture *  tex1, IDirect3DTexture *  tex2  )

static

Definition at line 565 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    struct ddraw_surface *surf1 = unsafe_impl_from_IDirect3DTexture(tex1);
    struct ddraw_surface *surf2 = unsafe_impl_from_IDirect3DTexture(tex2);
    IDirect3DTexture2 *t1 = surf1 ? &surf1->IDirect3DTexture2_iface : NULL;
    IDirect3DTexture2 *t2 = surf2 ? &surf2->IDirect3DTexture2_iface : NULL;
 
    TRACE("iface %p, tex1 %p, tex2 %p.\n", iface, tex1, tex2);
 
    return d3d_device2_SwapTextureHandles(&device->IDirect3DDevice2_iface, t1, t2);
}

d3d_device2_AddRef()

static ULONG WINAPI d3d_device2_AddRef ( IDirect3DDevice2 *  iface )

static

Definition at line 205 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IUnknown_AddRef(device->outer_unknown);
}

d3d_device2_AddViewport()

static HRESULT WINAPI d3d_device2_AddViewport ( IDirect3DDevice2 *  iface, IDirect3DViewport2 *  viewport  )

static

Definition at line 761 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport2(viewport);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    return d3d_device3_AddViewport(&device->IDirect3DDevice3_iface, &vp->IDirect3DViewport3_iface);
}

d3d_device2_Begin()

static HRESULT WINAPI d3d_device2_Begin ( IDirect3DDevice2 *  iface, D3DPRIMITIVETYPE  primitive_type, D3DVERTEXTYPE  vertex_type, DWORD  flags  )

static

Definition at line 2110 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    DWORD fvf;
 
    TRACE("iface %p, primitive_type %#x, vertex_type %#x, flags %#x.\n",
            iface, primitive_type, vertex_type, flags);
 
    switch (vertex_type)
    {
        case D3DVT_VERTEX: fvf = D3DFVF_VERTEX; break;
        case D3DVT_LVERTEX: fvf = D3DFVF_LVERTEX; break;
        case D3DVT_TLVERTEX: fvf = D3DFVF_TLVERTEX; break;
        default:
            ERR("Unexpected vertex type %#x.\n", vertex_type);
            return DDERR_INVALIDPARAMS;  /* Should never happen */
    };
 
    return d3d_device3_Begin(&device->IDirect3DDevice3_iface, primitive_type, fvf, flags);
}

d3d_device2_BeginIndexed()

static HRESULT WINAPI d3d_device2_BeginIndexed ( IDirect3DDevice2 *  iface, D3DPRIMITIVETYPE  primitive_type, D3DVERTEXTYPE  vertex_type, void *  vertices, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 2162 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    DWORD fvf;
 
    TRACE("iface %p, primitive_type %#x, vertex_type %#x, vertices %p, vertex_count %u, flags %#x stub!\n",
            iface, primitive_type, vertex_type, vertices, vertex_count, flags);
 
    switch (vertex_type)
    {
        case D3DVT_VERTEX: fvf = D3DFVF_VERTEX; break;
        case D3DVT_LVERTEX: fvf = D3DFVF_LVERTEX; break;
        case D3DVT_TLVERTEX: fvf = D3DFVF_TLVERTEX; break;
        default:
            ERR("Unexpected vertex type %#x.\n", vertex_type);
            return DDERR_INVALIDPARAMS;  /* Should never happen */
    };
 
    return d3d_device3_BeginIndexed(&device->IDirect3DDevice3_iface,
            primitive_type, fvf, vertices, vertex_count, flags);
}

d3d_device2_BeginScene()

static HRESULT WINAPI d3d_device2_BeginScene ( IDirect3DDevice2 *  iface )

static

Definition at line 1507 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IDirect3DDevice7_BeginScene(&device->IDirect3DDevice7_iface);
}

d3d_device2_DeleteViewport()

static HRESULT WINAPI d3d_device2_DeleteViewport ( IDirect3DDevice2 *  iface, IDirect3DViewport2 *  viewport  )

static

Definition at line 837 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport2(viewport);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    return d3d_device3_DeleteViewport(&device->IDirect3DDevice3_iface,
            vp ? &vp->IDirect3DViewport3_iface : NULL);
}

d3d_device2_DrawIndexedPrimitive()

static HRESULT WINAPI d3d_device2_DrawIndexedPrimitive ( IDirect3DDevice2 *  iface, D3DPRIMITIVETYPE  primitive_type, D3DVERTEXTYPE  vertex_type, void *  vertices, DWORD  vertex_count, WORD *  indices, DWORD  index_count, DWORD  flags  )

static

Definition at line 3805 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    DWORD fvf;
 
    TRACE("iface %p, primitive_type %#x, vertex_type %#x, vertices %p, vertex_count %u, "
            "indices %p, index_count %u, flags %#x.\n",
            iface, primitive_type, vertex_type, vertices, vertex_count, indices, index_count, flags);
 
    switch (vertex_type)
    {
        case D3DVT_VERTEX: fvf = D3DFVF_VERTEX; break;
        case D3DVT_LVERTEX: fvf = D3DFVF_LVERTEX; break;
        case D3DVT_TLVERTEX: fvf = D3DFVF_TLVERTEX; break;
        default:
            ERR("Unhandled vertex type %#x.\n", vertex_type);
            return DDERR_INVALIDPARAMS;  /* Should never happen */
    }
 
    return d3d_device3_DrawIndexedPrimitive(&device->IDirect3DDevice3_iface,
            primitive_type, fvf, vertices, vertex_count, indices, index_count, flags);
}

d3d_device2_DrawPrimitive()

static HRESULT WINAPI d3d_device2_DrawPrimitive ( IDirect3DDevice2 *  iface, D3DPRIMITIVETYPE  primitive_type, D3DVERTEXTYPE  vertex_type, void *  vertices, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 3603 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    DWORD fvf;
 
    TRACE("iface %p, primitive_type %#x, vertex_type %#x, vertices %p, vertex_count %u, flags %#x.\n",
            iface, primitive_type, vertex_type, vertices, vertex_count, flags);
 
    switch (vertex_type)
    {
        case D3DVT_VERTEX: fvf = D3DFVF_VERTEX; break;
        case D3DVT_LVERTEX: fvf = D3DFVF_LVERTEX; break;
        case D3DVT_TLVERTEX: fvf = D3DFVF_TLVERTEX; break;
        default:
            FIXME("Unhandled vertex type %#x.\n", vertex_type);
            return DDERR_INVALIDPARAMS;  /* Should never happen */
    }
 
    return d3d_device3_DrawPrimitive(&device->IDirect3DDevice3_iface,
            primitive_type, fvf, vertices, vertex_count, flags);
}

d3d_device2_End()

static HRESULT WINAPI d3d_device2_End ( IDirect3DDevice2 *  iface, DWORD  flags  )

static

Definition at line 3858 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, flags %#x.\n", iface, flags);
 
    return d3d_device3_End(&device->IDirect3DDevice3_iface, flags);
}

d3d_device2_EndScene()

static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device2_EndScene ( IDirect3DDevice2 *  iface )

static

Definition at line 1580 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IDirect3DDevice7_EndScene(&device->IDirect3DDevice7_iface);
}

d3d_device2_EnumTextureFormats()

static HRESULT WINAPI d3d_device2_EnumTextureFormats ( IDirect3DDevice2 *  iface, LPD3DENUMTEXTUREFORMATSCALLBACK  callback, void *  context  )

static

Definition at line 1178 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    struct wined3d_display_mode mode;
    HRESULT hr;
    unsigned int i;
 
    static const enum wined3d_format_id FormatList[] =
    {
        /* 16 bit */
        WINED3DFMT_B5G5R5X1_UNORM,
        WINED3DFMT_B5G5R5A1_UNORM,
        WINED3DFMT_B4G4R4A4_UNORM,
        WINED3DFMT_B5G6R5_UNORM,
        /* 32 bit */
        WINED3DFMT_B8G8R8X8_UNORM,
        WINED3DFMT_B8G8R8A8_UNORM,
        /* 8 bit */
        WINED3DFMT_B2G3R3_UNORM,
        WINED3DFMT_P8_UINT,
        /* FOURCC codes - Not in this version*/
    };
 
    TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
 
    if (!callback)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
 
    memset(&mode, 0, sizeof(mode));
    if (FAILED(hr = wined3d_get_adapter_display_mode(device->ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
    {
        wined3d_mutex_unlock();
        WARN("Cannot get the current adapter format\n");
        return hr;
    }
 
    for (i = 0; i < ARRAY_SIZE(FormatList); ++i)
    {
        if (wined3d_check_device_format(device->ddraw->wined3d, 0, WINED3D_DEVICE_TYPE_HAL,
                mode.format_id, WINED3DUSAGE_TEXTURE, WINED3D_RTYPE_TEXTURE_2D, FormatList[i]) == D3D_OK)
        {
            DDSURFACEDESC sdesc;
 
            memset(&sdesc, 0, sizeof(sdesc));
            sdesc.dwSize = sizeof(sdesc);
            sdesc.dwFlags = DDSD_PIXELFORMAT | DDSD_CAPS;
            sdesc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
            sdesc.ddpfPixelFormat.dwSize = sizeof(sdesc.ddpfPixelFormat);
            ddrawformat_from_wined3dformat(&sdesc.ddpfPixelFormat, FormatList[i]);
 
            TRACE("Enumerating WineD3DFormat %d\n", FormatList[i]);
            hr = callback(&sdesc, context);
            if(hr != DDENUMRET_OK)
            {
                TRACE("Format enumeration cancelled by application\n");
                wined3d_mutex_unlock();
                return D3D_OK;
            }
        }
    }
    TRACE("End of enumeration\n");
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device1_EnumTextureFormats().

d3d_device2_GetCaps()

static HRESULT WINAPI d3d_device2_GetCaps ( IDirect3DDevice2 *  iface, D3DDEVICEDESC *  hw_desc, D3DDEVICEDESC *  hel_desc  )

static

Definition at line 509 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, hw_desc %p, hel_desc %p.\n", iface, hw_desc, hel_desc);
 
    return d3d_device3_GetCaps(&device->IDirect3DDevice3_iface, hw_desc, hel_desc);
}

d3d_device2_GetClipStatus()

static HRESULT WINAPI d3d_device2_GetClipStatus ( IDirect3DDevice2 *  iface, D3DCLIPSTATUS *  clip_status  )

static

Definition at line 3936 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, clip_status %p.\n", iface, clip_status);
 
    return IDirect3DDevice7_GetClipStatus(&device->IDirect3DDevice7_iface, clip_status);
}

d3d_device2_GetCurrentViewport()

static HRESULT WINAPI d3d_device2_GetCurrentViewport ( IDirect3DDevice2 *  iface, IDirect3DViewport2 **  viewport  )

static

Definition at line 1788 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    return d3d_device3_GetCurrentViewport(&device->IDirect3DDevice3_iface,
            (IDirect3DViewport3 **)viewport);
}

d3d_device2_GetDirect3D()

static HRESULT WINAPI d3d_device2_GetDirect3D ( IDirect3DDevice2 *  iface, IDirect3D2 **  d3d  )

static

Definition at line 1644 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, d3d %p.\n", iface, d3d);
 
    if (!d3d)
        return DDERR_INVALIDPARAMS;
 
    *d3d = &device->ddraw->IDirect3D2_iface;
    IDirect3D2_AddRef(*d3d);
 
    TRACE("Returning interface %p.\n", *d3d);
    return D3D_OK;
}

d3d_device2_GetLightState()

static HRESULT WINAPI d3d_device2_GetLightState ( IDirect3DDevice2 *  iface, D3DLIGHTSTATETYPE  state, DWORD *  value  )

static

Definition at line 3105 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
 
    return d3d_device3_GetLightState(&device->IDirect3DDevice3_iface, state, value);
}

d3d_device2_GetRenderState()

static HRESULT WINAPI d3d_device2_GetRenderState ( IDirect3DDevice2 *  iface, D3DRENDERSTATETYPE  state, DWORD *  value  )

static

Definition at line 2534 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
 
    return IDirect3DDevice3_GetRenderState(&device->IDirect3DDevice3_iface, state, value);
}

d3d_device2_GetRenderTarget()

static HRESULT WINAPI d3d_device2_GetRenderTarget ( IDirect3DDevice2 *  iface, IDirectDrawSurface **  RenderTarget  )

static

Definition at line 2052 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    IDirectDrawSurface7 *RenderTarget7;
    struct ddraw_surface *RenderTargetImpl;
    HRESULT hr;
 
    TRACE("iface %p, target %p.\n", iface, RenderTarget);
 
    if(!RenderTarget)
        return DDERR_INVALIDPARAMS;
 
    hr = d3d_device7_GetRenderTarget(&device->IDirect3DDevice7_iface, &RenderTarget7);
    if(hr != D3D_OK) return hr;
    RenderTargetImpl = impl_from_IDirectDrawSurface7(RenderTarget7);
    *RenderTarget = &RenderTargetImpl->IDirectDrawSurface_iface;
    IDirectDrawSurface_AddRef(*RenderTarget);
    IDirectDrawSurface7_Release(RenderTarget7);
    return D3D_OK;
}

d3d_device2_GetStats()

static HRESULT WINAPI d3d_device2_GetStats ( IDirect3DDevice2 *  iface, D3DSTATS *  stats  )

static

Definition at line 614 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, stats %p.\n", iface, stats);
 
    return d3d_device3_GetStats(&device->IDirect3DDevice3_iface, stats);
}

d3d_device2_GetTransform()

static HRESULT WINAPI d3d_device2_GetTransform ( IDirect3DDevice2 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3321 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    return IDirect3DDevice3_GetTransform(&device->IDirect3DDevice3_iface, state, matrix);
}

d3d_device2_Index()

static HRESULT WINAPI d3d_device2_Index ( IDirect3DDevice2 *  iface, WORD  index  )

static

Definition at line 2262 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, index %#x.\n", iface, index);
 
    return d3d_device3_Index(&device->IDirect3DDevice3_iface, index);
}

d3d_device2_MultiplyTransform()

static HRESULT WINAPI d3d_device2_MultiplyTransform ( IDirect3DDevice2 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3427 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    return IDirect3DDevice3_MultiplyTransform(&device->IDirect3DDevice3_iface, state, matrix);
}

d3d_device2_NextViewport()

static HRESULT WINAPI d3d_device2_NextViewport ( IDirect3DDevice2 *  iface, IDirect3DViewport2 *  viewport, IDirect3DViewport2 **  next, DWORD  flags  )

static

Definition at line 930 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport2(viewport);
    IDirect3DViewport3 *res;
    HRESULT hr;
 
    TRACE("iface %p, viewport %p, next %p, flags %#x.\n",
            iface, viewport, next, flags);
 
    hr = d3d_device3_NextViewport(&device->IDirect3DDevice3_iface,
            &vp->IDirect3DViewport3_iface, &res, flags);
    *next = (IDirect3DViewport2 *)res;
    return hr;
}

d3d_device2_QueryInterface()

static HRESULT WINAPI d3d_device2_QueryInterface ( IDirect3DDevice2 *  iface, REFIID  riid, void **  out  )

static

Definition at line 159 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 
    return IUnknown_QueryInterface(device->outer_unknown, riid, out);
}

d3d_device2_Release()

static ULONG WINAPI d3d_device2_Release ( IDirect3DDevice2 *  iface )

static

Definition at line 351 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IUnknown_Release(device->outer_unknown);
}

d3d_device2_SetClipStatus()

static HRESULT WINAPI d3d_device2_SetClipStatus ( IDirect3DDevice2 *  iface, D3DCLIPSTATUS *  clip_status  )

static

Definition at line 3899 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, clip_status %p.\n", iface, clip_status);
 
    return IDirect3DDevice7_SetClipStatus(&device->IDirect3DDevice7_iface, clip_status);
}

d3d_device2_SetCurrentViewport()

static HRESULT WINAPI d3d_device2_SetCurrentViewport ( IDirect3DDevice2 *  iface, IDirect3DViewport2 *  viewport  )

static

Definition at line 1740 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport2(viewport);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    return d3d_device3_SetCurrentViewport(&device->IDirect3DDevice3_iface,
            vp ? &vp->IDirect3DViewport3_iface : NULL);
}

d3d_device2_SetLightState()

static HRESULT WINAPI d3d_device2_SetLightState ( IDirect3DDevice2 *  iface, D3DLIGHTSTATETYPE  state, DWORD  value  )

static

Definition at line 3013 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
 
    return d3d_device3_SetLightState(&device->IDirect3DDevice3_iface, state, value);
}

d3d_device2_SetRenderState()

static HRESULT WINAPI d3d_device2_SetRenderState ( IDirect3DDevice2 *  iface, D3DRENDERSTATETYPE  state, DWORD  value  )

static

Definition at line 2897 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
 
    return IDirect3DDevice3_SetRenderState(&device->IDirect3DDevice3_iface, state, value);
}

d3d_device2_SetRenderTarget()

static HRESULT WINAPI d3d_device2_SetRenderTarget ( IDirect3DDevice2 *  iface, IDirectDrawSurface *  target, DWORD  flags  )

static

Definition at line 1948 of file device.c.

{
    struct ddraw_surface *target_impl = unsafe_impl_from_IDirectDrawSurface(target);
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    HRESULT hr;
 
    TRACE("iface %p, target %p, flags %#x.\n", iface, target, flags);
 
    wined3d_mutex_lock();
 
    if (!validate_surface_palette(target_impl))
    {
        WARN("Surface %p has an indexed pixel format, but no palette.\n", target_impl);
        wined3d_mutex_unlock();
        return DDERR_INVALIDCAPS;
    }
 
    if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
    {
        WARN("Surface %p is not a render target.\n", target_impl);
        wined3d_mutex_unlock();
        return DDERR_INVALIDCAPS;
    }
 
    if (target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
    {
        WARN("Surface %p is a depth buffer.\n", target_impl);
        IUnknown_Release(device->rt_iface);
        device->rt_iface = (IUnknown *)target;
        wined3d_mutex_unlock();
        return DDERR_INVALIDPIXELFORMAT;
    }
 
    if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
    {
        WARN("Surface %p is not in video memory.\n", target_impl);
        IDirectDrawSurface_AddRef(target);
        IUnknown_Release(device->rt_iface);
        device->rt_iface = (IUnknown *)target;
        wined3d_mutex_unlock();
        return D3D_OK;
    }
 
    hr = d3d_device_set_render_target(device, target_impl, (IUnknown *)target);
    wined3d_mutex_unlock();
    return hr;
}

d3d_device2_SetTransform()

static HRESULT WINAPI d3d_device2_SetTransform ( IDirect3DDevice2 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3218 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    return IDirect3DDevice3_SetTransform(&device->IDirect3DDevice3_iface, state, matrix);
}

d3d_device2_SwapTextureHandles()

static HRESULT WINAPI d3d_device2_SwapTextureHandles ( IDirect3DDevice2 *  iface, IDirect3DTexture2 *  tex1, IDirect3DTexture2 *  tex2  )

static

Definition at line 541 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    struct ddraw_surface *surf1 = unsafe_impl_from_IDirect3DTexture2(tex1);
    struct ddraw_surface *surf2 = unsafe_impl_from_IDirect3DTexture2(tex2);
    DWORD h1, h2;
 
    TRACE("iface %p, tex1 %p, tex2 %p.\n", iface, tex1, tex2);
 
    wined3d_mutex_lock();
 
    h1 = surf1->Handle - 1;
    h2 = surf2->Handle - 1;
    device->handle_table.entries[h1].object = surf2;
    device->handle_table.entries[h2].object = surf1;
    surf2->Handle = h1 + 1;
    surf1->Handle = h2 + 1;
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device1_SwapTextureHandles().

d3d_device2_Vertex()

static HRESULT WINAPI d3d_device2_Vertex ( IDirect3DDevice2 *  iface, void *  vertex  )

static

Definition at line 2233 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, vertex %p.\n", iface, vertex);
 
    return d3d_device3_Vertex(&device->IDirect3DDevice3_iface, vertex);
}

d3d_device3_AddRef()

static ULONG WINAPI d3d_device3_AddRef ( IDirect3DDevice3 *  iface )

static

Definition at line 196 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IUnknown_AddRef(device->outer_unknown);
}

d3d_device3_AddViewport()

static HRESULT WINAPI d3d_device3_AddViewport ( IDirect3DDevice3 *  iface, IDirect3DViewport3 *  viewport  )

static

Definition at line 740 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(viewport);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    /* Sanity check */
    if(!vp)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    IDirect3DViewport3_AddRef(viewport);
    list_add_head(&device->viewport_list, &vp->entry);
    /* Viewport must be usable for Clear() after AddViewport, so set active_device here. */
    vp->active_device = device;
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device1_AddViewport(), and d3d_device2_AddViewport().

d3d_device3_Begin()

static HRESULT WINAPI d3d_device3_Begin ( IDirect3DDevice3 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, DWORD  flags  )

static

Definition at line 2091 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, fvf %#x, flags %#x.\n",
            iface, primitive_type, fvf, flags);
 
    wined3d_mutex_lock();
    device->primitive_type = primitive_type;
    device->vertex_type = fvf;
    device->render_flags = flags;
    device->vertex_size = get_flexible_vertex_size(device->vertex_type);
    device->nb_vertices = 0;
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device2_Begin().

d3d_device3_BeginIndexed()

static HRESULT WINAPI d3d_device3_BeginIndexed ( IDirect3DDevice3 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 2151 of file device.c.

{
    FIXME("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, flags %#x stub!\n",
            iface, primitive_type, fvf, vertices, vertex_count, flags);
 
    return D3D_OK;
}

Referenced by d3d_device2_BeginIndexed().

d3d_device3_BeginScene()

static HRESULT WINAPI d3d_device3_BeginScene ( IDirect3DDevice3 *  iface )

static

Definition at line 1498 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IDirect3DDevice7_BeginScene(&device->IDirect3DDevice7_iface);
}

d3d_device3_ComputeSphereVisibility()

static HRESULT WINAPI d3d_device3_ComputeSphereVisibility ( IDirect3DDevice3 *  iface, D3DVECTOR *  centers, D3DVALUE *  radii, DWORD  sphere_count, DWORD  flags, DWORD *  return_values  )

static

Definition at line 4625 of file device.c.

{
    static const DWORD enabled_planes = 0x3f;
    struct wined3d_vec4 plane[6];
    unsigned int i, j;
 
    TRACE("iface %p, centers %p, radii %p, sphere_count %u, flags %#x, return_values %p.\n",
            iface, centers, radii, sphere_count, flags, return_values);
 
    prepare_clip_space_planes(impl_from_IDirect3DDevice3(iface), plane);
 
    compute_sphere_visibility(plane, enabled_planes, TRUE, centers, radii, sphere_count, return_values);
    for (i = 0; i < sphere_count; ++i)
    {
        BOOL intersect_frustum = FALSE, outside_frustum = FALSE;
        DWORD d3d7_result = return_values[i];
 
        return_values[i] = 0;
 
        for (j = 0; j < 6; ++j)
        {
            DWORD clip = (d3d7_result >> j) & (D3DSTATUS_CLIPUNIONLEFT | D3DSTATUS_CLIPINTERSECTIONLEFT);
 
            if (clip == D3DSTATUS_CLIPUNIONLEFT)
            {
                return_values[i] |= D3DVIS_INTERSECT_LEFT << j * 2;
                intersect_frustum = TRUE;
            }
            else if (clip)
            {
                return_values[i] |= D3DVIS_OUTSIDE_LEFT << j * 2;
                outside_frustum = TRUE;
            }
        }
        if (outside_frustum)
            return_values[i] |= D3DVIS_OUTSIDE_FRUSTUM;
        else if (intersect_frustum)
            return_values[i] |= D3DVIS_INTERSECT_FRUSTUM;
    }
    return D3D_OK;
}

d3d_device3_DeleteViewport()

static HRESULT WINAPI d3d_device3_DeleteViewport ( IDirect3DDevice3 *  iface, IDirect3DViewport3 *  viewport  )

static

Definition at line 798 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(viewport);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    if (!vp)
    {
        WARN("NULL viewport, returning DDERR_INVALIDPARAMS\n");
        return DDERR_INVALIDPARAMS;
    }
 
    wined3d_mutex_lock();
 
    if (vp->active_device != device)
    {
        WARN("Viewport %p active device is %p.\n", vp, vp->active_device);
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    if (device->current_viewport == vp)
    {
        TRACE("Deleting current viewport, unsetting and releasing\n");
        IDirect3DViewport3_Release(viewport);
        device->current_viewport = NULL;
    }
 
    vp->active_device = NULL;
    list_remove(&vp->entry);
 
    IDirect3DViewport3_Release(viewport);
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device1_DeleteViewport(), and d3d_device2_DeleteViewport().

d3d_device3_DrawIndexedPrimitive()

static HRESULT WINAPI d3d_device3_DrawIndexedPrimitive ( IDirect3DDevice3 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, WORD *  indices, DWORD  index_count, DWORD  flags  )

static

Definition at line 3789 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, "
            "indices %p, index_count %u, flags %#x.\n",
            iface, primitive_type, fvf, vertices, vertex_count, indices, index_count, flags);
 
    setup_lighting(device, fvf, flags);
 
    return IDirect3DDevice7_DrawIndexedPrimitive(&device->IDirect3DDevice7_iface,
            primitive_type, fvf, vertices, vertex_count, indices, index_count, flags);
}

Referenced by d3d_device2_DrawIndexedPrimitive().

d3d_device3_DrawIndexedPrimitiveStrided()

static HRESULT WINAPI d3d_device3_DrawIndexedPrimitiveStrided ( IDirect3DDevice3 *  iface, D3DPRIMITIVETYPE  PrimitiveType, DWORD  VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *  D3DDrawPrimStrideData, DWORD  VertexCount, WORD *  Indices, DWORD  IndexCount, DWORD  Flags  )

static

Definition at line 4238 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, FVF %#x, strided_data %p, vertex_count %u, indices %p, index_count %u, flags %#x.\n",
            iface, PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
 
    setup_lighting(device, VertexType, Flags);
 
    return IDirect3DDevice7_DrawIndexedPrimitiveStrided(&device->IDirect3DDevice7_iface,
            PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
}

d3d_device3_DrawIndexedPrimitiveVB()

static HRESULT WINAPI d3d_device3_DrawIndexedPrimitiveVB ( IDirect3DDevice3 *  iface, D3DPRIMITIVETYPE  PrimitiveType, IDirect3DVertexBuffer *  D3DVertexBuf, WORD *  Indices, DWORD  IndexCount, DWORD  Flags  )

static

Definition at line 4466 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    struct d3d_vertex_buffer *vb = unsafe_impl_from_IDirect3DVertexBuffer7((IDirect3DVertexBuffer7 *)D3DVertexBuf);
 
    TRACE("iface %p, primitive_type %#x, vb %p, indices %p, index_count %u, flags %#x.\n",
            iface, PrimitiveType, D3DVertexBuf, Indices, IndexCount, Flags);
 
    setup_lighting(device, vb->fvf, Flags);
 
    return IDirect3DDevice7_DrawIndexedPrimitiveVB(&device->IDirect3DDevice7_iface, PrimitiveType,
            &vb->IDirect3DVertexBuffer7_iface, 0, IndexCount, Indices, IndexCount, Flags);
}

d3d_device3_DrawPrimitive()

static HRESULT WINAPI d3d_device3_DrawPrimitive ( IDirect3DDevice3 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 3588 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, flags %#x.\n",
            iface, primitive_type, fvf, vertices, vertex_count, flags);
 
    setup_lighting(device, fvf, flags);
 
    return IDirect3DDevice7_DrawPrimitive(&device->IDirect3DDevice7_iface,
            primitive_type, fvf, vertices, vertex_count, flags);
}

Referenced by d3d_device2_DrawPrimitive(), and d3d_device3_End().

d3d_device3_DrawPrimitiveStrided()

static HRESULT WINAPI d3d_device3_DrawPrimitiveStrided ( IDirect3DDevice3 *  iface, D3DPRIMITIVETYPE  PrimitiveType, DWORD  VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *  D3DDrawPrimStrideData, DWORD  VertexCount, DWORD  Flags  )

static

Definition at line 4101 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, FVF %#x, strided_data %p, vertex_count %u, flags %#x.\n",
            iface, PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
 
    setup_lighting(device, VertexType, Flags);
 
    return IDirect3DDevice7_DrawPrimitiveStrided(&device->IDirect3DDevice7_iface,
            PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
}

d3d_device3_DrawPrimitiveVB()

static HRESULT WINAPI d3d_device3_DrawPrimitiveVB ( IDirect3DDevice3 *  iface, D3DPRIMITIVETYPE  PrimitiveType, IDirect3DVertexBuffer *  D3DVertexBuf, DWORD  StartVertex, DWORD  NumVertices, DWORD  Flags  )

static

Definition at line 4330 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    struct d3d_vertex_buffer *vb = unsafe_impl_from_IDirect3DVertexBuffer7((IDirect3DVertexBuffer7 *)D3DVertexBuf);
 
    TRACE("iface %p, primitive_type %#x, vb %p, start_vertex %u, vertex_count %u, flags %#x.\n",
            iface, PrimitiveType, D3DVertexBuf, StartVertex, NumVertices, Flags);
 
    setup_lighting(device, vb->fvf, Flags);
 
    return IDirect3DDevice7_DrawPrimitiveVB(&device->IDirect3DDevice7_iface,
            PrimitiveType, &vb->IDirect3DVertexBuffer7_iface, StartVertex, NumVertices, Flags);
}

d3d_device3_End()

static HRESULT WINAPI d3d_device3_End ( IDirect3DDevice3 *  iface, DWORD  flags  )

static

Definition at line 3848 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, flags %#x.\n", iface, flags);
 
    return d3d_device3_DrawPrimitive(&device->IDirect3DDevice3_iface, device->primitive_type,
            device->vertex_type, device->sysmem_vertex_buffer, device->nb_vertices, device->render_flags);
}

Referenced by d3d_device2_End().

d3d_device3_EndScene()

static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device3_EndScene ( IDirect3DDevice3 *  iface )

static

Definition at line 1571 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IDirect3DDevice7_EndScene(&device->IDirect3DDevice7_iface);
}

d3d_device3_EnumTextureFormats()

static HRESULT WINAPI d3d_device3_EnumTextureFormats ( IDirect3DDevice3 *  iface, LPD3DENUMPIXELFORMATSCALLBACK  callback, void *  context  )

static

Definition at line 1158 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
 
    return IDirect3DDevice7_EnumTextureFormats(&device->IDirect3DDevice7_iface, callback, context);
}

d3d_device3_GetCaps()

static HRESULT WINAPI d3d_device3_GetCaps ( IDirect3DDevice3 *  iface, D3DDEVICEDESC *  HWDesc, D3DDEVICEDESC *  HelDesc  )

static

Definition at line 469 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    D3DDEVICEDESC7 desc7;
    D3DDEVICEDESC desc1;
    HRESULT hr;
 
    TRACE("iface %p, hw_desc %p, hel_desc %p.\n", iface, HWDesc, HelDesc);
 
    if (!HWDesc)
    {
        WARN("HWDesc is NULL, returning DDERR_INVALIDPARAMS.\n");
        return DDERR_INVALIDPARAMS;
    }
    if (!check_d3ddevicedesc_size(HWDesc->dwSize))
    {
        WARN("HWDesc->dwSize is %u, returning DDERR_INVALIDPARAMS.\n", HWDesc->dwSize);
        return DDERR_INVALIDPARAMS;
    }
    if (!HelDesc)
    {
        WARN("HelDesc is NULL, returning DDERR_INVALIDPARAMS.\n");
        return DDERR_INVALIDPARAMS;
    }
    if (!check_d3ddevicedesc_size(HelDesc->dwSize))
    {
        WARN("HelDesc->dwSize is %u, returning DDERR_INVALIDPARAMS.\n", HelDesc->dwSize);
        return DDERR_INVALIDPARAMS;
    }
 
    if (FAILED(hr = ddraw_get_d3dcaps(device->ddraw, &desc7)))
        return hr;
 
    ddraw_d3dcaps1_from_7(&desc1, &desc7);
    DD_STRUCT_COPY_BYSIZE(HWDesc, &desc1);
    DD_STRUCT_COPY_BYSIZE(HelDesc, &desc1);
    return D3D_OK;
}

Referenced by d3d_device1_GetCaps(), and d3d_device2_GetCaps().

d3d_device3_GetClipStatus()

static HRESULT WINAPI d3d_device3_GetClipStatus ( IDirect3DDevice3 *  iface, D3DCLIPSTATUS *  clip_status  )

static

Definition at line 3927 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, clip_status %p.\n", iface, clip_status);
 
    return IDirect3DDevice7_GetClipStatus(&device->IDirect3DDevice7_iface, clip_status);
}

d3d_device3_GetCurrentViewport()

static HRESULT WINAPI d3d_device3_GetCurrentViewport ( IDirect3DDevice3 *  iface, IDirect3DViewport3 **  viewport  )

static

Definition at line 1766 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    wined3d_mutex_lock();
    if (!device->current_viewport)
    {
        wined3d_mutex_unlock();
        WARN("No current viewport, returning D3DERR_NOCURRENTVIEWPORT\n");
        return D3DERR_NOCURRENTVIEWPORT;
    }
 
    *viewport = &device->current_viewport->IDirect3DViewport3_iface;
    IDirect3DViewport3_AddRef(*viewport);
 
    TRACE("Returning interface %p.\n", *viewport);
    wined3d_mutex_unlock();
    return D3D_OK;
}

Referenced by d3d_device2_GetCurrentViewport().

d3d_device3_GetDirect3D()

static HRESULT WINAPI d3d_device3_GetDirect3D ( IDirect3DDevice3 *  iface, IDirect3D3 **  d3d  )

static

Definition at line 1628 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, d3d %p.\n", iface, d3d);
 
    if (!d3d)
        return DDERR_INVALIDPARAMS;
 
    *d3d = &device->ddraw->IDirect3D3_iface;
    IDirect3D3_AddRef(*d3d);
 
    TRACE("Returning interface %p.\n", *d3d);
    return D3D_OK;
}

d3d_device3_GetLightState()

static HRESULT WINAPI d3d_device3_GetLightState ( IDirect3DDevice3 *  iface, D3DLIGHTSTATETYPE  state, DWORD *  value  )

static

Definition at line 3041 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    HRESULT hr;
 
    TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
 
    if (!state || (state > D3DLIGHTSTATE_COLORVERTEX))
    {
        TRACE("Unexpected Light State Type\n");
        return DDERR_INVALIDPARAMS;
    }
 
    if (!value)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    if (state == D3DLIGHTSTATE_MATERIAL)
    {
        *value = device->material;
    }
    else if (state == D3DLIGHTSTATE_COLORMODEL)
    {
        *value = D3DCOLOR_RGB;
    }
    else
    {
        D3DRENDERSTATETYPE rs;
        switch (state)
        {
            case D3DLIGHTSTATE_AMBIENT:       /* 2 */
                rs = D3DRENDERSTATE_AMBIENT;
                break;
            case D3DLIGHTSTATE_FOGMODE:       /* 4 */
                rs = D3DRENDERSTATE_FOGVERTEXMODE;
                break;
            case D3DLIGHTSTATE_FOGSTART:      /* 5 */
                rs = D3DRENDERSTATE_FOGSTART;
                break;
            case D3DLIGHTSTATE_FOGEND:        /* 6 */
                rs = D3DRENDERSTATE_FOGEND;
                break;
            case D3DLIGHTSTATE_FOGDENSITY:    /* 7 */
                rs = D3DRENDERSTATE_FOGDENSITY;
                break;
            case D3DLIGHTSTATE_COLORVERTEX:   /* 8 */
                rs = D3DRENDERSTATE_COLORVERTEX;
                break;
            default:
                FIXME("Unhandled D3DLIGHTSTATETYPE %#x.\n", state);
                wined3d_mutex_unlock();
                return DDERR_INVALIDPARAMS;
        }
 
        hr = IDirect3DDevice7_GetRenderState(&device->IDirect3DDevice7_iface, rs, value);
        wined3d_mutex_unlock();
        return hr;
    }
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device2_GetLightState().

d3d_device3_GetRenderState()

static HRESULT WINAPI d3d_device3_GetRenderState ( IDirect3DDevice3 *  iface, D3DRENDERSTATETYPE  state, DWORD *  value  )

static

Definition at line 2432 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
 
    switch (state)
    {
        case D3DRENDERSTATE_TEXTUREHANDLE:
        {
            /* This state is wrapped to SetTexture in SetRenderState, so
             * it has to be wrapped to GetTexture here. */
            struct wined3d_texture *tex = NULL;
            *value = 0;
 
            wined3d_mutex_lock();
            if ((tex = wined3d_device_get_texture(device->wined3d_device, 0)))
            {
                /* The parent of the texture is the IDirectDrawSurface7
                 * interface of the ddraw surface. */
                struct ddraw_texture *parent = wined3d_texture_get_parent(tex);
                if (parent)
                    *value = parent->root->Handle;
            }
            wined3d_mutex_unlock();
 
            return D3D_OK;
        }
 
        case D3DRENDERSTATE_TEXTUREMAPBLEND:
        {
            /* D3DRENDERSTATE_TEXTUREMAPBLEND is mapped to texture state stages in SetRenderState; reverse
               the mapping to get the value. */
            DWORD colorop, colorarg1, colorarg2;
            DWORD alphaop, alphaarg1, alphaarg2;
 
            wined3d_mutex_lock();
 
            device->legacyTextureBlending = TRUE;
 
            colorop = wined3d_device_get_texture_stage_state(device->wined3d_device, 0, WINED3D_TSS_COLOR_OP);
            colorarg1 = wined3d_device_get_texture_stage_state(device->wined3d_device, 0, WINED3D_TSS_COLOR_ARG1);
            colorarg2 = wined3d_device_get_texture_stage_state(device->wined3d_device, 0, WINED3D_TSS_COLOR_ARG2);
            alphaop = wined3d_device_get_texture_stage_state(device->wined3d_device, 0, WINED3D_TSS_ALPHA_OP);
            alphaarg1 = wined3d_device_get_texture_stage_state(device->wined3d_device, 0, WINED3D_TSS_ALPHA_ARG1);
            alphaarg2 = wined3d_device_get_texture_stage_state(device->wined3d_device, 0, WINED3D_TSS_ALPHA_ARG2);
 
            if (colorop == WINED3D_TOP_SELECT_ARG1 && colorarg1 == WINED3DTA_TEXTURE
                    && alphaop == WINED3D_TOP_SELECT_ARG1 && alphaarg1 == WINED3DTA_TEXTURE)
                *value = D3DTBLEND_DECAL;
            else if (colorop == WINED3D_TOP_SELECT_ARG1 && colorarg1 == WINED3DTA_TEXTURE
                    && alphaop == WINED3D_TOP_MODULATE
                    && alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT)
                *value = D3DTBLEND_DECALALPHA;
            else if (colorop == WINED3D_TOP_MODULATE
                    && colorarg1 == WINED3DTA_TEXTURE && colorarg2 == WINED3DTA_CURRENT
                    && alphaop == WINED3D_TOP_MODULATE
                    && alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT)
                *value = D3DTBLEND_MODULATEALPHA;
            else
            {
                struct wined3d_texture *tex = NULL;
                BOOL tex_alpha = FALSE;
                DDPIXELFORMAT ddfmt;
 
                if ((tex = wined3d_device_get_texture(device->wined3d_device, 0)))
                {
                    struct wined3d_resource_desc desc;
 
                    wined3d_resource_get_desc(wined3d_texture_get_resource(tex), &desc);
                    ddfmt.dwSize = sizeof(ddfmt);
                    ddrawformat_from_wined3dformat(&ddfmt, desc.format);
                    if (ddfmt.u5.dwRGBAlphaBitMask)
                        tex_alpha = TRUE;
                }
 
                if (!(colorop == WINED3D_TOP_MODULATE
                        && colorarg1 == WINED3DTA_TEXTURE && colorarg2 == WINED3DTA_CURRENT
                        && alphaop == (tex_alpha ? WINED3D_TOP_SELECT_ARG1 : WINED3D_TOP_SELECT_ARG2)
                        && alphaarg1 == WINED3DTA_TEXTURE && alphaarg2 == WINED3DTA_CURRENT))
                    ERR("Unexpected texture stage state setup, returning D3DTBLEND_MODULATE - likely erroneous.\n");
 
                *value = D3DTBLEND_MODULATE;
            }
 
            wined3d_mutex_unlock();
 
            return D3D_OK;
        }
 
        case D3DRENDERSTATE_LIGHTING:
        case D3DRENDERSTATE_NORMALIZENORMALS:
        case D3DRENDERSTATE_LOCALVIEWER:
            *value = 0xffffffff;
            return D3D_OK;
 
        default:
            return IDirect3DDevice7_GetRenderState(&device->IDirect3DDevice7_iface, state, value);
    }
}

d3d_device3_GetRenderTarget()

static HRESULT WINAPI d3d_device3_GetRenderTarget ( IDirect3DDevice3 *  iface, IDirectDrawSurface4 **  RenderTarget  )

static

Definition at line 2031 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    IDirectDrawSurface7 *RenderTarget7;
    struct ddraw_surface *RenderTargetImpl;
    HRESULT hr;
 
    TRACE("iface %p, target %p.\n", iface, RenderTarget);
 
    if(!RenderTarget)
        return DDERR_INVALIDPARAMS;
 
    hr = d3d_device7_GetRenderTarget(&device->IDirect3DDevice7_iface, &RenderTarget7);
    if(hr != D3D_OK) return hr;
    RenderTargetImpl = impl_from_IDirectDrawSurface7(RenderTarget7);
    *RenderTarget = &RenderTargetImpl->IDirectDrawSurface4_iface;
    IDirectDrawSurface4_AddRef(*RenderTarget);
    IDirectDrawSurface7_Release(RenderTarget7);
    return D3D_OK;
}

d3d_device3_GetStats()

static HRESULT WINAPI d3d_device3_GetStats ( IDirect3DDevice3 *  iface, D3DSTATS *  Stats  )

static

Definition at line 597 of file device.c.

{
    FIXME("iface %p, stats %p stub!\n", iface, Stats);
 
    if(!Stats)
        return DDERR_INVALIDPARAMS;
 
    /* Fill the Stats with 0 */
    Stats->dwTrianglesDrawn = 0;
    Stats->dwLinesDrawn = 0;
    Stats->dwPointsDrawn = 0;
    Stats->dwSpansDrawn = 0;
    Stats->dwVerticesProcessed = 0;
 
    return D3D_OK;
}

Referenced by d3d_device1_GetStats(), and d3d_device2_GetStats().

d3d_device3_GetTexture()

static HRESULT WINAPI d3d_device3_GetTexture ( IDirect3DDevice3 *  iface, DWORD  stage, IDirect3DTexture2 **  Texture2  )

static

Definition at line 4733 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    struct ddraw_surface *ret_val_impl;
    HRESULT ret;
    IDirectDrawSurface7 *ret_val;
 
    TRACE("iface %p, stage %u, texture %p.\n", iface, stage, Texture2);
 
    ret = IDirect3DDevice7_GetTexture(&device->IDirect3DDevice7_iface, stage, &ret_val);
 
    ret_val_impl = unsafe_impl_from_IDirectDrawSurface7(ret_val);
    *Texture2 = ret_val_impl ? &ret_val_impl->IDirect3DTexture2_iface : NULL;
 
    TRACE("Returning texture %p.\n", *Texture2);
 
    return ret;
}

d3d_device3_GetTextureStageState()

static HRESULT WINAPI d3d_device3_GetTextureStageState ( IDirect3DDevice3 *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  state, DWORD *  value  )

static

Definition at line 5022 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, stage %u, state %#x, value %p.\n",
            iface, stage, state, value);
 
    return IDirect3DDevice7_GetTextureStageState(&device->IDirect3DDevice7_iface, stage, state, value);
}

d3d_device3_GetTransform()

static HRESULT WINAPI d3d_device3_GetTransform ( IDirect3DDevice3 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3300 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    if (!matrix)
        return DDERR_INVALIDPARAMS;
 
    if (state == D3DTRANSFORMSTATE_PROJECTION)
    {
        wined3d_mutex_lock();
        *matrix = device->legacy_projection;
        wined3d_mutex_unlock();
        return DD_OK;
    }
 
    return IDirect3DDevice7_GetTransform(&device->IDirect3DDevice7_iface, state, matrix);
}

d3d_device3_Index()

static HRESULT WINAPI d3d_device3_Index ( IDirect3DDevice3 *  iface, WORD  index  )

static

Definition at line 2255 of file device.c.

{
    FIXME("iface %p, index %#x stub!\n", iface, index);
 
    return D3D_OK;
}

Referenced by d3d_device2_Index().

d3d_device3_MultiplyTransform()

static HRESULT WINAPI d3d_device3_MultiplyTransform ( IDirect3DDevice3 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3402 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    if (state == D3DTRANSFORMSTATE_PROJECTION)
    {
        D3DMATRIX projection, tmp;
 
        wined3d_mutex_lock();
        multiply_matrix(&tmp, &device->legacy_projection, matrix);
        multiply_matrix(&projection, &device->legacy_clipspace, &tmp);
        wined3d_device_set_transform(device->wined3d_device,
                WINED3D_TS_PROJECTION, (struct wined3d_matrix *)&projection);
        device->legacy_projection = tmp;
        wined3d_mutex_unlock();
 
        return D3D_OK;
    }
 
    return IDirect3DDevice7_MultiplyTransform(&device->IDirect3DDevice7_iface, state, matrix);
}

d3d_device3_NextViewport()

static HRESULT WINAPI d3d_device3_NextViewport ( IDirect3DDevice3 *  iface, IDirect3DViewport3 *  Viewport3, IDirect3DViewport3 **  lplpDirect3DViewport3, DWORD  flags  )

static

Definition at line 877 of file device.c.

{
    struct d3d_device *This = impl_from_IDirect3DDevice3(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(Viewport3);
    struct d3d_viewport *next;
    struct list *entry;
 
    TRACE("iface %p, viewport %p, next %p, flags %#x.\n",
            iface, Viewport3, lplpDirect3DViewport3, flags);
 
    if(!vp)
    {
        *lplpDirect3DViewport3 = NULL;
        return DDERR_INVALIDPARAMS;
    }
 
 
    wined3d_mutex_lock();
    switch (flags)
    {
        case D3DNEXT_NEXT:
            entry = list_next(&This->viewport_list, &vp->entry);
            break;
 
        case D3DNEXT_HEAD:
            entry = list_head(&This->viewport_list);
            break;
 
        case D3DNEXT_TAIL:
            entry = list_tail(&This->viewport_list);
            break;
 
        default:
            WARN("Invalid flags %#x.\n", flags);
            *lplpDirect3DViewport3 = NULL;
            wined3d_mutex_unlock();
            return DDERR_INVALIDPARAMS;
    }
 
    if (entry)
    {
        next = LIST_ENTRY(entry, struct d3d_viewport, entry);
        *lplpDirect3DViewport3 = &next->IDirect3DViewport3_iface;
    }
    else
        *lplpDirect3DViewport3 = NULL;
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device1_NextViewport(), and d3d_device2_NextViewport().

d3d_device3_QueryInterface()

static HRESULT WINAPI d3d_device3_QueryInterface ( IDirect3DDevice3 *  iface, REFIID  riid, void **  out  )

static

Definition at line 150 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 
    return IUnknown_QueryInterface(device->outer_unknown, riid, out);
}

d3d_device3_Release()

static ULONG WINAPI d3d_device3_Release ( IDirect3DDevice3 *  iface )

static

Definition at line 342 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IUnknown_Release(device->outer_unknown);
}

d3d_device3_SetClipStatus()

static HRESULT WINAPI d3d_device3_SetClipStatus ( IDirect3DDevice3 *  iface, D3DCLIPSTATUS *  clip_status  )

static

Definition at line 3890 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, clip_status %p.\n", iface, clip_status);
 
    return IDirect3DDevice7_SetClipStatus(&device->IDirect3DDevice7_iface, clip_status);
}

d3d_device3_SetCurrentViewport()

static HRESULT WINAPI d3d_device3_SetCurrentViewport ( IDirect3DDevice3 *  iface, IDirect3DViewport3 *  Direct3DViewport3  )

static

Definition at line 1692 of file device.c.

{
    struct d3d_device *This = impl_from_IDirect3DDevice3(iface);
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(Direct3DViewport3);
 
    TRACE("iface %p, viewport %p.\n", iface, Direct3DViewport3);
 
    if (!vp)
    {
        WARN("Direct3DViewport3 is NULL, returning DDERR_INVALIDPARAMS\n");
        return DDERR_INVALIDPARAMS;
    }
 
    wined3d_mutex_lock();
    /* Do nothing if the specified viewport is the same as the current one */
    if (This->current_viewport == vp)
    {
        wined3d_mutex_unlock();
        return D3D_OK;
    }
 
    if (vp->active_device != This)
    {
        WARN("Viewport %p active device is %p.\n", vp, vp->active_device);
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    /* Release previous viewport and AddRef the new one */
    if (This->current_viewport)
    {
        TRACE("ViewportImpl is at %p, interface is at %p\n", This->current_viewport,
                &This->current_viewport->IDirect3DViewport3_iface);
        IDirect3DViewport3_Release(&This->current_viewport->IDirect3DViewport3_iface);
    }
    IDirect3DViewport3_AddRef(Direct3DViewport3);
 
    /* Set this viewport as the current viewport */
    This->current_viewport = vp;
 
    /* Activate this viewport */
    viewport_activate(This->current_viewport, FALSE);
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device2_SetCurrentViewport().

d3d_device3_SetLightState()

static HRESULT WINAPI d3d_device3_SetLightState ( IDirect3DDevice3 *  iface, D3DLIGHTSTATETYPE  state, DWORD  value  )

static

Definition at line 2925 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    HRESULT hr;
 
    TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
 
    if (!state || (state > D3DLIGHTSTATE_COLORVERTEX))
    {
        TRACE("Unexpected Light State Type\n");
        return DDERR_INVALIDPARAMS;
    }
 
    wined3d_mutex_lock();
    if (state == D3DLIGHTSTATE_MATERIAL)
    {
        if (value)
        {
            struct d3d_material *m;
 
            if (!(m = ddraw_get_object(&device->handle_table, value - 1, DDRAW_HANDLE_MATERIAL)))
            {
                WARN("Invalid material handle.\n");
                wined3d_mutex_unlock();
                return DDERR_INVALIDPARAMS;
            }
 
            material_activate(m);
        }
 
        device->material = value;
    }
    else if (state == D3DLIGHTSTATE_COLORMODEL)
    {
        switch (value)
        {
            case D3DCOLOR_MONO:
                ERR("DDCOLOR_MONO should not happen!\n");
                break;
            case D3DCOLOR_RGB:
                /* We are already in this mode */
                TRACE("Setting color model to RGB (no-op).\n");
                break;
            default:
                ERR("Unknown color model!\n");
                wined3d_mutex_unlock();
                return DDERR_INVALIDPARAMS;
        }
    }
    else
    {
        D3DRENDERSTATETYPE rs;
        switch (state)
        {
            case D3DLIGHTSTATE_AMBIENT:       /* 2 */
                rs = D3DRENDERSTATE_AMBIENT;
                break;
            case D3DLIGHTSTATE_FOGMODE:       /* 4 */
                rs = D3DRENDERSTATE_FOGVERTEXMODE;
                break;
            case D3DLIGHTSTATE_FOGSTART:      /* 5 */
                rs = D3DRENDERSTATE_FOGSTART;
                break;
            case D3DLIGHTSTATE_FOGEND:        /* 6 */
                rs = D3DRENDERSTATE_FOGEND;
                break;
            case D3DLIGHTSTATE_FOGDENSITY:    /* 7 */
                rs = D3DRENDERSTATE_FOGDENSITY;
                break;
            case D3DLIGHTSTATE_COLORVERTEX:   /* 8 */
                rs = D3DRENDERSTATE_COLORVERTEX;
                break;
            default:
                FIXME("Unhandled D3DLIGHTSTATETYPE %#x.\n", state);
                wined3d_mutex_unlock();
                return DDERR_INVALIDPARAMS;
        }
 
        hr = IDirect3DDevice7_SetRenderState(&device->IDirect3DDevice7_iface, rs, value);
        wined3d_mutex_unlock();
        return hr;
    }
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device2_SetLightState().

d3d_device3_SetRenderState()

static HRESULT WINAPI d3d_device3_SetRenderState ( IDirect3DDevice3 *  iface, D3DRENDERSTATETYPE  state, DWORD  value  )

static

Definition at line 2720 of file device.c.

{
    /* Note about D3DRENDERSTATE_TEXTUREMAPBLEND implementation: most of values
    for this state can be directly mapped to texture stage colorop and alphaop, but
    D3DTBLEND_MODULATE is tricky: it uses alpha from texture when available and alpha
    from diffuse otherwise. So changing the texture must be monitored in SetTexture to modify
    alphaarg when needed.
 
    Aliens vs Predator 1 depends on accurate D3DTBLEND_MODULATE emulation
 
    Legacy texture blending (TEXTUREMAPBLEND) and texture stage states: directx6 docs state that
    TEXTUREMAPBLEND is deprecated, yet can still be used. Games must not use both or results
    are undefined. D3DTBLEND_MODULATE mode in particular is dependent on texture pixel format and
    requires fixup of stage 0 texture states when texture changes, but this fixup can interfere
    with games not using this deprecated state. So a flag 'legacyTextureBlending' has to be kept
    in device - TRUE if the app is using TEXTUREMAPBLEND.
 
    Tests show that setting TEXTUREMAPBLEND on native doesn't seem to change values returned by
    GetTextureStageState and vice versa. Not so on Wine, but it is 'undefined' anyway so, probably, ok,
    unless some broken game will be found that cares. */
 
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    HRESULT hr;
 
    TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
 
    if (state >= D3DSTATE_OVERRIDE_BIAS)
    {
        WARN("Unhandled state %#x.\n", state);
        return DDERR_INVALIDPARAMS;
    }
 
    wined3d_mutex_lock();
 
    switch (state)
    {
        case D3DRENDERSTATE_TEXTUREHANDLE:
        {
            struct ddraw_surface *surf;
 
            if (value == 0)
            {
                hr = wined3d_device_set_texture(device->wined3d_device, 0, NULL);
                break;
            }
 
            surf = ddraw_get_object(&device->handle_table, value - 1, DDRAW_HANDLE_SURFACE);
            if (!surf)
            {
                WARN("Invalid texture handle.\n");
                hr = DDERR_INVALIDPARAMS;
                break;
            }
 
            hr = IDirect3DDevice3_SetTexture(iface, 0, &surf->IDirect3DTexture2_iface);
            break;
        }
 
        case D3DRENDERSTATE_TEXTUREMAPBLEND:
        {
            device->legacyTextureBlending = TRUE;
 
            switch (value)
            {
                case D3DTBLEND_MODULATE:
                {
                    struct wined3d_texture *tex = NULL;
                    BOOL tex_alpha = FALSE;
                    DDPIXELFORMAT ddfmt;
 
                    if ((tex = wined3d_device_get_texture(device->wined3d_device, 0)))
                    {
                        struct wined3d_resource_desc desc;
 
                        wined3d_resource_get_desc(wined3d_texture_get_resource(tex), &desc);
                        ddfmt.dwSize = sizeof(ddfmt);
                        ddrawformat_from_wined3dformat(&ddfmt, desc.format);
                        if (ddfmt.u5.dwRGBAlphaBitMask)
                            tex_alpha = TRUE;
                    }
 
                    if (tex_alpha)
                        wined3d_device_set_texture_stage_state(device->wined3d_device,
                                0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG1);
                    else
                        wined3d_device_set_texture_stage_state(device->wined3d_device,
                                0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_MODULATE);
                    break;
                }
 
                case D3DTBLEND_ADD:
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_ADD);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
                    break;
 
                case D3DTBLEND_MODULATEALPHA:
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_MODULATE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_MODULATE);
                    break;
 
                case D3DTBLEND_COPY:
                case D3DTBLEND_DECAL:
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_SELECT_ARG1);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG1);
                    break;
 
                case D3DTBLEND_DECALALPHA:
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_BLEND_TEXTURE_ALPHA);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
                    wined3d_device_set_texture_stage_state(device->wined3d_device,
                            0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
                    break;
 
                default:
                    FIXME("Unhandled texture environment %#x.\n", value);
            }
 
            hr = D3D_OK;
            break;
        }
 
        case D3DRENDERSTATE_LIGHTING:
        case D3DRENDERSTATE_NORMALIZENORMALS:
        case D3DRENDERSTATE_LOCALVIEWER:
            hr = D3D_OK;
            break;
 
        default:
            hr = IDirect3DDevice7_SetRenderState(&device->IDirect3DDevice7_iface, state, value);
            break;
    }
    wined3d_mutex_unlock();
 
    return hr;
}

d3d_device3_SetRenderTarget()

static HRESULT WINAPI d3d_device3_SetRenderTarget ( IDirect3DDevice3 *  iface, IDirectDrawSurface4 *  target, DWORD  flags  )

static

Definition at line 1898 of file device.c.

{
    struct ddraw_surface *target_impl = unsafe_impl_from_IDirectDrawSurface4(target);
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    HRESULT hr;
 
    TRACE("iface %p, target %p, flags %#x.\n", iface, target, flags);
 
    wined3d_mutex_lock();
 
    if (!validate_surface_palette(target_impl))
    {
        WARN("Surface %p has an indexed pixel format, but no palette.\n", target_impl);
        wined3d_mutex_unlock();
        return DDERR_INVALIDCAPS;
    }
 
    if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
    {
        WARN("Surface %p is not a render target.\n", target_impl);
        wined3d_mutex_unlock();
        return DDERR_INVALIDCAPS;
    }
 
    if (target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
    {
        WARN("Surface %p is a depth buffer.\n", target_impl);
        IDirectDrawSurface4_AddRef(target);
        IUnknown_Release(device->rt_iface);
        device->rt_iface = (IUnknown *)target;
        wined3d_mutex_unlock();
        return DDERR_INVALIDPIXELFORMAT;
    }
 
    if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
    {
        WARN("Surface %p is not in video memory.\n", target_impl);
        IDirectDrawSurface4_AddRef(target);
        IUnknown_Release(device->rt_iface);
        device->rt_iface = (IUnknown *)target;
        wined3d_mutex_unlock();
        return D3D_OK;
    }
 
    hr = d3d_device_set_render_target(device, target_impl, (IUnknown *)target);
    wined3d_mutex_unlock();
    return hr;
}

d3d_device3_SetTexture()

static HRESULT WINAPI d3d_device3_SetTexture ( IDirect3DDevice3 *  iface, DWORD  stage, IDirect3DTexture2 *  texture  )

static

Definition at line 4806 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    struct ddraw_surface *tex = unsafe_impl_from_IDirect3DTexture2(texture);
    DWORD texmapblend;
    HRESULT hr;
 
    TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
 
    wined3d_mutex_lock();
 
    if (device->legacyTextureBlending)
        IDirect3DDevice3_GetRenderState(iface, D3DRENDERSTATE_TEXTUREMAPBLEND, &texmapblend);
 
    hr = IDirect3DDevice7_SetTexture(&device->IDirect3DDevice7_iface, stage, &tex->IDirectDrawSurface7_iface);
 
    if (device->legacyTextureBlending && texmapblend == D3DTBLEND_MODULATE)
    {
        /* This fixup is required by the way D3DTBLEND_MODULATE maps to texture stage states.
           See d3d_device3_SetRenderState() for details. */
        struct wined3d_texture *tex = NULL;
        BOOL tex_alpha = FALSE;
        DDPIXELFORMAT ddfmt;
 
        if ((tex = wined3d_device_get_texture(device->wined3d_device, 0)))
        {
            struct wined3d_resource_desc desc;
 
            wined3d_resource_get_desc(wined3d_texture_get_resource(tex), &desc);
            ddfmt.dwSize = sizeof(ddfmt);
            ddrawformat_from_wined3dformat(&ddfmt, desc.format);
            if (ddfmt.u5.dwRGBAlphaBitMask)
                tex_alpha = TRUE;
        }
 
        /* Args 1 and 2 are already set to WINED3DTA_TEXTURE/WINED3DTA_CURRENT in case of D3DTBLEND_MODULATE */
        if (tex_alpha)
            wined3d_device_set_texture_stage_state(device->wined3d_device,
                    0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG1);
        else
            wined3d_device_set_texture_stage_state(device->wined3d_device,
                    0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
    }
 
    wined3d_mutex_unlock();
 
    return hr;
}

d3d_device3_SetTextureStageState()

static HRESULT WINAPI d3d_device3_SetTextureStageState ( IDirect3DDevice3 *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  state, DWORD  value  )

static

Definition at line 5163 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, stage %u, state %#x, value %#x.\n",
            iface, stage, state, value);
 
    return IDirect3DDevice7_SetTextureStageState(&device->IDirect3DDevice7_iface, stage, state, value);
}

d3d_device3_SetTransform()

static HRESULT WINAPI d3d_device3_SetTransform ( IDirect3DDevice3 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3191 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    if (!matrix)
        return DDERR_INVALIDPARAMS;
 
    if (state == D3DTRANSFORMSTATE_PROJECTION)
    {
        D3DMATRIX projection;
 
        wined3d_mutex_lock();
        multiply_matrix(&projection, &device->legacy_clipspace, matrix);
        wined3d_device_set_transform(device->wined3d_device,
                WINED3D_TS_PROJECTION, (struct wined3d_matrix *)&projection);
        device->legacy_projection = *matrix;
        wined3d_mutex_unlock();
 
        return D3D_OK;
    }
 
    return IDirect3DDevice7_SetTransform(&device->IDirect3DDevice7_iface, state, matrix);
}

d3d_device3_ValidateDevice()

static HRESULT WINAPI d3d_device3_ValidateDevice ( IDirect3DDevice3 *  iface, DWORD *  pass_count  )

static

Definition at line 5222 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, pass_count %p.\n", iface, pass_count);
 
    return IDirect3DDevice7_ValidateDevice(&device->IDirect3DDevice7_iface, pass_count);
}

d3d_device3_Vertex()

static HRESULT WINAPI d3d_device3_Vertex ( IDirect3DDevice3 *  iface, void *  vertex  )

static

Definition at line 2203 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, vertex %p.\n", iface, vertex);
 
    if (!vertex)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    if ((device->nb_vertices + 1) * device->vertex_size > device->buffer_size)
    {
        BYTE *old_buffer;
 
        device->buffer_size = device->buffer_size ? device->buffer_size * 2 : device->vertex_size * 3;
        old_buffer = device->sysmem_vertex_buffer;
        device->sysmem_vertex_buffer = heap_alloc(device->buffer_size);
        if (old_buffer)
        {
            memcpy(device->sysmem_vertex_buffer, old_buffer, device->nb_vertices * device->vertex_size);
            heap_free(old_buffer);
        }
    }
 
    memcpy(device->sysmem_vertex_buffer + device->nb_vertices++ * device->vertex_size, vertex, device->vertex_size);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device2_Vertex().

d3d_device7_AddRef()

static ULONG WINAPI d3d_device7_AddRef ( IDirect3DDevice7 *  iface )

static

Definition at line 187 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IUnknown_AddRef(device->outer_unknown);
}

d3d_device7_ApplyStateBlock()

static HRESULT d3d_device7_ApplyStateBlock ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5776 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
 
    TRACE("iface %p, stateblock %#x.\n", iface, stateblock);
 
    wined3d_mutex_lock();
    wined3d_sb = ddraw_get_object(&device->handle_table, stateblock - 1, DDRAW_HANDLE_STATEBLOCK);
    if (!wined3d_sb)
    {
        WARN("Invalid stateblock handle.\n");
        wined3d_mutex_unlock();
        return D3DERR_INVALIDSTATEBLOCK;
    }
 
    wined3d_stateblock_apply(wined3d_sb);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_ApplyStateBlock_FPUPreserve(), and d3d_device7_ApplyStateBlock_FPUSetup().

d3d_device7_ApplyStateBlock_FPUPreserve()

static HRESULT WINAPI d3d_device7_ApplyStateBlock_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5803 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_ApplyStateBlock(iface, stateblock);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_ApplyStateBlock_FPUSetup()

static HRESULT WINAPI d3d_device7_ApplyStateBlock_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5798 of file device.c.

{
    return d3d_device7_ApplyStateBlock(iface, stateblock);
}

d3d_device7_BeginScene()

static HRESULT d3d_device7_BeginScene ( IDirect3DDevice7 *  iface )

static

Definition at line 1466 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p.\n", iface);
 
    wined3d_mutex_lock();
    hr = wined3d_device_begin_scene(device->wined3d_device);
    wined3d_mutex_unlock();
 
    if(hr == WINED3D_OK) return D3D_OK;
    else return D3DERR_SCENE_IN_SCENE; /* TODO: Other possible causes of failure */
}

Referenced by d3d_device7_BeginScene_FPUPreserve(), and d3d_device7_BeginScene_FPUSetup().

d3d_device7_BeginScene_FPUPreserve()

static HRESULT WINAPI d3d_device7_BeginScene_FPUPreserve ( IDirect3DDevice7 *  iface )

static

Definition at line 1486 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_BeginScene(iface);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_BeginScene_FPUSetup()

static HRESULT WINAPI d3d_device7_BeginScene_FPUSetup ( IDirect3DDevice7 *  iface )

static

Definition at line 1481 of file device.c.

{
    return d3d_device7_BeginScene(iface);
}

d3d_device7_BeginStateBlock()

static HRESULT d3d_device7_BeginStateBlock ( IDirect3DDevice7 *  iface )

static

Definition at line 5611 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p.\n", iface);
 
    wined3d_mutex_lock();
    hr = wined3d_device_begin_stateblock(device->wined3d_device);
    wined3d_mutex_unlock();
 
    return hr_ddraw_from_wined3d(hr);
}

Referenced by d3d_device7_BeginStateBlock_FPUPreserve(), and d3d_device7_BeginStateBlock_FPUSetup().

d3d_device7_BeginStateBlock_FPUPreserve()

static HRESULT WINAPI d3d_device7_BeginStateBlock_FPUPreserve ( IDirect3DDevice7 *  iface )

static

Definition at line 5630 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_BeginStateBlock(iface);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_BeginStateBlock_FPUSetup()

static HRESULT WINAPI d3d_device7_BeginStateBlock_FPUSetup ( IDirect3DDevice7 *  iface )

static

Definition at line 5625 of file device.c.

{
    return d3d_device7_BeginStateBlock(iface);
}

d3d_device7_CaptureStateBlock()

static HRESULT d3d_device7_CaptureStateBlock ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5830 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
 
    TRACE("iface %p, stateblock %#x.\n", iface, stateblock);
 
    wined3d_mutex_lock();
    wined3d_sb = ddraw_get_object(&device->handle_table, stateblock - 1, DDRAW_HANDLE_STATEBLOCK);
    if (!wined3d_sb)
    {
        WARN("Invalid stateblock handle.\n");
        wined3d_mutex_unlock();
        return D3DERR_INVALIDSTATEBLOCK;
    }
 
    wined3d_stateblock_capture(wined3d_sb);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_CaptureStateBlock_FPUPreserve(), and d3d_device7_CaptureStateBlock_FPUSetup().

d3d_device7_CaptureStateBlock_FPUPreserve()

static HRESULT WINAPI d3d_device7_CaptureStateBlock_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5857 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_CaptureStateBlock(iface, stateblock);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_CaptureStateBlock_FPUSetup()

static HRESULT WINAPI d3d_device7_CaptureStateBlock_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5852 of file device.c.

{
    return d3d_device7_CaptureStateBlock(iface, stateblock);
}

d3d_device7_Clear()

static HRESULT d3d_device7_Clear ( IDirect3DDevice7 *  iface, DWORD  count, D3DRECT *  rects, DWORD  flags, D3DCOLOR  color, D3DVALUE  z, DWORD  stencil  )

static

Definition at line 5251 of file device.c.

{
    const struct wined3d_color c =
    {
        ((color >> 16) & 0xff) / 255.0f,
        ((color >>  8) & 0xff) / 255.0f,
        (color & 0xff) / 255.0f,
        ((color >> 24) & 0xff) / 255.0f,
    };
    struct d3d_device *This = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, count %u, rects %p, flags %#x, color 0x%08x, z %.8e, stencil %#x.\n",
            iface, count, rects, flags, color, z, stencil);
 
    if (count && !rects)
    {
        WARN("count %u with NULL rects.\n", count);
        count = 0;
    }
 
    wined3d_mutex_lock();
    hr = wined3d_device_clear(This->wined3d_device, count, (RECT *)rects, flags, &c, z, stencil);
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_Clear_FPUPreserve(), and d3d_device7_Clear_FPUSetup().

d3d_device7_Clear_FPUPreserve()

static HRESULT WINAPI d3d_device7_Clear_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  count, D3DRECT *  rects, DWORD  flags, D3DCOLOR  color, D3DVALUE  z, DWORD  stencil  )

static

Definition at line 5286 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_Clear(iface, count, rects, flags, color, z, stencil);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_Clear_FPUSetup()

static HRESULT WINAPI d3d_device7_Clear_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  count, D3DRECT *  rects, DWORD  flags, D3DCOLOR  color, D3DVALUE  z, DWORD  stencil  )

static

Definition at line 5280 of file device.c.

{
    return d3d_device7_Clear(iface, count, rects, flags, color, z, stencil);
}

d3d_device7_ComputeSphereVisibility()

static HRESULT WINAPI d3d_device7_ComputeSphereVisibility ( IDirect3DDevice7 *  iface, D3DVECTOR *  centers, D3DVALUE *  radii, DWORD  sphere_count, DWORD  flags, DWORD *  return_values  )

static

Definition at line 4603 of file device.c.

{
    struct wined3d_vec4 plane[12];
    DWORD enabled_planes = 0x3f;
    DWORD user_clip_planes;
    UINT j;
 
    TRACE("iface %p, centers %p, radii %p, sphere_count %u, flags %#x, return_values %p.\n",
            iface, centers, radii, sphere_count, flags, return_values);
 
    prepare_clip_space_planes(impl_from_IDirect3DDevice7(iface), plane);
 
    IDirect3DDevice7_GetRenderState(iface, D3DRENDERSTATE_CLIPPLANEENABLE, &user_clip_planes);
    enabled_planes |= user_clip_planes << 6;
    for (j = 6; j < 12; ++j)
        IDirect3DDevice7_GetClipPlane(iface, j - 6, (D3DVALUE *)&plane[j]);
 
    compute_sphere_visibility(plane, enabled_planes, FALSE, centers, radii, sphere_count, return_values);
    return D3D_OK;
}

d3d_device7_CreateStateBlock()

static HRESULT d3d_device7_CreateStateBlock ( IDirect3DDevice7 *  iface, D3DSTATEBLOCKTYPE  type, DWORD *  stateblock  )

static

Definition at line 5945 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
    HRESULT hr;
    DWORD h;
 
    TRACE("iface %p, type %#x, stateblock %p.\n", iface, type, stateblock);
 
    if (!stateblock)
        return DDERR_INVALIDPARAMS;
 
    if (type != D3DSBT_ALL
            && type != D3DSBT_PIXELSTATE
            && type != D3DSBT_VERTEXSTATE)
    {
        WARN("Unexpected stateblock type, returning DDERR_INVALIDPARAMS\n");
        return DDERR_INVALIDPARAMS;
    }
 
    wined3d_mutex_lock();
 
    /* The D3DSTATEBLOCKTYPE enum is fine here. */
    hr = wined3d_stateblock_create(device->wined3d_device, type, &wined3d_sb);
    if (FAILED(hr))
    {
        WARN("Failed to create stateblock, hr %#x.\n", hr);
        wined3d_mutex_unlock();
        return hr_ddraw_from_wined3d(hr);
    }
 
    h = ddraw_allocate_handle(&device->handle_table, wined3d_sb, DDRAW_HANDLE_STATEBLOCK);
    if (h == DDRAW_INVALID_HANDLE)
    {
        ERR("Failed to allocate stateblock handle.\n");
        wined3d_stateblock_decref(wined3d_sb);
        wined3d_mutex_unlock();
        return DDERR_OUTOFMEMORY;
    }
 
    *stateblock = h + 1;
    wined3d_mutex_unlock();
 
    return hr_ddraw_from_wined3d(hr);
}

Referenced by d3d_device7_CreateStateBlock_FPUPreserve(), and d3d_device7_CreateStateBlock_FPUSetup().

d3d_device7_CreateStateBlock_FPUPreserve()

static HRESULT WINAPI d3d_device7_CreateStateBlock_FPUPreserve ( IDirect3DDevice7 *  iface, D3DSTATEBLOCKTYPE  type, DWORD *  stateblock  )

static

Definition at line 5998 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_CreateStateBlock(iface, type, stateblock);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_CreateStateBlock_FPUSetup()

static HRESULT WINAPI d3d_device7_CreateStateBlock_FPUSetup ( IDirect3DDevice7 *  iface, D3DSTATEBLOCKTYPE  type, DWORD *  stateblock  )

static

Definition at line 5992 of file device.c.

{
    return d3d_device7_CreateStateBlock(iface, type, stateblock);
}

d3d_device7_DeleteStateBlock()

static HRESULT d3d_device7_DeleteStateBlock ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5884 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
    ULONG ref;
 
    TRACE("iface %p, stateblock %#x.\n", iface, stateblock);
 
    wined3d_mutex_lock();
 
    wined3d_sb = ddraw_free_handle(&device->handle_table, stateblock - 1, DDRAW_HANDLE_STATEBLOCK);
    if (!wined3d_sb)
    {
        WARN("Invalid stateblock handle.\n");
        wined3d_mutex_unlock();
        return D3DERR_INVALIDSTATEBLOCK;
    }
 
    if ((ref = wined3d_stateblock_decref(wined3d_sb)))
    {
        ERR("Something is still holding stateblock %p (refcount %u).\n", wined3d_sb, ref);
    }
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_DeleteStateBlock_FPUPreserve(), and d3d_device7_DeleteStateBlock_FPUSetup().

d3d_device7_DeleteStateBlock_FPUPreserve()

static HRESULT WINAPI d3d_device7_DeleteStateBlock_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5917 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_DeleteStateBlock(iface, stateblock);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_DeleteStateBlock_FPUSetup()

static HRESULT WINAPI d3d_device7_DeleteStateBlock_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  stateblock  )

static

Definition at line 5912 of file device.c.

{
    return d3d_device7_DeleteStateBlock(iface, stateblock);
}

d3d_device7_DrawIndexedPrimitive()

static HRESULT d3d_device7_DrawIndexedPrimitive ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, WORD *  indices, DWORD  index_count, DWORD  flags  )

static

Definition at line 3686 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
    UINT stride = get_flexible_vertex_size(fvf);
    UINT vtx_size = stride * vertex_count, idx_size = index_count * sizeof(*indices);
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
    struct wined3d_resource *ib, *vb;
    UINT vb_pos, ib_pos, align;
 
    TRACE("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, "
            "indices %p, index_count %u, flags %#x.\n",
            iface, primitive_type, fvf, vertices, vertex_count, indices, index_count, flags);
 
    if (!vertex_count || !index_count)
    {
        WARN("0 vertex or index count.\n");
        return D3D_OK;
    }
 
    /* Set the D3DDevice's FVF */
    wined3d_mutex_lock();
 
    hr = d3d_device_prepare_vertex_buffer(device, vtx_size);
    if (FAILED(hr))
        goto done;
 
    vb_pos = device->vertex_buffer_pos;
    align = vb_pos % stride;
    if (align) align = stride - align;
    if (vb_pos + vtx_size + align > device->vertex_buffer_size)
        vb_pos = 0;
    else
        vb_pos += align;
 
    wined3d_box.left = vb_pos;
    wined3d_box.right = vb_pos + vtx_size;
    vb = wined3d_buffer_get_resource(device->vertex_buffer);
    if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
            WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
        goto done;
    memcpy(wined3d_map_desc.data, vertices, vtx_size);
    wined3d_resource_unmap(vb, 0);
    device->vertex_buffer_pos = vb_pos + vtx_size;
 
    hr = d3d_device_prepare_index_buffer(device, idx_size);
    if (FAILED(hr))
        goto done;
    ib_pos = device->index_buffer_pos;
    if (device->index_buffer_size - idx_size < ib_pos)
        ib_pos = 0;
 
    wined3d_box.left = ib_pos;
    wined3d_box.right = ib_pos + idx_size;
    ib = wined3d_buffer_get_resource(device->index_buffer);
    if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box,
            WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
        goto done;
    memcpy(wined3d_map_desc.data, indices, idx_size);
    wined3d_resource_unmap(ib, 0);
    device->index_buffer_pos = ib_pos + idx_size;
 
    hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, stride);
    if (FAILED(hr))
        goto done;
    wined3d_device_set_index_buffer(device->wined3d_device, device->index_buffer, WINED3DFMT_R16_UINT, 0);
 
    wined3d_device_set_vertex_declaration(device->wined3d_device, ddraw_find_decl(device->ddraw, fvf));
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
    wined3d_device_set_base_vertex_index(device->wined3d_device, vb_pos / stride);
    hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, ib_pos / sizeof(*indices), index_count);
 
done:
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d_device7_DrawIndexedPrimitive_FPUPreserve(), and d3d_device7_DrawIndexedPrimitive_FPUSetup().

d3d_device7_DrawIndexedPrimitive_FPUPreserve()

static HRESULT WINAPI d3d_device7_DrawIndexedPrimitive_FPUPreserve ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, WORD *  indices, DWORD  index_count, DWORD  flags  )

static

Definition at line 3774 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_DrawIndexedPrimitive(iface, primitive_type, fvf,
            vertices, vertex_count, indices, index_count, flags);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_DrawIndexedPrimitive_FPUSetup()

static HRESULT WINAPI d3d_device7_DrawIndexedPrimitive_FPUSetup ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, WORD *  indices, DWORD  index_count, DWORD  flags  )

static

Definition at line 3766 of file device.c.

{
    return d3d_device7_DrawIndexedPrimitive(iface, primitive_type, fvf,
            vertices, vertex_count, indices, index_count, flags);
}

d3d_device7_DrawIndexedPrimitiveStrided()

static HRESULT d3d_device7_DrawIndexedPrimitiveStrided ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, D3DDRAWPRIMITIVESTRIDEDDATA *  strided_data, DWORD  vertex_count, WORD *  indices, DWORD  index_count, DWORD  flags  )

static

Definition at line 4132 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    UINT vtx_dst_stride = get_flexible_vertex_size(fvf);
    UINT vtx_dst_size = vertex_count * vtx_dst_stride;
    UINT idx_size = index_count * sizeof(WORD);
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
    struct wined3d_resource *ib, *vb;
    UINT vb_pos, align;
    UINT ib_pos;
    HRESULT hr;
 
    TRACE("iface %p, primitive_type %#x, fvf %#x, strided_data %p, "
            "vertex_count %u, indices %p, index_count %u, flags %#x.\n",
            iface, primitive_type, fvf, strided_data, vertex_count, indices, index_count, flags);
 
    if (!vertex_count || !index_count)
    {
        WARN("0 vertex or index count.\n");
        return D3D_OK;
    }
 
    wined3d_mutex_lock();
 
    hr = d3d_device_prepare_vertex_buffer(device, vtx_dst_size);
    if (FAILED(hr))
        goto done;
 
    vb_pos = device->vertex_buffer_pos;
    align = vb_pos % vtx_dst_stride;
    if (align) align = vtx_dst_stride - align;
    if (vb_pos + vtx_dst_size + align > device->vertex_buffer_size)
        vb_pos = 0;
    else
        vb_pos += align;
 
    wined3d_box.left = vb_pos;
    wined3d_box.right = vb_pos + vtx_dst_size;
    vb = wined3d_buffer_get_resource(device->vertex_buffer);
    if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
            WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
        goto done;
    pack_strided_data(wined3d_map_desc.data, vertex_count, strided_data, fvf);
    wined3d_resource_unmap(vb, 0);
    device->vertex_buffer_pos = vb_pos + vtx_dst_size;
 
    hr = d3d_device_prepare_index_buffer(device, idx_size);
    if (FAILED(hr))
        goto done;
    ib_pos = device->index_buffer_pos;
    if (device->index_buffer_size - idx_size < ib_pos)
        ib_pos = 0;
 
    wined3d_box.left = ib_pos;
    wined3d_box.right = ib_pos + idx_size;
    ib = wined3d_buffer_get_resource(device->index_buffer);
    if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box,
            WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
        goto done;
    memcpy(wined3d_map_desc.data, indices, idx_size);
    wined3d_resource_unmap(ib, 0);
    device->index_buffer_pos = ib_pos + idx_size;
 
    hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, vtx_dst_stride);
    if (FAILED(hr))
        goto done;
    wined3d_device_set_index_buffer(device->wined3d_device, device->index_buffer, WINED3DFMT_R16_UINT, 0);
    wined3d_device_set_base_vertex_index(device->wined3d_device, vb_pos / vtx_dst_stride);
 
    wined3d_device_set_vertex_declaration(device->wined3d_device, ddraw_find_decl(device->ddraw, fvf));
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
    hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, ib_pos / sizeof(WORD), index_count);
 
done:
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d_device7_DrawIndexedPrimitiveStrided_FPUPreserve(), and d3d_device7_DrawIndexedPrimitiveStrided_FPUSetup().

d3d_device7_DrawIndexedPrimitiveStrided_FPUPreserve()

static HRESULT WINAPI d3d_device7_DrawIndexedPrimitiveStrided_FPUPreserve ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  PrimitiveType, DWORD  VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *  D3DDrawPrimStrideData, DWORD  VertexCount, WORD *  Indices, DWORD  IndexCount, DWORD  Flags  )

static

Definition at line 4222 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_DrawIndexedPrimitiveStrided(iface, PrimitiveType, VertexType,
            D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_DrawIndexedPrimitiveStrided_FPUSetup()

static HRESULT WINAPI d3d_device7_DrawIndexedPrimitiveStrided_FPUSetup ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  PrimitiveType, DWORD  VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *  D3DDrawPrimStrideData, DWORD  VertexCount, WORD *  Indices, DWORD  IndexCount, DWORD  Flags  )

static

Definition at line 4213 of file device.c.

{
    return d3d_device7_DrawIndexedPrimitiveStrided(iface, PrimitiveType, VertexType,
            D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
}

d3d_device7_DrawIndexedPrimitiveVB()

static HRESULT d3d_device7_DrawIndexedPrimitiveVB ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, IDirect3DVertexBuffer7 *  vb, DWORD  start_vertex, DWORD  vertex_count, WORD *  indices, DWORD  index_count, DWORD  flags  )

static

Definition at line 4362 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct d3d_vertex_buffer *vb_impl = unsafe_impl_from_IDirect3DVertexBuffer7(vb);
    DWORD stride = get_flexible_vertex_size(vb_impl->fvf);
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
    struct wined3d_resource *ib;
    HRESULT hr;
    UINT ib_pos;
 
    TRACE("iface %p, primitive_type %#x, vb %p, start_vertex %u, "
            "vertex_count %u, indices %p, index_count %u, flags %#x.\n",
            iface, primitive_type, vb, start_vertex, vertex_count, indices, index_count, flags);
 
    if (!vertex_count || !index_count)
    {
        WARN("0 vertex or index count.\n");
        return D3D_OK;
    }
 
    /* Steps:
     * 1) Upload the indices to the index buffer
     * 2) Set the index source
     * 3) Set the Vertex Buffer as the Stream source
     * 4) Call wined3d_device_draw_indexed_primitive()
     */
 
    wined3d_mutex_lock();
 
    wined3d_device_set_vertex_declaration(device->wined3d_device, vb_impl->wined3d_declaration);
 
    hr = d3d_device_prepare_index_buffer(device, index_count * sizeof(WORD));
    if (FAILED(hr))
    {
        wined3d_mutex_unlock();
        return hr;
    }
    ib_pos = device->index_buffer_pos;
 
    if (device->index_buffer_size - index_count * sizeof(WORD) < ib_pos)
        ib_pos = 0;
 
    /* Copy the index stream into the index buffer. */
    wined3d_box.left = ib_pos;
    wined3d_box.right = ib_pos + index_count * sizeof(WORD);
    ib = wined3d_buffer_get_resource(device->index_buffer);
    if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box,
            WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
    {
        ERR("Failed to map buffer, hr %#x.\n", hr);
        wined3d_mutex_unlock();
        return hr;
    }
    memcpy(wined3d_map_desc.data, indices, index_count * sizeof(WORD));
    wined3d_resource_unmap(ib, 0);
    device->index_buffer_pos = ib_pos + index_count * sizeof(WORD);
 
    /* Set the index stream */
    wined3d_device_set_base_vertex_index(device->wined3d_device, start_vertex);
    wined3d_device_set_index_buffer(device->wined3d_device, device->index_buffer, WINED3DFMT_R16_UINT, 0);
 
    /* Set the vertex stream source */
    if (FAILED(hr = wined3d_device_set_stream_source(device->wined3d_device,
            0, vb_impl->wined3d_buffer, 0, stride)))
    {
        ERR("(%p) IDirect3DDevice::SetStreamSource failed with hr = %08x\n", device, hr);
        wined3d_mutex_unlock();
        return hr;
    }
 
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
    hr = wined3d_device_draw_indexed_primitive(device->wined3d_device, ib_pos / sizeof(WORD), index_count);
 
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_DrawIndexedPrimitiveVB_FPUPreserve(), and d3d_device7_DrawIndexedPrimitiveVB_FPUSetup().

d3d_device7_DrawIndexedPrimitiveVB_FPUPreserve()

static HRESULT WINAPI d3d_device7_DrawIndexedPrimitiveVB_FPUPreserve ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  PrimitiveType, IDirect3DVertexBuffer7 *  D3DVertexBuf, DWORD  StartVertex, DWORD  NumVertices, WORD *  Indices, DWORD  IndexCount, DWORD  Flags  )

static

Definition at line 4451 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_DrawIndexedPrimitiveVB(iface, PrimitiveType,
            D3DVertexBuf, StartVertex, NumVertices, Indices, IndexCount, Flags);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_DrawIndexedPrimitiveVB_FPUSetup()

static HRESULT WINAPI d3d_device7_DrawIndexedPrimitiveVB_FPUSetup ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  PrimitiveType, IDirect3DVertexBuffer7 *  D3DVertexBuf, DWORD  StartVertex, DWORD  NumVertices, WORD *  Indices, DWORD  IndexCount, DWORD  Flags  )

static

Definition at line 4443 of file device.c.

{
    return d3d_device7_DrawIndexedPrimitiveVB(iface, PrimitiveType,
            D3DVertexBuf, StartVertex, NumVertices, Indices, IndexCount, Flags);
}

d3d_device7_DrawPrimitive()

static HRESULT d3d_device7_DrawPrimitive ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 3495 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
    UINT stride, vb_pos, size, align;
    struct wined3d_resource *vb;
    HRESULT hr;
 
    TRACE("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, flags %#x.\n",
            iface, primitive_type, fvf, vertices, vertex_count, flags);
 
    if (!vertex_count)
    {
        WARN("0 vertex count.\n");
        return D3D_OK;
    }
 
    /* Get the stride */
    stride = get_flexible_vertex_size(fvf);
    size = vertex_count * stride;
 
    wined3d_mutex_lock();
    hr = d3d_device_prepare_vertex_buffer(device, size);
    if (FAILED(hr))
        goto done;
 
    vb_pos = device->vertex_buffer_pos;
    align = vb_pos % stride;
    if (align) align = stride - align;
    if (vb_pos + size + align > device->vertex_buffer_size)
        vb_pos = 0;
    else
        vb_pos += align;
 
    wined3d_box.left = vb_pos;
    wined3d_box.right = vb_pos + size;
    vb = wined3d_buffer_get_resource(device->vertex_buffer);
    if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
            WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
        goto done;
    memcpy(wined3d_map_desc.data, vertices, size);
    wined3d_resource_unmap(vb, 0);
    device->vertex_buffer_pos = vb_pos + size;
 
    hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, stride);
    if (FAILED(hr))
        goto done;
 
    wined3d_device_set_vertex_declaration(device->wined3d_device, ddraw_find_decl(device->ddraw, fvf));
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
    hr = wined3d_device_draw_primitive(device->wined3d_device, vb_pos / stride, vertex_count);
 
done:
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d_device7_DrawPrimitive_FPUPreserve(), and d3d_device7_DrawPrimitive_FPUSetup().

d3d_device7_DrawPrimitive_FPUPreserve()

static HRESULT WINAPI d3d_device7_DrawPrimitive_FPUPreserve ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 3562 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_DrawPrimitive(iface, primitive_type, fvf, vertices, vertex_count, flags);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_DrawPrimitive_FPUSetup()

static HRESULT WINAPI d3d_device7_DrawPrimitive_FPUSetup ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, void *  vertices, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 3555 of file device.c.

{
    return d3d_device7_DrawPrimitive(iface, primitive_type, fvf, vertices, vertex_count, flags);
}

d3d_device7_DrawPrimitiveStrided()

static HRESULT d3d_device7_DrawPrimitiveStrided ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, DWORD  fvf, D3DDRAWPRIMITIVESTRIDEDDATA *  strided_data, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 4021 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
    UINT dst_stride = get_flexible_vertex_size(fvf);
    UINT dst_size = dst_stride * vertex_count;
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
    struct wined3d_resource *vb;
    UINT vb_pos, align;
 
    TRACE("iface %p, primitive_type %#x, fvf %#x, strided_data %p, vertex_count %u, flags %#x.\n",
            iface, primitive_type, fvf, strided_data, vertex_count, flags);
 
    if (!vertex_count)
    {
        WARN("0 vertex count.\n");
        return D3D_OK;
    }
 
    wined3d_mutex_lock();
    hr = d3d_device_prepare_vertex_buffer(device, dst_size);
    if (FAILED(hr))
        goto done;
 
    vb_pos = device->vertex_buffer_pos;
    align = vb_pos % dst_stride;
    if (align) align = dst_stride - align;
    if (vb_pos + dst_size + align > device->vertex_buffer_size)
        vb_pos = 0;
    else
        vb_pos += align;
 
    wined3d_box.left = vb_pos;
    wined3d_box.right = vb_pos + dst_size;
    vb = wined3d_buffer_get_resource(device->vertex_buffer);
    if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
            WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
        goto done;
    pack_strided_data(wined3d_map_desc.data, vertex_count, strided_data, fvf);
    wined3d_resource_unmap(vb, 0);
    device->vertex_buffer_pos = vb_pos + dst_size;
 
    hr = wined3d_device_set_stream_source(device->wined3d_device, 0, device->vertex_buffer, 0, dst_stride);
    if (FAILED(hr))
        goto done;
    wined3d_device_set_vertex_declaration(device->wined3d_device, ddraw_find_decl(device->ddraw, fvf));
 
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
    hr = wined3d_device_draw_primitive(device->wined3d_device, vb_pos / dst_stride, vertex_count);
 
done:
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d_device7_DrawPrimitiveStrided_FPUPreserve(), and d3d_device7_DrawPrimitiveStrided_FPUSetup().

d3d_device7_DrawPrimitiveStrided_FPUPreserve()

static HRESULT WINAPI d3d_device7_DrawPrimitiveStrided_FPUPreserve ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  PrimitiveType, DWORD  VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *  D3DDrawPrimStrideData, DWORD  VertexCount, DWORD  Flags  )

static

Definition at line 4086 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_DrawPrimitiveStrided(iface, PrimitiveType,
            VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_DrawPrimitiveStrided_FPUSetup()

static HRESULT WINAPI d3d_device7_DrawPrimitiveStrided_FPUSetup ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  PrimitiveType, DWORD  VertexType, D3DDRAWPRIMITIVESTRIDEDDATA *  D3DDrawPrimStrideData, DWORD  VertexCount, DWORD  Flags  )

static

Definition at line 4078 of file device.c.

{
    return d3d_device7_DrawPrimitiveStrided(iface, PrimitiveType,
            VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
}

d3d_device7_DrawPrimitiveVB()

static HRESULT d3d_device7_DrawPrimitiveVB ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  primitive_type, IDirect3DVertexBuffer7 *  vb, DWORD  start_vertex, DWORD  vertex_count, DWORD  flags  )

static

Definition at line 4273 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct d3d_vertex_buffer *vb_impl = unsafe_impl_from_IDirect3DVertexBuffer7(vb);
    HRESULT hr;
    DWORD stride;
 
    TRACE("iface %p, primitive_type %#x, vb %p, start_vertex %u, vertex_count %u, flags %#x.\n",
            iface, primitive_type, vb, start_vertex, vertex_count, flags);
 
    if (!vertex_count)
    {
        WARN("0 vertex count.\n");
        return D3D_OK;
    }
 
    stride = get_flexible_vertex_size(vb_impl->fvf);
 
    wined3d_mutex_lock();
    wined3d_device_set_vertex_declaration(device->wined3d_device, vb_impl->wined3d_declaration);
    if (FAILED(hr = wined3d_device_set_stream_source(device->wined3d_device,
            0, vb_impl->wined3d_buffer, 0, stride)))
    {
        WARN("Failed to set stream source, hr %#x.\n", hr);
        wined3d_mutex_unlock();
        return hr;
    }
 
    /* Now draw the primitives */
    wined3d_device_set_primitive_type(device->wined3d_device, primitive_type, 0);
    hr = wined3d_device_draw_primitive(device->wined3d_device, start_vertex, vertex_count);
 
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_DrawPrimitiveVB_FPUPreserve(), and d3d_device7_DrawPrimitiveVB_FPUSetup().

d3d_device7_DrawPrimitiveVB_FPUPreserve()

static HRESULT WINAPI d3d_device7_DrawPrimitiveVB_FPUPreserve ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  PrimitiveType, IDirect3DVertexBuffer7 *  D3DVertexBuf, DWORD  StartVertex, DWORD  NumVertices, DWORD  Flags  )

static

Definition at line 4317 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_DrawPrimitiveVB(iface, PrimitiveType, D3DVertexBuf, StartVertex, NumVertices, Flags);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_DrawPrimitiveVB_FPUSetup()

static HRESULT WINAPI d3d_device7_DrawPrimitiveVB_FPUSetup ( IDirect3DDevice7 *  iface, D3DPRIMITIVETYPE  PrimitiveType, IDirect3DVertexBuffer7 *  D3DVertexBuf, DWORD  StartVertex, DWORD  NumVertices, DWORD  Flags  )

static

Definition at line 4311 of file device.c.

{
    return d3d_device7_DrawPrimitiveVB(iface, PrimitiveType, D3DVertexBuf, StartVertex, NumVertices, Flags);
}

d3d_device7_EndScene()

static HRESULT d3d_device7_EndScene ( IDirect3DDevice7 *  iface )

static

Definition at line 1539 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p.\n", iface);
 
    wined3d_mutex_lock();
    hr = wined3d_device_end_scene(device->wined3d_device);
    wined3d_mutex_unlock();
 
    if(hr == WINED3D_OK) return D3D_OK;
    else return D3DERR_SCENE_NOT_IN_SCENE;
}

Referenced by d3d_device7_EndScene_FPUPreserve(), and d3d_device7_EndScene_FPUSetup().

d3d_device7_EndScene_FPUPreserve()

static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device7_EndScene_FPUPreserve ( IDirect3DDevice7 *  iface )

static

Definition at line 1559 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_EndScene(iface);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_EndScene_FPUSetup()

static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device7_EndScene_FPUSetup ( IDirect3DDevice7 *  iface )

static

Definition at line 1554 of file device.c.

{
    return d3d_device7_EndScene(iface);
}

d3d_device7_EndStateBlock()

static HRESULT d3d_device7_EndStateBlock ( IDirect3DDevice7 *  iface, DWORD *  stateblock  )

static

Definition at line 5658 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
    HRESULT hr;
    DWORD h;
 
    TRACE("iface %p, stateblock %p.\n", iface, stateblock);
 
    if (!stateblock)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
 
    hr = wined3d_device_end_stateblock(device->wined3d_device, &wined3d_sb);
    if (FAILED(hr))
    {
        WARN("Failed to end stateblock, hr %#x.\n", hr);
        wined3d_mutex_unlock();
        *stateblock = 0;
        return hr_ddraw_from_wined3d(hr);
    }
 
    h = ddraw_allocate_handle(&device->handle_table, wined3d_sb, DDRAW_HANDLE_STATEBLOCK);
    if (h == DDRAW_INVALID_HANDLE)
    {
        ERR("Failed to allocate a stateblock handle.\n");
        wined3d_stateblock_decref(wined3d_sb);
        wined3d_mutex_unlock();
        *stateblock = 0;
        return DDERR_OUTOFMEMORY;
    }
 
    wined3d_mutex_unlock();
    *stateblock = h + 1;
 
    return hr_ddraw_from_wined3d(hr);
}

Referenced by d3d_device7_EndStateBlock_FPUPreserve(), and d3d_device7_EndStateBlock_FPUSetup().

d3d_device7_EndStateBlock_FPUPreserve()

static HRESULT WINAPI d3d_device7_EndStateBlock_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD *  stateblock  )

static

Definition at line 5702 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_EndStateBlock(iface, stateblock);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_EndStateBlock_FPUSetup()

static HRESULT WINAPI d3d_device7_EndStateBlock_FPUSetup ( IDirect3DDevice7 *  iface, DWORD *  stateblock  )

static

Definition at line 5697 of file device.c.

{
    return d3d_device7_EndStateBlock(iface, stateblock);
}

d3d_device7_EnumTextureFormats()

static HRESULT d3d_device7_EnumTextureFormats ( IDirect3DDevice7 *  iface, LPD3DENUMPIXELFORMATSCALLBACK  callback, void *  context  )

static

Definition at line 1036 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_display_mode mode;
    HRESULT hr;
    unsigned int i;
 
    static const enum wined3d_format_id FormatList[] =
    {
        /* 16 bit */
        WINED3DFMT_B5G5R5X1_UNORM,
        WINED3DFMT_B5G5R5A1_UNORM,
        WINED3DFMT_B4G4R4A4_UNORM,
        WINED3DFMT_B5G6R5_UNORM,
        /* 32 bit */
        WINED3DFMT_B8G8R8X8_UNORM,
        WINED3DFMT_B8G8R8A8_UNORM,
        /* 8 bit */
        WINED3DFMT_B2G3R3_UNORM,
        WINED3DFMT_P8_UINT,
        /* FOURCC codes */
        WINED3DFMT_DXT1,
        WINED3DFMT_DXT2,
        WINED3DFMT_DXT3,
        WINED3DFMT_DXT4,
        WINED3DFMT_DXT5,
    };
 
    static const enum wined3d_format_id BumpFormatList[] =
    {
        WINED3DFMT_R8G8_SNORM,
        WINED3DFMT_R5G5_SNORM_L6_UNORM,
        WINED3DFMT_R8G8_SNORM_L8X8_UNORM,
        WINED3DFMT_R10G11B11_SNORM,
        WINED3DFMT_R10G10B10_SNORM_A2_UNORM
    };
 
    TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
 
    if (!callback)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
 
    memset(&mode, 0, sizeof(mode));
    if (FAILED(hr = wined3d_get_adapter_display_mode(device->ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
    {
        wined3d_mutex_unlock();
        WARN("Cannot get the current adapter format\n");
        return hr;
    }
 
    for (i = 0; i < ARRAY_SIZE(FormatList); ++i)
    {
        if (wined3d_check_device_format(device->ddraw->wined3d, WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL,
                mode.format_id, WINED3DUSAGE_TEXTURE, WINED3D_RTYPE_TEXTURE_2D, FormatList[i]) == D3D_OK)
        {
            DDPIXELFORMAT pformat;
 
            memset(&pformat, 0, sizeof(pformat));
            pformat.dwSize = sizeof(pformat);
            ddrawformat_from_wined3dformat(&pformat, FormatList[i]);
 
            TRACE("Enumerating WineD3DFormat %d\n", FormatList[i]);
            hr = callback(&pformat, context);
            if(hr != DDENUMRET_OK)
            {
                TRACE("Format enumeration cancelled by application\n");
                wined3d_mutex_unlock();
                return D3D_OK;
            }
        }
    }
 
    for (i = 0; i < ARRAY_SIZE(BumpFormatList); ++i)
    {
        if (wined3d_check_device_format(device->ddraw->wined3d, WINED3DADAPTER_DEFAULT,
                WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_TEXTURE | WINED3DUSAGE_QUERY_LEGACYBUMPMAP,
                WINED3D_RTYPE_TEXTURE_2D, BumpFormatList[i]) == D3D_OK)
        {
            DDPIXELFORMAT pformat;
 
            memset(&pformat, 0, sizeof(pformat));
            pformat.dwSize = sizeof(pformat);
            ddrawformat_from_wined3dformat(&pformat, BumpFormatList[i]);
 
            TRACE("Enumerating WineD3DFormat %d\n", BumpFormatList[i]);
            hr = callback(&pformat, context);
            if(hr != DDENUMRET_OK)
            {
                TRACE("Format enumeration cancelled by application\n");
                wined3d_mutex_unlock();
                return D3D_OK;
            }
        }
    }
    TRACE("End of enumeration\n");
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_EnumTextureFormats_FPUPreserve(), and d3d_device7_EnumTextureFormats_FPUSetup().

d3d_device7_EnumTextureFormats_FPUPreserve()

static HRESULT WINAPI d3d_device7_EnumTextureFormats_FPUPreserve ( IDirect3DDevice7 *  iface, LPD3DENUMPIXELFORMATSCALLBACK  callback, void *  context  )

static

Definition at line 1145 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_EnumTextureFormats(iface, callback, context);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_EnumTextureFormats_FPUSetup()

static HRESULT WINAPI d3d_device7_EnumTextureFormats_FPUSetup ( IDirect3DDevice7 *  iface, LPD3DENUMPIXELFORMATSCALLBACK  callback, void *  context  )

static

Definition at line 1139 of file device.c.

{
    return d3d_device7_EnumTextureFormats(iface, callback, context);
}

d3d_device7_GetCaps()

static HRESULT d3d_device7_GetCaps ( IDirect3DDevice7 *  iface, D3DDEVICEDESC7 *  device_desc  )

static

Definition at line 398 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, device_desc %p.\n", iface, device_desc);
 
    if (!device_desc)
    {
        WARN("device_desc is NULL, returning DDERR_INVALIDPARAMS.\n");
        return DDERR_INVALIDPARAMS;
    }
 
    /* Call the same function used by IDirect3D, this saves code */
    return ddraw_get_d3dcaps(device->ddraw, device_desc);
}

Referenced by d3d_device7_GetCaps_FPUPreserve(), and d3d_device7_GetCaps_FPUSetup().

d3d_device7_GetCaps_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetCaps_FPUPreserve ( IDirect3DDevice7 *  iface, D3DDEVICEDESC7 *  desc  )

static

Definition at line 419 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetCaps(iface, desc);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetCaps_FPUSetup()

static HRESULT WINAPI d3d_device7_GetCaps_FPUSetup ( IDirect3DDevice7 *  iface, D3DDEVICEDESC7 *  desc  )

static

Definition at line 414 of file device.c.

{
    return d3d_device7_GetCaps(iface, desc);
}

d3d_device7_GetClipPlane()

static HRESULT d3d_device7_GetClipPlane ( IDirect3DDevice7 *  iface, DWORD  idx, D3DVALUE *  plane  )

static

Definition at line 6529 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_vec4 *wined3d_plane;
    HRESULT hr;
 
    TRACE("iface %p, idx %u, plane %p.\n", iface, idx, plane);
 
    if (!plane)
        return DDERR_INVALIDPARAMS;
 
    wined3d_plane = (struct wined3d_vec4 *)plane;
 
    wined3d_mutex_lock();
    hr = wined3d_device_get_clip_plane(device->wined3d_device, idx, wined3d_plane);
    if (hr == WINED3DERR_INVALIDCALL && idx < ARRAY_SIZE(device->user_clip_planes))
    {
        WARN("Clip plane %u is not supported.\n", idx);
        *wined3d_plane = device->user_clip_planes[idx];
        hr = D3D_OK;
    }
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_GetClipPlane_FPUPreserve(), and d3d_device7_GetClipPlane_FPUSetup().

d3d_device7_GetClipPlane_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetClipPlane_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  idx, D3DVALUE *  plane  )

static

Definition at line 6560 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetClipPlane(iface, idx, plane);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetClipPlane_FPUSetup()

static HRESULT WINAPI d3d_device7_GetClipPlane_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  idx, D3DVALUE *  plane  )

static

Definition at line 6555 of file device.c.

{
    return d3d_device7_GetClipPlane(iface, idx, plane);
}

d3d_device7_GetClipStatus()

static HRESULT WINAPI d3d_device7_GetClipStatus ( IDirect3DDevice7 *  iface, D3DCLIPSTATUS *  clip_status  )

static

Definition at line 3920 of file device.c.

{
    FIXME("iface %p, clip_status %p stub!\n", iface, clip_status);
 
    return D3D_OK;
}

d3d_device7_GetDirect3D()

static HRESULT WINAPI d3d_device7_GetDirect3D ( IDirect3DDevice7 *  iface, IDirect3D7 **  d3d  )

static

Definition at line 1612 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, d3d %p.\n", iface, d3d);
 
    if (!d3d)
        return DDERR_INVALIDPARAMS;
 
    *d3d = &device->ddraw->IDirect3D7_iface;
    IDirect3D7_AddRef(*d3d);
 
    TRACE("Returning interface %p.\n", *d3d);
    return D3D_OK;
}

d3d_device7_GetInfo()

static HRESULT WINAPI d3d_device7_GetInfo ( IDirect3DDevice7 *  iface, DWORD  info_id, void *  info, DWORD  info_size  )

static

Definition at line 6588 of file device.c.

{
    TRACE("iface %p, info_id %#x, info %p, info_size %u.\n",
            iface, info_id, info, info_size);
 
    if (TRACE_ON(ddraw))
    {
        TRACE(" info requested : ");
        switch (info_id)
        {
            case D3DDEVINFOID_TEXTUREMANAGER: TRACE("D3DDEVINFOID_TEXTUREMANAGER\n"); break;
            case D3DDEVINFOID_D3DTEXTUREMANAGER: TRACE("D3DDEVINFOID_D3DTEXTUREMANAGER\n"); break;
            case D3DDEVINFOID_TEXTURING: TRACE("D3DDEVINFOID_TEXTURING\n"); break;
            default: ERR(" invalid flag !!!\n"); return DDERR_INVALIDPARAMS;
        }
    }
 
    return S_FALSE; /* According to MSDN, this is valid for a non-debug driver */
}

d3d_device7_GetLight()

static HRESULT d3d_device7_GetLight ( IDirect3DDevice7 *  iface, DWORD  light_idx, D3DLIGHT7 *  light  )

static

Definition at line 5567 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT rc;
 
    TRACE("iface %p, light_idx %u, light %p.\n", iface, light_idx, light);
 
    wined3d_mutex_lock();
    /* Note: D3DLIGHT7 is compatible with struct wined3d_light. */
    rc =  wined3d_device_get_light(device->wined3d_device, light_idx, (struct wined3d_light *)light);
    wined3d_mutex_unlock();
 
    /* Translate the result. WineD3D returns other values than D3D7 */
    return hr_ddraw_from_wined3d(rc);
}

Referenced by d3d_device7_GetLight_FPUPreserve(), and d3d_device7_GetLight_FPUSetup().

d3d_device7_GetLight_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetLight_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  light_idx, D3DLIGHT7 *  light  )

static

Definition at line 5588 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetLight(iface, light_idx, light);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetLight_FPUSetup()

static HRESULT WINAPI d3d_device7_GetLight_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  light_idx, D3DLIGHT7 *  light  )

static

Definition at line 5583 of file device.c.

{
    return d3d_device7_GetLight(iface, light_idx, light);
}

d3d_device7_GetLightEnable()

static HRESULT d3d_device7_GetLightEnable ( IDirect3DDevice7 *  iface, DWORD  light_idx, BOOL *  enabled  )

static

Definition at line 6419 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, light_idx %u, enabled %p.\n", iface, light_idx, enabled);
 
    if (!enabled)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    hr = wined3d_device_get_light_enable(device->wined3d_device, light_idx, enabled);
    wined3d_mutex_unlock();
 
    return hr_ddraw_from_wined3d(hr);
}

Referenced by d3d_device7_GetLightEnable_FPUPreserve(), and d3d_device7_GetLightEnable_FPUSetup().

d3d_device7_GetLightEnable_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetLightEnable_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  light_idx, BOOL *  enabled  )

static

Definition at line 6441 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetLightEnable(iface, light_idx, enabled);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetLightEnable_FPUSetup()

static HRESULT WINAPI d3d_device7_GetLightEnable_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  light_idx, BOOL *  enabled  )

static

Definition at line 6436 of file device.c.

{
    return d3d_device7_GetLightEnable(iface, light_idx, enabled);
}

d3d_device7_GetMaterial()

static HRESULT d3d_device7_GetMaterial ( IDirect3DDevice7 *  iface, D3DMATERIAL7 *  material  )

static

Definition at line 5476 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, material %p.\n", iface, material);
 
    wined3d_mutex_lock();
    /* Note: D3DMATERIAL7 is compatible with struct wined3d_material. */
    wined3d_device_get_material(device->wined3d_device, (struct wined3d_material *)material);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_GetMaterial_FPUPreserve(), and d3d_device7_GetMaterial_FPUSetup().

d3d_device7_GetMaterial_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetMaterial_FPUPreserve ( IDirect3DDevice7 *  iface, D3DMATERIAL7 *  material  )

static

Definition at line 5495 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetMaterial(iface, material);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetMaterial_FPUSetup()

static HRESULT WINAPI d3d_device7_GetMaterial_FPUSetup ( IDirect3DDevice7 *  iface, D3DMATERIAL7 *  material  )

static

Definition at line 5490 of file device.c.

{
    return d3d_device7_GetMaterial(iface, material);
}

d3d_device7_GetRenderState()

static HRESULT d3d_device7_GetRenderState ( IDirect3DDevice7 *  iface, D3DRENDERSTATETYPE  state, DWORD *  value  )

static

Definition at line 2288 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr = D3D_OK;
 
    TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
 
    if (!value)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    switch (state)
    {
        case D3DRENDERSTATE_TEXTUREMAG:
        {
            enum wined3d_texture_filter_type tex_mag;
 
            tex_mag = wined3d_device_get_sampler_state(device->wined3d_device, 0, WINED3D_SAMP_MAG_FILTER);
            switch (tex_mag)
            {
                case WINED3D_TEXF_POINT:
                    *value = D3DFILTER_NEAREST;
                    break;
                case WINED3D_TEXF_LINEAR:
                    *value = D3DFILTER_LINEAR;
                    break;
                default:
                    ERR("Unhandled texture mag %d !\n",tex_mag);
                    *value = 0;
            }
            break;
        }
 
        case D3DRENDERSTATE_TEXTUREMIN:
        {
            enum wined3d_texture_filter_type tex_min;
            enum wined3d_texture_filter_type tex_mip;
 
            tex_min = wined3d_device_get_sampler_state(device->wined3d_device, 0, WINED3D_SAMP_MIN_FILTER);
            tex_mip = wined3d_device_get_sampler_state(device->wined3d_device, 0, WINED3D_SAMP_MIP_FILTER);
            switch (tex_min)
            {
                case WINED3D_TEXF_POINT:
                    switch (tex_mip)
                    {
                        case WINED3D_TEXF_NONE:
                            *value = D3DFILTER_NEAREST;
                            break;
                        case WINED3D_TEXF_POINT:
                            *value = D3DFILTER_MIPNEAREST;
                            break;
                        case WINED3D_TEXF_LINEAR:
                            *value = D3DFILTER_LINEARMIPNEAREST;
                            break;
                        default:
                            ERR("Unhandled mip filter %#x.\n", tex_mip);
                            *value = D3DFILTER_NEAREST;
                            break;
                    }
                    break;
                case WINED3D_TEXF_LINEAR:
                    switch (tex_mip)
                    {
                        case WINED3D_TEXF_NONE:
                            *value = D3DFILTER_LINEAR;
                            break;
                        case WINED3D_TEXF_POINT:
                            *value = D3DFILTER_MIPLINEAR;
                            break;
                        case WINED3D_TEXF_LINEAR:
                            *value = D3DFILTER_LINEARMIPLINEAR;
                            break;
                        default:
                            ERR("Unhandled mip filter %#x.\n", tex_mip);
                            *value = D3DFILTER_LINEAR;
                            break;
                    }
                    break;
                default:
                    ERR("Unhandled texture min filter %#x.\n",tex_min);
                    *value = D3DFILTER_NEAREST;
                    break;
            }
            break;
        }
 
        case D3DRENDERSTATE_TEXTUREADDRESS:
        case D3DRENDERSTATE_TEXTUREADDRESSU:
            *value = wined3d_device_get_sampler_state(device->wined3d_device, 0, WINED3D_SAMP_ADDRESS_U);
            break;
        case D3DRENDERSTATE_TEXTUREADDRESSV:
            *value = wined3d_device_get_sampler_state(device->wined3d_device, 0, WINED3D_SAMP_ADDRESS_V);
            break;
 
        case D3DRENDERSTATE_BORDERCOLOR:
            FIXME("Unhandled render state D3DRENDERSTATE_BORDERCOLOR.\n");
            hr = E_NOTIMPL;
            break;
 
        case D3DRENDERSTATE_TEXTUREHANDLE:
        case D3DRENDERSTATE_TEXTUREMAPBLEND:
            WARN("Render state %#x is invalid in d3d7.\n", state);
            hr = DDERR_INVALIDPARAMS;
            break;
 
        case D3DRENDERSTATE_ZBIAS:
            *value = wined3d_device_get_render_state(device->wined3d_device, WINED3D_RS_DEPTHBIAS);
            break;
 
        default:
            if (state >= D3DRENDERSTATE_STIPPLEPATTERN00
                    && state <= D3DRENDERSTATE_STIPPLEPATTERN31)
            {
                FIXME("Unhandled stipple pattern render state (%#x).\n", state);
                hr = E_NOTIMPL;
                break;
            }
            *value = wined3d_device_get_render_state(device->wined3d_device, state);
    }
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_GetRenderState_FPUPreserve(), and d3d_device7_GetRenderState_FPUSetup().

d3d_device7_GetRenderState_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetRenderState_FPUPreserve ( IDirect3DDevice7 *  iface, D3DRENDERSTATETYPE  state, DWORD *  value  )

static

Definition at line 2419 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetRenderState(iface, state, value);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetRenderState_FPUSetup()

static HRESULT WINAPI d3d_device7_GetRenderState_FPUSetup ( IDirect3DDevice7 *  iface, D3DRENDERSTATETYPE  state, DWORD *  value  )

static

Definition at line 2413 of file device.c.

{
    return d3d_device7_GetRenderState(iface, state, value);
}

d3d_device7_GetRenderTarget()

static HRESULT WINAPI d3d_device7_GetRenderTarget ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 **  RenderTarget  )

static

Definition at line 2014 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, target %p.\n", iface, RenderTarget);
 
    if(!RenderTarget)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    hr = IUnknown_QueryInterface(device->rt_iface, &IID_IDirectDrawSurface7, (void **)RenderTarget);
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device2_GetRenderTarget(), and d3d_device3_GetRenderTarget().

d3d_device7_GetTexture()

static HRESULT d3d_device7_GetTexture ( IDirect3DDevice7 *  iface, DWORD  stage, IDirectDrawSurface7 **  texture  )

static

Definition at line 4686 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_texture *wined3d_texture;
    struct ddraw_texture *ddraw_texture;
 
    TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
 
    if (!texture)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    if (!(wined3d_texture = wined3d_device_get_texture(device->wined3d_device, stage)))
    {
        *texture = NULL;
        wined3d_mutex_unlock();
        return D3D_OK;
    }
 
    ddraw_texture = wined3d_texture_get_parent(wined3d_texture);
    *texture = &ddraw_texture->root->IDirectDrawSurface7_iface;
    IDirectDrawSurface7_AddRef(*texture);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_GetTexture_FPUPreserve(), and d3d_device7_GetTexture_FPUSetup().

d3d_device7_GetTexture_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetTexture_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  stage, IDirectDrawSurface7 **  Texture  )

static

Definition at line 4720 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetTexture(iface, stage, Texture);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetTexture_FPUSetup()

static HRESULT WINAPI d3d_device7_GetTexture_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  stage, IDirectDrawSurface7 **  Texture  )

static

Definition at line 4714 of file device.c.

{
    return d3d_device7_GetTexture(iface, stage, Texture);
}

d3d_device7_GetTextureStageState()

static HRESULT d3d_device7_GetTextureStageState ( IDirect3DDevice7 *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  state, DWORD *  value  )

static

Definition at line 4911 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    const struct tss_lookup *l;
 
    TRACE("iface %p, stage %u, state %#x, value %p.\n",
            iface, stage, state, value);
 
    if (!value)
        return DDERR_INVALIDPARAMS;
 
    if (state > D3DTSS_TEXTURETRANSFORMFLAGS)
    {
        WARN("Invalid state %#x passed.\n", state);
        return DD_OK;
    }
 
    l = &tss_lookup[state];
 
    wined3d_mutex_lock();
 
    if (l->sampler_state)
    {
        *value = wined3d_device_get_sampler_state(device->wined3d_device, stage, l->u.sampler_state);
 
        switch (state)
        {
            /* Mipfilter is a sampler state with different values */
            case D3DTSS_MIPFILTER:
            {
                switch (*value)
                {
                    case WINED3D_TEXF_NONE:
                        *value = D3DTFP_NONE;
                        break;
                    case WINED3D_TEXF_POINT:
                        *value = D3DTFP_POINT;
                        break;
                    case WINED3D_TEXF_LINEAR:
                        *value = D3DTFP_LINEAR;
                        break;
                    default:
                        ERR("Unexpected mipfilter value %#x.\n", *value);
                        *value = D3DTFP_NONE;
                        break;
                }
                break;
            }
 
            /* Magfilter has slightly different values */
            case D3DTSS_MAGFILTER:
            {
                switch (*value)
                {
                    case WINED3D_TEXF_POINT:
                            *value = D3DTFG_POINT;
                            break;
                    case WINED3D_TEXF_LINEAR:
                            *value = D3DTFG_LINEAR;
                            break;
                    case WINED3D_TEXF_ANISOTROPIC:
                            *value = D3DTFG_ANISOTROPIC;
                            break;
                    case WINED3D_TEXF_FLAT_CUBIC:
                            *value = D3DTFG_FLATCUBIC;
                            break;
                    case WINED3D_TEXF_GAUSSIAN_CUBIC:
                            *value = D3DTFG_GAUSSIANCUBIC;
                            break;
                    default:
                        ERR("Unexpected wined3d mag filter value %#x.\n", *value);
                        *value = D3DTFG_POINT;
                        break;
                }
                break;
            }
 
            default:
                break;
        }
    }
    else
    {
        *value = wined3d_device_get_texture_stage_state(device->wined3d_device, stage, l->u.texture_state);
    }
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_GetTextureStageState_FPUPreserve(), and d3d_device7_GetTextureStageState_FPUSetup().

d3d_device7_GetTextureStageState_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetTextureStageState_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  state, DWORD *  value  )

static

Definition at line 5009 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetTextureStageState(iface, stage, state, value);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetTextureStageState_FPUSetup()

static HRESULT WINAPI d3d_device7_GetTextureStageState_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  state, DWORD *  value  )

static

Definition at line 5003 of file device.c.

{
    return d3d_device7_GetTextureStageState(iface, stage, state, value);
}

d3d_device7_GetTransform()

static HRESULT d3d_device7_GetTransform ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3244 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    enum wined3d_transform_state wined3d_state;
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    switch (state)
    {
        case D3DTRANSFORMSTATE_WORLD:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(0);
            break;
        case D3DTRANSFORMSTATE_WORLD1:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(1);
            break;
        case D3DTRANSFORMSTATE_WORLD2:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(2);
            break;
        case D3DTRANSFORMSTATE_WORLD3:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(3);
            break;
        default:
            wined3d_state = state;
    }
 
    if (!matrix)
        return DDERR_INVALIDPARAMS;
 
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
    wined3d_mutex_lock();
    wined3d_device_get_transform(device->wined3d_device, wined3d_state, (struct wined3d_matrix *)matrix);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_GetTransform_FPUPreserve(), and d3d_device7_GetTransform_FPUSetup().

d3d_device7_GetTransform_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetTransform_FPUPreserve ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3287 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetTransform(iface, state, matrix);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetTransform_FPUSetup()

static HRESULT WINAPI d3d_device7_GetTransform_FPUSetup ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3281 of file device.c.

{
    return d3d_device7_GetTransform(iface, state, matrix);
}

d3d_device7_GetViewport()

static HRESULT d3d_device7_GetViewport ( IDirect3DDevice7 *  iface, D3DVIEWPORT7 *  viewport  )

static

Definition at line 5371 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_viewport wined3d_viewport;
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    if (!viewport)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    wined3d_device_get_viewport(device->wined3d_device, &wined3d_viewport);
    wined3d_mutex_unlock();
 
    viewport->dwX = wined3d_viewport.x;
    viewport->dwY = wined3d_viewport.y;
    viewport->dwWidth = wined3d_viewport.width;
    viewport->dwHeight = wined3d_viewport.height;
    viewport->dvMinZ = wined3d_viewport.min_z;
    viewport->dvMaxZ = wined3d_viewport.max_z;
 
    return D3D_OK;
}

Referenced by d3d_device7_GetViewport_FPUPreserve(), and d3d_device7_GetViewport_FPUSetup().

d3d_device7_GetViewport_FPUPreserve()

static HRESULT WINAPI d3d_device7_GetViewport_FPUPreserve ( IDirect3DDevice7 *  iface, D3DVIEWPORT7 *  viewport  )

static

Definition at line 5400 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_GetViewport(iface, viewport);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_GetViewport_FPUSetup()

static HRESULT WINAPI d3d_device7_GetViewport_FPUSetup ( IDirect3DDevice7 *  iface, D3DVIEWPORT7 *  viewport  )

static

Definition at line 5395 of file device.c.

{
    return d3d_device7_GetViewport(iface, viewport);
}

d3d_device7_LightEnable()

static HRESULT d3d_device7_LightEnable ( IDirect3DDevice7 *  iface, DWORD  light_idx, BOOL  enabled  )

static

Definition at line 6372 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, light_idx %u, enabled %#x.\n", iface, light_idx, enabled);
 
    wined3d_mutex_lock();
    hr = wined3d_device_set_light_enable(device->wined3d_device, light_idx, enabled);
    wined3d_mutex_unlock();
 
    return hr_ddraw_from_wined3d(hr);
}

Referenced by d3d_device7_LightEnable_FPUPreserve(), and d3d_device7_LightEnable_FPUSetup().

d3d_device7_LightEnable_FPUPreserve()

static HRESULT WINAPI d3d_device7_LightEnable_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  light_idx, BOOL  enabled  )

static

Definition at line 6391 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_LightEnable(iface, light_idx, enabled);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_LightEnable_FPUSetup()

static HRESULT WINAPI d3d_device7_LightEnable_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  light_idx, BOOL  enabled  )

static

Definition at line 6386 of file device.c.

{
    return d3d_device7_LightEnable(iface, light_idx, enabled);
}

d3d_device7_Load()

static HRESULT d3d_device7_Load ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  dst_texture, POINT *  dst_pos, IDirectDrawSurface7 *  src_texture, RECT *  src_rect, DWORD  flags  )

static

Definition at line 6173 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct ddraw_surface *dest = unsafe_impl_from_IDirectDrawSurface7(dst_texture);
    struct ddraw_surface *src = unsafe_impl_from_IDirectDrawSurface7(src_texture);
    POINT destpoint;
    RECT srcrect;
 
    TRACE("iface %p, dst_texture %p, dst_pos %s, src_texture %p, src_rect %s, flags %#x.\n",
            iface, dst_texture, wine_dbgstr_point(dst_pos), src_texture, wine_dbgstr_rect(src_rect), flags);
 
    if( (!src) || (!dest) )
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
 
    if (!src_rect)
        SetRect(&srcrect, 0, 0, src->surface_desc.dwWidth, src->surface_desc.dwHeight);
    else
        srcrect = *src_rect;
 
    if (!dst_pos)
        destpoint.x = destpoint.y = 0;
    else
        destpoint = *dst_pos;
 
    /* Check bad dimensions. dst_pos is validated against src, not dest, because
     * destination can be a subset of mip levels, in which case actual coordinates used
     * for it may be divided. If any dimension of dest is larger than source, it can't be
     * mip level subset, so an error can be returned early.
     */
    if (IsRectEmpty(&srcrect) || srcrect.right > src->surface_desc.dwWidth ||
        srcrect.bottom > src->surface_desc.dwHeight ||
        destpoint.x + srcrect.right - srcrect.left > src->surface_desc.dwWidth ||
        destpoint.y + srcrect.bottom - srcrect.top > src->surface_desc.dwHeight ||
        dest->surface_desc.dwWidth > src->surface_desc.dwWidth ||
        dest->surface_desc.dwHeight > src->surface_desc.dwHeight)
    {
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    /* Must be top level surfaces. */
    if (src->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_MIPMAPSUBLEVEL ||
        dest->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_MIPMAPSUBLEVEL)
    {
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    if (src->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
    {
        struct ddraw_surface *src_face, *dest_face;
        DWORD src_face_flag, dest_face_flag;
        IDirectDrawSurface7 *temp;
        DDSURFACEDESC2 ddsd;
        int i;
 
        if (!(dest->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
        {
            wined3d_mutex_unlock();
            return DDERR_INVALIDPARAMS;
        }
 
        /* Iterate through cube faces 2 times. First time is just to check INVALIDPARAMS conditions, second
         * time it's actual surface loading. */
        for (i = 0; i < 2; i++)
        {
            dest_face = dest;
            src_face = src;
 
            for (;dest_face && src_face;)
            {
                src_face_flag = src_face->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES;
                dest_face_flag = dest_face->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES;
 
                if (src_face_flag == dest_face_flag)
                {
                    if (i == 0)
                    {
                        /* Destination mip levels must be subset of source mip levels. */
                        if (!is_mip_level_subset(dest_face, src_face))
                        {
                            wined3d_mutex_unlock();
                            return DDERR_INVALIDPARAMS;
                        }
                    }
                    else if (flags & dest_face_flag)
                    {
                        copy_mipmap_chain(device, dest_face, src_face, &destpoint, &srcrect);
                    }
 
                    if (src_face_flag < DDSCAPS2_CUBEMAP_NEGATIVEZ)
                    {
                        ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
                        ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP | (src_face_flag << 1);
                        IDirectDrawSurface7_GetAttachedSurface(&src->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
 
                        if (src_face != src) IDirectDrawSurface7_Release(&src_face->IDirectDrawSurface7_iface);
 
                        src_face = unsafe_impl_from_IDirectDrawSurface7(temp);
                    }
                    else
                    {
                        if (src_face != src) IDirectDrawSurface7_Release(&src_face->IDirectDrawSurface7_iface);
 
                        src_face = NULL;
                    }
                }
 
                if (dest_face_flag < DDSCAPS2_CUBEMAP_NEGATIVEZ)
                {
                    ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
                    ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP | (dest_face_flag << 1);
                    IDirectDrawSurface7_GetAttachedSurface(&dest->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
 
                    if (dest_face != dest) IDirectDrawSurface7_Release(&dest_face->IDirectDrawSurface7_iface);
 
                    dest_face = unsafe_impl_from_IDirectDrawSurface7(temp);
                }
                else
                {
                    if (dest_face != dest) IDirectDrawSurface7_Release(&dest_face->IDirectDrawSurface7_iface);
 
                    dest_face = NULL;
                }
            }
 
            if (i == 0)
            {
                /* Native returns error if src faces are not subset of dest faces. */
                if (src_face)
                {
                    wined3d_mutex_unlock();
                    return DDERR_INVALIDPARAMS;
                }
            }
        }
 
        wined3d_mutex_unlock();
        return D3D_OK;
    }
    else if (dest->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
    {
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    /* Handle non cube map textures. */
 
    /* Destination mip levels must be subset of source mip levels. */
    if (!is_mip_level_subset(dest, src))
    {
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    copy_mipmap_chain(device, dest, src, &destpoint, &srcrect);
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_Load_FPUPreserve(), and d3d_device7_Load_FPUSetup().

d3d_device7_Load_FPUPreserve()

static HRESULT WINAPI d3d_device7_Load_FPUPreserve ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  dst_texture, POINT *  dst_pos, IDirectDrawSurface7 *  src_texture, RECT *  src_rect, DWORD  flags  )

static

Definition at line 6344 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_Load(iface, dst_texture, dst_pos, src_texture, src_rect, flags);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_Load_FPUSetup()

static HRESULT WINAPI d3d_device7_Load_FPUSetup ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  dst_texture, POINT *  dst_pos, IDirectDrawSurface7 *  src_texture, RECT *  src_rect, DWORD  flags  )

static

Definition at line 6338 of file device.c.

{
    return d3d_device7_Load(iface, dst_texture, dst_pos, src_texture, src_rect, flags);
}

d3d_device7_MultiplyTransform()

static HRESULT d3d_device7_MultiplyTransform ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3348 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    enum wined3d_transform_state wined3d_state;
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    switch (state)
    {
        case D3DTRANSFORMSTATE_WORLD:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(0);
            break;
        case D3DTRANSFORMSTATE_WORLD1:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(1);
            break;
        case D3DTRANSFORMSTATE_WORLD2:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(2);
            break;
        case D3DTRANSFORMSTATE_WORLD3:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(3);
            break;
        default:
            wined3d_state = state;
    }
 
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
    wined3d_mutex_lock();
    wined3d_device_multiply_transform(device->wined3d_device,
            wined3d_state, (struct wined3d_matrix *)matrix);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_MultiplyTransform_FPUPreserve(), and d3d_device7_MultiplyTransform_FPUSetup().

d3d_device7_MultiplyTransform_FPUPreserve()

static HRESULT WINAPI d3d_device7_MultiplyTransform_FPUPreserve ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3389 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_MultiplyTransform(iface, state, matrix);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_MultiplyTransform_FPUSetup()

static HRESULT WINAPI d3d_device7_MultiplyTransform_FPUSetup ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3383 of file device.c.

{
    return d3d_device7_MultiplyTransform(iface, state, matrix);
}

d3d_device7_PreLoad()

static HRESULT d3d_device7_PreLoad ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  texture  )

static

Definition at line 5730 of file device.c.

{
    struct ddraw_surface *surface = unsafe_impl_from_IDirectDrawSurface7(texture);
 
    TRACE("iface %p, texture %p.\n", iface, texture);
 
    if (!texture)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    wined3d_resource_preload(wined3d_texture_get_resource(surface->wined3d_texture));
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_PreLoad_FPUPreserve(), and d3d_device7_PreLoad_FPUSetup().

d3d_device7_PreLoad_FPUPreserve()

static HRESULT WINAPI d3d_device7_PreLoad_FPUPreserve ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  texture  )

static

Definition at line 5751 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_PreLoad(iface, texture);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_PreLoad_FPUSetup()

static HRESULT WINAPI d3d_device7_PreLoad_FPUSetup ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  texture  )

static

Definition at line 5746 of file device.c.

{
    return d3d_device7_PreLoad(iface, texture);
}

d3d_device7_QueryInterface()

static HRESULT WINAPI d3d_device7_QueryInterface ( IDirect3DDevice7 *  iface, REFIID  riid, void **  out  )

static

Definition at line 141 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 
    return IUnknown_QueryInterface(device->outer_unknown, riid, out);
}

d3d_device7_Release()

static ULONG WINAPI d3d_device7_Release ( IDirect3DDevice7 *  iface )

static

Definition at line 333 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p.\n", iface);
 
    return IUnknown_Release(device->outer_unknown);
}

d3d_device7_SetClipPlane()

static HRESULT d3d_device7_SetClipPlane ( IDirect3DDevice7 *  iface, DWORD  idx, D3DVALUE *  plane  )

static

Definition at line 6469 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    const struct wined3d_vec4 *wined3d_plane;
    HRESULT hr;
 
    TRACE("iface %p, idx %u, plane %p.\n", iface, idx, plane);
 
    if (!plane)
        return DDERR_INVALIDPARAMS;
 
    wined3d_plane = (struct wined3d_vec4 *)plane;
 
    wined3d_mutex_lock();
    hr = wined3d_device_set_clip_plane(device->wined3d_device, idx, wined3d_plane);
    if (idx < ARRAY_SIZE(device->user_clip_planes))
    {
        device->user_clip_planes[idx] = *wined3d_plane;
        if (hr == WINED3DERR_INVALIDCALL)
        {
            WARN("Clip plane %u is not supported.\n", idx);
            hr = D3D_OK;
        }
    }
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_SetClipPlane_FPUPreserve(), and d3d_device7_SetClipPlane_FPUSetup().

d3d_device7_SetClipPlane_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetClipPlane_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  idx, D3DVALUE *  plane  )

static

Definition at line 6503 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetClipPlane(iface, idx, plane);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetClipPlane_FPUSetup()

static HRESULT WINAPI d3d_device7_SetClipPlane_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  idx, D3DVALUE *  plane  )

static

Definition at line 6498 of file device.c.

{
    return d3d_device7_SetClipPlane(iface, idx, plane);
}

d3d_device7_SetClipStatus()

static HRESULT WINAPI d3d_device7_SetClipStatus ( IDirect3DDevice7 *  iface, D3DCLIPSTATUS *  clip_status  )

static

Definition at line 3883 of file device.c.

{
    FIXME("iface %p, clip_status %p stub!\n", iface, clip_status);
 
    return D3D_OK;
}

d3d_device7_SetLight()

static HRESULT d3d_device7_SetLight ( IDirect3DDevice7 *  iface, DWORD  light_idx, D3DLIGHT7 *  light  )

static

Definition at line 5522 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, light_idx %u, light %p.\n", iface, light_idx, light);
 
    wined3d_mutex_lock();
    /* Note: D3DLIGHT7 is compatible with struct wined3d_light. */
    hr = wined3d_device_set_light(device->wined3d_device, light_idx, (struct wined3d_light *)light);
    wined3d_mutex_unlock();
 
    return hr_ddraw_from_wined3d(hr);
}

Referenced by d3d_device7_SetLight_FPUPreserve(), and d3d_device7_SetLight_FPUSetup().

d3d_device7_SetLight_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetLight_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  light_idx, D3DLIGHT7 *  light  )

static

Definition at line 5542 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetLight(iface, light_idx, light);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetLight_FPUSetup()

static HRESULT WINAPI d3d_device7_SetLight_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  light_idx, D3DLIGHT7 *  light  )

static

Definition at line 5537 of file device.c.

{
    return d3d_device7_SetLight(iface, light_idx, light);
}

d3d_device7_SetMaterial()

static HRESULT d3d_device7_SetMaterial ( IDirect3DDevice7 *  iface, D3DMATERIAL7 *  material  )

static

Definition at line 5427 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, material %p.\n", iface, material);
 
    if (!material)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    /* Note: D3DMATERIAL7 is compatible with struct wined3d_material. */
    wined3d_device_set_material(device->wined3d_device, (struct wined3d_material *)material);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_SetMaterial_FPUPreserve(), and d3d_device7_SetMaterial_FPUSetup().

d3d_device7_SetMaterial_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetMaterial_FPUPreserve ( IDirect3DDevice7 *  iface, D3DMATERIAL7 *  material  )

static

Definition at line 5449 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetMaterial(iface, material);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetMaterial_FPUSetup()

static HRESULT WINAPI d3d_device7_SetMaterial_FPUSetup ( IDirect3DDevice7 *  iface, D3DMATERIAL7 *  material  )

static

Definition at line 5444 of file device.c.

{
    return d3d_device7_SetMaterial(iface, material);
}

d3d_device7_SetRenderState()

static HRESULT d3d_device7_SetRenderState ( IDirect3DDevice7 *  iface, D3DRENDERSTATETYPE  state, DWORD  value  )

static

Definition at line 2557 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr = D3D_OK;
 
    TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
 
    wined3d_mutex_lock();
    /* Some render states need special care */
    switch (state)
    {
        /*
         * The ddraw texture filter mapping works like this:
         *     D3DFILTER_NEAREST            Point min/mag, no mip
         *     D3DFILTER_MIPNEAREST         Point min/mag, point mip
         *     D3DFILTER_LINEARMIPNEAREST:  Point min/mag, linear mip
         *
         *     D3DFILTER_LINEAR             Linear min/mag, no mip
         *     D3DFILTER_MIPLINEAR          Linear min/mag, point mip
         *     D3DFILTER_LINEARMIPLINEAR    Linear min/mag, linear mip
         *
         * This is the opposite of the GL naming convention,
         * D3DFILTER_LINEARMIPNEAREST corresponds to GL_NEAREST_MIPMAP_LINEAR.
         */
        case D3DRENDERSTATE_TEXTUREMAG:
        {
            enum wined3d_texture_filter_type tex_mag;
 
            switch (value)
            {
                case D3DFILTER_NEAREST:
                case D3DFILTER_MIPNEAREST:
                case D3DFILTER_LINEARMIPNEAREST:
                    tex_mag = WINED3D_TEXF_POINT;
                    break;
                case D3DFILTER_LINEAR:
                case D3DFILTER_MIPLINEAR:
                case D3DFILTER_LINEARMIPLINEAR:
                    tex_mag = WINED3D_TEXF_LINEAR;
                    break;
                default:
                    tex_mag = WINED3D_TEXF_POINT;
                    FIXME("Unhandled texture mag %#x.\n", value);
                    break;
            }
 
            wined3d_device_set_sampler_state(device->wined3d_device, 0, WINED3D_SAMP_MAG_FILTER, tex_mag);
            break;
        }
 
        case D3DRENDERSTATE_TEXTUREMIN:
        {
            enum wined3d_texture_filter_type tex_min;
            enum wined3d_texture_filter_type tex_mip;
 
            switch (value)
            {
                case D3DFILTER_NEAREST:
                    tex_min = WINED3D_TEXF_POINT;
                    tex_mip = WINED3D_TEXF_NONE;
                    break;
                case D3DFILTER_LINEAR:
                    tex_min = WINED3D_TEXF_LINEAR;
                    tex_mip = WINED3D_TEXF_NONE;
                    break;
                case D3DFILTER_MIPNEAREST:
                    tex_min = WINED3D_TEXF_POINT;
                    tex_mip = WINED3D_TEXF_POINT;
                    break;
                case D3DFILTER_MIPLINEAR:
                    tex_min = WINED3D_TEXF_LINEAR;
                    tex_mip = WINED3D_TEXF_POINT;
                    break;
                case D3DFILTER_LINEARMIPNEAREST:
                    tex_min = WINED3D_TEXF_POINT;
                    tex_mip = WINED3D_TEXF_LINEAR;
                    break;
                case D3DFILTER_LINEARMIPLINEAR:
                    tex_min = WINED3D_TEXF_LINEAR;
                    tex_mip = WINED3D_TEXF_LINEAR;
                    break;
 
                default:
                    FIXME("Unhandled texture min %#x.\n",value);
                    tex_min = WINED3D_TEXF_POINT;
                    tex_mip = WINED3D_TEXF_NONE;
                    break;
            }
 
            wined3d_device_set_sampler_state(device->wined3d_device,
                    0, WINED3D_SAMP_MIP_FILTER, tex_mip);
            wined3d_device_set_sampler_state(device->wined3d_device,
                    0, WINED3D_SAMP_MIN_FILTER, tex_min);
            break;
        }
 
        case D3DRENDERSTATE_TEXTUREADDRESS:
            wined3d_device_set_sampler_state(device->wined3d_device,
                    0, WINED3D_SAMP_ADDRESS_V, value);
            /* Drop through */
        case D3DRENDERSTATE_TEXTUREADDRESSU:
            wined3d_device_set_sampler_state(device->wined3d_device,
                    0, WINED3D_SAMP_ADDRESS_U, value);
            break;
        case D3DRENDERSTATE_TEXTUREADDRESSV:
            wined3d_device_set_sampler_state(device->wined3d_device,
                    0, WINED3D_SAMP_ADDRESS_V, value);
            break;
 
        case D3DRENDERSTATE_BORDERCOLOR:
            /* This should probably just forward to the corresponding sampler
             * state. Needs tests. */
            FIXME("Unhandled render state D3DRENDERSTATE_BORDERCOLOR.\n");
            hr = E_NOTIMPL;
            break;
 
        case D3DRENDERSTATE_TEXTUREHANDLE:
        case D3DRENDERSTATE_TEXTUREMAPBLEND:
            WARN("Render state %#x is invalid in d3d7.\n", state);
            hr = DDERR_INVALIDPARAMS;
            break;
 
        case D3DRENDERSTATE_ZBIAS:
            wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DEPTHBIAS, value);
            break;
 
        default:
            if (state >= D3DRENDERSTATE_STIPPLEPATTERN00
                    && state <= D3DRENDERSTATE_STIPPLEPATTERN31)
            {
                FIXME("Unhandled stipple pattern render state (%#x).\n", state);
                hr = E_NOTIMPL;
                break;
            }
 
            wined3d_device_set_render_state(device->wined3d_device, state, value);
            break;
    }
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_SetRenderState_FPUPreserve(), and d3d_device7_SetRenderState_FPUSetup().

d3d_device7_SetRenderState_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetRenderState_FPUPreserve ( IDirect3DDevice7 *  iface, D3DRENDERSTATETYPE  state, DWORD  value  )

static

Definition at line 2707 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetRenderState(iface, state, value);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetRenderState_FPUSetup()

static HRESULT WINAPI d3d_device7_SetRenderState_FPUSetup ( IDirect3DDevice7 *  iface, D3DRENDERSTATETYPE  state, DWORD  value  )

static

Definition at line 2701 of file device.c.

{
    return d3d_device7_SetRenderState(iface, state, value);
}

d3d_device7_SetRenderTarget()

static HRESULT d3d_device7_SetRenderTarget ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  target, DWORD  flags  )

static

Definition at line 1832 of file device.c.

{
    struct ddraw_surface *target_impl = unsafe_impl_from_IDirectDrawSurface7(target);
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, target %p, flags %#x.\n", iface, target, flags);
 
    wined3d_mutex_lock();
 
    if (!validate_surface_palette(target_impl))
    {
        WARN("Surface %p has an indexed pixel format, but no palette.\n", target_impl);
        wined3d_mutex_unlock();
        return DDERR_INVALIDCAPS;
    }
 
    if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
    {
        WARN("Surface %p is not a render target.\n", target_impl);
        wined3d_mutex_unlock();
        return DDERR_INVALIDCAPS;
    }
 
    if (device->hw && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
    {
        WARN("Surface %p is not in video memory.\n", target_impl);
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    if (target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
    {
        WARN("Surface %p is a depth buffer.\n", target_impl);
        IDirectDrawSurface7_AddRef(target);
        IUnknown_Release(device->rt_iface);
        device->rt_iface = (IUnknown *)target;
        wined3d_mutex_unlock();
        return DDERR_INVALIDPIXELFORMAT;
    }
 
    hr = d3d_device_set_render_target(device, target_impl, (IUnknown *)target);
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d_device7_SetRenderTarget_FPUPreserve(), and d3d_device7_SetRenderTarget_FPUSetup().

d3d_device7_SetRenderTarget_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetRenderTarget_FPUPreserve ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  NewTarget, DWORD  flags  )

static

Definition at line 1885 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetRenderTarget(iface, NewTarget, flags);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetRenderTarget_FPUSetup()

static HRESULT WINAPI d3d_device7_SetRenderTarget_FPUSetup ( IDirect3DDevice7 *  iface, IDirectDrawSurface7 *  NewTarget, DWORD  flags  )

static

Definition at line 1879 of file device.c.

{
    return d3d_device7_SetRenderTarget(iface, NewTarget, flags);
}

d3d_device7_SetTexture()

static HRESULT d3d_device7_SetTexture ( IDirect3DDevice7 *  iface, DWORD  stage, IDirectDrawSurface7 *  texture  )

static

Definition at line 4767 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct ddraw_surface *surf = unsafe_impl_from_IDirectDrawSurface7(texture);
    struct wined3d_texture *wined3d_texture = NULL;
    HRESULT hr;
 
    TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
 
    if (surf && (surf->surface_desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE))
        wined3d_texture = surf->wined3d_texture;
 
    wined3d_mutex_lock();
    hr = wined3d_device_set_texture(device->wined3d_device, stage, wined3d_texture);
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_SetTexture_FPUPreserve(), and d3d_device7_SetTexture_FPUSetup().

d3d_device7_SetTexture_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetTexture_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  stage, IDirectDrawSurface7 *  texture  )

static

Definition at line 4793 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetTexture(iface, stage, texture);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetTexture_FPUSetup()

static HRESULT WINAPI d3d_device7_SetTexture_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  stage, IDirectDrawSurface7 *  texture  )

static

Definition at line 4787 of file device.c.

{
    return d3d_device7_SetTexture(iface, stage, texture);
}

d3d_device7_SetTextureStageState()

static HRESULT d3d_device7_SetTextureStageState ( IDirect3DDevice7 *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  state, DWORD  value  )

static

Definition at line 5050 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    const struct tss_lookup *l;
 
    TRACE("iface %p, stage %u, state %#x, value %#x.\n",
            iface, stage, state, value);
 
    if (state > D3DTSS_TEXTURETRANSFORMFLAGS)
    {
        WARN("Invalid state %#x passed.\n", state);
        return DD_OK;
    }
 
    l = &tss_lookup[state];
 
    wined3d_mutex_lock();
 
    if (l->sampler_state)
    {
        switch (state)
        {
            /* Mipfilter is a sampler state with different values */
            case D3DTSS_MIPFILTER:
            {
                switch (value)
                {
                    case D3DTFP_NONE:
                        value = WINED3D_TEXF_NONE;
                        break;
                    case D3DTFP_POINT:
                        value = WINED3D_TEXF_POINT;
                        break;
                    case 0: /* Unchecked */
                    case D3DTFP_LINEAR:
                        value = WINED3D_TEXF_LINEAR;
                        break;
                    default:
                        ERR("Unexpected mipfilter value %#x.\n", value);
                        value = WINED3D_TEXF_NONE;
                        break;
                }
                break;
            }
 
            /* Magfilter has slightly different values */
            case D3DTSS_MAGFILTER:
            {
                switch (value)
                {
                    case D3DTFG_POINT:
                        value = WINED3D_TEXF_POINT;
                        break;
                    case D3DTFG_LINEAR:
                        value = WINED3D_TEXF_LINEAR;
                        break;
                    case D3DTFG_FLATCUBIC:
                        value = WINED3D_TEXF_FLAT_CUBIC;
                        break;
                    case D3DTFG_GAUSSIANCUBIC:
                        value = WINED3D_TEXF_GAUSSIAN_CUBIC;
                        break;
                    case D3DTFG_ANISOTROPIC:
                        value = WINED3D_TEXF_ANISOTROPIC;
                        break;
                    default:
                        ERR("Unexpected d3d7 mag filter value %#x.\n", value);
                        value = WINED3D_TEXF_POINT;
                        break;
                }
                break;
            }
 
            case D3DTSS_ADDRESS:
                wined3d_device_set_sampler_state(device->wined3d_device, stage, WINED3D_SAMP_ADDRESS_V, value);
                break;
 
            default:
                break;
        }
 
        wined3d_device_set_sampler_state(device->wined3d_device, stage, l->u.sampler_state, value);
    }
    else
    {
        wined3d_device_set_texture_stage_state(device->wined3d_device, stage, l->u.texture_state, value);
    }
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_SetTextureStageState_FPUPreserve(), and d3d_device7_SetTextureStageState_FPUSetup().

d3d_device7_SetTextureStageState_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetTextureStageState_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  state, DWORD  value  )

static

Definition at line 5150 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetTextureStageState(iface, stage, state, value);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetTextureStageState_FPUSetup()

static HRESULT WINAPI d3d_device7_SetTextureStageState_FPUSetup ( IDirect3DDevice7 *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  state, DWORD  value  )

static

Definition at line 5144 of file device.c.

{
    return d3d_device7_SetTextureStageState(iface, stage, state, value);
}

d3d_device7_SetTransform()

static HRESULT d3d_device7_SetTransform ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3135 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    enum wined3d_transform_state wined3d_state;
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    switch (state)
    {
        case D3DTRANSFORMSTATE_WORLD:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(0);
            break;
        case D3DTRANSFORMSTATE_WORLD1:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(1);
            break;
        case D3DTRANSFORMSTATE_WORLD2:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(2);
            break;
        case D3DTRANSFORMSTATE_WORLD3:
            wined3d_state = WINED3D_TS_WORLD_MATRIX(3);
            break;
        default:
            wined3d_state = state;
    }
 
    if (!matrix)
        return DDERR_INVALIDPARAMS;
 
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
    wined3d_mutex_lock();
    wined3d_device_set_transform(device->wined3d_device, wined3d_state, (struct wined3d_matrix *)matrix);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_SetTransform_FPUPreserve(), and d3d_device7_SetTransform_FPUSetup().

d3d_device7_SetTransform_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetTransform_FPUPreserve ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3178 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetTransform(iface, state, matrix);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetTransform_FPUSetup()

static HRESULT WINAPI d3d_device7_SetTransform_FPUSetup ( IDirect3DDevice7 *  iface, D3DTRANSFORMSTATETYPE  state, D3DMATRIX *  matrix  )

static

Definition at line 3172 of file device.c.

{
    return d3d_device7_SetTransform(iface, state, matrix);
}

d3d_device7_SetViewport()

static HRESULT d3d_device7_SetViewport ( IDirect3DDevice7 *  iface, D3DVIEWPORT7 *  viewport  )

static

Definition at line 5315 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_viewport vp;
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    if (!viewport)
        return DDERR_INVALIDPARAMS;
 
    vp.x = viewport->dwX;
    vp.y = viewport->dwY;
    vp.width = viewport->dwWidth;
    vp.height = viewport->dwHeight;
    vp.min_z = viewport->dvMinZ;
    vp.max_z = viewport->dvMaxZ;
 
    wined3d_mutex_lock();
    wined3d_device_set_viewport(device->wined3d_device, &vp);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d_device7_SetViewport_FPUPreserve(), and d3d_device7_SetViewport_FPUSetup().

d3d_device7_SetViewport_FPUPreserve()

static HRESULT WINAPI d3d_device7_SetViewport_FPUPreserve ( IDirect3DDevice7 *  iface, D3DVIEWPORT7 *  viewport  )

static

Definition at line 5344 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_SetViewport(iface, viewport);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_SetViewport_FPUSetup()

static HRESULT WINAPI d3d_device7_SetViewport_FPUSetup ( IDirect3DDevice7 *  iface, D3DVIEWPORT7 *  viewport  )

static

Definition at line 5339 of file device.c.

{
    return d3d_device7_SetViewport(iface, viewport);
}

d3d_device7_ValidateDevice()

static HRESULT d3d_device7_ValidateDevice ( IDirect3DDevice7 *  iface, DWORD *  pass_count  )

static

Definition at line 5191 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, pass_count %p.\n", iface, pass_count);
 
    wined3d_mutex_lock();
    hr = wined3d_device_validate_device(device->wined3d_device, pass_count);
    wined3d_mutex_unlock();
 
    return hr;
}

Referenced by d3d_device7_ValidateDevice_FPUPreserve(), and d3d_device7_ValidateDevice_FPUSetup().

d3d_device7_ValidateDevice_FPUPreserve()

static HRESULT WINAPI d3d_device7_ValidateDevice_FPUPreserve ( IDirect3DDevice7 *  iface, DWORD *  pass_count  )

static

Definition at line 5210 of file device.c.

{
    HRESULT hr;
    WORD old_fpucw;
 
    old_fpucw = d3d_fpu_setup();
    hr = d3d_device7_ValidateDevice(iface, pass_count);
    set_fpu_control_word(old_fpucw);
 
    return hr;
}

d3d_device7_ValidateDevice_FPUSetup()

static HRESULT WINAPI d3d_device7_ValidateDevice_FPUSetup ( IDirect3DDevice7 *  iface, DWORD *  pass_count  )

static

Definition at line 5205 of file device.c.

{
    return d3d_device7_ValidateDevice(iface, pass_count);
}

d3d_device_create()

HRESULT d3d_device_create	(	struct ddraw *	ddraw,
		const GUID *	guid,
		struct ddraw_surface *	target,
		IUnknown *	rt_iface,
		UINT	version,
		struct d3d_device **	device,
		IUnknown *	outer_unknown
	)

Definition at line 6980 of file device.c.

{
    struct d3d_device *object;
    BOOL hw = TRUE;
    HRESULT hr;
 
    TRACE("ddraw %p, guid %s, target %p, version %u, device %p, outer_unknown %p.\n",
            ddraw, debugstr_guid(guid), target, version, device, outer_unknown);
 
    if (IsEqualGUID(guid, &IID_IDirect3DRGBDevice))
        hw = FALSE;
 
    if (!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
            || (target->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
    {
        WARN("Surface %p is not a render target.\n", target);
        return DDERR_INVALIDCAPS;
    }
 
    if (!validate_surface_palette(target))
    {
        WARN("Surface %p has an indexed pixel format, but no palette.\n", target);
        return DDERR_NOPALETTEATTACHED;
    }
 
    if (hw && !(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
    {
        WARN("Surface %p is not in video memory.\n", target);
        return D3DERR_SURFACENOTINVIDMEM;
    }
 
    if (ddraw->flags & DDRAW_NO3D)
    {
        ERR_(winediag)("The application wants to create a Direct3D device, "
                "but the current DirectDrawRenderer does not support this.\n");
 
        return DDERR_NO3D;
    }
 
    if (ddraw->d3ddevice)
    {
        FIXME("Only one Direct3D device per DirectDraw object supported.\n");
        return DDERR_INVALIDPARAMS;
    }
 
    if (!(object = heap_alloc_zero(sizeof(*object))))
    {
        ERR("Failed to allocate device memory.\n");
        return DDERR_OUTOFMEMORY;
    }
 
    if (FAILED(hr = d3d_device_init(object, ddraw, hw, target, rt_iface, version, outer_unknown)))
    {
        WARN("Failed to initialize device, hr %#x.\n", hr);
        heap_free(object);
        return hr;
    }
 
    TRACE("Created device %p.\n", object);
    *device = object;
 
    return D3D_OK;
}

Referenced by d3d2_CreateDevice(), d3d3_CreateDevice(), d3d7_CreateDevice(), and ddraw_surface7_QueryInterface().

d3d_device_init()

static HRESULT d3d_device_init ( struct d3d_device *  device, struct ddraw *  ddraw, BOOL  hw, struct ddraw_surface *  target, IUnknown *  rt_iface, UINT  version, IUnknown *  outer_unknown  )

static

Definition at line 6906 of file device.c.

{
    static const D3DMATRIX ident =
    {
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f,
    };
    HRESULT hr;
 
    if (ddraw->cooperative_level & DDSCL_FPUPRESERVE)
        device->IDirect3DDevice7_iface.lpVtbl = &d3d_device7_fpu_preserve_vtbl;
    else
        device->IDirect3DDevice7_iface.lpVtbl = &d3d_device7_fpu_setup_vtbl;
 
    device->IDirect3DDevice3_iface.lpVtbl = &d3d_device3_vtbl;
    device->IDirect3DDevice2_iface.lpVtbl = &d3d_device2_vtbl;
    device->IDirect3DDevice_iface.lpVtbl = &d3d_device1_vtbl;
    device->IUnknown_inner.lpVtbl = &d3d_device_inner_vtbl;
    device->ref = 1;
    device->version = version;
    device->hw = hw;
 
    if (outer_unknown)
        device->outer_unknown = outer_unknown;
    else
        device->outer_unknown = &device->IUnknown_inner;
 
    device->ddraw = ddraw;
    list_init(&device->viewport_list);
 
    if (!ddraw_handle_table_init(&device->handle_table, 64))
    {
        ERR("Failed to initialize handle table.\n");
        return DDERR_OUTOFMEMORY;
    }
 
    device->legacyTextureBlending = FALSE;
    device->legacy_projection = ident;
    device->legacy_clipspace = ident;
 
    /* This is for convenience. */
    device->wined3d_device = ddraw->wined3d_device;
    wined3d_device_incref(ddraw->wined3d_device);
 
    /* Render to the back buffer */
    if (FAILED(hr = wined3d_device_set_rendertarget_view(ddraw->wined3d_device,
            0, ddraw_surface_get_rendertarget_view(target), TRUE)))
    {
        ERR("Failed to set render target, hr %#x.\n", hr);
        ddraw_handle_table_destroy(&device->handle_table);
        return hr;
    }
 
    device->rt_iface = rt_iface;
    if (version != 1)
        IUnknown_AddRef(device->rt_iface);
 
    ddraw->d3ddevice = device;
 
    wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_ZENABLE,
            d3d_device_update_depth_stencil(device));
    if (version == 1) /* Color keying is initially enabled for version 1 devices. */
        wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_COLORKEYENABLE, TRUE);
    else if (version == 2)
        wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_SPECULARENABLE, TRUE);
    if (version < 7)
        wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_NORMALIZENORMALS, TRUE);
 
    return D3D_OK;
}

Referenced by d3d_device_create().

d3d_device_inner_AddRef()

static ULONG WINAPI d3d_device_inner_AddRef ( IUnknown *  iface )

static

Definition at line 177 of file device.c.

{
    struct d3d_device *device = impl_from_IUnknown(iface);
    ULONG ref = InterlockedIncrement(&device->ref);
 
    TRACE("%p increasing refcount to %u.\n", device, ref);
 
    return ref;
}

d3d_device_inner_QueryInterface()

static HRESULT WINAPI d3d_device_inner_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  out  )

static

Definition at line 83 of file device.c.

{
    struct d3d_device *device = impl_from_IUnknown(iface);
 
    TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 
    if (!riid)
    {
        *out = NULL;
        return DDERR_INVALIDPARAMS;
    }
 
    if (IsEqualGUID(&IID_IUnknown, riid))
    {
        IDirect3DDevice7_AddRef(&device->IDirect3DDevice7_iface);
        *out = &device->IDirect3DDevice7_iface;
        return S_OK;
    }
 
    if (device->version == 7)
    {
        if (IsEqualGUID(&IID_IDirect3DDevice7, riid))
        {
            IDirect3DDevice7_AddRef(&device->IDirect3DDevice7_iface);
            *out = &device->IDirect3DDevice7_iface;
            return S_OK;
        }
    }
    else
    {
        if (IsEqualGUID(&IID_IDirect3DDevice3, riid) && device->version == 3)
        {
            IDirect3DDevice3_AddRef(&device->IDirect3DDevice3_iface);
            *out = &device->IDirect3DDevice3_iface;
            return S_OK;
        }
 
        if (IsEqualGUID(&IID_IDirect3DDevice2, riid) && device->version >= 2)
        {
            IDirect3DDevice2_AddRef(&device->IDirect3DDevice2_iface);
            *out = &device->IDirect3DDevice2_iface;
            return S_OK;
        }
 
        if (IsEqualGUID(&IID_IDirect3DDevice, riid))
        {
            IDirect3DDevice_AddRef(&device->IDirect3DDevice_iface);
            *out = &device->IDirect3DDevice_iface;
            return S_OK;
        }
    }
 
    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 
    *out = NULL;
    return E_NOINTERFACE;
}

d3d_device_inner_Release()

static ULONG WINAPI d3d_device_inner_Release ( IUnknown *  iface )

static

Definition at line 223 of file device.c.

{
    struct d3d_device *This = impl_from_IUnknown(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
    IUnknown *rt_iface;
 
    TRACE("%p decreasing refcount to %u.\n", This, ref);
 
    /* This method doesn't destroy the wined3d device, because it's still in
     * use for 2D rendering. IDirectDrawSurface7::Release will destroy the
     * wined3d device when the render target is released. */
    if (!ref)
    {
        DWORD i;
        struct list *vp_entry, *vp_entry2;
 
        wined3d_mutex_lock();
 
        /* There is no need to unset any resources here, wined3d will take
         * care of that on uninit_3d(). */
 
        if (This->index_buffer)
            wined3d_buffer_decref(This->index_buffer);
        if (This->vertex_buffer)
            wined3d_buffer_decref(This->vertex_buffer);
 
        wined3d_device_set_rendertarget_view(This->wined3d_device, 0, NULL, FALSE);
 
        /* Release the wined3d device. This won't destroy it. */
        if (!wined3d_device_decref(This->wined3d_device))
            ERR("The wined3d device (%p) was destroyed unexpectedly.\n", This->wined3d_device);
 
        /* The texture handles should be unset by now, but there might be some bits
         * missing in our reference counting(needs test). Do a sanity check. */
        for (i = 0; i < This->handle_table.entry_count; ++i)
        {
            struct ddraw_handle_entry *entry = &This->handle_table.entries[i];
 
            switch (entry->type)
            {
                case DDRAW_HANDLE_FREE:
                    break;
 
                case DDRAW_HANDLE_MATERIAL:
                {
                    struct d3d_material *m = entry->object;
                    FIXME("Material handle %#x (%p) not unset properly.\n", i + 1, m);
                    m->Handle = 0;
                    break;
                }
 
                case DDRAW_HANDLE_MATRIX:
                {
                    /* No FIXME here because this might happen because of sloppy applications. */
                    WARN("Leftover matrix handle %#x (%p), deleting.\n", i + 1, entry->object);
                    IDirect3DDevice_DeleteMatrix(&This->IDirect3DDevice_iface, i + 1);
                    break;
                }
 
                case DDRAW_HANDLE_STATEBLOCK:
                {
                    /* No FIXME here because this might happen because of sloppy applications. */
                    WARN("Leftover stateblock handle %#x (%p), deleting.\n", i + 1, entry->object);
                    IDirect3DDevice7_DeleteStateBlock(&This->IDirect3DDevice7_iface, i + 1);
                    break;
                }
 
                case DDRAW_HANDLE_SURFACE:
                {
                    struct ddraw_surface *surf = entry->object;
                    FIXME("Texture handle %#x (%p) not unset properly.\n", i + 1, surf);
                    surf->Handle = 0;
                    break;
                }
 
                default:
                    FIXME("Handle %#x (%p) has unknown type %#x.\n", i + 1, entry->object, entry->type);
                    break;
            }
        }
 
        ddraw_handle_table_destroy(&This->handle_table);
 
        LIST_FOR_EACH_SAFE(vp_entry, vp_entry2, &This->viewport_list)
        {
            struct d3d_viewport *vp = LIST_ENTRY(vp_entry, struct d3d_viewport, entry);
            IDirect3DDevice3_DeleteViewport(&This->IDirect3DDevice3_iface, &vp->IDirect3DViewport3_iface);
        }
 
        TRACE("Releasing render target %p.\n", This->rt_iface);
        rt_iface = This->rt_iface;
        This->rt_iface = NULL;
        if (This->version != 1)
            IUnknown_Release(rt_iface);
        TRACE("Render target release done.\n");
 
        /* Releasing the render target above may have released the last
         * reference to the ddraw object. */
        if (This->ddraw)
            This->ddraw->d3ddevice = NULL;
 
        /* Now free the structure */
        heap_free(This);
        wined3d_mutex_unlock();
    }
 
    TRACE("Done\n");
    return ref;
}

d3d_device_prepare_index_buffer()

static HRESULT d3d_device_prepare_index_buffer ( struct d3d_device *  device, UINT  min_size  )

static

Definition at line 3651 of file device.c.

{
    HRESULT hr;
 
    if (device->index_buffer_size < min_size || !device->index_buffer)
    {
        UINT size = max(device->index_buffer_size * 2, min_size);
        struct wined3d_buffer_desc desc;
        struct wined3d_buffer *buffer;
 
        TRACE("Growing index buffer to %u bytes\n", size);
 
        desc.byte_width = size;
        desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY | WINED3DUSAGE_STATICDECL;
        desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
        desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
        desc.misc_flags = 0;
        desc.structure_byte_stride = 0;
 
        if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc,
                NULL, NULL, &ddraw_null_wined3d_parent_ops, &buffer)))
        {
            ERR("Failed to create index buffer, hr %#x.\n", hr);
            return hr;
        }
 
        if (device->index_buffer)
            wined3d_buffer_decref(device->index_buffer);
        device->index_buffer = buffer;
        device->index_buffer_size = size;
        device->index_buffer_pos = 0;
    }
    return D3D_OK;
}

Referenced by d3d_device7_DrawIndexedPrimitive(), d3d_device7_DrawIndexedPrimitiveStrided(), and d3d_device7_DrawIndexedPrimitiveVB().

d3d_device_prepare_vertex_buffer()

static HRESULT d3d_device_prepare_vertex_buffer ( struct d3d_device *  device, UINT  min_size  )

static

Definition at line 3459 of file device.c.

{
    HRESULT hr;
 
    if (device->vertex_buffer_size < min_size || !device->vertex_buffer)
    {
        UINT size = max(device->vertex_buffer_size * 2, min_size);
        struct wined3d_buffer_desc desc;
        struct wined3d_buffer *buffer;
 
        TRACE("Growing vertex buffer to %u bytes\n", size);
 
        desc.byte_width = size;
        desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY;
        desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
        desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
        desc.misc_flags = 0;
        desc.structure_byte_stride = 0;
 
        if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc,
                NULL, NULL, &ddraw_null_wined3d_parent_ops, &buffer)))
        {
            ERR("Failed to create vertex buffer, hr %#x.\n", hr);
            return hr;
        }
 
        if (device->vertex_buffer)
            wined3d_buffer_decref(device->vertex_buffer);
 
        device->vertex_buffer = buffer;
        device->vertex_buffer_size = size;
        device->vertex_buffer_pos = 0;
    }
    return D3D_OK;
}

Referenced by d3d_device7_DrawIndexedPrimitive(), d3d_device7_DrawIndexedPrimitiveStrided(), d3d_device7_DrawPrimitive(), and d3d_device7_DrawPrimitiveStrided().

d3d_device_set_render_target()

static HRESULT d3d_device_set_render_target ( struct d3d_device *  device, struct ddraw_surface *  target, IUnknown *  rt_iface  )

static

Definition at line 1804 of file device.c.

{
    HRESULT hr;
 
    if (device->rt_iface == rt_iface)
    {
        TRACE("No-op SetRenderTarget operation, not doing anything\n");
        return D3D_OK;
    }
    if (!target)
    {
        WARN("Trying to set render target to NULL.\n");
        return DDERR_INVALIDPARAMS;
    }
 
    if (FAILED(hr = wined3d_device_set_rendertarget_view(device->wined3d_device,
            0, ddraw_surface_get_rendertarget_view(target), FALSE)))
        return hr;
 
    IUnknown_AddRef(rt_iface);
    IUnknown_Release(device->rt_iface);
    device->rt_iface = rt_iface;
    d3d_device_update_depth_stencil(device);
 
    return D3D_OK;
}

Referenced by d3d_device2_SetRenderTarget(), d3d_device3_SetRenderTarget(), and d3d_device7_SetRenderTarget().

d3d_device_update_depth_stencil()

enum wined3d_depth_buffer_type d3d_device_update_depth_stencil

(

struct d3d_device *

device

)

Definition at line 6878 of file device.c.

{
    IDirectDrawSurface7 *depthStencil = NULL;
    IDirectDrawSurface7 *render_target;
    static DDSCAPS2 depthcaps = { DDSCAPS_ZBUFFER, 0, 0, {0} };
    struct ddraw_surface *dsi;
 
    if (device->rt_iface && SUCCEEDED(IUnknown_QueryInterface(device->rt_iface,
            &IID_IDirectDrawSurface7, (void **)&render_target)))
    {
        IDirectDrawSurface7_GetAttachedSurface(render_target, &depthcaps, &depthStencil);
        IDirectDrawSurface7_Release(render_target);
    }
    if (!depthStencil)
    {
        TRACE("Setting wined3d depth stencil to NULL\n");
        wined3d_device_set_depth_stencil_view(device->wined3d_device, NULL);
        return WINED3D_ZB_FALSE;
    }
 
    dsi = impl_from_IDirectDrawSurface7(depthStencil);
    wined3d_device_set_depth_stencil_view(device->wined3d_device,
            ddraw_surface_get_rendertarget_view(dsi));
 
    IDirectDrawSurface7_Release(depthStencil);
    return WINED3D_ZB_TRUE;
}

Referenced by d3d_device_init(), d3d_device_set_render_target(), and ddraw_surface_attach_surface().

d3d_fpu_setup()

static WORD d3d_fpu_setup ( void  )

inlinestatic

Definition at line 55 of file device.c.

{
    WORD oldcw;
 
#if defined(__i386__) && defined(__GNUC__)
    __asm__ volatile ("fnstcw %0" : "=m" (oldcw));
#elif defined(__i386__) && defined(_MSC_VER)
    __asm fnstcw oldcw;
#else
    static BOOL warned = FALSE;
    if(!warned)
    {
        FIXME("FPUPRESERVE not implemented for this platform / compiler\n");
        warned = TRUE;
    }
    return 0;
#endif
 
    set_fpu_control_word(0x37f);
 
    return oldcw;
}

Referenced by d3d_device7_ApplyStateBlock_FPUPreserve(), d3d_device7_BeginScene_FPUPreserve(), d3d_device7_BeginStateBlock_FPUPreserve(), d3d_device7_CaptureStateBlock_FPUPreserve(), d3d_device7_Clear_FPUPreserve(), d3d_device7_CreateStateBlock_FPUPreserve(), d3d_device7_DeleteStateBlock_FPUPreserve(), d3d_device7_DrawIndexedPrimitive_FPUPreserve(), d3d_device7_DrawIndexedPrimitiveStrided_FPUPreserve(), d3d_device7_DrawIndexedPrimitiveVB_FPUPreserve(), d3d_device7_DrawPrimitive_FPUPreserve(), d3d_device7_DrawPrimitiveStrided_FPUPreserve(), d3d_device7_DrawPrimitiveVB_FPUPreserve(), d3d_device7_EndScene_FPUPreserve(), d3d_device7_EndStateBlock_FPUPreserve(), d3d_device7_EnumTextureFormats_FPUPreserve(), d3d_device7_GetCaps_FPUPreserve(), d3d_device7_GetClipPlane_FPUPreserve(), d3d_device7_GetLight_FPUPreserve(), d3d_device7_GetLightEnable_FPUPreserve(), d3d_device7_GetMaterial_FPUPreserve(), d3d_device7_GetRenderState_FPUPreserve(), d3d_device7_GetTexture_FPUPreserve(), d3d_device7_GetTextureStageState_FPUPreserve(), d3d_device7_GetTransform_FPUPreserve(), d3d_device7_GetViewport_FPUPreserve(), d3d_device7_LightEnable_FPUPreserve(), d3d_device7_Load_FPUPreserve(), d3d_device7_MultiplyTransform_FPUPreserve(), d3d_device7_PreLoad_FPUPreserve(), d3d_device7_SetClipPlane_FPUPreserve(), d3d_device7_SetLight_FPUPreserve(), d3d_device7_SetMaterial_FPUPreserve(), d3d_device7_SetRenderState_FPUPreserve(), d3d_device7_SetRenderTarget_FPUPreserve(), d3d_device7_SetTexture_FPUPreserve(), d3d_device7_SetTextureStageState_FPUPreserve(), d3d_device7_SetTransform_FPUPreserve(), d3d_device7_SetViewport_FPUPreserve(), and d3d_device7_ValidateDevice_FPUPreserve().

impl_from_IUnknown()

static struct d3d_device * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 78 of file device.c.

{
    return CONTAINING_RECORD(iface, struct d3d_device, IUnknown_inner);
}

Referenced by d3d_device_inner_AddRef(), d3d_device_inner_QueryInterface(), and d3d_device_inner_Release().

in_plane()

static DWORD in_plane ( UINT  idx, struct wined3d_vec4  p, D3DVECTOR  center, D3DVALUE  radius, BOOL  equality  )

static

Definition at line 4509 of file device.c.

{
    float distance, norm;
 
    norm = sqrtf(p.x * p.x + p.y * p.y + p.z * p.z);
    distance = (p.x * center.u1.x + p.y * center.u2.y + p.z * center.u3.z + p.w) / norm;
 
    if (equality)
    {
        if (fabs(distance) <= radius)
            return D3DSTATUS_CLIPUNIONLEFT << idx;
        if (distance <= -radius)
            return (D3DSTATUS_CLIPUNIONLEFT | D3DSTATUS_CLIPINTERSECTIONLEFT) << idx;
    }
    else
    {
        if (fabs(distance) < radius)
            return D3DSTATUS_CLIPUNIONLEFT << idx;
        if (distance < -radius)
            return (D3DSTATUS_CLIPUNIONLEFT | D3DSTATUS_CLIPINTERSECTIONLEFT) << idx;
    }
    return 0;
}

Referenced by compute_sphere_visibility().

is_mip_level_subset()

static BOOL is_mip_level_subset ( struct ddraw_surface *  dest, struct ddraw_surface *  src  )

static

Definition at line 6011 of file device.c.

{
    struct ddraw_surface *src_level, *dest_level;
    IDirectDrawSurface7 *temp;
    DDSURFACEDESC2 ddsd;
    BOOL levelFound; /* at least one suitable sublevel in dest found */
 
    /* To satisfy "destination is mip level subset of source" criteria (regular texture counts as 1 level),
     * 1) there must be at least one mip level in destination that matched dimensions of some mip level in source and
     * 2) there must be no destination levels that don't match any levels in source. Otherwise it's INVALIDPARAMS.
     */
    levelFound = FALSE;
 
    src_level = src;
    dest_level = dest;
 
    for (;src_level && dest_level;)
    {
        if (src_level->surface_desc.dwWidth == dest_level->surface_desc.dwWidth &&
            src_level->surface_desc.dwHeight == dest_level->surface_desc.dwHeight)
        {
            levelFound = TRUE;
 
            ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
            ddsd.ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
            IDirectDrawSurface7_GetAttachedSurface(&dest_level->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
 
            if (dest_level != dest) IDirectDrawSurface7_Release(&dest_level->IDirectDrawSurface7_iface);
 
            dest_level = unsafe_impl_from_IDirectDrawSurface7(temp);
        }
 
        ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
        ddsd.ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
        IDirectDrawSurface7_GetAttachedSurface(&src_level->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
 
        if (src_level != src) IDirectDrawSurface7_Release(&src_level->IDirectDrawSurface7_iface);
 
        src_level = unsafe_impl_from_IDirectDrawSurface7(temp);
    }
 
    if (src_level && src_level != src) IDirectDrawSurface7_Release(&src_level->IDirectDrawSurface7_iface);
    if (dest_level && dest_level != dest) IDirectDrawSurface7_Release(&dest_level->IDirectDrawSurface7_iface);
 
    return !dest_level && levelFound;
}

Referenced by d3d_device7_Load().

pack_strided_data()

static void pack_strided_data ( BYTE *  dst, DWORD  count, const D3DDRAWPRIMITIVESTRIDEDDATA *  src, DWORD  fvf  )

static

Definition at line 3965 of file device.c.

{
    DWORD i, tex, offset;
 
    for (i = 0; i < count; i++)
    {
        /* The contents of the strided data are determined by the fvf,
         * not by the members set in src. So it's valid
         * to have diffuse.lpvData set to 0xdeadbeef if the diffuse flag is
         * not set in the fvf. */
        if (fvf & D3DFVF_POSITION_MASK)
        {
            offset = i * src->position.dwStride;
            if (fvf & D3DFVF_XYZRHW)
            {
                memcpy(dst, ((BYTE *)src->position.lpvData) + offset, 4 * sizeof(float));
                dst += 4 * sizeof(float);
            }
            else
            {
                memcpy(dst, ((BYTE *)src->position.lpvData) + offset, 3 * sizeof(float));
                dst += 3 * sizeof(float);
            }
        }
 
        if (fvf & D3DFVF_NORMAL)
        {
            offset = i * src->normal.dwStride;
            memcpy(dst, ((BYTE *)src->normal.lpvData) + offset, 3 * sizeof(float));
            dst += 3 * sizeof(float);
        }
 
        if (fvf & D3DFVF_DIFFUSE)
        {
            offset = i * src->diffuse.dwStride;
            memcpy(dst, ((BYTE *)src->diffuse.lpvData) + offset, sizeof(DWORD));
            dst += sizeof(DWORD);
        }
 
        if (fvf & D3DFVF_SPECULAR)
        {
            offset = i * src->specular.dwStride;
            memcpy(dst, ((BYTE *)src->specular.lpvData) + offset, sizeof(DWORD));
            dst += sizeof(DWORD);
        }
 
        for (tex = 0; tex < GET_TEXCOUNT_FROM_FVF(fvf); ++tex)
        {
            DWORD attrib_count = GET_TEXCOORD_SIZE_FROM_FVF(fvf, tex);
            offset = i * src->textureCoords[tex].dwStride;
            memcpy(dst, ((BYTE *)src->textureCoords[tex].lpvData) + offset, attrib_count * sizeof(float));
            dst += attrib_count * sizeof(float);
        }
    }
}

Referenced by d3d_device7_DrawIndexedPrimitiveStrided(), and d3d_device7_DrawPrimitiveStrided().

prepare_clip_space_planes()

static void prepare_clip_space_planes ( struct d3d_device *  device, struct wined3d_vec4 *  plane  )

static

Definition at line 4533 of file device.c.

{
    D3DMATRIX m, temp;
 
    /* We want the wined3d matrices since those include the legacy viewport
     * transformation. */
    wined3d_mutex_lock();
    wined3d_device_get_transform(device->wined3d_device,
            WINED3D_TS_WORLD, (struct wined3d_matrix *)&m);
 
    wined3d_device_get_transform(device->wined3d_device,
            WINED3D_TS_VIEW, (struct wined3d_matrix *)&temp);
    multiply_matrix(&m, &temp, &m);
 
    wined3d_device_get_transform(device->wined3d_device,
            WINED3D_TS_PROJECTION, (struct wined3d_matrix *)&temp);
    multiply_matrix(&m, &temp, &m);
    wined3d_mutex_unlock();
 
    /* Left plane. */
    plane[0].x = m._14 + m._11;
    plane[0].y = m._24 + m._21;
    plane[0].z = m._34 + m._31;
    plane[0].w = m._44 + m._41;
 
    /* Right plane. */
    plane[1].x = m._14 - m._11;
    plane[1].y = m._24 - m._21;
    plane[1].z = m._34 - m._31;
    plane[1].w = m._44 - m._41;
 
    /* Top plane. */
    plane[2].x = m._14 - m._12;
    plane[2].y = m._24 - m._22;
    plane[2].z = m._34 - m._32;
    plane[2].w = m._44 - m._42;
 
    /* Bottom plane. */
    plane[3].x = m._14 + m._12;
    plane[3].y = m._24 + m._22;
    plane[3].z = m._34 + m._32;
    plane[3].w = m._44 + m._42;
 
    /* Front plane. */
    plane[4].x = m._13;
    plane[4].y = m._23;
    plane[4].z = m._33;
    plane[4].w = m._43;
 
    /* Back plane. */
    plane[5].x = m._14 - m._13;
    plane[5].y = m._24 - m._23;
    plane[5].z = m._34 - m._33;
    plane[5].w = m._44 - m._43;
}

Referenced by d3d_device3_ComputeSphereVisibility(), and d3d_device7_ComputeSphereVisibility().

set_fpu_control_word()

static void set_fpu_control_word ( WORD  fpucw )

inlinestatic

Definition at line 46 of file device.c.

{
#if defined(__i386__) && defined(__GNUC__)
    __asm__ volatile ("fldcw %0" : : "m" (fpucw));
#elif defined(__i386__) && defined(_MSC_VER)
    __asm fldcw fpucw;
#endif
}

Referenced by d3d_device7_ApplyStateBlock_FPUPreserve(), d3d_device7_BeginScene_FPUPreserve(), d3d_device7_BeginStateBlock_FPUPreserve(), d3d_device7_CaptureStateBlock_FPUPreserve(), d3d_device7_Clear_FPUPreserve(), d3d_device7_CreateStateBlock_FPUPreserve(), d3d_device7_DeleteStateBlock_FPUPreserve(), d3d_device7_DrawIndexedPrimitive_FPUPreserve(), d3d_device7_DrawIndexedPrimitiveStrided_FPUPreserve(), d3d_device7_DrawIndexedPrimitiveVB_FPUPreserve(), d3d_device7_DrawPrimitive_FPUPreserve(), d3d_device7_DrawPrimitiveStrided_FPUPreserve(), d3d_device7_DrawPrimitiveVB_FPUPreserve(), d3d_device7_EndScene_FPUPreserve(), d3d_device7_EndStateBlock_FPUPreserve(), d3d_device7_EnumTextureFormats_FPUPreserve(), d3d_device7_GetCaps_FPUPreserve(), d3d_device7_GetClipPlane_FPUPreserve(), d3d_device7_GetLight_FPUPreserve(), d3d_device7_GetLightEnable_FPUPreserve(), d3d_device7_GetMaterial_FPUPreserve(), d3d_device7_GetRenderState_FPUPreserve(), d3d_device7_GetTexture_FPUPreserve(), d3d_device7_GetTextureStageState_FPUPreserve(), d3d_device7_GetTransform_FPUPreserve(), d3d_device7_GetViewport_FPUPreserve(), d3d_device7_LightEnable_FPUPreserve(), d3d_device7_Load_FPUPreserve(), d3d_device7_MultiplyTransform_FPUPreserve(), d3d_device7_PreLoad_FPUPreserve(), d3d_device7_SetClipPlane_FPUPreserve(), d3d_device7_SetLight_FPUPreserve(), d3d_device7_SetMaterial_FPUPreserve(), d3d_device7_SetRenderState_FPUPreserve(), d3d_device7_SetRenderTarget_FPUPreserve(), d3d_device7_SetTexture_FPUPreserve(), d3d_device7_SetTextureStageState_FPUPreserve(), d3d_device7_SetTransform_FPUPreserve(), d3d_device7_SetViewport_FPUPreserve(), d3d_device7_ValidateDevice_FPUPreserve(), and d3d_fpu_setup().

setup_lighting()

static void setup_lighting ( const struct d3d_device *  device, DWORD  fvf, DWORD  flags  )

static

Definition at line 3576 of file device.c.

{
    BOOL enable = TRUE;
 
    /* Ignore the D3DFVF_XYZRHW case here, wined3d takes care of that */
    if (!device->material || !(fvf & D3DFVF_NORMAL) || (flags & D3DDP_DONOTLIGHT))
        enable = FALSE;
 
    wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_LIGHTING, enable);
}

Referenced by d3d_device3_DrawIndexedPrimitive(), d3d_device3_DrawIndexedPrimitiveStrided(), d3d_device3_DrawIndexedPrimitiveVB(), d3d_device3_DrawPrimitive(), d3d_device3_DrawPrimitiveStrided(), and d3d_device3_DrawPrimitiveVB().

unsafe_impl_from_IDirect3DDevice()

struct d3d_device * unsafe_impl_from_IDirect3DDevice

(

IDirect3DDevice *

iface

)

Definition at line 6871 of file device.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_device1_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice_iface);
}

Referenced by d3d_material1_GetHandle(), and d3d_texture1_GetHandle().

unsafe_impl_from_IDirect3DDevice2()

struct d3d_device * unsafe_impl_from_IDirect3DDevice2

(

IDirect3DDevice2 *

iface

)

Definition at line 6864 of file device.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_device2_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice2_iface);
}

Referenced by d3d_material2_GetHandle(), and d3d_texture2_GetHandle().

unsafe_impl_from_IDirect3DDevice3()

struct d3d_device * unsafe_impl_from_IDirect3DDevice3

(

IDirect3DDevice3 *

iface

)

Definition at line 6857 of file device.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_device3_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice3_iface);
}

Referenced by d3d_material3_GetHandle(), and d3d_vertex_buffer7_ProcessVertices().

unsafe_impl_from_IDirect3DDevice7()

struct d3d_device * unsafe_impl_from_IDirect3DDevice7

(

IDirect3DDevice7 *

iface

)

Definition at line 6850 of file device.c.

{
    if (!iface) return NULL;
    assert((iface->lpVtbl == &d3d_device7_fpu_preserve_vtbl) || (iface->lpVtbl == &d3d_device7_fpu_setup_vtbl));
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice7_iface);
}

Referenced by d3d_vertex_buffer7_ProcessVertices().

validate_surface_palette()

static BOOL validate_surface_palette ( struct ddraw_surface *  surface )

static

Definition at line 1798 of file device.c.

{
    return !format_is_paletteindexed(&surface->surface_desc.u4.ddpfPixelFormat)
            || surface->palette;
}

Referenced by d3d_device2_SetRenderTarget(), d3d_device3_SetRenderTarget(), d3d_device7_SetRenderTarget(), and d3d_device_create().

WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL

(

winediag

)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ddraw

)

Variable Documentation

d3d_device1_vtbl

const struct IDirect3DDeviceVtbl d3d_device1_vtbl

static

Initial value:

=
{
    
    d3d_device1_QueryInterface,
    d3d_device1_AddRef,
    d3d_device1_Release,
    
    d3d_device1_Initialize,
    d3d_device1_GetCaps,
    d3d_device1_SwapTextureHandles,
    d3d_device1_CreateExecuteBuffer,
    d3d_device1_GetStats,
    d3d_device1_Execute,
    d3d_device1_AddViewport,
    d3d_device1_DeleteViewport,
    d3d_device1_NextViewport,
    d3d_device1_Pick,
    d3d_device1_GetPickRecords,
    d3d_device1_EnumTextureFormats,
    d3d_device1_CreateMatrix,
    d3d_device1_SetMatrix,
    d3d_device1_GetMatrix,
    d3d_device1_DeleteMatrix,
    d3d_device1_BeginScene,
    d3d_device1_EndScene,
    d3d_device1_GetDirect3D
}

Definition at line 6815 of file device.c.

Referenced by d3d_device_init(), and unsafe_impl_from_IDirect3DDevice().

d3d_device2_vtbl

const struct IDirect3DDevice2Vtbl d3d_device2_vtbl

static

Definition at line 6776 of file device.c.

Referenced by d3d_device_init(), and unsafe_impl_from_IDirect3DDevice2().

d3d_device3_vtbl

const struct IDirect3DDevice3Vtbl d3d_device3_vtbl

static

Definition at line 6728 of file device.c.

Referenced by d3d_device_init(), and unsafe_impl_from_IDirect3DDevice3().

d3d_device7_fpu_preserve_vtbl

const struct IDirect3DDevice7Vtbl d3d_device7_fpu_preserve_vtbl

static

Definition at line 6673 of file device.c.

Referenced by d3d_device_init(), and unsafe_impl_from_IDirect3DDevice7().

d3d_device7_fpu_setup_vtbl

const struct IDirect3DDevice7Vtbl d3d_device7_fpu_setup_vtbl

static

Definition at line 6618 of file device.c.

Referenced by d3d_device_init(), and unsafe_impl_from_IDirect3DDevice7().

d3d_device_inner_vtbl

const struct IUnknownVtbl d3d_device_inner_vtbl

static

Initial value:

=
{
    d3d_device_inner_QueryInterface,
    d3d_device_inner_AddRef,
    d3d_device_inner_Release,
}

Definition at line 6843 of file device.c.

Referenced by d3d_device_init().

IID_D3DDEVICE_WineD3D

const GUID IID_D3DDEVICE_WineD3D

Initial value:

= {
  0xaef72d43,
  0xb09a,
  0x4b7b,
  { 0xb7,0x98,0xc6,0x8a,0x77,0x2d,0x72,0x2a }
}

Definition at line 39 of file device.c.

Referenced by d3d3_FindDevice(), d3d7_EnumZBufferFormats(), and ddraw_surface7_QueryInterface().

tss_lookup

const struct tss_lookup tss_lookup[]

static

Initial value:

=
{
    {FALSE, {WINED3D_TSS_INVALID}},                   
    {FALSE, {WINED3D_TSS_COLOR_OP}},                  
    {FALSE, {WINED3D_TSS_COLOR_ARG1}},                
    {FALSE, {WINED3D_TSS_COLOR_ARG2}},                
    {FALSE, {WINED3D_TSS_ALPHA_OP}},                  
    {FALSE, {WINED3D_TSS_ALPHA_ARG1}},                
    {FALSE, {WINED3D_TSS_ALPHA_ARG2}},                
    {FALSE, {WINED3D_TSS_BUMPENV_MAT00}},             
    {FALSE, {WINED3D_TSS_BUMPENV_MAT01}},             
    {FALSE, {WINED3D_TSS_BUMPENV_MAT10}},             
    {FALSE, {WINED3D_TSS_BUMPENV_MAT11}},             
    {FALSE, {WINED3D_TSS_TEXCOORD_INDEX}},            
    {TRUE,  {WINED3D_SAMP_ADDRESS_U}},                
    {TRUE,  {WINED3D_SAMP_ADDRESS_U}},                
    {TRUE,  {WINED3D_SAMP_ADDRESS_V}},                
    {TRUE,  {WINED3D_SAMP_BORDER_COLOR}},             
    {TRUE,  {WINED3D_SAMP_MAG_FILTER}},               
    {TRUE,  {WINED3D_SAMP_MIN_FILTER}},               
    {TRUE,  {WINED3D_SAMP_MIP_FILTER}},               
    {TRUE,  {WINED3D_SAMP_MIPMAP_LOD_BIAS}},          
    {TRUE,  {WINED3D_SAMP_MAX_MIP_LEVEL}},            
    {TRUE,  {WINED3D_SAMP_MAX_ANISOTROPY}},           
    {FALSE, {WINED3D_TSS_BUMPENV_LSCALE}},            
    {FALSE, {WINED3D_TSS_BUMPENV_LOFFSET}},           
    {FALSE, {WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS}},   
}