#include "wine/debug.h"
#include <assert.h>
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "objbase.h"
#include "dxgi1_6.h"
#include "d3d11_4.h"
#include "wine/wined3d.h"
#include "wine/winedxgi.h"
#include "wine/rbtree.h"

Include dependency graph for d3d11_private.h:

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

Go to the source code of this file.

Classes
struct	d3d_texture1d

struct	d3d_texture2d

struct	d3d_texture3d

struct	d3d_buffer

struct	d3d_depthstencil_view

struct	d3d_rendertarget_view

struct	d3d_shader_resource_view

struct	d3d11_unordered_access_view

struct	d3d_video_decoder_output_view

struct	d3d_input_layout

struct	d3d_vertex_shader

struct	d3d11_hull_shader

struct	d3d11_domain_shader

struct	d3d_geometry_shader

struct	d3d_pixel_shader

struct	d3d11_compute_shader

struct	d3d11_class_linkage

struct	d3d_blend_state

struct	d3d_depthstencil_state

struct	d3d_rasterizer_state

struct	d3d_sampler_state

struct	d3d_query

struct	d3d_device_context_state_entry

struct	d3d_device_context_state

struct	d3d11_device_context

struct	d3d_device

struct	d3d11_command_list

struct	d3d_video_decoder

struct	layer_get_size_args

struct	dxgi_device_layer

Macros
#define	COBJMACROS

Enumerations
enum	dxgi_device_layer_id { DXGI_DEVICE_LAYER_DEBUG1 = 0x8 , DXGI_DEVICE_LAYER_THREAD_SAFE = 0x10 , DXGI_DEVICE_LAYER_DEBUG2 = 0x20 , DXGI_DEVICE_LAYER_SWITCH_TO_REF = 0x30 , DXGI_DEVICE_LAYER_D3D10_DEVICE = 0xffffffff , DXGI_DEVICE_LAYER_DEBUG1 = 0x8 , DXGI_DEVICE_LAYER_THREAD_SAFE = 0x10 , DXGI_DEVICE_LAYER_DEBUG2 = 0x20 , DXGI_DEVICE_LAYER_SWITCH_TO_REF = 0x30 , DXGI_DEVICE_LAYER_D3D10_DEVICE = 0xffffffff }

Functions
const char *	debug_d3d10_primitive_topology (D3D10_PRIMITIVE_TOPOLOGY topology)

const char *	debug_dxgi_format (DXGI_FORMAT format)

const char *	debug_float4 (const float *values)

DXGI_FORMAT	dxgi_format_from_wined3dformat (enum wined3d_format_id format)

enum wined3d_format_id	wined3dformat_from_dxgi_format (DXGI_FORMAT format)

void	d3d11_primitive_topology_from_wined3d_primitive_type (enum wined3d_primitive_type primitive_type, unsigned int patch_vertex_count, D3D11_PRIMITIVE_TOPOLOGY *topology)

void	wined3d_primitive_type_from_d3d11_primitive_topology (D3D11_PRIMITIVE_TOPOLOGY topology, enum wined3d_primitive_type type, unsigned int patch_vertex_count)

unsigned int	wined3d_getdata_flags_from_d3d11_async_getdata_flags (unsigned int d3d11_flags)

DWORD	wined3d_usage_from_d3d11 (enum D3D11_USAGE usage)

struct wined3d_resource *	wined3d_resource_from_d3d11_resource (ID3D11Resource *resource)

struct wined3d_resource *	wined3d_resource_from_d3d10_resource (ID3D10Resource *resource)

DWORD	wined3d_map_flags_from_d3d11_map_type (D3D11_MAP map_type)

DWORD	wined3d_map_flags_from_d3d10_map_type (D3D10_MAP map_type)

DWORD	wined3d_clear_flags_from_d3d11_clear_flags (UINT clear_flags)

unsigned int	wined3d_access_from_d3d11 (D3D11_USAGE usage, UINT cpu_access)

HRESULT	d3d_device_create_dxgi_resource (IUnknown device, struct wined3d_resource wined3d_resource, IUnknown outer, BOOL needs_surface, IUnknown *dxgi_resource)

enum D3D11_USAGE	d3d11_usage_from_d3d10_usage (enum D3D10_USAGE usage)

enum D3D10_USAGE	d3d10_usage_from_d3d11_usage (enum D3D11_USAGE usage)

UINT	d3d11_bind_flags_from_d3d10_bind_flags (UINT bind_flags)

UINT	d3d10_bind_flags_from_d3d11_bind_flags (UINT bind_flags)

UINT	d3d11_cpu_access_flags_from_d3d10_cpu_access_flags (UINT cpu_access_flags)

UINT	d3d10_cpu_access_flags_from_d3d11_cpu_access_flags (UINT cpu_access_flags)

UINT	d3d11_resource_misc_flags_from_d3d10_resource_misc_flags (UINT resource_misc_flags)

UINT	d3d10_resource_misc_flags_from_d3d11_resource_misc_flags (UINT resource_misc_flags)

BOOL	validate_d3d11_resource_access_flags (D3D11_RESOURCE_DIMENSION resource_dimension, D3D11_USAGE usage, UINT bind_flags, UINT cpu_access_flags, D3D_FEATURE_LEVEL feature_level)

HRESULT	d3d_get_private_data (struct wined3d_private_store store, REFGUID guid, UINT data_size, void *data)

HRESULT	d3d_set_private_data (struct wined3d_private_store store, REFGUID guid, UINT data_size, const void data)

HRESULT	d3d_set_private_data_interface (struct wined3d_private_store store, REFGUID guid, const IUnknown object)

static unsigned int	wined3d_bind_flags_from_d3d11 (UINT bind_flags, UINT misc_flags)

static UINT	d3d11_bind_flags_from_wined3d (unsigned int bind_flags)

HRESULT	d3d_texture1d_create (struct d3d_device device, const D3D11_TEXTURE1D_DESC desc, const D3D11_SUBRESOURCE_DATA data, struct d3d_texture1d *texture)

struct d3d_texture1d *	unsafe_impl_from_ID3D11Texture1D (ID3D11Texture1D *iface)

struct d3d_texture1d *	unsafe_impl_from_ID3D10Texture1D (ID3D10Texture1D *iface)

static struct d3d_texture2d *	impl_from_ID3D11Texture2D (ID3D11Texture2D *iface)

HRESULT	d3d_texture2d_create (struct d3d_device device, const D3D11_TEXTURE2D_DESC desc, struct wined3d_texture wined3d_texture, const D3D11_SUBRESOURCE_DATA data, struct d3d_texture2d **out)

struct d3d_texture2d *	unsafe_impl_from_ID3D11Texture2D (ID3D11Texture2D *iface)

struct d3d_texture2d *	unsafe_impl_from_ID3D10Texture2D (ID3D10Texture2D *iface)

HRESULT	d3d_texture3d_create (struct d3d_device device, const D3D11_TEXTURE3D_DESC desc, const D3D11_SUBRESOURCE_DATA data, struct d3d_texture3d *texture)

struct d3d_texture3d *	unsafe_impl_from_ID3D11Texture3D (ID3D11Texture3D *iface)

struct d3d_texture3d *	unsafe_impl_from_ID3D10Texture3D (ID3D10Texture3D *iface)

HRESULT	d3d_buffer_create (struct d3d_device device, const D3D11_BUFFER_DESC desc, const D3D11_SUBRESOURCE_DATA data, struct d3d_buffer *buffer)

struct d3d_buffer *	unsafe_impl_from_ID3D11Buffer (ID3D11Buffer *iface)

struct d3d_buffer *	unsafe_impl_from_ID3D10Buffer (ID3D10Buffer *iface)

HRESULT	d3d_depthstencil_view_create (struct d3d_device device, ID3D11Resource resource, const D3D11_DEPTH_STENCIL_VIEW_DESC desc, struct d3d_depthstencil_view *view)

struct d3d_depthstencil_view *	unsafe_impl_from_ID3D11DepthStencilView (ID3D11DepthStencilView *iface)

struct d3d_depthstencil_view *	unsafe_impl_from_ID3D10DepthStencilView (ID3D10DepthStencilView *iface)

HRESULT	d3d_rendertarget_view_create (struct d3d_device device, ID3D11Resource resource, const D3D11_RENDER_TARGET_VIEW_DESC desc, struct d3d_rendertarget_view *view)

struct d3d_rendertarget_view *	unsafe_impl_from_ID3D11RenderTargetView (ID3D11RenderTargetView *iface)

struct d3d_rendertarget_view *	unsafe_impl_from_ID3D10RenderTargetView (ID3D10RenderTargetView *iface)

HRESULT	d3d_shader_resource_view_create (struct d3d_device device, ID3D11Resource resource, const D3D11_SHADER_RESOURCE_VIEW_DESC desc, struct d3d_shader_resource_view *view)

struct d3d_shader_resource_view *	unsafe_impl_from_ID3D11ShaderResourceView (ID3D11ShaderResourceView *iface)

struct d3d_shader_resource_view *	unsafe_impl_from_ID3D10ShaderResourceView (ID3D10ShaderResourceView *iface)

HRESULT	d3d11_unordered_access_view_create (struct d3d_device device, ID3D11Resource resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC desc, struct d3d11_unordered_access_view *view)

struct d3d11_unordered_access_view *	unsafe_impl_from_ID3D11UnorderedAccessView (ID3D11UnorderedAccessView *iface)

HRESULT	d3d_video_decoder_output_view_create (struct d3d_device device, ID3D11Resource resource, const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC desc, struct d3d_video_decoder_output_view *view)

HRESULT	d3d_input_layout_create (struct d3d_device device, const D3D11_INPUT_ELEMENT_DESC element_descs, UINT element_count, const void shader_byte_code, SIZE_T shader_byte_code_length, struct d3d_input_layout *layout)

struct d3d_input_layout *	unsafe_impl_from_ID3D11InputLayout (ID3D11InputLayout *iface)

struct d3d_input_layout *	unsafe_impl_from_ID3D10InputLayout (ID3D10InputLayout *iface)

HRESULT	d3d_vertex_shader_create (struct d3d_device device, const void byte_code, SIZE_T byte_code_length, struct d3d_vertex_shader **shader)

struct d3d_vertex_shader *	unsafe_impl_from_ID3D11VertexShader (ID3D11VertexShader *iface)

struct d3d_vertex_shader *	unsafe_impl_from_ID3D10VertexShader (ID3D10VertexShader *iface)

HRESULT	d3d11_hull_shader_create (struct d3d_device device, const void byte_code, SIZE_T byte_code_length, struct d3d11_hull_shader **shader)

struct d3d11_hull_shader *	unsafe_impl_from_ID3D11HullShader (ID3D11HullShader *iface)

HRESULT	d3d11_domain_shader_create (struct d3d_device device, const void byte_code, SIZE_T byte_code_length, struct d3d11_domain_shader **shader)

struct d3d11_domain_shader *	unsafe_impl_from_ID3D11DomainShader (ID3D11DomainShader *iface)

HRESULT	d3d_geometry_shader_create (struct d3d_device device, const void byte_code, SIZE_T byte_code_length, const D3D11_SO_DECLARATION_ENTRY so_entries, unsigned int so_entry_count, const unsigned int buffer_strides, unsigned int buffer_stride_count, unsigned int rasterizer_stream, struct d3d_geometry_shader **shader)

struct d3d_geometry_shader *	unsafe_impl_from_ID3D11GeometryShader (ID3D11GeometryShader *iface)

struct d3d_geometry_shader *	unsafe_impl_from_ID3D10GeometryShader (ID3D10GeometryShader *iface)

HRESULT	d3d_pixel_shader_create (struct d3d_device device, const void byte_code, SIZE_T byte_code_length, struct d3d_pixel_shader **shader)

struct d3d_pixel_shader *	unsafe_impl_from_ID3D11PixelShader (ID3D11PixelShader *iface)

struct d3d_pixel_shader *	unsafe_impl_from_ID3D10PixelShader (ID3D10PixelShader *iface)

HRESULT	d3d11_compute_shader_create (struct d3d_device device, const void byte_code, SIZE_T byte_code_length, struct d3d11_compute_shader **shader)

struct d3d11_compute_shader *	unsafe_impl_from_ID3D11ComputeShader (ID3D11ComputeShader *iface)

HRESULT	d3d11_class_linkage_create (struct d3d_device device, struct d3d11_class_linkage *class_linkage)

static struct d3d_blend_state *	impl_from_ID3D11BlendState1 (ID3D11BlendState1 *iface)

HRESULT	d3d_blend_state_create (struct d3d_device device, const D3D11_BLEND_DESC1 desc, struct d3d_blend_state **state)

struct d3d_blend_state *	unsafe_impl_from_ID3D11BlendState (ID3D11BlendState *iface)

struct d3d_blend_state *	unsafe_impl_from_ID3D10BlendState (ID3D10BlendState *iface)

static struct d3d_depthstencil_state *	impl_from_ID3D11DepthStencilState (ID3D11DepthStencilState *iface)

HRESULT	d3d_depthstencil_state_create (struct d3d_device device, const D3D11_DEPTH_STENCIL_DESC desc, struct d3d_depthstencil_state **state)

struct d3d_depthstencil_state *	unsafe_impl_from_ID3D11DepthStencilState (ID3D11DepthStencilState *iface)

struct d3d_depthstencil_state *	unsafe_impl_from_ID3D10DepthStencilState (ID3D10DepthStencilState *iface)

HRESULT	d3d_rasterizer_state_create (struct d3d_device device, const D3D11_RASTERIZER_DESC1 desc, struct d3d_rasterizer_state **state)

struct d3d_rasterizer_state *	unsafe_impl_from_ID3D11RasterizerState (ID3D11RasterizerState *iface)

struct d3d_rasterizer_state *	unsafe_impl_from_ID3D10RasterizerState (ID3D10RasterizerState *iface)

HRESULT	d3d_sampler_state_create (struct d3d_device device, const D3D11_SAMPLER_DESC desc, struct d3d_sampler_state **state)

struct d3d_sampler_state *	unsafe_impl_from_ID3D11SamplerState (ID3D11SamplerState *iface)

struct d3d_sampler_state *	unsafe_impl_from_ID3D10SamplerState (ID3D10SamplerState *iface)

HRESULT	d3d_query_create (struct d3d_device device, const D3D11_QUERY_DESC desc, BOOL predicate, struct d3d_query **query)

struct d3d_query *	unsafe_impl_from_ID3D11Query (ID3D11Query *iface)

struct d3d_query *	unsafe_impl_from_ID3D10Query (ID3D10Query *iface)

struct d3d_query *	unsafe_impl_from_ID3D11Asynchronous (ID3D11Asynchronous *iface)

static struct d3d_device *	impl_from_ID3D11Device (ID3D11Device *iface)

static struct d3d_device *	impl_from_ID3D11Device2 (ID3D11Device2 *iface)

static struct d3d_device *	impl_from_ID3D10Device (ID3D10Device1 *iface)

void	d3d_device_init (struct d3d_device device, void outer_unknown)

HRESULT	d3d_video_decoder_create (struct d3d_device device, const D3D11_VIDEO_DECODER_DESC desc, const D3D11_VIDEO_DECODER_CONFIG config, struct d3d_video_decoder *decoder)

HRESULT WINAPI	DXGID3D10CreateDevice (HMODULE d3d10core, IDXGIFactory factory, IDXGIAdapter adapter, unsigned int flags, const D3D_FEATURE_LEVEL feature_levels, unsigned int level_count, void *device)

HRESULT WINAPI	DXGID3D10RegisterLayers (const struct dxgi_device_layer *layers, UINT layer_count)

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 26 of file d3d11_private.h.

Enumeration Type Documentation

◆ dxgi_device_layer_id

enum dxgi_device_layer_id

Enumerator
DXGI_DEVICE_LAYER_DEBUG1
DXGI_DEVICE_LAYER_THREAD_SAFE
DXGI_DEVICE_LAYER_DEBUG2
DXGI_DEVICE_LAYER_SWITCH_TO_REF
DXGI_DEVICE_LAYER_D3D10_DEVICE
DXGI_DEVICE_LAYER_DEBUG1
DXGI_DEVICE_LAYER_THREAD_SAFE
DXGI_DEVICE_LAYER_DEBUG2
DXGI_DEVICE_LAYER_SWITCH_TO_REF
DXGI_DEVICE_LAYER_D3D10_DEVICE

Definition at line 632 of file d3d11_private.h.

{
    DXGI_DEVICE_LAYER_DEBUG1        = 0x8,
    DXGI_DEVICE_LAYER_THREAD_SAFE   = 0x10,
    DXGI_DEVICE_LAYER_DEBUG2        = 0x20,
    DXGI_DEVICE_LAYER_SWITCH_TO_REF = 0x30,
    DXGI_DEVICE_LAYER_D3D10_DEVICE  = 0xffffffff,
};

Function Documentation

◆ d3d10_bind_flags_from_d3d11_bind_flags()

UINT d3d10_bind_flags_from_d3d11_bind_flags ( UINT bind_flags )

Definition at line 502 of file utils.c.

{
    static const UINT handled_flags = D3D11_BIND_VERTEX_BUFFER
            | D3D11_BIND_INDEX_BUFFER
            | D3D11_BIND_CONSTANT_BUFFER
            | D3D11_BIND_SHADER_RESOURCE
            | D3D11_BIND_STREAM_OUTPUT
            | D3D11_BIND_RENDER_TARGET
            | D3D11_BIND_DEPTH_STENCIL
            | D3D11_BIND_UNORDERED_ACCESS
            | D3D11_BIND_DECODER
            | D3D11_BIND_VIDEO_ENCODER;
    UINT d3d10_bind_flags = bind_flags & handled_flags;
 
    if (bind_flags & ~handled_flags)
        FIXME("Unhandled bind flags %#x.\n", bind_flags & ~handled_flags);
 
    return d3d10_bind_flags;
}

Referenced by d3d10_buffer_GetDesc(), d3d10_texture1d_GetDesc(), d3d10_texture2d_GetDesc(), and d3d10_texture3d_GetDesc().

◆ d3d10_cpu_access_flags_from_d3d11_cpu_access_flags()

UINT d3d10_cpu_access_flags_from_d3d11_cpu_access_flags ( UINT cpu_access_flags )

Definition at line 534 of file utils.c.

{
    static const UINT handled_flags = D3D11_CPU_ACCESS_WRITE
            | D3D11_CPU_ACCESS_READ;
    UINT d3d10_cpu_access_flags = cpu_access_flags & handled_flags;
 
    if (cpu_access_flags & ~handled_flags)
        FIXME("Unhandled cpu access flags %#x.\n", cpu_access_flags & ~handled_flags);
 
    return d3d10_cpu_access_flags;
}

Referenced by d3d10_buffer_GetDesc(), d3d10_texture1d_GetDesc(), d3d10_texture2d_GetDesc(), and d3d10_texture3d_GetDesc().

◆ d3d10_resource_misc_flags_from_d3d11_resource_misc_flags()

UINT d3d10_resource_misc_flags_from_d3d11_resource_misc_flags ( UINT resource_misc_flags )

Definition at line 567 of file utils.c.

{
    static const UINT bitwise_identical_flags = D3D11_RESOURCE_MISC_GENERATE_MIPS
            | D3D11_RESOURCE_MISC_SHARED
            | D3D11_RESOURCE_MISC_TEXTURECUBE;
    const UINT handled_flags = bitwise_identical_flags
            | D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS
            | D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS
            | D3D11_RESOURCE_MISC_BUFFER_STRUCTURED
            | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX
            | D3D11_RESOURCE_MISC_GDI_COMPATIBLE
            | D3D11_RESOURCE_MISC_SHARED_NTHANDLE;
    UINT d3d10_resource_misc_flags = resource_misc_flags & bitwise_identical_flags;
 
    if (resource_misc_flags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX)
        d3d10_resource_misc_flags |= D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX;
    if (resource_misc_flags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
        d3d10_resource_misc_flags |= D3D10_RESOURCE_MISC_GDI_COMPATIBLE;
 
    if (resource_misc_flags & ~handled_flags)
        FIXME("Unhandled resource misc flags #%x.\n", resource_misc_flags & ~handled_flags);
 
    return d3d10_resource_misc_flags;
}

Referenced by d3d10_buffer_GetDesc(), d3d10_texture1d_GetDesc(), d3d10_texture2d_GetDesc(), and d3d10_texture3d_GetDesc().

◆ d3d10_usage_from_d3d11_usage()

enum D3D10_USAGE d3d10_usage_from_d3d11_usage ( enum D3D11_USAGE usage )

Definition at line 471 of file utils.c.

{
    switch (usage)
    {
        case D3D11_USAGE_DEFAULT: return D3D10_USAGE_DEFAULT;
        case D3D11_USAGE_IMMUTABLE: return D3D10_USAGE_IMMUTABLE;
        case D3D11_USAGE_DYNAMIC: return D3D10_USAGE_DYNAMIC;
        case D3D11_USAGE_STAGING: return D3D10_USAGE_STAGING;
        default:
            FIXME("Unhandled usage %#x.\n", usage);
            return D3D10_USAGE_DEFAULT;
    }
}

Referenced by d3d10_buffer_GetDesc(), d3d10_texture1d_GetDesc(), d3d10_texture2d_GetDesc(), and d3d10_texture3d_GetDesc().

◆ d3d11_bind_flags_from_d3d10_bind_flags()

UINT d3d11_bind_flags_from_d3d10_bind_flags ( UINT bind_flags )

Definition at line 485 of file utils.c.

{
    static const UINT handled_flags = D3D10_BIND_VERTEX_BUFFER
            | D3D10_BIND_INDEX_BUFFER
            | D3D10_BIND_CONSTANT_BUFFER
            | D3D10_BIND_SHADER_RESOURCE
            | D3D10_BIND_STREAM_OUTPUT
            | D3D10_BIND_RENDER_TARGET
            | D3D10_BIND_DEPTH_STENCIL;
    UINT d3d11_bind_flags = bind_flags & handled_flags;
 
    if (bind_flags & ~handled_flags)
        FIXME("Unhandled bind flags %#x.\n", bind_flags & ~handled_flags);
 
    return d3d11_bind_flags;
}

Referenced by d3d10_device_CreateBuffer(), d3d10_device_CreateTexture1D(), d3d10_device_CreateTexture2D(), and d3d10_device_CreateTexture3D().

◆ d3d11_bind_flags_from_wined3d()

static UINT d3d11_bind_flags_from_wined3d ( unsigned int bind_flags )

inlinestatic

Definition at line 102 of file d3d11_private.h.

{
    return bind_flags & (WINED3D_BIND_VERTEX_BUFFER
            | WINED3D_BIND_INDEX_BUFFER
            | WINED3D_BIND_CONSTANT_BUFFER
            | WINED3D_BIND_SHADER_RESOURCE
            | WINED3D_BIND_STREAM_OUTPUT
            | WINED3D_BIND_RENDER_TARGET
            | WINED3D_BIND_DEPTH_STENCIL
            | WINED3D_BIND_UNORDERED_ACCESS);
}

Referenced by dxgi_device_parent_register_swapchain_texture().

◆ d3d11_class_linkage_create()

HRESULT d3d11_class_linkage_create	(	struct d3d_device *	device,
		struct d3d11_class_linkage **	class_linkage
	)

Definition at line 1818 of file shader.c.

{
    struct d3d11_class_linkage *object;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->ID3D11ClassLinkage_iface.lpVtbl = &d3d11_class_linkage_vtbl;
    object->refcount = 1;
    wined3d_private_store_init(&object->private_store);
 
    ID3D11Device2_AddRef(object->device = &device->ID3D11Device2_iface);
 
    TRACE("Created class linkage %p.\n", object);
    *class_linkage = object;
 
    return S_OK;
}

Referenced by d3d11_device_CreateClassLinkage().

◆ d3d11_compute_shader_create()

HRESULT d3d11_compute_shader_create	(	struct d3d_device *	device,
		const void *	byte_code,
		SIZE_T	byte_code_length,
		struct d3d11_compute_shader **	shader
	)

Definition at line 1655 of file shader.c.

{
    struct d3d11_compute_shader *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d11_compute_shader_init(object, device, byte_code, byte_code_length)))
    {
        free(object);
        return hr;
    }
 
    TRACE("Created compute shader %p.\n", object);
    *shader = object;
 
    return S_OK;
}

Referenced by d3d11_device_CreateComputeShader().

◆ d3d11_cpu_access_flags_from_d3d10_cpu_access_flags()

UINT d3d11_cpu_access_flags_from_d3d10_cpu_access_flags ( UINT cpu_access_flags )

Definition at line 522 of file utils.c.

{
    static const UINT handled_flags = D3D10_CPU_ACCESS_WRITE
            | D3D10_CPU_ACCESS_READ;
    UINT d3d11_cpu_access_flags = cpu_access_flags & handled_flags;
 
    if (cpu_access_flags & ~handled_flags)
        FIXME("Unhandled cpu access flags %#x.\n", cpu_access_flags & ~handled_flags);
 
    return d3d11_cpu_access_flags;
}

Referenced by d3d10_device_CreateBuffer(), d3d10_device_CreateTexture1D(), d3d10_device_CreateTexture2D(), and d3d10_device_CreateTexture3D().

◆ d3d11_domain_shader_create()

HRESULT d3d11_domain_shader_create	(	struct d3d_device *	device,
		const void *	byte_code,
		SIZE_T	byte_code_length,
		struct d3d11_domain_shader **	shader
	)

Definition at line 671 of file shader.c.

{
    struct d3d11_domain_shader *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d11_domain_shader_init(object, device, byte_code, byte_code_length)))
    {
        free(object);
        return hr;
    }
 
    TRACE("Created domain shader %p.\n", object);
    *shader = object;
 
    return S_OK;
}

Referenced by d3d11_device_CreateDomainShader().

◆ d3d11_hull_shader_create()

HRESULT d3d11_hull_shader_create	(	struct d3d_device *	device,
		const void *	byte_code,
		SIZE_T	byte_code_length,
		struct d3d11_hull_shader **	shader
	)

Definition at line 484 of file shader.c.

{
    struct d3d11_hull_shader *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d11_hull_shader_init(object, device, byte_code, byte_code_length)))
    {
        free(object);
        return hr;
    }
 
    TRACE("Created hull shader %p.\n", object);
    *shader = object;
 
    return S_OK;
}

Referenced by d3d11_device_CreateHullShader().

◆ d3d11_primitive_topology_from_wined3d_primitive_type()

void d3d11_primitive_topology_from_wined3d_primitive_type	(	enum wined3d_primitive_type	primitive_type,
		unsigned int	patch_vertex_count,
		D3D11_PRIMITIVE_TOPOLOGY *	topology
	)

Definition at line 169 of file utils.c.

{
    if (primitive_type <= WINED3D_PT_TRIANGLESTRIP_ADJ)
    {
        *topology = (D3D11_PRIMITIVE_TOPOLOGY)primitive_type;
        return;
    }
 
    if (primitive_type == WINED3D_PT_PATCH)
    {
        *topology = D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST + patch_vertex_count - 1;
        return;
    }
 
    *topology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED;
}

Referenced by d3d11_device_context_IAGetPrimitiveTopology().

◆ d3d11_resource_misc_flags_from_d3d10_resource_misc_flags()

UINT d3d11_resource_misc_flags_from_d3d10_resource_misc_flags ( UINT resource_misc_flags )

Definition at line 546 of file utils.c.

{
    static const UINT bitwise_identical_flags = D3D10_RESOURCE_MISC_GENERATE_MIPS
            | D3D10_RESOURCE_MISC_SHARED
            | D3D10_RESOURCE_MISC_TEXTURECUBE;
    const UINT handled_flags = bitwise_identical_flags
            | D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX
            | D3D10_RESOURCE_MISC_GDI_COMPATIBLE;
    UINT d3d11_resource_misc_flags = resource_misc_flags & bitwise_identical_flags;
 
    if (resource_misc_flags & D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX)
        d3d11_resource_misc_flags |= D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
    if (resource_misc_flags & D3D10_RESOURCE_MISC_GDI_COMPATIBLE)
        d3d11_resource_misc_flags |= D3D11_RESOURCE_MISC_GDI_COMPATIBLE;
 
    if (resource_misc_flags & ~handled_flags)
        FIXME("Unhandled resource misc flags %#x.\n", resource_misc_flags & ~handled_flags);
 
    return d3d11_resource_misc_flags;
}

Referenced by d3d10_device_CreateBuffer(), d3d10_device_CreateTexture1D(), d3d10_device_CreateTexture2D(), and d3d10_device_CreateTexture3D().

◆ d3d11_unordered_access_view_create()

HRESULT d3d11_unordered_access_view_create	(	struct d3d_device *	device,
		ID3D11Resource *	resource,
		const D3D11_UNORDERED_ACCESS_VIEW_DESC *	desc,
		struct d3d11_unordered_access_view **	view
	)

Definition at line 2553 of file view.c.

{
    struct d3d11_unordered_access_view *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d11_unordered_access_view_init(object, device, resource, desc)))
    {
        WARN("Failed to initialise unordered access view, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created unordered access view %p.\n", object);
    *view = object;
 
    return S_OK;
}

Referenced by d3d11_device_CreateUnorderedAccessView().

◆ d3d11_usage_from_d3d10_usage()

enum D3D11_USAGE d3d11_usage_from_d3d10_usage ( enum D3D10_USAGE usage )

Definition at line 457 of file utils.c.

{
    switch (usage)
    {
        case D3D10_USAGE_DEFAULT: return D3D11_USAGE_DEFAULT;
        case D3D10_USAGE_IMMUTABLE: return D3D11_USAGE_IMMUTABLE;
        case D3D10_USAGE_DYNAMIC: return D3D11_USAGE_DYNAMIC;
        case D3D10_USAGE_STAGING: return D3D11_USAGE_STAGING;
        default:
            FIXME("Unhandled usage %#x.\n", usage);
            return D3D11_USAGE_DEFAULT;
    }
}

Referenced by d3d10_device_CreateBuffer(), d3d10_device_CreateTexture1D(), d3d10_device_CreateTexture2D(), and d3d10_device_CreateTexture3D().

◆ d3d_blend_state_create()

HRESULT d3d_blend_state_create	(	struct d3d_device *	device,
		const D3D11_BLEND_DESC1 *	desc,
		struct d3d_blend_state **	state
	)

Definition at line 346 of file state.c.

{
    struct wined3d_blend_state_desc wined3d_desc;
    struct d3d_blend_state *object;
    struct wine_rb_entry *entry;
    D3D11_BLEND_DESC1 tmp_desc;
    unsigned int i, j;
    HRESULT hr;
 
    if (!desc)
        return E_INVALIDARG;
 
    /* D3D11_RENDER_TARGET_BLEND_DESC1 has a hole, which is a problem because we use
     * D3D11_BLEND_DESC1 as a key in the rbtree. */
    memset(&tmp_desc, 0, sizeof(tmp_desc));
    tmp_desc.AlphaToCoverageEnable = desc->AlphaToCoverageEnable;
    tmp_desc.IndependentBlendEnable = desc->IndependentBlendEnable;
    for (i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
    {
        j = desc->IndependentBlendEnable ? i : 0;
        tmp_desc.RenderTarget[i].BlendEnable = desc->RenderTarget[j].BlendEnable;
        if (tmp_desc.RenderTarget[i].BlendEnable)
        {
            tmp_desc.RenderTarget[i].SrcBlend = desc->RenderTarget[j].SrcBlend;
            tmp_desc.RenderTarget[i].DestBlend = desc->RenderTarget[j].DestBlend;
            tmp_desc.RenderTarget[i].BlendOp = desc->RenderTarget[j].BlendOp;
            tmp_desc.RenderTarget[i].SrcBlendAlpha = desc->RenderTarget[j].SrcBlendAlpha;
            tmp_desc.RenderTarget[i].DestBlendAlpha = desc->RenderTarget[j].DestBlendAlpha;
            tmp_desc.RenderTarget[i].BlendOpAlpha = desc->RenderTarget[j].BlendOpAlpha;
        }
        else
        {
            tmp_desc.RenderTarget[i].SrcBlend = D3D11_BLEND_ONE;
            tmp_desc.RenderTarget[i].DestBlend = D3D11_BLEND_ZERO;
            tmp_desc.RenderTarget[i].BlendOp = D3D11_BLEND_OP_ADD;
            tmp_desc.RenderTarget[i].SrcBlendAlpha = D3D11_BLEND_ONE;
            tmp_desc.RenderTarget[i].DestBlendAlpha = D3D11_BLEND_ZERO;
            tmp_desc.RenderTarget[i].BlendOpAlpha = D3D11_BLEND_OP_ADD;
        }
 
        tmp_desc.RenderTarget[i].LogicOpEnable = desc->RenderTarget[j].LogicOpEnable;
        if (tmp_desc.RenderTarget[i].LogicOpEnable)
            tmp_desc.RenderTarget[i].LogicOp = desc->RenderTarget[j].LogicOp;
        else
            tmp_desc.RenderTarget[i].LogicOp = D3D11_LOGIC_OP_NOOP;
 
        tmp_desc.RenderTarget[i].RenderTargetWriteMask = desc->RenderTarget[j].RenderTargetWriteMask;
    }
 
    wined3d_mutex_lock();
    if ((entry = wine_rb_get(&device->blend_states, &tmp_desc)))
    {
        object = WINE_RB_ENTRY_VALUE(entry, struct d3d_blend_state, entry);
 
        TRACE("Returning existing blend state %p.\n", object);
        ID3D11BlendState1_AddRef(&object->ID3D11BlendState1_iface);
        *state = object;
        wined3d_mutex_unlock();
 
        return S_OK;
    }
 
    if (!(object = calloc(1, sizeof(*object))))
    {
        wined3d_mutex_unlock();
        return E_OUTOFMEMORY;
    }
 
    object->ID3D11BlendState1_iface.lpVtbl = &d3d11_blend_state_vtbl;
    object->ID3D10BlendState1_iface.lpVtbl = &d3d10_blend_state_vtbl;
    object->refcount = 1;
    wined3d_private_store_init(&object->private_store);
    object->desc = tmp_desc;
 
    if (wine_rb_put(&device->blend_states, &tmp_desc, &object->entry) == -1)
    {
        ERR("Failed to insert blend state entry.\n");
        wined3d_private_store_cleanup(&object->private_store);
        free(object);
        wined3d_mutex_unlock();
        return E_FAIL;
    }
 
    wined3d_desc.alpha_to_coverage = desc->AlphaToCoverageEnable;
    wined3d_desc.independent = desc->IndependentBlendEnable;
    for (i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
    {
        wined3d_desc.rt[i].enable = desc->RenderTarget[i].BlendEnable;
        wined3d_desc.rt[i].src = wined3d_blend_from_d3d11(desc->RenderTarget[i].SrcBlend);
        wined3d_desc.rt[i].dst = wined3d_blend_from_d3d11(desc->RenderTarget[i].DestBlend);
        wined3d_desc.rt[i].op = wined3d_blend_op_from_d3d11(desc->RenderTarget[i].BlendOp);
        wined3d_desc.rt[i].src_alpha = wined3d_blend_from_d3d11(desc->RenderTarget[i].SrcBlendAlpha);
        wined3d_desc.rt[i].dst_alpha = wined3d_blend_from_d3d11(desc->RenderTarget[i].DestBlendAlpha);
        wined3d_desc.rt[i].op_alpha = wined3d_blend_op_from_d3d11(desc->RenderTarget[i].BlendOpAlpha);
        wined3d_desc.rt[i].writemask = desc->RenderTarget[i].RenderTargetWriteMask;
    }
 
    if (desc->RenderTarget[0].LogicOpEnable && desc->RenderTarget[0].LogicOp != D3D11_LOGIC_OP_NOOP)
        FIXME("Ignoring logic op %#x.\n", desc->RenderTarget[0].LogicOp);
 
    /* We cannot fail after creating a wined3d_blend_state object. It
     * would lead to double free. */
    if (FAILED(hr = wined3d_blend_state_create(device->wined3d_device, &wined3d_desc,
            object, &d3d_blend_state_wined3d_parent_ops, &object->wined3d_state)))
    {
        WARN("Failed to create wined3d blend state, hr %#lx.\n", hr);
        wined3d_private_store_cleanup(&object->private_store);
        wine_rb_remove(&device->blend_states, &object->entry);
        free(object);
        wined3d_mutex_unlock();
        return hr;
    }
    wined3d_mutex_unlock();
 
    ID3D11Device2_AddRef(object->device = &device->ID3D11Device2_iface);
 
    TRACE("Created blend state %p.\n", object);
    *state = object;
 
    return S_OK;
}

Referenced by d3d11_device_CreateBlendState1().

◆ d3d_buffer_create()

HRESULT d3d_buffer_create	(	struct d3d_device *	device,
		const D3D11_BUFFER_DESC *	desc,
		const D3D11_SUBRESOURCE_DATA *	data,
		struct d3d_buffer **	buffer
	)

Definition at line 504 of file buffer.c.

{
    struct d3d_buffer *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_buffer_init(object, device, desc, data)))
    {
        WARN("Failed to initialise buffer, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created buffer %p.\n", object);
    *buffer = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateBuffer(), and d3d11_device_CreateBuffer().

◆ d3d_depthstencil_state_create()

HRESULT d3d_depthstencil_state_create	(	struct d3d_device *	device,
		const D3D11_DEPTH_STENCIL_DESC *	desc,
		struct d3d_depthstencil_state **	state
	)

Definition at line 751 of file state.c.

{
    struct wined3d_depth_stencil_state_desc wined3d_desc;
    struct d3d_depthstencil_state *object;
    D3D11_DEPTH_STENCIL_DESC tmp_desc;
    struct wine_rb_entry *entry;
    HRESULT hr;
 
    if (!desc)
        return E_INVALIDARG;
 
    /* D3D11_DEPTH_STENCIL_DESC has a hole, which is a problem because we use
     * it as a key in the rbtree. */
    memset(&tmp_desc, 0, sizeof(tmp_desc));
    tmp_desc.DepthEnable = desc->DepthEnable;
    if (desc->DepthEnable)
    {
        tmp_desc.DepthWriteMask = desc->DepthWriteMask;
        tmp_desc.DepthFunc = desc->DepthFunc;
    }
    else
    {
        tmp_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
        tmp_desc.DepthFunc = D3D11_COMPARISON_LESS;
    }
    tmp_desc.StencilEnable = desc->StencilEnable;
    if (desc->StencilEnable)
    {
        tmp_desc.StencilReadMask = desc->StencilReadMask;
        tmp_desc.StencilWriteMask = desc->StencilWriteMask;
        tmp_desc.FrontFace = desc->FrontFace;
        tmp_desc.BackFace = desc->BackFace;
    }
    else
    {
        tmp_desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
        tmp_desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
        tmp_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
        tmp_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
        tmp_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
        tmp_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
        tmp_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
        tmp_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
        tmp_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
        tmp_desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
    }
 
    wined3d_mutex_lock();
    if ((entry = wine_rb_get(&device->depthstencil_states, &tmp_desc)))
    {
        object = WINE_RB_ENTRY_VALUE(entry, struct d3d_depthstencil_state, entry);
 
        TRACE("Returning existing depthstencil state %p.\n", object);
        ID3D11DepthStencilState_AddRef(&object->ID3D11DepthStencilState_iface);
        *state = object;
        wined3d_mutex_unlock();
 
        return S_OK;
    }
 
    if (!(object = calloc(1, sizeof(*object))))
    {
        wined3d_mutex_unlock();
        return E_OUTOFMEMORY;
    }
 
    object->ID3D11DepthStencilState_iface.lpVtbl = &d3d11_depthstencil_state_vtbl;
    object->ID3D10DepthStencilState_iface.lpVtbl = &d3d10_depthstencil_state_vtbl;
    object->refcount = 1;
    wined3d_private_store_init(&object->private_store);
    object->desc = tmp_desc;
 
    if (wine_rb_put(&device->depthstencil_states, &tmp_desc, &object->entry) == -1)
    {
        ERR("Failed to insert depth/stencil state entry.\n");
        wined3d_private_store_cleanup(&object->private_store);
        free(object);
        wined3d_mutex_unlock();
        return E_FAIL;
    }
 
    wined3d_desc.depth = desc->DepthEnable;
    wined3d_desc.depth_write = desc->DepthWriteMask;
    wined3d_desc.depth_func = wined3d_cmp_func_from_d3d11(desc->DepthFunc);
    wined3d_desc.stencil = desc->StencilEnable;
    wined3d_desc.stencil_read_mask = desc->StencilReadMask;
    wined3d_desc.stencil_write_mask = desc->StencilWriteMask;
    wined3d_desc.front.fail_op = wined3d_stencil_op_from_d3d11(desc->FrontFace.StencilFailOp);
    wined3d_desc.front.depth_fail_op = wined3d_stencil_op_from_d3d11(desc->FrontFace.StencilDepthFailOp);
    wined3d_desc.front.pass_op = wined3d_stencil_op_from_d3d11(desc->FrontFace.StencilPassOp);
    wined3d_desc.front.func = wined3d_cmp_func_from_d3d11(desc->FrontFace.StencilFunc);
    wined3d_desc.back.fail_op = wined3d_stencil_op_from_d3d11(desc->BackFace.StencilFailOp);
    wined3d_desc.back.depth_fail_op = wined3d_stencil_op_from_d3d11(desc->BackFace.StencilDepthFailOp);
    wined3d_desc.back.pass_op = wined3d_stencil_op_from_d3d11(desc->BackFace.StencilPassOp);
    wined3d_desc.back.func = wined3d_cmp_func_from_d3d11(desc->BackFace.StencilFunc);
 
    /* We cannot fail after creating a wined3d_depth_stencil_state object. It
     * would lead to double free. */
    if (FAILED(hr = wined3d_depth_stencil_state_create(device->wined3d_device, &wined3d_desc,
            object, &d3d_depthstencil_state_wined3d_parent_ops, &object->wined3d_state)))
    {
        WARN("Failed to create wined3d depth/stencil state, hr %#lx.\n", hr);
        wined3d_private_store_cleanup(&object->private_store);
        wine_rb_remove(&device->depthstencil_states, &object->entry);
        free(object);
        wined3d_mutex_unlock();
        return hr;
    }
    wined3d_mutex_unlock();
 
    ID3D11Device2_AddRef(object->device = &device->ID3D11Device2_iface);
 
    TRACE("Created depth/stencil state %p.\n", object);
    *state = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateDepthStencilState(), and d3d11_device_CreateDepthStencilState().

◆ d3d_depthstencil_view_create()

HRESULT d3d_depthstencil_view_create	(	struct d3d_device *	device,
		ID3D11Resource *	resource,
		const D3D11_DEPTH_STENCIL_VIEW_DESC *	desc,
		struct d3d_depthstencil_view **	view
	)

Definition at line 1315 of file view.c.

{
    struct d3d_depthstencil_view *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_depthstencil_view_init(object, device, resource, desc)))
    {
        WARN("Failed to initialise depth/stencil view, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created depthstencil view %p.\n", object);
    *view = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateDepthStencilView(), and d3d11_device_CreateDepthStencilView().

◆ d3d_device_create_dxgi_resource()

HRESULT d3d_device_create_dxgi_resource	(	IUnknown *	device,
		struct wined3d_resource *	wined3d_resource,
		IUnknown *	outer,
		BOOL	needs_surface,
		IUnknown **	dxgi_resource
	)

Definition at line 416 of file texture.c.

{
    IWineDXGIDevice *wine_device;
    HRESULT hr;
 
    if (FAILED(hr = IUnknown_QueryInterface(device, &IID_IWineDXGIDevice, (void **)&wine_device)))
    {
        ERR("Device should implement IWineDXGIDevice.\n");
        return E_FAIL;
    }
 
    hr = IWineDXGIDevice_create_resource(wine_device, wined3d_resource, 0, NULL, outer,
            needs_surface, (void **)dxgi_resource);
    IWineDXGIDevice_Release(wine_device);
    if (FAILED(hr))
    {
        ERR("Failed to create DXGI resource, returning %#.lx\n", hr);
        *dxgi_resource = NULL;
    }
 
    return hr;
}

Referenced by d3d_buffer_init(), d3d_texture1d_create(), d3d_texture2d_create(), and d3d_texture3d_init().

◆ d3d_device_init()

void d3d_device_init	(	struct d3d_device *	device,
		void *	outer_unknown
	)

Definition at line 7756 of file device.c.

{
    device->IUnknown_inner.lpVtbl = &d3d_device_inner_unknown_vtbl;
    device->ID3D11Device2_iface.lpVtbl = &d3d11_device_vtbl;
    device->ID3D10Device1_iface.lpVtbl = &d3d10_device1_vtbl;
    device->ID3D10Multithread_iface.lpVtbl = &d3d10_multithread_vtbl;
    device->ID3D11VideoDevice1_iface.lpVtbl = &d3d11_video_device1_vtbl;
    device->IWineDXGIDeviceParent_iface.lpVtbl = &d3d_dxgi_device_parent_vtbl;
    device->device_parent.ops = &d3d_wined3d_device_parent_ops;
    device->refcount = 1;
    /* COM aggregation always takes place */
    device->outer_unk = outer_unknown;
    device->d3d11_only = FALSE;
    device->state = NULL;
 
    d3d11_device_context_init(&device->immediate_context, device, D3D11_DEVICE_CONTEXT_IMMEDIATE);
    ID3D11DeviceContext1_Release(&device->immediate_context.ID3D11DeviceContext1_iface);
 
    wine_rb_init(&device->blend_states, d3d_blend_state_compare);
    wine_rb_init(&device->depthstencil_states, d3d_depthstencil_state_compare);
    wine_rb_init(&device->rasterizer_states, d3d_rasterizer_state_compare);
    wine_rb_init(&device->sampler_states, d3d_sampler_state_compare);
}

Referenced by d3d_device_create(), and layer_create().

◆ d3d_geometry_shader_create()

HRESULT d3d_geometry_shader_create	(	struct d3d_device *	device,
		const void *	byte_code,
		SIZE_T	byte_code_length,
		const D3D11_SO_DECLARATION_ENTRY *	so_entries,
		unsigned int	so_entry_count,
		const unsigned int *	buffer_strides,
		unsigned int	buffer_stride_count,
		unsigned int	rasterizer_stream,
		struct d3d_geometry_shader **	shader
	)

Definition at line 1156 of file shader.c.

{
    struct d3d_geometry_shader *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_geometry_shader_init(object, device, byte_code, byte_code_length,
            so_entries, so_entry_count, buffer_strides, buffer_stride_count, rasterizer_stream)))
    {
        WARN("Failed to initialise geometry shader, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created geometry shader %p.\n", object);
    *shader = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateGeometryShader(), d3d10_device_CreateGeometryShaderWithStreamOutput(), d3d11_device_CreateGeometryShader(), and d3d11_device_CreateGeometryShaderWithStreamOutput().

◆ d3d_get_private_data()

HRESULT d3d_get_private_data	(	struct wined3d_private_store *	store,
		REFGUID	guid,
		UINT *	data_size,
		void *	data
	)

Definition at line 803 of file utils.c.

{
    const struct wined3d_private_data *stored_data;
    DWORD size_in;
 
    if (!data_size)
        return E_INVALIDARG;
 
    wined3d_mutex_lock();
    if (!(stored_data = wined3d_private_store_get_private_data(store, guid)))
    {
        *data_size = 0;
        wined3d_mutex_unlock();
        return DXGI_ERROR_NOT_FOUND;
    }
 
    size_in = *data_size;
    *data_size = stored_data->size;
    if (!data)
    {
        wined3d_mutex_unlock();
        return S_OK;
    }
    if (size_in < stored_data->size)
    {
        wined3d_mutex_unlock();
        return DXGI_ERROR_MORE_DATA;
    }
 
    if (stored_data->flags & WINED3DSPD_IUNKNOWN)
        IUnknown_AddRef(stored_data->content.object);
    memcpy(data, stored_data->content.data, stored_data->size);
 
    wined3d_mutex_unlock();
    return S_OK;
}

◆ d3d_input_layout_create()

HRESULT d3d_input_layout_create	(	struct d3d_device *	device,
		const D3D11_INPUT_ELEMENT_DESC *	element_descs,
		UINT	element_count,
		const void *	shader_byte_code,
		SIZE_T	shader_byte_code_length,
		struct d3d_input_layout **	layout
	)

Definition at line 385 of file inputlayout.c.

{
    struct d3d_input_layout *object;
    HRESULT hr;
 
    if (!element_descs) return E_INVALIDARG;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_input_layout_init(object, device, element_descs, element_count,
            shader_byte_code, shader_byte_code_length)))
    {
        WARN("Failed to initialise input layout, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created input layout %p.\n", object);
    *layout = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateInputLayout(), and d3d11_device_CreateInputLayout().

◆ d3d_pixel_shader_create()

HRESULT d3d_pixel_shader_create	(	struct d3d_device *	device,
		const void *	byte_code,
		SIZE_T	byte_code_length,
		struct d3d_pixel_shader **	shader
	)

Definition at line 1460 of file shader.c.

{
    struct d3d_pixel_shader *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_pixel_shader_init(object, device, byte_code, byte_code_length)))
    {
        WARN("Failed to initialise pixel shader, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created pixel shader %p.\n", object);
    *shader = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreatePixelShader(), and d3d11_device_CreatePixelShader().

◆ d3d_query_create()

HRESULT d3d_query_create	(	struct d3d_device *	device,
		const D3D11_QUERY_DESC *	desc,
		BOOL	predicate,
		struct d3d_query **	query
	)

Definition at line 465 of file async.c.

{
    struct d3d_query *object;
    BOOL is_predicate_type;
    HRESULT hr;
 
    if (!desc)
        return E_INVALIDARG;
 
    is_predicate_type = desc->Query == D3D11_QUERY_OCCLUSION_PREDICATE
            || desc->Query == D3D11_QUERY_SO_OVERFLOW_PREDICATE
            || desc->Query == D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0
            || desc->Query == D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1
            || desc->Query == D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2
            || desc->Query == D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3;
 
    if (!is_predicate_type && predicate)
    {
        WARN("Query type %u is not a predicate.\n", desc->Query);
        return E_INVALIDARG;
    }
 
    if (is_predicate_type)
        predicate = TRUE;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_query_init(object, device, desc, predicate)))
    {
        WARN("Failed to initialise predicate, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created query %p.\n", object);
    *query = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreatePredicate(), d3d10_device_CreateQuery(), d3d11_device_CreatePredicate(), and d3d11_device_CreateQuery().

◆ d3d_rasterizer_state_create()

HRESULT d3d_rasterizer_state_create	(	struct d3d_device *	device,
		const D3D11_RASTERIZER_DESC1 *	desc,
		struct d3d_rasterizer_state **	state
	)

Definition at line 1228 of file state.c.

{
    struct d3d_rasterizer_state *object;
    struct wine_rb_entry *entry;
    HRESULT hr;
 
    wined3d_mutex_lock();
    if ((entry = wine_rb_get(&device->rasterizer_states, desc)))
    {
        object = WINE_RB_ENTRY_VALUE(entry, struct d3d_rasterizer_state, entry);
 
        TRACE("Returning existing rasterizer state %p.\n", object);
        ID3D11RasterizerState1_AddRef(&object->ID3D11RasterizerState1_iface);
        *state = object;
        wined3d_mutex_unlock();
 
        return S_OK;
    }
 
    if (!(object = calloc(1, sizeof(*object))))
    {
        wined3d_mutex_unlock();
        return E_OUTOFMEMORY;
    }
 
    hr = d3d_rasterizer_state_init(object, device, desc);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to initialise rasterizer state, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created rasterizer state %p.\n", object);
    *state = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateRasterizerState(), d3d11_device_CreateRasterizerState(), and d3d11_device_CreateRasterizerState1().

◆ d3d_rendertarget_view_create()

HRESULT d3d_rendertarget_view_create	(	struct d3d_device *	device,
		ID3D11Resource *	resource,
		const D3D11_RENDER_TARGET_VIEW_DESC *	desc,
		struct d3d_rendertarget_view **	view
	)

Definition at line 1756 of file view.c.

{
    struct d3d_rendertarget_view *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_rendertarget_view_init(object, device, resource, desc)))
    {
        WARN("Failed to initialise rendertarget view, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created rendertarget view %p.\n", object);
    *view = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateRenderTargetView(), and d3d11_device_CreateRenderTargetView().

◆ d3d_sampler_state_create()

HRESULT d3d_sampler_state_create	(	struct d3d_device *	device,
		const D3D11_SAMPLER_DESC *	desc,
		struct d3d_sampler_state **	state
	)

Definition at line 1627 of file state.c.

{
    D3D11_SAMPLER_DESC normalized_desc;
    struct d3d_sampler_state *object;
    struct wine_rb_entry *entry;
    HRESULT hr;
 
    if (!desc)
        return E_INVALIDARG;
 
    normalized_desc = *desc;
    if (!D3D11_DECODE_IS_ANISOTROPIC_FILTER(normalized_desc.Filter))
        normalized_desc.MaxAnisotropy = 0;
    if (!D3D11_DECODE_IS_COMPARISON_FILTER(normalized_desc.Filter))
        normalized_desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
    if (normalized_desc.AddressU != D3D11_TEXTURE_ADDRESS_BORDER
            && normalized_desc.AddressV != D3D11_TEXTURE_ADDRESS_BORDER
            && normalized_desc.AddressW != D3D11_TEXTURE_ADDRESS_BORDER)
        memset(&normalized_desc.BorderColor, 0, sizeof(normalized_desc.BorderColor));
 
    wined3d_mutex_lock();
    if ((entry = wine_rb_get(&device->sampler_states, &normalized_desc)))
    {
        object = WINE_RB_ENTRY_VALUE(entry, struct d3d_sampler_state, entry);
 
        TRACE("Returning existing sampler state %p.\n", object);
        ID3D11SamplerState_AddRef(&object->ID3D11SamplerState_iface);
        *state = object;
        wined3d_mutex_unlock();
 
        return S_OK;
    }
 
    if (!(object = calloc(1, sizeof(*object))))
    {
        wined3d_mutex_unlock();
        return E_OUTOFMEMORY;
    }
 
    hr = d3d_sampler_state_init(object, device, &normalized_desc);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to initialise sampler state, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created sampler state %p.\n", object);
    *state = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateSamplerState(), and d3d11_device_CreateSamplerState().

◆ d3d_set_private_data()

HRESULT d3d_set_private_data	(	struct wined3d_private_store *	store,
		REFGUID	guid,
		UINT	data_size,
		const void *	data
	)

Definition at line 841 of file utils.c.

{
    struct wined3d_private_data *entry;
    HRESULT hr;
 
    wined3d_mutex_lock();
    if (!data)
    {
        if (!(entry = wined3d_private_store_get_private_data(store, guid)))
        {
            wined3d_mutex_unlock();
            return S_FALSE;
        }
        wined3d_private_store_free_private_data(store, entry);
        wined3d_mutex_unlock();
 
        return S_OK;
    }
 
    hr = wined3d_private_store_set_private_data(store, guid, data, data_size, 0);
    wined3d_mutex_unlock();
 
    return hr;
}

◆ d3d_set_private_data_interface()

HRESULT d3d_set_private_data_interface	(	struct wined3d_private_store *	store,
		REFGUID	guid,
		const IUnknown *	object
	)

Definition at line 867 of file utils.c.

{
    HRESULT hr;
 
    if (!object)
        return d3d_set_private_data(store, guid, sizeof(object), &object);
 
    wined3d_mutex_lock();
    hr = wined3d_private_store_set_private_data(store,
            guid, object, sizeof(object), WINED3DSPD_IUNKNOWN);
    wined3d_mutex_unlock();
 
    return hr;
}

◆ d3d_shader_resource_view_create()

HRESULT d3d_shader_resource_view_create	(	struct d3d_device *	device,
		ID3D11Resource *	resource,
		const D3D11_SHADER_RESOURCE_VIEW_DESC *	desc,
		struct d3d_shader_resource_view **	view
	)

Definition at line 2250 of file view.c.

{
    struct d3d_shader_resource_view *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_shader_resource_view_init(object, device, resource, desc)))
    {
        WARN("Failed to initialise shader resource view, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created shader resource view %p.\n", object);
    *view = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateShaderResourceView1(), and d3d11_device_CreateShaderResourceView().

◆ d3d_texture1d_create()

HRESULT d3d_texture1d_create	(	struct d3d_device *	device,
		const D3D11_TEXTURE1D_DESC *	desc,
		const D3D11_SUBRESOURCE_DATA *	data,
		struct d3d_texture1d **	texture
	)

Definition at line 440 of file texture.c.

{
    struct wined3d_resource_desc wined3d_desc;
    struct d3d_texture1d *texture;
    unsigned int levels;
    BOOL needs_surface;
    DWORD flags = 0;
    HRESULT hr;
 
    if (!(texture = calloc(1, sizeof(*texture))))
        return E_OUTOFMEMORY;
 
    texture->ID3D11Texture1D_iface.lpVtbl = &d3d11_texture1d_vtbl;
    texture->ID3D10Texture1D_iface.lpVtbl = &d3d10_texture1d_vtbl;
    texture->refcount = 1;
    texture->desc = *desc;
    levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(desc->Width) + 1;
    texture->desc.MipLevels = levels;
 
    wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_1D;
    wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
    wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    wined3d_desc.multisample_quality = 0;
    wined3d_desc.usage = wined3d_usage_from_d3d11(desc->Usage);
    wined3d_desc.bind_flags = wined3d_bind_flags_from_d3d11(desc->BindFlags, desc->MiscFlags);
    wined3d_desc.access = wined3d_access_from_d3d11(desc->Usage,
            desc->Usage == D3D11_USAGE_DEFAULT ? 0 : desc->CPUAccessFlags);
    wined3d_desc.width = desc->Width;
    wined3d_desc.height = 1;
    wined3d_desc.depth = 1;
    wined3d_desc.size = 0;
 
    if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
        flags |= WINED3D_TEXTURE_CREATE_GET_DC;
    if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
        flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
 
    wined3d_mutex_lock();
    if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
            desc->ArraySize, levels, flags, (struct wined3d_sub_resource_data *)data,
            texture, &d3d_texture1d_wined3d_parent_ops, &texture->wined3d_texture)))
    {
        WARN("Failed to create wined3d texture, hr %#lx.\n", hr);
        free(texture);
        wined3d_mutex_unlock();
        if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DERR_INVALIDCALL)
            hr = E_INVALIDARG;
        return hr;
    }
 
    needs_surface = desc->MipLevels == 1 && desc->ArraySize == 1;
    hr = d3d_device_create_dxgi_resource((IUnknown *)&device->ID3D10Device1_iface,
            wined3d_texture_get_resource(texture->wined3d_texture), (IUnknown *)&texture->ID3D10Texture1D_iface,
            needs_surface, &texture->dxgi_resource);
    if (FAILED(hr))
    {
        ERR("Failed to create DXGI resource, returning %#.lx\n", hr);
        wined3d_texture_decref(texture->wined3d_texture);
        wined3d_mutex_unlock();
        return hr;
    }
    wined3d_mutex_unlock();
 
    ID3D11Device2_AddRef(texture->device = &device->ID3D11Device2_iface);
 
    TRACE("Created texture %p.\n", texture);
    *out = texture;
 
    return S_OK;
}

Referenced by d3d10_device_CreateTexture1D(), and d3d11_device_CreateTexture1D().

◆ d3d_texture2d_create()

HRESULT d3d_texture2d_create	(	struct d3d_device *	device,
		const D3D11_TEXTURE2D_DESC *	desc,
		struct wined3d_texture *	wined3d_texture,
		const D3D11_SUBRESOURCE_DATA *	data,
		struct d3d_texture2d **	out
	)

Definition at line 964 of file texture.c.

{
    struct d3d_texture2d *texture;
    BOOL needs_surface;
    DWORD flags = 0;
    HRESULT hr;
 
    if (!validate_texture2d_desc(desc, device->state->feature_level))
    {
        WARN("Failed to validate texture desc.\n");
        return E_INVALIDARG;
    }
 
    if (!(texture = calloc(1, sizeof(*texture))))
        return E_OUTOFMEMORY;
 
    texture->ID3D11Texture2D_iface.lpVtbl = &d3d11_texture2d_vtbl;
    texture->ID3D10Texture2D_iface.lpVtbl = &d3d10_texture2d_vtbl;
    texture->refcount = 1;
    wined3d_mutex_lock();
    texture->desc = *desc;
 
    if (wined3d_texture)
    {
        wined3d_resource_set_parent(wined3d_texture_get_resource(wined3d_texture),
                texture, &d3d_texture2d_wined3d_parent_ops);
        wined3d_texture_incref(wined3d_texture);
        texture->wined3d_texture = wined3d_texture;
 
        if ((texture->swapchain = wined3d_texture_get_swapchain(wined3d_texture)))
            wined3d_swapchain_incref(texture->swapchain);
    }
    else
    {
        struct wined3d_resource_desc wined3d_desc;
        unsigned int levels;
 
        wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
        wined3d_desc.format = wined3dformat_from_dxgi_format(desc->Format);
        wined3d_desc.multisample_type = desc->SampleDesc.Count > 1 ? desc->SampleDesc.Count : WINED3D_MULTISAMPLE_NONE;
        wined3d_desc.multisample_quality = desc->SampleDesc.Quality;
        wined3d_desc.usage = wined3d_usage_from_d3d11(desc->Usage);
        wined3d_desc.bind_flags = wined3d_bind_flags_from_d3d11(desc->BindFlags, desc->MiscFlags);
        wined3d_desc.access = wined3d_access_from_d3d11(desc->Usage,
                desc->Usage == D3D11_USAGE_DEFAULT ? 0 : desc->CPUAccessFlags);
        wined3d_desc.width = desc->Width;
        wined3d_desc.height = desc->Height;
        wined3d_desc.depth = 1;
        wined3d_desc.size = 0;
 
        levels = desc->MipLevels ? desc->MipLevels : wined3d_log2i(max(desc->Width, desc->Height)) + 1;
 
        if (desc->MiscFlags & D3D11_RESOURCE_MISC_GDI_COMPATIBLE)
            flags |= WINED3D_TEXTURE_CREATE_GET_DC;
        if (desc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
            flags |= WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS;
 
        if (FAILED(hr = wined3d_texture_create(device->wined3d_device, &wined3d_desc,
                desc->ArraySize, levels, flags, (struct wined3d_sub_resource_data *)data,
                texture, &d3d_texture2d_wined3d_parent_ops, &texture->wined3d_texture)))
        {
            WARN("Failed to create wined3d texture, hr %#lx.\n", hr);
            free(texture);
            wined3d_mutex_unlock();
            if (hr == WINED3DERR_NOTAVAILABLE || hr == WINED3DERR_INVALIDCALL)
                hr = E_INVALIDARG;
            return hr;
        }
        texture->desc.MipLevels = levels;
    }
 
    needs_surface = desc->MipLevels == 1 && desc->ArraySize == 1;
    hr = d3d_device_create_dxgi_resource((IUnknown *)&device->ID3D10Device1_iface,
            wined3d_texture_get_resource(texture->wined3d_texture), (IUnknown *)&texture->ID3D10Texture2D_iface,
            needs_surface, &texture->dxgi_resource);
    if (FAILED(hr))
    {
        ERR("Failed to create DXGI resource, returning %#.lx\n", hr);
        wined3d_texture_decref(texture->wined3d_texture);
        wined3d_mutex_unlock();
        return hr;
    }
    wined3d_mutex_unlock();
 
    ID3D11Device2_AddRef(texture->device = &device->ID3D11Device2_iface);
 
    TRACE("Created texture %p.\n", texture);
    *out = texture;
 
    return S_OK;
}

Referenced by d3d10_device_CreateTexture2D(), d3d11_device_CreateTexture2D(), and dxgi_device_parent_register_swapchain_texture().

◆ d3d_texture3d_create()

HRESULT d3d_texture3d_create	(	struct d3d_device *	device,
		const D3D11_TEXTURE3D_DESC *	desc,
		const D3D11_SUBRESOURCE_DATA *	data,
		struct d3d_texture3d **	texture
	)

Definition at line 1514 of file texture.c.

{
    struct d3d_texture3d *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_texture3d_init(object, device, desc, data)))
    {
        WARN("Failed to initialise texture, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created texture %p.\n", object);
    *texture = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateTexture3D(), and d3d11_device_CreateTexture3D().

◆ d3d_vertex_shader_create()

HRESULT d3d_vertex_shader_create	(	struct d3d_device *	device,
		const void *	byte_code,
		SIZE_T	byte_code_length,
		struct d3d_vertex_shader **	shader
	)

Definition at line 287 of file shader.c.

{
    struct d3d_vertex_shader *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_vertex_shader_init(object, device, byte_code, byte_code_length)))
    {
        WARN("Failed to initialise vertex shader, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created vertex shader %p.\n", object);
    *shader = object;
 
    return S_OK;
}

Referenced by d3d10_device_CreateVertexShader(), and d3d11_device_CreateVertexShader().

◆ d3d_video_decoder_create()

HRESULT d3d_video_decoder_create	(	struct d3d_device *	device,
		const D3D11_VIDEO_DECODER_DESC *	desc,
		const D3D11_VIDEO_DECODER_CONFIG *	config,
		struct d3d_video_decoder **	decoder
	)

Definition at line 142 of file decoder.c.

{
    struct d3d_video_decoder *object;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->ID3D11VideoDecoder_iface.lpVtbl = &d3d11_video_decoder_vtbl;
    object->refcount = 1;
 
    wined3d_private_store_init(&object->private_store);
    object->device = device;
    ID3D11Device2_AddRef(&device->ID3D11Device2_iface);
 
    TRACE("Created video decoder %p.\n", object);
    *decoder = object;
    return S_OK;
}

Referenced by d3d11_video_device_CreateVideoDecoder().

◆ d3d_video_decoder_output_view_create()

HRESULT d3d_video_decoder_output_view_create	(	struct d3d_device *	device,
		ID3D11Resource *	resource,
		const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *	desc,
		struct d3d_video_decoder_output_view **	view
	)

Definition at line 2729 of file view.c.

{
    struct d3d_video_decoder_output_view *object;
    HRESULT hr;
 
    TRACE("profile %s, slice %u.\n", debugstr_guid(&desc->DecodeProfile), desc->u.Texture2D.ArraySlice);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d_video_decoder_output_view_init(object, device, resource, desc)))
    {
        WARN("Failed to initialise video decoder output view, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    TRACE("Created video decoder output view %p.\n", object);
    *view = object;
 
    return S_OK;
}

Referenced by d3d11_video_device_CreateVideoDecoderOutputView().

◆ debug_d3d10_primitive_topology()

const char * debug_d3d10_primitive_topology ( D3D10_PRIMITIVE_TOPOLOGY topology )

Definition at line 26 of file utils.c.

{
    switch (topology)
    {
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_POINTLIST);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_LINELIST);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ);
        WINE_D3D_TO_STR(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ);
        default:
            FIXME("Unrecognized D3D10_PRIMITIVE_TOPOLOGY %#x\n", topology);
            return "unrecognized";
    }
}

Referenced by d3d10_device_IASetPrimitiveTopology().

◆ debug_dxgi_format()

const char * debug_dxgi_format ( DXGI_FORMAT format )

Definition at line 46 of file utils.c.

{
    switch(format)
    {
        WINE_D3D_TO_STR(DXGI_FORMAT_UNKNOWN);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32B32A32_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32B32A32_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32B32A32_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32B32A32_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32B32_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32B32_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32B32_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32B32_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16B16A16_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16B16A16_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16B16A16_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16B16A16_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16B16A16_SNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16B16A16_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G32_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32G8X24_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_X32_TYPELESS_G8X24_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R10G10B10A2_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R10G10B10A2_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R10G10B10A2_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R11G11B10_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8B8A8_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8B8A8_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8B8A8_UNORM_SRGB);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8B8A8_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8B8A8_SNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8B8A8_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16_SNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16G16_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_D32_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R32_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R24G8_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_D24_UNORM_S8_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R24_UNORM_X8_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_X24_TYPELESS_G8_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8_SNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16_FLOAT);
        WINE_D3D_TO_STR(DXGI_FORMAT_D16_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16_SNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R16_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8_UINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8_SNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8_SINT);
        WINE_D3D_TO_STR(DXGI_FORMAT_A8_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R1_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R9G9B9E5_SHAREDEXP);
        WINE_D3D_TO_STR(DXGI_FORMAT_R8G8_B8G8_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_G8R8_G8B8_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC1_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC1_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC1_UNORM_SRGB);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC2_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC2_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC2_UNORM_SRGB);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC3_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC3_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC3_UNORM_SRGB);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC4_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC4_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC4_SNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC5_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC5_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC5_SNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_B5G6R5_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_B5G5R5A1_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_B8G8R8A8_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_B8G8R8X8_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_B8G8R8A8_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_B8G8R8A8_UNORM_SRGB);
        WINE_D3D_TO_STR(DXGI_FORMAT_B8G8R8X8_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_B8G8R8X8_UNORM_SRGB);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC6H_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC6H_UF16);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC6H_SF16);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC7_TYPELESS);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC7_UNORM);
        WINE_D3D_TO_STR(DXGI_FORMAT_BC7_UNORM_SRGB);
        WINE_D3D_TO_STR(DXGI_FORMAT_NV12);
        WINE_D3D_TO_STR(DXGI_FORMAT_YUY2);
        WINE_D3D_TO_STR(DXGI_FORMAT_B4G4R4A4_UNORM);
        default:
            FIXME("Unrecognized DXGI_FORMAT %#x.\n", format);
            return "unrecognized";
    }
}

Referenced by d3d10_device_CheckFormatSupport(), d3d10_device_CheckMultisampleQualityLevels(), d3d10_device_IASetIndexBuffer(), d3d10_device_ResolveSubresource(), d3d11_device_CheckMultisampleQualityLevels(), d3d11_device_context_IASetIndexBuffer(), d3d11_device_context_ResolveSubresource(), d3d11_swapchain_ResizeBuffers(), d3d11_swapchain_ResizeBuffers1(), d3d12_swapchain_ResizeBuffers(), d3d12_swapchain_ResizeBuffers1(), dxgi_output_GetDisplayModeList(), dxgi_output_GetDisplayModeList1(), and select_vk_format().

◆ debug_float4()

const char * debug_float4 ( const float * values )

Definition at line 161 of file utils.c.

{
    if (!values)
        return "(null)";
    return wine_dbg_sprintf("{%.8e, %.8e, %.8e, %.8e}",
            values[0], values[1], values[2], values[3]);
}

Referenced by d3d10_device_ClearRenderTargetView(), d3d10_device_OMSetBlendState(), d3d11_device_context_ClearRenderTargetView(), d3d11_device_context_ClearUnorderedAccessViewFloat(), and d3d11_device_context_OMSetBlendState().

◆ dxgi_format_from_wined3dformat()

DXGI_FORMAT dxgi_format_from_wined3dformat ( enum wined3d_format_id format )

Definition at line 210 of file utils.c.

{
    switch(format)
    {
        case WINED3DFMT_UNKNOWN: return DXGI_FORMAT_UNKNOWN;
        case WINED3DFMT_R32G32B32A32_TYPELESS: return DXGI_FORMAT_R32G32B32A32_TYPELESS;
        case WINED3DFMT_R32G32B32A32_FLOAT: return DXGI_FORMAT_R32G32B32A32_FLOAT;
        case WINED3DFMT_R32G32B32A32_UINT: return DXGI_FORMAT_R32G32B32A32_UINT;
        case WINED3DFMT_R32G32B32A32_SINT: return DXGI_FORMAT_R32G32B32A32_SINT;
        case WINED3DFMT_R32G32B32_TYPELESS: return DXGI_FORMAT_R32G32B32_TYPELESS;
        case WINED3DFMT_R32G32B32_FLOAT: return DXGI_FORMAT_R32G32B32_FLOAT;
        case WINED3DFMT_R32G32B32_UINT: return DXGI_FORMAT_R32G32B32_UINT;
        case WINED3DFMT_R32G32B32_SINT: return DXGI_FORMAT_R32G32B32_SINT;
        case WINED3DFMT_R16G16B16A16_TYPELESS: return DXGI_FORMAT_R16G16B16A16_TYPELESS;
        case WINED3DFMT_R16G16B16A16_FLOAT: return DXGI_FORMAT_R16G16B16A16_FLOAT;
        case WINED3DFMT_R16G16B16A16_UNORM: return DXGI_FORMAT_R16G16B16A16_UNORM;
        case WINED3DFMT_R16G16B16A16_UINT: return DXGI_FORMAT_R16G16B16A16_UINT;
        case WINED3DFMT_R16G16B16A16_SNORM: return DXGI_FORMAT_R16G16B16A16_SNORM;
        case WINED3DFMT_R16G16B16A16_SINT: return DXGI_FORMAT_R16G16B16A16_SINT;
        case WINED3DFMT_R32G32_TYPELESS: return DXGI_FORMAT_R32G32_TYPELESS;
        case WINED3DFMT_R32G32_FLOAT: return DXGI_FORMAT_R32G32_FLOAT;
        case WINED3DFMT_R32G32_UINT: return DXGI_FORMAT_R32G32_UINT;
        case WINED3DFMT_R32G32_SINT: return DXGI_FORMAT_R32G32_SINT;
        case WINED3DFMT_R32G8X24_TYPELESS: return DXGI_FORMAT_R32G8X24_TYPELESS;
        case WINED3DFMT_D32_FLOAT_S8X24_UINT: return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
        case WINED3DFMT_R32_FLOAT_X8X24_TYPELESS: return DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
        case WINED3DFMT_X32_TYPELESS_G8X24_UINT: return DXGI_FORMAT_X32_TYPELESS_G8X24_UINT;
        case WINED3DFMT_R10G10B10A2_TYPELESS: return DXGI_FORMAT_R10G10B10A2_TYPELESS;
        case WINED3DFMT_R10G10B10A2_UNORM: return DXGI_FORMAT_R10G10B10A2_UNORM;
        case WINED3DFMT_R10G10B10A2_UINT: return DXGI_FORMAT_R10G10B10A2_UINT;
        case WINED3DFMT_R11G11B10_FLOAT: return DXGI_FORMAT_R11G11B10_FLOAT;
        case WINED3DFMT_R8G8B8A8_TYPELESS: return DXGI_FORMAT_R8G8B8A8_TYPELESS;
        case WINED3DFMT_R8G8B8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM;
        case WINED3DFMT_R8G8B8A8_UNORM_SRGB: return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
        case WINED3DFMT_R8G8B8A8_UINT: return DXGI_FORMAT_R8G8B8A8_UINT;
        case WINED3DFMT_R8G8B8A8_SNORM: return DXGI_FORMAT_R8G8B8A8_SNORM;
        case WINED3DFMT_R8G8B8A8_SINT: return DXGI_FORMAT_R8G8B8A8_SINT;
        case WINED3DFMT_R16G16_TYPELESS: return DXGI_FORMAT_R16G16_TYPELESS;
        case WINED3DFMT_R16G16_FLOAT: return DXGI_FORMAT_R16G16_FLOAT;
        case WINED3DFMT_R16G16_UNORM: return DXGI_FORMAT_R16G16_UNORM;
        case WINED3DFMT_R16G16_UINT: return DXGI_FORMAT_R16G16_UINT;
        case WINED3DFMT_R16G16_SNORM: return DXGI_FORMAT_R16G16_SNORM;
        case WINED3DFMT_R16G16_SINT: return DXGI_FORMAT_R16G16_SINT;
        case WINED3DFMT_R32_TYPELESS: return DXGI_FORMAT_R32_TYPELESS;
        case WINED3DFMT_D32_FLOAT: return DXGI_FORMAT_D32_FLOAT;
        case WINED3DFMT_R32_FLOAT: return DXGI_FORMAT_R32_FLOAT;
        case WINED3DFMT_R32_UINT: return DXGI_FORMAT_R32_UINT;
        case WINED3DFMT_R32_SINT: return DXGI_FORMAT_R32_SINT;
        case WINED3DFMT_R24G8_TYPELESS: return DXGI_FORMAT_R24G8_TYPELESS;
        case WINED3DFMT_D24_UNORM_S8_UINT: return DXGI_FORMAT_D24_UNORM_S8_UINT;
        case WINED3DFMT_R24_UNORM_X8_TYPELESS: return DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
        case WINED3DFMT_X24_TYPELESS_G8_UINT: return DXGI_FORMAT_X24_TYPELESS_G8_UINT;
        case WINED3DFMT_R8G8_TYPELESS: return DXGI_FORMAT_R8G8_TYPELESS;
        case WINED3DFMT_R8G8_UNORM: return DXGI_FORMAT_R8G8_UNORM;
        case WINED3DFMT_R8G8_UINT: return DXGI_FORMAT_R8G8_UINT;
        case WINED3DFMT_R8G8_SNORM: return DXGI_FORMAT_R8G8_SNORM;
        case WINED3DFMT_R8G8_SINT: return DXGI_FORMAT_R8G8_SINT;
        case WINED3DFMT_R16_TYPELESS: return DXGI_FORMAT_R16_TYPELESS;
        case WINED3DFMT_R16_FLOAT: return DXGI_FORMAT_R16_FLOAT;
        case WINED3DFMT_D16_UNORM: return DXGI_FORMAT_D16_UNORM;
        case WINED3DFMT_R16_UNORM: return DXGI_FORMAT_R16_UNORM;
        case WINED3DFMT_R16_UINT: return DXGI_FORMAT_R16_UINT;
        case WINED3DFMT_R16_SNORM: return DXGI_FORMAT_R16_SNORM;
        case WINED3DFMT_R16_SINT: return DXGI_FORMAT_R16_SINT;
        case WINED3DFMT_R8_TYPELESS: return DXGI_FORMAT_R8_TYPELESS;
        case WINED3DFMT_R8_UNORM: return DXGI_FORMAT_R8_UNORM;
        case WINED3DFMT_R8_UINT: return DXGI_FORMAT_R8_UINT;
        case WINED3DFMT_R8_SNORM: return DXGI_FORMAT_R8_SNORM;
        case WINED3DFMT_R8_SINT: return DXGI_FORMAT_R8_SINT;
        case WINED3DFMT_A8_UNORM: return DXGI_FORMAT_A8_UNORM;
        case WINED3DFMT_R1_UNORM: return DXGI_FORMAT_R1_UNORM;
        case WINED3DFMT_R9G9B9E5_SHAREDEXP: return DXGI_FORMAT_R9G9B9E5_SHAREDEXP;
        case WINED3DFMT_R8G8_B8G8_UNORM: return DXGI_FORMAT_R8G8_B8G8_UNORM;
        case WINED3DFMT_G8R8_G8B8_UNORM: return DXGI_FORMAT_G8R8_G8B8_UNORM;
        case WINED3DFMT_BC1_TYPELESS: return DXGI_FORMAT_BC1_TYPELESS;
        case WINED3DFMT_BC1_UNORM: return DXGI_FORMAT_BC1_UNORM;
        case WINED3DFMT_BC1_UNORM_SRGB: return DXGI_FORMAT_BC1_UNORM_SRGB;
        case WINED3DFMT_BC2_TYPELESS: return DXGI_FORMAT_BC2_TYPELESS;
        case WINED3DFMT_BC2_UNORM: return DXGI_FORMAT_BC2_UNORM;
        case WINED3DFMT_BC2_UNORM_SRGB: return DXGI_FORMAT_BC2_UNORM_SRGB;
        case WINED3DFMT_BC3_TYPELESS: return DXGI_FORMAT_BC3_TYPELESS;
        case WINED3DFMT_BC3_UNORM: return DXGI_FORMAT_BC3_UNORM;
        case WINED3DFMT_BC3_UNORM_SRGB: return DXGI_FORMAT_BC3_UNORM_SRGB;
        case WINED3DFMT_BC4_TYPELESS: return DXGI_FORMAT_BC4_TYPELESS;
        case WINED3DFMT_BC4_UNORM: return DXGI_FORMAT_BC4_UNORM;
        case WINED3DFMT_BC4_SNORM: return DXGI_FORMAT_BC4_SNORM;
        case WINED3DFMT_BC5_TYPELESS: return DXGI_FORMAT_BC5_TYPELESS;
        case WINED3DFMT_BC5_UNORM: return DXGI_FORMAT_BC5_UNORM;
        case WINED3DFMT_BC5_SNORM: return DXGI_FORMAT_BC5_SNORM;
        case WINED3DFMT_B5G6R5_UNORM: return DXGI_FORMAT_B5G6R5_UNORM;
        case WINED3DFMT_B5G5R5A1_UNORM: return DXGI_FORMAT_B5G5R5A1_UNORM;
        case WINED3DFMT_B8G8R8A8_UNORM: return DXGI_FORMAT_B8G8R8A8_UNORM;
        case WINED3DFMT_B8G8R8X8_UNORM: return DXGI_FORMAT_B8G8R8X8_UNORM;
        case WINED3DFMT_R10G10B10_XR_BIAS_A2_UNORM: return DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM;
        case WINED3DFMT_B8G8R8A8_TYPELESS: return DXGI_FORMAT_B8G8R8A8_TYPELESS;
        case WINED3DFMT_B8G8R8A8_UNORM_SRGB: return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
        case WINED3DFMT_B8G8R8X8_TYPELESS: return DXGI_FORMAT_B8G8R8X8_TYPELESS;
        case WINED3DFMT_B8G8R8X8_UNORM_SRGB: return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
        case WINED3DFMT_BC6H_TYPELESS: return DXGI_FORMAT_BC6H_TYPELESS;
        case WINED3DFMT_BC6H_UF16: return DXGI_FORMAT_BC6H_UF16;
        case WINED3DFMT_BC6H_SF16: return DXGI_FORMAT_BC6H_SF16;
        case WINED3DFMT_BC7_TYPELESS: return DXGI_FORMAT_BC7_TYPELESS;
        case WINED3DFMT_BC7_UNORM: return DXGI_FORMAT_BC7_UNORM;
        case WINED3DFMT_BC7_UNORM_SRGB: return DXGI_FORMAT_BC7_UNORM_SRGB;
        case WINED3DFMT_NV12: return DXGI_FORMAT_NV12;
        case WINED3DFMT_YUY2: return DXGI_FORMAT_YUY2;
        case WINED3DFMT_B4G4R4A4_UNORM: return DXGI_FORMAT_B4G4R4A4_UNORM;
        default:
            FIXME("Unhandled wined3d format %#x.\n", format);
            return DXGI_FORMAT_UNKNOWN;
    }
}

Referenced by d3d10_device_IAGetIndexBuffer(), d3d11_device_context_IAGetIndexBuffer(), d3d11_swapchain_GetDesc(), d3d11_swapchain_GetDesc1(), d3d11_texture2d_GetDesc(), dxgi_device_parent_register_swapchain_texture(), dxgi_mode1_from_wined3d(), dxgi_mode_from_wined3d(), and dxgi_surface_GetDesc().

◆ DXGID3D10CreateDevice()

HRESULT WINAPI DXGID3D10CreateDevice	(	HMODULE	d3d10core,
		IDXGIFactory *	factory,
		IDXGIAdapter *	adapter,
		unsigned int	flags,
		const D3D_FEATURE_LEVEL *	feature_levels,
		unsigned int	level_count,
		void **	device
	)

Definition at line 135 of file dxgi_main.c.

{
    struct layer_get_size_args get_size_args;
    struct dxgi_device_layer d3d10_layer;
    struct dxgi_device *dxgi_device;
    UINT device_size;
    DWORD count;
    HRESULT hr;
 
    TRACE("d3d10core %p, factory %p, adapter %p, flags %#x, feature_levels %p, level_count %u, device %p.\n",
            d3d10core, factory, adapter, flags, feature_levels, level_count, device);
 
    if (flags)
        FIXME("Ignoring flags %#x.\n", flags);
 
    if (TRACE_ON(dxgi))
        dump_feature_levels(feature_levels, level_count);
 
    hr = register_d3d10core_layers(d3d10core);
    if (FAILED(hr))
    {
        ERR("Failed to register d3d10core layers, returning %#lx.\n", hr);
        return hr;
    }
 
    if (!get_layer(DXGI_DEVICE_LAYER_D3D10_DEVICE, &d3d10_layer))
    {
        ERR("Failed to get D3D10 device layer.\n");
        return E_FAIL;
    }
 
    count = 0;
    hr = d3d10_layer.init(d3d10_layer.id, &count, NULL);
    if (FAILED(hr))
    {
        WARN("Failed to initialize D3D10 device layer.\n");
        return E_FAIL;
    }
 
    get_size_args.unknown0 = 0;
    get_size_args.unknown1 = 0;
    get_size_args.unknown2 = NULL;
    get_size_args.unknown3 = NULL;
    get_size_args.adapter = adapter;
    get_size_args.interface_major = 10;
    get_size_args.interface_minor = 1;
    get_size_args.version_build = 4;
    get_size_args.version_revision = 6000;
 
    device_size = d3d10_layer.get_size(d3d10_layer.id, &get_size_args, 0);
    device_size += sizeof(*dxgi_device);
 
    if (!(dxgi_device = calloc(1, device_size)))
    {
        ERR("Failed to allocate device memory.\n");
        return E_OUTOFMEMORY;
    }
 
    hr = dxgi_device_init(dxgi_device, &d3d10_layer, factory, adapter, feature_levels, level_count);
    if (FAILED(hr))
    {
        WARN("Failed to initialize device, hr %#lx.\n", hr);
        free(dxgi_device);
        *device = NULL;
        return hr;
    }
 
    TRACE("Created device %p.\n", dxgi_device);
    *device = &dxgi_device->IWineDXGIDevice_iface;
 
    return S_OK;
}

◆ DXGID3D10RegisterLayers()

HRESULT WINAPI DXGID3D10RegisterLayers	(	const struct dxgi_device_layer *	layers,
		UINT	layer_count
	)

Definition at line 209 of file dxgi_main.c.

{
    UINT i;
    struct dxgi_device_layer *new_layers;
 
    TRACE("layers %p, layer_count %u\n", layers, layer_count);
 
    wined3d_mutex_lock();
 
    new_layers = realloc(dxgi_main.device_layers,
            (dxgi_main.layer_count + layer_count) * sizeof(*new_layers));
 
    if (!new_layers)
    {
        wined3d_mutex_unlock();
        ERR("Failed to allocate layer memory\n");
        return E_OUTOFMEMORY;
    }
 
    for (i = 0; i < layer_count; ++i)
    {
        const struct dxgi_device_layer *layer = &layers[i];
 
        TRACE("layer %d: id %#x, init %p, get_size %p, create %p\n",
                i, layer->id, layer->init, layer->get_size, layer->create);
 
        new_layers[dxgi_main.layer_count + i] = *layer;
    }
 
    dxgi_main.device_layers = new_layers;
    dxgi_main.layer_count += layer_count;
 
    wined3d_mutex_unlock();
 
    return S_OK;
}

Referenced by D3D11CoreRegisterLayers().

◆ impl_from_ID3D10Device()

static struct d3d_device * impl_from_ID3D10Device ( ID3D10Device1 * iface )

inlinestatic

Definition at line 612 of file d3d11_private.h.

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

◆ impl_from_ID3D11BlendState1()

static struct d3d_blend_state * impl_from_ID3D11BlendState1 ( ID3D11BlendState1 * iface )

inlinestatic

Definition at line 428 of file d3d11_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d_blend_state, ID3D11BlendState1_iface);
}

Referenced by d3d10_device_CreateBlendState1(), d3d10_device_OMGetBlendState(), d3d11_blend_state_AddRef(), d3d11_blend_state_GetDesc(), d3d11_blend_state_GetDesc1(), d3d11_blend_state_GetDevice(), d3d11_blend_state_GetPrivateData(), d3d11_blend_state_QueryInterface(), d3d11_blend_state_Release(), d3d11_blend_state_SetPrivateData(), d3d11_blend_state_SetPrivateDataInterface(), and unsafe_impl_from_ID3D11BlendState().

◆ impl_from_ID3D11DepthStencilState()

static struct d3d_depthstencil_state * impl_from_ID3D11DepthStencilState ( ID3D11DepthStencilState * iface )

inlinestatic

Definition at line 452 of file d3d11_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d_depthstencil_state, ID3D11DepthStencilState_iface);
}

Referenced by d3d10_device_OMGetDepthStencilState(), d3d11_depthstencil_state_AddRef(), d3d11_depthstencil_state_GetDesc(), d3d11_depthstencil_state_GetDevice(), d3d11_depthstencil_state_GetPrivateData(), d3d11_depthstencil_state_QueryInterface(), d3d11_depthstencil_state_Release(), d3d11_depthstencil_state_SetPrivateData(), d3d11_depthstencil_state_SetPrivateDataInterface(), and unsafe_impl_from_ID3D11DepthStencilState().

◆ impl_from_ID3D11Device()

static struct d3d_device * impl_from_ID3D11Device ( ID3D11Device * iface )

inlinestatic

Definition at line 602 of file d3d11_private.h.

{
    return CONTAINING_RECORD((ID3D11Device2 *)iface, struct d3d_device, ID3D11Device2_iface);
}

Referenced by D3D11CoreCreateDevice().

◆ impl_from_ID3D11Device2()

static struct d3d_device * impl_from_ID3D11Device2 ( ID3D11Device2 * iface )

inlinestatic

Definition at line 607 of file d3d11_private.h.

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

◆ impl_from_ID3D11Texture2D()

static struct d3d_texture2d * impl_from_ID3D11Texture2D ( ID3D11Texture2D * iface )

inlinestatic

Definition at line 146 of file d3d11_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D11Texture2D_iface);
}

Referenced by d3d11_texture2d_AddRef(), d3d11_texture2d_GetDesc(), d3d11_texture2d_GetDevice(), d3d11_texture2d_GetPrivateData(), d3d11_texture2d_QueryInterface(), d3d11_texture2d_Release(), d3d11_texture2d_SetPrivateData(), and d3d11_texture2d_SetPrivateDataInterface().

◆ unsafe_impl_from_ID3D10BlendState()

struct d3d_blend_state * unsafe_impl_from_ID3D10BlendState ( ID3D10BlendState * iface )

Definition at line 478 of file state.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (ID3D10BlendStateVtbl *)&d3d10_blend_state_vtbl);
 
    return impl_from_ID3D10BlendState((ID3D10BlendState1 *)iface);
}

Referenced by d3d10_device_OMSetBlendState().

◆ unsafe_impl_from_ID3D10Buffer()

struct d3d_buffer * unsafe_impl_from_ID3D10Buffer ( ID3D10Buffer * iface )

Definition at line 386 of file buffer.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d10_buffer_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_buffer, ID3D10Buffer_iface);
}

Referenced by d3d10_device_IASetIndexBuffer(), d3d10_device_IASetVertexBuffers(), d3d10_device_set_constant_buffers(), d3d10_device_SOSetTargets(), and wined3d_resource_from_d3d10_resource().

◆ unsafe_impl_from_ID3D10DepthStencilState()

struct d3d_depthstencil_state * unsafe_impl_from_ID3D10DepthStencilState ( ID3D10DepthStencilState * iface )

Definition at line 879 of file state.c.

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

Referenced by d3d10_device_OMSetDepthStencilState().

◆ unsafe_impl_from_ID3D10DepthStencilView()

struct d3d_depthstencil_view * unsafe_impl_from_ID3D10DepthStencilView ( ID3D10DepthStencilView * iface )

Definition at line 1346 of file view.c.

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

Referenced by d3d10_device_ClearDepthStencilView(), and d3d10_device_OMSetRenderTargets().

◆ unsafe_impl_from_ID3D10GeometryShader()

struct d3d_geometry_shader * unsafe_impl_from_ID3D10GeometryShader ( ID3D10GeometryShader * iface )

Definition at line 1190 of file shader.c.

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

Referenced by d3d10_device_GSSetShader().

◆ unsafe_impl_from_ID3D10InputLayout()

struct d3d_input_layout * unsafe_impl_from_ID3D10InputLayout ( ID3D10InputLayout * iface )

Definition at line 421 of file inputlayout.c.

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

Referenced by d3d10_device_IASetInputLayout().

◆ unsafe_impl_from_ID3D10PixelShader()

struct d3d_pixel_shader * unsafe_impl_from_ID3D10PixelShader ( ID3D10PixelShader * iface )

Definition at line 1491 of file shader.c.

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

Referenced by d3d10_device_PSSetShader().

◆ unsafe_impl_from_ID3D10Query()

struct d3d_query * unsafe_impl_from_ID3D10Query ( ID3D10Query * iface )

Definition at line 398 of file async.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d10_query_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_query, ID3D10Query_iface);
}

Referenced by d3d10_device_SetPredication().

◆ unsafe_impl_from_ID3D10RasterizerState()

struct d3d_rasterizer_state * unsafe_impl_from_ID3D10RasterizerState ( ID3D10RasterizerState * iface )

Definition at line 1278 of file state.c.

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

Referenced by d3d10_device_RSSetState().

◆ unsafe_impl_from_ID3D10RenderTargetView()

struct d3d_rendertarget_view * unsafe_impl_from_ID3D10RenderTargetView ( ID3D10RenderTargetView * iface )

Definition at line 1787 of file view.c.

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

Referenced by d3d10_device_ClearRenderTargetView(), and d3d10_device_OMSetRenderTargets().

◆ unsafe_impl_from_ID3D10SamplerState()

struct d3d_sampler_state * unsafe_impl_from_ID3D10SamplerState ( ID3D10SamplerState * iface )

Definition at line 1691 of file state.c.

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

Referenced by d3d10_device_set_samplers().

◆ unsafe_impl_from_ID3D10ShaderResourceView()

struct d3d_shader_resource_view * unsafe_impl_from_ID3D10ShaderResourceView ( ID3D10ShaderResourceView * iface )

Definition at line 2280 of file view.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (ID3D10ShaderResourceViewVtbl *)&d3d10_shader_resource_view_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
}

Referenced by d3d10_device_GenerateMips(), and d3d10_device_set_shader_resource_views().

◆ unsafe_impl_from_ID3D10Texture1D()

struct d3d_texture1d * unsafe_impl_from_ID3D10Texture1D ( ID3D10Texture1D * iface )

Definition at line 403 of file texture.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d10_texture1d_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_texture1d, ID3D10Texture1D_iface);
}

Referenced by wined3d_resource_from_d3d10_resource().

◆ unsafe_impl_from_ID3D10Texture2D()

struct d3d_texture2d * unsafe_impl_from_ID3D10Texture2D ( ID3D10Texture2D * iface )

Definition at line 907 of file texture.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d10_texture2d_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D10Texture2D_iface);
}

Referenced by wined3d_resource_from_d3d10_resource().

◆ unsafe_impl_from_ID3D10Texture3D()

struct d3d_texture3d * unsafe_impl_from_ID3D10Texture3D ( ID3D10Texture3D * iface )

Definition at line 1424 of file texture.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d10_texture3d_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_texture3d, ID3D10Texture3D_iface);
}

Referenced by wined3d_resource_from_d3d10_resource().

◆ unsafe_impl_from_ID3D10VertexShader()

struct d3d_vertex_shader * unsafe_impl_from_ID3D10VertexShader ( ID3D10VertexShader * iface )

Definition at line 318 of file shader.c.

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

Referenced by d3d10_device_VSSetShader().

◆ unsafe_impl_from_ID3D11Asynchronous()

struct d3d_query * unsafe_impl_from_ID3D11Asynchronous ( ID3D11Asynchronous * iface )

Definition at line 199 of file async.c.

{
    return unsafe_impl_from_ID3D11Query((ID3D11Query *)iface);
}

Referenced by d3d11_device_context_Begin(), d3d11_device_context_End(), and d3d11_device_context_GetData().

◆ unsafe_impl_from_ID3D11BlendState()

struct d3d_blend_state * unsafe_impl_from_ID3D11BlendState ( ID3D11BlendState * iface )

Definition at line 469 of file state.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (ID3D11BlendStateVtbl *)&d3d11_blend_state_vtbl);
 
    return impl_from_ID3D11BlendState1((ID3D11BlendState1 *)iface);
}

Referenced by d3d11_device_context_OMSetBlendState().

◆ unsafe_impl_from_ID3D11Buffer()

struct d3d_buffer * unsafe_impl_from_ID3D11Buffer ( ID3D11Buffer * iface )

Definition at line 214 of file buffer.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d11_buffer_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_buffer, ID3D11Buffer_iface);
}

Referenced by d3d11_device_context_CopyStructureCount(), d3d11_device_context_DispatchIndirect(), d3d11_device_context_DrawIndexedInstancedIndirect(), d3d11_device_context_DrawInstancedIndirect(), d3d11_device_context_IASetIndexBuffer(), d3d11_device_context_IASetVertexBuffers(), d3d11_device_context_set_constant_buffers(), d3d11_device_context_SOSetTargets(), and wined3d_resource_from_d3d11_resource().

◆ unsafe_impl_from_ID3D11ComputeShader()

struct d3d11_compute_shader * unsafe_impl_from_ID3D11ComputeShader ( ID3D11ComputeShader * iface )

Definition at line 1676 of file shader.c.

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

Referenced by d3d11_device_context_CSSetShader().

◆ unsafe_impl_from_ID3D11DepthStencilState()

struct d3d_depthstencil_state * unsafe_impl_from_ID3D11DepthStencilState ( ID3D11DepthStencilState * iface )

Definition at line 870 of file state.c.

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

Referenced by d3d11_device_context_OMSetDepthStencilState().

◆ unsafe_impl_from_ID3D11DepthStencilView()

struct d3d_depthstencil_view * unsafe_impl_from_ID3D11DepthStencilView ( ID3D11DepthStencilView * iface )

Definition at line 1337 of file view.c.

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

Referenced by d3d11_device_context_ClearDepthStencilView(), d3d11_device_context_OMSetRenderTargets(), and d3d11_device_context_OMSetRenderTargetsAndUnorderedAccessViews().

◆ unsafe_impl_from_ID3D11DomainShader()

struct d3d11_domain_shader * unsafe_impl_from_ID3D11DomainShader ( ID3D11DomainShader * iface )

Definition at line 692 of file shader.c.

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

Referenced by d3d11_device_context_DSSetShader().

◆ unsafe_impl_from_ID3D11GeometryShader()

struct d3d_geometry_shader * unsafe_impl_from_ID3D11GeometryShader ( ID3D11GeometryShader * iface )

Definition at line 1181 of file shader.c.

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

Referenced by d3d11_device_context_GSSetShader().

◆ unsafe_impl_from_ID3D11HullShader()

struct d3d11_hull_shader * unsafe_impl_from_ID3D11HullShader ( ID3D11HullShader * iface )

Definition at line 505 of file shader.c.

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

Referenced by d3d11_device_context_HSSetShader().

◆ unsafe_impl_from_ID3D11InputLayout()

struct d3d_input_layout * unsafe_impl_from_ID3D11InputLayout ( ID3D11InputLayout * iface )

Definition at line 412 of file inputlayout.c.

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

Referenced by d3d11_device_context_IASetInputLayout().

◆ unsafe_impl_from_ID3D11PixelShader()

struct d3d_pixel_shader * unsafe_impl_from_ID3D11PixelShader ( ID3D11PixelShader * iface )

Definition at line 1482 of file shader.c.

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

Referenced by d3d11_device_context_PSSetShader().

◆ unsafe_impl_from_ID3D11Query()

struct d3d_query * unsafe_impl_from_ID3D11Query ( ID3D11Query * iface )

Definition at line 191 of file async.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d11_query_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_query, ID3D11Query_iface);
}

Referenced by d3d11_device_context_SetPredication(), and unsafe_impl_from_ID3D11Asynchronous().

◆ unsafe_impl_from_ID3D11RasterizerState()

struct d3d_rasterizer_state * unsafe_impl_from_ID3D11RasterizerState ( ID3D11RasterizerState * iface )

Definition at line 1269 of file state.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == (ID3D11RasterizerStateVtbl *)&d3d11_rasterizer_state_vtbl);
 
    return impl_from_ID3D11RasterizerState1((ID3D11RasterizerState1 *)iface);
}

Referenced by d3d11_device_context_RSSetState().

◆ unsafe_impl_from_ID3D11RenderTargetView()

struct d3d_rendertarget_view * unsafe_impl_from_ID3D11RenderTargetView ( ID3D11RenderTargetView * iface )

Definition at line 1778 of file view.c.

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

Referenced by d3d11_device_context_ClearRenderTargetView(), d3d11_device_context_OMSetRenderTargets(), and d3d11_device_context_OMSetRenderTargetsAndUnorderedAccessViews().

◆ unsafe_impl_from_ID3D11SamplerState()

struct d3d_sampler_state * unsafe_impl_from_ID3D11SamplerState ( ID3D11SamplerState * iface )

Definition at line 1682 of file state.c.

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

Referenced by d3d11_device_context_set_samplers().

◆ unsafe_impl_from_ID3D11ShaderResourceView()

struct d3d_shader_resource_view * unsafe_impl_from_ID3D11ShaderResourceView ( ID3D11ShaderResourceView * iface )

Definition at line 2272 of file view.c.

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

Referenced by d3d11_device_context_GenerateMips(), and d3d11_device_context_set_shader_resource_views().

◆ unsafe_impl_from_ID3D11Texture1D()

struct d3d_texture1d * unsafe_impl_from_ID3D11Texture1D ( ID3D11Texture1D * iface )

Definition at line 216 of file texture.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d11_texture1d_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_texture1d, ID3D11Texture1D_iface);
}

Referenced by get_resource_properties(), and wined3d_resource_from_d3d11_resource().

◆ unsafe_impl_from_ID3D11Texture2D()

struct d3d_texture2d * unsafe_impl_from_ID3D11Texture2D ( ID3D11Texture2D * iface )

Definition at line 718 of file texture.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d11_texture2d_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_texture2d, ID3D11Texture2D_iface);
}

Referenced by get_resource_properties(), and wined3d_resource_from_d3d11_resource().

◆ unsafe_impl_from_ID3D11Texture3D()

struct d3d_texture3d * unsafe_impl_from_ID3D11Texture3D ( ID3D11Texture3D * iface )

Definition at line 1432 of file texture.c.

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

Referenced by get_resource_properties(), and wined3d_resource_from_d3d11_resource().

◆ unsafe_impl_from_ID3D11UnorderedAccessView()

struct d3d11_unordered_access_view * unsafe_impl_from_ID3D11UnorderedAccessView ( ID3D11UnorderedAccessView * iface )

Definition at line 2575 of file view.c.

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

Referenced by d3d11_device_context_ClearUnorderedAccessViewFloat(), d3d11_device_context_ClearUnorderedAccessViewUint(), d3d11_device_context_CopyStructureCount(), d3d11_device_context_CSSetUnorderedAccessViews(), and d3d11_device_context_OMSetRenderTargetsAndUnorderedAccessViews().

◆ unsafe_impl_from_ID3D11VertexShader()

struct d3d_vertex_shader * unsafe_impl_from_ID3D11VertexShader ( ID3D11VertexShader * iface )

Definition at line 309 of file shader.c.

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

Referenced by d3d11_device_context_VSSetShader().

◆ validate_d3d11_resource_access_flags()

BOOL validate_d3d11_resource_access_flags	(	D3D11_RESOURCE_DIMENSION	resource_dimension,
		D3D11_USAGE	usage,
		UINT	bind_flags,
		UINT	cpu_access_flags,
		D3D_FEATURE_LEVEL	feature_level
	)

Definition at line 601 of file utils.c.

{
    const BOOL is_texture = resource_dimension != D3D11_RESOURCE_DIMENSION_BUFFER;
 
    switch (usage)
    {
        case D3D11_USAGE_DEFAULT:
            if ((bind_flags == D3D11_BIND_SHADER_RESOURCE && feature_level >= D3D_FEATURE_LEVEL_11_0)
                    || (is_texture && bind_flags == D3D11_BIND_RENDER_TARGET)
                    || bind_flags == D3D11_BIND_UNORDERED_ACCESS)
                break;
            if (cpu_access_flags)
            {
                WARN("Default resources are not CPU accessible.\n");
                return FALSE;
            }
            break;
 
        case D3D11_USAGE_IMMUTABLE:
            if (!bind_flags)
            {
                WARN("Bind flags must be non-zero for immutable resources.\n");
                return FALSE;
            }
            if (!d3d11_bind_flags_are_gpu_read_only(bind_flags))
            {
                WARN("Immutable resources cannot be writable by GPU.\n");
                return FALSE;
            }
 
            if (cpu_access_flags)
            {
                WARN("Immutable resources are not CPU accessible.\n");
                return FALSE;
            }
            break;
 
        case D3D11_USAGE_DYNAMIC:
            if (!bind_flags)
            {
                WARN("Bind flags must be non-zero for dynamic resources.\n");
                return FALSE;
            }
            if (!d3d11_bind_flags_are_gpu_read_only(bind_flags))
            {
                WARN("Dynamic resources cannot be writable by GPU.\n");
                return FALSE;
            }
 
            if (cpu_access_flags != D3D11_CPU_ACCESS_WRITE)
            {
                WARN("CPU access must be D3D11_CPU_ACCESS_WRITE for dynamic resources.\n");
                return FALSE;
            }
            break;
 
        case D3D11_USAGE_STAGING:
            if (bind_flags)
            {
                WARN("Invalid bind flags %#x for staging resources.\n", bind_flags);
                return FALSE;
            }
 
            if (!cpu_access_flags)
            {
                WARN("CPU access must be non-zero for staging resources.\n");
                return FALSE;
            }
            break;
 
        default:
            WARN("Invalid usage %#x.\n", usage);
            return FALSE;
    }
 
    return TRUE;
}

Referenced by validate_buffer_desc(), and validate_texture2d_desc().

◆ wined3d_access_from_d3d11()

unsigned int wined3d_access_from_d3d11	(	D3D11_USAGE	usage,
		UINT	cpu_access
	)

Definition at line 788 of file utils.c.

{
    unsigned int access;
 
    access = usage == D3D11_USAGE_STAGING ? WINED3D_RESOURCE_ACCESS_CPU : WINED3D_RESOURCE_ACCESS_GPU;
    if (cpu_access & D3D11_CPU_ACCESS_WRITE)
        access |= WINED3D_RESOURCE_ACCESS_MAP_W;
    if (cpu_access & D3D11_CPU_ACCESS_READ)
        access |= WINED3D_RESOURCE_ACCESS_MAP_R;
    if (cpu_access &= ~(D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ))
        FIXME("Unhandled CPU access flags %#x.\n", cpu_access);
 
    return access;
}

Referenced by d3d_buffer_init(), d3d_texture1d_create(), d3d_texture2d_create(), and d3d_texture3d_init().

◆ wined3d_bind_flags_from_d3d11()

static unsigned int wined3d_bind_flags_from_d3d11	(	UINT	bind_flags,
		UINT	misc_flags
	)

inlinestatic

Definition at line 85 of file d3d11_private.h.

{
    unsigned int wined3d_flags = bind_flags & (D3D11_BIND_VERTEX_BUFFER
            | D3D11_BIND_INDEX_BUFFER
            | D3D11_BIND_CONSTANT_BUFFER
            | D3D11_BIND_SHADER_RESOURCE
            | D3D11_BIND_STREAM_OUTPUT
            | D3D11_BIND_RENDER_TARGET
            | D3D11_BIND_DEPTH_STENCIL
            | D3D11_BIND_UNORDERED_ACCESS);
 
    if (misc_flags & D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS)
        wined3d_flags |= WINED3D_BIND_INDIRECT_BUFFER;
 
    return wined3d_flags;
}

Referenced by d3d_buffer_init(), d3d_texture1d_create(), d3d_texture2d_create(), and d3d_texture3d_init().

◆ wined3d_clear_flags_from_d3d11_clear_flags()

DWORD wined3d_clear_flags_from_d3d11_clear_flags ( UINT clear_flags )

Definition at line 770 of file utils.c.

{
    DWORD wined3d_clear_flags = 0;
 
    if (clear_flags & D3D11_CLEAR_DEPTH)
        wined3d_clear_flags |= WINED3DCLEAR_ZBUFFER;
    if (clear_flags & D3D11_CLEAR_STENCIL)
        wined3d_clear_flags |= WINED3DCLEAR_STENCIL;
 
    if (clear_flags & ~(D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL))
    {
        FIXME("Unhandled clear flags %#x.\n",
                clear_flags & ~(D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL));
    }
 
    return wined3d_clear_flags;
}

Referenced by d3d10_device_ClearDepthStencilView(), and d3d11_device_context_ClearDepthStencilView().

◆ wined3d_getdata_flags_from_d3d11_async_getdata_flags()

unsigned int wined3d_getdata_flags_from_d3d11_async_getdata_flags ( unsigned int d3d11_flags )

Definition at line 436 of file utils.c.

{
    if (d3d11_flags & ~D3D11_ASYNC_GETDATA_DONOTFLUSH)
        FIXME("Unhandled async getdata flags %#x.\n", d3d11_flags);
 
    if (d3d11_flags & D3D11_ASYNC_GETDATA_DONOTFLUSH)
        return 0;
 
    return WINED3DGETDATA_FLUSH;
}

Referenced by d3d10_query_GetData(), and d3d11_device_context_GetData().

◆ wined3d_map_flags_from_d3d10_map_type()

DWORD wined3d_map_flags_from_d3d10_map_type ( D3D10_MAP map_type )

Definition at line 765 of file utils.c.

{
    return wined3d_map_flags_from_d3d11_map_type((D3D11_MAP)map_type);
}

Referenced by d3d10_buffer_Map(), d3d10_texture1d_Map(), d3d10_texture2d_Map(), and d3d10_texture3d_Map().

◆ wined3d_map_flags_from_d3d11_map_type()

DWORD wined3d_map_flags_from_d3d11_map_type ( D3D11_MAP map_type )

Definition at line 740 of file utils.c.

{
    switch (map_type)
    {
        case D3D11_MAP_WRITE:
            return WINED3D_MAP_WRITE;
 
        case D3D11_MAP_READ_WRITE:
            return WINED3D_MAP_READ | WINED3D_MAP_WRITE;
 
        case D3D11_MAP_READ:
            return WINED3D_MAP_READ;
 
        case D3D11_MAP_WRITE_DISCARD:
            return WINED3D_MAP_WRITE | WINED3D_MAP_DISCARD;
 
        case D3D11_MAP_WRITE_NO_OVERWRITE:
            return WINED3D_MAP_WRITE | WINED3D_MAP_NOOVERWRITE;
 
        default:
            FIXME("Unhandled map_type %#x.\n", map_type);
            return WINED3D_MAP_READ | WINED3D_MAP_WRITE;
    }
}

Referenced by d3d11_device_context_Map(), and wined3d_map_flags_from_d3d10_map_type().

◆ wined3d_primitive_type_from_d3d11_primitive_topology()

void wined3d_primitive_type_from_d3d11_primitive_topology	(	D3D11_PRIMITIVE_TOPOLOGY	topology,
		enum wined3d_primitive_type *	type,
		unsigned int *	patch_vertex_count
	)

Definition at line 187 of file utils.c.

{
    if (topology <= D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ)
    {
        *type = (enum wined3d_primitive_type)topology;
        *patch_vertex_count = 0;
        return;
    }
 
    if (D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST <= topology
            && topology <= D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST)
    {
        *type = WINED3D_PT_PATCH;
        *patch_vertex_count = topology - D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST + 1;
        return;
    }
 
    WARN("Invalid primitive topology %#x.\n", topology);
    *type = WINED3D_PT_UNDEFINED;
    *patch_vertex_count = 0;
}

Referenced by d3d11_device_context_IASetPrimitiveTopology().

◆ wined3d_resource_from_d3d10_resource()

struct wined3d_resource * wined3d_resource_from_d3d10_resource ( ID3D10Resource * resource )

Definition at line 710 of file utils.c.

{
    D3D10_RESOURCE_DIMENSION dimension;
 
    ID3D10Resource_GetType(resource, &dimension);
 
    switch (dimension)
    {
        case D3D10_RESOURCE_DIMENSION_BUFFER:
            return wined3d_buffer_get_resource(unsafe_impl_from_ID3D10Buffer(
                    (ID3D10Buffer *)resource)->wined3d_buffer);
 
        case D3D10_RESOURCE_DIMENSION_TEXTURE1D:
            return wined3d_texture_get_resource(unsafe_impl_from_ID3D10Texture1D(
                    (ID3D10Texture1D *)resource)->wined3d_texture);
 
        case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
            return wined3d_texture_get_resource(unsafe_impl_from_ID3D10Texture2D(
                    (ID3D10Texture2D *)resource)->wined3d_texture);
 
        case D3D10_RESOURCE_DIMENSION_TEXTURE3D:
            return wined3d_texture_get_resource(unsafe_impl_from_ID3D10Texture3D(
                    (ID3D10Texture3D *)resource)->wined3d_texture);
 
        default:
            FIXME("Unhandled resource dimension %#x.\n", dimension);
            return NULL;
    }
}

Referenced by d3d10_device_CopyResource(), d3d10_device_CopySubresourceRegion(), and d3d10_device_ResolveSubresource().

◆ wined3d_resource_from_d3d11_resource()

struct wined3d_resource * wined3d_resource_from_d3d11_resource ( ID3D11Resource * resource )

Definition at line 680 of file utils.c.

{
    D3D11_RESOURCE_DIMENSION dimension;
 
    ID3D11Resource_GetType(resource, &dimension);
 
    switch (dimension)
    {
        case D3D11_RESOURCE_DIMENSION_BUFFER:
            return wined3d_buffer_get_resource(unsafe_impl_from_ID3D11Buffer(
                    (ID3D11Buffer *)resource)->wined3d_buffer);
 
        case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
            return wined3d_texture_get_resource(unsafe_impl_from_ID3D11Texture1D(
                    (ID3D11Texture1D *)resource)->wined3d_texture);
 
        case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
            return wined3d_texture_get_resource(unsafe_impl_from_ID3D11Texture2D(
                    (ID3D11Texture2D *)resource)->wined3d_texture);
 
        case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
            return wined3d_texture_get_resource(unsafe_impl_from_ID3D11Texture3D(
                    (ID3D11Texture3D *)resource)->wined3d_texture);
 
        default:
            FIXME("Unhandled resource dimension %#x.\n", dimension);
            return NULL;
    }
}

Referenced by d3d11_device_context_CopyResource(), d3d11_device_context_CopySubresourceRegion(), d3d11_device_context_CopySubresourceRegion1(), d3d11_device_context_Map(), d3d11_device_context_ResolveSubresource(), d3d11_device_context_Unmap(), d3d11_device_context_UpdateSubresource(), d3d11_device_context_UpdateSubresource1(), d3d11_unordered_access_view_init(), d3d_depthstencil_view_init(), d3d_rendertarget_view_init(), and d3d_shader_resource_view_init().

◆ wined3d_usage_from_d3d11()

DWORD wined3d_usage_from_d3d11 ( enum D3D11_USAGE usage )

Definition at line 447 of file utils.c.

{
    DWORD wined3d_usage = 0;
 
    if (usage == D3D11_USAGE_DYNAMIC)
        wined3d_usage |= WINED3DUSAGE_DYNAMIC;
 
    return wined3d_usage;
}

Referenced by d3d_buffer_init(), d3d_texture1d_create(), d3d_texture2d_create(), and d3d_texture3d_init().

◆ wined3dformat_from_dxgi_format()

enum wined3d_format_id wined3dformat_from_dxgi_format ( DXGI_FORMAT format )

Definition at line 323 of file utils.c.

{
    switch(format)
    {
        case DXGI_FORMAT_UNKNOWN: return WINED3DFMT_UNKNOWN;
        case DXGI_FORMAT_R32G32B32A32_TYPELESS: return WINED3DFMT_R32G32B32A32_TYPELESS;
        case DXGI_FORMAT_R32G32B32A32_FLOAT: return WINED3DFMT_R32G32B32A32_FLOAT;
        case DXGI_FORMAT_R32G32B32A32_UINT: return WINED3DFMT_R32G32B32A32_UINT;
        case DXGI_FORMAT_R32G32B32A32_SINT: return WINED3DFMT_R32G32B32A32_SINT;
        case DXGI_FORMAT_R32G32B32_TYPELESS: return WINED3DFMT_R32G32B32_TYPELESS;
        case DXGI_FORMAT_R32G32B32_FLOAT: return WINED3DFMT_R32G32B32_FLOAT;
        case DXGI_FORMAT_R32G32B32_UINT: return WINED3DFMT_R32G32B32_UINT;
        case DXGI_FORMAT_R32G32B32_SINT: return WINED3DFMT_R32G32B32_SINT;
        case DXGI_FORMAT_R16G16B16A16_TYPELESS: return WINED3DFMT_R16G16B16A16_TYPELESS;
        case DXGI_FORMAT_R16G16B16A16_FLOAT: return WINED3DFMT_R16G16B16A16_FLOAT;
        case DXGI_FORMAT_R16G16B16A16_UNORM: return WINED3DFMT_R16G16B16A16_UNORM;
        case DXGI_FORMAT_R16G16B16A16_UINT: return WINED3DFMT_R16G16B16A16_UINT;
        case DXGI_FORMAT_R16G16B16A16_SNORM: return WINED3DFMT_R16G16B16A16_SNORM;
        case DXGI_FORMAT_R16G16B16A16_SINT: return WINED3DFMT_R16G16B16A16_SINT;
        case DXGI_FORMAT_R32G32_TYPELESS: return WINED3DFMT_R32G32_TYPELESS;
        case DXGI_FORMAT_R32G32_FLOAT: return WINED3DFMT_R32G32_FLOAT;
        case DXGI_FORMAT_R32G32_UINT: return WINED3DFMT_R32G32_UINT;
        case DXGI_FORMAT_R32G32_SINT: return WINED3DFMT_R32G32_SINT;
        case DXGI_FORMAT_R32G8X24_TYPELESS: return WINED3DFMT_R32G8X24_TYPELESS;
        case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: return WINED3DFMT_D32_FLOAT_S8X24_UINT;
        case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: return WINED3DFMT_R32_FLOAT_X8X24_TYPELESS;
        case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: return WINED3DFMT_X32_TYPELESS_G8X24_UINT;
        case DXGI_FORMAT_R10G10B10A2_TYPELESS: return WINED3DFMT_R10G10B10A2_TYPELESS;
        case DXGI_FORMAT_R10G10B10A2_UNORM: return WINED3DFMT_R10G10B10A2_UNORM;
        case DXGI_FORMAT_R10G10B10A2_UINT: return WINED3DFMT_R10G10B10A2_UINT;
        case DXGI_FORMAT_R11G11B10_FLOAT: return WINED3DFMT_R11G11B10_FLOAT;
        case DXGI_FORMAT_R8G8B8A8_TYPELESS: return WINED3DFMT_R8G8B8A8_TYPELESS;
        case DXGI_FORMAT_R8G8B8A8_UNORM: return WINED3DFMT_R8G8B8A8_UNORM;
        case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: return WINED3DFMT_R8G8B8A8_UNORM_SRGB;
        case DXGI_FORMAT_R8G8B8A8_UINT: return WINED3DFMT_R8G8B8A8_UINT;
        case DXGI_FORMAT_R8G8B8A8_SNORM: return WINED3DFMT_R8G8B8A8_SNORM;
        case DXGI_FORMAT_R8G8B8A8_SINT: return WINED3DFMT_R8G8B8A8_SINT;
        case DXGI_FORMAT_R16G16_TYPELESS: return WINED3DFMT_R16G16_TYPELESS;
        case DXGI_FORMAT_R16G16_FLOAT: return WINED3DFMT_R16G16_FLOAT;
        case DXGI_FORMAT_R16G16_UNORM: return WINED3DFMT_R16G16_UNORM;
        case DXGI_FORMAT_R16G16_UINT: return WINED3DFMT_R16G16_UINT;
        case DXGI_FORMAT_R16G16_SNORM: return WINED3DFMT_R16G16_SNORM;
        case DXGI_FORMAT_R16G16_SINT: return WINED3DFMT_R16G16_SINT;
        case DXGI_FORMAT_R32_TYPELESS: return WINED3DFMT_R32_TYPELESS;
        case DXGI_FORMAT_D32_FLOAT: return WINED3DFMT_D32_FLOAT;
        case DXGI_FORMAT_R32_FLOAT: return WINED3DFMT_R32_FLOAT;
        case DXGI_FORMAT_R32_UINT: return WINED3DFMT_R32_UINT;
        case DXGI_FORMAT_R32_SINT: return WINED3DFMT_R32_SINT;
        case DXGI_FORMAT_R24G8_TYPELESS: return WINED3DFMT_R24G8_TYPELESS;
        case DXGI_FORMAT_D24_UNORM_S8_UINT: return WINED3DFMT_D24_UNORM_S8_UINT;
        case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: return WINED3DFMT_R24_UNORM_X8_TYPELESS;
        case DXGI_FORMAT_X24_TYPELESS_G8_UINT: return WINED3DFMT_X24_TYPELESS_G8_UINT;
        case DXGI_FORMAT_R8G8_TYPELESS: return WINED3DFMT_R8G8_TYPELESS;
        case DXGI_FORMAT_R8G8_UNORM: return WINED3DFMT_R8G8_UNORM;
        case DXGI_FORMAT_R8G8_UINT: return WINED3DFMT_R8G8_UINT;
        case DXGI_FORMAT_R8G8_SNORM: return WINED3DFMT_R8G8_SNORM;
        case DXGI_FORMAT_R8G8_SINT: return WINED3DFMT_R8G8_SINT;
        case DXGI_FORMAT_R16_TYPELESS: return WINED3DFMT_R16_TYPELESS;
        case DXGI_FORMAT_R16_FLOAT: return WINED3DFMT_R16_FLOAT;
        case DXGI_FORMAT_D16_UNORM: return WINED3DFMT_D16_UNORM;
        case DXGI_FORMAT_R16_UNORM: return WINED3DFMT_R16_UNORM;
        case DXGI_FORMAT_R16_UINT: return WINED3DFMT_R16_UINT;
        case DXGI_FORMAT_R16_SNORM: return WINED3DFMT_R16_SNORM;
        case DXGI_FORMAT_R16_SINT: return WINED3DFMT_R16_SINT;
        case DXGI_FORMAT_R8_TYPELESS: return WINED3DFMT_R8_TYPELESS;
        case DXGI_FORMAT_R8_UNORM: return WINED3DFMT_R8_UNORM;
        case DXGI_FORMAT_R8_UINT: return WINED3DFMT_R8_UINT;
        case DXGI_FORMAT_R8_SNORM: return WINED3DFMT_R8_SNORM;
        case DXGI_FORMAT_R8_SINT: return WINED3DFMT_R8_SINT;
        case DXGI_FORMAT_A8_UNORM: return WINED3DFMT_A8_UNORM;
        case DXGI_FORMAT_R1_UNORM: return WINED3DFMT_R1_UNORM;
        case DXGI_FORMAT_R9G9B9E5_SHAREDEXP: return WINED3DFMT_R9G9B9E5_SHAREDEXP;
        case DXGI_FORMAT_R8G8_B8G8_UNORM: return WINED3DFMT_R8G8_B8G8_UNORM;
        case DXGI_FORMAT_G8R8_G8B8_UNORM: return WINED3DFMT_G8R8_G8B8_UNORM;
        case DXGI_FORMAT_BC1_TYPELESS: return WINED3DFMT_BC1_TYPELESS;
        case DXGI_FORMAT_BC1_UNORM: return WINED3DFMT_BC1_UNORM;
        case DXGI_FORMAT_BC1_UNORM_SRGB: return WINED3DFMT_BC1_UNORM_SRGB;
        case DXGI_FORMAT_BC2_TYPELESS: return WINED3DFMT_BC2_TYPELESS;
        case DXGI_FORMAT_BC2_UNORM: return WINED3DFMT_BC2_UNORM;
        case DXGI_FORMAT_BC2_UNORM_SRGB: return WINED3DFMT_BC2_UNORM_SRGB;
        case DXGI_FORMAT_BC3_TYPELESS: return WINED3DFMT_BC3_TYPELESS;
        case DXGI_FORMAT_BC3_UNORM: return WINED3DFMT_BC3_UNORM;
        case DXGI_FORMAT_BC3_UNORM_SRGB: return WINED3DFMT_BC3_UNORM_SRGB;
        case DXGI_FORMAT_BC4_TYPELESS: return WINED3DFMT_BC4_TYPELESS;
        case DXGI_FORMAT_BC4_UNORM: return WINED3DFMT_BC4_UNORM;
        case DXGI_FORMAT_BC4_SNORM: return WINED3DFMT_BC4_SNORM;
        case DXGI_FORMAT_BC5_TYPELESS: return WINED3DFMT_BC5_TYPELESS;
        case DXGI_FORMAT_BC5_UNORM: return WINED3DFMT_BC5_UNORM;
        case DXGI_FORMAT_BC5_SNORM: return WINED3DFMT_BC5_SNORM;
        case DXGI_FORMAT_B5G6R5_UNORM: return WINED3DFMT_B5G6R5_UNORM;
        case DXGI_FORMAT_B5G5R5A1_UNORM: return WINED3DFMT_B5G5R5A1_UNORM;
        case DXGI_FORMAT_B8G8R8A8_UNORM: return WINED3DFMT_B8G8R8A8_UNORM;
        case DXGI_FORMAT_B8G8R8X8_UNORM: return WINED3DFMT_B8G8R8X8_UNORM;
        case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM: return WINED3DFMT_R10G10B10_XR_BIAS_A2_UNORM;
        case DXGI_FORMAT_B8G8R8A8_TYPELESS: return WINED3DFMT_B8G8R8A8_TYPELESS;
        case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: return WINED3DFMT_B8G8R8A8_UNORM_SRGB;
        case DXGI_FORMAT_B8G8R8X8_TYPELESS: return WINED3DFMT_B8G8R8X8_TYPELESS;
        case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: return WINED3DFMT_B8G8R8X8_UNORM_SRGB;
        case DXGI_FORMAT_BC6H_TYPELESS: return WINED3DFMT_BC6H_TYPELESS;
        case DXGI_FORMAT_BC6H_UF16: return WINED3DFMT_BC6H_UF16;
        case DXGI_FORMAT_BC6H_SF16: return WINED3DFMT_BC6H_SF16;
        case DXGI_FORMAT_BC7_TYPELESS: return WINED3DFMT_BC7_TYPELESS;
        case DXGI_FORMAT_BC7_UNORM: return WINED3DFMT_BC7_UNORM;
        case DXGI_FORMAT_BC7_UNORM_SRGB: return WINED3DFMT_BC7_UNORM_SRGB;
        case DXGI_FORMAT_NV12: return WINED3DFMT_NV12;
        case DXGI_FORMAT_YUY2: return WINED3DFMT_YUY2;
        case DXGI_FORMAT_B4G4R4A4_UNORM: return WINED3DFMT_B4G4R4A4_UNORM;
        default:
            FIXME("Unhandled DXGI_FORMAT %#x.\n", format);
            return WINED3DFMT_UNKNOWN;
    }
}

Referenced by d3d10_device_IASetIndexBuffer(), d3d10_device_ResolveSubresource(), d3d11_device_CheckFormatSupport(), d3d11_device_CheckMultisampleQualityLevels(), d3d11_device_context_IASetIndexBuffer(), d3d11_device_context_ResolveSubresource(), d3d11_input_layout_to_wined3d_declaration(), d3d11_swapchain_ResizeBuffers(), d3d_texture1d_create(), d3d_texture2d_create(), d3d_texture3d_init(), dxgi_device_CreateSurface(), dxgi_output_get_display_mode_list(), wined3d_depth_stencil_view_desc_from_d3d11(), wined3d_rendertarget_view_desc_from_d3d11(), wined3d_shader_resource_view_desc_from_d3d11(), and wined3d_unordered_access_view_desc_from_d3d11().

Classes

Macros

Enumerations

Functions

Macro Definition Documentation

◆ COBJMACROS

Enumeration Type Documentation

◆ dxgi_device_layer_id

Function Documentation

◆ d3d10_bind_flags_from_d3d11_bind_flags()

◆ d3d10_cpu_access_flags_from_d3d11_cpu_access_flags()

◆ d3d10_resource_misc_flags_from_d3d11_resource_misc_flags()

◆ d3d10_usage_from_d3d11_usage()

◆ d3d11_bind_flags_from_d3d10_bind_flags()

◆ d3d11_bind_flags_from_wined3d()

◆ d3d11_class_linkage_create()

◆ d3d11_compute_shader_create()

◆ d3d11_cpu_access_flags_from_d3d10_cpu_access_flags()

◆ d3d11_domain_shader_create()

◆ d3d11_hull_shader_create()

◆ d3d11_primitive_topology_from_wined3d_primitive_type()

◆ d3d11_resource_misc_flags_from_d3d10_resource_misc_flags()

◆ d3d11_unordered_access_view_create()

◆ d3d11_usage_from_d3d10_usage()

◆ d3d_blend_state_create()

◆ d3d_buffer_create()

◆ d3d_depthstencil_state_create()

◆ d3d_depthstencil_view_create()

◆ d3d_device_create_dxgi_resource()

◆ d3d_device_init()

◆ d3d_geometry_shader_create()

◆ d3d_get_private_data()

◆ d3d_input_layout_create()

◆ d3d_pixel_shader_create()

◆ d3d_query_create()

◆ d3d_rasterizer_state_create()

◆ d3d_rendertarget_view_create()

◆ d3d_sampler_state_create()

◆ d3d_set_private_data()

◆ d3d_set_private_data_interface()

◆ d3d_shader_resource_view_create()

◆ d3d_texture1d_create()

◆ d3d_texture2d_create()

◆ d3d_texture3d_create()

◆ d3d_vertex_shader_create()

◆ d3d_video_decoder_create()

◆ d3d_video_decoder_output_view_create()

◆ debug_d3d10_primitive_topology()

◆ debug_dxgi_format()

◆ debug_float4()

◆ dxgi_format_from_wined3dformat()

◆ DXGID3D10CreateDevice()

◆ DXGID3D10RegisterLayers()

◆ impl_from_ID3D10Device()

◆ impl_from_ID3D11BlendState1()

◆ impl_from_ID3D11DepthStencilState()

◆ impl_from_ID3D11Device()

◆ impl_from_ID3D11Device2()

◆ impl_from_ID3D11Texture2D()

◆ unsafe_impl_from_ID3D10BlendState()

◆ unsafe_impl_from_ID3D10Buffer()

◆ unsafe_impl_from_ID3D10DepthStencilState()

◆ unsafe_impl_from_ID3D10DepthStencilView()

◆ unsafe_impl_from_ID3D10GeometryShader()

◆ unsafe_impl_from_ID3D10InputLayout()

◆ unsafe_impl_from_ID3D10PixelShader()

◆ unsafe_impl_from_ID3D10Query()

◆ unsafe_impl_from_ID3D10RasterizerState()

◆ unsafe_impl_from_ID3D10RenderTargetView()

◆ unsafe_impl_from_ID3D10SamplerState()

◆ unsafe_impl_from_ID3D10ShaderResourceView()

◆ unsafe_impl_from_ID3D10Texture1D()

◆ unsafe_impl_from_ID3D10Texture2D()

◆ unsafe_impl_from_ID3D10Texture3D()

◆ unsafe_impl_from_ID3D10VertexShader()

◆ unsafe_impl_from_ID3D11Asynchronous()

◆ unsafe_impl_from_ID3D11BlendState()

◆ unsafe_impl_from_ID3D11Buffer()

◆ unsafe_impl_from_ID3D11ComputeShader()

◆ unsafe_impl_from_ID3D11DepthStencilState()