#include "config.h"
#include "wine/port.h"
#include <stdio.h>
#include "wined3d_private.h"

Include dependency graph for device.c:

Macros
#define	copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3d)

	WINE_DECLARE_DEBUG_CHANNEL (winediag)

GLenum	gl_primitive_type_from_d3d (enum wined3d_primitive_type primitive_type)

static enum wined3d_primitive_type	d3d_primitive_type_from_gl (GLenum primitive_type)

BOOL	device_context_add (struct wined3d_device device, struct wined3d_context context)

void	device_context_remove (struct wined3d_device device, struct wined3d_context context)

static BOOL	is_full_clear (const struct wined3d_texture texture, unsigned int sub_resource_idx, const RECT draw_rect, const RECT *clear_rect)

void	device_clear_render_targets (struct wined3d_device device, UINT rt_count, const struct wined3d_fb_state fb, UINT rect_count, const RECT clear_rect, const RECT draw_rect, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)

ULONG CDECL	wined3d_device_incref (struct wined3d_device *device)

static void	device_leftover_sampler (struct wine_rb_entry entry, void context)

ULONG CDECL	wined3d_device_decref (struct wined3d_device *device)

UINT CDECL	wined3d_device_get_swapchain_count (const struct wined3d_device *device)

struct wined3d_swapchain *CDECL	wined3d_device_get_swapchain (const struct wined3d_device *device, UINT swapchain_idx)

static void	device_load_logo (struct wined3d_device device, const char filename)

static void	create_dummy_textures (struct wined3d_device device, struct wined3d_context context)

static void	destroy_dummy_textures (struct wined3d_device device, struct wined3d_context context)

static void	create_default_samplers (struct wined3d_device device, struct wined3d_context context)

static void	destroy_default_samplers (struct wined3d_device device, struct wined3d_context context)

static LONG	fullscreen_style (LONG style)

static LONG	fullscreen_exstyle (LONG exstyle)

void CDECL	wined3d_device_setup_fullscreen_window (struct wined3d_device *device, HWND window, UINT w, UINT h)

void CDECL	wined3d_device_restore_fullscreen_window (struct wined3d_device device, HWND window, const RECT window_rect)

HRESULT CDECL	wined3d_device_acquire_focus_window (struct wined3d_device *device, HWND window)

void CDECL	wined3d_device_release_focus_window (struct wined3d_device *device)

static void	device_init_swapchain_state (struct wined3d_device device, struct wined3d_swapchain swapchain)

static void	wined3d_device_delete_opengl_contexts_cs (void *object)

static void	wined3d_device_delete_opengl_contexts (struct wined3d_device *device)

static void	wined3d_device_create_primary_opengl_context_cs (void *object)

static HRESULT	wined3d_device_create_primary_opengl_context (struct wined3d_device *device)

HRESULT CDECL	wined3d_device_init_3d (struct wined3d_device device, struct wined3d_swapchain_desc swapchain_desc)

HRESULT CDECL	wined3d_device_init_gdi (struct wined3d_device device, struct wined3d_swapchain_desc swapchain_desc)

static void	device_free_sampler (struct wine_rb_entry entry, void context)

HRESULT CDECL	wined3d_device_uninit_3d (struct wined3d_device *device)

HRESULT CDECL	wined3d_device_uninit_gdi (struct wined3d_device *device)

void CDECL	wined3d_device_set_multithreaded (struct wined3d_device *device)

UINT CDECL	wined3d_device_get_available_texture_mem (const struct wined3d_device *device)

void CDECL	wined3d_device_set_stream_output (struct wined3d_device device, UINT idx, struct wined3d_buffer buffer, UINT offset)

struct wined3d_buffer *CDECL	wined3d_device_get_stream_output (struct wined3d_device device, UINT idx, UINT offset)

HRESULT CDECL	wined3d_device_set_stream_source (struct wined3d_device device, UINT stream_idx, struct wined3d_buffer buffer, UINT offset, UINT stride)

HRESULT CDECL	wined3d_device_get_stream_source (const struct wined3d_device device, UINT stream_idx, struct wined3d_buffer buffer, UINT offset, UINT *stride)

HRESULT CDECL	wined3d_device_set_stream_source_freq (struct wined3d_device *device, UINT stream_idx, UINT divider)

HRESULT CDECL	wined3d_device_get_stream_source_freq (const struct wined3d_device device, UINT stream_idx, UINT divider)

void CDECL	wined3d_device_set_transform (struct wined3d_device device, enum wined3d_transform_state d3dts, const struct wined3d_matrix matrix)

void CDECL	wined3d_device_get_transform (const struct wined3d_device device, enum wined3d_transform_state state, struct wined3d_matrix matrix)

void CDECL	wined3d_device_multiply_transform (struct wined3d_device device, enum wined3d_transform_state state, const struct wined3d_matrix matrix)

HRESULT CDECL	wined3d_device_set_light (struct wined3d_device device, UINT light_idx, const struct wined3d_light light)

HRESULT CDECL	wined3d_device_get_light (const struct wined3d_device device, UINT light_idx, struct wined3d_light light)

HRESULT CDECL	wined3d_device_set_light_enable (struct wined3d_device *device, UINT light_idx, BOOL enable)

HRESULT CDECL	wined3d_device_get_light_enable (const struct wined3d_device device, UINT light_idx, BOOL enable)

HRESULT CDECL	wined3d_device_set_clip_plane (struct wined3d_device device, UINT plane_idx, const struct wined3d_vec4 plane)

HRESULT CDECL	wined3d_device_get_clip_plane (const struct wined3d_device device, UINT plane_idx, struct wined3d_vec4 plane)

HRESULT CDECL	wined3d_device_set_clip_status (struct wined3d_device device, const struct wined3d_clip_status clip_status)

HRESULT CDECL	wined3d_device_get_clip_status (const struct wined3d_device device, struct wined3d_clip_status clip_status)

void CDECL	wined3d_device_set_material (struct wined3d_device device, const struct wined3d_material material)

void CDECL	wined3d_device_get_material (const struct wined3d_device device, struct wined3d_material material)

void CDECL	wined3d_device_set_index_buffer (struct wined3d_device device, struct wined3d_buffer buffer, enum wined3d_format_id format_id, unsigned int offset)

struct wined3d_buffer *CDECL	wined3d_device_get_index_buffer (const struct wined3d_device device, enum wined3d_format_id format, unsigned int *offset)

void CDECL	wined3d_device_set_base_vertex_index (struct wined3d_device *device, INT base_index)

INT CDECL	wined3d_device_get_base_vertex_index (const struct wined3d_device *device)

void CDECL	wined3d_device_set_viewport (struct wined3d_device device, const struct wined3d_viewport viewport)

void CDECL	wined3d_device_get_viewport (const struct wined3d_device device, struct wined3d_viewport viewport)

static void	resolve_depth_buffer (struct wined3d_device *device)

void CDECL	wined3d_device_set_blend_state (struct wined3d_device device, struct wined3d_blend_state blend_state)

struct wined3d_blend_state *CDECL	wined3d_device_get_blend_state (const struct wined3d_device *device)

void CDECL	wined3d_device_set_rasterizer_state (struct wined3d_device device, struct wined3d_rasterizer_state rasterizer_state)

struct wined3d_rasterizer_state *CDECL	wined3d_device_get_rasterizer_state (struct wined3d_device *device)

void CDECL	wined3d_device_set_render_state (struct wined3d_device *device, enum wined3d_render_state state, DWORD value)

DWORD CDECL	wined3d_device_get_render_state (const struct wined3d_device *device, enum wined3d_render_state state)

void CDECL	wined3d_device_set_sampler_state (struct wined3d_device *device, UINT sampler_idx, enum wined3d_sampler_state state, DWORD value)

DWORD CDECL	wined3d_device_get_sampler_state (const struct wined3d_device *device, UINT sampler_idx, enum wined3d_sampler_state state)

void CDECL	wined3d_device_set_scissor_rect (struct wined3d_device device, const RECT rect)

void CDECL	wined3d_device_get_scissor_rect (const struct wined3d_device device, RECT rect)

void CDECL	wined3d_device_set_vertex_declaration (struct wined3d_device device, struct wined3d_vertex_declaration declaration)

struct wined3d_vertex_declaration *CDECL	wined3d_device_get_vertex_declaration (const struct wined3d_device *device)

void CDECL	wined3d_device_set_vertex_shader (struct wined3d_device device, struct wined3d_shader shader)

struct wined3d_shader *CDECL	wined3d_device_get_vertex_shader (const struct wined3d_device *device)

static void	wined3d_device_set_constant_buffer (struct wined3d_device device, enum wined3d_shader_type type, UINT idx, struct wined3d_buffer buffer)

void CDECL	wined3d_device_set_vs_cb (struct wined3d_device device, UINT idx, struct wined3d_buffer buffer)

static struct wined3d_buffer *	wined3d_device_get_constant_buffer (const struct wined3d_device *device, enum wined3d_shader_type shader_type, unsigned int idx)

struct wined3d_buffer *CDECL	wined3d_device_get_vs_cb (const struct wined3d_device *device, UINT idx)

static void	wined3d_device_set_shader_resource_view (struct wined3d_device device, enum wined3d_shader_type type, UINT idx, struct wined3d_shader_resource_view view)

void CDECL	wined3d_device_set_vs_resource_view (struct wined3d_device device, UINT idx, struct wined3d_shader_resource_view view)

static struct wined3d_shader_resource_view *	wined3d_device_get_shader_resource_view (const struct wined3d_device *device, enum wined3d_shader_type shader_type, unsigned int idx)

struct wined3d_shader_resource_view *CDECL	wined3d_device_get_vs_resource_view (const struct wined3d_device *device, UINT idx)

static void	wined3d_device_set_sampler (struct wined3d_device device, enum wined3d_shader_type type, UINT idx, struct wined3d_sampler sampler)

void CDECL	wined3d_device_set_vs_sampler (struct wined3d_device device, UINT idx, struct wined3d_sampler sampler)

static struct wined3d_sampler *	wined3d_device_get_sampler (const struct wined3d_device *device, enum wined3d_shader_type shader_type, unsigned int idx)

struct wined3d_sampler *CDECL	wined3d_device_get_vs_sampler (const struct wined3d_device *device, UINT idx)

HRESULT CDECL	wined3d_device_set_vs_consts_b (struct wined3d_device device, unsigned int start_idx, unsigned int count, const BOOL constants)

HRESULT CDECL	wined3d_device_get_vs_consts_b (const struct wined3d_device device, unsigned int start_idx, unsigned int count, BOOL constants)

HRESULT CDECL	wined3d_device_set_vs_consts_i (struct wined3d_device device, unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 constants)

HRESULT CDECL	wined3d_device_get_vs_consts_i (const struct wined3d_device device, unsigned int start_idx, unsigned int count, struct wined3d_ivec4 constants)

HRESULT CDECL	wined3d_device_set_vs_consts_f (struct wined3d_device device, unsigned int start_idx, unsigned int count, const struct wined3d_vec4 constants)

HRESULT CDECL	wined3d_device_get_vs_consts_f (const struct wined3d_device device, unsigned int start_idx, unsigned int count, struct wined3d_vec4 constants)

void CDECL	wined3d_device_set_pixel_shader (struct wined3d_device device, struct wined3d_shader shader)

struct wined3d_shader *CDECL	wined3d_device_get_pixel_shader (const struct wined3d_device *device)

void CDECL	wined3d_device_set_ps_cb (struct wined3d_device device, UINT idx, struct wined3d_buffer buffer)

struct wined3d_buffer *CDECL	wined3d_device_get_ps_cb (const struct wined3d_device *device, UINT idx)

void CDECL	wined3d_device_set_ps_resource_view (struct wined3d_device device, UINT idx, struct wined3d_shader_resource_view view)

struct wined3d_shader_resource_view *CDECL	wined3d_device_get_ps_resource_view (const struct wined3d_device *device, UINT idx)

void CDECL	wined3d_device_set_ps_sampler (struct wined3d_device device, UINT idx, struct wined3d_sampler sampler)

struct wined3d_sampler *CDECL	wined3d_device_get_ps_sampler (const struct wined3d_device *device, UINT idx)

HRESULT CDECL	wined3d_device_set_ps_consts_b (struct wined3d_device device, unsigned int start_idx, unsigned int count, const BOOL constants)

HRESULT CDECL	wined3d_device_get_ps_consts_b (const struct wined3d_device device, unsigned int start_idx, unsigned int count, BOOL constants)

HRESULT CDECL	wined3d_device_set_ps_consts_i (struct wined3d_device device, unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 constants)

HRESULT CDECL	wined3d_device_get_ps_consts_i (const struct wined3d_device device, unsigned int start_idx, unsigned int count, struct wined3d_ivec4 constants)

HRESULT CDECL	wined3d_device_set_ps_consts_f (struct wined3d_device device, unsigned int start_idx, unsigned int count, const struct wined3d_vec4 constants)

HRESULT CDECL	wined3d_device_get_ps_consts_f (const struct wined3d_device device, unsigned int start_idx, unsigned int count, struct wined3d_vec4 constants)

void CDECL	wined3d_device_set_hull_shader (struct wined3d_device device, struct wined3d_shader shader)

struct wined3d_shader *CDECL	wined3d_device_get_hull_shader (const struct wined3d_device *device)

void CDECL	wined3d_device_set_hs_cb (struct wined3d_device device, unsigned int idx, struct wined3d_buffer buffer)

struct wined3d_buffer *CDECL	wined3d_device_get_hs_cb (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_hs_resource_view (struct wined3d_device device, unsigned int idx, struct wined3d_shader_resource_view view)

struct wined3d_shader_resource_view *CDECL	wined3d_device_get_hs_resource_view (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_hs_sampler (struct wined3d_device device, unsigned int idx, struct wined3d_sampler sampler)

struct wined3d_sampler *CDECL	wined3d_device_get_hs_sampler (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_domain_shader (struct wined3d_device device, struct wined3d_shader shader)

struct wined3d_shader *CDECL	wined3d_device_get_domain_shader (const struct wined3d_device *device)

void CDECL	wined3d_device_set_ds_cb (struct wined3d_device device, unsigned int idx, struct wined3d_buffer buffer)

struct wined3d_buffer *CDECL	wined3d_device_get_ds_cb (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_ds_resource_view (struct wined3d_device device, unsigned int idx, struct wined3d_shader_resource_view view)

struct wined3d_shader_resource_view *CDECL	wined3d_device_get_ds_resource_view (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_ds_sampler (struct wined3d_device device, unsigned int idx, struct wined3d_sampler sampler)

struct wined3d_sampler *CDECL	wined3d_device_get_ds_sampler (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_geometry_shader (struct wined3d_device device, struct wined3d_shader shader)

struct wined3d_shader *CDECL	wined3d_device_get_geometry_shader (const struct wined3d_device *device)

void CDECL	wined3d_device_set_gs_cb (struct wined3d_device device, UINT idx, struct wined3d_buffer buffer)

struct wined3d_buffer *CDECL	wined3d_device_get_gs_cb (const struct wined3d_device *device, UINT idx)

void CDECL	wined3d_device_set_gs_resource_view (struct wined3d_device device, UINT idx, struct wined3d_shader_resource_view view)

struct wined3d_shader_resource_view *CDECL	wined3d_device_get_gs_resource_view (const struct wined3d_device *device, UINT idx)

void CDECL	wined3d_device_set_gs_sampler (struct wined3d_device device, UINT idx, struct wined3d_sampler sampler)

struct wined3d_sampler *CDECL	wined3d_device_get_gs_sampler (const struct wined3d_device *device, UINT idx)

void CDECL	wined3d_device_set_compute_shader (struct wined3d_device device, struct wined3d_shader shader)

struct wined3d_shader *CDECL	wined3d_device_get_compute_shader (const struct wined3d_device *device)

void CDECL	wined3d_device_set_cs_cb (struct wined3d_device device, unsigned int idx, struct wined3d_buffer buffer)

struct wined3d_buffer *CDECL	wined3d_device_get_cs_cb (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_cs_resource_view (struct wined3d_device device, unsigned int idx, struct wined3d_shader_resource_view view)

struct wined3d_shader_resource_view *CDECL	wined3d_device_get_cs_resource_view (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_cs_sampler (struct wined3d_device device, unsigned int idx, struct wined3d_sampler sampler)

struct wined3d_sampler *CDECL	wined3d_device_get_cs_sampler (const struct wined3d_device *device, unsigned int idx)

static void	wined3d_device_set_pipeline_unordered_access_view (struct wined3d_device device, enum wined3d_pipeline pipeline, unsigned int idx, struct wined3d_unordered_access_view uav, unsigned int initial_count)

static struct wined3d_unordered_access_view *	wined3d_device_get_pipeline_unordered_access_view (const struct wined3d_device *device, enum wined3d_pipeline pipeline, unsigned int idx)

void CDECL	wined3d_device_set_cs_uav (struct wined3d_device device, unsigned int idx, struct wined3d_unordered_access_view uav, unsigned int initial_count)

struct wined3d_unordered_access_view *CDECL	wined3d_device_get_cs_uav (const struct wined3d_device *device, unsigned int idx)

void CDECL	wined3d_device_set_unordered_access_view (struct wined3d_device device, unsigned int idx, struct wined3d_unordered_access_view uav, unsigned int initial_count)

struct wined3d_unordered_access_view *CDECL	wined3d_device_get_unordered_access_view (const struct wined3d_device *device, unsigned int idx)

static HRESULT	process_vertices_strided (const struct wined3d_device device, DWORD dwDestIndex, DWORD dwCount, const struct wined3d_stream_info stream_info, struct wined3d_buffer *dest, DWORD flags, DWORD DestFVF)

HRESULT CDECL	wined3d_device_process_vertices (struct wined3d_device device, UINT src_start_idx, UINT dst_idx, UINT vertex_count, struct wined3d_buffer dst_buffer, const struct wined3d_vertex_declaration *declaration, DWORD flags, DWORD dst_fvf)

void CDECL	wined3d_device_set_texture_stage_state (struct wined3d_device *device, UINT stage, enum wined3d_texture_stage_state state, DWORD value)

DWORD CDECL	wined3d_device_get_texture_stage_state (const struct wined3d_device *device, UINT stage, enum wined3d_texture_stage_state state)

HRESULT CDECL	wined3d_device_set_texture (struct wined3d_device device, UINT stage, struct wined3d_texture texture)

struct wined3d_texture *CDECL	wined3d_device_get_texture (const struct wined3d_device *device, UINT stage)

HRESULT CDECL	wined3d_device_get_device_caps (const struct wined3d_device device, WINED3DCAPS caps)

HRESULT CDECL	wined3d_device_get_display_mode (const struct wined3d_device device, UINT swapchain_idx, struct wined3d_display_mode mode, enum wined3d_display_rotation *rotation)

HRESULT CDECL	wined3d_device_begin_stateblock (struct wined3d_device *device)

HRESULT CDECL	wined3d_device_end_stateblock (struct wined3d_device device, struct wined3d_stateblock *stateblock)

HRESULT CDECL	wined3d_device_begin_scene (struct wined3d_device *device)

HRESULT CDECL	wined3d_device_end_scene (struct wined3d_device *device)

HRESULT CDECL	wined3d_device_clear (struct wined3d_device device, DWORD rect_count, const RECT rects, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)

void CDECL	wined3d_device_set_predication (struct wined3d_device device, struct wined3d_query predicate, BOOL value)

struct wined3d_query *CDECL	wined3d_device_get_predication (struct wined3d_device device, BOOL value)

void CDECL	wined3d_device_dispatch_compute (struct wined3d_device *device, unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z)

void CDECL	wined3d_device_dispatch_compute_indirect (struct wined3d_device device, struct wined3d_buffer buffer, unsigned int offset)

void CDECL	wined3d_device_set_primitive_type (struct wined3d_device *device, enum wined3d_primitive_type primitive_type, unsigned int patch_vertex_count)

void CDECL	wined3d_device_get_primitive_type (const struct wined3d_device device, enum wined3d_primitive_type primitive_type, unsigned int *patch_vertex_count)

HRESULT CDECL	wined3d_device_draw_primitive (struct wined3d_device *device, UINT start_vertex, UINT vertex_count)

void CDECL	wined3d_device_draw_primitive_instanced (struct wined3d_device *device, UINT start_vertex, UINT vertex_count, UINT start_instance, UINT instance_count)

void CDECL	wined3d_device_draw_primitive_instanced_indirect (struct wined3d_device device, struct wined3d_buffer buffer, unsigned int offset)

HRESULT CDECL	wined3d_device_draw_indexed_primitive (struct wined3d_device *device, UINT start_idx, UINT index_count)

void CDECL	wined3d_device_draw_indexed_primitive_instanced (struct wined3d_device *device, UINT start_idx, UINT index_count, UINT start_instance, UINT instance_count)

void CDECL	wined3d_device_draw_indexed_primitive_instanced_indirect (struct wined3d_device device, struct wined3d_buffer buffer, unsigned int offset)

HRESULT CDECL	wined3d_device_update_texture (struct wined3d_device device, struct wined3d_texture src_texture, struct wined3d_texture *dst_texture)

HRESULT CDECL	wined3d_device_validate_device (const struct wined3d_device device, DWORD num_passes)

void CDECL	wined3d_device_set_software_vertex_processing (struct wined3d_device *device, BOOL software)

BOOL CDECL	wined3d_device_get_software_vertex_processing (const struct wined3d_device *device)

HRESULT CDECL	wined3d_device_get_raster_status (const struct wined3d_device device, UINT swapchain_idx, struct wined3d_raster_status raster_status)

HRESULT CDECL	wined3d_device_set_npatch_mode (struct wined3d_device *device, float segments)

float CDECL	wined3d_device_get_npatch_mode (const struct wined3d_device *device)

void CDECL	wined3d_device_copy_uav_counter (struct wined3d_device device, struct wined3d_buffer dst_buffer, unsigned int offset, struct wined3d_unordered_access_view *uav)

void CDECL	wined3d_device_copy_resource (struct wined3d_device device, struct wined3d_resource dst_resource, struct wined3d_resource *src_resource)

HRESULT CDECL	wined3d_device_copy_sub_resource_region (struct wined3d_device device, struct wined3d_resource dst_resource, unsigned int dst_sub_resource_idx, unsigned int dst_x, unsigned int dst_y, unsigned int dst_z, struct wined3d_resource src_resource, unsigned int src_sub_resource_idx, const struct wined3d_box src_box)

void CDECL	wined3d_device_update_sub_resource (struct wined3d_device device, struct wined3d_resource resource, unsigned int sub_resource_idx, const struct wined3d_box box, const void data, unsigned int row_pitch, unsigned int depth_pitch)

void CDECL	wined3d_device_resolve_sub_resource (struct wined3d_device device, struct wined3d_resource dst_resource, unsigned int dst_sub_resource_idx, struct wined3d_resource *src_resource, unsigned int src_sub_resource_idx, enum wined3d_format_id format_id)

HRESULT CDECL	wined3d_device_clear_rendertarget_view (struct wined3d_device device, struct wined3d_rendertarget_view view, const RECT rect, DWORD flags, const struct wined3d_color color, float depth, DWORD stencil)

void CDECL	wined3d_device_clear_unordered_access_view_uint (struct wined3d_device device, struct wined3d_unordered_access_view view, const struct wined3d_uvec4 *clear_value)

struct wined3d_rendertarget_view *CDECL	wined3d_device_get_rendertarget_view (const struct wined3d_device *device, unsigned int view_idx)

struct wined3d_rendertarget_view *CDECL	wined3d_device_get_depth_stencil_view (const struct wined3d_device *device)

HRESULT CDECL	wined3d_device_set_rendertarget_view (struct wined3d_device device, unsigned int view_idx, struct wined3d_rendertarget_view view, BOOL set_viewport)

void CDECL	wined3d_device_set_depth_stencil_view (struct wined3d_device device, struct wined3d_rendertarget_view view)

static struct wined3d_texture *	wined3d_device_create_cursor_texture (struct wined3d_device device, struct wined3d_texture cursor_image, unsigned int sub_resource_idx)

HRESULT CDECL	wined3d_device_set_cursor_properties (struct wined3d_device device, UINT x_hotspot, UINT y_hotspot, struct wined3d_texture texture, unsigned int sub_resource_idx)

void CDECL	wined3d_device_set_cursor_position (struct wined3d_device *device, int x_screen_space, int y_screen_space, DWORD flags)

BOOL CDECL	wined3d_device_show_cursor (struct wined3d_device *device, BOOL show)

void CDECL	wined3d_device_evict_managed_resources (struct wined3d_device *device)

HRESULT CDECL	wined3d_device_reset (struct wined3d_device device, const struct wined3d_swapchain_desc swapchain_desc, const struct wined3d_display_mode *mode, wined3d_device_reset_cb callback, BOOL reset_state)

HRESULT CDECL	wined3d_device_set_dialog_box_mode (struct wined3d_device *device, BOOL enable_dialogs)

void CDECL	wined3d_device_get_creation_parameters (const struct wined3d_device device, struct wined3d_device_creation_parameters parameters)

struct wined3d *CDECL	wined3d_device_get_wined3d (const struct wined3d_device *device)

void CDECL	wined3d_device_set_gamma_ramp (const struct wined3d_device device, UINT swapchain_idx, DWORD flags, const struct wined3d_gamma_ramp ramp)

void CDECL	wined3d_device_get_gamma_ramp (const struct wined3d_device device, UINT swapchain_idx, struct wined3d_gamma_ramp ramp)

void	device_resource_add (struct wined3d_device device, struct wined3d_resource resource)

static void	device_resource_remove (struct wined3d_device device, struct wined3d_resource resource)

void	device_resource_released (struct wined3d_device device, struct wined3d_resource resource)

static int	wined3d_sampler_compare (const void key, const struct wine_rb_entry entry)

HRESULT	device_init (struct wined3d_device device, struct wined3d wined3d, UINT adapter_idx, enum wined3d_device_type device_type, HWND focus_window, DWORD flags, BYTE surface_alignment, struct wined3d_device_parent *device_parent)

void	device_invalidate_state (const struct wined3d_device *device, DWORD state)

LRESULT	device_process_message (struct wined3d_device *device, HWND window, BOOL unicode, UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc)

Variables
const struct wined3d_light	WINED3D_default_light

Macro Definition Documentation

◆ copy_and_next

#define copy_and_next	(	dest,
		src,
		size
	)	memcpy(dest, src, size); dest += (size)

Definition at line 3069 of file device.c.

Function Documentation

◆ create_default_samplers()

static void create_default_samplers	(	struct wined3d_device *	device,
		struct wined3d_context *	context
	)

static

Definition at line 780 of file device.c.

{
    struct wined3d_sampler_desc desc;
    HRESULT hr;
 
    desc.address_u = WINED3D_TADDRESS_WRAP;
    desc.address_v = WINED3D_TADDRESS_WRAP;
    desc.address_w = WINED3D_TADDRESS_WRAP;
    memset(desc.border_color, 0, sizeof(desc.border_color));
    desc.mag_filter = WINED3D_TEXF_POINT;
    desc.min_filter = WINED3D_TEXF_POINT;
    desc.mip_filter = WINED3D_TEXF_NONE;
    desc.lod_bias = 0.0f;
    desc.min_lod = -1000.0f;
    desc.max_lod =  1000.0f;
    desc.mip_base_level = 0;
    desc.max_anisotropy = 1;
    desc.compare = FALSE;
    desc.comparison_func = WINED3D_CMP_NEVER;
    desc.srgb_decode = TRUE;
 
    /* In SM4+ shaders there is a separation between resources and samplers. Some shader
     * instructions allow access to resources without using samplers.
     * In GLSL, resources are always accessed through sampler or image variables. The default
     * sampler object is used to emulate the direct resource access when there is no sampler state
     * to use.
     */
    if (FAILED(hr = wined3d_sampler_create(device, &desc, NULL, &wined3d_null_parent_ops, &device->default_sampler)))
    {
        ERR("Failed to create default sampler, hr %#x.\n", hr);
        device->default_sampler = NULL;
    }
 
    /* In D3D10+, a NULL sampler maps to the default sampler state. */
    desc.address_u = WINED3D_TADDRESS_CLAMP;
    desc.address_v = WINED3D_TADDRESS_CLAMP;
    desc.address_w = WINED3D_TADDRESS_CLAMP;
    desc.mag_filter = WINED3D_TEXF_LINEAR;
    desc.min_filter = WINED3D_TEXF_LINEAR;
    desc.mip_filter = WINED3D_TEXF_LINEAR;
    if (FAILED(hr = wined3d_sampler_create(device, &desc, NULL, &wined3d_null_parent_ops, &device->null_sampler)))
    {
        ERR("Failed to create null sampler, hr %#x.\n", hr);
        device->null_sampler = NULL;
    }
}

Referenced by wined3d_device_create_primary_opengl_context_cs().

◆ create_dummy_textures()

static void create_dummy_textures	(	struct wined3d_device *	device,
		struct wined3d_context *	context
	)

static

Definition at line 604 of file device.c.

{
    const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
    const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
    struct wined3d_dummy_textures *textures = &device->dummy_textures;
    unsigned int i;
    DWORD color;
 
    if (d3d_info->wined3d_creation_flags & WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR)
        color = 0x000000ff;
    else
        color = 0x00000000;
 
    /* Under DirectX you can sample even if no texture is bound, whereas
     * OpenGL will only allow that when a valid texture is bound.
     * We emulate this by creating dummy textures and binding them
     * to each texture stage when the currently set D3D texture is NULL. */
    context_active_texture(context, gl_info, 0);
 
    gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_1d);
    TRACE("Dummy 1D texture given name %u.\n", textures->tex_1d);
    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D, textures->tex_1d);
    gl_info->gl_ops.gl.p_glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA8, 1, 0,
            GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color);
 
    gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_2d);
    TRACE("Dummy 2D texture given name %u.\n", textures->tex_2d);
    gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, textures->tex_2d);
    gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0,
            GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color);
 
    if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
    {
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_rect);
        TRACE("Dummy rectangle texture given name %u.\n", textures->tex_rect);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_RECTANGLE_ARB, textures->tex_rect);
        gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, 1, 1, 0,
                GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color);
    }
 
    if (gl_info->supported[EXT_TEXTURE3D])
    {
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_3d);
        TRACE("Dummy 3D texture given name %u.\n", textures->tex_3d);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_3D, textures->tex_3d);
        GL_EXTCALL(glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, 1, 1, 1, 0,
                    GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color));
    }
 
    if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
    {
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_cube);
        TRACE("Dummy cube texture given name %u.\n", textures->tex_cube);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP, textures->tex_cube);
        for (i = GL_TEXTURE_CUBE_MAP_POSITIVE_X; i <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; ++i)
        {
            gl_info->gl_ops.gl.p_glTexImage2D(i, 0, GL_RGBA8, 1, 1, 0,
                    GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color);
        }
    }
 
    if (gl_info->supported[ARB_TEXTURE_CUBE_MAP_ARRAY])
    {
        DWORD cube_array_data[6];
 
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_cube_array);
        TRACE("Dummy cube array texture given name %u.\n", textures->tex_cube_array);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures->tex_cube_array);
        for (i = 0; i < ARRAY_SIZE(cube_array_data); ++i)
            cube_array_data[i] = color;
        GL_EXTCALL(glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_RGBA8, 1, 1, 6, 0,
                    GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, cube_array_data));
    }
 
    if (gl_info->supported[EXT_TEXTURE_ARRAY])
    {
 
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_1d_array);
        TRACE("Dummy 1D array texture given name %u.\n", textures->tex_1d_array);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D_ARRAY, textures->tex_1d_array);
        gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_1D_ARRAY, 0, GL_RGBA8, 1, 1, 0,
                GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color);
 
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_2d_array);
        TRACE("Dummy 2D array texture given name %u.\n", textures->tex_2d_array);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_ARRAY, textures->tex_2d_array);
        GL_EXTCALL(glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 1, 1, 1, 0,
                    GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color));
    }
 
    if (gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
    {
        GLuint buffer;
 
        GL_EXTCALL(glGenBuffers(1, &buffer));
        GL_EXTCALL(glBindBuffer(GL_TEXTURE_BUFFER, buffer));
        GL_EXTCALL(glBufferData(GL_TEXTURE_BUFFER, sizeof(color), &color, GL_STATIC_DRAW));
        GL_EXTCALL(glBindBuffer(GL_TEXTURE_BUFFER, 0));
 
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_buffer);
        TRACE("Dummy buffer texture given name %u.\n", textures->tex_buffer);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_BUFFER, textures->tex_buffer);
        GL_EXTCALL(glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, buffer));
        GL_EXTCALL(glDeleteBuffers(1, &buffer));
    }
 
    if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
    {
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_2d_ms);
        TRACE("Dummy multisample texture given name %u.\n", textures->tex_2d_ms);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textures->tex_2d_ms);
        GL_EXTCALL(glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, GL_RGBA8, 1, 1, GL_TRUE));
 
        gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_2d_ms_array);
        TRACE("Dummy multisample array texture given name %u.\n", textures->tex_2d_ms_array);
        gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, textures->tex_2d_ms_array);
        GL_EXTCALL(glTexImage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, 1, GL_RGBA8, 1, 1, 1, GL_TRUE));
 
        if (gl_info->supported[ARB_CLEAR_TEXTURE])
        {
            GL_EXTCALL(glClearTexImage(textures->tex_2d_ms, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color));
            GL_EXTCALL(glClearTexImage(textures->tex_2d_ms_array, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color));
        }
        else
        {
            WARN("ARB_clear_texture is currently required to clear dummy multisample textures.\n");
        }
    }
 
    checkGLcall("create dummy textures");
 
    context_bind_dummy_textures(device, context);
}

Referenced by wined3d_device_create_primary_opengl_context_cs().

◆ d3d_primitive_type_from_gl()

static enum wined3d_primitive_type d3d_primitive_type_from_gl ( GLenum primitive_type )

static

Definition at line 102 of file device.c.

{
    switch (primitive_type)
    {
        case GL_POINTS:
            return WINED3D_PT_POINTLIST;
 
        case GL_LINES:
            return WINED3D_PT_LINELIST;
 
        case GL_LINE_STRIP:
            return WINED3D_PT_LINESTRIP;
 
        case GL_TRIANGLES:
            return WINED3D_PT_TRIANGLELIST;
 
        case GL_TRIANGLE_STRIP:
            return WINED3D_PT_TRIANGLESTRIP;
 
        case GL_TRIANGLE_FAN:
            return WINED3D_PT_TRIANGLEFAN;
 
        case GL_LINES_ADJACENCY_ARB:
            return WINED3D_PT_LINELIST_ADJ;
 
        case GL_LINE_STRIP_ADJACENCY_ARB:
            return WINED3D_PT_LINESTRIP_ADJ;
 
        case GL_TRIANGLES_ADJACENCY_ARB:
            return WINED3D_PT_TRIANGLELIST_ADJ;
 
        case GL_TRIANGLE_STRIP_ADJACENCY_ARB:
            return WINED3D_PT_TRIANGLESTRIP_ADJ;
 
        case GL_PATCHES:
            return WINED3D_PT_PATCH;
 
        default:
            FIXME("Unhandled primitive type %s.\n", debug_d3dprimitivetype(primitive_type));
        case ~0u:
            return WINED3D_PT_UNDEFINED;
    }
}

Referenced by wined3d_device_get_primitive_type().

◆ destroy_default_samplers()

static void destroy_default_samplers	(	struct wined3d_device *	device,
		struct wined3d_context *	context
	)

static

Definition at line 828 of file device.c.

{
    wined3d_sampler_decref(device->default_sampler);
    device->default_sampler = NULL;
    wined3d_sampler_decref(device->null_sampler);
    device->null_sampler = NULL;
}

Referenced by wined3d_device_delete_opengl_contexts_cs().

◆ destroy_dummy_textures()

static void destroy_dummy_textures	(	struct wined3d_device *	device,
		struct wined3d_context *	context
	)

static

Definition at line 739 of file device.c.

{
    struct wined3d_dummy_textures *dummy_textures = &device->dummy_textures;
    const struct wined3d_gl_info *gl_info = context->gl_info;
 
    if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
    {
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_2d_ms);
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_2d_ms_array);
    }
 
    if (gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_buffer);
 
    if (gl_info->supported[EXT_TEXTURE_ARRAY])
    {
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_1d_array);
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_2d_array);
    }
 
    if (gl_info->supported[ARB_TEXTURE_CUBE_MAP_ARRAY])
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_cube_array);
 
    if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_cube);
 
    if (gl_info->supported[EXT_TEXTURE3D])
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_3d);
 
    if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_rect);
 
    gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_2d);
    gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_1d);
 
    checkGLcall("delete dummy textures");
 
    memset(dummy_textures, 0, sizeof(*dummy_textures));
}

Referenced by wined3d_device_delete_opengl_contexts_cs().

◆ device_clear_render_targets()

void device_clear_render_targets	(	struct wined3d_device *	device,
		UINT	rt_count,
		const struct wined3d_fb_state *	fb,
		UINT	rect_count,
		const RECT *	clear_rect,
		const RECT *	draw_rect,
		DWORD	flags,
		const struct wined3d_color *	color,
		float	depth,
		DWORD	stencil
	)

Definition at line 224 of file device.c.

{
    struct wined3d_rendertarget_view *rtv = rt_count ? fb->render_targets[0] : NULL;
    struct wined3d_surface *target = rtv ? wined3d_rendertarget_view_get_surface(rtv) : NULL;
    struct wined3d_rendertarget_view *dsv = fb->depth_stencil;
    struct wined3d_surface *depth_stencil = dsv ? wined3d_rendertarget_view_get_surface(dsv) : NULL;
    const struct wined3d_state *state = &device->cs->state;
    const struct wined3d_gl_info *gl_info;
    UINT drawable_width, drawable_height;
    struct wined3d_color corrected_color;
    struct wined3d_context *context;
    GLbitfield clear_mask = 0;
    BOOL render_offscreen;
    unsigned int i;
 
    if (target)
        context = context_acquire(device, target->container, rtv->sub_resource_idx);
    else
        context = context_acquire(device, NULL, 0);
    if (!context->valid)
    {
        context_release(context);
        WARN("Invalid context, skipping clear.\n");
        return;
    }
    gl_info = context->gl_info;
 
    /* When we're clearing parts of the drawable, make sure that the target surface is well up to date in the
     * drawable. After the clear we'll mark the drawable up to date, so we have to make sure that this is true
     * for the cleared parts, and the untouched parts.
     *
     * If we're clearing the whole target there is no need to copy it into the drawable, it will be overwritten
     * anyway. If we're not clearing the color buffer we don't have to copy either since we're not going to set
     * the drawable up to date. We have to check all settings that limit the clear area though. Do not bother
     * checking all this if the dest surface is in the drawable anyway. */
    for (i = 0; i < rt_count; ++i)
    {
        struct wined3d_rendertarget_view *rtv = fb->render_targets[i];
 
        if (rtv && rtv->format->id != WINED3DFMT_NULL)
        {
            struct wined3d_texture *rt = wined3d_texture_from_resource(rtv->resource);
 
            if (flags & WINED3DCLEAR_TARGET && !is_full_clear(rt, rtv->sub_resource_idx,
                    draw_rect, rect_count ? clear_rect : NULL))
                wined3d_texture_load_location(rt, rtv->sub_resource_idx, context, rtv->resource->draw_binding);
            else
                wined3d_texture_prepare_location(rt, rtv->sub_resource_idx, context, rtv->resource->draw_binding);
        }
    }
 
    if (target)
    {
        render_offscreen = context->render_offscreen;
        wined3d_rendertarget_view_get_drawable_size(rtv, context, &drawable_width, &drawable_height);
    }
    else
    {
        unsigned int ds_level = dsv->sub_resource_idx % depth_stencil->container->level_count;
 
        render_offscreen = TRUE;
        drawable_width = wined3d_texture_get_level_pow2_width(depth_stencil->container, ds_level);
        drawable_height = wined3d_texture_get_level_pow2_height(depth_stencil->container, ds_level);
    }
 
    if (depth_stencil)
    {
        DWORD ds_location = render_offscreen ? dsv->resource->draw_binding : WINED3D_LOCATION_DRAWABLE;
        struct wined3d_texture *ds = wined3d_texture_from_resource(dsv->resource);
 
        if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL)
                && !is_full_clear(ds, dsv->sub_resource_idx, draw_rect, rect_count ? clear_rect : NULL))
            wined3d_texture_load_location(ds, dsv->sub_resource_idx, context, ds_location);
        else
            wined3d_texture_prepare_location(ds, dsv->sub_resource_idx, context, ds_location);
 
        if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
        {
            wined3d_texture_validate_location(ds, dsv->sub_resource_idx, ds_location);
            wined3d_texture_invalidate_location(ds, dsv->sub_resource_idx, ~ds_location);
        }
    }
 
    if (!context_apply_clear_state(context, state, rt_count, fb))
    {
        context_release(context);
        WARN("Failed to apply clear state, skipping clear.\n");
        return;
    }
 
    /* Only set the values up once, as they are not changing. */
    if (flags & WINED3DCLEAR_STENCIL)
    {
        if (gl_info->supported[EXT_STENCIL_TWO_SIDE])
        {
            gl_info->gl_ops.gl.p_glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
            context_invalidate_state(context, STATE_RENDER(WINED3D_RS_TWOSIDEDSTENCILMODE));
        }
        gl_info->gl_ops.gl.p_glStencilMask(~0U);
        context_invalidate_state(context, STATE_RENDER(WINED3D_RS_STENCILWRITEMASK));
        gl_info->gl_ops.gl.p_glClearStencil(stencil);
        checkGLcall("glClearStencil");
        clear_mask = clear_mask | GL_STENCIL_BUFFER_BIT;
    }
 
    if (flags & WINED3DCLEAR_ZBUFFER)
    {
        gl_info->gl_ops.gl.p_glDepthMask(GL_TRUE);
        context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ZWRITEENABLE));
        gl_info->gl_ops.gl.p_glClearDepth(depth);
        checkGLcall("glClearDepth");
        clear_mask = clear_mask | GL_DEPTH_BUFFER_BIT;
    }
 
    if (flags & WINED3DCLEAR_TARGET)
    {
        for (i = 0; i < rt_count; ++i)
        {
            struct wined3d_rendertarget_view *rtv = fb->render_targets[i];
            struct wined3d_texture *texture;
 
            if (!rtv)
                continue;
 
            if (rtv->resource->type == WINED3D_RTYPE_BUFFER)
            {
                FIXME("Not supported on buffer resources.\n");
                continue;
            }
 
            texture = texture_from_resource(rtv->resource);
            wined3d_texture_validate_location(texture, rtv->sub_resource_idx, rtv->resource->draw_binding);
            wined3d_texture_invalidate_location(texture, rtv->sub_resource_idx, ~rtv->resource->draw_binding);
        }
 
        if (!gl_info->supported[ARB_FRAMEBUFFER_SRGB] && needs_srgb_write(context, state, fb))
        {
            if (rt_count > 1)
                WARN("Clearing multiple sRGB render targets with no GL_ARB_framebuffer_sRGB "
                        "support, this might cause graphical issues.\n");
 
            corrected_color.r = color->r < wined3d_srgb_const1[0]
                    ? color->r * wined3d_srgb_const0[3]
                    : pow(color->r, wined3d_srgb_const0[0]) * wined3d_srgb_const0[1]
                    - wined3d_srgb_const0[2];
            corrected_color.r = min(max(corrected_color.r, 0.0f), 1.0f);
            corrected_color.g = color->g < wined3d_srgb_const1[0]
                    ? color->g * wined3d_srgb_const0[3]
                    : pow(color->g, wined3d_srgb_const0[0]) * wined3d_srgb_const0[1]
                    - wined3d_srgb_const0[2];
            corrected_color.g = min(max(corrected_color.g, 0.0f), 1.0f);
            corrected_color.b = color->b < wined3d_srgb_const1[0]
                    ? color->b * wined3d_srgb_const0[3]
                    : pow(color->b, wined3d_srgb_const0[0]) * wined3d_srgb_const0[1]
                    - wined3d_srgb_const0[2];
            corrected_color.b = min(max(corrected_color.b, 0.0f), 1.0f);
            color = &corrected_color;
        }
 
        gl_info->gl_ops.gl.p_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
        for (i = 0; i < MAX_RENDER_TARGETS; ++i)
            context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITE(i)));
        gl_info->gl_ops.gl.p_glClearColor(color->r, color->g, color->b, color->a);
        checkGLcall("glClearColor");
        clear_mask = clear_mask | GL_COLOR_BUFFER_BIT;
    }
 
    if (!rect_count)
    {
        if (render_offscreen)
        {
            gl_info->gl_ops.gl.p_glScissor(draw_rect->left, draw_rect->top,
                    draw_rect->right - draw_rect->left, draw_rect->bottom - draw_rect->top);
        }
        else
        {
            gl_info->gl_ops.gl.p_glScissor(draw_rect->left, drawable_height - draw_rect->bottom,
                        draw_rect->right - draw_rect->left, draw_rect->bottom - draw_rect->top);
        }
        checkGLcall("glScissor");
        gl_info->gl_ops.gl.p_glClear(clear_mask);
        checkGLcall("glClear");
    }
    else
    {
        RECT current_rect;
 
        /* Now process each rect in turn. */
        for (i = 0; i < rect_count; ++i)
        {
            /* Note that GL uses lower left, width/height. */
            IntersectRect(&current_rect, draw_rect, &clear_rect[i]);
 
            TRACE("clear_rect[%u] %s, current_rect %s.\n", i,
                    wine_dbgstr_rect(&clear_rect[i]),
                    wine_dbgstr_rect(&current_rect));
 
            /* Tests show that rectangles where x1 > x2 or y1 > y2 are ignored silently.
             * The rectangle is not cleared, no error is returned, but further rectangles are
             * still cleared if they are valid. */
            if (current_rect.left > current_rect.right || current_rect.top > current_rect.bottom)
            {
                TRACE("Rectangle with negative dimensions, ignoring.\n");
                continue;
            }
 
            if (render_offscreen)
            {
                gl_info->gl_ops.gl.p_glScissor(current_rect.left, current_rect.top,
                        current_rect.right - current_rect.left, current_rect.bottom - current_rect.top);
            }
            else
            {
                gl_info->gl_ops.gl.p_glScissor(current_rect.left, drawable_height - current_rect.bottom,
                          current_rect.right - current_rect.left, current_rect.bottom - current_rect.top);
            }
            checkGLcall("glScissor");
 
            gl_info->gl_ops.gl.p_glClear(clear_mask);
            checkGLcall("glClear");
        }
    }
 
    if (wined3d_settings.strict_draw_ordering || (flags & WINED3DCLEAR_TARGET
            && target->container->swapchain && target->container->swapchain->front_buffer == target->container))
        gl_info->gl_ops.gl.p_glFlush(); /* Flush to ensure ordering across contexts. */
 
    context_release(context);
}

Referenced by ffp_blitter_clear().

◆ device_context_add()

BOOL device_context_add	(	struct wined3d_device *	device,
		struct wined3d_context *	context
	)

Definition at line 146 of file device.c.

{
    struct wined3d_context **new_array;
 
    TRACE("Adding context %p.\n", context);
 
    if (!(new_array = heap_realloc(device->contexts, sizeof(*new_array) * (device->context_count + 1))))
    {
        ERR("Failed to grow the context array.\n");
        return FALSE;
    }
 
    new_array[device->context_count++] = context;
    device->contexts = new_array;
    return TRUE;
}

Referenced by context_create().

◆ device_context_remove()

void device_context_remove	(	struct wined3d_device *	device,
		struct wined3d_context *	context
	)

Definition at line 163 of file device.c.

{
    struct wined3d_context **new_array;
    BOOL found = FALSE;
    UINT i;
 
    TRACE("Removing context %p.\n", context);
 
    for (i = 0; i < device->context_count; ++i)
    {
        if (device->contexts[i] == context)
        {
            found = TRUE;
            break;
        }
    }
 
    if (!found)
    {
        ERR("Context %p doesn't exist in context array.\n", context);
        return;
    }
 
    if (!--device->context_count)
    {
        heap_free(device->contexts);
        device->contexts = NULL;
        return;
    }
 
    memmove(&device->contexts[i], &device->contexts[i + 1], (device->context_count - i) * sizeof(*device->contexts));
    if (!(new_array = heap_realloc(device->contexts, device->context_count * sizeof(*device->contexts))))
    {
        ERR("Failed to shrink context array. Oh well.\n");
        return;
    }
 
    device->contexts = new_array;
}

Referenced by context_create(), and context_destroy().

◆ device_free_sampler()

static void device_free_sampler	(	struct wine_rb_entry *	entry,
		void *	context
	)

static

Definition at line 1188 of file device.c.

{
    struct wined3d_sampler *sampler = WINE_RB_ENTRY_VALUE(entry, struct wined3d_sampler, entry);
 
    wined3d_sampler_decref(sampler);
}

Referenced by wined3d_device_reset(), and wined3d_device_uninit_3d().

◆ device_init()

HRESULT device_init	(	struct wined3d_device *	device,
		struct wined3d *	wined3d,
		UINT	adapter_idx,
		enum wined3d_device_type	device_type,
		HWND	focus_window,
		DWORD	flags,
		BYTE	surface_alignment,
		struct wined3d_device_parent *	device_parent
	)

Definition at line 5195 of file device.c.

{
    struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx];
    const struct fragment_pipeline *fragment_pipeline;
    const struct wined3d_vertex_pipe_ops *vertex_pipeline;
    unsigned int i;
    HRESULT hr;
 
    device->ref = 1;
    device->wined3d = wined3d;
    wined3d_incref(device->wined3d);
    device->adapter = wined3d->adapter_count ? adapter : NULL;
    device->device_parent = device_parent;
    list_init(&device->resources);
    list_init(&device->shaders);
    device->surface_alignment = surface_alignment;
 
    /* Save the creation parameters. */
    device->create_parms.adapter_idx = adapter_idx;
    device->create_parms.device_type = device_type;
    device->create_parms.focus_window = focus_window;
    device->create_parms.flags = flags;
 
    device->shader_backend = adapter->shader_backend;
 
    vertex_pipeline = adapter->vertex_pipe;
 
    fragment_pipeline = adapter->fragment_pipe;
 
    wine_rb_init(&device->samplers, wined3d_sampler_compare);
 
    if (vertex_pipeline->vp_states && fragment_pipeline->states
            && FAILED(hr = compile_state_table(device->StateTable, device->multistate_funcs,
            &adapter->gl_info, &adapter->d3d_info, vertex_pipeline,
            fragment_pipeline, misc_state_template)))
    {
        ERR("Failed to compile state table, hr %#x.\n", hr);
        wine_rb_destroy(&device->samplers, NULL, NULL);
        wined3d_decref(device->wined3d);
        return hr;
    }
 
    state_init(&device->state, &device->fb, &adapter->gl_info,
            &adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT);
    device->update_state = &device->state;
 
    if (!(device->cs = wined3d_cs_create(device)))
    {
        WARN("Failed to create command stream.\n");
        state_cleanup(&device->state);
        hr = E_FAIL;
        goto err;
    }
 
    return WINED3D_OK;
 
err:
    for (i = 0; i < ARRAY_SIZE(device->multistate_funcs); ++i)
    {
        heap_free(device->multistate_funcs[i]);
    }
    wine_rb_destroy(&device->samplers, NULL, NULL);
    wined3d_decref(device->wined3d);
    return hr;
}

◆ device_init_swapchain_state()

static void device_init_swapchain_state	(	struct wined3d_device *	device,
		struct wined3d_swapchain *	swapchain
	)

static

Definition at line 962 of file device.c.

{
    BOOL ds_enable = swapchain->desc.enable_auto_depth_stencil;
    unsigned int i;
 
    for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
    {
        wined3d_device_set_rendertarget_view(device, i, NULL, FALSE);
    }
    if (device->back_buffer_view)
        wined3d_device_set_rendertarget_view(device, 0, device->back_buffer_view, TRUE);
 
    wined3d_device_set_depth_stencil_view(device, ds_enable ? device->auto_depth_stencil_view : NULL);
}

Referenced by wined3d_device_init_3d(), and wined3d_device_reset().

◆ device_invalidate_state()

void device_invalidate_state	(	const struct wined3d_device *	device,
		DWORD	state
	)

Definition at line 5263 of file device.c.

{
    DWORD rep = device->StateTable[state].representative;
    struct wined3d_context *context;
    DWORD idx;
    BYTE shift;
    UINT i;
 
    wined3d_from_cs(device->cs);
 
    if (STATE_IS_COMPUTE(state))
    {
        for (i = 0; i < device->context_count; ++i)
            context_invalidate_compute_state(device->contexts[i], state);
        return;
    }
 
    for (i = 0; i < device->context_count; ++i)
    {
        context = device->contexts[i];
        if(isStateDirty(context, rep)) continue;
 
        context->dirtyArray[context->numDirtyEntries++] = rep;
        idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
        shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
        context->isStateDirty[idx] |= (1u << shift);
    }
}

◆ device_leftover_sampler()

static void device_leftover_sampler	(	struct wine_rb_entry *	entry,
		void *	context
	)

static

Definition at line 465 of file device.c.

{
    struct wined3d_sampler *sampler = WINE_RB_ENTRY_VALUE(entry, struct wined3d_sampler, entry);
 
    ERR("Leftover sampler %p.\n", sampler);
}

Referenced by wined3d_device_decref().

◆ device_load_logo()

static void device_load_logo	(	struct wined3d_device *	device,
		const char *	filename
	)

static

Definition at line 547 of file device.c.

{
    struct wined3d_color_key color_key;
    struct wined3d_resource_desc desc;
    HBITMAP hbm;
    BITMAP bm;
    HRESULT hr;
    HDC dcb = NULL, dcs = NULL;
 
    if (!(hbm = LoadImageA(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION)))
    {
        ERR_(winediag)("Failed to load logo %s.\n", wine_dbgstr_a(filename));
        return;
    }
    GetObjectA(hbm, sizeof(BITMAP), &bm);
 
    if (!(dcb = CreateCompatibleDC(NULL)))
        goto out;
    SelectObject(dcb, hbm);
 
    desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
    desc.format = WINED3DFMT_B5G6R5_UNORM;
    desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    desc.multisample_quality = 0;
    desc.usage = WINED3DUSAGE_DYNAMIC;
    desc.access = WINED3D_RESOURCE_ACCESS_GPU;
    desc.width = bm.bmWidth;
    desc.height = bm.bmHeight;
    desc.depth = 1;
    desc.size = 0;
    if (FAILED(hr = wined3d_texture_create(device, &desc, 1, 1,
            WINED3D_TEXTURE_CREATE_MAPPABLE | WINED3D_TEXTURE_CREATE_GET_DC,
            NULL, NULL, &wined3d_null_parent_ops, &device->logo_texture)))
    {
        ERR("Wine logo requested, but failed to create texture, hr %#x.\n", hr);
        goto out;
    }
 
    if (FAILED(hr = wined3d_texture_get_dc(device->logo_texture, 0, &dcs)))
    {
        wined3d_texture_decref(device->logo_texture);
        device->logo_texture = NULL;
        goto out;
    }
    BitBlt(dcs, 0, 0, bm.bmWidth, bm.bmHeight, dcb, 0, 0, SRCCOPY);
    wined3d_texture_release_dc(device->logo_texture, 0, dcs);
 
    color_key.color_space_low_value = 0;
    color_key.color_space_high_value = 0;
    wined3d_texture_set_color_key(device->logo_texture, WINED3D_CKEY_SRC_BLT, &color_key);
 
out:
    if (dcb) DeleteDC(dcb);
    if (hbm) DeleteObject(hbm);
}

Referenced by wined3d_device_init_3d(), and wined3d_device_reset().

◆ device_process_message()

LRESULT device_process_message	(	struct wined3d_device *	device,
		HWND	window,
		BOOL	unicode,
		UINT	message,
		WPARAM	wparam,
		LPARAM	lparam,
		WNDPROC	proc
	)

Definition at line 5292 of file device.c.

{
    if (device->filter_messages && message != WM_DISPLAYCHANGE)
    {
        TRACE("Filtering message: window %p, message %#x, wparam %#lx, lparam %#lx.\n",
                window, message, wparam, lparam);
        if (unicode)
            return DefWindowProcW(window, message, wparam, lparam);
        else
            return DefWindowProcA(window, message, wparam, lparam);
    }
 
    if (message == WM_DESTROY)
    {
        TRACE("unregister window %p.\n", window);
        wined3d_unregister_window(window);
 
        if (InterlockedCompareExchangePointer((void **)&device->focus_window, NULL, window) != window)
            ERR("Window %p is not the focus window for device %p.\n", window, device);
    }
    else if (message == WM_DISPLAYCHANGE)
    {
        device->device_parent->ops->mode_changed(device->device_parent);
    }
    else if (message == WM_ACTIVATEAPP)
    {
        UINT i;
 
        for (i = 0; i < device->swapchain_count; i++)
            wined3d_swapchain_activate(device->swapchains[i], wparam);
 
        device->device_parent->ops->activate(device->device_parent, wparam);
    }
    else if (message == WM_SYSCOMMAND)
    {
        if (wparam == SC_RESTORE && device->wined3d->flags & WINED3D_HANDLE_RESTORE)
        {
            if (unicode)
                DefWindowProcW(window, message, wparam, lparam);
            else
                DefWindowProcA(window, message, wparam, lparam);
        }
    }
 
    if (unicode)
        return CallWindowProcW(proc, window, message, wparam, lparam);
    else
        return CallWindowProcA(proc, window, message, wparam, lparam);
}

Referenced by wined3d_wndproc().

◆ device_resource_add()

void device_resource_add	(	struct wined3d_device *	device,
		struct wined3d_resource *	resource
	)

Definition at line 5081 of file device.c.

{
    TRACE("device %p, resource %p.\n", device, resource);
 
    wined3d_not_from_cs(device->cs);
 
    list_add_head(&device->resources, &resource->resource_list_entry);
}

Referenced by resource_init().

◆ device_resource_released()

void device_resource_released	(	struct wined3d_device *	device,
		struct wined3d_resource *	resource
	)

Definition at line 5099 of file device.c.

{
    enum wined3d_resource_type type = resource->type;
    struct wined3d_rendertarget_view *rtv;
    unsigned int i;
 
    TRACE("device %p, resource %p, type %s.\n", device, resource, debug_d3dresourcetype(type));
 
    if (device->d3d_initialized)
    {
        for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
        {
            if ((rtv = device->fb.render_targets[i]) && rtv->resource == resource)
                ERR("Resource %p is still in use as render target %u.\n", resource, i);
        }
 
        if ((rtv = device->fb.depth_stencil) && rtv->resource == resource)
            ERR("Resource %p is still in use as depth/stencil buffer.\n", resource);
    }
 
    switch (type)
    {
        case WINED3D_RTYPE_TEXTURE_1D:
        case WINED3D_RTYPE_TEXTURE_2D:
        case WINED3D_RTYPE_TEXTURE_3D:
            for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
            {
                struct wined3d_texture *texture = texture_from_resource(resource);
 
                if (device->state.textures[i] == texture)
                {
                    ERR("Texture %p is still in use, stage %u.\n", texture, i);
                    device->state.textures[i] = NULL;
                }
 
                if (device->recording && device->update_state->textures[i] == texture)
                {
                    ERR("Texture %p is still in use by recording stateblock %p, stage %u.\n",
                            texture, device->recording, i);
                    device->update_state->textures[i] = NULL;
                }
            }
            break;
 
        case WINED3D_RTYPE_BUFFER:
            {
                struct wined3d_buffer *buffer = buffer_from_resource(resource);
 
                for (i = 0; i < MAX_STREAMS; ++i)
                {
                    if (device->state.streams[i].buffer == buffer)
                    {
                        ERR("Buffer %p is still in use, stream %u.\n", buffer, i);
                        device->state.streams[i].buffer = NULL;
                    }
 
                    if (device->recording && device->update_state->streams[i].buffer == buffer)
                    {
                        ERR("Buffer %p is still in use by stateblock %p, stream %u.\n",
                                buffer, device->recording, i);
                        device->update_state->streams[i].buffer = NULL;
                    }
                }
 
                if (device->state.index_buffer == buffer)
                {
                    ERR("Buffer %p is still in use as index buffer.\n", buffer);
                    device->state.index_buffer =  NULL;
                }
 
                if (device->recording && device->update_state->index_buffer == buffer)
                {
                    ERR("Buffer %p is still in use by stateblock %p as index buffer.\n",
                            buffer, device->recording);
                    device->update_state->index_buffer =  NULL;
                }
            }
            break;
 
        default:
            break;
    }
 
    /* Remove the resource from the resourceStore */
    device_resource_remove(device, resource);
 
    TRACE("Resource released.\n");
}

Referenced by resource_cleanup().

◆ device_resource_remove()

static void device_resource_remove	(	struct wined3d_device *	device,
		struct wined3d_resource *	resource
	)

static

Definition at line 5090 of file device.c.

{
    TRACE("device %p, resource %p.\n", device, resource);
 
    wined3d_not_from_cs(device->cs);
 
    list_remove(&resource->resource_list_entry);
}

Referenced by device_resource_released().

◆ fullscreen_exstyle()

static LONG fullscreen_exstyle ( LONG exstyle )

static

Definition at line 845 of file device.c.

{
    /* Filter out window decorations. */
    exstyle &= ~(WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE);
 
    return exstyle;
}

Referenced by wined3d_device_restore_fullscreen_window(), and wined3d_device_setup_fullscreen_window().

◆ fullscreen_style()

static LONG fullscreen_style ( LONG style )

static

Definition at line 836 of file device.c.

{
    /* Make sure the window is managed, otherwise we won't get keyboard input. */
    style |= WS_POPUP | WS_SYSMENU;
    style &= ~(WS_CAPTION | WS_THICKFRAME);
 
    return style;
}

Referenced by wined3d_device_restore_fullscreen_window(), and wined3d_device_setup_fullscreen_window().

◆ gl_primitive_type_from_d3d()

GLenum gl_primitive_type_from_d3d ( enum wined3d_primitive_type primitive_type )

Definition at line 58 of file device.c.

{
    switch (primitive_type)
    {
        case WINED3D_PT_POINTLIST:
            return GL_POINTS;
 
        case WINED3D_PT_LINELIST:
            return GL_LINES;
 
        case WINED3D_PT_LINESTRIP:
            return GL_LINE_STRIP;
 
        case WINED3D_PT_TRIANGLELIST:
            return GL_TRIANGLES;
 
        case WINED3D_PT_TRIANGLESTRIP:
            return GL_TRIANGLE_STRIP;
 
        case WINED3D_PT_TRIANGLEFAN:
            return GL_TRIANGLE_FAN;
 
        case WINED3D_PT_LINELIST_ADJ:
            return GL_LINES_ADJACENCY_ARB;
 
        case WINED3D_PT_LINESTRIP_ADJ:
            return GL_LINE_STRIP_ADJACENCY_ARB;
 
        case WINED3D_PT_TRIANGLELIST_ADJ:
            return GL_TRIANGLES_ADJACENCY_ARB;
 
        case WINED3D_PT_TRIANGLESTRIP_ADJ:
            return GL_TRIANGLE_STRIP_ADJACENCY_ARB;
 
        case WINED3D_PT_PATCH:
            return GL_PATCHES;
 
        default:
            FIXME("Unhandled primitive type %s.\n", debug_d3dprimitivetype(primitive_type));
        case WINED3D_PT_UNDEFINED:
            return ~0u;
    }
}

Referenced by gl_tfb_primitive_type_from_d3d(), and wined3d_device_set_primitive_type().

◆ is_full_clear()

static BOOL is_full_clear	(	const struct wined3d_texture *	texture,
		unsigned int	sub_resource_idx,
		const RECT *	draw_rect,
		const RECT *	clear_rect
	)

static

Definition at line 203 of file device.c.

{
    unsigned int width, height, level;
 
    level = sub_resource_idx % texture->level_count;
    width = wined3d_texture_get_level_width(texture, level);
    height = wined3d_texture_get_level_height(texture, level);
 
    /* partial draw rect */
    if (draw_rect->left || draw_rect->top || draw_rect->right < width || draw_rect->bottom < height)
        return FALSE;
 
    /* partial clear rect */
    if (clear_rect && (clear_rect->left > 0 || clear_rect->top > 0
            || clear_rect->right < width || clear_rect->bottom < height))
        return FALSE;
 
    return TRUE;
}

Referenced by device_clear_render_targets().

◆ process_vertices_strided()

static HRESULT process_vertices_strided	(	const struct wined3d_device *	device,
		DWORD	dwDestIndex,
		DWORD	dwCount,
		const struct wined3d_stream_info *	stream_info,
		struct wined3d_buffer *	dest,
		DWORD	flags,
		DWORD	DestFVF
	)

static

Definition at line 3070 of file device.c.

{
    struct wined3d_matrix mat, proj_mat, view_mat, world_mat;
    struct wined3d_map_desc map_desc;
    struct wined3d_box box = {0};
    struct wined3d_viewport vp;
    UINT vertex_size;
    unsigned int i;
    BYTE *dest_ptr;
    BOOL doClip;
    DWORD numTextures;
    HRESULT hr;
 
    if (stream_info->use_map & (1u << WINED3D_FFP_NORMAL))
    {
        WARN(" lighting state not saved yet... Some strange stuff may happen !\n");
    }
 
    if (!(stream_info->use_map & (1u << WINED3D_FFP_POSITION)))
    {
        ERR("Source has no position mask\n");
        return WINED3DERR_INVALIDCALL;
    }
 
    if (device->state.render_states[WINED3D_RS_CLIPPING])
    {
        static BOOL warned = FALSE;
        /*
         * The clipping code is not quite correct. Some things need
         * to be checked against IDirect3DDevice3 (!), d3d8 and d3d9,
         * so disable clipping for now.
         * (The graphics in Half-Life are broken, and my processvertices
         *  test crashes with IDirect3DDevice3)
        doClip = TRUE;
         */
        doClip = FALSE;
        if(!warned) {
           warned = TRUE;
           FIXME("Clipping is broken and disabled for now\n");
        }
    }
    else
        doClip = FALSE;
 
    vertex_size = get_flexible_vertex_size(DestFVF);
    box.left = dwDestIndex * vertex_size;
    box.right = box.left + dwCount * vertex_size;
    if (FAILED(hr = wined3d_resource_map(&dest->resource, 0, &map_desc, &box, WINED3D_MAP_WRITE)))
    {
        WARN("Failed to map buffer, hr %#x.\n", hr);
        return hr;
    }
    dest_ptr = map_desc.data;
 
    wined3d_device_get_transform(device, WINED3D_TS_VIEW, &view_mat);
    wined3d_device_get_transform(device, WINED3D_TS_PROJECTION, &proj_mat);
    wined3d_device_get_transform(device, WINED3D_TS_WORLD_MATRIX(0), &world_mat);
 
    TRACE("View mat:\n");
    TRACE("%.8e %.8e %.8e %.8e\n", view_mat._11, view_mat._12, view_mat._13, view_mat._14);
    TRACE("%.8e %.8e %.8e %.8e\n", view_mat._21, view_mat._22, view_mat._23, view_mat._24);
    TRACE("%.8e %.8e %.8e %.8e\n", view_mat._31, view_mat._32, view_mat._33, view_mat._34);
    TRACE("%.8e %.8e %.8e %.8e\n", view_mat._41, view_mat._42, view_mat._43, view_mat._44);
 
    TRACE("Proj mat:\n");
    TRACE("%.8e %.8e %.8e %.8e\n", proj_mat._11, proj_mat._12, proj_mat._13, proj_mat._14);
    TRACE("%.8e %.8e %.8e %.8e\n", proj_mat._21, proj_mat._22, proj_mat._23, proj_mat._24);
    TRACE("%.8e %.8e %.8e %.8e\n", proj_mat._31, proj_mat._32, proj_mat._33, proj_mat._34);
    TRACE("%.8e %.8e %.8e %.8e\n", proj_mat._41, proj_mat._42, proj_mat._43, proj_mat._44);
 
    TRACE("World mat:\n");
    TRACE("%.8e %.8e %.8e %.8e\n", world_mat._11, world_mat._12, world_mat._13, world_mat._14);
    TRACE("%.8e %.8e %.8e %.8e\n", world_mat._21, world_mat._22, world_mat._23, world_mat._24);
    TRACE("%.8e %.8e %.8e %.8e\n", world_mat._31, world_mat._32, world_mat._33, world_mat._34);
    TRACE("%.8e %.8e %.8e %.8e\n", world_mat._41, world_mat._42, world_mat._43, world_mat._44);
 
    /* Get the viewport */
    wined3d_device_get_viewport(device, &vp);
    TRACE("viewport  x %.8e, y %.8e, width %.8e, height %.8e, min_z %.8e, max_z %.8e.\n",
          vp.x, vp.y, vp.width, vp.height, vp.min_z, vp.max_z);
 
    multiply_matrix(&mat,&view_mat,&world_mat);
    multiply_matrix(&mat,&proj_mat,&mat);
 
    numTextures = (DestFVF & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
 
    for (i = 0; i < dwCount; i+= 1) {
        unsigned int tex_index;
 
        if ( ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZ ) ||
             ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) ) {
            /* The position first */
            const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_POSITION];
            const float *p = (const float *)(element->data.addr + i * element->stride);
            float x, y, z, rhw;
            TRACE("In: ( %06.2f %06.2f %06.2f )\n", p[0], p[1], p[2]);
 
            /* Multiplication with world, view and projection matrix. */
            x   = (p[0] * mat._11) + (p[1] * mat._21) + (p[2] * mat._31) + mat._41;
            y   = (p[0] * mat._12) + (p[1] * mat._22) + (p[2] * mat._32) + mat._42;
            z   = (p[0] * mat._13) + (p[1] * mat._23) + (p[2] * mat._33) + mat._43;
            rhw = (p[0] * mat._14) + (p[1] * mat._24) + (p[2] * mat._34) + mat._44;
 
            TRACE("x=%f y=%f z=%f rhw=%f\n", x, y, z, rhw);
 
            /* WARNING: The following things are taken from d3d7 and were not yet checked
             * against d3d8 or d3d9!
             */
 
            /* Clipping conditions: From msdn
             *
             * A vertex is clipped if it does not match the following requirements
             * -rhw < x <= rhw
             * -rhw < y <= rhw
             *    0 < z <= rhw
             *    0 < rhw ( Not in d3d7, but tested in d3d7)
             *
             * If clipping is on is determined by the D3DVOP_CLIP flag in D3D7, and
             * by the D3DRS_CLIPPING in D3D9(according to the msdn, not checked)
             *
             */
 
            if( !doClip ||
                ( (-rhw -eps < x) && (-rhw -eps < y) && ( -eps < z) &&
                  (x <= rhw + eps) && (y <= rhw + eps ) && (z <= rhw + eps) &&
                  ( rhw > eps ) ) ) {
 
                /* "Normal" viewport transformation (not clipped)
                 * 1) The values are divided by rhw
                 * 2) The y axis is negative, so multiply it with -1
                 * 3) Screen coordinates go from -(Width/2) to +(Width/2) and
                 *    -(Height/2) to +(Height/2). The z range is MinZ to MaxZ
                 * 4) Multiply x with Width/2 and add Width/2
                 * 5) The same for the height
                 * 6) Add the viewpoint X and Y to the 2D coordinates and
                 *    The minimum Z value to z
                 * 7) rhw = 1 / rhw Reciprocal of Homogeneous W....
                 *
                 * Well, basically it's simply a linear transformation into viewport
                 * coordinates
                 */
 
                x /= rhw;
                y /= rhw;
                z /= rhw;
 
                y *= -1;
 
                x *= vp.width / 2;
                y *= vp.height / 2;
                z *= vp.max_z - vp.min_z;
 
                x += vp.width / 2 + vp.x;
                y += vp.height / 2 + vp.y;
                z += vp.min_z;
 
                rhw = 1 / rhw;
            } else {
                /* That vertex got clipped
                 * Contrary to OpenGL it is not dropped completely, it just
                 * undergoes a different calculation.
                 */
                TRACE("Vertex got clipped\n");
                x += rhw;
                y += rhw;
 
                x  /= 2;
                y  /= 2;
 
                /* Msdn mentions that Direct3D9 keeps a list of clipped vertices
                 * outside of the main vertex buffer memory. That needs some more
                 * investigation...
                 */
            }
 
            TRACE("Writing (%f %f %f) %f\n", x, y, z, rhw);
 
 
            ( (float *) dest_ptr)[0] = x;
            ( (float *) dest_ptr)[1] = y;
            ( (float *) dest_ptr)[2] = z;
            ( (float *) dest_ptr)[3] = rhw; /* SIC, see ddraw test! */
 
            dest_ptr += 3 * sizeof(float);
 
            if ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW)
                dest_ptr += sizeof(float);
        }
 
        if (DestFVF & WINED3DFVF_PSIZE)
            dest_ptr += sizeof(DWORD);
 
        if (DestFVF & WINED3DFVF_NORMAL)
        {
            const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_NORMAL];
            const float *normal = (const float *)(element->data.addr + i * element->stride);
            /* AFAIK this should go into the lighting information */
            FIXME("Didn't expect the destination to have a normal\n");
            copy_and_next(dest_ptr, normal, 3 * sizeof(float));
        }
 
        if (DestFVF & WINED3DFVF_DIFFUSE)
        {
            const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_DIFFUSE];
            const DWORD *color_d = (const DWORD *)(element->data.addr + i * element->stride);
            if (!(stream_info->use_map & (1u << WINED3D_FFP_DIFFUSE)))
            {
                static BOOL warned = FALSE;
 
                if(!warned) {
                    ERR("No diffuse color in source, but destination has one\n");
                    warned = TRUE;
                }
 
                *( (DWORD *) dest_ptr) = 0xffffffff;
                dest_ptr += sizeof(DWORD);
            }
            else
            {
                copy_and_next(dest_ptr, color_d, sizeof(DWORD));
            }
        }
 
        if (DestFVF & WINED3DFVF_SPECULAR)
        {
            /* What's the color value in the feedback buffer? */
            const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_SPECULAR];
            const DWORD *color_s = (const DWORD *)(element->data.addr + i * element->stride);
            if (!(stream_info->use_map & (1u << WINED3D_FFP_SPECULAR)))
            {
                static BOOL warned = FALSE;
 
                if(!warned) {
                    ERR("No specular color in source, but destination has one\n");
                    warned = TRUE;
                }
 
                *(DWORD *)dest_ptr = 0xff000000;
                dest_ptr += sizeof(DWORD);
            }
            else
            {
                copy_and_next(dest_ptr, color_s, sizeof(DWORD));
            }
        }
 
        for (tex_index = 0; tex_index < numTextures; ++tex_index)
        {
            const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_TEXCOORD0 + tex_index];
            const float *tex_coord = (const float *)(element->data.addr + i * element->stride);
            if (!(stream_info->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + tex_index))))
            {
                ERR("No source texture, but destination requests one\n");
                dest_ptr += GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
            }
            else
            {
                copy_and_next(dest_ptr, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
            }
        }
    }
 
    wined3d_resource_unmap(&dest->resource, 0);
 
    return WINED3D_OK;
}

Referenced by wined3d_device_process_vertices().

◆ resolve_depth_buffer()

static void resolve_depth_buffer ( struct wined3d_device * device )

static

Definition at line 1957 of file device.c.

{
    const struct wined3d_state *state = &device->state;
    struct wined3d_rendertarget_view *src_view;
    struct wined3d_resource *dst_resource;
    struct wined3d_texture *dst_texture;
 
    if (!(dst_texture = state->textures[0]))
        return;
    dst_resource = &dst_texture->resource;
    if (!(dst_resource->format_flags & WINED3DFMT_FLAG_DEPTH))
        return;
    if (!(src_view = state->fb->depth_stencil))
        return;
 
    wined3d_device_resolve_sub_resource(device, dst_resource, 0,
            src_view->resource, src_view->sub_resource_idx, dst_resource->format->id);
}

Referenced by wined3d_device_set_render_state().

◆ WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL ( winediag )

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( d3d )

◆ wined3d_device_acquire_focus_window()

HRESULT CDECL wined3d_device_acquire_focus_window	(	struct wined3d_device *	device,
		HWND	window
	)

Definition at line 938 of file device.c.

{
    TRACE("device %p, window %p.\n", device, window);
 
    if (!wined3d_register_window(window, device))
    {
        ERR("Failed to register window %p.\n", window);
        return E_FAIL;
    }
 
    InterlockedExchangePointer((void **)&device->focus_window, window);
    SetWindowPos(window, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
 
    return WINED3D_OK;
}

Referenced by ddraw_set_cooperative_level(), device_init(), and wined3d_swapchain_set_fullscreen().

◆ wined3d_device_begin_scene()

HRESULT CDECL wined3d_device_begin_scene ( struct wined3d_device * device )

Definition at line 3602 of file device.c.

{
    /* At the moment we have no need for any functionality at the beginning
     * of a scene. */
    TRACE("device %p.\n", device);
 
    if (device->inScene)
    {
        WARN("Already in scene, returning WINED3DERR_INVALIDCALL.\n");
        return WINED3DERR_INVALIDCALL;
    }
    device->inScene = TRUE;
    return WINED3D_OK;
}

Referenced by d3d8_device_BeginScene(), d3d9_device_BeginScene(), and d3d_device7_BeginScene().

◆ wined3d_device_begin_stateblock()

HRESULT CDECL wined3d_device_begin_stateblock ( struct wined3d_device * device )

Definition at line 3555 of file device.c.

{
    struct wined3d_stateblock *stateblock;
    HRESULT hr;
 
    TRACE("device %p.\n", device);
 
    if (device->recording)
        return WINED3DERR_INVALIDCALL;
 
    hr = wined3d_stateblock_create(device, WINED3D_SBT_RECORDED, &stateblock);
    if (FAILED(hr))
        return hr;
 
    device->recording = stateblock;
    device->update_state = &stateblock->state;
 
    TRACE("Recording stateblock %p.\n", stateblock);
 
    return WINED3D_OK;
}

Referenced by d3d8_device_BeginStateBlock(), d3d9_device_BeginStateBlock(), and d3d_device7_BeginStateBlock().

◆ wined3d_device_clear()

HRESULT CDECL wined3d_device_clear	(	struct wined3d_device *	device,
		DWORD	rect_count,
		const RECT *	rects,
		DWORD	flags,
		const struct wined3d_color *	color,
		float	depth,
		DWORD	stencil
	)

Definition at line 3633 of file device.c.

{
    TRACE("device %p, rect_count %u, rects %p, flags %#x, color %s, depth %.8e, stencil %u.\n",
            device, rect_count, rects, flags, debug_color(color), depth, stencil);
 
    if (!rect_count && rects)
    {
        WARN("Rects is %p, but rect_count is 0, ignoring clear\n", rects);
        return WINED3D_OK;
    }
 
    if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
    {
        struct wined3d_rendertarget_view *ds = device->fb.depth_stencil;
        if (!ds)
        {
            WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
            /* TODO: What about depth stencil buffers without stencil bits? */
            return WINED3DERR_INVALIDCALL;
        }
        else if (flags & WINED3DCLEAR_TARGET)
        {
            if (ds->width < device->fb.render_targets[0]->width
                    || ds->height < device->fb.render_targets[0]->height)
            {
                WARN("Silently ignoring depth and target clear with mismatching sizes\n");
                return WINED3D_OK;
            }
        }
    }
 
    wined3d_cs_emit_clear(device->cs, rect_count, rects, flags, color, depth, stencil);
 
    return WINED3D_OK;
}

Referenced by d3d8_device_Clear(), d3d9_device_Clear(), d3d_device7_Clear(), and wined3d_device_init_3d().

◆ wined3d_device_clear_rendertarget_view()

HRESULT CDECL wined3d_device_clear_rendertarget_view	(	struct wined3d_device *	device,
		struct wined3d_rendertarget_view *	view,
		const RECT *	rect,
		DWORD	flags,
		const struct wined3d_color *	color,
		float	depth,
		DWORD	stencil
	)

Definition at line 4392 of file device.c.

{
    struct wined3d_resource *resource;
    RECT r;
 
    TRACE("device %p, view %p, rect %s, flags %#x, color %s, depth %.8e, stencil %u.\n",
            device, view, wine_dbgstr_rect(rect), flags, debug_color(color), depth, stencil);
 
    if (!flags)
        return WINED3D_OK;
 
    resource = view->resource;
    if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
    {
        FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type));
        return WINED3DERR_INVALIDCALL;
    }
 
    if (view->layer_count > 1)
    {
        FIXME("Layered clears not implemented.\n");
        return WINED3DERR_INVALIDCALL;
    }
 
    if (!rect)
    {
        SetRect(&r, 0, 0, view->width, view->height);
        rect = &r;
    }
    else
    {
        struct wined3d_box b = {rect->left, rect->top, rect->right, rect->bottom, 0, 1};
        struct wined3d_texture *texture = texture_from_resource(view->resource);
        HRESULT hr;
 
        if (FAILED(hr = wined3d_texture_check_box_dimensions(texture,
                view->sub_resource_idx % texture->level_count, &b)))
            return hr;
    }
 
    wined3d_cs_emit_clear_rendertarget_view(device->cs, view, rect, flags, color, depth, stencil);
 
    return WINED3D_OK;
}

Referenced by d3d9_device_ColorFill(), and ddraw_surface_blt().

◆ wined3d_device_clear_unordered_access_view_uint()

void CDECL wined3d_device_clear_unordered_access_view_uint	(	struct wined3d_device *	device,
		struct wined3d_unordered_access_view *	view,
		const struct wined3d_uvec4 *	clear_value
	)

Definition at line 4439 of file device.c.

{
    TRACE("device %p, view %p, clear_value %s.\n", device, view, debug_uvec4(clear_value));
 
    wined3d_cs_emit_clear_unordered_access_view_uint(device->cs, view, clear_value);
}

◆ wined3d_device_copy_resource()

void CDECL wined3d_device_copy_resource	(	struct wined3d_device *	device,
		struct wined3d_resource *	dst_resource,
		struct wined3d_resource *	src_resource
	)

Definition at line 4043 of file device.c.

{
    struct wined3d_texture *dst_texture, *src_texture;
    struct wined3d_box box;
    unsigned int i, j;
 
    TRACE("device %p, dst_resource %p, src_resource %p.\n", device, dst_resource, src_resource);
 
    if (src_resource == dst_resource)
    {
        WARN("Source and destination are the same resource.\n");
        return;
    }
 
    if (src_resource->type != dst_resource->type)
    {
        WARN("Resource types (%s / %s) don't match.\n",
                debug_d3dresourcetype(dst_resource->type),
                debug_d3dresourcetype(src_resource->type));
        return;
    }
 
    if (src_resource->width != dst_resource->width
            || src_resource->height != dst_resource->height
            || src_resource->depth != dst_resource->depth)
    {
        WARN("Resource dimensions (%ux%ux%u / %ux%ux%u) don't match.\n",
                dst_resource->width, dst_resource->height, dst_resource->depth,
                src_resource->width, src_resource->height, src_resource->depth);
        return;
    }
 
    if (src_resource->format->typeless_id != dst_resource->format->typeless_id
            || (!src_resource->format->typeless_id && src_resource->format->id != dst_resource->format->id))
    {
        WARN("Resource formats %s and %s are incompatible.\n",
                debug_d3dformat(dst_resource->format->id),
                debug_d3dformat(src_resource->format->id));
        return;
    }
 
    if (dst_resource->type == WINED3D_RTYPE_BUFFER)
    {
        wined3d_box_set(&box, 0, 0, src_resource->size, 1, 0, 1);
        wined3d_cs_emit_blt_sub_resource(device->cs, dst_resource, 0, &box,
                src_resource, 0, &box, WINED3D_BLT_RAW, NULL, WINED3D_TEXF_POINT);
        return;
    }
 
    dst_texture = texture_from_resource(dst_resource);
    src_texture = texture_from_resource(src_resource);
 
    if (src_texture->layer_count != dst_texture->layer_count
            || src_texture->level_count != dst_texture->level_count)
    {
        WARN("Subresource layouts (%ux%u / %ux%u) don't match.\n",
                dst_texture->layer_count, dst_texture->level_count,
                src_texture->layer_count, src_texture->level_count);
        return;
    }
 
    for (i = 0; i < dst_texture->level_count; ++i)
    {
        wined3d_box_set(&box, 0, 0,
                wined3d_texture_get_level_width(dst_texture, i),
                wined3d_texture_get_level_height(dst_texture, i),
                0, wined3d_texture_get_level_depth(dst_texture, i));
        for (j = 0; j < dst_texture->layer_count; ++j)
        {
            unsigned int idx = j * dst_texture->level_count + i;
 
            wined3d_cs_emit_blt_sub_resource(device->cs, dst_resource, idx, &box,
                    src_resource, idx, &box, WINED3D_BLT_RAW, NULL, WINED3D_TEXF_POINT);
        }
    }
}

◆ wined3d_device_copy_sub_resource_region()

HRESULT CDECL wined3d_device_copy_sub_resource_region	(	struct wined3d_device *	device,
		struct wined3d_resource *	dst_resource,
		unsigned int	dst_sub_resource_idx,
		unsigned int	dst_x,
		unsigned int	dst_y,
		unsigned int	dst_z,
		struct wined3d_resource *	src_resource,
		unsigned int	src_sub_resource_idx,
		const struct wined3d_box *	src_box
	)

Definition at line 4121 of file device.c.

{
    struct wined3d_box dst_box, b;
 
    TRACE("device %p, dst_resource %p, dst_sub_resource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
            "src_resource %p, src_sub_resource_idx %u, src_box %s.\n",
            device, dst_resource, dst_sub_resource_idx, dst_x, dst_y, dst_z,
            src_resource, src_sub_resource_idx, debug_box(src_box));
 
    if (src_resource == dst_resource && src_sub_resource_idx == dst_sub_resource_idx)
    {
        WARN("Source and destination are the same sub-resource.\n");
        return WINED3DERR_INVALIDCALL;
    }
 
    if (src_resource->type != dst_resource->type)
    {
        WARN("Resource types (%s / %s) don't match.\n",
                debug_d3dresourcetype(dst_resource->type),
                debug_d3dresourcetype(src_resource->type));
        return WINED3DERR_INVALIDCALL;
    }
 
    if (src_resource->format->typeless_id != dst_resource->format->typeless_id
            || (!src_resource->format->typeless_id && src_resource->format->id != dst_resource->format->id))
    {
        WARN("Resource formats %s and %s are incompatible.\n",
                debug_d3dformat(dst_resource->format->id),
                debug_d3dformat(src_resource->format->id));
        return WINED3DERR_INVALIDCALL;
    }
 
    if (dst_resource->type == WINED3D_RTYPE_BUFFER)
    {
        if (dst_sub_resource_idx)
        {
            WARN("Invalid dst_sub_resource_idx %u.\n", dst_sub_resource_idx);
            return WINED3DERR_INVALIDCALL;
        }
 
        if (src_sub_resource_idx)
        {
            WARN("Invalid src_sub_resource_idx %u.\n", src_sub_resource_idx);
            return WINED3DERR_INVALIDCALL;
        }
 
        if (!src_box)
        {
            unsigned int dst_w;
 
            dst_w = dst_resource->size - dst_x;
            wined3d_box_set(&b, 0, 0, min(src_resource->size, dst_w), 1, 0, 1);
            src_box = &b;
        }
        else if ((src_box->left >= src_box->right
                || src_box->top >= src_box->bottom
                || src_box->front >= src_box->back))
        {
            WARN("Invalid box %s specified.\n", debug_box(src_box));
            return WINED3DERR_INVALIDCALL;
        }
 
        if (src_box->right > src_resource->size || dst_x >= dst_resource->size
                || src_box->right - src_box->left > dst_resource->size - dst_x)
        {
            WARN("Invalid range specified, dst_offset %u, src_offset %u, size %u.\n",
                    dst_x, src_box->left, src_box->right - src_box->left);
            return WINED3DERR_INVALIDCALL;
        }
 
        wined3d_box_set(&dst_box, dst_x, 0, dst_x + (src_box->right - src_box->left), 1, 0, 1);
    }
    else if (dst_resource->type == WINED3D_RTYPE_TEXTURE_2D)
    {
        struct wined3d_texture *dst_texture = texture_from_resource(dst_resource);
        struct wined3d_texture *src_texture = texture_from_resource(src_resource);
        unsigned int src_level = src_sub_resource_idx % src_texture->level_count;
 
        if (dst_sub_resource_idx >= dst_texture->level_count * dst_texture->layer_count)
        {
            WARN("Invalid destination sub-resource %u.\n", dst_sub_resource_idx);
            return WINED3DERR_INVALIDCALL;
        }
 
        if (src_sub_resource_idx >= src_texture->level_count * src_texture->layer_count)
        {
            WARN("Invalid source sub-resource %u.\n", src_sub_resource_idx);
            return WINED3DERR_INVALIDCALL;
        }
 
#if !defined(STAGING_CSMT)
        if (dst_texture->sub_resources[dst_sub_resource_idx].map_count)
        {
            WARN("Destination sub-resource %u is mapped.\n", dst_sub_resource_idx);
            return WINED3DERR_INVALIDCALL;
        }
 
        if (src_texture->sub_resources[src_sub_resource_idx].map_count)
        {
            WARN("Source sub-resource %u is mapped.\n", src_sub_resource_idx);
            return WINED3DERR_INVALIDCALL;
#else  /* STAGING_CSMT */
        if (dst_texture->sub_resources[dst_sub_resource_idx].map_count ||
            src_texture->sub_resources[src_sub_resource_idx].map_count)
        {
            struct wined3d_device *device = dst_texture->resource.device;
            device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
            if (dst_texture->sub_resources[dst_sub_resource_idx].map_count ||
                src_texture->sub_resources[src_sub_resource_idx].map_count)
            {
                WARN("Destination or source sub-resource is mapped.\n");
                return WINEDDERR_SURFACEBUSY;
            }
#endif /* STAGING_CSMT */
        }
 
        if (!src_box)
        {
            unsigned int src_w, src_h, dst_w, dst_h, dst_level;
 
            src_w = wined3d_texture_get_level_width(src_texture, src_level);
            src_h = wined3d_texture_get_level_height(src_texture, src_level);
 
            dst_level = dst_sub_resource_idx % dst_texture->level_count;
            dst_w = wined3d_texture_get_level_width(dst_texture, dst_level) - dst_x;
            dst_h = wined3d_texture_get_level_height(dst_texture, dst_level) - dst_y;
 
            wined3d_box_set(&b, 0, 0, min(src_w, dst_w), min(src_h, dst_h), 0, 1);
            src_box = &b;
        }
        else if (FAILED(wined3d_texture_check_box_dimensions(src_texture, src_level, src_box)))
        {
            WARN("Invalid source box %s.\n", debug_box(src_box));
            return WINED3DERR_INVALIDCALL;
        }
 
        wined3d_box_set(&dst_box, dst_x, dst_y, dst_x + (src_box->right - src_box->left),
                dst_y + (src_box->bottom - src_box->top), 0, 1);
        if (FAILED(wined3d_texture_check_box_dimensions(dst_texture,
                dst_sub_resource_idx % dst_texture->level_count, &dst_box)))
        {
            WARN("Invalid destination box %s.\n", debug_box(&dst_box));
            return WINED3DERR_INVALIDCALL;
        }
    }
    else
    {
        FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(dst_resource->type));
        return WINED3DERR_INVALIDCALL;
    }
 
    wined3d_cs_emit_blt_sub_resource(device->cs, dst_resource, dst_sub_resource_idx, &dst_box,
            src_resource, src_sub_resource_idx, src_box, WINED3D_BLT_RAW, NULL, WINED3D_TEXF_POINT);
 
    return WINED3D_OK;
}

Referenced by d3d9_device_UpdateSurface().

◆ wined3d_device_copy_uav_counter()

void CDECL wined3d_device_copy_uav_counter	(	struct wined3d_device *	device,
		struct wined3d_buffer *	dst_buffer,
		unsigned int	offset,
		struct wined3d_unordered_access_view *	uav
	)

Definition at line 4028 of file device.c.

{
    TRACE("device %p, dst_buffer %p, offset %u, uav %p.\n",
            device, dst_buffer, offset, uav);
 
    if (offset + sizeof(GLuint) > dst_buffer->resource.size)
    {
        WARN("Offset %u too large.\n", offset);
        return;
    }
 
    wined3d_cs_emit_copy_uav_counter(device->cs, dst_buffer, offset, uav);
}

◆ wined3d_device_create_cursor_texture()

static struct wined3d_texture * wined3d_device_create_cursor_texture	(	struct wined3d_device *	device,
		struct wined3d_texture *	cursor_image,
		unsigned int	sub_resource_idx
	)

static

Definition at line 4544 of file device.c.

{
    unsigned int texture_level = sub_resource_idx % cursor_image->level_count;
    struct wined3d_sub_resource_data data;
    struct wined3d_resource_desc desc;
    struct wined3d_map_desc map_desc;
    struct wined3d_texture *texture;
    HRESULT hr;
 
    if (FAILED(wined3d_resource_map(&cursor_image->resource, sub_resource_idx, &map_desc, NULL, WINED3D_MAP_READ)))
    {
        ERR("Failed to map source texture.\n");
        return NULL;
    }
 
    data.data = map_desc.data;
    data.row_pitch = map_desc.row_pitch;
    data.slice_pitch = map_desc.slice_pitch;
 
    desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
    desc.format = WINED3DFMT_B8G8R8A8_UNORM;
    desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    desc.multisample_quality = 0;
    desc.usage = WINED3DUSAGE_DYNAMIC;
    desc.access = WINED3D_RESOURCE_ACCESS_GPU;
    desc.width = wined3d_texture_get_level_width(cursor_image, texture_level);
    desc.height = wined3d_texture_get_level_height(cursor_image, texture_level);
    desc.depth = 1;
    desc.size = 0;
 
    hr = wined3d_texture_create(device, &desc, 1, 1, WINED3D_TEXTURE_CREATE_MAPPABLE,
            &data, NULL, &wined3d_null_parent_ops, &texture);
    wined3d_resource_unmap(&cursor_image->resource, sub_resource_idx);
    if (FAILED(hr))
    {
        ERR("Failed to create cursor texture.\n");
        return NULL;
    }
 
    return texture;
}

Referenced by wined3d_device_set_cursor_properties().

◆ wined3d_device_create_primary_opengl_context()

static HRESULT wined3d_device_create_primary_opengl_context ( struct wined3d_device * device )

static

Definition at line 1051 of file device.c.

{
    wined3d_cs_init_object(device->cs, wined3d_device_create_primary_opengl_context_cs, device);
    device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
    if (!device->swapchains[0]->num_contexts)
        return E_FAIL;
 
    return WINED3D_OK;
}

Referenced by wined3d_device_init_3d(), and wined3d_device_reset().

◆ wined3d_device_create_primary_opengl_context_cs()

static void wined3d_device_create_primary_opengl_context_cs ( void * object )

static

Definition at line 1017 of file device.c.

{
    struct wined3d_device *device = object;
    struct wined3d_swapchain *swapchain;
    struct wined3d_context *context;
    struct wined3d_texture *target;
    HRESULT hr;
 
    if (FAILED(hr = device->shader_backend->shader_alloc_private(device,
            device->adapter->vertex_pipe, device->adapter->fragment_pipe)))
    {
        ERR("Failed to allocate shader private data, hr %#x.\n", hr);
        return;
    }
 
    if (!(device->blitter = wined3d_cpu_blitter_create()))
    {
        ERR("Failed to create CPU blitter.\n");
        device->shader_backend->shader_free_private(device);
        return;
    }
    wined3d_ffp_blitter_create(&device->blitter, &device->adapter->gl_info);
    wined3d_arbfp_blitter_create(&device->blitter, device);
    wined3d_fbo_blitter_create(&device->blitter, &device->adapter->gl_info);
    wined3d_raw_blitter_create(&device->blitter, &device->adapter->gl_info);
 
    swapchain = device->swapchains[0];
    target = swapchain->back_buffers ? swapchain->back_buffers[0] : swapchain->front_buffer;
    context = context_acquire(device, target, 0);
    create_dummy_textures(device, context);
    create_default_samplers(device, context);
    context_release(context);
}

Referenced by wined3d_device_create_primary_opengl_context().

◆ wined3d_device_decref()

ULONG CDECL wined3d_device_decref ( struct wined3d_device * device )

Definition at line 472 of file device.c.

{
    ULONG refcount = InterlockedDecrement(&device->ref);
 
    TRACE("%p decreasing refcount to %u.\n", device, refcount);
 
    if (!refcount)
    {
        UINT i;
 
        wined3d_cs_destroy(device->cs);
 
        if (device->recording && wined3d_stateblock_decref(device->recording))
            ERR("Something's still holding the recording stateblock.\n");
        device->recording = NULL;
 
        state_cleanup(&device->state);
 
        for (i = 0; i < ARRAY_SIZE(device->multistate_funcs); ++i)
        {
            heap_free(device->multistate_funcs[i]);
            device->multistate_funcs[i] = NULL;
        }
 
        if (!list_empty(&device->resources))
        {
            struct wined3d_resource *resource;
 
            ERR("Device released with resources still bound.\n");
 
            LIST_FOR_EACH_ENTRY(resource, &device->resources, struct wined3d_resource, resource_list_entry)
            {
                ERR("Leftover resource %p with type %s (%#x).\n",
                        resource, debug_d3dresourcetype(resource->type), resource->type);
            }
        }
 
        if (device->contexts)
            ERR("Context array not freed!\n");
        if (device->hardwareCursor)
            DestroyCursor(device->hardwareCursor);
        device->hardwareCursor = 0;
 
        wine_rb_destroy(&device->samplers, device_leftover_sampler, NULL);
 
        wined3d_decref(device->wined3d);
        device->wined3d = NULL;
        heap_free(device);
        TRACE("Freed device %p.\n", device);
    }
 
    return refcount;
}

Referenced by d3d8_device_Release(), d3d9_device_Release(), d3d_device_inner_Release(), ddraw_destroy(), ddraw_surface_release_iface(), and device_init().

◆ wined3d_device_delete_opengl_contexts()

static void wined3d_device_delete_opengl_contexts ( struct wined3d_device * device )

static

Definition at line 1011 of file device.c.

{
    wined3d_cs_destroy_object(device->cs, wined3d_device_delete_opengl_contexts_cs, device);
    device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
}

Referenced by wined3d_device_reset(), and wined3d_device_uninit_3d().

◆ wined3d_device_delete_opengl_contexts_cs()

static void wined3d_device_delete_opengl_contexts_cs ( void * object )

static

Definition at line 977 of file device.c.

{
    struct wined3d_resource *resource, *cursor;
    struct wined3d_device *device = object;
    struct wined3d_context *context;
    struct wined3d_shader *shader;
 
    LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
    {
        TRACE("Unloading resource %p.\n", resource);
        wined3d_cs_emit_unload_resource(device->cs, resource);
    }
 
    LIST_FOR_EACH_ENTRY(shader, &device->shaders, struct wined3d_shader, shader_list_entry)
    {
        device->shader_backend->shader_destroy(shader);
    }
 
    context = context_acquire(device, NULL, 0);
    device->blitter->ops->blitter_destroy(device->blitter, context);
    device->shader_backend->shader_free_private(device);
    destroy_dummy_textures(device, context);
    destroy_default_samplers(device, context);
    context_release(context);
 
    while (device->context_count)
    {
        if (device->contexts[0]->swapchain)
            swapchain_destroy_contexts(device->contexts[0]->swapchain);
        else
            context_destroy(device, device->contexts[0]);
    }
}

Referenced by wined3d_device_delete_opengl_contexts().

◆ wined3d_device_dispatch_compute()

void CDECL wined3d_device_dispatch_compute	(	struct wined3d_device *	device,
		unsigned int	group_count_x,
		unsigned int	group_count_y,
		unsigned int	group_count_z
	)

Definition at line 3700 of file device.c.

{
    TRACE("device %p, group_count_x %u, group_count_y %u, group_count_z %u.\n",
            device, group_count_x, group_count_y, group_count_z);
 
    wined3d_cs_emit_dispatch(device->cs, group_count_x, group_count_y, group_count_z);
}

◆ wined3d_device_dispatch_compute_indirect()

void CDECL wined3d_device_dispatch_compute_indirect	(	struct wined3d_device *	device,
		struct wined3d_buffer *	buffer,
		unsigned int	offset
	)

Definition at line 3709 of file device.c.

{
    TRACE("device %p, buffer %p, offset %u.\n", device, buffer, offset);
 
    wined3d_cs_emit_dispatch_indirect(device->cs, buffer, offset);
}

◆ wined3d_device_draw_indexed_primitive()

HRESULT CDECL wined3d_device_draw_indexed_primitive	(	struct wined3d_device *	device,
		UINT	start_idx,
		UINT	index_count
	)

Definition at line 3769 of file device.c.

{
    TRACE("device %p, start_idx %u, index_count %u.\n", device, start_idx, index_count);
 
    if (!device->state.index_buffer)
    {
        /* D3D9 returns D3DERR_INVALIDCALL when DrawIndexedPrimitive is called
         * without an index buffer set. (The first time at least...)
         * D3D8 simply dies, but I doubt it can do much harm to return
         * D3DERR_INVALIDCALL there as well. */
        WARN("Called without a valid index buffer set, returning WINED3DERR_INVALIDCALL.\n");
        return WINED3DERR_INVALIDCALL;
    }
 
    wined3d_cs_emit_draw(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
            device->state.base_vertex_index, start_idx, index_count, 0, 0, TRUE);
 
    return WINED3D_OK;
}

Referenced by d3d8_device_DrawIndexedPrimitive(), d3d8_device_DrawIndexedPrimitiveUP(), d3d9_device_DrawIndexedPrimitive(), d3d9_device_DrawIndexedPrimitiveUP(), d3d_device7_DrawIndexedPrimitive(), d3d_device7_DrawIndexedPrimitiveStrided(), and d3d_device7_DrawIndexedPrimitiveVB().

◆ wined3d_device_draw_indexed_primitive_instanced()

void CDECL wined3d_device_draw_indexed_primitive_instanced	(	struct wined3d_device *	device,
		UINT	start_idx,
		UINT	index_count,
		UINT	start_instance,
		UINT	instance_count
	)

Definition at line 3789 of file device.c.

{
    TRACE("device %p, start_idx %u, index_count %u, start_instance %u, instance_count %u.\n",
            device, start_idx, index_count, start_instance, instance_count);
 
    wined3d_cs_emit_draw(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
            device->state.base_vertex_index, start_idx, index_count, start_instance, instance_count, TRUE);
}

◆ wined3d_device_draw_indexed_primitive_instanced_indirect()

void CDECL wined3d_device_draw_indexed_primitive_instanced_indirect	(	struct wined3d_device *	device,
		struct wined3d_buffer *	buffer,
		unsigned int	offset
	)

Definition at line 3799 of file device.c.

{
    TRACE("device %p, buffer %p, offset %u.\n", device, buffer, offset);
 
    wined3d_cs_emit_draw_indirect(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
            buffer, offset, TRUE);
}

◆ wined3d_device_draw_primitive()

HRESULT CDECL wined3d_device_draw_primitive	(	struct wined3d_device *	device,
		UINT	start_vertex,
		UINT	vertex_count
	)

Definition at line 3740 of file device.c.

{
    TRACE("device %p, start_vertex %u, vertex_count %u.\n", device, start_vertex, vertex_count);
 
    wined3d_cs_emit_draw(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
            0, start_vertex, vertex_count, 0, 0, FALSE);
 
    return WINED3D_OK;
}

Referenced by d3d8_device_DrawPrimitive(), d3d8_device_DrawPrimitiveUP(), d3d9_device_DrawPrimitive(), d3d9_device_DrawPrimitiveUP(), d3d_device7_DrawPrimitive(), d3d_device7_DrawPrimitiveStrided(), and d3d_device7_DrawPrimitiveVB().

◆ wined3d_device_draw_primitive_instanced()

void CDECL wined3d_device_draw_primitive_instanced	(	struct wined3d_device *	device,
		UINT	start_vertex,
		UINT	vertex_count,
		UINT	start_instance,
		UINT	instance_count
	)

Definition at line 3750 of file device.c.

{
    TRACE("device %p, start_vertex %u, vertex_count %u, start_instance %u, instance_count %u.\n",
            device, start_vertex, vertex_count, start_instance, instance_count);
 
    wined3d_cs_emit_draw(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
            0, start_vertex, vertex_count, start_instance, instance_count, FALSE);
}

◆ wined3d_device_draw_primitive_instanced_indirect()

void CDECL wined3d_device_draw_primitive_instanced_indirect	(	struct wined3d_device *	device,
		struct wined3d_buffer *	buffer,
		unsigned int	offset
	)

Definition at line 3760 of file device.c.

{
    TRACE("device %p, buffer %p, offset %u.\n", device, buffer, offset);
 
    wined3d_cs_emit_draw_indirect(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
            buffer, offset, FALSE);
}

◆ wined3d_device_end_scene()

HRESULT CDECL wined3d_device_end_scene ( struct wined3d_device * device )

Definition at line 3617 of file device.c.

{
    TRACE("device %p.\n", device);
 
    if (!device->inScene)
    {
        WARN("Not in scene, returning WINED3DERR_INVALIDCALL.\n");
        return WINED3DERR_INVALIDCALL;
    }
 
    wined3d_cs_emit_flush(device->cs);
 
    device->inScene = FALSE;
    return WINED3D_OK;
}

Referenced by d3d8_device_EndScene(), d3d9_device_EndScene(), and d3d_device7_EndScene().

◆ wined3d_device_end_stateblock()

HRESULT CDECL wined3d_device_end_stateblock	(	struct wined3d_device *	device,
		struct wined3d_stateblock **	stateblock
	)

Definition at line 3577 of file device.c.

{
    struct wined3d_stateblock *object = device->recording;
 
    TRACE("device %p, stateblock %p.\n", device, stateblock);
 
    if (!device->recording)
    {
        WARN("Not recording.\n");
        *stateblock = NULL;
        return WINED3DERR_INVALIDCALL;
    }
 
    stateblock_init_contained_states(object);
 
    *stateblock = object;
    device->recording = NULL;
    device->update_state = &device->state;
 
    TRACE("Returning stateblock %p.\n", *stateblock);
 
    return WINED3D_OK;
}

Referenced by d3d8_device_EndStateBlock(), d3d9_device_EndStateBlock(), and d3d_device7_EndStateBlock().

◆ wined3d_device_evict_managed_resources()

void CDECL wined3d_device_evict_managed_resources ( struct wined3d_device * device )

Definition at line 4753 of file device.c.

{
    struct wined3d_resource *resource, *cursor;
 
    TRACE("device %p.\n", device);
 
    LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
    {
        TRACE("Checking resource %p for eviction.\n", resource);
 
        if (wined3d_resource_access_is_managed(resource->access) && !resource->map_count)
        {
            TRACE("Evicting %p.\n", resource);
            wined3d_cs_emit_unload_resource(device->cs, resource);
        }
    }
}

Referenced by d3d7_EvictManagedTextures(), d3d8_device_ResourceManagerDiscardBytes(), and d3d9_device_EvictManagedResources().

◆ wined3d_device_get_available_texture_mem()

UINT CDECL wined3d_device_get_available_texture_mem ( const struct wined3d_device * device )

Definition at line 1298 of file device.c.

{
    /* const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; */
 
    TRACE("device %p.\n", device);
 
    /* We can not acquire the context unless there is a swapchain. */
    /*
    if (device->swapchains && gl_info->supported[NVX_GPU_MEMORY_INFO] &&
            !wined3d_settings.emulated_textureram)
    {
        GLint vram_free_kb;
        UINT64 vram_free;
 
        struct wined3d_context *context = context_acquire(device, NULL, 0);
        gl_info->gl_ops.gl.p_glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &vram_free_kb);
        vram_free = (UINT64)vram_free_kb * 1024;
        context_release(context);
 
        TRACE("Total 0x%s bytes. emulation 0x%s left, driver 0x%s left.\n",
                wine_dbgstr_longlong(device->adapter->vram_bytes),
                wine_dbgstr_longlong(device->adapter->vram_bytes - device->adapter->vram_bytes_used),
                wine_dbgstr_longlong(vram_free));
 
        vram_free = min(vram_free, device->adapter->vram_bytes - device->adapter->vram_bytes_used);
        return min(UINT_MAX, vram_free);
    }
    */
 
    TRACE("Emulating 0x%s bytes. 0x%s used, returning 0x%s left.\n",
            wine_dbgstr_longlong(device->adapter->vram_bytes),
            wine_dbgstr_longlong(device->adapter->vram_bytes_used),
            wine_dbgstr_longlong(device->adapter->vram_bytes - device->adapter->vram_bytes_used));
 
    return min(UINT_MAX, device->adapter->vram_bytes - device->adapter->vram_bytes_used);
}

Referenced by d3d8_device_GetAvailableTextureMem(), d3d9_device_GetAvailableTextureMem(), ddraw7_GetAvailableVidMem(), and resource_init().

◆ wined3d_device_get_base_vertex_index()

INT CDECL wined3d_device_get_base_vertex_index ( const struct wined3d_device * device )

Definition at line 1924 of file device.c.

{
    TRACE("device %p.\n", device);
 
    return device->state.base_vertex_index;
}

Referenced by d3d8_device_GetIndices().

◆ wined3d_device_get_blend_state()

struct wined3d_blend_state *CDECL wined3d_device_get_blend_state ( const struct wined3d_device * device )

Definition at line 1994 of file device.c.

{
    TRACE("device %p.\n", device);
 
    return device->state.blend_state;
}

◆ wined3d_device_get_clip_plane()

HRESULT CDECL wined3d_device_get_clip_plane	(	const struct wined3d_device *	device,
		UINT	plane_idx,
		struct wined3d_vec4 *	plane
	)

Definition at line 1811 of file device.c.

{
    TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
 
    if (plane_idx >= device->adapter->gl_info.limits.user_clip_distances)
    {
        TRACE("Application has requested clipplane this device doesn't support.\n");
        return WINED3DERR_INVALIDCALL;
    }
 
    *plane = device->state.clip_planes[plane_idx];
 
    return WINED3D_OK;
}

Referenced by d3d8_device_GetClipPlane(), d3d9_device_GetClipPlane(), and d3d_device7_GetClipPlane().

◆ wined3d_device_get_clip_status()

HRESULT CDECL wined3d_device_get_clip_status	(	const struct wined3d_device *	device,
		struct wined3d_clip_status *	clip_status
	)

Definition at line 1838 of file device.c.

{
    FIXME("device %p, clip_status %p stub!\n", device, clip_status);
 
    if (!clip_status)
        return WINED3DERR_INVALIDCALL;
 
    return WINED3D_OK;
}

Referenced by d3d8_device_GetClipStatus(), and d3d9_device_GetClipStatus().

◆ wined3d_device_get_compute_shader()

struct wined3d_shader *CDECL wined3d_device_get_compute_shader ( const struct wined3d_device * device )

Definition at line 2947 of file device.c.

{
    TRACE("device %p.\n", device);
 
    return device->state.shader[WINED3D_SHADER_TYPE_COMPUTE];
}

◆ wined3d_device_get_constant_buffer()

static struct wined3d_buffer * wined3d_device_get_constant_buffer	(	const struct wined3d_device *	device,
		enum wined3d_shader_type	shader_type,
		unsigned int	idx
	)

static

Definition at line 2245 of file device.c.

{
    if (idx >= MAX_CONSTANT_BUFFERS)
    {
        WARN("Invalid constant buffer index %u.\n", idx);
        return NULL;
    }
 
    return device->state.cb[shader_type][idx];
}

Referenced by wined3d_device_get_cs_cb(), wined3d_device_get_ds_cb(), wined3d_device_get_gs_cb(), wined3d_device_get_hs_cb(), wined3d_device_get_ps_cb(), and wined3d_device_get_vs_cb().

◆ wined3d_device_get_creation_parameters()

void CDECL wined3d_device_get_creation_parameters	(	const struct wined3d_device *	device,
		struct wined3d_device_creation_parameters *	parameters
	)

Definition at line 5042 of file device.c.

{
    TRACE("device %p, parameters %p.\n", device, parameters);
 
    *parameters = device->create_parms;
}

Referenced by d3d8_device_GetCreationParameters(), and d3d9_device_GetCreationParameters().

◆ wined3d_device_get_cs_cb()

struct wined3d_buffer *CDECL wined3d_device_get_cs_cb	(	const struct wined3d_device *	device,
		unsigned int	idx
	)

Definition at line 2961 of file device.c.

{
    TRACE("device %p, idx %u.\n", device, idx);
 
    return wined3d_device_get_constant_buffer(device, WINED3D_SHADER_TYPE_COMPUTE, idx);
}

◆ wined3d_device_get_cs_resource_view()

struct wined3d_shader_resource_view *CDECL wined3d_device_get_cs_resource_view	(	const struct wined3d_device *	device,
		unsigned int	idx
	)

Definition at line 2976 of file device.c.

{
    TRACE("device %p, idx %u.\n", device, idx);
 
    return wined3d_device_get_shader_resource_view(device, WINED3D_SHADER_TYPE_COMPUTE, idx);
}

◆ wined3d_device_get_cs_sampler()

struct wined3d_sampler *CDECL wined3d_device_get_cs_sampler ( const struct wined3d_device *

Macros

Functions

Variables

Macro Definition Documentation

◆ copy_and_next

Function Documentation

◆ create_default_samplers()

◆ create_dummy_textures()

◆ d3d_primitive_type_from_gl()

◆ destroy_default_samplers()

◆ destroy_dummy_textures()

◆ device_clear_render_targets()

◆ device_context_add()

◆ device_context_remove()

◆ device_free_sampler()

◆ device_init()

◆ device_init_swapchain_state()

◆ device_invalidate_state()

◆ device_leftover_sampler()

◆ device_load_logo()

◆ device_process_message()

◆ device_resource_add()

◆ device_resource_released()

◆ device_resource_remove()

◆ fullscreen_exstyle()

◆ fullscreen_style()

◆ gl_primitive_type_from_d3d()

◆ is_full_clear()

◆ process_vertices_strided()

◆ resolve_depth_buffer()

◆ WINE_DECLARE_DEBUG_CHANNEL()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

◆ wined3d_device_acquire_focus_window()

◆ wined3d_device_begin_scene()

◆ wined3d_device_begin_stateblock()

◆ wined3d_device_clear()

◆ wined3d_device_clear_rendertarget_view()

◆ wined3d_device_clear_unordered_access_view_uint()

◆ wined3d_device_copy_resource()

◆ wined3d_device_copy_sub_resource_region()

◆ wined3d_device_copy_uav_counter()

◆ wined3d_device_create_cursor_texture()

◆ wined3d_device_create_primary_opengl_context()

◆ wined3d_device_create_primary_opengl_context_cs()

◆ wined3d_device_decref()

◆ wined3d_device_delete_opengl_contexts()

◆ wined3d_device_delete_opengl_contexts_cs()

◆ wined3d_device_dispatch_compute()

◆ wined3d_device_dispatch_compute_indirect()

◆ wined3d_device_draw_indexed_primitive()

◆ wined3d_device_draw_indexed_primitive_instanced()

◆ wined3d_device_draw_indexed_primitive_instanced_indirect()

◆ wined3d_device_draw_primitive()

◆ wined3d_device_draw_primitive_instanced()

◆ wined3d_device_draw_primitive_instanced_indirect()

◆ wined3d_device_end_scene()

◆ wined3d_device_end_stateblock()

◆ wined3d_device_evict_managed_resources()

◆ wined3d_device_get_available_texture_mem()

◆ wined3d_device_get_base_vertex_index()

◆ wined3d_device_get_blend_state()

◆ wined3d_device_get_clip_plane()

◆ wined3d_device_get_clip_status()

◆ wined3d_device_get_compute_shader()

◆ wined3d_device_get_constant_buffer()

◆ wined3d_device_get_creation_parameters()

◆ wined3d_device_get_cs_cb()

◆ wined3d_device_get_cs_resource_view()

◆ wined3d_device_get_cs_sampler()