device.c File Reference

#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 enum wined3d_render_state	wined3d_render_state_from_ddraw (D3DRENDERSTATETYPE state)
static enum wined3d_transform_state	wined3d_transform_state_from_ddraw (D3DTRANSFORMSTATETYPE state)
static enum wined3d_primitive_type	wined3d_primitive_type_from_ddraw (D3DPRIMITIVETYPE type)
static enum wined3d_stateblock_type	wined3d_stateblock_type_from_ddraw (D3DSTATEBLOCKTYPE type)
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 matrix_handle, D3DMATRIX *matrix)
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 *viewport)
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 void	fixup_texture_alpha_op (struct d3d_device *device)
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 void	d3d_device_sync_rendertarget (struct d3d_device *device)
void	d3d_device_sync_surfaces (struct d3d_device *device)
void	d3d_device_apply_state (struct d3d_device *device, BOOL clear_state)
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_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 primitive_type, IDirect3DVertexBuffer *vertex_buffer, WORD *indices, DWORD index_count, 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 (const struct wined3d_vec4 *planes, DWORD enabled_planes, BOOL equality, const D3DVECTOR *centres, const D3DVALUE *radii, unsigned int 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 void	device_reset_viewport_state (struct d3d_device *device)
static HRESULT	d3d_device_init (struct d3d_device *device, struct ddraw *ddraw, const GUID *guid, 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 484 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 ( const struct wined3d_vec4 *  planes, DWORD  enabled_planes, BOOL  equality, const D3DVECTOR *  centres, const D3DVALUE *  radii, unsigned int  sphere_count, DWORD *  return_values  )

static

Definition at line 4486 of file device.c.

{
    unsigned int mask, i, j;
 
    memset(return_values, 0, sphere_count * sizeof(*return_values));
    for (i = 0; i < sphere_count; ++i)
    {
        mask = enabled_planes;
        while (mask)
        {
            j = wined3d_bit_scan(&mask);
            return_values[i] |= in_plane(j, planes[j], centres[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 5997 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_device_context_blt(device->immediate_context,
                    ddraw_surface_get_any_texture(dst_level, DDRAW_SURFACE_RW), dst_level->sub_resource_idx, &dst_rect,
                    ddraw_surface_get_any_texture(src_level, DDRAW_SURFACE_READ),
                    src_level->sub_resource_idx, &src_rect, 0, NULL, WINED3D_TEXF_POINT)))
                ERR("Blit failed, hr %#lx.\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 251 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 808 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 1554 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 684 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 = calloc(1, 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 %#lx.\n", hr);
        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 1313 of file device.c.

{
    D3DMATRIX *matrix;
    DWORD h;
 
    TRACE("iface %p, matrix_handle %p.\n", iface, D3DMatHandle);
 
    if(!D3DMatHandle)
        return DDERR_INVALIDPARAMS;
 
    if (!(matrix = calloc(1, sizeof(*matrix))))
    {
        ERR("Out of memory when allocating a D3DMATRIX\n");
        return DDERR_OUTOFMEMORY;
    }
 
    wined3d_mutex_lock();
 
    h = ddraw_allocate_handle(NULL, matrix, DDRAW_HANDLE_MATRIX);
    if (h == DDRAW_INVALID_HANDLE)
    {
        ERR("Failed to allocate a matrix handle.\n");
        free(matrix);
        wined3d_mutex_unlock();
        return DDERR_OUTOFMEMORY;
    }
 
    *D3DMatHandle = h + 1;
 
    TRACE(" returning matrix handle %#lx\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 1467 of file device.c.

{
    D3DMATRIX *m;
 
    TRACE("iface %p, matrix_handle %#lx.\n", iface, D3DMatHandle);
 
    wined3d_mutex_lock();
 
    m = ddraw_free_handle(NULL, D3DMatHandle - 1, DDRAW_HANDLE_MATRIX);
    if (!m)
    {
        WARN("Invalid matrix handle.\n");
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    wined3d_mutex_unlock();
 
    free(m);
 
    return D3D_OK;
}

d3d_device1_DeleteViewport()

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

static

Definition at line 886 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 1627 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 1287 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 734 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 %#lx.\n", iface, ExecuteBuffer, viewport, flags);
 
    if(!buffer)
        return DDERR_INVALIDPARAMS;
 
    if (FAILED(hr = IDirect3DDevice3_SetCurrentViewport
            (&device->IDirect3DDevice3_iface, &viewport_impl->IDirect3DViewport3_iface)))
        return hr;
 
    /* Execute... */
    wined3d_mutex_lock();
    hr = d3d_execute_buffer_execute(buffer, device);
    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 542 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 1698 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 1426 of file device.c.

{
    D3DMATRIX *m;
 
    TRACE("iface %p, matrix_handle %#lx, matrix %p.\n", iface, D3DMatHandle, D3DMatrix);
 
    if (!D3DMatrix) return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
 
    m = ddraw_get_object(NULL, 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 1048 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 655 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 410 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 985 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 %#lx.\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 1023 of file device.c.

{
    FIXME("iface %p, buffer %p, viewport %p, flags %#lx, 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 205 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 383 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  matrix_handle, D3DMATRIX *  matrix  )

static

Definition at line 1367 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice(iface);
    D3DMATRIX *m;
 
    TRACE("iface %p, matrix_handle %#lx, matrix %p.\n", iface, matrix_handle, matrix);
 
    if (!matrix)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
 
    m = ddraw_get_object(NULL, matrix_handle - 1, DDRAW_HANDLE_MATRIX);
    if (!m)
    {
        WARN("Invalid matrix handle.\n");
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    if (TRACE_ON(ddraw))
        dump_D3DMATRIX(matrix);
 
    *m = *matrix;
 
    if (matrix_handle == device->world)
        wined3d_stateblock_set_transform(device->state,
                WINED3D_TS_WORLD_MATRIX(0), (struct wined3d_matrix *)matrix);
 
    if (matrix_handle == device->view)
        wined3d_stateblock_set_transform(device->state,
                WINED3D_TS_VIEW, (struct wined3d_matrix *)matrix);
 
    if (matrix_handle == device->proj)
        wined3d_stateblock_set_transform(device->state,
                WINED3D_TS_PROJECTION, (struct wined3d_matrix *)matrix);
 
    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 597 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 242 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 797 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 2154 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
    DWORD fvf;
 
    TRACE("iface %p, primitive_type %#x, vertex_type %#x, flags %#lx.\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 2206 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 %lu, flags %#lx.\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 1545 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 875 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 3702 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 %lu, "
            "indices %p, index_count %lu, flags %#lx.\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 3558 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 %lu, flags %#lx.\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 3755 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, flags %#lx.\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 1618 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 1217 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_output_get_display_mode(device->ddraw->wined3d_output, &mode, NULL)))
    {
        wined3d_mutex_unlock();
        WARN("Failed to get output display mode, hr %#lx.\n", hr);
        return hr;
    }
 
    for (i = 0; i < ARRAY_SIZE(FormatList); ++i)
    {
        if (wined3d_check_device_format(device->ddraw->wined3d, device->ddraw->wined3d_adapter,
                WINED3D_DEVICE_TYPE_HAL, mode.format_id, 0, WINED3D_BIND_SHADER_RESOURCE,
                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 532 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 3846 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 1820 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 1682 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 3098 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 2520 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 2096 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 646 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 3276 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 2306 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 3362 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 968 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 %#lx.\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 196 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 374 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 3796 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 1772 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 3006 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, value %#lx.\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 2890 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
 
    TRACE("iface %p, state %#x, value %#lx.\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 1988 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 %#lx.\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;
        device->target = NULL;
        device->target_ds = NULL;
        wined3d_mutex_unlock();
        return DDERR_INVALIDPIXELFORMAT;
    }
 
    if (device->hardware_device && !(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;
        device->target = NULL;
        device->target_ds = NULL;
        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 3192 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 564 of file device.c.

{
    struct ddraw_surface *surf1 = unsafe_impl_from_IDirect3DTexture2(tex1);
    struct ddraw_surface *surf2 = unsafe_impl_from_IDirect3DTexture2(tex2);
    DWORD h1, h2, h;
    HRESULT hr;
 
    TRACE("iface %p, tex1 %p, tex2 %p.\n", iface, tex1, tex2);
 
    if (!surf1->Handle || !surf2->Handle)
        return E_INVALIDARG;
 
    if (FAILED(hr = IDirect3DDevice2_GetRenderState(iface, D3DRENDERSTATE_TEXTUREHANDLE, &h)))
        return hr;
 
    wined3d_mutex_lock();
 
    h1 = surf1->Handle - 1;
    h2 = surf2->Handle - 1;
    global_handle_table.entries[h1].object = surf2;
    global_handle_table.entries[h2].object = surf1;
    surf2->Handle = h1 + 1;
    surf1->Handle = h2 + 1;
 
    wined3d_mutex_unlock();
 
    if ((h == surf1->Handle || h == surf2->Handle)
            && FAILED(hr = IDirect3DDevice2_SetRenderState(iface, D3DRENDERSTATE_TEXTUREHANDLE, h)))
        return hr;
    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 2277 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 233 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 776 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 2135 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, fvf %#lx, flags %#lx.\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 2195 of file device.c.

{
    FIXME("iface %p, primitive_type %#x, fvf %#lx, vertices %p, vertex_count %lu, flags %#lx 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 1536 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 4525 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 %lu, flags %#lx, 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 834 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");
 
        viewport_deactivate(vp);
        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 3686 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, fvf %#lx, vertices %p, vertex_count %lu, "
            "indices %p, index_count %lu, flags %#lx.\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 4104 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, FVF %#lx, strided_data %p, vertex_count %lu, indices %p, index_count %lu, flags %#lx.\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  primitive_type, IDirect3DVertexBuffer *  vertex_buffer, WORD *  indices, DWORD  index_count, DWORD  flags  )

static

Definition at line 4364 of file device.c.

{
    struct d3d_vertex_buffer *vb =
            unsafe_impl_from_IDirect3DVertexBuffer7((IDirect3DVertexBuffer7 *)vertex_buffer);
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    DWORD stride;
 
    TRACE("iface %p, primitive_type %#x, vb %p, indices %p, index_count %lu, flags %#lx.\n",
            iface, primitive_type, vertex_buffer, indices, index_count, flags);
 
    setup_lighting(device, vb->fvf, flags);
 
    if (!(stride = get_flexible_vertex_size(vb->fvf)))
        return D3D_OK;
 
    return IDirect3DDevice7_DrawIndexedPrimitiveVB(&device->IDirect3DDevice7_iface, primitive_type,
            &vb->IDirect3DVertexBuffer7_iface, 0, vb->size / stride, indices, index_count, 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 3543 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, fvf %#lx, vertices %p, vertex_count %lu, flags %#lx.\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 3996 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, primitive_type %#x, FVF %#lx, strided_data %p, vertex_count %lu, flags %#lx.\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 4223 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 %lu, vertex_count %lu, flags %#lx.\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 3745 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, flags %#lx.\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 1609 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 1197 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 492 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 %lu, 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 %lu, 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 3837 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 1798 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 1666 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 3034 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 2473 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 = device->stateblock_state->textures[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:
        {
            *value = device->texture_map_blend;
            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 2075 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 629 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 4640 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 %lu, 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 4930 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, stage %lu, 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 3255 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();
        memcpy(matrix, &device->legacy_projection, sizeof(*matrix));
        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 2299 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 3338 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)
    {
        struct wined3d_matrix projection, tmp;
 
        wined3d_mutex_lock();
        multiply_matrix(&tmp, &device->legacy_projection, (struct wined3d_matrix *)matrix);
        multiply_matrix(&projection, &device->legacy_clipspace, &tmp);
        wined3d_stateblock_set_transform(device->state, WINED3D_TS_PROJECTION, &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 915 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 %#lx.\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 %#lx.\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 187 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 365 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 3787 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 *  viewport  )

static

Definition at line 1730 of file device.c.

{
    struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(viewport);
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
 
    TRACE("iface %p, viewport %p, current_viewport %p.\n", iface, viewport, device->current_viewport);
 
    if (!vp)
    {
        WARN("Direct3DViewport3 is NULL.\n");
        return DDERR_INVALIDPARAMS;
    }
 
    wined3d_mutex_lock();
    /* Do nothing if the specified viewport is the same as the current one */
    if (device->current_viewport == vp)
    {
        wined3d_mutex_unlock();
        return D3D_OK;
    }
 
    if (vp->active_device != device)
    {
        WARN("Viewport %p, active device %p.\n", vp, vp->active_device);
        wined3d_mutex_unlock();
        return DDERR_INVALIDPARAMS;
    }
 
    IDirect3DViewport3_AddRef(viewport);
    if (device->current_viewport)
    {
        viewport_deactivate(device->current_viewport);
        IDirect3DViewport3_Release(&device->current_viewport->IDirect3DViewport3_iface);
    }
    device->current_viewport = vp;
    viewport_activate(device->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 2918 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    HRESULT hr;
 
    TRACE("iface %p, state %#x, value %#lx.\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(NULL, 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 2724 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. */
 
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    HRESULT hr;
 
    TRACE("iface %p, state %#x, value %#lx.\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)
            {
                wined3d_stateblock_set_texture(device->state, 0, NULL);
                hr = D3D_OK;
                break;
            }
 
            surf = ddraw_get_object(NULL, 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:
        {
            if (value == device->texture_map_blend)
            {
                TRACE("Application is setting the same value over, nothing to do.\n");
 
                hr = D3D_OK;
                break;
            }
 
            device->legacyTextureBlending = TRUE;
            device->texture_map_blend = value;
 
            switch (value)
            {
                case D3DTBLEND_MODULATE:
                {
                    fixup_texture_alpha_op(device);
 
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_MODULATE);
                    break;
                }
 
                case D3DTBLEND_ADD:
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_ADD);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
                    break;
 
                case D3DTBLEND_MODULATEALPHA:
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_MODULATE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_MODULATE);
                    break;
 
                case D3DTBLEND_COPY:
                case D3DTBLEND_DECAL:
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_SELECT_ARG1);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG1);
                    break;
 
                case D3DTBLEND_DECALALPHA:
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_BLEND_TEXTURE_ALPHA);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
                    wined3d_stateblock_set_texture_stage_state(device->state,
                            0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
                    break;
 
                default:
                    FIXME("Unhandled texture environment %#lx.\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 1934 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 %#lx.\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;
        device->target = NULL;
        device->target_ds = NULL;
        wined3d_mutex_unlock();
        return DDERR_INVALIDPIXELFORMAT;
    }
 
    if (device->hardware_device && !(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;
        device->target = NULL;
        device->target_ds = NULL;
        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 4722 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    struct ddraw_surface *tex = unsafe_impl_from_IDirect3DTexture2(texture);
    struct wined3d_texture *wined3d_texture = NULL;
 
    TRACE("iface %p, stage %lu, texture %p.\n", iface, stage, texture);
 
    wined3d_mutex_lock();
 
    if (tex && ((tex->surface_desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE) || !device->hardware_device))
    {
        if (tex->draw_texture)
        {
            wined3d_texture = tex->draw_texture;
            device->have_draw_textures = TRUE;
        }
        else
        {
            wined3d_texture = tex->wined3d_texture;
        }
    }
 
    wined3d_stateblock_set_texture(device->state, stage, wined3d_texture);
    fixup_texture_alpha_op(device);
 
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

d3d_device3_SetTextureStageState()

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

static

Definition at line 5069 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
    DWORD old_value;
    HRESULT hr;
 
    TRACE("iface %p, stage %lu, state %#x, value %#lx.\n",
            iface, stage, state, value);
 
    /* Tests show that legacy texture blending is not reset if the texture stage state
     * value is unchanged. */
    if (FAILED(hr = IDirect3DDevice7_GetTextureStageState(&device->IDirect3DDevice7_iface,
                stage, state, &old_value)))
        return hr;
 
    if (old_value == value)
    {
        TRACE("Application is setting the same value over, nothing to do.\n");
        return D3D_OK;
    }
 
    device->legacyTextureBlending = FALSE;
 
    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 3166 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)
    {
        struct wined3d_matrix projection;
 
        wined3d_mutex_lock();
        multiply_matrix(&projection, &device->legacy_clipspace, (struct wined3d_matrix *)matrix);
        wined3d_stateblock_set_transform(device->state, WINED3D_TS_PROJECTION, &projection);
        memcpy(&device->legacy_projection, matrix, sizeof(*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 5144 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 2247 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 = malloc(device->buffer_size);
        if (old_buffer)
        {
            memcpy(device->sysmem_vertex_buffer, old_buffer, device->nb_vertices * device->vertex_size);
            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 224 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 5697 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
 
    TRACE("iface %p, stateblock %#lx.\n", iface, stateblock);
 
    wined3d_mutex_lock();
    if (device->recording)
    {
        wined3d_mutex_unlock();
        WARN("Trying to apply a stateblock while recording, returning D3DERR_INBEGINSTATEBLOCK.\n");
        return D3DERR_INBEGINSTATEBLOCK;
    }
    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, device->state);
    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 5730 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 5725 of file device.c.

{
    return d3d_device7_ApplyStateBlock(iface, stateblock);
}

d3d_device7_BeginScene()

static HRESULT d3d_device7_BeginScene ( IDirect3DDevice7 *  iface )

static

Definition at line 1504 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 1524 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 1519 of file device.c.

{
    return d3d_device7_BeginScene(iface);
}

d3d_device7_BeginStateBlock()

static HRESULT d3d_device7_BeginStateBlock ( IDirect3DDevice7 *  iface )

static

Definition at line 5523 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *stateblock;
    HRESULT hr;
 
    TRACE("iface %p.\n", iface);
 
    wined3d_mutex_lock();
    if (device->recording)
    {
        wined3d_mutex_unlock();
        WARN("Trying to begin a stateblock while recording, returning D3DERR_INBEGINSTATEBLOCK.\n");
        return D3DERR_INBEGINSTATEBLOCK;
    }
    if (SUCCEEDED(hr = wined3d_stateblock_create(device->wined3d_device, NULL, WINED3D_SBT_RECORDED, &stateblock)))
        device->update_state = device->recording = stateblock;
    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 5550 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 5545 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 5757 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
 
    TRACE("iface %p, stateblock %#lx.\n", iface, stateblock);
 
    wined3d_mutex_lock();
    if (device->recording)
    {
        wined3d_mutex_unlock();
        WARN("Trying to capture a stateblock while recording, returning D3DERR_INBEGINSTATEBLOCK.\n");
        return D3DERR_INBEGINSTATEBLOCK;
    }
    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, device->state);
    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 5790 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 5785 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 5173 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 *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, count %lu, rects %p, flags %#lx, color 0x%08lx, z %.8e, stencil %#lx.\n",
            iface, count, rects, flags, color, z, stencil);
 
    if (count && !rects)
    {
        WARN("count %lu with NULL rects.\n", count);
        count = 0;
    }
 
    wined3d_mutex_lock();
    d3d_device_apply_state(device, TRUE);
    hr = wined3d_device_clear(device->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 5209 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 5203 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 4503 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 %lu, flags %#lx, 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 5878 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();
 
    if (device->recording)
    {
        wined3d_mutex_unlock();
        WARN("Trying to apply a stateblock while recording, returning D3DERR_INBEGINSTATEBLOCK.\n");
        return D3DERR_INBEGINSTATEBLOCK;
    }
 
    if (FAILED(hr = wined3d_stateblock_create(device->wined3d_device,
            device->state, wined3d_stateblock_type_from_ddraw(type), &wined3d_sb)))
    {
        WARN("Failed to create stateblock, hr %#lx.\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 5937 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 5931 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 5817 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
    ULONG ref;
 
    TRACE("iface %p, stateblock %#lx.\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 %lu).\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 5850 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 5845 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 3605 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    unsigned int idx_size = index_count * sizeof(*indices);
    unsigned short min_index = USHRT_MAX, max_index = 0;
    unsigned int i;
    HRESULT hr;
    UINT stride = get_flexible_vertex_size(fvf);
    UINT vb_pos, ib_pos;
 
    TRACE("iface %p, primitive_type %#x, fvf %#lx, vertices %p, vertex_count %lu, "
            "indices %p, index_count %lu, flags %#lx.\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;
    }
 
    /* Prince of Persia 3D creates large vertex buffers but only actually uses
     * a few vertices from them. This improves performance dramatically. */
    for (i = 0; i < index_count; ++i)
    {
        min_index = min(min_index, indices[i]);
        max_index = max(max_index, indices[i]);
    }
 
    /* Set the D3DDevice's FVF */
    wined3d_mutex_lock();
 
    if (FAILED(hr = wined3d_streaming_buffer_upload(device->wined3d_device, &device->vertex_buffer,
            (char *)vertices + (min_index * stride), (max_index + 1 - min_index) * stride, stride, &vb_pos)))
        goto done;
 
    if (FAILED(hr = wined3d_streaming_buffer_upload(device->wined3d_device,
            &device->index_buffer, indices, idx_size, sizeof(*indices), &ib_pos)))
        goto done;
 
    hr = wined3d_stateblock_set_stream_source(device->state, 0, device->vertex_buffer.buffer, 0, stride);
    if (FAILED(hr))
        goto done;
    wined3d_stateblock_set_index_buffer(device->state, device->index_buffer.buffer, WINED3DFMT_R16_UINT);
 
    wined3d_stateblock_set_vertex_declaration(device->state, ddraw_find_decl(device->ddraw, fvf));
    wined3d_device_context_set_primitive_type(device->immediate_context,
            wined3d_primitive_type_from_ddraw(primitive_type), 0);
    d3d_device_apply_state(device, FALSE);
    wined3d_device_context_draw_indexed(device->immediate_context, (int)(vb_pos / stride) - min_index,
            ib_pos / sizeof(*indices), index_count, 0, 0);
 
done:
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d_device7_DrawIndexedPrimitive_FPUPreserve(), d3d_device7_DrawIndexedPrimitive_FPUSetup(), and d3d_device7_DrawIndexedPrimitiveVB().

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 3671 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 3663 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 4027 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);
    void *dst_data;
    UINT vb_pos;
    UINT ib_pos;
    HRESULT hr;
 
    TRACE("iface %p, primitive_type %#x, fvf %#lx, strided_data %p, "
            "vertex_count %lu, indices %p, index_count %lu, flags %#lx.\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();
 
    if (FAILED(hr = wined3d_streaming_buffer_map(device->wined3d_device,
            &device->vertex_buffer, vtx_dst_size, vtx_dst_stride, &vb_pos, &dst_data)))
        goto done;
    pack_strided_data(dst_data, vertex_count, strided_data, fvf);
    wined3d_streaming_buffer_unmap(&device->vertex_buffer);
 
    if (FAILED(hr = wined3d_streaming_buffer_upload(device->wined3d_device,
            &device->index_buffer, indices, idx_size, sizeof(WORD), &ib_pos)))
        goto done;
 
    hr = wined3d_stateblock_set_stream_source(device->state, 0, device->vertex_buffer.buffer, 0, vtx_dst_stride);
    if (FAILED(hr))
        goto done;
    wined3d_stateblock_set_index_buffer(device->state, device->index_buffer.buffer, WINED3DFMT_R16_UINT);
 
    wined3d_stateblock_set_vertex_declaration(device->state, ddraw_find_decl(device->ddraw, fvf));
    wined3d_device_context_set_primitive_type(device->immediate_context,
            wined3d_primitive_type_from_ddraw(primitive_type), 0);
    d3d_device_apply_state(device, FALSE);
    wined3d_device_context_draw_indexed(device->immediate_context,
            vb_pos / vtx_dst_stride, ib_pos / sizeof(WORD), index_count, 0, 0);
 
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 4088 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 4079 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 4255 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_resource *wined3d_resource;
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
    HRESULT hr;
    UINT ib_pos;
 
    TRACE("iface %p, primitive_type %#x, vb %p, start_vertex %lu, "
            "vertex_count %lu, indices %p, index_count %lu, flags %#lx.\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;
    }
 
    vb_impl->discarded = false;
 
    if (vb_impl->sysmem)
    {
        TRACE("Drawing from D3DVBCAPS_SYSTEMMEMORY vertex buffer, forwarding to DrawIndexedPrimitive().\n");
        wined3d_mutex_lock();
        wined3d_box.left = start_vertex * stride;
        wined3d_box.right = wined3d_box.left + vertex_count * stride;
        wined3d_resource = wined3d_buffer_get_resource(vb_impl->wined3d_buffer);
        if (FAILED(hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc,
                &wined3d_box, WINED3D_MAP_READ)))
        {
            wined3d_mutex_unlock();
            return D3DERR_VERTEXBUFFERLOCKED;
        }
        hr = d3d_device7_DrawIndexedPrimitive(iface, primitive_type, vb_impl->fvf,
                wined3d_map_desc.data, vertex_count, indices, index_count, flags);
        wined3d_resource_unmap(wined3d_resource, 0);
        wined3d_mutex_unlock();
        return hr;
    }
 
    /* 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_context_draw_indexed()
     */
 
    wined3d_mutex_lock();
 
    wined3d_stateblock_set_vertex_declaration(device->state, vb_impl->wined3d_declaration);
 
    if (FAILED(hr = wined3d_streaming_buffer_upload(device->wined3d_device,
            &device->index_buffer, indices, index_count * sizeof(WORD), sizeof(WORD), &ib_pos)))
    {
        wined3d_mutex_unlock();
        return hr;
    }
 
    /* Set the index stream */
    wined3d_stateblock_set_index_buffer(device->state, device->index_buffer.buffer, WINED3DFMT_R16_UINT);
 
    /* Set the vertex stream source */
    if (FAILED(hr = wined3d_stateblock_set_stream_source(device->state,
            0, vb_impl->wined3d_buffer, 0, stride)))
    {
        ERR("Failed to set stream source for device %p, hr %#lx.\n", device, hr);
        wined3d_mutex_unlock();
        return hr;
    }
 
    wined3d_device_context_set_primitive_type(device->immediate_context,
            wined3d_primitive_type_from_ddraw(primitive_type), 0);
    d3d_device_apply_state(device, FALSE);
    wined3d_device_context_draw_indexed(device->immediate_context, start_vertex,
            ib_pos / sizeof(WORD), index_count, 0, 0);
 
    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 4349 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 4341 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 3468 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    UINT stride, vb_pos, size;
    HRESULT hr;
 
    TRACE("iface %p, primitive_type %#x, fvf %#lx, vertices %p, vertex_count %lu, flags %#lx.\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();
 
    if (FAILED(hr = wined3d_streaming_buffer_upload(device->wined3d_device,
            &device->vertex_buffer, vertices, size, stride, &vb_pos)))
        goto done;
 
    hr = wined3d_stateblock_set_stream_source(device->state, 0, device->vertex_buffer.buffer, 0, stride);
    if (FAILED(hr))
        goto done;
 
    wined3d_stateblock_set_vertex_declaration(device->state, ddraw_find_decl(device->ddraw, fvf));
    wined3d_device_context_set_primitive_type(device->immediate_context,
            wined3d_primitive_type_from_ddraw(primitive_type), 0);
    d3d_device_apply_state(device, FALSE);
    wined3d_device_context_draw(device->immediate_context, vb_pos / stride, vertex_count, 0, 0);
 
done:
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d_device7_DrawPrimitive_FPUPreserve(), d3d_device7_DrawPrimitive_FPUSetup(), and d3d_device7_DrawPrimitiveVB().

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 3517 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 3510 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 3931 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;
    void *dst_data;
    UINT vb_pos;
 
    TRACE("iface %p, primitive_type %#x, fvf %#lx, strided_data %p, vertex_count %lu, flags %#lx.\n",
            iface, primitive_type, fvf, strided_data, vertex_count, flags);
 
    if (!vertex_count)
    {
        WARN("0 vertex count.\n");
        return D3D_OK;
    }
 
    wined3d_mutex_lock();
 
    if (FAILED(hr = wined3d_streaming_buffer_map(device->wined3d_device,
            &device->vertex_buffer, dst_size, dst_stride, &vb_pos, &dst_data)))
        goto done;
    pack_strided_data(dst_data, vertex_count, strided_data, fvf);
    wined3d_streaming_buffer_unmap(&device->vertex_buffer);
 
    hr = wined3d_stateblock_set_stream_source(device->state, 0, device->vertex_buffer.buffer, 0, dst_stride);
    if (FAILED(hr))
        goto done;
    wined3d_stateblock_set_vertex_declaration(device->state, ddraw_find_decl(device->ddraw, fvf));
 
    wined3d_device_context_set_primitive_type(device->immediate_context,
            wined3d_primitive_type_from_ddraw(primitive_type), 0);
    d3d_device_apply_state(device, FALSE);
    wined3d_device_context_draw(device->immediate_context, vb_pos / dst_stride, vertex_count, 0, 0);
 
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 3981 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 3973 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 4139 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct d3d_vertex_buffer *vb_impl = unsafe_impl_from_IDirect3DVertexBuffer7(vb);
    struct wined3d_resource *wined3d_resource;
    struct wined3d_map_desc wined3d_map_desc;
    struct wined3d_box wined3d_box = {0};
    DWORD stride;
    HRESULT hr;
 
    TRACE("iface %p, primitive_type %#x, vb %p, start_vertex %lu, vertex_count %lu, flags %#lx.\n",
            iface, primitive_type, vb, start_vertex, vertex_count, flags);
 
    if (!vertex_count)
    {
        WARN("0 vertex count.\n");
        return D3D_OK;
    }
 
    vb_impl->discarded = false;
 
    stride = get_flexible_vertex_size(vb_impl->fvf);
 
    if (vb_impl->sysmem)
    {
        TRACE("Drawing from D3DVBCAPS_SYSTEMMEMORY vertex buffer, forwarding to DrawPrimitive().\n");
        wined3d_mutex_lock();
        wined3d_resource = wined3d_buffer_get_resource(vb_impl->wined3d_buffer);
        wined3d_box.left = start_vertex * stride;
        wined3d_box.right = wined3d_box.left + vertex_count * stride;
        if (FAILED(hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc,
                &wined3d_box, WINED3D_MAP_READ)))
        {
            wined3d_mutex_unlock();
            return D3DERR_VERTEXBUFFERLOCKED;
        }
        hr = d3d_device7_DrawPrimitive(iface, primitive_type, vb_impl->fvf, wined3d_map_desc.data,
                vertex_count, flags);
        wined3d_resource_unmap(wined3d_resource, 0);
        wined3d_mutex_unlock();
        return hr;
    }
 
    wined3d_mutex_lock();
    wined3d_stateblock_set_vertex_declaration(device->state, vb_impl->wined3d_declaration);
    if (FAILED(hr = wined3d_stateblock_set_stream_source(device->state,
            0, vb_impl->wined3d_buffer, 0, stride)))
    {
        WARN("Failed to set stream source, hr %#lx.\n", hr);
        wined3d_mutex_unlock();
        return hr;
    }
 
    /* Now draw the primitives */
    wined3d_device_context_set_primitive_type(device->immediate_context,
            wined3d_primitive_type_from_ddraw(primitive_type), 0);
    d3d_device_apply_state(device, FALSE);
    wined3d_device_context_draw(device->immediate_context, start_vertex, vertex_count, 0, 0);
 
    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 4210 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 4204 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 1577 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 1597 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 1592 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 5578 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_stateblock *wined3d_sb;
    DWORD h;
 
    TRACE("iface %p, stateblock %p.\n", iface, stateblock);
 
    if (!stateblock)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    if (!device->recording)
    {
        wined3d_mutex_unlock();
        WARN("Trying to end a stateblock, but no stateblock is being recorded.\n");
        return D3DERR_NOTINBEGINSTATEBLOCK;
    }
    wined3d_sb = device->recording;
    wined3d_stateblock_init_contained_states(wined3d_sb);
    device->recording = NULL;
    device->update_state = device->state;
 
    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 D3D_OK;
}

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 5622 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 5617 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 1074 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_output_get_display_mode(device->ddraw->wined3d_output, &mode, NULL)))
    {
        wined3d_mutex_unlock();
        WARN("Failed to get output display mode, hr %#lx.\n", hr);
        return hr;
    }
 
    for (i = 0; i < ARRAY_SIZE(FormatList); ++i)
    {
        if (wined3d_check_device_format(device->ddraw->wined3d, device->ddraw->wined3d_adapter,
                WINED3D_DEVICE_TYPE_HAL, mode.format_id, 0, WINED3D_BIND_SHADER_RESOURCE,
                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, device->ddraw->wined3d_adapter,
                WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_QUERY_LEGACYBUMPMAP,
                WINED3D_BIND_SHADER_RESOURCE, 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 1184 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 1178 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 421 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 442 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 437 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 6471 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, idx %lu, plane %p.\n", iface, idx, plane);
 
    if (!plane)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    if (idx < WINED3D_MAX_CLIP_DISTANCES)
        memcpy(plane, &device->stateblock_state->clip_planes[idx], sizeof(struct wined3d_vec4));
    else
    {
        WARN("Clip plane %lu is not supported.\n", idx);
        if (idx < ARRAY_SIZE(device->user_clip_planes))
            memcpy(plane, &device->user_clip_planes[idx], sizeof(struct wined3d_vec4));
    }
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

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 6499 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 6494 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 3817 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_viewport vp;
 
    FIXME("iface %p, clip_status %p stub.\n", iface, clip_status);
 
    vp = device->stateblock_state->viewport;
    clip_status->minx = vp.x;
    clip_status->maxx = vp.x + vp.width;
    clip_status->miny = vp.y;
    clip_status->maxy = vp.y + vp.height;
    clip_status->minz = 0.0f;
    clip_status->maxz = 0.0f;
    clip_status->dwFlags = D3DCLIPSTATUS_EXTENTS2;
    clip_status->dwStatus = 0;
 
    return D3D_OK;
}

d3d_device7_GetDirect3D()

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

static

Definition at line 1650 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 6527 of file device.c.

{
    TRACE("iface %p, info_id %#lx, info %p, info_size %lu.\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 5479 of file device.c.

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

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 5500 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 5495 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 6360 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_light light;
    HRESULT hr;
 
    TRACE("iface %p, light_idx %lu, enabled %p.\n", iface, light_idx, enabled);
 
    if (!enabled)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    hr = wined3d_stateblock_get_light(device->state, light_idx, &light, 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 6383 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 6378 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 5388 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. */
    memcpy(material, &device->stateblock_state->material, sizeof(*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 5407 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 5402 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 2332 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    const struct wined3d_stateblock_state *device_state;
    HRESULT hr = D3D_OK;
 
    TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
 
    if (!value)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    device_state = device->stateblock_state;
    switch (state)
    {
        case D3DRENDERSTATE_TEXTUREMAG:
        {
            enum wined3d_texture_filter_type tex_mag = device_state->sampler_states[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 = device_state->sampler_states[0][WINED3D_SAMP_MIN_FILTER];
            tex_mip = device_state->sampler_states[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 = device_state->sampler_states[0][WINED3D_SAMP_ADDRESS_U];
            break;
        case D3DRENDERSTATE_TEXTUREADDRESSV:
            *value = device_state->sampler_states[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;
 
        default:
            if (state >= D3DRENDERSTATE_STIPPLEPATTERN00
                    && state <= D3DRENDERSTATE_STIPPLEPATTERN31)
            {
                FIXME("Unhandled stipple pattern render state (%#x).\n", state);
                hr = E_NOTIMPL;
                break;
            }
            *value = device_state->rs[wined3d_render_state_from_ddraw(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 2460 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 2454 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 2058 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 4586 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 %lu, texture %p.\n", iface, stage, texture);
 
    if (!texture)
        return DDERR_INVALIDPARAMS;
 
    if (stage >= DDRAW_MAX_TEXTURES)
    {
        WARN("Invalid stage %lu.\n", stage);
        *texture = NULL;
        return D3D_OK;
    }
 
    wined3d_mutex_lock();
    if (!(wined3d_texture = device->stateblock_state->textures[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 4627 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 4621 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 4809 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    const struct wined3d_stateblock_state *device_state;
    const struct tss_lookup *l;
 
    TRACE("iface %p, stage %lu, 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;
    }
 
    if (stage >= DDRAW_MAX_TEXTURES)
    {
        WARN("Invalid stage %lu.\n", stage);
        *value = 0;
        return D3D_OK;
    }
 
    l = &tss_lookup[state];
 
    wined3d_mutex_lock();
 
    device_state = device->stateblock_state;
 
    if (l->sampler_state)
    {
        *value = device_state->sampler_states[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 %#lx.\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 %#lx.\n", *value);
                        *value = D3DTFG_POINT;
                        break;
                }
                break;
            }
 
            default:
                break;
        }
    }
    else
    {
        *value = device_state->texture_states[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 4917 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 4911 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 3218 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    if (!matrix)
        return DDERR_INVALIDPARAMS;
 
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
    wined3d_mutex_lock();
    memcpy(matrix, &device->stateblock_state->transforms[wined3d_transform_state_from_ddraw(state)], sizeof(*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 3242 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 3236 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 5283 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_viewport = device->stateblock_state->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 5312 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 5307 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 6313 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, light_idx %lu, enabled %#x.\n", iface, light_idx, enabled);
 
    wined3d_mutex_lock();
    hr = wined3d_stateblock_set_light_enable(device->update_state, 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 6332 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 6327 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 6114 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 %#lx.\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 6285 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 6279 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 3303 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
    wined3d_mutex_lock();
    wined3d_stateblock_multiply_transform(device->state,
            wined3d_transform_state_from_ddraw(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 3325 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 3319 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 5650 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->draw_texture ? surface->draw_texture
            : 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 5672 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 5667 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 178 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 356 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 6411 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    const struct wined3d_vec4 *wined3d_plane;
    HRESULT hr;
 
    TRACE("iface %p, idx %lu, plane %p.\n", iface, idx, plane);
 
    if (!plane)
        return DDERR_INVALIDPARAMS;
 
    wined3d_plane = (struct wined3d_vec4 *)plane;
 
    wined3d_mutex_lock();
    hr = wined3d_stateblock_set_clip_plane(device->update_state, 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 %lu 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 6445 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 6440 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 3780 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 5434 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr;
 
    TRACE("iface %p, light_idx %lu, light %p.\n", iface, light_idx, light);
 
    wined3d_mutex_lock();
    /* Note: D3DLIGHT7 is compatible with struct wined3d_light. */
    hr = wined3d_stateblock_set_light(device->update_state, light_idx, (const 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 5454 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 5449 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 5339 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_stateblock_set_material(device->update_state, (const 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 5361 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 5356 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 2543 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    HRESULT hr = D3D_OK;
 
    TRACE("iface %p, state %#x, value %#lx.\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 %#lx.\n", value);
                    break;
            }
 
            wined3d_stateblock_set_sampler_state(device->state, 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 %#lx.\n",value);
                    tex_min = WINED3D_TEXF_POINT;
                    tex_mip = WINED3D_TEXF_NONE;
                    break;
            }
 
            wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_MIP_FILTER, tex_mip);
            wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_MIN_FILTER, tex_min);
            break;
        }
 
        case D3DRENDERSTATE_TEXTUREADDRESS:
            wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_ADDRESS_V, value);
            /* Drop through */
        case D3DRENDERSTATE_TEXTUREADDRESSU:
            wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_ADDRESS_U, value);
            break;
        case D3DRENDERSTATE_TEXTUREADDRESSV:
            wined3d_stateblock_set_sampler_state(device->state, 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;
 
        default:
            if (state >= D3DRENDERSTATE_STIPPLEPATTERN00
                    && state <= D3DRENDERSTATE_STIPPLEPATTERN31)
            {
                FIXME("Unhandled stipple pattern render state (%#x).\n", state);
                hr = E_NOTIMPL;
                break;
            }
 
            wined3d_stateblock_set_render_state(device->update_state, wined3d_render_state_from_ddraw(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 2684 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 2678 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 1866 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 %#lx.\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->hardware_device && !(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;
        device->target = NULL;
        device->target_ds = NULL;
        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 1921 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 1915 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 4674 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;
 
    TRACE("iface %p, stage %lu, texture %p.\n", iface, stage, texture);
 
    if (surf && (surf->surface_desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE))
    {
        if (surf->draw_texture)
        {
            wined3d_texture = surf->draw_texture;
            device->have_draw_textures = TRUE;
        }
        else
        {
            wined3d_texture = surf->wined3d_texture;
        }
    }
 
    wined3d_mutex_lock();
    wined3d_stateblock_set_texture(device->update_state, stage, wined3d_texture);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

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 4709 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 4703 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 4958 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    const struct tss_lookup *l;
 
    TRACE("iface %p, stage %lu, state %#x, value %#lx.\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 %#lx.\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 %#lx.\n", value);
                        value = WINED3D_TEXF_POINT;
                        break;
                }
                break;
            }
 
            case D3DTSS_ADDRESS:
                wined3d_stateblock_set_sampler_state(device->state, stage, WINED3D_SAMP_ADDRESS_V, value);
                break;
 
            default:
                break;
        }
 
        wined3d_stateblock_set_sampler_state(device->state, stage, l->u.sampler_state, value);
    }
    else
        wined3d_stateblock_set_texture_stage_state(device->update_state, 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 5056 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 5050 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 3128 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
 
    TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
 
    if (!matrix)
        return DDERR_INVALIDPARAMS;
 
    /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
    wined3d_mutex_lock();
    wined3d_stateblock_set_transform(device->update_state,
            wined3d_transform_state_from_ddraw(state), (const 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 3153 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 3147 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 5222 of file device.c.

{
    struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
    struct wined3d_sub_resource_desc rt_desc;
    struct wined3d_rendertarget_view *rtv;
    struct ddraw_surface *surface;
    struct wined3d_viewport vp;
 
    TRACE("iface %p, viewport %p.\n", iface, viewport);
 
    if (!viewport)
        return DDERR_INVALIDPARAMS;
 
    wined3d_mutex_lock();
    rtv = device->target ? ddraw_surface_get_rendertarget_view(device->target) : NULL;
    if (!rtv)
    {
        wined3d_mutex_unlock();
        return DDERR_INVALIDCAPS;
    }
    surface = wined3d_rendertarget_view_get_sub_resource_parent(rtv);
    wined3d_texture_get_sub_resource_desc(surface->wined3d_texture, surface->sub_resource_idx, &rt_desc);
 
    if (!wined3d_bound_range(viewport->dwX, viewport->dwWidth, rt_desc.width)
            || !wined3d_bound_range(viewport->dwY, viewport->dwHeight, rt_desc.height))
    {
        WARN("Invalid viewport, returning E_INVALIDARG.\n");
        wined3d_mutex_unlock();
        return E_INVALIDARG;
    }
 
    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_stateblock_set_viewport(device->update_state, &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 5271 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 5266 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 5113 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, device->stateblock_state, 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 5132 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 5127 of file device.c.

{
    return d3d_device7_ValidateDevice(iface, pass_count);
}

d3d_device_apply_state()

void d3d_device_apply_state	(	struct d3d_device *	device,
		BOOL	clear_state
	)

Definition at line 3454 of file device.c.

{
    if (device->ddraw && device->ddraw->device_last_applied_state != device)
    {
        wined3d_stateblock_primary_dirtify_all_states(device->wined3d_device, device->state);
        device->ddraw->device_last_applied_state = device;
    }
    if (clear_state)
        wined3d_stateblock_apply_clear_state(device->state, device->wined3d_device);
    else
        wined3d_device_apply_stateblock(device->wined3d_device, device->state);
    d3d_device_sync_surfaces(device);
}

Referenced by d3d_device7_Clear(), d3d_device7_DrawIndexedPrimitive(), d3d_device7_DrawIndexedPrimitiveStrided(), d3d_device7_DrawIndexedPrimitiveVB(), d3d_device7_DrawPrimitive(), d3d_device7_DrawPrimitiveStrided(), and d3d_device7_DrawPrimitiveVB().

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 6959 of file device.c.

{
    struct d3d_device *object;
    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 (!(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 (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_OUTOFMEMORY;
    }
 
    if (!(object = calloc(1, sizeof(*object))))
    {
        ERR("Failed to allocate device memory.\n");
        return DDERR_OUTOFMEMORY;
    }
 
    if (FAILED(hr = d3d_device_init(object, ddraw, guid, target, rt_iface, version, outer_unknown)))
    {
        WARN("Failed to initialize device, hr %#lx.\n", hr);
        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, const GUID *  guid, struct ddraw_surface *  target, IUnknown *  rt_iface, UINT  version, IUnknown *  outer_unknown  )

static

Definition at line 6858 of file device.c.

{
    static const struct wined3d_matrix 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,
    };
    struct wined3d_rendertarget_view *rtv;
    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->hardware_device = IsEqualGUID(&IID_IDirect3DTnLHalDevice, guid)
            || IsEqualGUID(&IID_IDirect3DHALDevice, guid);
 
    if (device->hardware_device && !(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
    {
        WARN("Surface %p is not in video memory.\n", target);
        return D3DERR_SURFACENOTINVIDMEM;
    }
 
    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;
 
    if (FAILED(hr = wined3d_stateblock_create(ddraw->wined3d_device, NULL, WINED3D_SBT_PRIMARY, &device->state)))
    {
        ERR("Failed to create the primary stateblock, hr %#lx.\n", hr);
        ddraw_handle_table_destroy(&device->handle_table);
        return hr;
    }
    device->stateblock_state = wined3d_stateblock_get_state(device->state);
    device->update_state = device->state;
 
    /* This is for convenience. */
    device->wined3d_device = ddraw->wined3d_device;
    device->immediate_context = ddraw->immediate_context;
    wined3d_device_incref(ddraw->wined3d_device);
 
    wined3d_streaming_buffer_init(&device->vertex_buffer, WINED3D_BIND_VERTEX_BUFFER);
    wined3d_streaming_buffer_init(&device->index_buffer, WINED3D_BIND_INDEX_BUFFER);
 
    /* Render to the back buffer */
    rtv = ddraw_surface_get_rendertarget_view(target);
    if (FAILED(hr = wined3d_device_context_set_rendertarget_views(device->immediate_context, 0, 1, &rtv, TRUE)))
    {
        ERR("Failed to set render target, hr %#lx.\n", hr);
        wined3d_stateblock_decref(device->state);
        ddraw_handle_table_destroy(&device->handle_table);
        return hr;
    }
 
    device->rt_iface = rt_iface;
    device->target = target;
    if (version != 1)
        IUnknown_AddRef(device->rt_iface);
 
    list_add_head(&ddraw->d3ddevice_list, &device->ddraw_entry);
 
    wined3d_stateblock_set_render_state(device->state, WINED3D_RS_ZENABLE,
            d3d_device_update_depth_stencil(device));
    if (version == 1) /* Color keying is initially enabled for version 1 devices. */
        wined3d_stateblock_set_render_state(device->state, WINED3D_RS_COLORKEYENABLE, TRUE);
    else if (version == 2)
        wined3d_stateblock_set_render_state(device->state, WINED3D_RS_SPECULARENABLE, TRUE);
    if (version < 7)
    {
        wined3d_stateblock_set_render_state(device->state, WINED3D_RS_NORMALIZENORMALS, TRUE);
        IDirect3DDevice3_SetRenderState(&device->IDirect3DDevice3_iface,
                D3DRENDERSTATE_TEXTUREMAPBLEND, D3DTBLEND_MODULATE);
    }
    device_reset_viewport_state(device);
    return D3D_OK;
}

d3d_device_inner_AddRef()

static ULONG WINAPI d3d_device_inner_AddRef ( IUnknown *  iface )

static

Definition at line 214 of file device.c.

{
    struct d3d_device *device = impl_from_IUnknown(iface);
    ULONG ref = InterlockedIncrement(&device->ref);
 
    TRACE("%p increasing refcount to %lu.\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 120 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 260 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 %lu.\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)
    {
        static struct wined3d_rendertarget_view *const null_rtv;
        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(). */
 
        wined3d_streaming_buffer_cleanup(&This->index_buffer);
        wined3d_streaming_buffer_cleanup(&This->vertex_buffer);
 
        wined3d_device_context_set_rendertarget_views(This->immediate_context, 0, 1, &null_rtv, 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_STATEBLOCK:
                {
                    /* No FIXME here because this might happen because of sloppy applications. */
                    WARN("Leftover stateblock handle %#lx (%p), deleting.\n", i + 1, entry->object);
                    IDirect3DDevice7_DeleteStateBlock(&This->IDirect3DDevice7_iface, i + 1);
                    break;
                }
 
                default:
                    FIXME("Handle %#lx (%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);
        }
 
        wined3d_stateblock_decref(This->state);
        if (This->recording)
            wined3d_stateblock_decref(This->recording);
 
        /* Releasing the render target below may release the last reference to the ddraw object. Detach
         * the device from it before so it doesn't try to save / restore state on the teared down device. */
        if (This->ddraw)
        {
            if (This->ddraw->device_last_applied_state == This)
                This->ddraw->device_last_applied_state = NULL;
            list_remove(&This->ddraw_entry);
            This->ddraw = NULL;
        }
 
        TRACE("Releasing render target %p.\n", This->rt_iface);
        rt_iface = This->rt_iface;
        This->rt_iface = NULL;
        This->target = NULL;
        This->target_ds = NULL;
        if (This->version != 1)
            IUnknown_Release(rt_iface);
        TRACE("Render target release done.\n");
 
        /* Now free the structure */
        free(This);
        wined3d_mutex_unlock();
    }
 
    TRACE("Done\n");
    return ref;
}

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 1836 of file device.c.

{
    struct wined3d_rendertarget_view *rtv;
    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;
    }
 
    rtv = ddraw_surface_get_rendertarget_view(target);
    if (FAILED(hr = wined3d_device_context_set_rendertarget_views(device->immediate_context, 0, 1, &rtv, FALSE)))
        return hr;
 
    IUnknown_AddRef(rt_iface);
    IUnknown_Release(device->rt_iface);
    device->rt_iface = rt_iface;
    device->target = target;
    d3d_device_update_depth_stencil(device);
 
    return D3D_OK;
}

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

d3d_device_sync_rendertarget()

static void d3d_device_sync_rendertarget ( struct d3d_device *  device )

static

Definition at line 3392 of file device.c.

{
    struct wined3d_rendertarget_view *rtv, *dsv;
 
    rtv = device->target ? ddraw_surface_get_rendertarget_view(device->target) : NULL;
    if (rtv)
    {
        if (FAILED(wined3d_device_context_set_rendertarget_views(device->immediate_context, 0, 1, &rtv, FALSE)))
            ERR("wined3d_device_context_set_rendertarget_views failed.\n");
    }
    else if (!device->target)
    {
        /* NULL device->target may appear when the game was setting invalid render target which in some cases
         * still keeps the invalid render target in the device even while returning an error.
         *
         * TODO: make render go nowhere instead of lefover render target (like it seems to work on Windows on HW devices
         * while may just crash on software devices. */
        FIXME("Keeping leftover render target.\n");
    }
 
    dsv = device->target_ds ? ddraw_surface_get_rendertarget_view(device->target_ds) : NULL;
    if (FAILED(wined3d_device_context_set_depth_stencil_view(device->immediate_context, dsv)))
        ERR("wined3d_device_context_set_depth_stencil_view failed.\n");
    wined3d_stateblock_depth_buffer_changed(device->state);
 
    if (device->hardware_device)
        return;
 
    if (rtv)
        ddraw_surface_get_draw_texture(wined3d_rendertarget_view_get_parent(rtv), DDRAW_SURFACE_RW);
 
    if (dsv)
        ddraw_surface_get_draw_texture(wined3d_rendertarget_view_get_parent(dsv), DDRAW_SURFACE_RW);
}

Referenced by d3d_device_sync_surfaces().

d3d_device_sync_surfaces()

void d3d_device_sync_surfaces

(

struct d3d_device *

device

)

Definition at line 3427 of file device.c.

{
    const struct wined3d_stateblock_state *state = device->stateblock_state;
    struct ddraw_surface *surface;
    unsigned int i, j;
 
    d3d_device_sync_rendertarget(device);
 
    if (!device->have_draw_textures)
        return;
 
    for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
    {
        if (!state->textures[i])
            continue;
 
        j = 0;
        while ((surface = wined3d_texture_get_sub_resource_parent(state->textures[i], j)))
        {
            if (!surface->draw_texture)
                break;
            ddraw_surface_get_draw_texture(surface, DDRAW_SURFACE_READ);
            ++j;
        }
    }
}

Referenced by d3d_device_apply_state().

d3d_device_update_depth_stencil()

enum wined3d_depth_buffer_type d3d_device_update_depth_stencil

(

struct d3d_device *

device

)

Definition at line 6817 of file device.c.

{
    IDirectDrawSurface7 *depthStencil = NULL;
    IDirectDrawSurface7 *render_target;
    static DDSCAPS2 depthcaps = { DDSCAPS_ZBUFFER, 0, 0, {0} };
 
    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_context_set_depth_stencil_view(device->immediate_context, NULL);
        wined3d_stateblock_depth_buffer_changed(device->state);
        device->target_ds = NULL;
        return WINED3D_ZB_FALSE;
    }
 
    device->target_ds = impl_from_IDirectDrawSurface7(depthStencil);
    wined3d_device_context_set_depth_stencil_view(device->immediate_context,
            ddraw_surface_get_rendertarget_view(device->target_ds));
    wined3d_stateblock_depth_buffer_changed(device->state);
 
    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 52 of file device.c.

{
    WORD oldcw;
 
#if defined(__i386__) && defined(_MSC_VER)
    __asm fnstcw oldcw;
#elif defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__) && (defined(__GNUC__) || defined(__clang__)))
    __asm__ volatile ("fnstcw %0" : "=m" (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().

device_reset_viewport_state()

static void device_reset_viewport_state ( struct d3d_device *  device )

static

Definition at line 6847 of file device.c.

{
    struct wined3d_viewport vp;
    RECT rect;
 
    wined3d_device_context_get_viewports(device->immediate_context, NULL, &vp);
    wined3d_stateblock_set_viewport(device->state, &vp);
    wined3d_device_context_get_scissor_rects(device->immediate_context, NULL, &rect);
    wined3d_stateblock_set_scissor_rect(device->state, &rect);
}

fixup_texture_alpha_op()

static void fixup_texture_alpha_op ( struct d3d_device *  device )

static

Definition at line 2697 of file device.c.

{
    /* This fixup is required by the way D3DTBLEND_MODULATE maps to texture stage states.
       See d3d_device3_SetRenderState() for details. */
    struct wined3d_texture *tex;
    BOOL tex_alpha = TRUE;
    DDPIXELFORMAT ddfmt;
 
    if (!(device->legacyTextureBlending && device->texture_map_blend == D3DTBLEND_MODULATE))
        return;
 
    if ((tex = device->stateblock_state->textures[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.dwRGBAlphaBitMask)
            tex_alpha = FALSE;
    }
 
    /* Args 1 and 2 are already set to WINED3DTA_TEXTURE/WINED3DTA_CURRENT in case of D3DTBLEND_MODULATE */
    wined3d_stateblock_set_texture_stage_state(device->state,
            0, WINED3D_TSS_ALPHA_OP, tex_alpha ? WINED3D_TOP_SELECT_ARG1 : WINED3D_TOP_SELECT_ARG2);
}

Referenced by d3d_device3_SetRenderState(), and d3d_device3_SetTexture().

impl_from_IUnknown()

static struct d3d_device * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 115 of file device.c.

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

in_plane()

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

static

Definition at line 4412 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.x + p.y * center.y + p.z * center.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 5950 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 3875 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 4436 of file device.c.

{
    const struct wined3d_stateblock_state *state;
    struct wined3d_matrix m;
 
    /* We want the wined3d matrices since those include the legacy viewport
     * transformation. */
    wined3d_mutex_lock();
    state = device->stateblock_state;
    multiply_matrix(&m, &state->transforms[WINED3D_TS_VIEW], &state->transforms[WINED3D_TS_WORLD]);
    multiply_matrix(&m, &state->transforms[WINED3D_TS_PROJECTION], &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 43 of file device.c.

{
#if defined(__i386__) && defined(_MSC_VER)
    __asm fldcw fpucw;
#elif defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__) && (defined(__GNUC__) || defined(__clang__)))
    __asm__ volatile ("fldcw %0" : : "m" (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 3531 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_stateblock_set_render_state(device->state, 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 6810 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 6803 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().

unsafe_impl_from_IDirect3DDevice3()

struct d3d_device * unsafe_impl_from_IDirect3DDevice3

(

IDirect3DDevice3 *

iface

)

Definition at line 6796 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 6789 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 1830 of file device.c.

{
    return !format_is_paletteindexed(&surface->surface_desc.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

)

wined3d_primitive_type_from_ddraw()

static enum wined3d_primitive_type wined3d_primitive_type_from_ddraw ( D3DPRIMITIVETYPE  type )

static

Definition at line 105 of file device.c.

{
    return (enum wined3d_primitive_type)type;
}

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

wined3d_render_state_from_ddraw()

static enum wined3d_render_state wined3d_render_state_from_ddraw ( D3DRENDERSTATETYPE  state )

static

Definition at line 75 of file device.c.

{
    switch (state)
    {
        case D3DRENDERSTATE_ZBIAS:
            return WINED3D_RS_DEPTHBIAS;
        case D3DRENDERSTATE_EDGEANTIALIAS:
            return WINED3D_RS_ANTIALIASEDLINEENABLE;
        default:
            return (enum wined3d_render_state)state;
    }
}

Referenced by d3d_device7_GetRenderState(), and d3d_device7_SetRenderState().

wined3d_stateblock_type_from_ddraw()

static enum wined3d_stateblock_type wined3d_stateblock_type_from_ddraw ( D3DSTATEBLOCKTYPE  type )

static

Definition at line 110 of file device.c.

{
    return (enum wined3d_stateblock_type)type;
}

Referenced by d3d_device7_CreateStateBlock().

wined3d_transform_state_from_ddraw()

static enum wined3d_transform_state wined3d_transform_state_from_ddraw ( D3DTRANSFORMSTATETYPE  state )

static

Definition at line 88 of file device.c.

{
    switch (state)
    {
        case D3DTRANSFORMSTATE_WORLD:
            return WINED3D_TS_WORLD_MATRIX(0);
        case D3DTRANSFORMSTATE_WORLD1:
            return WINED3D_TS_WORLD_MATRIX(1);
        case D3DTRANSFORMSTATE_WORLD2:
            return WINED3D_TS_WORLD_MATRIX(2);
        case D3DTRANSFORMSTATE_WORLD3:
            return WINED3D_TS_WORLD_MATRIX(3);
        default:
            return (enum wined3d_transform_state)state;
    }
}

Referenced by d3d_device7_GetTransform(), d3d_device7_MultiplyTransform(), and d3d_device7_SetTransform().

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 6754 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 6715 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 6667 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 6612 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 6557 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 6782 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 36 of file device.c.

Referenced by d3d1_FindDevice(), d3d2_FindDevice(), d3d3_FindDevice(), d3d7_EnumZBufferFormats(), ddraw_find_device(), and ddraw_surface7_QueryInterface().

tss_lookup

const struct tss_lookup tss_lookup[]

static

Initial value:

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