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 "wine/heap.h"
#include "wine/unicode.h"
#include "d3d9.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	NONAMELESSUNION
#define	NONAMELESSSTRUCT
#define	COBJMACROS
#define	D3D9_MAX_VERTEX_SHADER_CONSTANTF   256
#define	D3D9_MAX_TEXTURE_UNITS   20
#define	D3DPRESENTFLAGS_MASK   0x00000fffu
#define	D3D9_TEXTURE_MIPMAP_DIRTY   0x1

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) DECLSPEC_HIDDEN
D3DFORMAT	d3dformat_from_wined3dformat (enum wined3d_format_id format) DECLSPEC_HIDDEN
BOOL	is_gdi_compat_wined3dformat (enum wined3d_format_id format) DECLSPEC_HIDDEN
enum wined3d_format_id	wined3dformat_from_d3dformat (D3DFORMAT format) DECLSPEC_HIDDEN
unsigned int	wined3dmapflags_from_d3dmapflags (unsigned int flags) DECLSPEC_HIDDEN
void	present_parameters_from_wined3d_swapchain_desc (D3DPRESENT_PARAMETERS *present_parameters, const struct wined3d_swapchain_desc *swapchain_desc) DECLSPEC_HIDDEN
void	d3dcaps_from_wined3dcaps (D3DCAPS9 *caps, const WINED3DCAPS *wined3d_caps) DECLSPEC_HIDDEN
BOOL	d3d9_init (struct d3d9 *d3d9, BOOL extended) DECLSPEC_HIDDEN
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) DECLSPEC_HIDDEN
void	d3d9_resource_cleanup (struct d3d9_resource *resource) DECLSPEC_HIDDEN
HRESULT	d3d9_resource_free_private_data (struct d3d9_resource *resource, const GUID *guid) DECLSPEC_HIDDEN
HRESULT	d3d9_resource_get_private_data (struct d3d9_resource *resource, const GUID *guid, void *data, DWORD *data_size) DECLSPEC_HIDDEN
void	d3d9_resource_init (struct d3d9_resource *resource) DECLSPEC_HIDDEN
HRESULT	d3d9_resource_set_private_data (struct d3d9_resource *resource, const GUID *guid, const void *data, DWORD data_size, DWORD flags) DECLSPEC_HIDDEN
void	volume_init (struct d3d9_volume *volume, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, const struct wined3d_parent_ops **parent_ops) DECLSPEC_HIDDEN
HRESULT	d3d9_swapchain_create (struct d3d9_device *device, struct wined3d_swapchain_desc *desc, struct d3d9_swapchain **swapchain) DECLSPEC_HIDDEN
struct wined3d_rendertarget_view *	d3d9_surface_acquire_rendertarget_view (struct d3d9_surface *surface) DECLSPEC_HIDDEN
struct d3d9_device *	d3d9_surface_get_device (const struct d3d9_surface *surface) DECLSPEC_HIDDEN
void	d3d9_surface_release_rendertarget_view (struct d3d9_surface *surface, struct wined3d_rendertarget_view *rtv) DECLSPEC_HIDDEN
void	surface_init (struct d3d9_surface *surface, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, const struct wined3d_parent_ops **parent_ops) DECLSPEC_HIDDEN
struct d3d9_surface *	unsafe_impl_from_IDirect3DSurface9 (IDirect3DSurface9 *iface) DECLSPEC_HIDDEN
HRESULT	vertexbuffer_init (struct d3d9_vertexbuffer *buffer, struct d3d9_device *device, UINT size, UINT usage, DWORD fvf, D3DPOOL pool) DECLSPEC_HIDDEN
struct d3d9_vertexbuffer *	unsafe_impl_from_IDirect3DVertexBuffer9 (IDirect3DVertexBuffer9 *iface) DECLSPEC_HIDDEN
HRESULT	indexbuffer_init (struct d3d9_indexbuffer *buffer, struct d3d9_device *device, UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN
struct d3d9_indexbuffer *	unsafe_impl_from_IDirect3DIndexBuffer9 (IDirect3DIndexBuffer9 *iface) DECLSPEC_HIDDEN
HRESULT	cubetexture_init (struct d3d9_texture *texture, struct d3d9_device *device, UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN
HRESULT	texture_init (struct d3d9_texture *texture, struct d3d9_device *device, UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN
HRESULT	volumetexture_init (struct d3d9_texture *texture, struct d3d9_device *device, UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN
struct d3d9_texture *	unsafe_impl_from_IDirect3DBaseTexture9 (IDirect3DBaseTexture9 *iface) DECLSPEC_HIDDEN
void	d3d9_texture_flag_auto_gen_mipmap (struct d3d9_texture *texture) DECLSPEC_HIDDEN
void	d3d9_texture_gen_auto_mipmap (struct d3d9_texture *texture) DECLSPEC_HIDDEN
HRESULT	stateblock_init (struct d3d9_stateblock *stateblock, struct d3d9_device *device, D3DSTATEBLOCKTYPE type, struct wined3d_stateblock *wined3d_stateblock) DECLSPEC_HIDDEN
HRESULT	d3d9_vertex_declaration_create (struct d3d9_device *device, const D3DVERTEXELEMENT9 *elements, struct d3d9_vertex_declaration **declaration) DECLSPEC_HIDDEN
struct d3d9_vertex_declaration *	unsafe_impl_from_IDirect3DVertexDeclaration9 (IDirect3DVertexDeclaration9 *iface) DECLSPEC_HIDDEN
HRESULT	vertexshader_init (struct d3d9_vertexshader *shader, struct d3d9_device *device, const DWORD *byte_code) DECLSPEC_HIDDEN
struct d3d9_vertexshader *	unsafe_impl_from_IDirect3DVertexShader9 (IDirect3DVertexShader9 *iface) DECLSPEC_HIDDEN
HRESULT	pixelshader_init (struct d3d9_pixelshader *shader, struct d3d9_device *device, const DWORD *byte_code) DECLSPEC_HIDDEN
struct d3d9_pixelshader *	unsafe_impl_from_IDirect3DPixelShader9 (IDirect3DPixelShader9 *iface) DECLSPEC_HIDDEN
HRESULT	query_init (struct d3d9_query *query, struct d3d9_device *device, D3DQUERYTYPE type) DECLSPEC_HIDDEN
static struct d3d9_device *	impl_from_IDirect3DDevice9Ex (IDirect3DDevice9Ex *iface)
static DWORD	d3dusage_from_wined3dusage (unsigned int usage)
static D3DPOOL	d3dpool_from_wined3daccess (unsigned int access, unsigned int usage)
static unsigned int	wined3daccess_from_d3dpool (D3DPOOL pool, unsigned int usage)
static DWORD	wined3dusage_from_d3dusage (unsigned int usage)

Variables
const struct wined3d_parent_ops d3d9_null_wined3d_parent_ops	DECLSPEC_HIDDEN

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 31 of file d3d9_private.h.

D3D9_MAX_TEXTURE_UNITS

#define D3D9_MAX_TEXTURE_UNITS   20

Definition at line 44 of file d3d9_private.h.

D3D9_MAX_VERTEX_SHADER_CONSTANTF

#define D3D9_MAX_VERTEX_SHADER_CONSTANTF   256

Definition at line 43 of file d3d9_private.h.

D3D9_TEXTURE_MIPMAP_DIRTY

#define D3D9_TEXTURE_MIPMAP_DIRTY   0x1

Definition at line 48 of file d3d9_private.h.

D3DPRESENTFLAGS_MASK

#define D3DPRESENTFLAGS_MASK   0x00000fffu

Definition at line 46 of file d3d9_private.h.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 30 of file d3d9_private.h.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 29 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 77 of file d3d9_private.h.

{
    D3D9_DEVICE_STATE_OK,
    D3D9_DEVICE_STATE_LOST,
    D3D9_DEVICE_STATE_NOT_RESET,
};

Function Documentation

cubetexture_init()

HRESULT cubetexture_init	(	struct d3d9_texture *	texture,
		struct d3d9_device *	device,
		UINT	edge_length,
		UINT	levels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 1369 of file texture.c.

{
    struct wined3d_resource_desc desc;
    DWORD flags = 0;
    HRESULT hr;
 
    texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl;
    d3d9_resource_init(&texture->resource);
    list_init(&texture->rtv_list);
    texture->usage = usage;
 
    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 = wined3dusage_from_d3dusage(usage);
    desc.usage |= WINED3DUSAGE_LEGACY_CUBEMAP | WINED3DUSAGE_TEXTURE;
    if (pool == D3DPOOL_SCRATCH)
        desc.usage |= WINED3DUSAGE_SCRATCH;
    desc.access = wined3daccess_from_d3dpool(pool, usage)
            | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    desc.width = edge_length;
    desc.height = edge_length;
    desc.depth = 1;
    desc.size = 0;
 
    if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC))
        flags |= WINED3D_TEXTURE_CREATE_MAPPABLE;
 
    if (is_gdi_compat_wined3dformat(desc.format))
        flags |= WINED3D_TEXTURE_CREATE_GET_DC;
 
    if (usage & D3DUSAGE_AUTOGENMIPMAP)
    {
        if (pool == D3DPOOL_SYSTEMMEM)
        {
            WARN("D3DUSAGE_AUTOGENMIPMAP texture can't be in D3DPOOL_SYSTEMMEM, returning D3DERR_INVALIDCALL.\n");
            return D3DERR_INVALIDCALL;
        }
        if (levels && levels != 1)
        {
            WARN("D3DUSAGE_AUTOGENMIPMAP texture with %u levels, returning D3DERR_INVALIDCALL.\n", levels);
            return D3DERR_INVALIDCALL;
        }
        flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
        texture->autogen_filter_type = D3DTEXF_LINEAR;
        levels = 0;
    }
    else
    {
        texture->autogen_filter_type = D3DTEXF_NONE;
    }
    if (!levels)
        levels = wined3d_log2i(edge_length) + 1;
 
    wined3d_mutex_lock();
    hr = wined3d_texture_create(device->wined3d_device, &desc, 6, levels, flags,
            NULL, texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d cube texture, hr %#x.\n", hr);
        return hr;
    }
 
    texture->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(texture->parent_device);
 
    return D3D_OK;
}

d3d9_init()

BOOL d3d9_init	(	struct d3d9 *	d3d9,
		BOOL	extended
	)

Definition at line 577 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_LIMIT_VIEWPORT;
 
    if (!extended)
        flags |= WINED3D_VIDMEM_ACCOUNTING;
    else
        flags |= WINED3D_RESTORE_MODE_ON_ACTIVATE;
 
    d3d9->IDirect3D9Ex_iface.lpVtbl = &d3d9_vtbl;
    d3d9->refcount = 1;
 
    wined3d_mutex_lock();
    d3d9->wined3d = wined3d_create(flags);
    wined3d_mutex_unlock();
    if (!d3d9->wined3d)
        return FALSE;
    d3d9->extended = extended;
 
    return TRUE;
}

Referenced by Direct3DCreate9(), and Direct3DCreate9Ex().

d3d9_resource_cleanup()

void d3d9_resource_cleanup

(

struct d3d9_resource *

resource

)

Definition at line 155 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 160 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 178 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 216 of file d3d9_main.c.

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

Referenced by cubetexture_init(), indexbuffer_init(), surface_init(), texture_init(), vertexbuffer_init(), volume_init(), and volumetexture_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 222 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 407 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 %#x.\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_get_device()

struct d3d9_device * d3d9_surface_get_device

(

const struct d3d9_surface *

surface

)

Definition at line 400 of file surface.c.

{
    IDirect3DDevice9Ex *device;
    device = surface->texture ? surface->texture->parent_device : 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 433 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,
		struct d3d9_swapchain **	swapchain
	)

Definition at line 371 of file swapchain.c.

{
    struct d3d9_swapchain *object;
    HRESULT hr;
 
    if (!(object = heap_alloc_zero(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = swapchain_init(object, device, desc)))
    {
        WARN("Failed to initialize swapchain, hr %#x.\n", hr);
        heap_free(object);
        return hr;
    }
 
    TRACE("Created swapchain %p.\n", object);
    *swapchain = object;
 
    return D3D_OK;
}

Referenced by d3d9_device_CreateAdditionalSwapChain(), and device_parent_create_swapchain().

d3d9_texture_flag_auto_gen_mipmap()

void d3d9_texture_flag_auto_gen_mipmap

(

struct d3d9_texture *

texture

)

Definition at line 108 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 99 of file texture.c.

{
    if (!(texture->flags & D3D9_TEXTURE_MIPMAP_DIRTY))
        return;
    d3d9_texture_acquire_shader_resource_view(texture);
    wined3d_shader_resource_view_generate_mipmaps(texture->wined3d_srv);
    texture->flags &= ~D3D9_TEXTURE_MIPMAP_DIRTY;
}

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

d3d9_vertex_declaration_create()

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

Definition at line 415 of file vertexdeclaration.c.

{
    struct d3d9_vertex_declaration *object;
    HRESULT hr;
 
    if (!(object = heap_alloc_zero(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    hr = vertexdeclaration_init(object, device, elements);
    if (FAILED(hr))
    {
        WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
        heap_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().

d3dcaps_from_wined3dcaps()

void d3dcaps_from_wined3dcaps	(	D3DCAPS9 *	caps,
		const WINED3DCAPS *	wined3d_caps
	)

Definition at line 317 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;
 
    caps->DeviceType                        = (D3DDEVTYPE)wined3d_caps->DeviceType;
    caps->AdapterOrdinal                    = wined3d_caps->AdapterOrdinal;
    caps->Caps                              = wined3d_caps->Caps;
    caps->Caps2                             = wined3d_caps->Caps2;
    caps->Caps3                             = wined3d_caps->Caps3;
    caps->PresentationIntervals             = wined3d_caps->PresentationIntervals;
    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->MasterAdapterOrdinal              = wined3d_caps->MasterAdapterOrdinal;
    caps->AdapterOrdinalInGroup             = wined3d_caps->AdapterOrdinalInGroup;
    caps->NumberOfAdaptersInGroup           = wined3d_caps->NumberOfAdaptersInGroup;
    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]);
    }
}

d3dformat_from_wined3dformat()

D3DFORMAT d3dformat_from_wined3dformat

(

enum wined3d_format_id

format

)

Definition at line 44 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 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().

d3dpool_from_wined3daccess()

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

inlinestatic

Definition at line 299 of file d3d9_private.h.

{
    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;
    }
}

d3dusage_from_wined3dusage()

static DWORD d3dusage_from_wined3dusage ( unsigned int  usage )

inlinestatic

Definition at line 294 of file d3d9_private.h.

{
    return usage & WINED3DUSAGE_MASK;
}

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

{
    struct wined3d_swapchain_desc *swapchain_desc;
    unsigned i, count = 1;
    WINED3DCAPS caps;
    HRESULT hr;
 
    if (mode)
        FIXME("Ignoring display mode.\n");
 
    device->IDirect3DDevice9Ex_iface.lpVtbl = &d3d9_device_vtbl;
    device->device_parent.ops = &d3d9_wined3d_device_parent_ops;
    device->refcount = 1;
 
    if (!(flags & D3DCREATE_FPU_PRESERVE)) setup_fpu();
 
    wined3d_mutex_lock();
    if (FAILED(hr = wined3d_device_create(wined3d, adapter, device_type, focus_window, flags, 4,
            &device->device_parent, &device->wined3d_device)))
    {
        WARN("Failed to create wined3d device, hr %#x.\n", hr);
        wined3d_mutex_unlock();
        return hr;
    }
 
    wined3d_get_device_caps(wined3d, adapter, device_type, &caps);
    device->max_user_clip_planes = caps.MaxUserClipPlanes;
    if (flags & D3DCREATE_ADAPTERGROUP_DEVICE)
        count = caps.NumberOfAdaptersInGroup;
 
    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 %#x.\n", hr);
            wined3d_device_decref(device->wined3d_device);
            wined3d_mutex_unlock();
            return hr;
        }
 
        for (i = 0; i < count; ++i)
        {
            HWND device_window = parameters[i].hDeviceWindow;
 
            if (!device_window) device_window = focus_window;
            wined3d_device_setup_fullscreen_window(device->wined3d_device, device_window,
                    parameters[i].BackBufferWidth,
                    parameters[i].BackBufferHeight);
        }
    }
 
    if (!(swapchain_desc = heap_alloc(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_present_parameters(&swapchain_desc[i], &parameters[i],
                parent->extended))
        {
            wined3d_device_release_focus_window(device->wined3d_device);
            wined3d_device_decref(device->wined3d_device);
            heap_free(swapchain_desc);
            wined3d_mutex_unlock();
            return D3DERR_INVALIDCALL;
        }
    }
 
    if (FAILED(hr = wined3d_device_init_3d(device->wined3d_device, swapchain_desc)))
    {
        WARN("Failed to initialize 3D, hr %#x.\n", hr);
        wined3d_device_release_focus_window(device->wined3d_device);
        heap_free(swapchain_desc);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        return hr;
    }
 
    wined3d_device_set_render_state(device->wined3d_device,
            WINED3D_RS_ZENABLE, !!swapchain_desc->enable_auto_depth_stencil);
 
    if (FAILED(hr = d3d9_device_get_swapchains(device)))
    {
        wined3d_device_uninit_3d(device->wined3d_device);
        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)
    {
        present_parameters_from_wined3d_swapchain_desc(&parameters[i], &swapchain_desc[i]);
    }
 
    wined3d_mutex_unlock();
 
    heap_free(swapchain_desc);
 
    /* Initialize the converted declaration array. This creates a valid pointer
     * and when adding decls HeapReAlloc() can be used without further checking. */
    if (!(device->fvf_decls = heap_alloc(0)))
    {
        ERR("Failed to allocate FVF vertex declaration map memory.\n");
        wined3d_mutex_lock();
        heap_free(device->implicit_swapchains);
        wined3d_device_uninit_3d(device->wined3d_device);
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        return E_OUTOFMEMORY;
    }
 
    /* 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_get_rendertarget_view(device->wined3d_device, 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 289 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_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_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_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_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_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 569 of file buffer.c.

{
    struct wined3d_buffer_desc desc;
    HRESULT hr;
 
    desc.byte_width = size;
    desc.usage = (usage & WINED3DUSAGE_MASK) | WINED3DUSAGE_STATICDECL;
    if (pool == D3DPOOL_SCRATCH)
        desc.usage |= WINED3DUSAGE_SCRATCH;
    desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
    desc.access = wined3daccess_from_d3dpool(pool, usage)
            | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    desc.misc_flags = 0;
    desc.structure_byte_stride = 0;
 
    buffer->IDirect3DIndexBuffer9_iface.lpVtbl = &d3d9_indexbuffer_vtbl;
    buffer->format = wined3dformat_from_d3dformat(format);
    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 %#x.\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 1389 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 cubetexture_init(), d3d9_device_create_surface(), device_parent_create_swapchain_texture(), and texture_init().

pixelshader_init()

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

Definition at line 291 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;
    desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1;
    desc.input_signature.element_count = 0;
    desc.output_signature.element_count = 0;
    desc.patch_constant_signature.element_count = 0;
    desc.max_version = 3;
 
    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 %#x.\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
	)

Definition at line 233 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 = 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 = swapchain_desc->swap_interval;
}

query_init()

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

Definition at line 184 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, type,
            query, &d3d9_null_wined3d_parent_ops, &query->wined3d_query)))
    {
        wined3d_mutex_unlock();
        WARN("Failed to create wined3d query, hr %#x.\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 134 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,
                (enum wined3d_stateblock_type)type, &stateblock->wined3d_stateblock);
        wined3d_mutex_unlock();
        if (FAILED(hr))
        {
            WARN("Failed to create wined3d stateblock, hr %#x.\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().

surface_init()

void surface_init	(	struct d3d9_surface *	surface,
		struct wined3d_texture *	wined3d_texture,
		unsigned int	sub_resource_idx,
		const struct wined3d_parent_ops **	parent_ops
	)

Definition at line 355 of file surface.c.

{
    IDirect3DBaseTexture9 *texture;
 
    surface->IDirect3DSurface9_iface.lpVtbl = &d3d9_surface_vtbl;
    d3d9_resource_init(&surface->resource);
    surface->resource.refcount = 0;
    list_init(&surface->rtv_entry);
    surface->container = wined3d_texture_get_parent(wined3d_texture);
    surface->wined3d_texture = wined3d_texture;
    surface->sub_resource_idx = sub_resource_idx;
 
    if (surface->container && SUCCEEDED(IUnknown_QueryInterface(surface->container,
            &IID_IDirect3DBaseTexture9, (void **)&texture)))
    {
        surface->texture = unsafe_impl_from_IDirect3DBaseTexture9(texture);
        IDirect3DBaseTexture9_Release(texture);
    }
 
    *parent_ops = &d3d9_surface_wined3d_parent_ops;
}

texture_init()

HRESULT texture_init	(	struct d3d9_texture *	texture,
		struct d3d9_device *	device,
		UINT	width,
		UINT	height,
		UINT	levels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 1297 of file texture.c.

{
    struct wined3d_resource_desc desc;
    DWORD flags = 0;
    HRESULT hr;
 
    texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl;
    d3d9_resource_init(&texture->resource);
    list_init(&texture->rtv_list);
    texture->usage = usage;
 
    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 = wined3dusage_from_d3dusage(usage);
    desc.usage |= WINED3DUSAGE_TEXTURE;
    if (pool == D3DPOOL_SCRATCH)
        desc.usage |= WINED3DUSAGE_SCRATCH;
    desc.access = wined3daccess_from_d3dpool(pool, usage)
            | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    desc.width = width;
    desc.height = height;
    desc.depth = 1;
    desc.size = 0;
 
    if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC))
        flags |= WINED3D_TEXTURE_CREATE_MAPPABLE;
 
    if (is_gdi_compat_wined3dformat(desc.format))
        flags |= WINED3D_TEXTURE_CREATE_GET_DC;
 
    if (usage & D3DUSAGE_AUTOGENMIPMAP)
    {
        if (pool == D3DPOOL_SYSTEMMEM)
        {
            WARN("D3DUSAGE_AUTOGENMIPMAP texture can't be in D3DPOOL_SYSTEMMEM, returning D3DERR_INVALIDCALL.\n");
            return D3DERR_INVALIDCALL;
        }
        if (levels && levels != 1)
        {
            WARN("D3DUSAGE_AUTOGENMIPMAP texture with %u levels, returning D3DERR_INVALIDCALL.\n", levels);
            return D3DERR_INVALIDCALL;
        }
        flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
        texture->autogen_filter_type = D3DTEXF_LINEAR;
        levels = 0;
    }
    else
    {
        texture->autogen_filter_type = D3DTEXF_NONE;
    }
    if (!levels)
        levels = wined3d_log2i(max(width, height)) + 1;
 
    wined3d_mutex_lock();
    hr = wined3d_texture_create(device->wined3d_device, &desc, 1, levels, flags,
            NULL, texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d texture, hr %#x.\n", hr);
        return hr;
    }
 
    texture->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(texture->parent_device);
 
    return D3D_OK;
}

unsafe_impl_from_IDirect3DBaseTexture9()

struct d3d9_texture * unsafe_impl_from_IDirect3DBaseTexture9

(

IDirect3DBaseTexture9 *

iface

)

Definition at line 1269 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 surface_init().

unsafe_impl_from_IDirect3DIndexBuffer9()

struct d3d9_indexbuffer * unsafe_impl_from_IDirect3DIndexBuffer9

(

IDirect3DIndexBuffer9 *

iface

)

Definition at line 605 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 323 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 440 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 314 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 302 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 169 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 59 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 = heap_alloc(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: %u\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 274 of file buffer.c.

{
    struct wined3d_buffer_desc desc;
    HRESULT hr;
 
    if (pool == D3DPOOL_SCRATCH)
    {
        WARN("Vertex buffer with D3DPOOL_SCRATCH requested.\n");
        return D3DERR_INVALIDCALL;
    }
 
    buffer->IDirect3DVertexBuffer9_iface.lpVtbl = &d3d9_vertexbuffer_vtbl;
    buffer->fvf = fvf;
    d3d9_resource_init(&buffer->resource);
 
    desc.byte_width = size;
    desc.usage = usage & WINED3DUSAGE_MASK;
    desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
    desc.access = wined3daccess_from_d3dpool(pool, usage)
            | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    desc.misc_flags = 0;
    desc.structure_byte_stride = 0;
 
    wined3d_mutex_lock();
    hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
            &d3d9_vertexbuffer_wined3d_parent_ops, &buffer->wined3d_buffer);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d buffer, hr %#x.\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 137 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;
    desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1;
    desc.input_signature.element_count = 0;
    desc.output_signature.element_count = 0;
    desc.patch_constant_signature.element_count = 0;
    desc.max_version = 3;
 
    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 %#x.\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 209 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;
}

volumetexture_init()

HRESULT volumetexture_init	(	struct d3d9_texture *	texture,
		struct d3d9_device *	device,
		UINT	width,
		UINT	height,
		UINT	depth,
		UINT	levels,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 1441 of file texture.c.

{
    struct wined3d_resource_desc desc;
    HRESULT hr;
 
    texture->IDirect3DBaseTexture9_iface.lpVtbl = (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl;
    d3d9_resource_init(&texture->resource);
    list_init(&texture->rtv_list);
    texture->usage = usage;
 
    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 = wined3dusage_from_d3dusage(usage);
    desc.usage |= WINED3DUSAGE_TEXTURE;
    if (pool == D3DPOOL_SCRATCH)
        desc.usage |= WINED3DUSAGE_SCRATCH;
    desc.access = wined3daccess_from_d3dpool(pool, usage);
    desc.width = width;
    desc.height = height;
    desc.depth = depth;
    desc.size = 0;
 
    if (usage & D3DUSAGE_AUTOGENMIPMAP)
    {
        WARN("D3DUSAGE_AUTOGENMIPMAP volume texture is not supported, returning D3DERR_INVALIDCALL.\n");
        return D3DERR_INVALIDCALL;
    }
    if (!levels)
        levels = wined3d_log2i(max(max(width, height), depth)) + 1;
 
    wined3d_mutex_lock();
    hr = wined3d_texture_create(device->wined3d_device, &desc, 1, levels, 0,
            NULL, texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d volume texture, hr %#x.\n", hr);
        return hr;
    }
 
    texture->parent_device = &device->IDirect3DDevice9Ex_iface;
    IDirect3DDevice9Ex_AddRef(texture->parent_device);
 
    return D3D_OK;
}

wined3daccess_from_d3dpool()

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

inlinestatic

Definition at line 315 of file d3d9_private.h.

{
    switch (pool)
    {
        case D3DPOOL_DEFAULT:
            if (usage & D3DUSAGE_DYNAMIC)
                return WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
            return WINED3D_RESOURCE_ACCESS_GPU;
        case D3DPOOL_MANAGED:
            return WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU
                    | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
        case D3DPOOL_SYSTEMMEM:
        case D3DPOOL_SCRATCH:
            return WINED3D_RESOURCE_ACCESS_CPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
        default:
            return 0;
    }
}

wined3dformat_from_d3dformat()

enum wined3d_format_id wined3dformat_from_d3dformat

(

D3DFORMAT

format

)

Definition at line 94 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 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_create_surface(), d3d8_device_DrawIndexedPrimitiveUP(), d3d9_device_create_surface(), d3d9_device_CreateTexture(), d3d9_device_DrawIndexedPrimitiveUP(), d3d9_device_reset(), and wined3d_swapchain_desc_from_present_parameters().

wined3dmapflags_from_d3dmapflags()

unsigned int wined3dmapflags_from_d3dmapflags

(

unsigned int

flags

)

Definition at line 144 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 (!(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_READ | WINED3D_MAP_WRITE;
    flags &= ~(handled | D3DLOCK_READONLY);
 
    if (flags)
        FIXME("Unhandled flags %#x.\n", flags);
 
    return wined3d_flags;
}

wined3dusage_from_d3dusage()

static DWORD wined3dusage_from_d3dusage ( unsigned int  usage )

inlinestatic

Definition at line 334 of file d3d9_private.h.

{
    return usage & WINED3DUSAGE_MASK;
}

Referenced by cubetexture_init(), texture_init(), and volumetexture_init().

Variable Documentation

DECLSPEC_HIDDEN

const struct wined3d_parent_ops d3d9_null_wined3d_parent_ops DECLSPEC_HIDDEN

extern

Definition at line 289 of file d3dcompiler_private.h.