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 "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	COBJMACROS
#define	D3DPRESENTFLAGS_MASK   0x00000fffu
#define	D3D8_MAX_VERTEX_SHADER_CONSTANTF   256
#define	D3D8_MAX_PIXEL_SHADER_CONSTANTF   8
#define	D3D8_MAX_STREAMS   16
#define	D3DFMT_RESZ   MAKEFOURCC('R','E','S','Z')
#define	D3D8_RESZ_CODE   0x7fa05000
#define	VS_HIGHESTFIXEDFXF   0xF0000000
#define	D3D8_INITIAL_HANDLE_TABLE_SIZE   64
#define	D3D8_INVALID_HANDLE   ~0U

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 struct wined3d_caps *wined3d_caps, unsigned int adapter_ordinal)
BOOL	d3d8_init (struct d3d8 *d3d8)
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)
static struct d3d8_device *	impl_from_IDirect3DDevice8 (IDirect3DDevice8 *iface)
void	d3d8_resource_cleanup (struct d3d8_resource *resource)
HRESULT	d3d8_resource_free_private_data (struct d3d8_resource *resource, const GUID *guid)
HRESULT	d3d8_resource_get_private_data (struct d3d8_resource *resource, const GUID *guid, void *data, DWORD *data_size)
void	d3d8_resource_init (struct d3d8_resource *resource)
HRESULT	d3d8_resource_set_private_data (struct d3d8_resource *resource, const GUID *guid, const void *data, DWORD data_size, DWORD flags)
void	volume_init (struct d3d8_volume *volume, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, const struct wined3d_parent_ops **parent_ops)
HRESULT	d3d8_swapchain_create (struct d3d8_device *device, struct wined3d_swapchain_desc *desc, unsigned int swap_interval, struct d3d8_swapchain **swapchain)
struct wined3d_rendertarget_view *	d3d8_surface_acquire_rendertarget_view (struct d3d8_surface *surface)
struct d3d8_surface *	d3d8_surface_create (struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, IUnknown *container)
struct d3d8_device *	d3d8_surface_get_device (const struct d3d8_surface *surface)
void	d3d8_surface_release_rendertarget_view (struct d3d8_surface *surface, struct wined3d_rendertarget_view *rtv)
struct d3d8_surface *	unsafe_impl_from_IDirect3DSurface8 (IDirect3DSurface8 *iface)
HRESULT	vertexbuffer_init (struct d3d8_vertexbuffer *buffer, struct d3d8_device *device, UINT size, DWORD usage, DWORD fvf, D3DPOOL pool)
struct d3d8_vertexbuffer *	unsafe_impl_from_IDirect3DVertexBuffer8 (IDirect3DVertexBuffer8 *iface)
HRESULT	indexbuffer_init (struct d3d8_indexbuffer *buffer, struct d3d8_device *device, UINT size, DWORD usage, D3DFORMAT format, D3DPOOL pool)
struct d3d8_indexbuffer *	unsafe_impl_from_IDirect3DIndexBuffer8 (IDirect3DIndexBuffer8 *iface)
HRESULT	d3d8_texture_2d_init (struct d3d8_texture *texture, struct d3d8_device *device, unsigned int width, unsigned int height, unsigned int level_count, DWORD usage, D3DFORMAT format, D3DPOOL pool)
HRESULT	d3d8_texture_3d_init (struct d3d8_texture *texture, struct d3d8_device *device, unsigned int width, unsigned int height, unsigned int depth, unsigned int levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
HRESULT	d3d8_texture_cube_init (struct d3d8_texture *texture, struct d3d8_device *device, unsigned int edge_length, unsigned int level_count, DWORD usage, D3DFORMAT format, D3DPOOL pool)
static struct wined3d_texture *	d3d8_texture_get_draw_texture (struct d3d8_texture *texture)
struct d3d8_texture *	unsafe_impl_from_IDirect3DBaseTexture8 (IDirect3DBaseTexture8 *iface)
void	d3d8_vertex_declaration_destroy (struct d3d8_vertex_declaration *declaration)
HRESULT	d3d8_vertex_declaration_init (struct d3d8_vertex_declaration *declaration, struct d3d8_device *device, const DWORD *elements, DWORD shader_handle)
HRESULT	d3d8_vertex_declaration_init_fvf (struct d3d8_vertex_declaration *declaration, struct d3d8_device *device, DWORD fvf)
void	d3d8_vertex_shader_destroy (struct d3d8_vertex_shader *shader)
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)
void	d3d8_pixel_shader_destroy (struct d3d8_pixel_shader *shader)
HRESULT	d3d8_pixel_shader_init (struct d3d8_pixel_shader *shader, struct d3d8_device *device, const DWORD *byte_code, DWORD shader_handle)
D3DFORMAT	d3dformat_from_wined3dformat (enum wined3d_format_id format)
enum wined3d_format_id	wined3dformat_from_d3dformat (D3DFORMAT format)
unsigned int	wined3dmapflags_from_d3dmapflags (unsigned int flags, unsigned int usage)
void	load_local_constants (const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader)
size_t	parse_token (const DWORD *pToken)
static DWORD	d3dusage_from_wined3dusage (unsigned int wined3d_usage, unsigned int bind_flags)
static D3DPOOL	d3dpool_from_wined3daccess (unsigned int access, unsigned int usage)
static unsigned int	map_access_from_usage (unsigned int usage)
static unsigned int	wined3daccess_from_d3dpool (D3DPOOL pool, unsigned int usage)
static unsigned int	wined3d_usage_from_d3d (D3DPOOL pool, DWORD usage)
static unsigned int	wined3d_bind_flags_from_d3d8_usage (DWORD usage)
static D3DMULTISAMPLE_TYPE	d3dmultisample_type_from_wined3d (enum wined3d_multisample_type type)
static enum wined3d_device_type	wined3d_device_type_from_d3d (D3DDEVTYPE type)

Variables
const struct wined3d_parent_ops	d3d8_null_wined3d_parent_ops

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 29 of file d3d8_private.h.

D3D8_INITIAL_HANDLE_TABLE_SIZE

#define D3D8_INITIAL_HANDLE_TABLE_SIZE   64

Definition at line 69 of file d3d8_private.h.

D3D8_INVALID_HANDLE

#define D3D8_INVALID_HANDLE   ~0U

Definition at line 70 of file d3d8_private.h.

D3D8_MAX_PIXEL_SHADER_CONSTANTF

#define D3D8_MAX_PIXEL_SHADER_CONSTANTF   8

Definition at line 40 of file d3d8_private.h.

D3D8_MAX_STREAMS

#define D3D8_MAX_STREAMS   16

Definition at line 41 of file d3d8_private.h.

D3D8_MAX_VERTEX_SHADER_CONSTANTF

#define D3D8_MAX_VERTEX_SHADER_CONSTANTF   256

Definition at line 39 of file d3d8_private.h.

D3D8_RESZ_CODE

#define D3D8_RESZ_CODE   0x7fa05000

Definition at line 44 of file d3d8_private.h.

D3DFMT_RESZ

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

Definition at line 43 of file d3d8_private.h.

D3DPRESENTFLAGS_MASK

#define D3DPRESENTFLAGS_MASK   0x00000fffu

Definition at line 37 of file d3d8_private.h.

VS_HIGHESTFIXEDFXF

#define VS_HIGHESTFIXEDFXF   0xF0000000

Definition at line 47 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 100 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 72 of file d3d8_private.h.

{
    D3D8_HANDLE_FREE,
    D3D8_HANDLE_VS,
    D3D8_HANDLE_PS,
    D3D8_HANDLE_SB,
};

Function Documentation

d3d8_init()

BOOL d3d8_init

(

struct d3d8 *

d3d8

)

Definition at line 474 of file directx.c.

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

Referenced by Direct3DCreate8().

d3d8_pixel_shader_destroy()

void d3d8_pixel_shader_destroy

(

struct d3d8_pixel_shader *

shader

)

Definition at line 142 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 156 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;
 
    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 %#lx.\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 149 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 154 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 172 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 210 of file d3d8_main.c.

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

Referenced by d3d8_surface_create(), d3d8_texture_init(), indexbuffer_init(), vertexbuffer_init(), and volume_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 216 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 379 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 %#lx.\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_create()

struct d3d8_surface * d3d8_surface_create	(	struct wined3d_texture *	wined3d_texture,
		unsigned int	sub_resource_idx,
		IUnknown *	container
	)

Definition at line 318 of file surface.c.

{
    IDirect3DBaseTexture8 *texture;
    struct d3d8_surface *surface;
 
    if (!(surface = calloc(1, sizeof(*surface))))
        return NULL;
 
    surface->IDirect3DSurface8_iface.lpVtbl = &d3d8_surface_vtbl;
    d3d8_resource_init(&surface->resource);
    surface->resource.refcount = 0;
    list_init(&surface->rtv_entry);
    surface->container = container;
    surface->wined3d_texture = wined3d_texture;
    surface->sub_resource_idx = sub_resource_idx;
    surface->swapchain = wined3d_texture_get_swapchain(wined3d_texture);
 
    if (surface->container && SUCCEEDED(IUnknown_QueryInterface(surface->container,
            &IID_IDirect3DBaseTexture8, (void **)&texture)))
    {
        surface->texture = unsafe_impl_from_IDirect3DBaseTexture8(texture);
        IDirect3DBaseTexture8_Release(texture);
    }
 
    wined3d_texture_set_sub_resource_parent(wined3d_texture, sub_resource_idx,
            surface, &d3d8_surface_wined3d_parent_ops);
 
    TRACE("Created surface %p.\n", surface);
    return surface;
}

Referenced by d3d8_device_create_surface(), d3d8_device_CreateCubeTexture(), d3d8_device_CreateTexture(), d3d8_device_Reset(), and d3d8_swapchain_create().

d3d8_surface_get_device()

struct d3d8_device * d3d8_surface_get_device

(

const struct d3d8_surface *

surface

)

Definition at line 372 of file surface.c.

{
    IDirect3DDevice8 *device;
    device = surface->texture ? &surface->texture->parent_device->IDirect3DDevice8_iface : 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 405 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,
		unsigned int	swap_interval,
		struct d3d8_swapchain **	swapchain
	)

Definition at line 193 of file swapchain.c.

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

Referenced by d3d8_device_CreateAdditionalSwapChain(), and device_init().

d3d8_texture_2d_init()

HRESULT d3d8_texture_2d_init	(	struct d3d8_texture *	texture,
		struct d3d8_device *	device,
		unsigned int	width,
		unsigned int	height,
		unsigned int	level_count,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 1114 of file texture.c.

{
    struct wined3d_resource_desc desc;
 
    desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
    desc.format = wined3dformat_from_d3dformat(format);
    desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    desc.multisample_quality = 0;
    desc.usage = wined3d_usage_from_d3d(pool, usage);
    desc.bind_flags = wined3d_bind_flags_from_d3d8_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
    desc.access = wined3daccess_from_d3dpool(pool, usage);
    desc.width = width;
    desc.height = height;
    desc.depth = 1;
    desc.size = 0;
 
    if (usage & D3DUSAGE_WRITEONLY)
    {
        WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flag, returning D3DERR_INVALIDCALL.\n");
        return D3DERR_INVALIDCALL;
    }
 
    texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DTexture8_Vtbl;
    return d3d8_texture_init(texture, device, &desc, pool, 1, level_count);
}

Referenced by d3d8_device_CreateTexture().

d3d8_texture_3d_init()

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

Definition at line 1168 of file texture.c.

{
    struct wined3d_resource_desc desc;
 
    /* In d3d8, 3D textures can't be used as rendertarget or depth/stencil buffer. */
    if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
        return D3DERR_INVALIDCALL;
 
    desc.resource_type = WINED3D_RTYPE_TEXTURE_3D;
    desc.format = wined3dformat_from_d3dformat(format);
    desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    desc.multisample_quality = 0;
    desc.usage = wined3d_usage_from_d3d(pool, usage);
    desc.bind_flags = wined3d_bind_flags_from_d3d8_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
    desc.access = wined3daccess_from_d3dpool(pool, usage);
    desc.width = width;
    desc.height = height;
    desc.depth = depth;
    desc.size = 0;
 
    if (usage & D3DUSAGE_WRITEONLY)
    {
        WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flags, returning D3DERR_INVALIDCALL.\n");
        return D3DERR_INVALIDCALL;
    }
 
    texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DVolumeTexture8_Vtbl;
    return d3d8_texture_init(texture, device, &desc, pool, 1, level_count);
}

Referenced by d3d8_device_CreateVolumeTexture().

d3d8_texture_cube_init()

HRESULT d3d8_texture_cube_init	(	struct d3d8_texture *	texture,
		struct d3d8_device *	device,
		unsigned int	edge_length,
		unsigned int	level_count,
		DWORD	usage,
		D3DFORMAT	format,
		D3DPOOL	pool
	)

Definition at line 1141 of file texture.c.

{
    struct wined3d_resource_desc desc;
 
    desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
    desc.format = wined3dformat_from_d3dformat(format);
    desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    desc.multisample_quality = 0;
    desc.usage = wined3d_usage_from_d3d(pool, usage) | WINED3DUSAGE_LEGACY_CUBEMAP;
    desc.bind_flags = wined3d_bind_flags_from_d3d8_usage(usage) | WINED3D_BIND_SHADER_RESOURCE;
    desc.access = wined3daccess_from_d3dpool(pool, usage);
    desc.width = edge_length;
    desc.height = edge_length;
    desc.depth = 1;
    desc.size = 0;
 
    if (usage & D3DUSAGE_WRITEONLY)
    {
        WARN("Texture can't be created with the D3DUSAGE_WRITEONLY flag, returning D3DERR_INVALIDCALL.\n");
        return D3DERR_INVALIDCALL;
    }
 
    texture->IDirect3DBaseTexture8_iface.lpVtbl = (const IDirect3DBaseTexture8Vtbl *)&Direct3DCubeTexture8_Vtbl;
    return d3d8_texture_init(texture, device, &desc, pool, 6, level_count);
}

Referenced by d3d8_device_CreateCubeTexture().

d3d8_texture_get_draw_texture()

static struct wined3d_texture * d3d8_texture_get_draw_texture ( struct d3d8_texture *  texture )

inlinestatic

Definition at line 257 of file d3d8_private.h.

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

Referenced by d3d8_device_SetTexture(), d3d8_texture_2d_GetLOD(), d3d8_texture_2d_GetPriority(), d3d8_texture_2d_SetLOD(), d3d8_texture_2d_SetPriority(), d3d8_texture_3d_GetLOD(), d3d8_texture_3d_GetPriority(), d3d8_texture_3d_SetLOD(), d3d8_texture_3d_SetPriority(), d3d8_texture_cube_GetLOD(), d3d8_texture_cube_GetPriority(), d3d8_texture_cube_SetLOD(), d3d8_texture_cube_SetPriority(), d3d8_texture_decref(), and d3d8_texture_incref().

d3d8_vertex_declaration_destroy()

void d3d8_vertex_declaration_destroy

(

struct d3d8_vertex_declaration *

declaration

)

Definition at line 318 of file vertexdeclaration.c.

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

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 330 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, &declaration->stream_map);
    if (!(declaration->elements = malloc(declaration->elements_size)))
    {
        ERR("Failed to allocate vertex declaration elements memory.\n");
        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();
    free(wined3d_elements);
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d vertex declaration, hr %#lx.\n", hr);
        free(declaration->elements);
        if (hr == E_INVALIDARG)
            hr = E_FAIL;
        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 367 of file vertexdeclaration.c.

{
    HRESULT hr;
 
    declaration->elements = NULL;
    declaration->elements_size = 0;
    declaration->stream_map = 1;
    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 %#lx.\n", hr);
        if (hr == E_INVALIDARG)
            hr = E_FAIL;
        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 31 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 78 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 %#lx.\n", hr);
        return hr;
    }
 
    if (byte_code)
    {
        struct wined3d_shader_desc desc;
 
        if (usage)
            FIXME("Usage %#lx not implemented.\n", usage);
 
        desc.byte_code = byte_code;
        desc.byte_code_size = ~(size_t)0;
 
        wined3d_mutex_lock();
        hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader,
                &d3d8_vertexshader_wined3d_parent_ops, &shader->wined3d_shader);
        wined3d_mutex_unlock();
        if (FAILED(hr))
        {
            WARN("Failed to create wined3d vertex shader, hr %#lx.\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 struct wined3d_caps *	wined3d_caps,
		unsigned int	adapter_ordinal
	)

Definition at line 321 of file device.c.

{
    caps->DeviceType                = (D3DDEVTYPE)wined3d_caps->DeviceType;
    caps->AdapterOrdinal            = adapter_ordinal;
    caps->Caps                      = wined3d_caps->Caps;
    caps->Caps2                     = wined3d_caps->Caps2;
    caps->Caps3                     = wined3d_caps->Caps3;
    caps->PresentationIntervals     = D3DPRESENT_INTERVAL_IMMEDIATE | D3DPRESENT_INTERVAL_ONE;
    caps->CursorCaps                = wined3d_caps->CursorCaps;
    caps->DevCaps                   = wined3d_caps->DevCaps;
    caps->PrimitiveMiscCaps         = wined3d_caps->PrimitiveMiscCaps;
    caps->RasterCaps                = wined3d_caps->RasterCaps;
    caps->ZCmpCaps                  = wined3d_caps->ZCmpCaps;
    caps->SrcBlendCaps              = wined3d_caps->SrcBlendCaps;
    caps->DestBlendCaps             = wined3d_caps->DestBlendCaps;
    caps->AlphaCmpCaps              = wined3d_caps->AlphaCmpCaps;
    caps->ShadeCaps                 = wined3d_caps->ShadeCaps;
    caps->TextureCaps               = wined3d_caps->TextureCaps;
    caps->TextureFilterCaps         = wined3d_caps->TextureFilterCaps;
    caps->CubeTextureFilterCaps     = wined3d_caps->CubeTextureFilterCaps;
    caps->VolumeTextureFilterCaps   = wined3d_caps->VolumeTextureFilterCaps;
    caps->TextureAddressCaps        = wined3d_caps->TextureAddressCaps;
    caps->VolumeTextureAddressCaps  = wined3d_caps->VolumeTextureAddressCaps;
    caps->LineCaps                  = wined3d_caps->LineCaps;
    caps->MaxTextureWidth           = wined3d_caps->MaxTextureWidth;
    caps->MaxTextureHeight          = wined3d_caps->MaxTextureHeight;
    caps->MaxVolumeExtent           = wined3d_caps->MaxVolumeExtent;
    caps->MaxTextureRepeat          = wined3d_caps->MaxTextureRepeat;
    caps->MaxTextureAspectRatio     = wined3d_caps->MaxTextureAspectRatio;
    caps->MaxAnisotropy             = wined3d_caps->MaxAnisotropy;
    caps->MaxVertexW                = wined3d_caps->MaxVertexW;
    caps->GuardBandLeft             = wined3d_caps->GuardBandLeft;
    caps->GuardBandTop              = wined3d_caps->GuardBandTop;
    caps->GuardBandRight            = wined3d_caps->GuardBandRight;
    caps->GuardBandBottom           = wined3d_caps->GuardBandBottom;
    caps->ExtentsAdjust             = wined3d_caps->ExtentsAdjust;
    caps->StencilCaps               = wined3d_caps->StencilCaps;
    caps->FVFCaps                   = wined3d_caps->FVFCaps;
    caps->TextureOpCaps             = wined3d_caps->TextureOpCaps;
    caps->MaxTextureBlendStages     = wined3d_caps->MaxTextureBlendStages;
    caps->MaxSimultaneousTextures   = wined3d_caps->MaxSimultaneousTextures;
    caps->VertexProcessingCaps      = wined3d_caps->VertexProcessingCaps;
    caps->MaxActiveLights           = wined3d_caps->MaxActiveLights;
    caps->MaxUserClipPlanes         = wined3d_caps->MaxUserClipPlanes;
    caps->MaxVertexBlendMatrices    = wined3d_caps->MaxVertexBlendMatrices;
    caps->MaxVertexBlendMatrixIndex = wined3d_caps->MaxVertexBlendMatrixIndex;
    caps->MaxPointSize              = wined3d_caps->MaxPointSize;
    caps->MaxPrimitiveCount         = wined3d_caps->MaxPrimitiveCount;
    caps->MaxVertexIndex            = wined3d_caps->MaxVertexIndex;
    caps->MaxStreams                = wined3d_caps->MaxStreams;
    caps->MaxStreamStride           = wined3d_caps->MaxStreamStride;
    caps->VertexShaderVersion       = wined3d_caps->VertexShaderVersion;
    caps->MaxVertexShaderConst      = wined3d_caps->MaxVertexShaderConst;
    caps->PixelShaderVersion        = wined3d_caps->PixelShaderVersion;
    caps->MaxPixelShaderValue       = wined3d_caps->PixelShader1xMaxValue;
 
    caps->Caps2 &= D3DCAPS2_CANCALIBRATEGAMMA | D3DCAPS2_CANRENDERWINDOWED
            | D3DCAPS2_CANMANAGERESOURCE | D3DCAPS2_DYNAMICTEXTURES | D3DCAPS2_FULLSCREENGAMMA
            | D3DCAPS2_NO2DDURING3DSCENE | D3DCAPS2_RESERVED;
    caps->Caps3 &= D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD | D3DCAPS3_RESERVED;
    caps->PrimitiveMiscCaps &= D3DPMISCCAPS_MASKZ | D3DPMISCCAPS_LINEPATTERNREP
            | D3DPMISCCAPS_CULLNONE | D3DPMISCCAPS_CULLCW | D3DPMISCCAPS_CULLCCW
            | D3DPMISCCAPS_COLORWRITEENABLE | D3DPMISCCAPS_CLIPPLANESCALEDPOINTS
            | D3DPMISCCAPS_CLIPTLVERTS | D3DPMISCCAPS_TSSARGTEMP | D3DPMISCCAPS_BLENDOP
            | D3DPMISCCAPS_NULLREFERENCE;
    caps->RasterCaps &= D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_PAT | D3DPRASTERCAPS_ZTEST
            | D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_FOGTABLE | D3DPRASTERCAPS_ANTIALIASEDGES
            | D3DPRASTERCAPS_MIPMAPLODBIAS | D3DPRASTERCAPS_ZBUFFERLESSHSR
            | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_ANISOTROPY | D3DPRASTERCAPS_WBUFFER
            | D3DPRASTERCAPS_WFOG | D3DPRASTERCAPS_ZFOG | D3DPRASTERCAPS_COLORPERSPECTIVE
            | D3DPRASTERCAPS_STRETCHBLTMULTISAMPLE | WINED3DPRASTERCAPS_DEPTHBIAS;
    if (caps->RasterCaps & WINED3DPRASTERCAPS_DEPTHBIAS)
        caps->RasterCaps = (caps->RasterCaps | D3DPRASTERCAPS_ZBIAS) & ~WINED3DPRASTERCAPS_DEPTHBIAS;
    caps->SrcBlendCaps &= D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR
            | D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA
            | D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR
            | D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA
            | D3DPBLENDCAPS_BOTHINVSRCALPHA;
    caps->DestBlendCaps &= D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR
            | D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA
            | D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR
            | D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA
            | D3DPBLENDCAPS_BOTHINVSRCALPHA;
    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;
    caps->TextureFilterCaps &= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR
            | D3DPTFILTERCAPS_MINFANISOTROPIC | D3DPTFILTERCAPS_MIPFPOINT
            | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | D3DPTFILTERCAPS_MAGFLINEAR
            | D3DPTFILTERCAPS_MAGFANISOTROPIC | D3DPTFILTERCAPS_MAGFAFLATCUBIC
            | D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC;
    caps->CubeTextureFilterCaps &= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR
            | D3DPTFILTERCAPS_MINFANISOTROPIC | D3DPTFILTERCAPS_MIPFPOINT
            | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | D3DPTFILTERCAPS_MAGFLINEAR
            | D3DPTFILTERCAPS_MAGFANISOTROPIC | D3DPTFILTERCAPS_MAGFAFLATCUBIC
            | D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC;
    caps->VolumeTextureFilterCaps &= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR
            | D3DPTFILTERCAPS_MINFANISOTROPIC | D3DPTFILTERCAPS_MIPFPOINT
            | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT | D3DPTFILTERCAPS_MAGFLINEAR
            | D3DPTFILTERCAPS_MAGFANISOTROPIC | D3DPTFILTERCAPS_MAGFAFLATCUBIC
            | D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC;
    if (caps->LineCaps & WINED3DLINECAPS_ANTIALIAS)
        caps->RasterCaps |= D3DPRASTERCAPS_ANTIALIASEDGES;
    caps->LineCaps &= ~WINED3DLINECAPS_ANTIALIAS;
    caps->StencilCaps &= ~WINED3DSTENCILCAPS_TWOSIDED;
    caps->VertexProcessingCaps &= D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7
            | D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER
            | D3DVTXPCAPS_TWEENING | D3DVTXPCAPS_NO_VSDT_UBYTE4;
 
    /* 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);
}

Referenced by d3d8_device_GetDeviceCaps(), and d3d8_GetDeviceCaps().

d3dformat_from_wined3dformat()

D3DFORMAT d3dformat_from_wined3dformat

(

enum wined3d_format_id

format

)

Definition at line 33 of file device.c.

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

Referenced by d3d8_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().

d3dmultisample_type_from_wined3d()

static D3DMULTISAMPLE_TYPE d3dmultisample_type_from_wined3d ( enum wined3d_multisample_type  type )

inlinestatic

Definition at line 387 of file d3d8_private.h.

{
    return (D3DMULTISAMPLE_TYPE)type;
}

Referenced by d3d8_surface_GetDesc(), d3d8_texture_2d_GetLevelDesc(), d3d8_texture_cube_GetLevelDesc(), d3d9_surface_GetDesc(), d3d9_texture_2d_GetLevelDesc(), d3d9_texture_cube_GetLevelDesc(), 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 315 of file d3d8_private.h.

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

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  wined3d_usage, unsigned int  bind_flags  )

inlinestatic

Definition at line 305 of file d3d8_private.h.

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

Referenced by d3d8_surface_GetDesc(), d3d8_texture_2d_GetLevelDesc(), d3d8_texture_3d_GetLevelDesc(), d3d8_texture_cube_GetLevelDesc(), d3d8_volume_GetDesc(), d3d9_surface_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 3667 of file device.c.

{
    struct wined3d_swapchain_desc swapchain_desc;
    struct wined3d_swapchain *wined3d_swapchain;
    struct wined3d_adapter *wined3d_adapter;
    struct wined3d_output *wined3d_output;
    struct d3d8_swapchain *d3d_swapchain;
    struct wined3d_caps caps;
    unsigned int output_idx;
    HRESULT hr;
 
    static const enum wined3d_feature_level feature_levels[] =
    {
        WINED3D_FEATURE_LEVEL_8,
        WINED3D_FEATURE_LEVEL_7,
        WINED3D_FEATURE_LEVEL_6,
        WINED3D_FEATURE_LEVEL_5,
    };
 
    output_idx = adapter;
    if (output_idx >= parent->wined3d_output_count)
        return D3DERR_INVALIDCALL;
 
    device->IDirect3DDevice8_iface.lpVtbl = &d3d8_device_vtbl;
    device->device_parent.ops = &d3d8_wined3d_device_parent_ops;
    device->adapter_ordinal = adapter;
    device->ref = 1;
    if (!(device->handle_table.entries = calloc(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();
    wined3d_output = parent->wined3d_outputs[output_idx];
    wined3d_adapter = wined3d_output_get_adapter(wined3d_output);
    if (FAILED(hr = wined3d_device_create(wined3d, wined3d_adapter, wined3d_device_type_from_d3d(device_type),
            focus_window, flags, 4, feature_levels, ARRAY_SIZE(feature_levels),
            &device->device_parent, &device->wined3d_device)))
    {
        WARN("Failed to create wined3d device, hr %#lx.\n", hr);
        wined3d_mutex_unlock();
        free(device->handle_table.entries);
        return hr;
    }
 
    device->immediate_context = wined3d_device_get_immediate_context(device->wined3d_device);
    wined3d_get_device_caps(wined3d_adapter, wined3d_device_type_from_d3d(device_type), &caps);
    device->max_user_clip_planes = caps.MaxUserClipPlanes;
    device->vs_uniform_count = caps.MaxVertexShaderConst;
 
    if (FAILED(hr = wined3d_stateblock_create(device->wined3d_device, NULL, WINED3D_SBT_PRIMARY, &device->state)))
    {
        ERR("Failed to create primary stateblock, hr %#lx.\n", hr);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        return hr;
    }
    device->stateblock_state = wined3d_stateblock_get_state(device->state);
    device->update_state = device->state;
 
    wined3d_streaming_buffer_init(&device->vertex_buffer, WINED3D_BIND_VERTEX_BUFFER);
    wined3d_streaming_buffer_init(&device->index_buffer, WINED3D_BIND_INDEX_BUFFER);
 
    if (!parameters->Windowed)
    {
        if (!focus_window)
            focus_window = parameters->hDeviceWindow;
        if (FAILED(hr = wined3d_device_acquire_focus_window(device->wined3d_device, focus_window)))
        {
            ERR("Failed to acquire focus window, hr %#lx.\n", hr);
            wined3d_device_decref(device->wined3d_device);
            wined3d_mutex_unlock();
            free(device->handle_table.entries);
            return hr;
        }
    }
 
    if (flags & D3DCREATE_MULTITHREADED)
        wined3d_device_set_multithreaded(device->wined3d_device);
 
    if (!wined3d_swapchain_desc_from_d3d8(&swapchain_desc, wined3d_output, parameters))
    {
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        free(device->handle_table.entries);
        return D3DERR_INVALIDCALL;
    }
    swapchain_desc.flags |= WINED3D_SWAPCHAIN_IMPLICIT;
 
    if (FAILED(hr = d3d8_swapchain_create(device, &swapchain_desc,
            wined3dswapinterval_from_d3d(parameters->FullScreen_PresentationInterval), &d3d_swapchain)))
    {
        WARN("Failed to create implicit swapchain, hr %#lx.\n", hr);
        wined3d_device_release_focus_window(device->wined3d_device);
        wined3d_device_decref(device->wined3d_device);
        wined3d_mutex_unlock();
        free(device->handle_table.entries);
        return hr;
    }
 
    wined3d_swapchain = d3d_swapchain->wined3d_swapchain;
    wined3d_swapchain_incref(wined3d_swapchain);
    IDirect3DSwapChain8_Release(&d3d_swapchain->IDirect3DSwapChain8_iface);
 
    wined3d_stateblock_set_render_state(device->state, WINED3D_RS_ZENABLE,
            !!swapchain_desc.enable_auto_depth_stencil);
    wined3d_stateblock_set_render_state(device->state, WINED3D_RS_POINTSIZE_MIN, 0);
    device_reset_viewport_state(device);
    wined3d_mutex_unlock();
 
    present_parameters_from_wined3d_swapchain_desc(parameters,
            &swapchain_desc, parameters->FullScreen_PresentationInterval);
 
    device->declArraySize = 16;
    if (!(device->decls = malloc(device->declArraySize * sizeof(*device->decls))))
    {
        ERR("Failed to allocate FVF vertex declaration map memory.\n");
        hr = E_OUTOFMEMORY;
        goto err;
    }
 
    device->implicit_swapchain = wined3d_swapchain;
 
    device->d3d_parent = parent;
    IDirect3D8_AddRef(&parent->IDirect3D8_iface);
 
    return D3D_OK;
 
err:
    wined3d_mutex_lock();
    wined3d_swapchain_decref(wined3d_swapchain);
    wined3d_device_release_focus_window(device->wined3d_device);
    wined3d_device_decref(device->wined3d_device);
    wined3d_mutex_unlock();
    free(device->handle_table.entries);
    return hr;
}

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

impl_from_IDirect3DDevice8()

static struct d3d8_device * impl_from_IDirect3DDevice8 ( IDirect3DDevice8 *  iface )

inlinestatic

Definition at line 144 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_CopyRects(), 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 605 of file buffer.c.

{
    struct wined3d_buffer_desc desc;
    HRESULT hr;
 
    if (pool == D3DPOOL_SCRATCH)
        return D3DERR_INVALIDCALL;
 
    /* In d3d8, buffers can't be used as rendertarget or depth/stencil buffer. */
    if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
        return D3DERR_INVALIDCALL;
 
    desc.byte_width = size;
    desc.usage = wined3d_usage_from_d3d(pool, usage) | WINED3DUSAGE_STATICDECL;
    desc.bind_flags = 0;
    desc.access = wined3daccess_from_d3dpool(pool, usage) | map_access_from_usage(usage);
    /* Buffers are always readable. */
    if (pool != D3DPOOL_DEFAULT)
        desc.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    desc.misc_flags = 0;
    desc.structure_byte_stride = 0;
 
    if (desc.access & WINED3D_RESOURCE_ACCESS_GPU)
        desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
 
    buffer->IDirect3DIndexBuffer8_iface.lpVtbl = &d3d8_indexbuffer_vtbl;
    d3d8_resource_init(&buffer->resource);
    buffer->format = wined3dformat_from_d3dformat(format);
    buffer->usage = usage;
    buffer->sysmem = !(desc.access & WINED3D_RESOURCE_ACCESS_GPU);
 
    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 %#lx.\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 146 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[%lu] = (%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().

map_access_from_usage()

static unsigned int map_access_from_usage ( unsigned int  usage )

inlinestatic

Definition at line 334 of file d3d8_private.h.

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

Referenced by indexbuffer_init(), vertexbuffer_init(), and wined3daccess_from_d3dpool().

parse_token()

size_t parse_token

(

const DWORD *

pToken

)

Definition at line 72 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%08lx NOP()\n", token);
            break;
 
        case D3DVSD_TOKEN_STREAM:
            if (token & D3DVSD_STREAMTESSMASK)
            {
                TRACE(" 0x%08lx STREAM_TESS()\n", token);
            } else {
                TRACE(" 0x%08lx STREAM(%lu)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
            }
            break;
 
        case D3DVSD_TOKEN_STREAMDATA:
            if (token & 0x10000000)
            {
                TRACE(" 0x%08lx SKIP(%lu)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
            } else {
                DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
                DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
                TRACE(" 0x%08lx 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%08lx 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%08lx 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%08lx EXT(%lu, %lu)\n", token, count, extinfo);
                /* todo ... print extension */
                tokenlen = count + 1;
            }
            break;
 
        case D3DVSD_TOKEN_END:
            TRACE(" 0x%08lx END()\n", token);
            break;
 
        default:
            TRACE(" 0x%08lx UNKNOWN\n", token);
            /* arg error */
    }
 
    return tokenlen;
}

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

unsafe_impl_from_IDirect3DBaseTexture8()

struct d3d8_texture * unsafe_impl_from_IDirect3DBaseTexture8

(

IDirect3DBaseTexture8 *

iface

)

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

unsafe_impl_from_IDirect3DIndexBuffer8()

struct d3d8_indexbuffer * unsafe_impl_from_IDirect3DIndexBuffer8

(

IDirect3DIndexBuffer8 *

iface

)

Definition at line 653 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 412 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 345 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 284 of file buffer.c.

{
    const struct wined3d_parent_ops *parent_ops = &d3d8_null_wined3d_parent_ops;
    struct wined3d_buffer_desc desc;
    HRESULT hr;
 
    if (pool == D3DPOOL_SCRATCH)
    {
        WARN("Vertex buffer with D3DPOOL_SCRATCH requested.\n");
        return D3DERR_INVALIDCALL;
    }
 
    /* In d3d8, buffers can't be used as rendertarget or depth/stencil buffer. */
    if (usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL))
        return D3DERR_INVALIDCALL;
 
    buffer->IDirect3DVertexBuffer8_iface.lpVtbl = &Direct3DVertexBuffer8_Vtbl;
    d3d8_resource_init(&buffer->resource);
    buffer->fvf = fvf;
    buffer->usage = usage;
 
    desc.byte_width = size;
    desc.usage = wined3d_usage_from_d3d(pool, usage);
    desc.bind_flags = 0;
    desc.access = wined3daccess_from_d3dpool(pool, usage) | map_access_from_usage(usage);
    /* Buffers are always readable. */
    if (pool != D3DPOOL_DEFAULT)
        desc.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    desc.misc_flags = 0;
    desc.structure_byte_stride = 0;
 
    if (desc.access & WINED3D_RESOURCE_ACCESS_GPU)
    {
        desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
        parent_ops = &d3d8_vertexbuffer_wined3d_parent_ops;
    }
 
    wined3d_mutex_lock();
    hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer, parent_ops, &buffer->wined3d_buffer);
    if (SUCCEEDED(hr) && !(desc.access & WINED3D_RESOURCE_ACCESS_GPU))
    {
        desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
        desc.access = WINED3D_RESOURCE_ACCESS_GPU;
        if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc, NULL, buffer,
                &d3d8_vertexbuffer_wined3d_parent_ops, &buffer->draw_buffer)))
            wined3d_buffer_decref(buffer->wined3d_buffer);
    }
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d buffer, hr %#lx.\n", hr);
        return hr;
    }
 
    buffer->parent_device = &device->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 203 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_texture_sub_resource_created().

wined3d_bind_flags_from_d3d8_usage()

static unsigned int wined3d_bind_flags_from_d3d8_usage ( DWORD  usage )

inlinestatic

Definition at line 375 of file d3d8_private.h.

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

Referenced by d3d8_CheckDeviceFormat(), d3d8_texture_2d_init(), d3d8_texture_3d_init(), and d3d8_texture_cube_init().

wined3d_device_type_from_d3d()

static enum wined3d_device_type wined3d_device_type_from_d3d ( D3DDEVTYPE  type )

inlinestatic

Definition at line 392 of file d3d8_private.h.

{
    return (enum wined3d_device_type)type;
}

Referenced by d3d8_CheckDepthStencilMatch(), d3d8_CheckDeviceFormat(), d3d8_CheckDeviceMultiSampleType(), d3d8_CheckDeviceType(), d3d8_GetDeviceCaps(), d3d9_CheckDepthStencilMatch(), d3d9_CheckDeviceFormat(), d3d9_CheckDeviceFormatConversion(), d3d9_CheckDeviceMultiSampleType(), d3d9_CheckDeviceType(), d3d9_GetDeviceCaps(), and device_init().

wined3d_usage_from_d3d()

static unsigned int wined3d_usage_from_d3d ( D3DPOOL  pool, DWORD  usage  )

inlinestatic

Definition at line 365 of file d3d8_private.h.

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

Referenced by d3d8_texture_2d_init(), d3d8_texture_3d_init(), d3d8_texture_cube_init(), d3d9_device_CreateOffscreenPlainSurface(), d3d9_texture_2d_init(), d3d9_texture_3d_init(), d3d9_texture_cube_init(), indexbuffer_init(), and vertexbuffer_init().

wined3daccess_from_d3dpool()

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

inlinestatic

Definition at line 341 of file d3d8_private.h.

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

Referenced by d3d8_texture_2d_init(), d3d8_texture_3d_init(), d3d8_texture_cube_init(), d3d9_device_CreateOffscreenPlainSurface(), d3d9_texture_2d_init(), d3d9_texture_3d_init(), d3d9_texture_cube_init(), indexbuffer_init(), and vertexbuffer_init().

wined3dformat_from_d3dformat()

enum wined3d_format_id wined3dformat_from_d3dformat

(

D3DFORMAT

format

)

Definition at line 84 of file device.c.

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

Referenced by d3d8_CheckDepthStencilMatch(), d3d8_CheckDeviceFormat(), d3d8_CheckDeviceMultiSampleType(), d3d8_CheckDeviceType(), d3d8_texture_2d_init(), d3d8_texture_3d_init(), d3d8_texture_cube_init(), d3d9_CheckDepthStencilMatch(), d3d9_CheckDeviceFormat(), d3d9_CheckDeviceFormatConversion(), d3d9_CheckDeviceMultiSampleType(), d3d9_CheckDeviceType(), d3d9_EnumAdapterModes(), d3d9_EnumAdapterModesEx(), d3d9_GetAdapterModeCount(), d3d9_GetAdapterModeCountEx(), d3d9_texture_2d_init(), d3d9_texture_3d_init(), d3d9_texture_cube_init(), and indexbuffer_init().

wined3dmapflags_from_d3dmapflags()

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

Definition at line 135 of file device.c.

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

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().

Variable Documentation

d3d8_null_wined3d_parent_ops

const struct wined3d_parent_ops d3d8_null_wined3d_parent_ops

extern

Definition at line 28 of file device.c.

Referenced by d3d8_device_create_surface(), d3d8_texture_init(), and vertexbuffer_init().