#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)

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_viewports (struct wined3d_device device, unsigned int viewport_count, const struct wined3d_viewport viewports)

void CDECL	wined3d_device_get_viewports (const struct wined3d_device device, unsigned int viewport_count, struct wined3d_viewport *viewports)

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_rects (struct wined3d_device device, unsigned int rect_count, const RECT rects)

void CDECL	wined3d_device_get_scissor_rects (const struct wined3d_device device, unsigned int rect_count, RECT *rects)

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)

void CDECL	wined3d_device_set_max_frame_latency (struct wined3d_device *device, unsigned int latency)

unsigned int CDECL	wined3d_device_get_max_frame_latency (const struct wined3d_device *device)

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

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

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 3126 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 784 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 609 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()

enum wined3d_primitive_type d3d_primitive_type_from_gl ( GLenum primitive_type )

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 draw_primitive(), find_gs_compile_args(), and 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 832 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 743 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_2d_array);
         gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_1d_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_rendertarget_view *dsv = fb->depth_stencil;
     const struct wined3d_state *state = &device->cs->state;
     struct wined3d_texture *depth_stencil = NULL;
     const struct wined3d_gl_info *gl_info;
     struct wined3d_texture *target = NULL;
     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 (rtv && rtv->resource->type != WINED3D_RTYPE_BUFFER)
     {
         target = texture_from_resource(rtv->resource);
         context = context_acquire(device, target, rtv->sub_resource_idx);
     }
     else
     {
         context = context_acquire(device, NULL, 0);
     }
 
     if (dsv && dsv->resource->type != WINED3D_RTYPE_BUFFER)
         depth_stencil = texture_from_resource(dsv->resource);
 
     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->level_count;
 
         render_offscreen = TRUE;
         drawable_width = wined3d_texture_get_level_pow2_width(depth_stencil, ds_level);
         drawable_height = wined3d_texture_get_level_pow2_height(depth_stencil, 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);
         }
         gl_info->gl_ops.gl.p_glClear(clear_mask);
     }
     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);
             }
             gl_info->gl_ops.gl.p_glClear(clear_mask);
         }
     }
     context->scissor_rect_count = WINED3D_MAX_VIEWPORTS;
     checkGLcall("clear");
 
     if (flags & WINED3DCLEAR_TARGET && target->swapchain && target->swapchain->front_buffer == target)
         gl_info->gl_ops.gl.p_glFlush();
 
     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 1193 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 5223 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;
 
     device->max_frame_latency = 3;
 
     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 966 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 5293 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 470 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 552 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 5322 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 5115 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 5133 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)
             {
                 if (&device->state.textures[i]->resource == resource)
                 {
                     ERR("Texture resource %p is still in use, stage %u.\n", resource, i);
                     device->state.textures[i] = NULL;
                 }
 
                 if (device->recording && &device->update_state->textures[i]->resource == resource)
                 {
                     ERR("Texture resource %p is still in use by recording stateblock %p, stage %u.\n",
                             resource, device->recording, i);
                     device->update_state->textures[i] = NULL;
                 }
             }
             break;
 
         case WINED3D_RTYPE_BUFFER:
             for (i = 0; i < MAX_STREAMS; ++i)
             {
                 if (&device->state.streams[i].buffer->resource == resource)
                 {
                     ERR("Buffer resource %p is still in use, stream %u.\n", resource, i);
                     device->state.streams[i].buffer = NULL;
                 }
 
                 if (device->recording && &device->update_state->streams[i].buffer->resource == resource)
                 {
                     ERR("Buffer resource %p is still in use by stateblock %p, stream %u.\n",
                             resource, device->recording, i);
                     device->update_state->streams[i].buffer = NULL;
                 }
             }
 
             if (&device->state.index_buffer->resource == resource)
             {
                 ERR("Buffer resource %p is still in use as index buffer.\n", resource);
                 device->state.index_buffer =  NULL;
             }
 
             if (device->recording && &device->update_state->index_buffer->resource == resource)
             {
                 ERR("Buffer resource %p is still in use by stateblock %p as index buffer.\n",
                         resource, 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 5124 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 849 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 840 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 3127 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_viewports(device, NULL, &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 1978 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 942 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 3659 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 3612 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 3690 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 4426 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_1D && 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 4473 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 4097 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,
		unsigned int	flags
	)

Definition at line 4175 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, flags %#x.\n",
             device, dst_resource, dst_sub_resource_idx, dst_x, dst_y, dst_z,
             src_resource, src_sub_resource_idx, debug_box(src_box), flags);
 
     if (flags)
         FIXME("Ignoring flags %#x.\n", flags);
 
     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
     {
         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 (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;
         }
 
         if (!src_box)
         {
             unsigned int src_w, src_h, src_d, dst_w, dst_h, dst_d, dst_level;
 
             src_w = wined3d_texture_get_level_width(src_texture, src_level);
             src_h = wined3d_texture_get_level_height(src_texture, src_level);
             src_d = wined3d_texture_get_level_depth(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;
             dst_d = wined3d_texture_get_level_depth(dst_texture, dst_level) - dst_z;
 
             wined3d_box_set(&b, 0, 0, min(src_w, dst_w), min(src_h, dst_h), 0, min(src_d, dst_d));
             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), dst_z, dst_z + (src_box->back - src_box->front));
         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;
         }
     }
 
     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 4082 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 4579 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 1056 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 1021 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);
     if (!wined3d_glsl_blitter_create(&device->blitter, device))
         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</

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