d3d8_private.h File Reference

#include <assert.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "wine/debug.h"
#include "wine/heap.h"
#include "d3d8.h"
#include "wine/wined3d.h"

Include dependency graph for d3d8_private.h:

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

Go to the source code of this file.

Classes
struct	d3d8
struct	d3d8_handle_entry
struct	d3d8_handle_table
struct	FvfToDecl
struct	d3d8_device
struct	d3d8_resource
struct	d3d8_volume
struct	d3d8_swapchain
struct	d3d8_surface
struct	d3d8_vertexbuffer
struct	d3d8_indexbuffer
struct	d3d8_texture
struct	d3d8_vertex_declaration
struct	d3d8_vertex_shader
struct	d3d8_pixel_shader

Macros
#define	NONAMELESSUNION
#define	NONAMELESSSTRUCT
#define	COBJMACROS
#define	D3DPRESENTFLAGS_MASK   0x00000fffu
#define	VS_HIGHESTFIXEDFXF   0xF0000000
#define	D3D8_INITIAL_HANDLE_TABLE_SIZE   64
#define	D3D8_INVALID_HANDLE   ~0U
#define	D3D8_MAX_VERTEX_SHADER_CONSTANTF   256

Enumerations
enum	d3d8_handle_type { D3D8_HANDLE_FREE , D3D8_HANDLE_VS , D3D8_HANDLE_PS , D3D8_HANDLE_SB }
enum	d3d8_device_state { D3D8_DEVICE_STATE_OK , D3D8_DEVICE_STATE_LOST , D3D8_DEVICE_STATE_NOT_RESET }

Functions
void	d3dcaps_from_wined3dcaps (D3DCAPS8 *caps, const WINED3DCAPS *wined3d_caps) DECLSPEC_HIDDEN
BOOL	d3d8_init (struct d3d8 *d3d8) DECLSPEC_HIDDEN
HRESULT	device_init (struct d3d8_device *device, struct d3d8 *parent, struct wined3d *wined3d, UINT adapter, D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters) DECLSPEC_HIDDEN
static struct d3d8_device *	impl_from_IDirect3DDevice8 (IDirect3DDevice8 *iface)
void	d3d8_resource_cleanup (struct d3d8_resource *resource) DECLSPEC_HIDDEN
HRESULT	d3d8_resource_free_private_data (struct d3d8_resource *resource, const GUID *guid) DECLSPEC_HIDDEN
HRESULT	d3d8_resource_get_private_data (struct d3d8_resource *resource, const GUID *guid, void *data, DWORD *data_size) DECLSPEC_HIDDEN
void	d3d8_resource_init (struct d3d8_resource *resource) DECLSPEC_HIDDEN
HRESULT	d3d8_resource_set_private_data (struct d3d8_resource *resource, const GUID *guid, const void *data, DWORD data_size, DWORD flags) DECLSPEC_HIDDEN
void	volume_init (struct d3d8_volume *volume, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, const struct wined3d_parent_ops **parent_ops) DECLSPEC_HIDDEN
HRESULT	d3d8_swapchain_create (struct d3d8_device *device, struct wined3d_swapchain_desc *desc, struct d3d8_swapchain **swapchain) DECLSPEC_HIDDEN
struct wined3d_rendertarget_view *	d3d8_surface_acquire_rendertarget_view (struct d3d8_surface *surface) DECLSPEC_HIDDEN
struct d3d8_device *	d3d8_surface_get_device (const struct d3d8_surface *surface) DECLSPEC_HIDDEN
void	d3d8_surface_release_rendertarget_view (struct d3d8_surface *surface, struct wined3d_rendertarget_view *rtv) DECLSPEC_HIDDEN
void	surface_init (struct d3d8_surface *surface, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, const struct wined3d_parent_ops **parent_ops) DECLSPEC_HIDDEN
struct d3d8_surface *	unsafe_impl_from_IDirect3DSurface8 (IDirect3DSurface8 *iface) DECLSPEC_HIDDEN
HRESULT	vertexbuffer_init (struct d3d8_vertexbuffer *buffer, struct d3d8_device *device, UINT size, DWORD usage, DWORD fvf, D3DPOOL pool) DECLSPEC_HIDDEN
struct d3d8_vertexbuffer *	unsafe_impl_from_IDirect3DVertexBuffer8 (IDirect3DVertexBuffer8 *iface) DECLSPEC_HIDDEN
HRESULT	indexbuffer_init (struct d3d8_indexbuffer *buffer, struct d3d8_device *device, UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN
struct d3d8_indexbuffer *	unsafe_impl_from_IDirect3DIndexBuffer8 (IDirect3DIndexBuffer8 *iface) DECLSPEC_HIDDEN
HRESULT	cubetexture_init (struct d3d8_texture *texture, struct d3d8_device *device, UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN
HRESULT	texture_init (struct d3d8_texture *texture, struct d3d8_device *device, UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN
HRESULT	volumetexture_init (struct d3d8_texture *texture, struct d3d8_device *device, UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN
struct d3d8_texture *	unsafe_impl_from_IDirect3DBaseTexture8 (IDirect3DBaseTexture8 *iface) DECLSPEC_HIDDEN
void	d3d8_vertex_declaration_destroy (struct d3d8_vertex_declaration *declaration) DECLSPEC_HIDDEN
HRESULT	d3d8_vertex_declaration_init (struct d3d8_vertex_declaration *declaration, struct d3d8_device *device, const DWORD *elements, DWORD shader_handle) DECLSPEC_HIDDEN
HRESULT	d3d8_vertex_declaration_init_fvf (struct d3d8_vertex_declaration *declaration, struct d3d8_device *device, DWORD fvf) DECLSPEC_HIDDEN
void	d3d8_vertex_shader_destroy (struct d3d8_vertex_shader *shader) DECLSPEC_HIDDEN
HRESULT	d3d8_vertex_shader_init (struct d3d8_vertex_shader *shader, struct d3d8_device *device, const DWORD *declaration, const DWORD *byte_code, DWORD shader_handle, DWORD usage) DECLSPEC_HIDDEN
void	d3d8_pixel_shader_destroy (struct d3d8_pixel_shader *shader) DECLSPEC_HIDDEN
HRESULT	d3d8_pixel_shader_init (struct d3d8_pixel_shader *shader, struct d3d8_device *device, const DWORD *byte_code, DWORD shader_handle) DECLSPEC_HIDDEN
D3DFORMAT	d3dformat_from_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	load_local_constants (const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader) DECLSPEC_HIDDEN
size_t	parse_token (const DWORD *pToken) DECLSPEC_HIDDEN
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)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 31 of file d3d8_private.h.

D3D8_INITIAL_HANDLE_TABLE_SIZE

#define D3D8_INITIAL_HANDLE_TABLE_SIZE   64

Definition at line 60 of file d3d8_private.h.

D3D8_INVALID_HANDLE

#define D3D8_INVALID_HANDLE   ~0U

Definition at line 61 of file d3d8_private.h.

D3D8_MAX_VERTEX_SHADER_CONSTANTF

#define D3D8_MAX_VERTEX_SHADER_CONSTANTF   256

Definition at line 262 of file d3d8_private.h.

D3DPRESENTFLAGS_MASK

#define D3DPRESENTFLAGS_MASK   0x00000fffu

Definition at line 40 of file d3d8_private.h.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 30 of file d3d8_private.h.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 29 of file d3d8_private.h.

VS_HIGHESTFIXEDFXF

#define VS_HIGHESTFIXEDFXF   0xF0000000

Definition at line 43 of file d3d8_private.h.

Enumeration Type Documentation

d3d8_device_state

enum d3d8_device_state

Enumerator
D3D8_DEVICE_STATE_OK
D3D8_DEVICE_STATE_LOST
D3D8_DEVICE_STATE_NOT_RESET

Definition at line 91 of file d3d8_private.h.

{
    D3D8_DEVICE_STATE_OK,
    D3D8_DEVICE_STATE_LOST,
    D3D8_DEVICE_STATE_NOT_RESET,
};

d3d8_handle_type

enum d3d8_handle_type

Enumerator
D3D8_HANDLE_FREE
D3D8_HANDLE_VS
D3D8_HANDLE_PS
D3D8_HANDLE_SB

Definition at line 63 of file d3d8_private.h.

{
    D3D8_HANDLE_FREE,
    D3D8_HANDLE_VS,
    D3D8_HANDLE_PS,
    D3D8_HANDLE_SB,
};

Function Documentation

cubetexture_init()

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

Definition at line 1142 of file texture.c.

{
    struct wined3d_resource_desc desc;
    DWORD flags = 0;
    HRESULT hr;
 
    texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl;
    d3d8_resource_init(&texture->resource);
    list_init(&texture->rtv_list);
 
    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 = usage & WINED3DUSAGE_MASK;
    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 (!levels)
        levels = wined3d_log2i(edge_length) + 1;
 
    wined3d_mutex_lock();
    hr = wined3d_texture_create(device->wined3d_device, &desc, 6, levels, flags,
            NULL, texture, &d3d8_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->IDirect3DDevice8_iface;
    IDirect3DDevice8_AddRef(texture->parent_device);
 
    return D3D_OK;
}

Referenced by d3d8_device_CreateCubeTexture(), and d3d9_device_CreateCubeTexture().

d3d8_init()

BOOL d3d8_init

(

struct d3d8 *

d3d8

)

Definition at line 415 of file directx.c.

{
    DWORD flags = WINED3D_LEGACY_DEPTH_BIAS | WINED3D_VIDMEM_ACCOUNTING
            | WINED3D_HANDLE_RESTORE | WINED3D_PIXEL_CENTER_INTEGER
            | WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR | WINED3D_NO_PRIMITIVE_RESTART
            | WINED3D_LEGACY_CUBEMAP_FILTERING | WINED3D_LIMIT_VIEWPORT;
 
    d3d8->IDirect3D8_iface.lpVtbl = &d3d8_vtbl;
    d3d8->refcount = 1;
 
    wined3d_mutex_lock();
    d3d8->wined3d = wined3d_create(flags);
    wined3d_mutex_unlock();
    if (!d3d8->wined3d)
        return FALSE;
 
    return TRUE;
}

Referenced by Direct3DCreate8().

d3d8_pixel_shader_destroy()

void d3d8_pixel_shader_destroy

(

struct d3d8_pixel_shader *

shader

)

Definition at line 148 of file shader.c.

{
    TRACE("shader %p.\n", shader);
 
    wined3d_mutex_lock();
    wined3d_shader_decref(shader->wined3d_shader);
    wined3d_mutex_unlock();
}

Referenced by d3d8_device_DeletePixelShader().

d3d8_pixel_shader_init()

HRESULT d3d8_pixel_shader_init	(	struct d3d8_pixel_shader *	shader,
		struct d3d8_device *	device,
		const DWORD *	byte_code,
		DWORD	shader_handle
	)

Definition at line 162 of file shader.c.

{
    struct wined3d_shader_desc desc;
    HRESULT hr;
 
    shader->handle = shader_handle;
 
    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 = 1;
 
    wined3d_mutex_lock();
    hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader,
            &d3d8_pixelshader_wined3d_parent_ops, &shader->wined3d_shader);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr);
        return hr;
    }
 
    return D3D_OK;
}

Referenced by d3d8_device_CreatePixelShader().

d3d8_resource_cleanup()

void d3d8_resource_cleanup

(

struct d3d8_resource *

resource

)

Definition at line 130 of file d3d8_main.c.

{
    wined3d_private_store_cleanup(&resource->private_store);
}

Referenced by d3d8_indexbuffer_wined3d_object_destroyed(), d3d8_texture_wined3d_object_destroyed(), d3d8_vertexbuffer_wined3d_object_destroyed(), surface_wined3d_object_destroyed(), and volume_wined3d_object_destroyed().

d3d8_resource_free_private_data()

HRESULT d3d8_resource_free_private_data	(	struct d3d8_resource *	resource,
		const GUID *	guid
	)

Definition at line 135 of file d3d8_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 d3d8_indexbuffer_FreePrivateData(), d3d8_surface_FreePrivateData(), d3d8_texture_2d_FreePrivateData(), d3d8_texture_3d_FreePrivateData(), d3d8_texture_cube_FreePrivateData(), d3d8_vertexbuffer_FreePrivateData(), and d3d8_volume_FreePrivateData().

d3d8_resource_get_private_data()

HRESULT d3d8_resource_get_private_data	(	struct d3d8_resource *	resource,
		const GUID *	guid,
		void *	data,
		DWORD *	data_size
	)

Definition at line 153 of file d3d8_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 d3d8_indexbuffer_GetPrivateData(), d3d8_surface_GetPrivateData(), d3d8_texture_2d_GetPrivateData(), d3d8_texture_3d_GetPrivateData(), d3d8_texture_cube_GetPrivateData(), d3d8_vertexbuffer_GetPrivateData(), and d3d8_volume_GetPrivateData().

d3d8_resource_init()

void d3d8_resource_init

(

struct d3d8_resource *

resource

)

Definition at line 191 of file d3d8_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().

d3d8_resource_set_private_data()

HRESULT d3d8_resource_set_private_data	(	struct d3d8_resource *	resource,
		const GUID *	guid,
		const void *	data,
		DWORD	data_size,
		DWORD	flags
	)

Definition at line 197 of file d3d8_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 d3d8_indexbuffer_SetPrivateData(), d3d8_surface_SetPrivateData(), d3d8_texture_2d_SetPrivateData(), d3d8_texture_3d_SetPrivateData(), d3d8_texture_cube_SetPrivateData(), d3d8_vertexbuffer_SetPrivateData(), and d3d8_volume_SetPrivateData().

d3d8_surface_acquire_rendertarget_view()

struct wined3d_rendertarget_view * d3d8_surface_acquire_rendertarget_view

(

struct d3d8_surface *

surface

)

Definition at line 369 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. */
    d3d8_surface_AddRef(&surface->IDirect3DSurface8_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, &d3d8_view_wined3d_parent_ops, &surface->wined3d_rtv)))
    {
        ERR("Failed to create rendertarget view, hr %#x.\n", hr);
        d3d8_surface_Release(&surface->IDirect3DSurface8_iface);
        return NULL;
    }
 
    if (surface->texture)
        list_add_head(&surface->texture->rtv_list, &surface->rtv_entry);
 
    return surface->wined3d_rtv;
}

Referenced by d3d8_device_SetRenderTarget().

d3d8_surface_get_device()

struct d3d8_device * d3d8_surface_get_device

(

const struct d3d8_surface *

surface

)

Definition at line 362 of file surface.c.

{
    IDirect3DDevice8 *device;
    device = surface->texture ? surface->texture->parent_device : surface->parent_device;
    return impl_from_IDirect3DDevice8(device);
}

Referenced by d3d8_device_SetRenderTarget().

d3d8_surface_release_rendertarget_view()

void d3d8_surface_release_rendertarget_view	(	struct d3d8_surface *	surface,
		struct wined3d_rendertarget_view *	rtv
	)

Definition at line 395 of file surface.c.

{
    if (rtv)
        d3d8_surface_Release(&surface->IDirect3DSurface8_iface);
}

Referenced by d3d8_device_SetRenderTarget().

d3d8_swapchain_create()

HRESULT d3d8_swapchain_create	(	struct d3d8_device *	device,
		struct wined3d_swapchain_desc *	desc,
		struct d3d8_swapchain **	swapchain
	)

Definition at line 194 of file swapchain.c.

{
    struct d3d8_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 d3d8_device_CreateAdditionalSwapChain(), and device_parent_create_swapchain().

d3d8_vertex_declaration_destroy()

void d3d8_vertex_declaration_destroy

(

struct d3d8_vertex_declaration *

declaration

)

Definition at line 321 of file vertexdeclaration.c.

{
    TRACE("declaration %p.\n", declaration);
 
    wined3d_mutex_lock();
    wined3d_vertex_declaration_decref(declaration->wined3d_vertex_declaration);
    wined3d_mutex_unlock();
}

Referenced by d3d8_device_get_fvf_declaration(), d3d8_device_Release(), d3d8_vertex_shader_init(), and d3d8_vertexshader_wined3d_object_destroyed().

d3d8_vertex_declaration_init()

HRESULT d3d8_vertex_declaration_init	(	struct d3d8_vertex_declaration *	declaration,
		struct d3d8_device *	device,
		const DWORD *	elements,
		DWORD	shader_handle
	)

Definition at line 335 of file vertexdeclaration.c.

{
    struct wined3d_vertex_element *wined3d_elements;
    UINT wined3d_element_count;
    HRESULT hr;
 
    declaration->shader_handle = shader_handle;
 
    wined3d_element_count = convert_to_wined3d_declaration(elements, &declaration->elements_size, &wined3d_elements);
    if (!(declaration->elements = heap_alloc(declaration->elements_size)))
    {
        ERR("Failed to allocate vertex declaration elements memory.\n");
        heap_free(wined3d_elements);
        return E_OUTOFMEMORY;
    }
 
    memcpy(declaration->elements, elements, declaration->elements_size);
 
    wined3d_mutex_lock();
    hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count,
            declaration, &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
    wined3d_mutex_unlock();
    heap_free(wined3d_elements);
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
        heap_free(declaration->elements);
        return hr;
    }
 
    return D3D_OK;
}

Referenced by d3d8_vertexshader_create_vertexdeclaration().

d3d8_vertex_declaration_init_fvf()

HRESULT d3d8_vertex_declaration_init_fvf	(	struct d3d8_vertex_declaration *	declaration,
		struct d3d8_device *	device,
		DWORD	fvf
	)

Definition at line 369 of file vertexdeclaration.c.

{
    HRESULT hr;
 
    declaration->elements = NULL;
    declaration->elements_size = 0;
    declaration->shader_handle = fvf;
 
    hr = wined3d_vertex_declaration_create_from_fvf(device->wined3d_device, fvf, declaration,
            &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
        return hr;
    }
 
    return D3D_OK;
}

Referenced by d3d8_device_get_fvf_declaration().

d3d8_vertex_shader_destroy()

void d3d8_vertex_shader_destroy

(

struct d3d8_vertex_shader *

shader

)

Definition at line 32 of file shader.c.

{
    TRACE("shader %p.\n", shader);
 
    if (shader->wined3d_shader)
    {
        wined3d_mutex_lock();
        wined3d_shader_decref(shader->wined3d_shader);
        wined3d_mutex_unlock();
    }
    else
    {
        d3d8_vertexshader_wined3d_object_destroyed(shader);
    }
}

Referenced by d3d8_device_DeleteVertexShader().

d3d8_vertex_shader_init()

HRESULT d3d8_vertex_shader_init	(	struct d3d8_vertex_shader *	shader,
		struct d3d8_device *	device,
		const DWORD *	declaration,
		const DWORD *	byte_code,
		DWORD	shader_handle,
		DWORD	usage
	)

Definition at line 79 of file shader.c.

{
    const DWORD *token = declaration;
    HRESULT hr;
 
    /* Test if the vertex declaration is valid. */
    while (D3DVSD_END() != *token)
    {
        D3DVSD_TOKENTYPE token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
 
        if (token_type == D3DVSD_TOKEN_STREAMDATA && !(token_type & 0x10000000))
        {
            DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
            DWORD reg  = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 
            if (reg == D3DVSDE_NORMAL && type != D3DVSDT_FLOAT3 && !byte_code)
            {
                WARN("Attempt to use a non-FLOAT3 normal with the fixed-function function\n");
                return D3DERR_INVALIDCALL;
            }
        }
        token += parse_token(token);
    }
 
    hr = d3d8_vertexshader_create_vertexdeclaration(device, declaration, shader_handle, &shader->vertex_declaration);
    if (FAILED(hr))
    {
        WARN("Failed to create vertex declaration, hr %#x.\n", hr);
        return hr;
    }
 
    if (byte_code)
    {
        struct wined3d_shader_desc desc;
 
        if (usage)
            FIXME("Usage %#x not implemented.\n", usage);
 
        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 = 1;
 
        wined3d_mutex_lock();
        hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader,
                &d3d8_vertexshader_wined3d_parent_ops, &shader->wined3d_shader);
        wined3d_mutex_unlock();
        if (FAILED(hr))
        {
            WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
            d3d8_vertex_declaration_destroy(shader->vertex_declaration);
            return hr;
        }
 
        load_local_constants(declaration, shader->wined3d_shader);
    }
 
    return D3D_OK;
}

Referenced by d3d8_device_CreateVertexShader().

d3dcaps_from_wined3dcaps()

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

Definition at line 290 of file device.c.

{
    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->MaxPixelShaderValue       = wined3d_caps->PixelShader1xMaxValue;
 
    /* D3D8 doesn't support SM 2.0 or higher, so clamp to 1.x */
    if (caps->PixelShaderVersion)
        caps->PixelShaderVersion = D3DPS_VERSION(1, 4);
    else
        caps->PixelShaderVersion = D3DPS_VERSION(0, 0);
    if (caps->VertexShaderVersion)
        caps->VertexShaderVersion = D3DVS_VERSION(1, 1);
    else
        caps->VertexShaderVersion = D3DVS_VERSION(0, 0);
    caps->MaxVertexShaderConst = min(D3D8_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst);
 
    caps->StencilCaps &= ~WINED3DSTENCILCAPS_TWOSIDED;
}

Referenced by d3d8_device_GetDeviceCaps(), d3d8_GetDeviceCaps(), d3d9_device_GetDeviceCaps(), and d3d9_GetDeviceCaps().

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_EnumAdapterModes(), d3d8_GetAdapterDisplayMode(), d3d8_indexbuffer_GetDesc(), d3d8_surface_GetDesc(), d3d8_texture_2d_GetLevelDesc(), d3d8_texture_3d_GetLevelDesc(), d3d8_texture_cube_GetLevelDesc(), d3d8_volume_GetDesc(), d3d9_EnumAdapterModes(), d3d9_EnumAdapterModesEx(), d3d9_GetAdapterDisplayMode(), d3d9_GetAdapterDisplayModeEx(), d3d9_indexbuffer_GetDesc(), d3d9_surface_GetDesc(), d3d9_swapchain_GetDisplayMode(), d3d9_swapchain_GetDisplayModeEx(), d3d9_texture_2d_GetLevelDesc(), d3d9_texture_3d_GetLevelDesc(), d3d9_texture_cube_GetLevelDesc(), and d3d9_volume_GetDesc().

d3dpool_from_wined3daccess()

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

inlinestatic

Definition at line 285 of file d3d8_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;
    }
}

Referenced by d3d8_indexbuffer_GetDesc(), d3d8_surface_GetDesc(), d3d8_texture_2d_GetLevelDesc(), d3d8_texture_3d_GetLevelDesc(), d3d8_texture_cube_GetLevelDesc(), d3d8_vertexbuffer_GetDesc(), d3d8_volume_GetDesc(), d3d9_indexbuffer_GetDesc(), d3d9_surface_GetDesc(), d3d9_texture_2d_GetLevelDesc(), d3d9_texture_3d_GetLevelDesc(), d3d9_texture_cube_GetLevelDesc(), d3d9_vertexbuffer_GetDesc(), and d3d9_volume_GetDesc().

d3dusage_from_wined3dusage()

static DWORD d3dusage_from_wined3dusage ( unsigned int  usage )

inlinestatic

Definition at line 280 of file d3d8_private.h.

{
    return usage & WINED3DUSAGE_MASK;
}

Referenced by d3d8_indexbuffer_GetDesc(), d3d8_surface_GetDesc(), d3d8_texture_2d_GetLevelDesc(), d3d8_texture_3d_GetLevelDesc(), d3d8_texture_cube_GetLevelDesc(), d3d8_vertexbuffer_GetDesc(), d3d8_volume_GetDesc(), d3d9_indexbuffer_GetDesc(), d3d9_surface_GetDesc(), d3d9_vertexbuffer_GetDesc(), and d3d9_volume_GetDesc().

device_init()

HRESULT device_init	(	struct d3d8_device *	device,
		struct d3d8 *	parent,
		struct wined3d *	wined3d,
		UINT	adapter,
		D3DDEVTYPE	device_type,
		HWND	focus_window,
		DWORD	flags,
		D3DPRESENT_PARAMETERS *	parameters
	)

Definition at line 3279 of file device.c.

{
    struct wined3d_swapchain_desc swapchain_desc;
    struct wined3d_swapchain *wined3d_swapchain;
    HRESULT hr;
 
    device->IDirect3DDevice8_iface.lpVtbl = &d3d8_device_vtbl;
    device->device_parent.ops = &d3d8_wined3d_device_parent_ops;
    device->ref = 1;
    if (!(device->handle_table.entries = heap_alloc_zero(D3D8_INITIAL_HANDLE_TABLE_SIZE
            * sizeof(*device->handle_table.entries))))
    {
        ERR("Failed to allocate handle table memory.\n");
        return E_OUTOFMEMORY;
    }
    device->handle_table.table_size = D3D8_INITIAL_HANDLE_TABLE_SIZE;
 
    if (!(flags & D3DCREATE_FPU_PRESERVE)) setup_fpu();
 
    wined3d_mutex_lock();
    hr = wined3d_device_create(wined3d, adapter, device_type, focus_window, flags, 4,
            &device->device_parent, &device->wined3d_device);
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d device, hr %#x.\n", hr);
        wined3d_mutex_unlock();
        heap_free(device->handle_table.entries);
        return hr;
    }
 
    if (!parameters->Windowed)
    {
        HWND device_window = parameters->hDeviceWindow;
 
        if (!focus_window)
            focus_window = device_window;
        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();
            heap_free(device->handle_table.entries);
            return hr;
        }
 
        if (!device_window)
            device_window = focus_window;
        wined3d_device_setup_fullscreen_window(device->wined3d_device, device_window,
                parameters->BackBufferWidth,
                parameters->BackBufferHeight);
    }
 
    if (flags & D3DCREATE_MULTITHREADED)
        wined3d_device_set_multithreaded(device->wined3d_device);
 
    if (!wined3d_swapchain_desc_from_present_parameters(&swapchain_desc, parameters))
    {
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        heap_free(device->handle_table.entries);
        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);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        heap_free(device->handle_table.entries);
        return hr;
    }
 
    wined3d_device_set_render_state(device->wined3d_device,
            WINED3D_RS_ZENABLE, !!swapchain_desc.enable_auto_depth_stencil);
    wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_POINTSIZE_MIN, 0);
    wined3d_mutex_unlock();
 
    present_parameters_from_wined3d_swapchain_desc(parameters, &swapchain_desc);
 
    device->declArraySize = 16;
    if (!(device->decls = heap_alloc(device->declArraySize * sizeof(*device->decls))))
    {
        ERR("Failed to allocate FVF vertex declaration map memory.\n");
        hr = E_OUTOFMEMORY;
        goto err;
    }
 
    wined3d_swapchain = wined3d_device_get_swapchain(device->wined3d_device, 0);
    device->implicit_swapchain = wined3d_swapchain_get_parent(wined3d_swapchain);
 
    device->d3d_parent = &parent->IDirect3D8_iface;
    IDirect3D8_AddRef(device->d3d_parent);
 
    return D3D_OK;
 
err:
    wined3d_mutex_lock();
    wined3d_device_uninit_3d(device->wined3d_device);
    wined3d_device_release_focus_window(device->wined3d_device);
    wined3d_device_decref(device->wined3d_device);
    wined3d_mutex_unlock();
    heap_free(device->handle_table.entries);
    return hr;
}

Referenced by d3d8_CreateDevice(), d3d9_CreateDevice(), d3d9_CreateDeviceEx(), and wined3d_device_create().

impl_from_IDirect3DDevice8()

static struct d3d8_device * impl_from_IDirect3DDevice8 ( IDirect3DDevice8 *  iface )

inlinestatic

Definition at line 132 of file d3d8_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d8_device, IDirect3DDevice8_iface);
}

Referenced by d3d8_device_AddRef(), d3d8_device_ApplyStateBlock(), d3d8_device_BeginScene(), d3d8_device_BeginStateBlock(), d3d8_device_CaptureStateBlock(), d3d8_device_Clear(), d3d8_device_CreateAdditionalSwapChain(), d3d8_device_CreateCubeTexture(), d3d8_device_CreateDepthStencilSurface(), d3d8_device_CreateImageSurface(), d3d8_device_CreateIndexBuffer(), d3d8_device_CreatePixelShader(), d3d8_device_CreateRenderTarget(), d3d8_device_CreateStateBlock(), d3d8_device_CreateTexture(), d3d8_device_CreateVertexBuffer(), d3d8_device_CreateVertexShader(), d3d8_device_CreateVolumeTexture(), d3d8_device_DeletePixelShader(), d3d8_device_DeleteStateBlock(), d3d8_device_DeleteVertexShader(), d3d8_device_DrawIndexedPrimitive(), d3d8_device_DrawIndexedPrimitiveUP(), d3d8_device_DrawPrimitive(), d3d8_device_DrawPrimitiveUP(), d3d8_device_EndScene(), d3d8_device_EndStateBlock(), d3d8_device_GetAvailableTextureMem(), d3d8_device_GetBackBuffer(), d3d8_device_GetClipPlane(), d3d8_device_GetClipStatus(), d3d8_device_GetCreationParameters(), d3d8_device_GetDepthStencilSurface(), d3d8_device_GetDeviceCaps(), d3d8_device_GetDirect3D(), d3d8_device_GetDisplayMode(), d3d8_device_GetFrontBuffer(), d3d8_device_GetGammaRamp(), d3d8_device_GetIndices(), d3d8_device_GetLight(), d3d8_device_GetLightEnable(), d3d8_device_GetMaterial(), d3d8_device_GetPixelShader(), d3d8_device_GetPixelShaderConstant(), d3d8_device_GetPixelShaderFunction(), d3d8_device_GetRasterStatus(), d3d8_device_GetRenderState(), d3d8_device_GetRenderTarget(), d3d8_device_GetStreamSource(), d3d8_device_GetTexture(), d3d8_device_GetTextureStageState(), d3d8_device_GetTransform(), d3d8_device_GetVertexShader(), d3d8_device_GetVertexShaderConstant(), d3d8_device_GetVertexShaderDeclaration(), d3d8_device_GetVertexShaderFunction(), d3d8_device_GetViewport(), d3d8_device_LightEnable(), d3d8_device_MultiplyTransform(), d3d8_device_Present(), d3d8_device_ProcessVertices(), d3d8_device_Release(), d3d8_device_Reset(), d3d8_device_ResourceManagerDiscardBytes(), d3d8_device_SetClipPlane(), d3d8_device_SetClipStatus(), d3d8_device_SetCursorPosition(), d3d8_device_SetCursorProperties(), d3d8_device_SetGammaRamp(), d3d8_device_SetIndices(), d3d8_device_SetLight(), d3d8_device_SetMaterial(), d3d8_device_SetPixelShader(), d3d8_device_SetPixelShaderConstant(), d3d8_device_SetRenderState(), d3d8_device_SetRenderTarget(), d3d8_device_SetStreamSource(), d3d8_device_SetTexture(), d3d8_device_SetTextureStageState(), d3d8_device_SetTransform(), d3d8_device_SetVertexShader(), d3d8_device_SetVertexShaderConstant(), d3d8_device_SetViewport(), d3d8_device_ShowCursor(), d3d8_device_TestCooperativeLevel(), d3d8_device_UpdateTexture(), d3d8_device_ValidateDevice(), d3d8_surface_get_device(), and d3d8_swapchain_Present().

indexbuffer_init()

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

Definition at line 570 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->IDirect3DIndexBuffer8_iface.lpVtbl = &d3d8_indexbuffer_vtbl;
    d3d8_resource_init(&buffer->resource);
    buffer->format = wined3dformat_from_d3dformat(format);
 
    wined3d_mutex_lock();
    hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
            &d3d8_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->IDirect3DDevice8_iface;
    IDirect3DDevice8_AddRef(buffer->parent_device);
 
    return D3D_OK;
}

Referenced by d3d8_device_CreateIndexBuffer(), and d3d9_device_CreateIndexBuffer().

load_local_constants()

void load_local_constants	(	const DWORD *	d3d8_elements,
		struct wined3d_shader *	wined3d_vertex_shader
	)

Definition at line 152 of file vertexdeclaration.c.

{
    const DWORD *token = d3d8_elements;
 
    while (*token != D3DVSD_END())
    {
        if (((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) == D3DVSD_TOKEN_CONSTMEM)
        {
            DWORD count = ((*token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
            DWORD constant_idx = ((*token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
            HRESULT hr;
 
            if (TRACE_ON(d3d8))
            {
                DWORD i;
                for (i = 0; i < count; ++i)
                {
                    TRACE("c[%u] = (%8f, %8f, %8f, %8f)\n",
                            constant_idx,
                            *(const float *)(token + i * 4 + 1),
                            *(const float *)(token + i * 4 + 2),
                            *(const float *)(token + i * 4 + 3),
                            *(const float *)(token + i * 4 + 4));
                }
            }
            hr = wined3d_shader_set_local_constants_float(wined3d_vertex_shader,
                    constant_idx, (const float *)token + 1, count);
            if (FAILED(hr)) ERR("Failed setting shader constants\n");
        }
 
        token += parse_token(token);
    }
}

Referenced by d3d8_vertex_shader_init().

parse_token()

size_t parse_token

(

const DWORD *

pToken

)

Definition at line 78 of file vertexdeclaration.c.

{
    const DWORD token = *pToken;
    size_t tokenlen = 1;
 
    switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
        case D3DVSD_TOKEN_NOP:
            TRACE(" 0x%08x NOP()\n", token);
            break;
 
        case D3DVSD_TOKEN_STREAM:
            if (token & D3DVSD_STREAMTESSMASK)
            {
                TRACE(" 0x%08x STREAM_TESS()\n", token);
            } else {
                TRACE(" 0x%08x STREAM(%u)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
            }
            break;
 
        case D3DVSD_TOKEN_STREAMDATA:
            if (token & 0x10000000)
            {
                TRACE(" 0x%08x SKIP(%u)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
            } else {
                DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
                DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
                TRACE(" 0x%08x REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
            }
            break;
 
        case D3DVSD_TOKEN_TESSELLATOR:
            if (token & 0x10000000)
            {
                DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
                DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
                TRACE(" 0x%08x TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
            } else {
                DWORD type = ((token & D3DVSD_DATATYPEMASK)    >> D3DVSD_DATATYPESHIFT);
                DWORD regout = ((token & D3DVSD_VERTEXREGMASK)   >> D3DVSD_VERTEXREGSHIFT);
                DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
                TRACE(" 0x%08x TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin),
                        debug_d3dvsde_register(regout), debug_d3dvsdt_type(type));
            }
            break;
 
        case D3DVSD_TOKEN_CONSTMEM:
            {
                DWORD count = ((token & D3DVSD_CONSTCOUNTMASK)   >> D3DVSD_CONSTCOUNTSHIFT);
                tokenlen = (4 * count) + 1;
            }
            break;
 
        case D3DVSD_TOKEN_EXT:
            {
                DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
                DWORD extinfo = ((token & D3DVSD_EXTINFOMASK)    >> D3DVSD_EXTINFOSHIFT);
                TRACE(" 0x%08x EXT(%u, %u)\n", token, count, extinfo);
                /* todo ... print extension */
                tokenlen = count + 1;
            }
            break;
 
        case D3DVSD_TOKEN_END:
            TRACE(" 0x%08x END()\n", token);
            break;
 
        default:
            TRACE(" 0x%08x UNKNOWN\n", token);
            /* arg error */
    }
 
    return tokenlen;
}

Referenced by convert_to_wined3d_declaration(), d3d8_vertex_shader_init(), and load_local_constants().

surface_init()

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

Definition at line 317 of file surface.c.

{
    IDirect3DBaseTexture8 *texture;
 
    surface->IDirect3DSurface8_iface.lpVtbl = &d3d8_surface_vtbl;
    d3d8_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_IDirect3DBaseTexture8, (void **)&texture)))
    {
        surface->texture = unsafe_impl_from_IDirect3DBaseTexture8(texture);
        IDirect3DBaseTexture8_Release(texture);
    }
 
    *parent_ops = &d3d8_surface_wined3d_parent_ops;
}

Referenced by device_parent_surface_created().

texture_init()

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

Definition at line 1094 of file texture.c.

{
    struct wined3d_resource_desc desc;
    DWORD flags = 0;
    HRESULT hr;
 
    texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl;
    d3d8_resource_init(&texture->resource);
    list_init(&texture->rtv_list);
 
    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 = usage & WINED3DUSAGE_MASK;
    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 (!levels)
        levels = wined3d_log2i(max(width, height)) + 1;
 
    wined3d_mutex_lock();
    hr = wined3d_texture_create(device->wined3d_device, &desc, 1, levels, flags,
            NULL, texture, &d3d8_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->IDirect3DDevice8_iface;
    IDirect3DDevice8_AddRef(texture->parent_device);
 
    return D3D_OK;
}

Referenced by d3d8_device_CreateTexture(), d3d9_device_CreateTexture(), and wined3d_texture_create().

unsafe_impl_from_IDirect3DBaseTexture8()

struct d3d8_texture * unsafe_impl_from_IDirect3DBaseTexture8

(

IDirect3DBaseTexture8 *

iface

)

Definition at line 1061 of file texture.c.

{
    if (!iface)
        return NULL;
 
    /* SetTexture() in particular doesn't do a lot of validation on the pointer
     * that gets passed in, and passing an invalid pointer works as long as the
     * application doesn't try to actually render anything with it, so we print
     * a WARN and return NULL instead of having the usual assert() here.
     * One application affected by this is Fishdom 2. */
    if (iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl
            && iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl
            && iface->lpVtbl != (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl)
    {
        WARN("%p is not a valid IDirect3DBaseTexture8 interface.\n", iface);
        return NULL;
    }
 
    return CONTAINING_RECORD(iface, struct d3d8_texture, IDirect3DBaseTexture8_iface);
}

Referenced by d3d8_device_SetTexture(), d3d8_device_UpdateTexture(), and surface_init().

unsafe_impl_from_IDirect3DIndexBuffer8()

struct d3d8_indexbuffer * unsafe_impl_from_IDirect3DIndexBuffer8

(

IDirect3DIndexBuffer8 *

iface

)

Definition at line 606 of file buffer.c.

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

Referenced by d3d8_device_SetIndices().

unsafe_impl_from_IDirect3DSurface8()

struct d3d8_surface * unsafe_impl_from_IDirect3DSurface8

(

IDirect3DSurface8 *

iface

)

Definition at line 402 of file surface.c.

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

Referenced by d3d8_device_CopyRects(), d3d8_device_GetFrontBuffer(), d3d8_device_SetCursorProperties(), and d3d8_device_SetRenderTarget().

unsafe_impl_from_IDirect3DVertexBuffer8()

struct d3d8_vertexbuffer * unsafe_impl_from_IDirect3DVertexBuffer8

(

IDirect3DVertexBuffer8 *

iface

)

Definition at line 313 of file buffer.c.

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

Referenced by d3d8_device_ProcessVertices(), and d3d8_device_SetStreamSource().

vertexbuffer_init()

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

Definition at line 273 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->IDirect3DVertexBuffer8_iface.lpVtbl = &Direct3DVertexBuffer8_Vtbl;
    d3d8_resource_init(&buffer->resource);
    buffer->fvf = fvf;
 
    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,
            &d3d8_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->IDirect3DDevice8_iface;
    IDirect3DDevice8_AddRef(buffer->parent_device);
 
    return D3D_OK;
}

Referenced by d3d8_device_CreateVertexBuffer(), and d3d9_device_CreateVertexBuffer().

volume_init()

void volume_init	(	struct d3d8_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->IDirect3DVolume8_iface.lpVtbl = &d3d8_volume_vtbl;
    d3d8_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 = &d3d8_volume_wined3d_parent_ops;
}

Referenced by device_parent_volume_created().

volumetexture_init()

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

Definition at line 1190 of file texture.c.

{
    struct wined3d_resource_desc desc;
    HRESULT hr;
 
    texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl;
    d3d8_resource_init(&texture->resource);
    list_init(&texture->rtv_list);
 
    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 = usage & WINED3DUSAGE_MASK;
    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 (!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, &d3d8_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->IDirect3DDevice8_iface;
    IDirect3DDevice8_AddRef(texture->parent_device);
 
    return D3D_OK;
}

Referenced by d3d8_device_CreateVolumeTexture(), d3d9_device_CreateVolumeTexture(), and wined3d_texture_create().

wined3daccess_from_d3dpool()

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

inlinestatic

Definition at line 301 of file d3d8_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;
    }
}

Referenced by cubetexture_init(), d3d8_device_create_surface(), d3d9_device_create_surface(), indexbuffer_init(), texture_init(), vertexbuffer_init(), and volumetexture_init().

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 cubetexture_init(), d3d8_CheckDepthStencilMatch(), d3d8_CheckDeviceFormat(), d3d8_CheckDeviceMultiSampleType(), d3d8_CheckDeviceType(), d3d9_CheckDepthStencilMatch(), d3d9_CheckDeviceFormat(), d3d9_CheckDeviceFormatConversion(), d3d9_CheckDeviceMultiSampleType(), d3d9_CheckDeviceType(), d3d9_EnumAdapterModes(), d3d9_EnumAdapterModesEx(), d3d9_GetAdapterModeCount(), d3d9_GetAdapterModeCountEx(), indexbuffer_init(), texture_init(), and volumetexture_init().

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

Referenced by d3d8_indexbuffer_Lock(), d3d8_surface_LockRect(), d3d8_vertexbuffer_Lock(), d3d8_volume_LockBox(), d3d9_indexbuffer_Lock(), d3d9_surface_LockRect(), d3d9_vertexbuffer_Lock(), and d3d9_volume_LockBox().