d3d9_private.h File Reference

#include <assert.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "wine/debug.h"
#include "d3d9.h"
#include "d3d9on12.h"
#include "wine/wined3d.h"

Include dependency graph for d3d9_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	d3d9
struct	fvf_declaration
struct	d3d9_device
struct	d3d9_resource
struct	d3d9_volume
struct	d3d9_swapchain
struct	d3d9_surface
struct	d3d9_vertexbuffer
struct	d3d9_indexbuffer
struct	d3d9_texture
struct	d3d9_stateblock
struct	d3d9_vertex_declaration
struct	d3d9_vertexshader
struct	d3d9_pixelshader
struct	d3d9_query

Macros
#define	COBJMACROS
#define	D3D9_MAX_VERTEX_SHADER_CONSTANTF   256
#define	D3D9_MAX_TEXTURE_UNITS   20
#define	D3D9_MAX_STREAMS   16
#define	D3DPRESENTFLAGS_MASK   0x00000fffu
#define	D3D9_TEXTURE_MIPMAP_DIRTY   0x1
#define	D3DFMT_RESZ   MAKEFOURCC('R','E','S','Z')
#define	D3D9_RESZ_CODE   0x7fa05000

Enumerations
enum	d3d9_device_state { D3D9_DEVICE_STATE_OK , D3D9_DEVICE_STATE_LOST , D3D9_DEVICE_STATE_NOT_RESET }

Functions
HRESULT	vdecl_convert_fvf (DWORD FVF, D3DVERTEXELEMENT9 **ppVertexElements)
D3DFORMAT	d3dformat_from_wined3dformat (enum wined3d_format_id format)
BOOL	is_gdi_compat_wined3dformat (enum wined3d_format_id format)
enum wined3d_format_id	wined3dformat_from_d3dformat (D3DFORMAT format)
unsigned int	wined3dmapflags_from_d3dmapflags (unsigned int flags, unsigned int usage)
void	present_parameters_from_wined3d_swapchain_desc (D3DPRESENT_PARAMETERS *present_parameters, const struct wined3d_swapchain_desc *swapchain_desc, DWORD presentation_interval)
void	d3d9_caps_from_wined3dcaps (const struct d3d9 *d3d9, unsigned int adapter_ordinal, D3DCAPS9 *caps, const struct wined3d_caps *wined3d_caps)
BOOL	d3d9_init (struct d3d9 *d3d9, BOOL extended, BOOL d3d9on12)
HRESULT	device_init (struct d3d9_device *device, struct d3d9 *parent, struct wined3d *wined3d, UINT adapter, D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters, D3DDISPLAYMODEEX *mode)
void	d3d9_resource_cleanup (struct d3d9_resource *resource)
HRESULT	d3d9_resource_free_private_data (struct d3d9_resource *resource, const GUID *guid)
HRESULT	d3d9_resource_get_private_data (struct d3d9_resource *resource, const GUID *guid, void *data, DWORD *data_size)
void	d3d9_resource_init (struct d3d9_resource *resource)
HRESULT	d3d9_resource_set_private_data (struct d3d9_resource *resource, const GUID *guid, const void *data, DWORD data_size, DWORD flags)
void	volume_init (struct d3d9_volume *volume, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, const struct wined3d_parent_ops **parent_ops)
HRESULT	d3d9_swapchain_create (struct d3d9_device *device, struct wined3d_swapchain_desc *desc, unsigned int swap_interval, struct d3d9_swapchain **swapchain)
struct wined3d_rendertarget_view *	d3d9_surface_acquire_rendertarget_view (struct d3d9_surface *surface)
struct d3d9_surface *	d3d9_surface_create (struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, IUnknown *container)
struct d3d9_device *	d3d9_surface_get_device (const struct d3d9_surface *surface)
void	d3d9_surface_release_rendertarget_view (struct d3d9_surface *surface, struct wined3d_rendertarget_view *rtv)
struct d3d9_surface *	unsafe_impl_from_IDirect3DSurface9 (IDirect3DSurface9 *iface)
HRESULT	vertexbuffer_init (struct d3d9_vertexbuffer *buffer, struct d3d9_device *device, UINT size, UINT usage, DWORD fvf, D3DPOOL pool)
struct d3d9_vertexbuffer *	unsafe_impl_from_IDirect3DVertexBuffer9 (IDirect3DVertexBuffer9 *iface)
HRESULT	indexbuffer_init (struct d3d9_indexbuffer *buffer, struct d3d9_device *device, UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool)
struct d3d9_indexbuffer *	unsafe_impl_from_IDirect3DIndexBuffer9 (IDirect3DIndexBuffer9 *iface)
HRESULT	d3d9_texture_2d_init (struct d3d9_texture *texture, struct d3d9_device *device, unsigned int width, unsigned int height, unsigned int level_count, DWORD usage, D3DFORMAT format, D3DPOOL pool)
HRESULT	d3d9_texture_3d_init (struct d3d9_texture *texture, struct d3d9_device *device, unsigned int width, unsigned int height, unsigned int depth, unsigned int level_count, DWORD usage, D3DFORMAT format, D3DPOOL pool)
HRESULT	d3d9_texture_cube_init (struct d3d9_texture *texture, struct d3d9_device *device, unsigned int edge_length, unsigned int level_count, DWORD usage, D3DFORMAT format, D3DPOOL pool)
static struct wined3d_texture *	d3d9_texture_get_draw_texture (struct d3d9_texture *texture)
struct d3d9_texture *	unsafe_impl_from_IDirect3DBaseTexture9 (IDirect3DBaseTexture9 *iface)
void	d3d9_texture_flag_auto_gen_mipmap (struct d3d9_texture *texture)
void	d3d9_texture_gen_auto_mipmap (struct d3d9_texture *texture)
HRESULT	stateblock_init (struct d3d9_stateblock *stateblock, struct d3d9_device *device, D3DSTATEBLOCKTYPE type, struct wined3d_stateblock *wined3d_stateblock)
HRESULT	d3d9_vertex_declaration_create (struct d3d9_device *device, const D3DVERTEXELEMENT9 *elements, struct d3d9_vertex_declaration **declaration)
struct d3d9_vertex_declaration *	unsafe_impl_from_IDirect3DVertexDeclaration9 (IDirect3DVertexDeclaration9 *iface)
HRESULT	vertexshader_init (struct d3d9_vertexshader *shader, struct d3d9_device *device, const DWORD *byte_code)
struct d3d9_vertexshader *	unsafe_impl_from_IDirect3DVertexShader9 (IDirect3DVertexShader9 *iface)
HRESULT	pixelshader_init (struct d3d9_pixelshader *shader, struct d3d9_device *device, const DWORD *byte_code)
struct d3d9_pixelshader *	unsafe_impl_from_IDirect3DPixelShader9 (IDirect3DPixelShader9 *iface)
HRESULT	query_init (struct d3d9_query *query, struct d3d9_device *device, D3DQUERYTYPE type)
static struct d3d9_device *	impl_from_IDirect3DDevice9Ex (IDirect3DDevice9Ex *iface)
static DWORD	d3dusage_from_wined3dusage (unsigned int wined3d_usage, unsigned int bind_flags)
static D3DPOOL	d3dpool_from_wined3daccess (unsigned int access, unsigned int usage)
static D3DMULTISAMPLE_TYPE	d3dmultisample_type_from_wined3d (enum wined3d_multisample_type type)
static D3DSCANLINEORDERING	d3dscanlineordering_from_wined3d (enum wined3d_scanline_ordering ordering)
static unsigned int	map_access_from_usage (unsigned int usage)
static unsigned int	wined3daccess_from_d3dpool (D3DPOOL pool, unsigned int usage)
static unsigned int	wined3d_usage_from_d3d (D3DPOOL pool, DWORD usage)
static unsigned int	wined3d_bind_flags_from_d3d9_usage (DWORD usage)
static enum wined3d_multisample_type	wined3d_multisample_type_from_d3d (D3DMULTISAMPLE_TYPE type)
static enum wined3d_device_type	wined3d_device_type_from_d3d (D3DDEVTYPE type)
static enum wined3d_scanline_ordering	wined3d_scanline_ordering_from_d3d (D3DSCANLINEORDERING ordering)

Variables
const struct wined3d_parent_ops	d3d9_null_wined3d_parent_ops

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 29 of file d3d9_private.h.

D3D9_MAX_STREAMS

#define D3D9_MAX_STREAMS   16

Definition at line 42 of file d3d9_private.h.

D3D9_MAX_TEXTURE_UNITS

#define D3D9_MAX_TEXTURE_UNITS   20

Definition at line 41 of file d3d9_private.h.

D3D9_MAX_VERTEX_SHADER_CONSTANTF

#define D3D9_MAX_VERTEX_SHADER_CONSTANTF   256

Definition at line 40 of file d3d9_private.h.

D3D9_RESZ_CODE

#define D3D9_RESZ_CODE   0x7fa05000

Definition at line 49 of file d3d9_private.h.

D3D9_TEXTURE_MIPMAP_DIRTY

#define D3D9_TEXTURE_MIPMAP_DIRTY   0x1

Definition at line 46 of file d3d9_private.h.

D3DFMT_RESZ

#define D3DFMT_RESZ   MAKEFOURCC('R','E','S','Z')

Definition at line 48 of file d3d9_private.h.

D3DPRESENTFLAGS_MASK

#define D3DPRESENTFLAGS_MASK   0x00000fffu

Definition at line 44 of file d3d9_private.h.

Enumeration Type Documentation

d3d9_device_state

enum d3d9_device_state

Enumerator
D3D9_DEVICE_STATE_OK
D3D9_DEVICE_STATE_LOST
D3D9_DEVICE_STATE_NOT_RESET

Definition at line 82 of file d3d9_private.h.

{
    D3D9_DEVICE_STATE_OK,
    D3D9_DEVICE_STATE_LOST,
    D3D9_DEVICE_STATE_NOT_RESET,
};

Function Documentation

d3d9_caps_from_wined3dcaps()

void d3d9_caps_from_wined3dcaps	(	const struct d3d9 *	d3d9,
		unsigned int	adapter_ordinal,
		D3DCAPS9 *	caps,
		const struct wined3d_caps *	wined3d_caps
	)

Definition at line 369 of file device.c.

{
    static const DWORD ps_minor_version[] = {0, 4, 0, 0};
    static const DWORD vs_minor_version[] = {0, 1, 0, 0};
    static const DWORD texture_filter_caps =
        D3DPTFILTERCAPS_MINFPOINT      | D3DPTFILTERCAPS_MINFLINEAR    | D3DPTFILTERCAPS_MINFANISOTROPIC |
        D3DPTFILTERCAPS_MINFPYRAMIDALQUAD                              | D3DPTFILTERCAPS_MINFGAUSSIANQUAD|
        D3DPTFILTERCAPS_MIPFPOINT      | D3DPTFILTERCAPS_MIPFLINEAR    | D3DPTFILTERCAPS_MAGFPOINT       |
        D3DPTFILTERCAPS_MAGFLINEAR     |D3DPTFILTERCAPS_MAGFANISOTROPIC|D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD|
        D3DPTFILTERCAPS_MAGFGAUSSIANQUAD;
    struct wined3d_adapter *wined3d_adapter;
    struct wined3d_output_desc output_desc;
    struct wined3d_output *wined3d_output;
    unsigned int output_idx;
    HRESULT hr;
 
    caps->DeviceType                        = (D3DDEVTYPE)wined3d_caps->DeviceType;
    caps->AdapterOrdinal                    = adapter_ordinal;
    caps->Caps                              = wined3d_caps->Caps;
    caps->Caps2                             = wined3d_caps->Caps2;
    caps->Caps3                             = wined3d_caps->Caps3;
    caps->PresentationIntervals             = D3DPRESENT_INTERVAL_IMMEDIATE | D3DPRESENT_INTERVAL_ONE;
    caps->CursorCaps                        = wined3d_caps->CursorCaps;
    caps->DevCaps                           = wined3d_caps->DevCaps;
    caps->PrimitiveMiscCaps                 = wined3d_caps->PrimitiveMiscCaps;
    caps->RasterCaps                        = wined3d_caps->RasterCaps;
    caps->ZCmpCaps                          = wined3d_caps->ZCmpCaps;
    caps->SrcBlendCaps                      = wined3d_caps->SrcBlendCaps;
    caps->DestBlendCaps                     = wined3d_caps->DestBlendCaps;
    caps->AlphaCmpCaps                      = wined3d_caps->AlphaCmpCaps;
    caps->ShadeCaps                         = wined3d_caps->ShadeCaps;
    caps->TextureCaps                       = wined3d_caps->TextureCaps;
    caps->TextureFilterCaps                 = wined3d_caps->TextureFilterCaps;
    caps->CubeTextureFilterCaps             = wined3d_caps->CubeTextureFilterCaps;
    caps->VolumeTextureFilterCaps           = wined3d_caps->VolumeTextureFilterCaps;
    caps->TextureAddressCaps                = wined3d_caps->TextureAddressCaps;
    caps->VolumeTextureAddressCaps          = wined3d_caps->VolumeTextureAddressCaps;
    caps->LineCaps                          = wined3d_caps->LineCaps;
    caps->MaxTextureWidth                   = wined3d_caps->MaxTextureWidth;
    caps->MaxTextureHeight                  = wined3d_caps->MaxTextureHeight;
    caps->MaxVolumeExtent                   = wined3d_caps->MaxVolumeExtent;
    caps->MaxTextureRepeat                  = wined3d_caps->MaxTextureRepeat;
    caps->MaxTextureAspectRatio             = wined3d_caps->MaxTextureAspectRatio;
    caps->MaxAnisotropy                     = wined3d_caps->MaxAnisotropy;
    caps->MaxVertexW                        = wined3d_caps->MaxVertexW;
    caps->GuardBandLeft                     = wined3d_caps->GuardBandLeft;
    caps->GuardBandTop                      = wined3d_caps->GuardBandTop;
    caps->GuardBandRight                    = wined3d_caps->GuardBandRight;
    caps->GuardBandBottom                   = wined3d_caps->GuardBandBottom;
    caps->ExtentsAdjust                     = wined3d_caps->ExtentsAdjust;
    caps->StencilCaps                       = wined3d_caps->StencilCaps;
    caps->FVFCaps                           = wined3d_caps->FVFCaps;
    caps->TextureOpCaps                     = wined3d_caps->TextureOpCaps;
    caps->MaxTextureBlendStages             = wined3d_caps->MaxTextureBlendStages;
    caps->MaxSimultaneousTextures           = wined3d_caps->MaxSimultaneousTextures;
    caps->VertexProcessingCaps              = wined3d_caps->VertexProcessingCaps;
    caps->MaxActiveLights                   = wined3d_caps->MaxActiveLights;
    caps->MaxUserClipPlanes                 = wined3d_caps->MaxUserClipPlanes;
    caps->MaxVertexBlendMatrices            = wined3d_caps->MaxVertexBlendMatrices;
    caps->MaxVertexBlendMatrixIndex         = wined3d_caps->MaxVertexBlendMatrixIndex;
    caps->MaxPointSize                      = wined3d_caps->MaxPointSize;
    caps->MaxPrimitiveCount                 = wined3d_caps->MaxPrimitiveCount;
    caps->MaxVertexIndex                    = wined3d_caps->MaxVertexIndex;
    caps->MaxStreams                        = wined3d_caps->MaxStreams;
    caps->MaxStreamStride                   = wined3d_caps->MaxStreamStride;
    caps->VertexShaderVersion               = wined3d_caps->VertexShaderVersion;
    caps->MaxVertexShaderConst              = wined3d_caps->MaxVertexShaderConst;
    caps->PixelShaderVersion                = wined3d_caps->PixelShaderVersion;
    caps->PixelShader1xMaxValue             = wined3d_caps->PixelShader1xMaxValue;
    caps->DevCaps2                          = wined3d_caps->DevCaps2;
    caps->MaxNpatchTessellationLevel        = wined3d_caps->MaxNpatchTessellationLevel;
    caps->DeclTypes                         = wined3d_caps->DeclTypes;
    caps->NumSimultaneousRTs                = wined3d_caps->NumSimultaneousRTs;
    caps->StretchRectFilterCaps             = wined3d_caps->StretchRectFilterCaps;
    caps->VS20Caps.Caps                     = wined3d_caps->VS20Caps.caps;
    caps->VS20Caps.DynamicFlowControlDepth  = wined3d_caps->VS20Caps.dynamic_flow_control_depth;
    caps->VS20Caps.NumTemps                 = wined3d_caps->VS20Caps.temp_count;
    caps->VS20Caps.StaticFlowControlDepth   = wined3d_caps->VS20Caps.static_flow_control_depth;
    caps->PS20Caps.Caps                     = wined3d_caps->PS20Caps.caps;
    caps->PS20Caps.DynamicFlowControlDepth  = wined3d_caps->PS20Caps.dynamic_flow_control_depth;
    caps->PS20Caps.NumTemps                 = wined3d_caps->PS20Caps.temp_count;
    caps->PS20Caps.StaticFlowControlDepth   = wined3d_caps->PS20Caps.static_flow_control_depth;
    caps->PS20Caps.NumInstructionSlots      = wined3d_caps->PS20Caps.instruction_slot_count;
    caps->VertexTextureFilterCaps           = wined3d_caps->VertexTextureFilterCaps;
    caps->MaxVShaderInstructionsExecuted    = wined3d_caps->MaxVShaderInstructionsExecuted;
    caps->MaxPShaderInstructionsExecuted    = wined3d_caps->MaxPShaderInstructionsExecuted;
    caps->MaxVertexShader30InstructionSlots = wined3d_caps->MaxVertexShader30InstructionSlots;
    caps->MaxPixelShader30InstructionSlots  = wined3d_caps->MaxPixelShader30InstructionSlots;
 
    /* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps. */
    caps->DevCaps2 |= D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES;
 
    /* Filter wined3d caps. */
    caps->TextureFilterCaps &= texture_filter_caps;
    caps->CubeTextureFilterCaps &= texture_filter_caps;
    caps->VolumeTextureFilterCaps &= texture_filter_caps;
 
    caps->DevCaps &=
        D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY |
        D3DDEVCAPS_TLVERTEXVIDEOMEMORY | D3DDEVCAPS_TEXTURESYSTEMMEMORY| D3DDEVCAPS_TEXTUREVIDEOMEMORY   |
        D3DDEVCAPS_DRAWPRIMTLVERTEX    | D3DDEVCAPS_CANRENDERAFTERFLIP | D3DDEVCAPS_TEXTURENONLOCALVIDMEM|
        D3DDEVCAPS_DRAWPRIMITIVES2     | D3DDEVCAPS_SEPARATETEXTUREMEMORIES                              |
        D3DDEVCAPS_DRAWPRIMITIVES2EX   | D3DDEVCAPS_HWTRANSFORMANDLIGHT| D3DDEVCAPS_CANBLTSYSTONONLOCAL  |
        D3DDEVCAPS_HWRASTERIZATION     | D3DDEVCAPS_PUREDEVICE         | D3DDEVCAPS_QUINTICRTPATCHES     |
        D3DDEVCAPS_RTPATCHES           | D3DDEVCAPS_RTPATCHHANDLEZERO  | D3DDEVCAPS_NPATCHES;
 
    caps->ShadeCaps &=
        D3DPSHADECAPS_COLORGOURAUDRGB  | D3DPSHADECAPS_SPECULARGOURAUDRGB |
        D3DPSHADECAPS_ALPHAGOURAUDBLEND | D3DPSHADECAPS_FOGGOURAUD;
 
    caps->RasterCaps &=
        D3DPRASTERCAPS_DITHER          | D3DPRASTERCAPS_ZTEST          | D3DPRASTERCAPS_FOGVERTEX        |
        D3DPRASTERCAPS_FOGTABLE        | D3DPRASTERCAPS_MIPMAPLODBIAS  | D3DPRASTERCAPS_ZBUFFERLESSHSR   |
        D3DPRASTERCAPS_FOGRANGE        | D3DPRASTERCAPS_ANISOTROPY     | D3DPRASTERCAPS_WBUFFER          |
        D3DPRASTERCAPS_WFOG            | D3DPRASTERCAPS_ZFOG           | D3DPRASTERCAPS_COLORPERSPECTIVE |
        D3DPRASTERCAPS_SCISSORTEST     | D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS                              |
        D3DPRASTERCAPS_DEPTHBIAS       | D3DPRASTERCAPS_MULTISAMPLE_TOGGLE;
 
    caps->DevCaps2 &=
        D3DDEVCAPS2_STREAMOFFSET       | D3DDEVCAPS2_DMAPNPATCH        | D3DDEVCAPS2_ADAPTIVETESSRTPATCH |
        D3DDEVCAPS2_ADAPTIVETESSNPATCH | D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES                       |
        D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH| D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
 
    caps->Caps2 &=
        D3DCAPS2_FULLSCREENGAMMA       | D3DCAPS2_CANCALIBRATEGAMMA    | D3DCAPS2_RESERVED               |
        D3DCAPS2_CANMANAGERESOURCE     | D3DCAPS2_DYNAMICTEXTURES      | D3DCAPS2_CANAUTOGENMIPMAP;
 
    caps->VertexProcessingCaps &=
        D3DVTXPCAPS_TEXGEN             | D3DVTXPCAPS_MATERIALSOURCE7   | D3DVTXPCAPS_DIRECTIONALLIGHTS   |
        D3DVTXPCAPS_POSITIONALLIGHTS   | D3DVTXPCAPS_LOCALVIEWER       | D3DVTXPCAPS_TWEENING            |
        D3DVTXPCAPS_TEXGEN_SPHEREMAP   | D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER;
 
    caps->TextureCaps &=
        D3DPTEXTURECAPS_PERSPECTIVE    | D3DPTEXTURECAPS_POW2          | D3DPTEXTURECAPS_ALPHA           |
        D3DPTEXTURECAPS_SQUAREONLY     | D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE                        |
        D3DPTEXTURECAPS_ALPHAPALETTE   | D3DPTEXTURECAPS_NONPOW2CONDITIONAL                              |
        D3DPTEXTURECAPS_PROJECTED      | D3DPTEXTURECAPS_CUBEMAP       | D3DPTEXTURECAPS_VOLUMEMAP       |
        D3DPTEXTURECAPS_MIPMAP         | D3DPTEXTURECAPS_MIPVOLUMEMAP  | D3DPTEXTURECAPS_MIPCUBEMAP      |
        D3DPTEXTURECAPS_CUBEMAP_POW2   | D3DPTEXTURECAPS_VOLUMEMAP_POW2| D3DPTEXTURECAPS_NOPROJECTEDBUMPENV;
 
    caps->MaxVertexShaderConst = min(D3D9_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst);
    caps->NumSimultaneousRTs = min(D3D_MAX_SIMULTANEOUS_RENDERTARGETS, caps->NumSimultaneousRTs);
 
    if (caps->PixelShaderVersion > 3)
    {
        caps->PixelShaderVersion = D3DPS_VERSION(3, 0);
    }
    else
    {
        DWORD major = caps->PixelShaderVersion;
        caps->PixelShaderVersion = D3DPS_VERSION(major, ps_minor_version[major]);
    }
 
    if (caps->VertexShaderVersion > 3)
    {
        caps->VertexShaderVersion = D3DVS_VERSION(3, 0);
    }
    else
    {
        DWORD major = caps->VertexShaderVersion;
        caps->VertexShaderVersion = D3DVS_VERSION(major, vs_minor_version[major]);
    }
 
    /* Get adapter group information */
    output_idx = adapter_ordinal;
    wined3d_output = d3d9->wined3d_outputs[output_idx];
 
    wined3d_mutex_lock();
    hr = wined3d_output_get_desc(wined3d_output, &output_desc);
    wined3d_mutex_unlock();
 
    if (FAILED(hr))
    {
        ERR("Failed to get output desc, hr %#lx.\n", hr);
        return;
    }
 
    caps->MasterAdapterOrdinal = output_idx - output_desc.ordinal;
    caps->AdapterOrdinalInGroup = output_desc.ordinal;
    if (!caps->AdapterOrdinalInGroup)
    {
        wined3d_adapter = wined3d_output_get_adapter(wined3d_output);
        caps->NumberOfAdaptersInGroup = wined3d_adapter_get_output_count(wined3d_adapter);
    }
    else
    {
        caps->NumberOfAdaptersInGroup = 0;
    }
}

Referenced by d3d9_device_GetDeviceCaps(), d3d9_GetDeviceCaps(), and device_init().

d3d9_init()

BOOL d3d9_init	(	struct d3d9 *	d3d9,
		BOOL	extended,
		BOOL	d3d9on12
	)

Definition at line 686 of file directx.c.

{
    DWORD flags = WINED3D_PRESENT_CONVERSION | WINED3D_HANDLE_RESTORE | WINED3D_PIXEL_CENTER_INTEGER
            | WINED3D_SRGB_READ_WRITE_CONTROL | WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR
            | WINED3D_NO_PRIMITIVE_RESTART | WINED3D_LEGACY_CUBEMAP_FILTERING
            | WINED3D_NORMALIZED_DEPTH_BIAS | WINED3D_NO_DRAW_INDIRECT;
    unsigned int adapter_idx, output_idx, adapter_count, output_count = 0;
    struct wined3d_adapter *wined3d_adapter;
 
    if (extended)
        flags |= WINED3D_RESTORE_MODE_ON_ACTIVATE;
 
    d3d9->IDirect3D9Ex_iface.lpVtbl = &d3d9_vtbl;
    d3d9->refcount = 1;
 
    wined3d_mutex_lock();
    d3d9->wined3d = wined3d_create(flags);
    if (!d3d9->wined3d)
    {
        wined3d_mutex_unlock();
        return FALSE;
    }
 
    adapter_count = wined3d_get_adapter_count(d3d9->wined3d);
    for (adapter_idx = 0; adapter_idx < adapter_count; ++adapter_idx)
    {
        wined3d_adapter = wined3d_get_adapter(d3d9->wined3d, adapter_idx);
        output_count += wined3d_adapter_get_output_count(wined3d_adapter);
    }
 
    d3d9->wined3d_outputs = calloc(output_count, sizeof(*d3d9->wined3d_outputs));
    if (!d3d9->wined3d_outputs)
    {
        wined3d_decref(d3d9->wined3d);
        wined3d_mutex_unlock();
        return FALSE;
    }
 
    d3d9->wined3d_output_count = 0;
    for (adapter_idx = 0; adapter_idx < adapter_count; ++adapter_idx)
    {
        wined3d_adapter = wined3d_get_adapter(d3d9->wined3d, adapter_idx);
        output_count = wined3d_adapter_get_output_count(wined3d_adapter);
        for (output_idx = 0; output_idx < output_count; ++output_idx)
        {
            d3d9->wined3d_outputs[d3d9->wined3d_output_count] =
                    wined3d_adapter_get_output(wined3d_adapter, output_idx);
            ++d3d9->wined3d_output_count;
        }
    }
 
    wined3d_mutex_unlock();
    d3d9->extended = extended;
    d3d9->d3d9on12 = d3d9on12;
 
    return TRUE;
}

Referenced by Direct3DCreate9(), Direct3DCreate9Ex(), and Direct3DCreate9On12().

d3d9_resource_cleanup()

void d3d9_resource_cleanup

(

struct d3d9_resource *

resource

)

Definition at line 284 of file d3d9_main.c.

{
    wined3d_private_store_cleanup(&resource->private_store);
}

Referenced by d3d9_indexbuffer_wined3d_object_destroyed(), d3d9_texture_wined3d_object_destroyed(), d3d9_vertexbuffer_wined3d_object_destroyed(), surface_wined3d_object_destroyed(), and volume_wined3d_object_destroyed().

d3d9_resource_free_private_data()

HRESULT d3d9_resource_free_private_data	(	struct d3d9_resource *	resource,
		const GUID *	guid
	)

Definition at line 289 of file d3d9_main.c.

{
    struct wined3d_private_data *entry;
 
    wined3d_mutex_lock();
    entry = wined3d_private_store_get_private_data(&resource->private_store, guid);
    if (!entry)
    {
        wined3d_mutex_unlock();
        return D3DERR_NOTFOUND;
    }
 
    wined3d_private_store_free_private_data(&resource->private_store, entry);
    wined3d_mutex_unlock();
 
    return D3D_OK;
}

Referenced by d3d9_indexbuffer_FreePrivateData(), d3d9_surface_FreePrivateData(), d3d9_texture_2d_FreePrivateData(), d3d9_texture_3d_FreePrivateData(), d3d9_texture_cube_FreePrivateData(), d3d9_vertexbuffer_FreePrivateData(), and d3d9_volume_FreePrivateData().

d3d9_resource_get_private_data()

HRESULT d3d9_resource_get_private_data	(	struct d3d9_resource *	resource,
		const GUID *	guid,
		void *	data,
		DWORD *	data_size
	)

Definition at line 307 of file d3d9_main.c.

{
    const struct wined3d_private_data *stored_data;
    DWORD size_in;
    HRESULT hr;
 
    wined3d_mutex_lock();
    stored_data = wined3d_private_store_get_private_data(&resource->private_store, guid);
    if (!stored_data)
    {
        hr = D3DERR_NOTFOUND;
        goto done;
    }
 
    size_in = *data_size;
    *data_size = stored_data->size;
    if (!data)
    {
        hr = D3D_OK;
        goto done;
    }
    if (size_in < stored_data->size)
    {
        hr = D3DERR_MOREDATA;
        goto done;
    }
 
    if (stored_data->flags & WINED3DSPD_IUNKNOWN)
        IUnknown_AddRef(stored_data->content.object);
    memcpy(data, stored_data->content.data, stored_data->size);
    hr = D3D_OK;
 
done:
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d9_indexbuffer_GetPrivateData(), d3d9_surface_GetPrivateData(), d3d9_texture_2d_GetPrivateData(), d3d9_texture_3d_GetPrivateData(), d3d9_texture_cube_GetPrivateData(), d3d9_vertexbuffer_GetPrivateData(), and d3d9_volume_GetPrivateData().

d3d9_resource_init()

void d3d9_resource_init

(

struct d3d9_resource *

resource

)

Definition at line 345 of file d3d9_main.c.

{
    resource->refcount = 1;
    wined3d_private_store_init(&resource->private_store);
}

Referenced by d3d9_surface_create(), d3d9_texture_init(), indexbuffer_init(), vertexbuffer_init(), and volume_init().

d3d9_resource_set_private_data()

HRESULT d3d9_resource_set_private_data	(	struct d3d9_resource *	resource,
		const GUID *	guid,
		const void *	data,
		DWORD	data_size,
		DWORD	flags
	)

Definition at line 351 of file d3d9_main.c.

{
    HRESULT hr;
 
    wined3d_mutex_lock();
    hr = wined3d_private_store_set_private_data(&resource->private_store, guid, data, data_size, flags);
    wined3d_mutex_unlock();
    return hr;
}

Referenced by d3d9_indexbuffer_SetPrivateData(), d3d9_surface_SetPrivateData(), d3d9_texture_2d_SetPrivateData(), d3d9_texture_3d_SetPrivateData(), d3d9_texture_cube_SetPrivateData(), d3d9_vertexbuffer_SetPrivateData(), and d3d9_volume_SetPrivateData().

d3d9_surface_acquire_rendertarget_view()

struct wined3d_rendertarget_view * d3d9_surface_acquire_rendertarget_view

(

struct d3d9_surface *

surface

)

Definition at line 417 of file surface.c.

{
    HRESULT hr;
 
    /* The surface reference count can be equal to 0 when this function is
     * called. In order to properly manage the render target view reference
     * count, we temporarily increment the surface reference count. */
    d3d9_surface_AddRef(&surface->IDirect3DSurface9_iface);
 
    if (surface->wined3d_rtv)
        return surface->wined3d_rtv;
 
    if (FAILED(hr = wined3d_rendertarget_view_create_from_sub_resource(surface->wined3d_texture,
            surface->sub_resource_idx, surface, &d3d9_view_wined3d_parent_ops, &surface->wined3d_rtv)))
    {
        ERR("Failed to create rendertarget view, hr %#lx.\n", hr);
        d3d9_surface_Release(&surface->IDirect3DSurface9_iface);
        return NULL;
    }
 
    if (surface->texture)
        list_add_head(&surface->texture->rtv_list, &surface->rtv_entry);
 
    return surface->wined3d_rtv;
}

Referenced by d3d9_device_ColorFill(), d3d9_device_SetDepthStencilSurface(), and d3d9_device_SetRenderTarget().

d3d9_surface_create()

struct d3d9_surface * d3d9_surface_create	(	struct wined3d_texture *	wined3d_texture,
		unsigned int	sub_resource_idx,
		IUnknown *	container
	)

Definition at line 356 of file surface.c.

{
    IDirect3DBaseTexture9 *texture;
    struct d3d9_surface *surface;
 
    if (!(surface = calloc(1, sizeof(*surface))))
        return NULL;
 
    surface->IDirect3DSurface9_iface.lpVtbl = &d3d9_surface_vtbl;
    d3d9_resource_init(&surface->resource);
    surface->resource.refcount = 0;
    list_init(&surface->rtv_entry);
    surface->container = container;
    surface->wined3d_texture = wined3d_texture;
    surface->sub_resource_idx = sub_resource_idx;
    surface->swapchain = wined3d_texture_get_swapchain(wined3d_texture);
 
    if (surface->container && SUCCEEDED(IUnknown_QueryInterface(surface->container,
            &IID_IDirect3DBaseTexture9, (void **)&texture)))
    {
        surface->texture = unsafe_impl_from_IDirect3DBaseTexture9(texture);
        IDirect3DBaseTexture9_Release(texture);
    }
 
    wined3d_texture_set_sub_resource_parent(wined3d_texture, sub_resource_idx,
            surface, &d3d9_surface_wined3d_parent_ops);
 
    TRACE("Created surface %p.\n", surface);
    return surface;
}

Referenced by d3d9_device_create_surface(), d3d9_device_CreateCubeTexture(), d3d9_device_CreateTexture(), d3d9_device_reset(), and d3d9_swapchain_create().

d3d9_surface_get_device()

struct d3d9_device * d3d9_surface_get_device

(

const struct d3d9_surface *

surface

)

Definition at line 410 of file surface.c.

{
    IDirect3DDevice9Ex *device;
    device = surface->texture ? &surface->texture->parent_device->IDirect3DDevice9Ex_iface : surface->parent_device;
    return impl_from_IDirect3DDevice9Ex(device);
}

Referenced by d3d9_device_SetRenderTarget().

d3d9_surface_release_rendertarget_view()

void d3d9_surface_release_rendertarget_view	(	struct d3d9_surface *	surface,
		struct wined3d_rendertarget_view *	rtv
	)

Definition at line 443 of file surface.c.

{
    if (rtv)
        d3d9_surface_Release(&surface->IDirect3DSurface9_iface);
}

Referenced by d3d9_device_ColorFill(), d3d9_device_SetDepthStencilSurface(), and d3d9_device_SetRenderTarget().

d3d9_swapchain_create()

HRESULT d3d9_swapchain_create	(	struct d3d9_device *	device,
		struct wined3d_swapchain_desc *	desc,
		unsigned int	swap_interval,
		struct d3d9_swapchain **	swapchain
	)

Definition at line 399 of file swapchain.c.

{
    struct wined3d_rendertarget_view *wined3d_dsv;
    struct d3d9_swapchain *object;
    struct d3d9_surface *surface;
    unsigned int i;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = swapchain_init(object, device, desc, swap_interval)))
    {
        WARN("Failed to initialize swapchain, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    for (i = 0; i < desc->backbuffer_count; ++i)
    {
        if (!(surface = d3d9_surface_create(wined3d_swapchain_get_back_buffer(object->wined3d_swapchain, i), 0,
                (IUnknown *)&object->IDirect3DSwapChain9Ex_iface)))
        {
            IDirect3DSwapChain9Ex_Release(&object->IDirect3DSwapChain9Ex_iface);
            return E_OUTOFMEMORY;
        }
        surface->parent_device = &device->IDirect3DDevice9Ex_iface;
    }
 
    if ((desc->flags & WINED3D_SWAPCHAIN_IMPLICIT)
            && (wined3d_dsv = wined3d_device_context_get_depth_stencil_view(device->immediate_context)))
    {
        struct wined3d_resource *resource = wined3d_rendertarget_view_get_resource(wined3d_dsv);
 
        if (!(surface = d3d9_surface_create(wined3d_texture_from_resource(resource), 0,
                (IUnknown *)&device->IDirect3DDevice9Ex_iface)))
        {
            IDirect3DSwapChain9Ex_Release(&object->IDirect3DSwapChain9Ex_iface);
            return E_OUTOFMEMORY;
        }
        surface->parent_device = &device->IDirect3DDevice9Ex_iface;
    }
 
    TRACE("Created swapchain %p.\n", object);
    *swapchain = object;
 
    return D3D_OK;
}

Referenced by d3d9_device_CreateAdditionalSwapChain(), and device_init().

d3d9_texture_2d_init()

HRESULT d3d9_texture_2d_init	(	struct d3d9_texture *	texture,
		struct d3d9_device *	device,
		unsigned int	width,
		unsigned int	height,
		unsigned int	level_count,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 1356 of file texture.c.

{
    struct wined3d_resource_desc desc;
 
    desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
    desc.format = wined3dformat_from_d3dformat(format);
    desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    desc.multisample_quality = 0;
    desc.usage = wined3d_usage_from_d3d(pool, usage);
    desc.bind_flags = wined3d_bind_flags_from_d3d9_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
    desc.access = wined3daccess_from_d3dpool(pool, usage);
    desc.width = width;
    desc.height = height;
    desc.depth = 1;
    desc.size = 0;
 
    if (!device->d3d_parent->extended)
        desc.usage |= WINED3DUSAGE_VIDMEM_ACCOUNTING;
 
    texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl;
    return d3d9_texture_init(texture, device, &desc, pool, usage, 1, level_count);
}

Referenced by d3d9_device_CreateTexture().

d3d9_texture_3d_init()

HRESULT d3d9_texture_3d_init	(	struct d3d9_texture *	texture,
		struct d3d9_device *	device,
		unsigned int	width,
		unsigned int	height,
		unsigned int	depth,
		unsigned int	level_count,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 1404 of file texture.c.

{
    struct wined3d_resource_desc desc;
 
    /* In d3d9, 3D textures can't be used as rendertarget or depth/stencil buffer. */
    if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
        return D3DERR_INVALIDCALL;
 
    desc.resource_type = WINED3D_RTYPE_TEXTURE_3D;
    desc.format = wined3dformat_from_d3dformat(format);
    desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    desc.multisample_quality = 0;
    desc.usage = wined3d_usage_from_d3d(pool, usage);
    desc.bind_flags = wined3d_bind_flags_from_d3d9_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
    desc.access = wined3daccess_from_d3dpool(pool, usage);
    desc.width = width;
    desc.height = height;
    desc.depth = depth;
    desc.size = 0;
 
    if (!device->d3d_parent->extended)
        desc.usage |= WINED3DUSAGE_VIDMEM_ACCOUNTING;
 
    texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl;
    return d3d9_texture_init(texture, device, &desc, pool, usage, 1, level_count);
}

Referenced by d3d9_device_CreateVolumeTexture().

d3d9_texture_cube_init()

HRESULT d3d9_texture_cube_init	(	struct d3d9_texture *	texture,
		struct d3d9_device *	device,
		unsigned int	edge_length,
		unsigned int	level_count,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 1380 of file texture.c.

{
    struct wined3d_resource_desc desc;
 
    desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
    desc.format = wined3dformat_from_d3dformat(format);
    desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    desc.multisample_quality = 0;
    desc.usage = wined3d_usage_from_d3d(pool, usage) | WINED3DUSAGE_LEGACY_CUBEMAP;
    desc.bind_flags = wined3d_bind_flags_from_d3d9_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
    desc.access = wined3daccess_from_d3dpool(pool, usage);
    desc.width = edge_length;
    desc.height = edge_length;
    desc.depth = 1;
    desc.size = 0;
 
    if (!device->d3d_parent->extended)
        desc.usage |= WINED3DUSAGE_VIDMEM_ACCOUNTING;
 
    texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl;
    return d3d9_texture_init(texture, device, &desc, pool, usage, 6, level_count);
}

Referenced by d3d9_device_CreateCubeTexture().

d3d9_texture_flag_auto_gen_mipmap()

void d3d9_texture_flag_auto_gen_mipmap

(

struct d3d9_texture *

texture

)

Definition at line 106 of file texture.c.

{
    if (texture->usage & D3DUSAGE_AUTOGENMIPMAP)
        texture->flags |= D3D9_TEXTURE_MIPMAP_DIRTY;
}

Referenced by d3d9_device_ColorFill(), d3d9_device_StretchRect(), d3d9_device_UpdateSurface(), d3d9_device_UpdateTexture(), d3d9_rts_flag_auto_gen_mipmap(), d3d9_surface_ReleaseDC(), and d3d9_surface_UnlockRect().

d3d9_texture_gen_auto_mipmap()

void d3d9_texture_gen_auto_mipmap

(

struct d3d9_texture *

texture

)

Definition at line 94 of file texture.c.

{
    if (!(texture->flags & D3D9_TEXTURE_MIPMAP_DIRTY))
        return;
    if (texture->draw_texture)
        wined3d_device_update_texture(texture->parent_device->wined3d_device,
                texture->wined3d_texture, texture->draw_texture);
    wined3d_device_context_generate_mipmaps(texture->parent_device->immediate_context,
            wined3d_texture_acquire_identity_srv(d3d9_texture_get_draw_texture(texture)));
    texture->flags &= ~D3D9_TEXTURE_MIPMAP_DIRTY;
}

Referenced by d3d9_generate_auto_mipmaps(), d3d9_texture_2d_GenerateMipSubLevels(), and d3d9_texture_cube_GenerateMipSubLevels().

d3d9_texture_get_draw_texture()

static struct wined3d_texture * d3d9_texture_get_draw_texture ( struct d3d9_texture *  texture )

inlinestatic

Definition at line 238 of file d3d9_private.h.

{
    return texture->draw_texture ? texture->draw_texture : texture->wined3d_texture;
}

Referenced by d3d9_device_SetTexture(), d3d9_texture_2d_GetLOD(), d3d9_texture_2d_GetPriority(), d3d9_texture_2d_SetLOD(), d3d9_texture_2d_SetPriority(), d3d9_texture_3d_GetLOD(), d3d9_texture_3d_GetPriority(), d3d9_texture_3d_SetLOD(), d3d9_texture_3d_SetPriority(), d3d9_texture_cube_GetLOD(), d3d9_texture_cube_GetPriority(), d3d9_texture_cube_SetLOD(), d3d9_texture_cube_SetPriority(), d3d9_texture_decref(), d3d9_texture_gen_auto_mipmap(), d3d9_texture_incref(), and d3d9_texture_preload().

d3d9_vertex_declaration_create()

HRESULT d3d9_vertex_declaration_create	(	struct d3d9_device *	device,
		const D3DVERTEXELEMENT9 *	elements,
		struct d3d9_vertex_declaration **	declaration
	)

Definition at line 416 of file vertexdeclaration.c.

{
    struct d3d9_vertex_declaration *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    hr = vertexdeclaration_init(object, device, elements);
    if (FAILED(hr))
    {
        WARN("Failed to initialize vertex declaration, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created vertex declaration %p.\n", object);
    *declaration = object;
 
    return D3D_OK;
}

Referenced by d3d9_device_CreateVertexDeclaration(), and device_get_fvf_declaration().

d3dformat_from_wined3dformat()

D3DFORMAT d3dformat_from_wined3dformat

(

enum wined3d_format_id

format

)

Definition at line 33 of file device.c.

{
    BYTE *c = (BYTE *)&format;
 
    /* Don't translate FOURCC formats */
    if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3]))
            return (D3DFORMAT)format;
 
    switch(format)
    {
        case WINED3DFMT_UNKNOWN: return D3DFMT_UNKNOWN;
        case WINED3DFMT_B8G8R8_UNORM: return D3DFMT_R8G8B8;
        case WINED3DFMT_B8G8R8A8_UNORM: return D3DFMT_A8R8G8B8;
        case WINED3DFMT_B8G8R8X8_UNORM: return D3DFMT_X8R8G8B8;
        case WINED3DFMT_B5G6R5_UNORM: return D3DFMT_R5G6B5;
        case WINED3DFMT_B5G5R5X1_UNORM: return D3DFMT_X1R5G5B5;
        case WINED3DFMT_B5G5R5A1_UNORM: return D3DFMT_A1R5G5B5;
        case WINED3DFMT_B4G4R4A4_UNORM: return D3DFMT_A4R4G4B4;
        case WINED3DFMT_B2G3R3_UNORM: return D3DFMT_R3G3B2;
        case WINED3DFMT_A8_UNORM: return D3DFMT_A8;
        case WINED3DFMT_B2G3R3A8_UNORM: return D3DFMT_A8R3G3B2;
        case WINED3DFMT_B4G4R4X4_UNORM: return D3DFMT_X4R4G4B4;
        case WINED3DFMT_R10G10B10A2_UNORM: return D3DFMT_A2B10G10R10;
        case WINED3DFMT_R16G16_UNORM: return D3DFMT_G16R16;
        case WINED3DFMT_P8_UINT_A8_UNORM: return D3DFMT_A8P8;
        case WINED3DFMT_P8_UINT: return D3DFMT_P8;
        case WINED3DFMT_L8_UNORM: return D3DFMT_L8;
        case WINED3DFMT_L8A8_UNORM: return D3DFMT_A8L8;
        case WINED3DFMT_L4A4_UNORM: return D3DFMT_A4L4;
        case WINED3DFMT_R8G8_SNORM: return D3DFMT_V8U8;
        case WINED3DFMT_R5G5_SNORM_L6_UNORM: return D3DFMT_L6V5U5;
        case WINED3DFMT_R8G8_SNORM_L8X8_UNORM: return D3DFMT_X8L8V8U8;
        case WINED3DFMT_R8G8B8A8_SNORM: return D3DFMT_Q8W8V8U8;
        case WINED3DFMT_R16G16_SNORM: return D3DFMT_V16U16;
        case WINED3DFMT_R10G11B11_SNORM: return D3DFMT_W11V11U10;
        case WINED3DFMT_R10G10B10_SNORM_A2_UNORM: return D3DFMT_A2W10V10U10;
        case WINED3DFMT_D16_LOCKABLE: return D3DFMT_D16_LOCKABLE;
        case WINED3DFMT_D32_UNORM: return D3DFMT_D32;
        case WINED3DFMT_S1_UINT_D15_UNORM: return D3DFMT_D15S1;
        case WINED3DFMT_D24_UNORM_S8_UINT: return D3DFMT_D24S8;
        case WINED3DFMT_X8D24_UNORM: return D3DFMT_D24X8;
        case WINED3DFMT_S4X4_UINT_D24_UNORM: return D3DFMT_D24X4S4;
        case WINED3DFMT_D16_UNORM: return D3DFMT_D16;
        case WINED3DFMT_R16_UINT: return D3DFMT_INDEX16;
        case WINED3DFMT_R32_UINT: return D3DFMT_INDEX32;
        default:
            FIXME("Unhandled wined3d format %#x.\n", format);
            return D3DFMT_UNKNOWN;
    }
}

Referenced by d3d8_device_GetDisplayMode(), d3d9_device_GetDisplayMode(), d3d9_device_GetDisplayModeEx(), d3d9_device_reset(), d3d9_device_UpdateSurface(), and present_parameters_from_wined3d_swapchain_desc().

d3dmultisample_type_from_wined3d()

static D3DMULTISAMPLE_TYPE d3dmultisample_type_from_wined3d ( enum wined3d_multisample_type  type )

inlinestatic

Definition at line 344 of file d3d9_private.h.

{
    return (D3DMULTISAMPLE_TYPE)type;
}

d3dpool_from_wined3daccess()

static D3DPOOL d3dpool_from_wined3daccess ( unsigned int  access, unsigned int  usage  )

inlinestatic

Definition at line 325 of file d3d9_private.h.

{
    if (usage & WINED3DUSAGE_MANAGED)
        return D3DPOOL_MANAGED;
 
    switch (access & (WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU))
    {
        default:
        case WINED3D_RESOURCE_ACCESS_GPU:
            return D3DPOOL_DEFAULT;
        case WINED3D_RESOURCE_ACCESS_CPU:
            if (usage & WINED3DUSAGE_SCRATCH)
                return D3DPOOL_SCRATCH;
            return D3DPOOL_SYSTEMMEM;
        case WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU:
            return D3DPOOL_MANAGED;
    }
}

d3dscanlineordering_from_wined3d()

static D3DSCANLINEORDERING d3dscanlineordering_from_wined3d ( enum wined3d_scanline_ordering  ordering )

inlinestatic

Definition at line 349 of file d3d9_private.h.

{
    return (D3DSCANLINEORDERING)ordering;
}

Referenced by d3d9_device_GetDisplayModeEx(), d3d9_EnumAdapterModesEx(), d3d9_GetAdapterDisplayModeEx(), and d3d9_swapchain_GetDisplayModeEx().

d3dusage_from_wined3dusage()

static DWORD d3dusage_from_wined3dusage ( unsigned int  wined3d_usage, unsigned int  bind_flags  )

inlinestatic

Definition at line 315 of file d3d9_private.h.

{
    DWORD usage = wined3d_usage & WINED3DUSAGE_MASK;
    if (bind_flags & WINED3D_BIND_RENDER_TARGET)
        usage |= D3DUSAGE_RENDERTARGET;
    if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
        usage |= D3DUSAGE_DEPTHSTENCIL;
    return usage;
}

device_init()

HRESULT device_init	(	struct d3d9_device *	device,
		struct d3d9 *	parent,
		struct wined3d *	wined3d,
		UINT	adapter,
		D3DDEVTYPE	device_type,
		HWND	focus_window,
		DWORD	flags,
		D3DPRESENT_PARAMETERS *	parameters,
		D3DDISPLAYMODEEX *	mode
	)

Definition at line 4714 of file device.c.

{
    struct wined3d_swapchain_desc *swapchain_desc;
    struct wined3d_adapter *wined3d_adapter;
    struct d3d9_swapchain *d3d_swapchain;
    struct wined3d_caps wined3d_caps;
    unsigned int output_idx;
    unsigned i, count = 1;
    D3DCAPS9 caps;
    HRESULT hr;
 
    static const enum wined3d_feature_level feature_levels[] =
    {
        WINED3D_FEATURE_LEVEL_9_3,
        WINED3D_FEATURE_LEVEL_9_2,
        WINED3D_FEATURE_LEVEL_9_1,
        WINED3D_FEATURE_LEVEL_8,
        WINED3D_FEATURE_LEVEL_7,
        WINED3D_FEATURE_LEVEL_6,
        WINED3D_FEATURE_LEVEL_5,
    };
 
    output_idx = adapter;
    if (output_idx >= parent->wined3d_output_count)
        return D3DERR_INVALIDCALL;
 
    if (mode)
        FIXME("Ignoring display mode.\n");
 
    device->IDirect3DDevice9Ex_iface.lpVtbl = &d3d9_device_vtbl;
    device->IDirect3DDevice9On12_iface.lpVtbl = &d3d9on12_vtbl;
    device->device_parent.ops = &d3d9_wined3d_device_parent_ops;
    device->adapter_ordinal = adapter;
    device->refcount = 1;
 
    if (!(flags & D3DCREATE_FPU_PRESERVE)) setup_fpu();
 
    wined3d_mutex_lock();
    wined3d_adapter = wined3d_output_get_adapter(parent->wined3d_outputs[output_idx]);
    if (FAILED(hr = wined3d_device_create(wined3d, wined3d_adapter, wined3d_device_type_from_d3d(device_type),
            focus_window, flags, 4, feature_levels, ARRAY_SIZE(feature_levels),
            &device->device_parent, &device->wined3d_device)))
    {
        WARN("Failed to create wined3d device, hr %#lx.\n", hr);
        wined3d_mutex_unlock();
        return hr;
    }
 
    device->immediate_context = wined3d_device_get_immediate_context(device->wined3d_device);
    wined3d_get_device_caps(wined3d_adapter, wined3d_device_type_from_d3d(device_type), &wined3d_caps);
    d3d9_caps_from_wined3dcaps(parent, adapter, &caps, &wined3d_caps);
    device->max_user_clip_planes = caps.MaxUserClipPlanes;
    device->vs_uniform_count = caps.MaxVertexShaderConst;
    if (flags & D3DCREATE_ADAPTERGROUP_DEVICE)
        count = caps.NumberOfAdaptersInGroup;
 
    if (FAILED(hr = wined3d_stateblock_create(device->wined3d_device, NULL, WINED3D_SBT_PRIMARY, &device->state)))
    {
        ERR("Failed to create the primary stateblock, hr %#lx.\n", hr);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        return hr;
    }
    device->stateblock_state = wined3d_stateblock_get_state(device->state);
    device->update_state = device->state;
 
    wined3d_streaming_buffer_init(&device->vertex_buffer, WINED3D_BIND_VERTEX_BUFFER);
    wined3d_streaming_buffer_init(&device->index_buffer, WINED3D_BIND_INDEX_BUFFER);
 
    if (flags & D3DCREATE_MULTITHREADED)
        wined3d_device_set_multithreaded(device->wined3d_device);
 
    if (!parameters->Windowed)
    {
        if (!focus_window)
            focus_window = parameters->hDeviceWindow;
        if (FAILED(hr = wined3d_device_acquire_focus_window(device->wined3d_device, focus_window)))
        {
            ERR("Failed to acquire focus window, hr %#lx.\n", hr);
            wined3d_device_decref(device->wined3d_device);
            wined3d_mutex_unlock();
            return hr;
        }
    }
 
    if (!(swapchain_desc = malloc(sizeof(*swapchain_desc) * count)))
    {
        ERR("Failed to allocate wined3d parameters.\n");
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        return E_OUTOFMEMORY;
    }
 
    for (i = 0; i < count; ++i)
    {
        if (!wined3d_swapchain_desc_from_d3d9(&swapchain_desc[i],
                parent->wined3d_outputs[output_idx + i], &parameters[i], parent->extended))
        {
            wined3d_device_release_focus_window(device->wined3d_device);
            wined3d_device_decref(device->wined3d_device);
            free(swapchain_desc);
            wined3d_mutex_unlock();
            return D3DERR_INVALIDCALL;
        }
        swapchain_desc[i].flags |= WINED3D_SWAPCHAIN_IMPLICIT;
        if (flags & D3DCREATE_NOWINDOWCHANGES)
            swapchain_desc[i].flags |= WINED3D_SWAPCHAIN_NO_WINDOW_CHANGES;
    }
 
    if (FAILED(hr = d3d9_swapchain_create(device, swapchain_desc,
            wined3dswapinterval_from_d3d(parameters->PresentationInterval), &d3d_swapchain)))
    {
        WARN("Failed to create swapchain, hr %#lx.\n", hr);
        wined3d_device_release_focus_window(device->wined3d_device);
        free(swapchain_desc);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        return hr;
    }
 
    wined3d_swapchain_incref(d3d_swapchain->wined3d_swapchain);
    IDirect3DSwapChain9Ex_Release(&d3d_swapchain->IDirect3DSwapChain9Ex_iface);
 
    wined3d_stateblock_set_render_state(device->state, WINED3D_RS_ZENABLE,
            !!swapchain_desc->enable_auto_depth_stencil);
    device_reset_viewport_state(device);
 
    if (FAILED(hr = d3d9_device_get_swapchains(device)))
    {
        wined3d_swapchain_decref(d3d_swapchain->wined3d_swapchain);
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
        free(swapchain_desc);
        wined3d_mutex_unlock();
        return E_OUTOFMEMORY;
    }
 
    for (i = 0; i < count; ++i)
    {
        present_parameters_from_wined3d_swapchain_desc(&parameters[i],
                &swapchain_desc[i], parameters[i].PresentationInterval);
    }
 
    wined3d_mutex_unlock();
 
    free(swapchain_desc);
 
    /* We could also simply ignore the initial rendertarget since it's known
     * not to be a texture (we currently use these only for automatic mipmap
     * generation). */
    wined3d_mutex_lock();
    device->render_targets[0] = wined3d_rendertarget_view_get_sub_resource_parent(
            wined3d_device_context_get_rendertarget_view(device->immediate_context, 0));
    wined3d_mutex_unlock();
 
    IDirect3D9Ex_AddRef(&parent->IDirect3D9Ex_iface);
    device->d3d_parent = parent;
 
    return D3D_OK;
}

impl_from_IDirect3DDevice9Ex()

static struct d3d9_device * impl_from_IDirect3DDevice9Ex ( IDirect3DDevice9Ex *  iface )

inlinestatic

Definition at line 310 of file d3d9_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d9_device, IDirect3DDevice9Ex_iface);
}

Referenced by d3d9_device_AddRef(), d3d9_device_BeginScene(), d3d9_device_BeginStateBlock(), d3d9_device_CheckDeviceState(), d3d9_device_Clear(), d3d9_device_ColorFill(), d3d9_device_CreateAdditionalSwapChain(), d3d9_device_CreateCubeTexture(), d3d9_device_CreateDepthStencilSurface(), d3d9_device_CreateDepthStencilSurfaceEx(), d3d9_device_CreateIndexBuffer(), d3d9_device_CreateOffscreenPlainSurface(), d3d9_device_CreatePixelShader(), d3d9_device_CreateQuery(), d3d9_device_CreateRenderTarget(), d3d9_device_CreateRenderTargetEx(), d3d9_device_CreateStateBlock(), d3d9_device_CreateTexture(), d3d9_device_CreateVertexBuffer(), d3d9_device_CreateVertexDeclaration(), d3d9_device_CreateVertexShader(), d3d9_device_CreateVolumeTexture(), d3d9_device_DrawIndexedPrimitive(), d3d9_device_DrawIndexedPrimitiveUP(), d3d9_device_DrawPrimitive(), d3d9_device_DrawPrimitiveUP(), d3d9_device_EndScene(), d3d9_device_EndStateBlock(), d3d9_device_EvictManagedResources(), d3d9_device_GetAvailableTextureMem(), d3d9_device_GetBackBuffer(), d3d9_device_GetClipPlane(), d3d9_device_GetClipStatus(), d3d9_device_GetCreationParameters(), d3d9_device_GetDepthStencilSurface(), d3d9_device_GetDeviceCaps(), d3d9_device_GetDirect3D(), d3d9_device_GetDisplayMode(), d3d9_device_GetDisplayModeEx(), d3d9_device_GetFrontBufferData(), d3d9_device_GetFVF(), d3d9_device_GetGammaRamp(), d3d9_device_GetIndices(), d3d9_device_GetLight(), d3d9_device_GetLightEnable(), d3d9_device_GetMaterial(), d3d9_device_GetMaximumFrameLatency(), d3d9_device_GetNPatchMode(), d3d9_device_GetNumberOfSwapChains(), d3d9_device_GetPixelShader(), d3d9_device_GetPixelShaderConstantB(), d3d9_device_GetPixelShaderConstantF(), d3d9_device_GetPixelShaderConstantI(), d3d9_device_GetRasterStatus(), d3d9_device_GetRenderState(), d3d9_device_GetRenderTarget(), d3d9_device_GetRenderTargetData(), d3d9_device_GetSamplerState(), d3d9_device_GetScissorRect(), d3d9_device_GetSoftwareVertexProcessing(), d3d9_device_GetStreamSource(), d3d9_device_GetStreamSourceFreq(), d3d9_device_GetSwapChain(), d3d9_device_GetTexture(), d3d9_device_GetTextureStageState(), d3d9_device_GetTransform(), d3d9_device_GetVertexDeclaration(), d3d9_device_GetVertexShader(), d3d9_device_GetVertexShaderConstantB(), d3d9_device_GetVertexShaderConstantF(), d3d9_device_GetVertexShaderConstantI(), d3d9_device_GetViewport(), d3d9_device_LightEnable(), d3d9_device_MultiplyTransform(), d3d9_device_Present(), d3d9_device_PresentEx(), d3d9_device_ProcessVertices(), d3d9_device_QueryInterface(), d3d9_device_Release(), d3d9_device_Reset(), d3d9_device_ResetEx(), d3d9_device_SetClipPlane(), d3d9_device_SetClipStatus(), d3d9_device_SetCursorPosition(), d3d9_device_SetCursorProperties(), d3d9_device_SetDepthStencilSurface(), d3d9_device_SetDialogBoxMode(), d3d9_device_SetFVF(), d3d9_device_SetGammaRamp(), d3d9_device_SetIndices(), d3d9_device_SetLight(), d3d9_device_SetMaterial(), d3d9_device_SetMaximumFrameLatency(), d3d9_device_SetNPatchMode(), d3d9_device_SetPixelShader(), d3d9_device_SetPixelShaderConstantB(), d3d9_device_SetPixelShaderConstantF(), d3d9_device_SetPixelShaderConstantI(), d3d9_device_SetRenderState(), d3d9_device_SetRenderTarget(), d3d9_device_SetSamplerState(), d3d9_device_SetScissorRect(), d3d9_device_SetSoftwareVertexProcessing(), d3d9_device_SetStreamSource(), d3d9_device_SetStreamSourceFreq(), d3d9_device_SetTexture(), d3d9_device_SetTextureStageState(), d3d9_device_SetTransform(), d3d9_device_SetVertexDeclaration(), d3d9_device_SetVertexShader(), d3d9_device_SetVertexShaderConstantB(), d3d9_device_SetVertexShaderConstantF(), d3d9_device_SetVertexShaderConstantI(), d3d9_device_SetViewport(), d3d9_device_ShowCursor(), d3d9_device_StretchRect(), d3d9_device_TestCooperativeLevel(), d3d9_device_UpdateSurface(), d3d9_device_UpdateTexture(), d3d9_device_ValidateDevice(), d3d9_stateblock_Apply(), d3d9_stateblock_Capture(), d3d9_surface_get_device(), d3d9_swapchain_Present(), and d3d9_swapchain_QueryInterface().

indexbuffer_init()

HRESULT indexbuffer_init	(	struct d3d9_indexbuffer *	buffer,
		struct d3d9_device *	device,
		UINT	size,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 597 of file buffer.c.

{
    struct wined3d_buffer_desc desc;
    HRESULT hr;
 
    if (pool == D3DPOOL_SCRATCH)
        return D3DERR_INVALIDCALL;
 
    if (pool == D3DPOOL_MANAGED && device->d3d_parent->extended)
    {
        WARN("Managed resources are not supported by d3d9ex devices.\n");
        return D3DERR_INVALIDCALL;
    }
 
    /* In d3d9, buffers can't be used as rendertarget or depth/stencil buffer. */
    if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
        return D3DERR_INVALIDCALL;
 
    desc.byte_width = size;
    desc.usage = wined3d_usage_from_d3d(pool, usage) | WINED3DUSAGE_STATICDECL;
    desc.bind_flags = 0;
    desc.access = wined3daccess_from_d3dpool(pool, usage) | map_access_from_usage(usage);
    /* Buffers are always readable. */
    if (pool != D3DPOOL_DEFAULT)
        desc.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    desc.misc_flags = 0;
    desc.structure_byte_stride = 0;
 
    if (!device->d3d_parent->extended)
        desc.usage |= WINED3DUSAGE_VIDMEM_ACCOUNTING;
 
    if (desc.access & WINED3D_RESOURCE_ACCESS_GPU)
        desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
 
    buffer->IDirect3DIndexBuffer9_iface.lpVtbl = &d3d9_indexbuffer_vtbl;
    buffer->format = wined3dformat_from_d3dformat(format);
    buffer->usage = usage;
    buffer->sysmem = !(desc.access & WINED3D_RESOURCE_ACCESS_GPU);
    d3d9_resource_init(&buffer->resource);
 
    wined3d_mutex_lock();
    hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
            &d3d9_indexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d buffer, hr %#lx.\n", hr);
        return hr;
    }
 
    buffer->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(buffer->parent_device);
 
    return D3D_OK;
}

is_gdi_compat_wined3dformat()

BOOL is_gdi_compat_wined3dformat

(

enum wined3d_format_id

format

)

Definition at line 1770 of file device.c.

{
    switch (format)
    {
        case WINED3DFMT_B8G8R8A8_UNORM:
        case WINED3DFMT_B8G8R8X8_UNORM:
        case WINED3DFMT_B5G6R5_UNORM:
        case WINED3DFMT_B5G5R5X1_UNORM:
        case WINED3DFMT_B5G5R5A1_UNORM:
        case WINED3DFMT_B8G8R8_UNORM:
            return TRUE;
        default:
            return FALSE;
    }
}

Referenced by d3d9_device_create_surface(), d3d9_texture_init(), and wined3d_swapchain_desc_from_d3d9().

map_access_from_usage()

static unsigned int map_access_from_usage ( unsigned int  usage )

inlinestatic

Definition at line 354 of file d3d9_private.h.

{
    if (usage & D3DUSAGE_WRITEONLY)
        return WINED3D_RESOURCE_ACCESS_MAP_W;
    return WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
}

Referenced by wined3daccess_from_d3dpool().

pixelshader_init()

HRESULT pixelshader_init	(	struct d3d9_pixelshader *	shader,
		struct d3d9_device *	device,
		const DWORD *	byte_code
	)

Definition at line 273 of file shader.c.

{
    struct wined3d_shader_desc desc;
    HRESULT hr;
 
    shader->refcount = 1;
    shader->IDirect3DPixelShader9_iface.lpVtbl = &d3d9_pixelshader_vtbl;
 
    desc.byte_code = byte_code;
    desc.byte_code_size = ~(size_t)0;
 
    wined3d_mutex_lock();
    hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader,
            &d3d9_pixelshader_wined3d_parent_ops, &shader->wined3d_shader);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to created wined3d pixel shader, hr %#lx.\n", hr);
        return hr;
    }
 
    shader->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(shader->parent_device);
 
    return D3D_OK;
}

Referenced by d3d9_device_CreatePixelShader().

present_parameters_from_wined3d_swapchain_desc()

void present_parameters_from_wined3d_swapchain_desc	(	D3DPRESENT_PARAMETERS *	present_parameters,
		const struct wined3d_swapchain_desc *	swapchain_desc,
		DWORD	presentation_interval
	)

Definition at line 242 of file device.c.

{
    present_parameters->BackBufferWidth = swapchain_desc->backbuffer_width;
    present_parameters->BackBufferHeight = swapchain_desc->backbuffer_height;
    present_parameters->BackBufferFormat = d3dformat_from_wined3dformat(swapchain_desc->backbuffer_format);
    present_parameters->BackBufferCount = swapchain_desc->backbuffer_count;
    present_parameters->MultiSampleType = d3dmultisample_type_from_wined3d(swapchain_desc->multisample_type);
    present_parameters->MultiSampleQuality = swapchain_desc->multisample_quality;
    present_parameters->SwapEffect = d3dswapeffect_from_wined3dswapeffect(swapchain_desc->swap_effect);
    present_parameters->hDeviceWindow = swapchain_desc->device_window;
    present_parameters->Windowed = swapchain_desc->windowed;
    present_parameters->EnableAutoDepthStencil = swapchain_desc->enable_auto_depth_stencil;
    present_parameters->AutoDepthStencilFormat
            = d3dformat_from_wined3dformat(swapchain_desc->auto_depth_stencil_format);
    present_parameters->Flags = swapchain_desc->flags & D3DPRESENTFLAGS_MASK;
    present_parameters->FullScreen_RefreshRateInHz = swapchain_desc->refresh_rate;
    present_parameters->PresentationInterval = presentation_interval;
}

query_init()

HRESULT query_init	(	struct d3d9_query *	query,
		struct d3d9_device *	device,
		D3DQUERYTYPE	type
	)

Definition at line 182 of file query.c.

{
    HRESULT hr;
 
    if (type > D3DQUERYTYPE_MEMORYPRESSURE)
    {
        if (type == 0x16)
            FIXME("Undocumented query %#x created.\n", type);
        else
            WARN("Invalid query type %#x.\n", type);
 
        return D3DERR_NOTAVAILABLE;
    }
 
    query->IDirect3DQuery9_iface.lpVtbl = &d3d9_query_vtbl;
    query->refcount = 1;
 
    wined3d_mutex_lock();
    if (FAILED(hr = wined3d_query_create(device->wined3d_device, wined3d_query_type_from_d3d(type),
            query, &d3d9_null_wined3d_parent_ops, &query->wined3d_query)))
    {
        wined3d_mutex_unlock();
        WARN("Failed to create wined3d query, hr %#lx.\n", hr);
        return hr;
    }
 
    if (type == D3DQUERYTYPE_OCCLUSION)
        query->data_size = sizeof(DWORD);
    else if (type == D3DQUERYTYPE_TIMESTAMPDISJOINT)
        query->data_size = sizeof(BOOL);
    else
        query->data_size = wined3d_query_get_data_size(query->wined3d_query);
    wined3d_mutex_unlock();
 
    query->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(query->parent_device);
 
    return D3D_OK;
}

Referenced by d3d9_device_CreateQuery().

stateblock_init()

HRESULT stateblock_init	(	struct d3d9_stateblock *	stateblock,
		struct d3d9_device *	device,
		D3DSTATEBLOCKTYPE	type,
		struct wined3d_stateblock *	wined3d_stateblock
	)

Definition at line 175 of file stateblock.c.

{
    HRESULT hr;
 
    stateblock->IDirect3DStateBlock9_iface.lpVtbl = &d3d9_stateblock_vtbl;
    stateblock->refcount = 1;
 
    if (wined3d_stateblock)
    {
        stateblock->wined3d_stateblock = wined3d_stateblock;
    }
    else
    {
        wined3d_mutex_lock();
        hr = wined3d_stateblock_create(device->wined3d_device, device->state,
                (enum wined3d_stateblock_type)type, &stateblock->wined3d_stateblock);
        wined3d_mutex_unlock();
        if (FAILED(hr))
        {
            WARN("Failed to create wined3d stateblock, hr %#lx.\n", hr);
            return hr;
        }
    }
 
    stateblock->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(stateblock->parent_device);
 
    return D3D_OK;
}

Referenced by d3d9_device_CreateStateBlock(), d3d9_device_EndStateBlock(), and wined3d_stateblock_create().

unsafe_impl_from_IDirect3DBaseTexture9()

struct d3d9_texture * unsafe_impl_from_IDirect3DBaseTexture9

(

IDirect3DBaseTexture9 *

iface

)

Definition at line 1204 of file texture.c.

{
    if (!iface)
        return NULL;
 
    if (iface->lpVtbl != (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl
            && iface->lpVtbl != (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl
            && iface->lpVtbl != (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl)
    {
        WARN("%p is not a valid IDirect3DBaseTexture9 interface.\n", iface);
        return NULL;
    }
 
    return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
}

Referenced by d3d9_device_SetTexture(), d3d9_device_UpdateTexture(), and d3d9_surface_create().

unsafe_impl_from_IDirect3DIndexBuffer9()

struct d3d9_indexbuffer * unsafe_impl_from_IDirect3DIndexBuffer9

(

IDirect3DIndexBuffer9 *

iface

)

Definition at line 654 of file buffer.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d9_indexbuffer_vtbl);
 
    return impl_from_IDirect3DIndexBuffer9(iface);
}

Referenced by d3d9_device_SetIndices().

unsafe_impl_from_IDirect3DPixelShader9()

struct d3d9_pixelshader * unsafe_impl_from_IDirect3DPixelShader9

(

IDirect3DPixelShader9 *

iface

)

Definition at line 300 of file shader.c.

{
    if (!iface)
        return NULL;
    if (iface->lpVtbl != &d3d9_pixelshader_vtbl)
        WARN("Pixel shader %p with the wrong vtbl %p\n", iface, iface->lpVtbl);
 
    return impl_from_IDirect3DPixelShader9(iface);
}

Referenced by d3d9_device_SetPixelShader().

unsafe_impl_from_IDirect3DSurface9()

struct d3d9_surface * unsafe_impl_from_IDirect3DSurface9

(

IDirect3DSurface9 *

iface

)

Definition at line 450 of file surface.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d9_surface_vtbl);
 
    return impl_from_IDirect3DSurface9(iface);
}

Referenced by d3d9_device_ColorFill(), d3d9_device_GetFrontBufferData(), d3d9_device_GetRenderTargetData(), d3d9_device_SetCursorProperties(), d3d9_device_SetDepthStencilSurface(), d3d9_device_SetRenderTarget(), d3d9_device_StretchRect(), d3d9_device_UpdateSurface(), and d3d9_swapchain_GetFrontBufferData().

unsafe_impl_from_IDirect3DVertexBuffer9()

struct d3d9_vertexbuffer * unsafe_impl_from_IDirect3DVertexBuffer9

(

IDirect3DVertexBuffer9 *

iface

)

Definition at line 347 of file buffer.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d9_vertexbuffer_vtbl);
 
    return impl_from_IDirect3DVertexBuffer9(iface);
}

Referenced by d3d9_device_ProcessVertices(), and d3d9_device_SetStreamSource().

unsafe_impl_from_IDirect3DVertexDeclaration9()

struct d3d9_vertex_declaration * unsafe_impl_from_IDirect3DVertexDeclaration9

(

IDirect3DVertexDeclaration9 *

iface

)

Definition at line 297 of file vertexdeclaration.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d9_vertex_declaration_vtbl);
    return CONTAINING_RECORD(iface, struct d3d9_vertex_declaration, IDirect3DVertexDeclaration9_iface);
}

Referenced by d3d9_device_ProcessVertices(), and d3d9_device_SetVertexDeclaration().

unsafe_impl_from_IDirect3DVertexShader9()

struct d3d9_vertexshader * unsafe_impl_from_IDirect3DVertexShader9

(

IDirect3DVertexShader9 *

iface

)

Definition at line 157 of file shader.c.

{
    if (!iface)
        return NULL;
    if (iface->lpVtbl != &d3d9_vertexshader_vtbl)
        WARN("Vertex shader %p with the wrong vtbl %p\n", iface, iface->lpVtbl);
 
    return impl_from_IDirect3DVertexShader9(iface);
}

Referenced by d3d9_device_SetVertexShader().

vdecl_convert_fvf()

HRESULT vdecl_convert_fvf	(	DWORD	FVF,
		D3DVERTEXELEMENT9 **	ppVertexElements
	)

Definition at line 58 of file vertexdeclaration.c.

                                          {
 
    unsigned int idx, idx2;
    unsigned int offset;
    BOOL has_pos = (fvf & D3DFVF_POSITION_MASK) != 0;
    BOOL has_blend = (fvf & D3DFVF_XYZB5) > D3DFVF_XYZRHW;
    BOOL has_blend_idx = has_blend &&
       (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB5) ||
        (fvf & D3DFVF_LASTBETA_D3DCOLOR) ||
        (fvf & D3DFVF_LASTBETA_UBYTE4));
    BOOL has_normal = (fvf & D3DFVF_NORMAL) != 0;
    BOOL has_psize = (fvf & D3DFVF_PSIZE) != 0;
 
    BOOL has_diffuse = (fvf & D3DFVF_DIFFUSE) != 0;
    BOOL has_specular = (fvf & D3DFVF_SPECULAR) !=0;
 
    DWORD num_textures = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
    DWORD texcoords = (fvf & 0xFFFF0000) >> 16;
 
    D3DVERTEXELEMENT9 end_element = D3DDECL_END();
    D3DVERTEXELEMENT9 *elements = NULL;
 
    unsigned int size;
    DWORD num_blends = 1 + (((fvf & D3DFVF_XYZB5) - D3DFVF_XYZB1) >> 1);
    if (has_blend_idx) num_blends--;
 
    /* Compute declaration size */
    size = has_pos + (has_blend && num_blends > 0) + has_blend_idx + has_normal +
           has_psize + has_diffuse + has_specular + num_textures + 1;
 
    /* convert the declaration */
    if (!(elements = malloc(size * sizeof(*elements))))
        return D3DERR_OUTOFVIDEOMEMORY;
 
    elements[size-1] = end_element;
    idx = 0;
    if (has_pos) {
        if (!has_blend && (fvf & D3DFVF_XYZRHW)) {
            elements[idx].Type = D3DDECLTYPE_FLOAT4;
            elements[idx].Usage = D3DDECLUSAGE_POSITIONT;
        }
        else if (!has_blend && (fvf & D3DFVF_XYZW) == D3DFVF_XYZW) {
            elements[idx].Type = D3DDECLTYPE_FLOAT4;
            elements[idx].Usage = D3DDECLUSAGE_POSITION;
        }
        else {
            elements[idx].Type = D3DDECLTYPE_FLOAT3;
            elements[idx].Usage = D3DDECLUSAGE_POSITION;
        }
        elements[idx].UsageIndex = 0;
        idx++;
    }
    if (has_blend && (num_blends > 0)) {
        if (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB2) && (fvf & D3DFVF_LASTBETA_D3DCOLOR))
            elements[idx].Type = D3DDECLTYPE_D3DCOLOR;
        else {
            switch(num_blends) {
                case 1: elements[idx].Type = D3DDECLTYPE_FLOAT1; break;
                case 2: elements[idx].Type = D3DDECLTYPE_FLOAT2; break;
                case 3: elements[idx].Type = D3DDECLTYPE_FLOAT3; break;
                case 4: elements[idx].Type = D3DDECLTYPE_FLOAT4; break;
                default:
                    ERR("Unexpected amount of blend values: %lu\n", num_blends);
            }
        }
        elements[idx].Usage = D3DDECLUSAGE_BLENDWEIGHT;
        elements[idx].UsageIndex = 0;
        idx++;
    }
    if (has_blend_idx) {
        if (fvf & D3DFVF_LASTBETA_UBYTE4 ||
            (((fvf & D3DFVF_XYZB5) == D3DFVF_XYZB2) && (fvf & D3DFVF_LASTBETA_D3DCOLOR)))
            elements[idx].Type = D3DDECLTYPE_UBYTE4;
        else if (fvf & D3DFVF_LASTBETA_D3DCOLOR)
            elements[idx].Type = D3DDECLTYPE_D3DCOLOR;
        else
            elements[idx].Type = D3DDECLTYPE_FLOAT1;
        elements[idx].Usage = D3DDECLUSAGE_BLENDINDICES;
        elements[idx].UsageIndex = 0;
        idx++;
    }
    if (has_normal) {
        elements[idx].Type = D3DDECLTYPE_FLOAT3;
        elements[idx].Usage = D3DDECLUSAGE_NORMAL;
        elements[idx].UsageIndex = 0;
        idx++;
    }
    if (has_psize) {
        elements[idx].Type = D3DDECLTYPE_FLOAT1;
        elements[idx].Usage = D3DDECLUSAGE_PSIZE;
        elements[idx].UsageIndex = 0;
        idx++;
    }
    if (has_diffuse) {
        elements[idx].Type = D3DDECLTYPE_D3DCOLOR;
        elements[idx].Usage = D3DDECLUSAGE_COLOR;
        elements[idx].UsageIndex = 0;
        idx++;
    }
    if (has_specular) {
        elements[idx].Type = D3DDECLTYPE_D3DCOLOR;
        elements[idx].Usage = D3DDECLUSAGE_COLOR;
        elements[idx].UsageIndex = 1;
        idx++;
    }
    for (idx2 = 0; idx2 < num_textures; idx2++) {
        unsigned int numcoords = (texcoords >> (idx2*2)) & 0x03;
        switch (numcoords) {
            case D3DFVF_TEXTUREFORMAT1:
                elements[idx].Type = D3DDECLTYPE_FLOAT1;
                break;
            case D3DFVF_TEXTUREFORMAT2:
                elements[idx].Type = D3DDECLTYPE_FLOAT2;
                break;
            case D3DFVF_TEXTUREFORMAT3:
                elements[idx].Type = D3DDECLTYPE_FLOAT3;
                break;
            case D3DFVF_TEXTUREFORMAT4:
                elements[idx].Type = D3DDECLTYPE_FLOAT4;
                break;
        }
        elements[idx].Usage = D3DDECLUSAGE_TEXCOORD;
        elements[idx].UsageIndex = idx2;
        idx++;
    }
 
    /* Now compute offsets, and initialize the rest of the fields */
    for (idx = 0, offset = 0; idx < size-1; idx++) {
        elements[idx].Stream = 0;
        elements[idx].Method = D3DDECLMETHOD_DEFAULT;
        elements[idx].Offset = offset;
        offset += d3d_dtype_lookup[elements[idx].Type].component_count
                * d3d_dtype_lookup[elements[idx].Type].component_size;
    }
 
    *ppVertexElements = elements;
    return D3D_OK;
}

Referenced by device_get_fvf_declaration().

vertexbuffer_init()

HRESULT vertexbuffer_init	(	struct d3d9_vertexbuffer *	buffer,
		struct d3d9_device *	device,
		UINT	size,
		UINT	usage,
		DWORD	fvf,
		D3DPOOL	pool
	)

Definition at line 277 of file buffer.c.

{
    const struct wined3d_parent_ops *parent_ops = &d3d9_null_wined3d_parent_ops;
    struct wined3d_buffer_desc desc;
    HRESULT hr;
 
    if (pool == D3DPOOL_SCRATCH)
    {
        WARN("Vertex buffer with D3DPOOL_SCRATCH requested.\n");
        return D3DERR_INVALIDCALL;
    }
 
    if (pool == D3DPOOL_MANAGED && device->d3d_parent->extended)
    {
        WARN("Managed resources are not supported by d3d9ex devices.\n");
        return D3DERR_INVALIDCALL;
    }
 
    /* In d3d9, buffers can't be used as rendertarget or depth/stencil buffer. */
    if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
        return D3DERR_INVALIDCALL;
 
    buffer->IDirect3DVertexBuffer9_iface.lpVtbl = &d3d9_vertexbuffer_vtbl;
    buffer->fvf = fvf;
    buffer->usage = usage;
    d3d9_resource_init(&buffer->resource);
 
    desc.byte_width = size;
    desc.usage = wined3d_usage_from_d3d(pool, usage);
    desc.bind_flags = 0;
    desc.access = wined3daccess_from_d3dpool(pool, usage) | map_access_from_usage(usage);
    /* Buffers are always readable. */
    if (pool != D3DPOOL_DEFAULT)
        desc.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    desc.misc_flags = 0;
    desc.structure_byte_stride = 0;
 
    if (!device->d3d_parent->extended)
        desc.usage |= WINED3DUSAGE_VIDMEM_ACCOUNTING;
 
    if (desc.access & WINED3D_RESOURCE_ACCESS_GPU)
    {
        desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
        parent_ops = &d3d9_vertexbuffer_wined3d_parent_ops;
    }
 
    wined3d_mutex_lock();
    hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, parent_ops, &buffer->wined3d_buffer);
    if (SUCCEEDED(hr) && !(desc.access & WINED3D_RESOURCE_ACCESS_GPU))
    {
        desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
        desc.access = WINED3D_RESOURCE_ACCESS_GPU;
        if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
                &d3d9_vertexbuffer_wined3d_parent_ops, &buffer->draw_buffer)))
            wined3d_buffer_decref(buffer->wined3d_buffer);
    }
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d buffer, hr %#lx.\n", hr);
        return hr;
    }
 
    buffer->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(buffer->parent_device);
 
    return D3D_OK;
}

vertexshader_init()

HRESULT vertexshader_init	(	struct d3d9_vertexshader *	shader,
		struct d3d9_device *	device,
		const DWORD *	byte_code
	)

Definition at line 130 of file shader.c.

{
    struct wined3d_shader_desc desc;
    HRESULT hr;
 
    shader->refcount = 1;
    shader->IDirect3DVertexShader9_iface.lpVtbl = &d3d9_vertexshader_vtbl;
 
    desc.byte_code = byte_code;
    desc.byte_code_size = ~(size_t)0;
 
    wined3d_mutex_lock();
    hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader,
            &d3d9_vertexshader_wined3d_parent_ops, &shader->wined3d_shader);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d vertex shader, hr %#lx.\n", hr);
        return hr;
    }
 
    shader->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(shader->parent_device);
 
    return D3D_OK;
}

Referenced by d3d9_device_CreateVertexShader().

volume_init()

void volume_init	(	struct d3d9_volume *	volume,
		struct wined3d_texture *	wined3d_texture,
		unsigned int	sub_resource_idx,
		const struct wined3d_parent_ops **	parent_ops
	)

Definition at line 204 of file volume.c.

{
    volume->IDirect3DVolume9_iface.lpVtbl = &d3d9_volume_vtbl;
    d3d9_resource_init(&volume->resource);
    volume->resource.refcount = 0;
    volume->texture = wined3d_texture_get_parent(wined3d_texture);
    volume->wined3d_texture = wined3d_texture;
    volume->sub_resource_idx = sub_resource_idx;
 
    *parent_ops = &d3d9_volume_wined3d_parent_ops;
}

wined3d_bind_flags_from_d3d9_usage()

static unsigned int wined3d_bind_flags_from_d3d9_usage ( DWORD  usage )

inlinestatic

Definition at line 395 of file d3d9_private.h.

{
    unsigned int bind_flags = 0;
 
    if (usage & D3DUSAGE_RENDERTARGET)
        bind_flags |= WINED3D_BIND_RENDER_TARGET;
    if (usage & D3DUSAGE_DEPTHSTENCIL)
        bind_flags |= WINED3D_BIND_DEPTH_STENCIL;
 
    return bind_flags;
}

Referenced by d3d9_CheckDeviceFormat(), d3d9_texture_2d_init(), d3d9_texture_3d_init(), and d3d9_texture_cube_init().

wined3d_device_type_from_d3d()

static enum wined3d_device_type wined3d_device_type_from_d3d ( D3DDEVTYPE  type )

inlinestatic

Definition at line 412 of file d3d9_private.h.

{
    return (enum wined3d_device_type)type;
}

wined3d_multisample_type_from_d3d()

static enum wined3d_multisample_type wined3d_multisample_type_from_d3d ( D3DMULTISAMPLE_TYPE  type )

inlinestatic

Definition at line 407 of file d3d9_private.h.

{
    return (enum wined3d_multisample_type)type;
}

wined3d_scanline_ordering_from_d3d()

static enum wined3d_scanline_ordering wined3d_scanline_ordering_from_d3d ( D3DSCANLINEORDERING  ordering )

inlinestatic

Definition at line 417 of file d3d9_private.h.

{
    return (enum wined3d_scanline_ordering)ordering;
}

Referenced by d3d9_device_reset(), d3d9_EnumAdapterModesEx(), and d3d9_GetAdapterModeCountEx().

wined3d_usage_from_d3d()

static unsigned int wined3d_usage_from_d3d ( D3DPOOL  pool, DWORD  usage  )

inlinestatic

Definition at line 385 of file d3d9_private.h.

{
    usage &= WINED3DUSAGE_MASK;
    if (pool == D3DPOOL_SCRATCH)
        usage |= WINED3DUSAGE_SCRATCH;
    else if (pool == D3DPOOL_MANAGED)
        usage |= WINED3DUSAGE_MANAGED;
    return usage;
}

wined3daccess_from_d3dpool()

static unsigned int wined3daccess_from_d3dpool ( D3DPOOL  pool, unsigned int  usage  )

inlinestatic

Definition at line 361 of file d3d9_private.h.

{
    unsigned int access;
 
    switch (pool)
    {
        case D3DPOOL_DEFAULT:
            access = WINED3D_RESOURCE_ACCESS_GPU;
            break;
        case D3DPOOL_MANAGED:
            access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU;
            break;
        case D3DPOOL_SYSTEMMEM:
        case D3DPOOL_SCRATCH:
            access = WINED3D_RESOURCE_ACCESS_CPU;
            break;
        default:
            access = 0;
    }
    if (pool != D3DPOOL_DEFAULT || usage & D3DUSAGE_DYNAMIC)
        access |= map_access_from_usage(usage);
    return access;
}

wined3dformat_from_d3dformat()

enum wined3d_format_id wined3dformat_from_d3dformat

(

D3DFORMAT

format

)

Definition at line 84 of file device.c.

{
    BYTE *c = (BYTE *)&format;
 
    /* Don't translate FOURCC formats */
    if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3]))
            return (enum wined3d_format_id)format;
 
    switch(format)
    {
        case D3DFMT_UNKNOWN: return WINED3DFMT_UNKNOWN;
        case D3DFMT_R8G8B8: return WINED3DFMT_B8G8R8_UNORM;
        case D3DFMT_A8R8G8B8: return WINED3DFMT_B8G8R8A8_UNORM;
        case D3DFMT_X8R8G8B8: return WINED3DFMT_B8G8R8X8_UNORM;
        case D3DFMT_R5G6B5: return WINED3DFMT_B5G6R5_UNORM;
        case D3DFMT_X1R5G5B5: return WINED3DFMT_B5G5R5X1_UNORM;
        case D3DFMT_A1R5G5B5: return WINED3DFMT_B5G5R5A1_UNORM;
        case D3DFMT_A4R4G4B4: return WINED3DFMT_B4G4R4A4_UNORM;
        case D3DFMT_R3G3B2: return WINED3DFMT_B2G3R3_UNORM;
        case D3DFMT_A8: return WINED3DFMT_A8_UNORM;
        case D3DFMT_A8R3G3B2: return WINED3DFMT_B2G3R3A8_UNORM;
        case D3DFMT_X4R4G4B4: return WINED3DFMT_B4G4R4X4_UNORM;
        case D3DFMT_A2B10G10R10: return WINED3DFMT_R10G10B10A2_UNORM;
        case D3DFMT_G16R16: return WINED3DFMT_R16G16_UNORM;
        case D3DFMT_A8P8: return WINED3DFMT_P8_UINT_A8_UNORM;
        case D3DFMT_P8: return WINED3DFMT_P8_UINT;
        case D3DFMT_L8: return WINED3DFMT_L8_UNORM;
        case D3DFMT_A8L8: return WINED3DFMT_L8A8_UNORM;
        case D3DFMT_A4L4: return WINED3DFMT_L4A4_UNORM;
        case D3DFMT_V8U8: return WINED3DFMT_R8G8_SNORM;
        case D3DFMT_L6V5U5: return WINED3DFMT_R5G5_SNORM_L6_UNORM;
        case D3DFMT_X8L8V8U8: return WINED3DFMT_R8G8_SNORM_L8X8_UNORM;
        case D3DFMT_Q8W8V8U8: return WINED3DFMT_R8G8B8A8_SNORM;
        case D3DFMT_V16U16: return WINED3DFMT_R16G16_SNORM;
        case D3DFMT_W11V11U10: return WINED3DFMT_R10G11B11_SNORM;
        case D3DFMT_A2W10V10U10: return WINED3DFMT_R10G10B10_SNORM_A2_UNORM;
        case D3DFMT_D16_LOCKABLE: return WINED3DFMT_D16_LOCKABLE;
        case D3DFMT_D32: return WINED3DFMT_D32_UNORM;
        case D3DFMT_D15S1: return WINED3DFMT_S1_UINT_D15_UNORM;
        case D3DFMT_D24S8: return WINED3DFMT_D24_UNORM_S8_UINT;
        case D3DFMT_D24X8: return WINED3DFMT_X8D24_UNORM;
        case D3DFMT_D24X4S4: return WINED3DFMT_S4X4_UINT_D24_UNORM;
        case D3DFMT_D16: return WINED3DFMT_D16_UNORM;
        case D3DFMT_INDEX16: return WINED3DFMT_R16_UINT;
        case D3DFMT_INDEX32: return WINED3DFMT_R32_UINT;
        default:
            FIXME("Unhandled D3DFORMAT %#x.\n", format);
            return WINED3DFMT_UNKNOWN;
    }
}

Referenced by d3d8_device_CreateDepthStencilSurface(), d3d8_device_CreateImageSurface(), d3d8_device_CreateRenderTarget(), d3d8_device_DrawIndexedPrimitiveUP(), d3d9_device_CreateDepthStencilSurface(), d3d9_device_CreateDepthStencilSurfaceEx(), d3d9_device_CreateOffscreenPlainSurface(), d3d9_device_CreateRenderTarget(), d3d9_device_CreateRenderTargetEx(), d3d9_device_DrawIndexedPrimitiveUP(), d3d9_device_reset(), wined3d_swapchain_desc_from_d3d8(), and wined3d_swapchain_desc_from_d3d9().

wined3dmapflags_from_d3dmapflags()

unsigned int wined3dmapflags_from_d3dmapflags	(	unsigned int	flags,
		unsigned int	usage
	)

Definition at line 135 of file device.c.

{
    static const unsigned int handled = D3DLOCK_NOSYSLOCK
            | D3DLOCK_NOOVERWRITE
            | D3DLOCK_DISCARD
            | D3DLOCK_NO_DIRTY_UPDATE;
    unsigned int wined3d_flags;
 
    wined3d_flags = flags & handled;
    if (~usage & D3DUSAGE_WRITEONLY && !(flags & (D3DLOCK_NOOVERWRITE | D3DLOCK_DISCARD)))
        wined3d_flags |= WINED3D_MAP_READ;
    if (!(flags & D3DLOCK_READONLY))
        wined3d_flags |= WINED3D_MAP_WRITE;
    if (!(wined3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE)))
        wined3d_flags |= WINED3D_MAP_WRITE;
    flags &= ~(handled | D3DLOCK_READONLY);
 
    if (flags)
        FIXME("Unhandled flags %#x.\n", flags);
 
    return wined3d_flags;
}

Variable Documentation

d3d9_null_wined3d_parent_ops

const struct wined3d_parent_ops d3d9_null_wined3d_parent_ops

extern

Definition at line 29 of file device.c.

Referenced by d3d9_device_create_surface(), d3d9_texture_init(), query_init(), and vertexbuffer_init().