ReactOS  0.4.14-dev-593-g1793dcc
device.c File Reference
#include "config.h"
#include "wine/port.h"
#include <stdio.h>
#include "wined3d_private.h"
Include dependency graph for device.c:

Go to the source code of this file.

Macros

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

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (d3d)
 
 WINE_DECLARE_DEBUG_CHANNEL (winediag)
 
GLenum gl_primitive_type_from_d3d (enum wined3d_primitive_type primitive_type)
 
static enum wined3d_primitive_type d3d_primitive_type_from_gl (GLenum primitive_type)
 
BOOL device_context_add (struct wined3d_device *device, struct wined3d_context *context)
 
void device_context_remove (struct wined3d_device *device, struct wined3d_context *context)
 
static BOOL is_full_clear (const struct wined3d_texture *texture, unsigned int sub_resource_idx, const RECT *draw_rect, const RECT *clear_rect)
 
void device_clear_render_targets (struct wined3d_device *device, UINT rt_count, const struct wined3d_fb_state *fb, UINT rect_count, const RECT *clear_rect, const RECT *draw_rect, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
 
ULONG CDECL wined3d_device_incref (struct wined3d_device *device)
 
static void device_leftover_sampler (struct wine_rb_entry *entry, void *context)
 
ULONG CDECL wined3d_device_decref (struct wined3d_device *device)
 
UINT CDECL wined3d_device_get_swapchain_count (const struct wined3d_device *device)
 
struct wined3d_swapchain *CDECL wined3d_device_get_swapchain (const struct wined3d_device *device, UINT swapchain_idx)
 
static void device_load_logo (struct wined3d_device *device, const char *filename)
 
static void create_dummy_textures (struct wined3d_device *device, struct wined3d_context *context)
 
static void destroy_dummy_textures (struct wined3d_device *device, struct wined3d_context *context)
 
static void create_default_samplers (struct wined3d_device *device, struct wined3d_context *context)
 
static void destroy_default_samplers (struct wined3d_device *device, struct wined3d_context *context)
 
static LONG fullscreen_style (LONG style)
 
static LONG fullscreen_exstyle (LONG exstyle)
 
void CDECL wined3d_device_setup_fullscreen_window (struct wined3d_device *device, HWND window, UINT w, UINT h)
 
void CDECL wined3d_device_restore_fullscreen_window (struct wined3d_device *device, HWND window, const RECT *window_rect)
 
HRESULT CDECL wined3d_device_acquire_focus_window (struct wined3d_device *device, HWND window)
 
void CDECL wined3d_device_release_focus_window (struct wined3d_device *device)
 
static void device_init_swapchain_state (struct wined3d_device *device, struct wined3d_swapchain *swapchain)
 
static void wined3d_device_delete_opengl_contexts_cs (void *object)
 
static void wined3d_device_delete_opengl_contexts (struct wined3d_device *device)
 
static void wined3d_device_create_primary_opengl_context_cs (void *object)
 
static HRESULT wined3d_device_create_primary_opengl_context (struct wined3d_device *device)
 
HRESULT CDECL wined3d_device_init_3d (struct wined3d_device *device, struct wined3d_swapchain_desc *swapchain_desc)
 
HRESULT CDECL wined3d_device_init_gdi (struct wined3d_device *device, struct wined3d_swapchain_desc *swapchain_desc)
 
static void device_free_sampler (struct wine_rb_entry *entry, void *context)
 
HRESULT CDECL wined3d_device_uninit_3d (struct wined3d_device *device)
 
HRESULT CDECL wined3d_device_uninit_gdi (struct wined3d_device *device)
 
void CDECL wined3d_device_set_multithreaded (struct wined3d_device *device)
 
UINT CDECL wined3d_device_get_available_texture_mem (const struct wined3d_device *device)
 
void CDECL wined3d_device_set_stream_output (struct wined3d_device *device, UINT idx, struct wined3d_buffer *buffer, UINT offset)
 
struct wined3d_buffer *CDECL wined3d_device_get_stream_output (struct wined3d_device *device, UINT idx, UINT *offset)
 
HRESULT CDECL wined3d_device_set_stream_source (struct wined3d_device *device, UINT stream_idx, struct wined3d_buffer *buffer, UINT offset, UINT stride)
 
HRESULT CDECL wined3d_device_get_stream_source (const struct wined3d_device *device, UINT stream_idx, struct wined3d_buffer **buffer, UINT *offset, UINT *stride)
 
HRESULT CDECL wined3d_device_set_stream_source_freq (struct wined3d_device *device, UINT stream_idx, UINT divider)
 
HRESULT CDECL wined3d_device_get_stream_source_freq (const struct wined3d_device *device, UINT stream_idx, UINT *divider)
 
void CDECL wined3d_device_set_transform (struct wined3d_device *device, enum wined3d_transform_state d3dts, const struct wined3d_matrix *matrix)
 
void CDECL wined3d_device_get_transform (const struct wined3d_device *device, enum wined3d_transform_state state, struct wined3d_matrix *matrix)
 
void CDECL wined3d_device_multiply_transform (struct wined3d_device *device, enum wined3d_transform_state state, const struct wined3d_matrix *matrix)
 
HRESULT CDECL wined3d_device_set_light (struct wined3d_device *device, UINT light_idx, const struct wined3d_light *light)
 
HRESULT CDECL wined3d_device_get_light (const struct wined3d_device *device, UINT light_idx, struct wined3d_light *light)
 
HRESULT CDECL wined3d_device_set_light_enable (struct wined3d_device *device, UINT light_idx, BOOL enable)
 
HRESULT CDECL wined3d_device_get_light_enable (const struct wined3d_device *device, UINT light_idx, BOOL *enable)
 
HRESULT CDECL wined3d_device_set_clip_plane (struct wined3d_device *device, UINT plane_idx, const struct wined3d_vec4 *plane)
 
HRESULT CDECL wined3d_device_get_clip_plane (const struct wined3d_device *device, UINT plane_idx, struct wined3d_vec4 *plane)
 
HRESULT CDECL wined3d_device_set_clip_status (struct wined3d_device *device, const struct wined3d_clip_status *clip_status)
 
HRESULT CDECL wined3d_device_get_clip_status (const struct wined3d_device *device, struct wined3d_clip_status *clip_status)
 
void CDECL wined3d_device_set_material (struct wined3d_device *device, const struct wined3d_material *material)
 
void CDECL wined3d_device_get_material (const struct wined3d_device *device, struct wined3d_material *material)
 
void CDECL wined3d_device_set_index_buffer (struct wined3d_device *device, struct wined3d_buffer *buffer, enum wined3d_format_id format_id, unsigned int offset)
 
struct wined3d_buffer *CDECL wined3d_device_get_index_buffer (const struct wined3d_device *device, enum wined3d_format_id *format, unsigned int *offset)
 
void CDECL wined3d_device_set_base_vertex_index (struct wined3d_device *device, INT base_index)
 
INT CDECL wined3d_device_get_base_vertex_index (const struct wined3d_device *device)
 
void CDECL wined3d_device_set_viewport (struct wined3d_device *device, const struct wined3d_viewport *viewport)
 
void CDECL wined3d_device_get_viewport (const struct wined3d_device *device, struct wined3d_viewport *viewport)
 
static void resolve_depth_buffer (struct wined3d_device *device)
 
void CDECL wined3d_device_set_blend_state (struct wined3d_device *device, struct wined3d_blend_state *blend_state)
 
struct wined3d_blend_state *CDECL wined3d_device_get_blend_state (const struct wined3d_device *device)
 
void CDECL wined3d_device_set_rasterizer_state (struct wined3d_device *device, struct wined3d_rasterizer_state *rasterizer_state)
 
struct wined3d_rasterizer_state *CDECL wined3d_device_get_rasterizer_state (struct wined3d_device *device)
 
void CDECL wined3d_device_set_render_state (struct wined3d_device *device, enum wined3d_render_state state, DWORD value)
 
DWORD CDECL wined3d_device_get_render_state (const struct wined3d_device *device, enum wined3d_render_state state)
 
void CDECL wined3d_device_set_sampler_state (struct wined3d_device *device, UINT sampler_idx, enum wined3d_sampler_state state, DWORD value)
 
DWORD CDECL wined3d_device_get_sampler_state (const struct wined3d_device *device, UINT sampler_idx, enum wined3d_sampler_state state)
 
void CDECL wined3d_device_set_scissor_rect (struct wined3d_device *device, const RECT *rect)
 
void CDECL wined3d_device_get_scissor_rect (const struct wined3d_device *device, RECT *rect)
 
void CDECL wined3d_device_set_vertex_declaration (struct wined3d_device *device, struct wined3d_vertex_declaration *declaration)
 
struct wined3d_vertex_declaration *CDECL wined3d_device_get_vertex_declaration (const struct wined3d_device *device)
 
void CDECL wined3d_device_set_vertex_shader (struct wined3d_device *device, struct wined3d_shader *shader)
 
struct wined3d_shader *CDECL wined3d_device_get_vertex_shader (const struct wined3d_device *device)
 
static void wined3d_device_set_constant_buffer (struct wined3d_device *device, enum wined3d_shader_type type, UINT idx, struct wined3d_buffer *buffer)
 
void CDECL wined3d_device_set_vs_cb (struct wined3d_device *device, UINT idx, struct wined3d_buffer *buffer)
 
static struct wined3d_bufferwined3d_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_viewwined3d_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_samplerwined3d_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_viewwined3d_device_get_pipeline_unordered_access_view (const struct wined3d_device *device, enum wined3d_pipeline pipeline, unsigned int idx)
 
void CDECL wined3d_device_set_cs_uav (struct wined3d_device *device, unsigned int idx, struct wined3d_unordered_access_view *uav, unsigned int initial_count)
 
struct wined3d_unordered_access_view *CDECL wined3d_device_get_cs_uav (const struct wined3d_device *device, unsigned int idx)
 
void CDECL wined3d_device_set_unordered_access_view (struct wined3d_device *device, unsigned int idx, struct wined3d_unordered_access_view *uav, unsigned int initial_count)
 
struct wined3d_unordered_access_view *CDECL wined3d_device_get_unordered_access_view (const struct wined3d_device *device, unsigned int idx)
 
static HRESULT process_vertices_strided (const struct wined3d_device *device, DWORD dwDestIndex, DWORD dwCount, const struct wined3d_stream_info *stream_info, struct wined3d_buffer *dest, DWORD flags, DWORD DestFVF)
 
HRESULT CDECL wined3d_device_process_vertices (struct wined3d_device *device, UINT src_start_idx, UINT dst_idx, UINT vertex_count, struct wined3d_buffer *dst_buffer, const struct wined3d_vertex_declaration *declaration, DWORD flags, DWORD dst_fvf)
 
void CDECL wined3d_device_set_texture_stage_state (struct wined3d_device *device, UINT stage, enum wined3d_texture_stage_state state, DWORD value)
 
DWORD CDECL wined3d_device_get_texture_stage_state (const struct wined3d_device *device, UINT stage, enum wined3d_texture_stage_state state)
 
HRESULT CDECL wined3d_device_set_texture (struct wined3d_device *device, UINT stage, struct wined3d_texture *texture)
 
struct wined3d_texture *CDECL wined3d_device_get_texture (const struct wined3d_device *device, UINT stage)
 
HRESULT CDECL wined3d_device_get_device_caps (const struct wined3d_device *device, WINED3DCAPS *caps)
 
HRESULT CDECL wined3d_device_get_display_mode (const struct wined3d_device *device, UINT swapchain_idx, struct wined3d_display_mode *mode, enum wined3d_display_rotation *rotation)
 
HRESULT CDECL wined3d_device_begin_stateblock (struct wined3d_device *device)
 
HRESULT CDECL wined3d_device_end_stateblock (struct wined3d_device *device, struct wined3d_stateblock **stateblock)
 
HRESULT CDECL wined3d_device_begin_scene (struct wined3d_device *device)
 
HRESULT CDECL wined3d_device_end_scene (struct wined3d_device *device)
 
HRESULT CDECL wined3d_device_clear (struct wined3d_device *device, DWORD rect_count, const RECT *rects, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
 
void CDECL wined3d_device_set_predication (struct wined3d_device *device, struct wined3d_query *predicate, BOOL value)
 
struct wined3d_query *CDECL wined3d_device_get_predication (struct wined3d_device *device, BOOL *value)
 
void CDECL wined3d_device_dispatch_compute (struct wined3d_device *device, unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z)
 
void CDECL wined3d_device_dispatch_compute_indirect (struct wined3d_device *device, struct wined3d_buffer *buffer, unsigned int offset)
 
void CDECL wined3d_device_set_primitive_type (struct wined3d_device *device, enum wined3d_primitive_type primitive_type, unsigned int patch_vertex_count)
 
void CDECL wined3d_device_get_primitive_type (const struct wined3d_device *device, enum wined3d_primitive_type *primitive_type, unsigned int *patch_vertex_count)
 
HRESULT CDECL wined3d_device_draw_primitive (struct wined3d_device *device, UINT start_vertex, UINT vertex_count)
 
void CDECL wined3d_device_draw_primitive_instanced (struct wined3d_device *device, UINT start_vertex, UINT vertex_count, UINT start_instance, UINT instance_count)
 
void CDECL wined3d_device_draw_primitive_instanced_indirect (struct wined3d_device *device, struct wined3d_buffer *buffer, unsigned int offset)
 
HRESULT CDECL wined3d_device_draw_indexed_primitive (struct wined3d_device *device, UINT start_idx, UINT index_count)
 
void CDECL wined3d_device_draw_indexed_primitive_instanced (struct wined3d_device *device, UINT start_idx, UINT index_count, UINT start_instance, UINT instance_count)
 
void CDECL wined3d_device_draw_indexed_primitive_instanced_indirect (struct wined3d_device *device, struct wined3d_buffer *buffer, unsigned int offset)
 
HRESULT CDECL wined3d_device_update_texture (struct wined3d_device *device, struct wined3d_texture *src_texture, struct wined3d_texture *dst_texture)
 
HRESULT CDECL wined3d_device_validate_device (const struct wined3d_device *device, DWORD *num_passes)
 
void CDECL wined3d_device_set_software_vertex_processing (struct wined3d_device *device, BOOL software)
 
BOOL CDECL wined3d_device_get_software_vertex_processing (const struct wined3d_device *device)
 
HRESULT CDECL wined3d_device_get_raster_status (const struct wined3d_device *device, UINT swapchain_idx, struct wined3d_raster_status *raster_status)
 
HRESULT CDECL wined3d_device_set_npatch_mode (struct wined3d_device *device, float segments)
 
float CDECL wined3d_device_get_npatch_mode (const struct wined3d_device *device)
 
void CDECL wined3d_device_copy_uav_counter (struct wined3d_device *device, struct wined3d_buffer *dst_buffer, unsigned int offset, struct wined3d_unordered_access_view *uav)
 
void CDECL wined3d_device_copy_resource (struct wined3d_device *device, struct wined3d_resource *dst_resource, struct wined3d_resource *src_resource)
 
HRESULT CDECL wined3d_device_copy_sub_resource_region (struct wined3d_device *device, struct wined3d_resource *dst_resource, unsigned int dst_sub_resource_idx, unsigned int dst_x, unsigned int dst_y, unsigned int dst_z, struct wined3d_resource *src_resource, unsigned int src_sub_resource_idx, const struct wined3d_box *src_box)
 
void CDECL wined3d_device_update_sub_resource (struct wined3d_device *device, struct wined3d_resource *resource, unsigned int sub_resource_idx, const struct wined3d_box *box, const void *data, unsigned int row_pitch, unsigned int depth_pitch)
 
void CDECL wined3d_device_resolve_sub_resource (struct wined3d_device *device, struct wined3d_resource *dst_resource, unsigned int dst_sub_resource_idx, struct wined3d_resource *src_resource, unsigned int src_sub_resource_idx, enum wined3d_format_id format_id)
 
HRESULT CDECL wined3d_device_clear_rendertarget_view (struct wined3d_device *device, struct wined3d_rendertarget_view *view, const RECT *rect, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
 
void CDECL wined3d_device_clear_unordered_access_view_uint (struct wined3d_device *device, struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value)
 
struct wined3d_rendertarget_view *CDECL wined3d_device_get_rendertarget_view (const struct wined3d_device *device, unsigned int view_idx)
 
struct wined3d_rendertarget_view *CDECL wined3d_device_get_depth_stencil_view (const struct wined3d_device *device)
 
HRESULT CDECL wined3d_device_set_rendertarget_view (struct wined3d_device *device, unsigned int view_idx, struct wined3d_rendertarget_view *view, BOOL set_viewport)
 
void CDECL wined3d_device_set_depth_stencil_view (struct wined3d_device *device, struct wined3d_rendertarget_view *view)
 
static struct wined3d_texturewined3d_device_create_cursor_texture (struct wined3d_device *device, struct wined3d_texture *cursor_image, unsigned int sub_resource_idx)
 
HRESULT CDECL wined3d_device_set_cursor_properties (struct wined3d_device *device, UINT x_hotspot, UINT y_hotspot, struct wined3d_texture *texture, unsigned int sub_resource_idx)
 
void CDECL wined3d_device_set_cursor_position (struct wined3d_device *device, int x_screen_space, int y_screen_space, DWORD flags)
 
BOOL CDECL wined3d_device_show_cursor (struct wined3d_device *device, BOOL show)
 
void CDECL wined3d_device_evict_managed_resources (struct wined3d_device *device)
 
HRESULT CDECL wined3d_device_reset (struct wined3d_device *device, const struct wined3d_swapchain_desc *swapchain_desc, const struct wined3d_display_mode *mode, wined3d_device_reset_cb callback, BOOL reset_state)
 
HRESULT CDECL wined3d_device_set_dialog_box_mode (struct wined3d_device *device, BOOL enable_dialogs)
 
void CDECL wined3d_device_get_creation_parameters (const struct wined3d_device *device, struct wined3d_device_creation_parameters *parameters)
 
struct wined3d *CDECL wined3d_device_get_wined3d (const struct wined3d_device *device)
 
void CDECL wined3d_device_set_gamma_ramp (const struct wined3d_device *device, UINT swapchain_idx, DWORD flags, const struct wined3d_gamma_ramp *ramp)
 
void CDECL wined3d_device_get_gamma_ramp (const struct wined3d_device *device, UINT swapchain_idx, struct wined3d_gamma_ramp *ramp)
 
void device_resource_add (struct wined3d_device *device, struct wined3d_resource *resource)
 
static void device_resource_remove (struct wined3d_device *device, struct wined3d_resource *resource)
 
void device_resource_released (struct wined3d_device *device, struct wined3d_resource *resource)
 
static int wined3d_sampler_compare (const void *key, const struct wine_rb_entry *entry)
 
HRESULT device_init (struct wined3d_device *device, struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, HWND focus_window, DWORD flags, BYTE surface_alignment, struct wined3d_device_parent *device_parent)
 
void device_invalidate_state (const struct wined3d_device *device, DWORD state)
 
LRESULT device_process_message (struct wined3d_device *device, HWND window, BOOL unicode, UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc)
 

Variables

const struct wined3d_light WINED3D_default_light
 

Macro Definition Documentation

◆ copy_and_next

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

Definition at line 3069 of file device.c.

Function Documentation

◆ create_default_samplers()

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

Definition at line 780 of file device.c.

781 {
782  struct wined3d_sampler_desc desc;
783  HRESULT hr;
784 
785  desc.address_u = WINED3D_TADDRESS_WRAP;
786  desc.address_v = WINED3D_TADDRESS_WRAP;
787  desc.address_w = WINED3D_TADDRESS_WRAP;
788  memset(desc.border_color, 0, sizeof(desc.border_color));
789  desc.mag_filter = WINED3D_TEXF_POINT;
790  desc.min_filter = WINED3D_TEXF_POINT;
791  desc.mip_filter = WINED3D_TEXF_NONE;
792  desc.lod_bias = 0.0f;
793  desc.min_lod = -1000.0f;
794  desc.max_lod = 1000.0f;
795  desc.mip_base_level = 0;
796  desc.max_anisotropy = 1;
797  desc.compare = FALSE;
798  desc.comparison_func = WINED3D_CMP_NEVER;
799  desc.srgb_decode = TRUE;
800 
801  /* In SM4+ shaders there is a separation between resources and samplers. Some shader
802  * instructions allow access to resources without using samplers.
803  * In GLSL, resources are always accessed through sampler or image variables. The default
804  * sampler object is used to emulate the direct resource access when there is no sampler state
805  * to use.
806  */
808  {
809  ERR("Failed to create default sampler, hr %#x.\n", hr);
810  device->default_sampler = NULL;
811  }
812 
813  /* In D3D10+, a NULL sampler maps to the default sampler state. */
814  desc.address_u = WINED3D_TADDRESS_CLAMP;
815  desc.address_v = WINED3D_TADDRESS_CLAMP;
816  desc.address_w = WINED3D_TADDRESS_CLAMP;
817  desc.mag_filter = WINED3D_TEXF_LINEAR;
818  desc.min_filter = WINED3D_TEXF_LINEAR;
819  desc.mip_filter = WINED3D_TEXF_LINEAR;
821  {
822  ERR("Failed to create null sampler, hr %#x.\n", hr);
823  device->null_sampler = NULL;
824  }
825 }
#define TRUE
Definition: types.h:120
HRESULT hr
Definition: shlfolder.c:183
HRESULT CDECL wined3d_sampler_create(struct wined3d_device *device, const struct wined3d_sampler_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_sampler **sampler)
Definition: sampler.c:130
Definition: devices.h:37
static const WCHAR desc[]
Definition: protectdata.c:36
smooth NULL
Definition: ftsmooth.c:416
LONG HRESULT
Definition: typedefs.h:77
#define ERR(fmt,...)
Definition: debug.h:109
const struct wined3d_parent_ops wined3d_null_parent_ops
Definition: directx.c:6815
#define memset(x, y, z)
Definition: compat.h:39

Referenced by wined3d_device_create_primary_opengl_context_cs().

◆ create_dummy_textures()

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

Definition at line 604 of file device.c.

605 {
606  const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
607  const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
608  struct wined3d_dummy_textures *textures = &device->dummy_textures;
609  unsigned int i;
610  DWORD color;
611 
613  color = 0x000000ff;
614  else
615  color = 0x00000000;
616 
617  /* Under DirectX you can sample even if no texture is bound, whereas
618  * OpenGL will only allow that when a valid texture is bound.
619  * We emulate this by creating dummy textures and binding them
620  * to each texture stage when the currently set D3D texture is NULL. */
621  context_active_texture(context, gl_info, 0);
622 
623  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_1d);
624  TRACE("Dummy 1D texture given name %u.\n", textures->tex_1d);
625  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D, textures->tex_1d);
626  gl_info->gl_ops.gl.p_glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA8, 1, 0,
628 
629  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_2d);
630  TRACE("Dummy 2D texture given name %u.\n", textures->tex_2d);
631  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, textures->tex_2d);
632  gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0,
634 
635  if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
636  {
637  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_rect);
638  TRACE("Dummy rectangle texture given name %u.\n", textures->tex_rect);
639  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_RECTANGLE_ARB, textures->tex_rect);
640  gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, 1, 1, 0,
642  }
643 
644  if (gl_info->supported[EXT_TEXTURE3D])
645  {
646  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_3d);
647  TRACE("Dummy 3D texture given name %u.\n", textures->tex_3d);
648  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_3D, textures->tex_3d);
651  }
652 
653  if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
654  {
655  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_cube);
656  TRACE("Dummy cube texture given name %u.\n", textures->tex_cube);
657  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP, textures->tex_cube);
659  {
660  gl_info->gl_ops.gl.p_glTexImage2D(i, 0, GL_RGBA8, 1, 1, 0,
662  }
663  }
664 
666  {
667  DWORD cube_array_data[6];
668 
669  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_cube_array);
670  TRACE("Dummy cube array texture given name %u.\n", textures->tex_cube_array);
671  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures->tex_cube_array);
672  for (i = 0; i < ARRAY_SIZE(cube_array_data); ++i)
673  cube_array_data[i] = color;
675  GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, cube_array_data));
676  }
677 
678  if (gl_info->supported[EXT_TEXTURE_ARRAY])
679  {
680 
681  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_1d_array);
682  TRACE("Dummy 1D array texture given name %u.\n", textures->tex_1d_array);
683  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D_ARRAY, textures->tex_1d_array);
684  gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_1D_ARRAY, 0, GL_RGBA8, 1, 1, 0,
686 
687  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_2d_array);
688  TRACE("Dummy 2D array texture given name %u.\n", textures->tex_2d_array);
689  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_ARRAY, textures->tex_2d_array);
692  }
693 
694  if (gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
695  {
696  GLuint buffer;
697 
698  GL_EXTCALL(glGenBuffers(1, &buffer));
699  GL_EXTCALL(glBindBuffer(GL_TEXTURE_BUFFER, buffer));
700  GL_EXTCALL(glBufferData(GL_TEXTURE_BUFFER, sizeof(color), &color, GL_STATIC_DRAW));
701  GL_EXTCALL(glBindBuffer(GL_TEXTURE_BUFFER, 0));
702 
703  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_buffer);
704  TRACE("Dummy buffer texture given name %u.\n", textures->tex_buffer);
705  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_BUFFER, textures->tex_buffer);
707  GL_EXTCALL(glDeleteBuffers(1, &buffer));
708  }
709 
710  if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
711  {
712  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_2d_ms);
713  TRACE("Dummy multisample texture given name %u.\n", textures->tex_2d_ms);
714  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textures->tex_2d_ms);
715  GL_EXTCALL(glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, GL_RGBA8, 1, 1, GL_TRUE));
716 
717  gl_info->gl_ops.gl.p_glGenTextures(1, &textures->tex_2d_ms_array);
718  TRACE("Dummy multisample array texture given name %u.\n", textures->tex_2d_ms_array);
719  gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, textures->tex_2d_ms_array);
720  GL_EXTCALL(glTexImage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, 1, GL_RGBA8, 1, 1, 1, GL_TRUE));
721 
722  if (gl_info->supported[ARB_CLEAR_TEXTURE])
723  {
724  GL_EXTCALL(glClearTexImage(textures->tex_2d_ms, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color));
725  GL_EXTCALL(glClearTexImage(textures->tex_2d_ms_array, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color));
726  }
727  else
728  {
729  WARN("ARB_clear_texture is currently required to clear dummy multisample textures.\n");
730  }
731  }
732 
733  checkGLcall("create dummy textures");
734 
736 }
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
Definition: gl.h:1795
struct opengl_funcs gl_ops
Definition: http.c:7098
void context_active_texture(struct wined3d_context *context, const struct wined3d_gl_info *gl_info, unsigned int unit)
Definition: context.c:2717
#define GL_TEXTURE_BUFFER
Definition: glext.h:748
#define WARN(fmt,...)
Definition: debug.h:111
GLuint buffer
Definition: glext.h:5915
GLAPI void GLAPIENTRY glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
#define GL_TEXTURE_CUBE_MAP_ARRAY
Definition: glext.h:920
#define GL_TEXTURE_2D_MULTISAMPLE
Definition: glext.h:1939
#define GL_TEXTURE_RECTANGLE_ARB
Definition: glext.h:1614
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR
Definition: wined3d.h:1325
#define GL_TEXTURE_1D
Definition: gl.h:644
#define GL_UNSIGNED_INT_8_8_8_8
Definition: gl.h:1494
GLuint color
Definition: glext.h:6243
Definition: devices.h:37
const GLuint * textures
Definition: glext.h:8098
#define GL_TEXTURE_CUBE_MAP_POSITIVE_X
Definition: gl.h:1790
BOOL supported[WINED3D_GL_EXT_COUNT]
void context_bind_dummy_textures(const struct wined3d_device *device, const struct wined3d_context *context)
Definition: context.c:1764
#define GL_TEXTURE_3D
Definition: gl.h:1515
#define GL_EXTCALL(f)
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
#define GL_TEXTURE_1D_ARRAY
Definition: glext.h:533
#define GL_RGBA8
Definition: gl.h:762
#define GL_TEXTURE_2D_ARRAY
Definition: glext.h:535
#define GL_TEXTURE_CUBE_MAP
Definition: gl.h:1788
#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY
Definition: glext.h:1941
unsigned int GLuint
Definition: gl.h:159
#define ARRAY_SIZE(a)
Definition: main.h:24
#define GL_TRUE
Definition: gl.h:174
#define checkGLcall(A)
#define GL_TEXTURE_2D
Definition: gl.h:645
#define GL_RGBA
Definition: gl.h:503
#define GL_STATIC_DRAW
Definition: glext.h:350

Referenced by wined3d_device_create_primary_opengl_context_cs().

◆ d3d_primitive_type_from_gl()

static enum wined3d_primitive_type d3d_primitive_type_from_gl ( GLenum  primitive_type)
static

Definition at line 102 of file device.c.

103 {
104  switch (primitive_type)
105  {
106  case GL_POINTS:
107  return WINED3D_PT_POINTLIST;
108 
109  case GL_LINES:
110  return WINED3D_PT_LINELIST;
111 
112  case GL_LINE_STRIP:
113  return WINED3D_PT_LINESTRIP;
114 
115  case GL_TRIANGLES:
117 
118  case GL_TRIANGLE_STRIP:
120 
121  case GL_TRIANGLE_FAN:
122  return WINED3D_PT_TRIANGLEFAN;
123 
126 
129 
132 
135 
136  case GL_PATCHES:
137  return WINED3D_PT_PATCH;
138 
139  default:
140  FIXME("Unhandled primitive type %s.\n", debug_d3dprimitivetype(primitive_type));
141  case ~0u:
142  return WINED3D_PT_UNDEFINED;
143  }
144 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define GL_TRIANGLES
Definition: gl.h:194
#define GL_LINE_STRIP_ADJACENCY_ARB
Definition: glext.h:1763
#define GL_POINTS
Definition: gl.h:190
#define FIXME(fmt,...)
Definition: debug.h:110
#define GL_TRIANGLE_FAN
Definition: gl.h:196
#define GL_LINE_STRIP
Definition: gl.h:193
#define GL_LINES
Definition: gl.h:191
const char * debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type)
Definition: utils.c:4346
#define GL_TRIANGLE_STRIP_ADJACENCY_ARB
Definition: glext.h:1765
#define GL_PATCHES
Definition: glext.h:2090
#define GL_TRIANGLES_ADJACENCY_ARB
Definition: glext.h:1764
#define GL_TRIANGLE_STRIP
Definition: gl.h:195
#define GL_LINES_ADJACENCY_ARB
Definition: glext.h:1762

Referenced by wined3d_device_get_primitive_type().

◆ destroy_default_samplers()

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

Definition at line 828 of file device.c.

829 {
830  wined3d_sampler_decref(device->default_sampler);
831  device->default_sampler = NULL;
832  wined3d_sampler_decref(device->null_sampler);
833  device->null_sampler = NULL;
834 }
Definition: devices.h:37
smooth NULL
Definition: ftsmooth.c:416
ULONG CDECL wined3d_sampler_decref(struct wined3d_sampler *sampler)
Definition: sampler.c:53

Referenced by wined3d_device_delete_opengl_contexts_cs().

◆ destroy_dummy_textures()

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

Definition at line 739 of file device.c.

740 {
741  struct wined3d_dummy_textures *dummy_textures = &device->dummy_textures;
742  const struct wined3d_gl_info *gl_info = context->gl_info;
743 
744  if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
745  {
746  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_2d_ms);
747  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_2d_ms_array);
748  }
749 
750  if (gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
751  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_buffer);
752 
753  if (gl_info->supported[EXT_TEXTURE_ARRAY])
754  {
755  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_1d_array);
756  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_2d_array);
757  }
758 
760  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_cube_array);
761 
762  if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
763  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_cube);
764 
765  if (gl_info->supported[EXT_TEXTURE3D])
766  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_3d);
767 
768  if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
769  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_rect);
770 
771  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_2d);
772  gl_info->gl_ops.gl.p_glDeleteTextures(1, &dummy_textures->tex_1d);
773 
774  checkGLcall("delete dummy textures");
775 
776  memset(dummy_textures, 0, sizeof(*dummy_textures));
777 }
struct opengl_funcs gl_ops
Definition: http.c:7098
Definition: devices.h:37
BOOL supported[WINED3D_GL_EXT_COUNT]
#define checkGLcall(A)
#define memset(x, y, z)
Definition: compat.h:39

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.

227 {
228  struct wined3d_rendertarget_view *rtv = rt_count ? fb->render_targets[0] : NULL;
230  struct wined3d_rendertarget_view *dsv = fb->depth_stencil;
231  struct wined3d_surface *depth_stencil = dsv ? wined3d_rendertarget_view_get_surface(dsv) : NULL;
232  const struct wined3d_state *state = &device->cs->state;
233  const struct wined3d_gl_info *gl_info;
234  UINT drawable_width, drawable_height;
235  struct wined3d_color corrected_color;
236  struct wined3d_context *context;
237  GLbitfield clear_mask = 0;
239  unsigned int i;
240 
241  if (target)
243  else
245  if (!context->valid)
246  {
248  WARN("Invalid context, skipping clear.\n");
249  return;
250  }
251  gl_info = context->gl_info;
252 
253  /* When we're clearing parts of the drawable, make sure that the target surface is well up to date in the
254  * drawable. After the clear we'll mark the drawable up to date, so we have to make sure that this is true
255  * for the cleared parts, and the untouched parts.
256  *
257  * If we're clearing the whole target there is no need to copy it into the drawable, it will be overwritten
258  * anyway. If we're not clearing the color buffer we don't have to copy either since we're not going to set
259  * the drawable up to date. We have to check all settings that limit the clear area though. Do not bother
260  * checking all this if the dest surface is in the drawable anyway. */
261  for (i = 0; i < rt_count; ++i)
262  {
263  struct wined3d_rendertarget_view *rtv = fb->render_targets[i];
264 
265  if (rtv && rtv->format->id != WINED3DFMT_NULL)
266  {
268 
270  draw_rect, rect_count ? clear_rect : NULL))
271  wined3d_texture_load_location(rt, rtv->sub_resource_idx, context, rtv->resource->draw_binding);
272  else
273  wined3d_texture_prepare_location(rt, rtv->sub_resource_idx, context, rtv->resource->draw_binding);
274  }
275  }
276 
277  if (target)
278  {
279  render_offscreen = context->render_offscreen;
280  wined3d_rendertarget_view_get_drawable_size(rtv, context, &drawable_width, &drawable_height);
281  }
282  else
283  {
284  unsigned int ds_level = dsv->sub_resource_idx % depth_stencil->container->level_count;
285 
286  render_offscreen = TRUE;
287  drawable_width = wined3d_texture_get_level_pow2_width(depth_stencil->container, ds_level);
288  drawable_height = wined3d_texture_get_level_pow2_height(depth_stencil->container, ds_level);
289  }
290 
291  if (depth_stencil)
292  {
293  DWORD ds_location = render_offscreen ? dsv->resource->draw_binding : WINED3D_LOCATION_DRAWABLE;
295 
297  && !is_full_clear(ds, dsv->sub_resource_idx, draw_rect, rect_count ? clear_rect : NULL))
299  else
301 
303  {
306  }
307  }
308 
309  if (!context_apply_clear_state(context, state, rt_count, fb))
310  {
312  WARN("Failed to apply clear state, skipping clear.\n");
313  return;
314  }
315 
316  /* Only set the values up once, as they are not changing. */
318  {
319  if (gl_info->supported[EXT_STENCIL_TWO_SIDE])
320  {
321  gl_info->gl_ops.gl.p_glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
323  }
324  gl_info->gl_ops.gl.p_glStencilMask(~0U);
326  gl_info->gl_ops.gl.p_glClearStencil(stencil);
327  checkGLcall("glClearStencil");
328  clear_mask = clear_mask | GL_STENCIL_BUFFER_BIT;
329  }
330 
332  {
333  gl_info->gl_ops.gl.p_glDepthMask(GL_TRUE);
335  gl_info->gl_ops.gl.p_glClearDepth(depth);
336  checkGLcall("glClearDepth");
337  clear_mask = clear_mask | GL_DEPTH_BUFFER_BIT;
338  }
339 
341  {
342  for (i = 0; i < rt_count; ++i)
343  {
344  struct wined3d_rendertarget_view *rtv = fb->render_targets[i];
345  struct wined3d_texture *texture;
346 
347  if (!rtv)
348  continue;
349 
350  if (rtv->resource->type == WINED3D_RTYPE_BUFFER)
351  {
352  FIXME("Not supported on buffer resources.\n");
353  continue;
354  }
355 
359  }
360 
362  {
363  if (rt_count > 1)
364  WARN("Clearing multiple sRGB render targets with no GL_ARB_framebuffer_sRGB "
365  "support, this might cause graphical issues.\n");
366 
367  corrected_color.r = color->r < wined3d_srgb_const1[0]
368  ? color->r * wined3d_srgb_const0[3]
370  - wined3d_srgb_const0[2];
371  corrected_color.r = min(max(corrected_color.r, 0.0f), 1.0f);
372  corrected_color.g = color->g < wined3d_srgb_const1[0]
373  ? color->g * wined3d_srgb_const0[3]
375  - wined3d_srgb_const0[2];
376  corrected_color.g = min(max(corrected_color.g, 0.0f), 1.0f);
377  corrected_color.b = color->b < wined3d_srgb_const1[0]
378  ? color->b * wined3d_srgb_const0[3]
380  - wined3d_srgb_const0[2];
381  corrected_color.b = min(max(corrected_color.b, 0.0f), 1.0f);
382  color = &corrected_color;
383  }
384 
385  gl_info->gl_ops.gl.p_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
386  for (i = 0; i < MAX_RENDER_TARGETS; ++i)
388  gl_info->gl_ops.gl.p_glClearColor(color->r, color->g, color->b, color->a);
389  checkGLcall("glClearColor");
390  clear_mask = clear_mask | GL_COLOR_BUFFER_BIT;
391  }
392 
393  if (!rect_count)
394  {
395  if (render_offscreen)
396  {
397  gl_info->gl_ops.gl.p_glScissor(draw_rect->left, draw_rect->top,
398  draw_rect->right - draw_rect->left, draw_rect->bottom - draw_rect->top);
399  }
400  else
401  {
402  gl_info->gl_ops.gl.p_glScissor(draw_rect->left, drawable_height - draw_rect->bottom,
403  draw_rect->right - draw_rect->left, draw_rect->bottom - draw_rect->top);
404  }
405  checkGLcall("glScissor");
406  gl_info->gl_ops.gl.p_glClear(clear_mask);
407  checkGLcall("glClear");
408  }
409  else
410  {
411  RECT current_rect;
412 
413  /* Now process each rect in turn. */
414  for (i = 0; i < rect_count; ++i)
415  {
416  /* Note that GL uses lower left, width/height. */
417  IntersectRect(&current_rect, draw_rect, &clear_rect[i]);
418 
419  TRACE("clear_rect[%u] %s, current_rect %s.\n", i,
420  wine_dbgstr_rect(&clear_rect[i]),
421  wine_dbgstr_rect(&current_rect));
422 
423  /* Tests show that rectangles where x1 > x2 or y1 > y2 are ignored silently.
424  * The rectangle is not cleared, no error is returned, but further rectangles are
425  * still cleared if they are valid. */
426  if (current_rect.left > current_rect.right || current_rect.top > current_rect.bottom)
427  {
428  TRACE("Rectangle with negative dimensions, ignoring.\n");
429  continue;
430  }
431 
432  if (render_offscreen)
433  {
434  gl_info->gl_ops.gl.p_glScissor(current_rect.left, current_rect.top,
435  current_rect.right - current_rect.left, current_rect.bottom - current_rect.top);
436  }
437  else
438  {
439  gl_info->gl_ops.gl.p_glScissor(current_rect.left, drawable_height - current_rect.bottom,
440  current_rect.right - current_rect.left, current_rect.bottom - current_rect.top);
441  }
442  checkGLcall("glScissor");
443 
444  gl_info->gl_ops.gl.p_glClear(clear_mask);
445  checkGLcall("glClear");
446  }
447  }
448 
450  && target->container->swapchain && target->container->swapchain->front_buffer == target->container))
451  gl_info->gl_ops.gl.p_glFlush(); /* Flush to ensure ordering across contexts. */
452 
454 }
#define MAX_RENDER_TARGETS
#define GL_COLOR_BUFFER_BIT
Definition: gl.h:716
#define max(a, b)
Definition: svc.c:63
#define TRUE
Definition: types.h:120
struct opengl_funcs gl_ops
Definition: http.c:7098
static BOOL is_full_clear(const struct wined3d_texture *texture, unsigned int sub_resource_idx, const RECT *draw_rect, const RECT *clear_rect)
Definition: device.c:203
struct wined3d_rendertarget_view * render_targets[MAX_RENDER_TARGET_VIEWS]
#define GL_DEPTH_BUFFER_BIT
Definition: gl.h:710
#define WARN(fmt,...)
Definition: debug.h:111
#define U(x)
Definition: wordpad.c:44
#define GL_STENCIL_BUFFER_BIT
Definition: gl.h:712
LONG top
Definition: windef.h:307
#define ds
Definition: i386-dis.c:434
void context_invalidate_state(struct wined3d_context *context, DWORD state)
Definition: context.c:1652
LONG left
Definition: windef.h:306
LONG right
Definition: windef.h:308
static enum wined3d_render_state WINED3D_RS_COLORWRITE(int index)
Definition: wined3d.h:400
#define WINED3DCLEAR_STENCIL
Definition: wined3d.h:999
GLint GLfloat GLint stencil
Definition: glext.h:6260
struct wined3d_texture *__cdecl wined3d_texture_from_resource(struct wined3d_resource *resource)
Definition: texture.c:2210
#define WINED3DCLEAR_ZBUFFER
Definition: wined3d.h:998
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define GL_STENCIL_TEST_TWO_SIDE_EXT
Definition: glext.h:4210
unsigned int BOOL
Definition: ntddk_ex.h:94
GLuint color
Definition: glext.h:6243
Definition: devices.h:37
float pow(float __x, int __y)
Definition: _cmath.h:458
static struct wined3d_surface * wined3d_rendertarget_view_get_surface(const struct wined3d_rendertarget_view *view)
#define FIXME(fmt,...)
Definition: debug.h:110
BOOL supported[WINED3D_GL_EXT_COUNT]
smooth NULL
Definition: ftsmooth.c:416
#define WINED3D_LOCATION_DRAWABLE
BOOL context_apply_clear_state(struct wined3d_context *context, const struct wined3d_state *state, UINT rt_count, const struct wined3d_fb_state *fb)
Definition: context.c:3047
void context_release(struct wined3d_context *context)
Definition: context.c:1571
const float wined3d_srgb_const0[]
Definition: shader.c:36
const struct wined3d_format * format
BOOL wined3d_texture_prepare_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location)
Definition: texture.c:1605
const float wined3d_srgb_const1[]
Definition: shader.c:38
void wined3d_rendertarget_view_get_drawable_size(const struct wined3d_rendertarget_view *view, const struct wined3d_context *context, unsigned int *width, unsigned int *height)
Definition: view.c:404
#define TRACE(s)
Definition: solgame.cpp:4
void wined3d_texture_validate_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, DWORD location)
Definition: texture.c:135
GLenum GLuint texture
Definition: glext.h:6295
const char * wine_dbgstr_rect(const RECT *rect)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
static struct wined3d_texture * texture_from_resource(struct wined3d_resource *resource)
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
static int state
Definition: maze.c:121
#define WINED3DCLEAR_TARGET
Definition: wined3d.h:997
static unsigned int wined3d_texture_get_level_pow2_height(const struct wined3d_texture *texture, unsigned int level)
struct wined3d_rendertarget_view * depth_stencil
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
#define STATE_RENDER(a)
struct wined3d_context * context_acquire(const struct wined3d_device *device, struct wined3d_texture *texture, unsigned int sub_resource_idx)
Definition: context.c:4242
unsigned int GLbitfield
Definition: gl.h:152
void wined3d_texture_invalidate_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, DWORD location)
Definition: texture.c:159
#define GL_TRUE
Definition: gl.h:174
#define checkGLcall(A)
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
BOOL wined3d_texture_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location)
Definition: texture.c:229
GLenum target
Definition: glext.h:7315
LONG bottom
Definition: windef.h:309
const struct wined3d_gl_info * gl_info
struct wined3d_texture * container
static BOOL needs_srgb_write(const struct wined3d_context *context, const struct wined3d_state *state, const struct wined3d_fb_state *fb)
static unsigned int wined3d_texture_get_level_pow2_width(const struct wined3d_texture *texture, unsigned int level)
struct wined3d_resource * resource

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.

147 {
148  struct wined3d_context **new_array;
149 
150  TRACE("Adding context %p.\n", context);
151 
152  if (!(new_array = heap_realloc(device->contexts, sizeof(*new_array) * (device->context_count + 1))))
153  {
154  ERR("Failed to grow the context array.\n");
155  return FALSE;
156  }
157 
158  new_array[device->context_count++] = context;
159  device->contexts = new_array;
160  return TRUE;
161 }
#define TRUE
Definition: types.h:120
Definition: http.c:7098
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:70
Definition: devices.h:37
#define TRACE(s)
Definition: solgame.cpp:4
#define ERR(fmt,...)
Definition: debug.h:109

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.

164 {
165  struct wined3d_context **new_array;
166  BOOL found = FALSE;
167  UINT i;
168 
169  TRACE("Removing context %p.\n", context);
170 
171  for (i = 0; i < device->context_count; ++i)
172  {
173  if (device->contexts[i] == context)
174  {
175  found = TRUE;
176  break;
177  }
178  }
179 
180  if (!found)
181  {
182  ERR("Context %p doesn't exist in context array.\n", context);
183  return;
184  }
185 
186  if (!--device->context_count)
187  {
188  heap_free(device->contexts);
189  device->contexts = NULL;
190  return;
191  }
192 
193  memmove(&device->contexts[i], &device->contexts[i + 1], (device->context_count - i) * sizeof(*device->contexts));
194  if (!(new_array = heap_realloc(device->contexts, device->context_count * sizeof(*device->contexts))))
195  {
196  ERR("Failed to shrink context array. Oh well.\n");
197  return;
198  }
199 
200  device->contexts = new_array;
201 }
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define TRUE
Definition: types.h:120
Definition: http.c:7098
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:70
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define ERR(fmt,...)
Definition: debug.h:109
unsigned int UINT
Definition: ndis.h:50
static BOOL heap_free(void *mem)
Definition: appwiz.h:75

Referenced by context_create(), and context_destroy().

◆ device_free_sampler()

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

Definition at line 1188 of file device.c.

1189 {
1191 
1193 }
#define WINE_RB_ENTRY_VALUE(element, type, field)
Definition: rbtree.h:31
ULONG CDECL wined3d_sampler_decref(struct wined3d_sampler *sampler)
Definition: sampler.c:53
uint32_t entry
Definition: isohybrid.c:63
GLuint sampler
Definition: glext.h:7283

Referenced by wined3d_device_reset(), and wined3d_device_uninit_3d().

◆ device_init()

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

Definition at line 5195 of file device.c.

5198 {
5199  struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx];
5200  const struct fragment_pipeline *fragment_pipeline;
5201  const struct wined3d_vertex_pipe_ops *vertex_pipeline;
5202  unsigned int i;
5203  HRESULT hr;
5204 
5205  device->ref = 1;
5206  device->wined3d = wined3d;
5207  wined3d_incref(device->wined3d);
5208  device->adapter = wined3d->adapter_count ? adapter : NULL;
5209  device->device_parent = device_parent;
5210  list_init(&device->resources);
5211  list_init(&device->shaders);
5212  device->surface_alignment = surface_alignment;
5213 
5214  /* Save the creation parameters. */
5215  device->create_parms.adapter_idx = adapter_idx;
5216  device->create_parms.device_type = device_type;
5217  device->create_parms.focus_window = focus_window;
5218  device->create_parms.flags = flags;
5219 
5220  device->shader_backend = adapter->shader_backend;
5221 
5222  vertex_pipeline = adapter->vertex_pipe;
5223 
5224  fragment_pipeline = adapter->fragment_pipe;
5225 
5227 
5228  if (vertex_pipeline->vp_states && fragment_pipeline->states
5229  && FAILED(hr = compile_state_table(device->StateTable, device->multistate_funcs,
5230  &adapter->gl_info, &adapter->d3d_info, vertex_pipeline,
5232  {
5233  ERR("Failed to compile state table, hr %#x.\n", hr);
5234  wine_rb_destroy(&device->samplers, NULL, NULL);
5235  wined3d_decref(device->wined3d);
5236  return hr;
5237  }
5238 
5239  state_init(&device->state, &device->fb, &adapter->gl_info,
5241  device->update_state = &device->state;
5242 
5243  if (!(device->cs = wined3d_cs_create(device)))
5244  {
5245  WARN("Failed to create command stream.\n");
5246  state_cleanup(&device->state);
5247  hr = E_FAIL;
5248  goto err;
5249  }
5250 
5251  return WINED3D_OK;
5252 
5253 err:
5254  for (i = 0; i < ARRAY_SIZE(device->multistate_funcs); ++i)
5255  {
5256  heap_free(device->multistate_funcs[i]);
5257  }
5258  wine_rb_destroy(&device->samplers, NULL, NULL);
5259  wined3d_decref(device->wined3d);
5260  return hr;
5261 }
const struct StateEntryTemplate * states
struct wined3d_adapter adapters[1]
const struct wined3d_vertex_pipe_ops * vertex_pipe
HRESULT hr
Definition: shlfolder.c:183
#define WARN(fmt,...)
Definition: debug.h:111
device_type
#define E_FAIL
Definition: ddrawi.h:102
struct wined3d_gl_info gl_info
struct wined3d_d3d_info d3d_info
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ULONG CDECL wined3d_incref(struct wined3d *wined3d)
Definition: directx.c:456
Definition: devices.h:37
smooth NULL
Definition: ftsmooth.c:416
const struct StateEntryTemplate misc_state_template[]
Definition: state.c:5097
void state_cleanup(struct wined3d_state *state)
Definition: stateblock.c:528
static void wine_rb_init(struct wine_rb_tree *tree, wine_rb_compare_func_t compare)
Definition: rbtree.h:179
static int wined3d_sampler_compare(const void *key, const struct wine_rb_entry *entry)
Definition: device.c:5188
ULONG CDECL wined3d_decref(struct wined3d *wined3d)
Definition: directx.c:465
const struct wined3d_shader_backend_ops * shader_backend
LONG HRESULT
Definition: typedefs.h:77
#define WINED3D_OK
Definition: wined3d.h:37
GLbitfield flags
Definition: glext.h:7161
static void wine_rb_destroy(struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context)
Definition: rbtree.h:198
UINT adapter_count
#define err(...)
#define ERR(fmt,...)
Definition: debug.h:109
#define ARRAY_SIZE(a)
Definition: main.h:24
const struct fragment_pipeline * fragment_pipe
void state_init(void *ipp)
Definition: dhclient.c:218
#define WINED3D_STATE_INIT_DEFAULT
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
struct wined3d_cs * wined3d_cs_create(struct wined3d_device *device)
Definition: cs.c:2828
HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_multistate_funcs, const struct wined3d_gl_info *gl_info, const struct wined3d_d3d_info *d3d_info, const struct wined3d_vertex_pipe_ops *vertex, const struct fragment_pipeline *fragment, const struct StateEntryTemplate *misc)
Definition: state.c:6139
const struct StateEntryTemplate * vp_states
static BOOL heap_free(void *mem)
Definition: appwiz.h:75

◆ device_init_swapchain_state()

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

Definition at line 962 of file device.c.

963 {
964  BOOL ds_enable = swapchain->desc.enable_auto_depth_stencil;
965  unsigned int i;
966 
967  for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
968  {
970  }
971  if (device->back_buffer_view)
972  wined3d_device_set_rendertarget_view(device, 0, device->back_buffer_view, TRUE);
973 
974  wined3d_device_set_depth_stencil_view(device, ds_enable ? device->auto_depth_stencil_view : NULL);
975 }
#define TRUE
Definition: types.h:120
void CDECL wined3d_device_set_depth_stencil_view(struct wined3d_device *device, struct wined3d_rendertarget_view *view)
Definition: device.c:4524
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
struct wined3d_swapchain_desc desc
smooth NULL
Definition: ftsmooth.c:416
HRESULT CDECL wined3d_device_set_rendertarget_view(struct wined3d_device *device, unsigned int view_idx, struct wined3d_rendertarget_view *view, BOOL set_viewport)
Definition: device.c:4468

Referenced by wined3d_device_init_3d(), and wined3d_device_reset().

◆ device_invalidate_state()

void device_invalidate_state ( const struct wined3d_device device,
DWORD  state 
)

Definition at line 5263 of file device.c.

5264 {
5265  DWORD rep = device->StateTable[state].representative;
5266  struct wined3d_context *context;
5267  DWORD idx;
5268  BYTE shift;
5269  UINT i;
5270 
5271  wined3d_from_cs(device->cs);
5272 
5273  if (STATE_IS_COMPUTE(state))
5274  {
5275  for (i = 0; i < device->context_count; ++i)
5277  return;
5278  }
5279 
5280  for (i = 0; i < device->context_count; ++i)
5281  {
5282  context = device->contexts[i];
5283  if(isStateDirty(context, rep)) continue;
5284 
5285  context->dirtyArray[context->numDirtyEntries++] = rep;
5286  idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
5287  shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
5288  context->isStateDirty[idx] |= (1u << shift);
5289  }
5290 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define shift
Definition: input.c:1761
Definition: http.c:7098
static void wined3d_from_cs(const struct wined3d_cs *cs)
#define CHAR_BIT
Definition: urlcache.c:58
#define STATE_IS_COMPUTE(a)
static BOOL isStateDirty(const struct wined3d_context *context, DWORD state)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Definition: devices.h:37
unsigned int idx
Definition: utils.c:41
void context_invalidate_compute_state(struct wined3d_context *context, DWORD state_id)
Definition: context.c:1642
unsigned long DWORD
Definition: ntddk_ex.h:95
static int state
Definition: maze.c:121
unsigned char BYTE
Definition: mem.h:68
unsigned int UINT
Definition: ndis.h:50

Referenced by buffer_destroy_buffer_object(), surface_load_fb_texture(), wined3d_cs_exec_draw(), wined3d_cs_exec_set_blend_state(), wined3d_cs_exec_set_clip_plane(), wined3d_cs_exec_set_color_key(), wined3d_cs_exec_set_constant_buffer(), wined3d_cs_exec_set_depth_stencil_view(), wined3d_cs_exec_set_index_buffer(), wined3d_cs_exec_set_light(), wined3d_cs_exec_set_light_enable(), wined3d_cs_exec_set_material(), wined3d_cs_exec_set_rasterizer_state(), wined3d_cs_exec_set_render_state(), wined3d_cs_exec_set_rendertarget_view(), wined3d_cs_exec_set_sampler(), wined3d_cs_exec_set_sampler_state(), wined3d_cs_exec_set_scissor_rect(), wined3d_cs_exec_set_shader(), wined3d_cs_exec_set_shader_resource_view(), wined3d_cs_exec_set_stream_output(), wined3d_cs_exec_set_stream_source(), wined3d_cs_exec_set_stream_source_freq(), wined3d_cs_exec_set_texture(), wined3d_cs_exec_set_texture_state(), wined3d_cs_exec_set_transform(), wined3d_cs_exec_set_unordered_access_view(), wined3d_cs_exec_set_vertex_declaration(), wined3d_cs_exec_set_viewport(), and wined3d_swapchain_rotate().

◆ device_leftover_sampler()

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

Definition at line 465 of file device.c.

466 {
468 
469  ERR("Leftover sampler %p.\n", sampler);
470 }
#define WINE_RB_ENTRY_VALUE(element, type, field)
Definition: rbtree.h:31
uint32_t entry
Definition: isohybrid.c:63
#define ERR(fmt,...)
Definition: debug.h:109
GLuint sampler
Definition: glext.h:7283

Referenced by wined3d_device_decref().

◆ device_load_logo()

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

Definition at line 547 of file device.c.

548 {
551  HBITMAP hbm;
552  BITMAP bm;
553  HRESULT hr;
554  HDC dcb = NULL, dcs = NULL;
555 
557  {
558  ERR_(winediag)("Failed to load logo %s.\n", wine_dbgstr_a(filename));
559  return;
560  }
561  GetObjectA(hbm, sizeof(BITMAP), &bm);
562 
563  if (!(dcb = CreateCompatibleDC(NULL)))
564  goto out;
565  SelectObject(dcb, hbm);
566 
567  desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
568  desc.format = WINED3DFMT_B5G6R5_UNORM;
569  desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
570  desc.multisample_quality = 0;
571  desc.usage = WINED3DUSAGE_DYNAMIC;
573  desc.width = bm.bmWidth;
574  desc.height = bm.bmHeight;
575  desc.depth = 1;
576  desc.size = 0;
579  NULL, NULL, &wined3d_null_parent_ops, &device->logo_texture)))
580  {
581  ERR("Wine logo requested, but failed to create texture, hr %#x.\n", hr);
582  goto out;
583  }
584 
585  if (FAILED(hr = wined3d_texture_get_dc(device->logo_texture, 0, &dcs)))
586  {
587  wined3d_texture_decref(device->logo_texture);
588  device->logo_texture = NULL;
589  goto out;
590  }
591  BitBlt(dcs, 0, 0, bm.bmWidth, bm.bmHeight, dcb, 0, 0, SRCCOPY);
592  wined3d_texture_release_dc(device->logo_texture, 0, dcs);
593 
594  color_key.color_space_low_value = 0;
595  color_key.color_space_high_value = 0;
597 
598 out:
599  if (dcb) DeleteDC(dcb);
600  if (hbm) DeleteObject(hbm);
601 }
int WINAPI GetObjectA(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
const char int int int static __inline const char * wine_dbgstr_a(const char *s)
Definition: debug.h:186
HRESULT hr
Definition: shlfolder.c:183
#define WINED3D_CKEY_SRC_BLT
Definition: wined3d.h:1336
#define LR_LOADFROMFILE
Definition: winuser.h:1082
#define WINED3DUSAGE_DYNAMIC
Definition: wined3d.h:907
#define ERR_(ch,...)
Definition: debug.h:156
static HDC
Definition: imagelist.c:92
HRESULT CDECL wined3d_texture_release_dc(struct wined3d_texture *texture, unsigned int sub_resource_idx, HDC dc)
Definition: texture.c:3671
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1497
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
const char * filename
Definition: ioapi.h:135
static VOID NTAPI BitBlt(IN ULONG Left, IN ULONG Top, IN ULONG Width, IN ULONG Height, IN PUCHAR Buffer, IN ULONG BitsPerPixel, IN ULONG Delta)
Definition: vga.c:410
#define WINED3D_TEXTURE_CREATE_GET_DC
Definition: wined3d.h:1561
Definition: devices.h:37
static const WCHAR desc[]
Definition: protectdata.c:36
smooth NULL
Definition: ftsmooth.c:416
HRESULT CDECL wined3d_texture_set_color_key(struct wined3d_texture *texture, DWORD flags, const struct wined3d_color_key *color_key)
Definition: texture.c:1235
LONG HRESULT
Definition: typedefs.h:77
static FILE * out
Definition: regtests2xml.c:44
#define WINED3D_RESOURCE_ACCESS_GPU
Definition: wined3d.h:55
#define ERR(fmt,...)
Definition: debug.h:109
HANDLE WINAPI LoadImageA(_In_opt_ HINSTANCE, _In_ LPCSTR, _In_ UINT, _In_ int, _In_ int, _In_ UINT)
Definition: cursoricon.c:2147
BOOL WINAPI DeleteDC(_In_ HDC)
#define WINED3D_TEXTURE_CREATE_MAPPABLE
Definition: wined3d.h:1558
const struct wined3d_parent_ops wined3d_null_parent_ops
Definition: directx.c:6815
_In_ HBITMAP hbm
Definition: ntgdi.h:2776
Definition: bl.h:1331
HRESULT CDECL wined3d_texture_get_dc(struct wined3d_texture *texture, unsigned int sub_resource_idx, HDC *dc)
Definition: texture.c:3623
#define LR_CREATEDIBSECTION
Definition: winuser.h:1088
#define IMAGE_BITMAP
Definition: winuser.h:211
ULONG CDECL wined3d_texture_decref(struct wined3d_texture *texture)
Definition: texture.c:1023
static HBITMAP
Definition: button.c:44
#define SRCCOPY
Definition: wingdi.h:332
HRESULT CDECL wined3d_texture_create(struct wined3d_device *device, const struct wined3d_resource_desc *desc, UINT layer_count, UINT level_count, DWORD flags, const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_texture **texture)
Definition: texture.c:3511

Referenced by wined3d_device_init_3d(), and wined3d_device_reset().

◆ device_process_message()

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

Definition at line 5292 of file device.c.

5294 {
5295  if (device->filter_messages && message != WM_DISPLAYCHANGE)
5296  {
5297  TRACE("Filtering message: window %p, message %#x, wparam %#lx, lparam %#lx.\n",
5299  if (unicode)
5301  else
5303  }
5304 
5305  if (message == WM_DESTROY)
5306  {
5307  TRACE("unregister window %p.\n", window);
5309 
5310  if (InterlockedCompareExchangePointer((void **)&device->focus_window, NULL, window) != window)
5311  ERR("Window %p is not the focus window for device %p.\n", window, device);
5312  }
5313  else if (message == WM_DISPLAYCHANGE)
5314  {
5315  device->device_parent->ops->mode_changed(device->device_parent);
5316  }
5317  else if (message == WM_ACTIVATEAPP)
5318  {
5319  UINT i;
5320 
5321  for (i = 0; i < device->swapchain_count; i++)
5322  wined3d_swapchain_activate(device->swapchains[i], wparam);
5323 
5324  device->device_parent->ops->activate(device->device_parent, wparam);
5325  }
5326  else if (message == WM_SYSCOMMAND)
5327  {
5328  if (wparam == SC_RESTORE && device->wined3d->flags & WINED3D_HANDLE_RESTORE)
5329  {
5330  if (unicode)
5332  else
5334  }
5335  }
5336 
5337  if (unicode)
5339  else
5341 }
Definition: tftpd.h:59
#define SC_RESTORE
Definition: winuser.h:2573
#define WINED3D_HANDLE_RESTORE
Definition: wined3d.h:1321
static HANDLE proc()
Definition: pdb.c:32
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
LRESULT WINAPI CallWindowProcA(_In_ WNDPROC, _In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
void wined3d_unregister_window(HWND window)
Definition: wined3d_main.c:470
Definition: devices.h:37
static UINT WPARAM LPARAM lparam
Definition: combo.c:716
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
smooth NULL
Definition: ftsmooth.c:416
void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activate)
Definition: swapchain.c:1149
#define WM_DESTROY
Definition: winuser.h:1591
#define TRACE(s)
Definition: solgame.cpp:4
LRESULT WINAPI DefWindowProcA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
static IHTMLWindow2 * window
Definition: events.c:77
#define ERR(fmt,...)
Definition: debug.h:109
#define WM_ACTIVATEAPP
Definition: winuser.h:1614
unsigned int UINT
Definition: ndis.h:50
LRESULT WINAPI CallWindowProcW(_In_ WNDPROC, _In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define WM_SYSCOMMAND
Definition: winuser.h:1723
static UINT WPARAM wparam
Definition: combo.c:716

Referenced by wined3d_wndproc().

◆ device_resource_add()

void device_resource_add ( struct wined3d_device device,
struct wined3d_resource resource 
)

Definition at line 5081 of file device.c.

5082 {
5083  TRACE("device %p, resource %p.\n", device, resource);
5084 
5086 
5087  list_add_head(&device->resources, &resource->resource_list_entry);
5088 }
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
Definition: list.h:96
Definition: devices.h:37
#define TRACE(s)
Definition: solgame.cpp:4
static void wined3d_not_from_cs(struct wined3d_cs *cs)

Referenced by resource_init().

◆ device_resource_released()

void device_resource_released ( struct wined3d_device device,
struct wined3d_resource resource 
)

Definition at line 5099 of file device.c.

5100 {
5101  enum wined3d_resource_type type = resource->type;
5102  struct wined3d_rendertarget_view *rtv;
5103  unsigned int i;
5104 
5105  TRACE("device %p, resource %p, type %s.\n", device, resource, debug_d3dresourcetype(type));
5106 
5107  if (device->d3d_initialized)
5108  {
5109  for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
5110  {
5111  if ((rtv = device->fb.render_targets[i]) && rtv->resource == resource)
5112  ERR("Resource %p is still in use as render target %u.\n", resource, i);
5113  }
5114 
5115  if ((rtv = device->fb.depth_stencil) && rtv->resource == resource)
5116  ERR("Resource %p is still in use as depth/stencil buffer.\n", resource);
5117  }
5118 
5119  switch (type)
5120  {
5124  for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
5125  {
5127 
5128  if (device->state.textures[i] == texture)
5129  {
5130  ERR("Texture %p is still in use, stage %u.\n", texture, i);
5131  device->state.textures[i] = NULL;
5132  }
5133 
5134  if (device->recording && device->update_state->textures[i] == texture)
5135  {
5136  ERR("Texture %p is still in use by recording stateblock %p, stage %u.\n",
5137  texture, device->recording, i);
5138  device->update_state->textures[i] = NULL;
5139  }
5140  }
5141  break;
5142 
5143  case WINED3D_RTYPE_BUFFER:
5144  {
5146 
5147  for (i = 0; i < MAX_STREAMS; ++i)
5148  {
5149  if (device->state.streams[i].buffer == buffer)
5150  {
5151  ERR("Buffer %p is still in use, stream %u.\n", buffer, i);
5152  device->state.streams[i].buffer = NULL;
5153  }
5154 
5155  if (device->recording && device->update_state->streams[i].buffer == buffer)
5156  {
5157  ERR("Buffer %p is still in use by stateblock %p, stream %u.\n",
5158  buffer, device->recording, i);
5159  device->update_state->streams[i].buffer = NULL;
5160  }
5161  }
5162 
5163  if (device->state.index_buffer == buffer)
5164  {
5165  ERR("Buffer %p is still in use as index buffer.\n", buffer);
5166  device->state.index_buffer = NULL;
5167  }
5168 
5169  if (device->recording && device->update_state->index_buffer == buffer)
5170  {
5171  ERR("Buffer %p is still in use by stateblock %p as index buffer.\n",
5172  buffer, device->recording);
5173  device->update_state->index_buffer = NULL;
5174  }
5175  }
5176  break;
5177 
5178  default:
5179  break;
5180  }
5181 
5182  /* Remove the resource from the resourceStore */
5184 
5185  TRACE("Resource released.\n");
5186 }
wined3d_resource_type
Definition: wined3d.h:695
static void device_resource_remove(struct wined3d_device *device, struct wined3d_resource *resource)
Definition: device.c:5090
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint buffer
Definition: glext.h:5915
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define MAX_COMBINED_SAMPLERS
Definition: devices.h:37
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
GLenum GLuint texture
Definition: glext.h:6295
static struct wined3d_texture * texture_from_resource(struct wined3d_resource *resource)
static struct wined3d_buffer * buffer_from_resource(struct wined3d_resource *resource)
#define ERR(fmt,...)
Definition: debug.h:109
#define MAX_STREAMS
const char * debug_d3dresourcetype(enum wined3d_resource_type resource_type)
Definition: utils.c:4329
struct wined3d_resource * resource

Referenced by resource_cleanup().

◆ device_resource_remove()

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

Definition at line 5090 of file device.c.

5091 {
5092  TRACE("device %p, resource %p.\n", device, resource);
5093 
5095 
5096  list_remove(&resource->resource_list_entry);
5097 }
Definition: devices.h:37
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
#define TRACE(s)
Definition: solgame.cpp:4
static void wined3d_not_from_cs(struct wined3d_cs *cs)

Referenced by device_resource_released().

◆ fullscreen_exstyle()

static LONG fullscreen_exstyle ( LONG  exstyle)
static

Definition at line 845 of file device.c.

846 {
847  /* Filter out window decorations. */
848  exstyle &= ~(WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE);
849 
850  return exstyle;
851 }
#define WS_EX_WINDOWEDGE
Definition: winuser.h:407
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384

Referenced by wined3d_device_restore_fullscreen_window(), and wined3d_device_setup_fullscreen_window().

◆ fullscreen_style()

static LONG fullscreen_style ( LONG  style)
static

Definition at line 836 of file device.c.

837 {
838  /* Make sure the window is managed, otherwise we won't get keyboard input. */
841 
842  return style;
843 }
#define WS_THICKFRAME
Definition: pedump.c:630
#define WS_CAPTION
Definition: pedump.c:624
#define WS_POPUP
Definition: pedump.c:616
Arabic default style
Definition: afstyles.h:93
#define WS_SYSMENU
Definition: pedump.c:629

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.

59 {
60  switch (primitive_type)
61  {
63  return GL_POINTS;
64 
66  return GL_LINES;
67 
69  return GL_LINE_STRIP;
70 
72  return GL_TRIANGLES;
73 
75  return GL_TRIANGLE_STRIP;
76 
78  return GL_TRIANGLE_FAN;
79 
82 
85 
88 
91 
92  case WINED3D_PT_PATCH:
93  return GL_PATCHES;
94 
95  default:
96  FIXME("Unhandled primitive type %s.\n", debug_d3dprimitivetype(primitive_type));
98  return ~0u;
99  }
100 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define GL_TRIANGLES
Definition: gl.h:194
#define GL_LINE_STRIP_ADJACENCY_ARB
Definition: glext.h:1763
#define GL_POINTS
Definition: gl.h:190
#define FIXME(fmt,...)
Definition: debug.h:110
#define GL_TRIANGLE_FAN
Definition: gl.h:196
#define GL_LINE_STRIP
Definition: gl.h:193
#define GL_LINES
Definition: gl.h:191
const char * debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type)
Definition: utils.c:4346
#define GL_TRIANGLE_STRIP_ADJACENCY_ARB
Definition: glext.h:1765
#define GL_PATCHES
Definition: glext.h:2090
#define GL_TRIANGLES_ADJACENCY_ARB
Definition: glext.h:1764
#define GL_TRIANGLE_STRIP
Definition: gl.h:195
#define GL_LINES_ADJACENCY_ARB
Definition: glext.h:1762

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.

205 {
206  unsigned int width, height, level;
207 
208  level = sub_resource_idx % texture->level_count;
211 
212  /* partial draw rect */
213  if (draw_rect->left || draw_rect->top || draw_rect->right < width || draw_rect->bottom < height)
214  return FALSE;
215 
216  /* partial clear rect */
217  if (clear_rect && (clear_rect->left > 0 || clear_rect->top > 0
218  || clear_rect->right < width || clear_rect->bottom < height))
219  return FALSE;
220 
221  return TRUE;
222 }
GLint level
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
#define TRUE
Definition: types.h:120
static unsigned int wined3d_texture_get_level_height(const struct wined3d_texture *texture, unsigned int level)
static unsigned int wined3d_texture_get_level_width(const struct wined3d_texture *texture, unsigned int level)
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
LONG right
Definition: windef.h:308
GLenum GLuint texture
Definition: glext.h:6295
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
LONG bottom
Definition: windef.h:309

Referenced by device_clear_render_targets().

◆ process_vertices_strided()

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

Definition at line 3070 of file device.c.

3073 {
3074  struct wined3d_matrix mat, proj_mat, view_mat, world_mat;
3075  struct wined3d_map_desc map_desc;
3076  struct wined3d_box box = {0};
3077  struct wined3d_viewport vp;
3078  UINT vertex_size;
3079  unsigned int i;
3080  BYTE *dest_ptr;
3081  BOOL doClip;
3082  DWORD numTextures;
3083  HRESULT hr;
3084 
3085  if (stream_info->use_map & (1u << WINED3D_FFP_NORMAL))
3086  {
3087  WARN(" lighting state not saved yet... Some strange stuff may happen !\n");
3088  }
3089 
3090  if (!(stream_info->use_map & (1u << WINED3D_FFP_POSITION)))
3091  {
3092  ERR("Source has no position mask\n");
3093  return WINED3DERR_INVALIDCALL;
3094  }
3095 
3096  if (device->state.render_states[WINED3D_RS_CLIPPING])
3097  {
3098  static BOOL warned = FALSE;
3099  /*
3100  * The clipping code is not quite correct. Some things need
3101  * to be checked against IDirect3DDevice3 (!), d3d8 and d3d9,
3102  * so disable clipping for now.
3103  * (The graphics in Half-Life are broken, and my processvertices
3104  * test crashes with IDirect3DDevice3)
3105  doClip = TRUE;
3106  */
3107  doClip = FALSE;
3108  if(!warned) {
3109  warned = TRUE;
3110  FIXME("Clipping is broken and disabled for now\n");
3111  }
3112  }
3113  else
3114  doClip = FALSE;
3115 
3116  vertex_size = get_flexible_vertex_size(DestFVF);
3117  box.left = dwDestIndex * vertex_size;
3118  box.right = box.left + dwCount * vertex_size;
3119  if (FAILED(hr = wined3d_resource_map(&dest->resource, 0, &map_desc, &box, WINED3D_MAP_WRITE)))
3120  {
3121  WARN("Failed to map buffer, hr %#x.\n", hr);
3122  return hr;
3123  }
3124  dest_ptr = map_desc.data;
3125 
3129 
3130  TRACE("View mat:\n");
3131  TRACE("%.8e %.8e %.8e %.8e\n", view_mat._11, view_mat._12, view_mat._13, view_mat._14);
3132  TRACE("%.8e %.8e %.8e %.8e\n", view_mat._21, view_mat._22, view_mat._23, view_mat._24);
3133  TRACE("%.8e %.8e %.8e %.8e\n", view_mat._31, view_mat._32, view_mat._33, view_mat._34);
3134  TRACE("%.8e %.8e %.8e %.8e\n", view_mat._41, view_mat._42, view_mat._43, view_mat._44);
3135 
3136  TRACE("Proj mat:\n");
3137  TRACE("%.8e %.8e %.8e %.8e\n", proj_mat._11, proj_mat._12, proj_mat._13, proj_mat._14);
3138  TRACE("%.8e %.8e %.8e %.8e\n", proj_mat._21, proj_mat._22, proj_mat._23, proj_mat._24);
3139  TRACE("%.8e %.8e %.8e %.8e\n", proj_mat._31, proj_mat._32, proj_mat._33, proj_mat._34);
3140  TRACE("%.8e %.8e %.8e %.8e\n", proj_mat._41, proj_mat._42, proj_mat._43, proj_mat._44);
3141 
3142  TRACE("World mat:\n");
3143  TRACE("%.8e %.8e %.8e %.8e\n", world_mat._11, world_mat._12, world_mat._13, world_mat._14);
3144  TRACE("%.8e %.8e %.8e %.8e\n", world_mat._21, world_mat._22, world_mat._23, world_mat._24);
3145  TRACE("%.8e %.8e %.8e %.8e\n", world_mat._31, world_mat._32, world_mat._33, world_mat._34);
3146  TRACE("%.8e %.8e %.8e %.8e\n", world_mat._41, world_mat._42, world_mat._43, world_mat._44);
3147 
3148  /* Get the viewport */
3150  TRACE("viewport x %.8e, y %.8e, width %.8e, height %.8e, min_z %.8e, max_z %.8e.\n",
3151  vp.x, vp.y, vp.width, vp.height, vp.min_z, vp.max_z);
3152 
3153  multiply_matrix(&mat,&view_mat,&world_mat);
3154  multiply_matrix(&mat,&proj_mat,&mat);
3155 
3156  numTextures = (DestFVF & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
3157 
3158  for (i = 0; i < dwCount; i+= 1) {
3159  unsigned int tex_index;
3160 
3161  if ( ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZ ) ||
3162  ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) ) {
3163  /* The position first */
3165  const float *p = (const float *)(element->data.addr + i * element->stride);
3166  float x, y, z, rhw;
3167  TRACE("In: ( %06.2f %06.2f %06.2f )\n", p[0], p[1], p[2]);
3168 
3169  /* Multiplication with world, view and projection matrix. */
3170  x = (p[0] * mat._11) + (p[1] * mat._21) + (p[2] * mat._31) + mat._41;
3171  y = (p[0] * mat._12) + (p[1] * mat._22) + (p[2] * mat._32) + mat._42;
3172  z = (p[0] * mat._13) + (p[1] * mat._23) + (p[2] * mat._33) + mat._43;
3173  rhw = (p[0] * mat._14) + (p[1] * mat._24) + (p[2] * mat._34) + mat._44;
3174 
3175  TRACE("x=%f y=%f z=%f rhw=%f\n", x, y, z, rhw);
3176 
3177  /* WARNING: The following things are taken from d3d7 and were not yet checked
3178  * against d3d8 or d3d9!
3179  */
3180 
3181  /* Clipping conditions: From msdn
3182  *
3183  * A vertex is clipped if it does not match the following requirements
3184  * -rhw < x <= rhw
3185  * -rhw < y <= rhw
3186  * 0 < z <= rhw
3187  * 0 < rhw ( Not in d3d7, but tested in d3d7)
3188  *
3189  * If clipping is on is determined by the D3DVOP_CLIP flag in D3D7, and
3190  * by the D3DRS_CLIPPING in D3D9(according to the msdn, not checked)
3191  *
3192  */
3193 
3194  if( !doClip ||
3195  ( (-rhw -eps < x) && (-rhw -eps < y) && ( -eps < z) &&
3196  (x <= rhw + eps) && (y <= rhw + eps ) && (z <= rhw + eps) &&
3197  ( rhw > eps ) ) ) {
3198 
3199  /* "Normal" viewport transformation (not clipped)
3200  * 1) The values are divided by rhw
3201  * 2) The y axis is negative, so multiply it with -1
3202  * 3) Screen coordinates go from -(Width/2) to +(Width/2) and
3203  * -(Height/2) to +(Height/2). The z range is MinZ to MaxZ
3204  * 4) Multiply x with Width/2 and add Width/2
3205  * 5) The same for the height
3206  * 6) Add the viewpoint X and Y to the 2D coordinates and
3207  * The minimum Z value to z
3208  * 7) rhw = 1 / rhw Reciprocal of Homogeneous W....
3209  *
3210  * Well, basically it's simply a linear transformation into viewport
3211  * coordinates
3212  */
3213 
3214  x /= rhw;
3215  y /= rhw;
3216  z /= rhw;
3217 
3218  y *= -1;
3219 
3220  x *= vp.width / 2;
3221  y *= vp.height / 2;
3222  z *= vp.max_z - vp.min_z;
3223 
3224  x += vp.width / 2 + vp.x;
3225  y += vp.height / 2 + vp.y;
3226  z += vp.min_z;
3227 
3228  rhw = 1 / rhw;
3229  } else {
3230  /* That vertex got clipped
3231  * Contrary to OpenGL it is not dropped completely, it just
3232  * undergoes a different calculation.
3233  */
3234  TRACE("Vertex got clipped\n");
3235  x += rhw;
3236  y += rhw;
3237 
3238  x /= 2;
3239  y /= 2;
3240 
3241  /* Msdn mentions that Direct3D9 keeps a list of clipped vertices
3242  * outside of the main vertex buffer memory. That needs some more
3243  * investigation...
3244  */
3245  }
3246 
3247  TRACE("Writing (%f %f %f) %f\n", x, y, z, rhw);
3248 
3249 
3250  ( (float *) dest_ptr)[0] = x;
3251  ( (float *) dest_ptr)[1] = y;
3252  ( (float *) dest_ptr)[2] = z;
3253  ( (float *) dest_ptr)[3] = rhw; /* SIC, see ddraw test! */
3254 
3255  dest_ptr += 3 * sizeof(float);
3256 
3257  if ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW)
3258  dest_ptr += sizeof(float);
3259  }
3260 
3261  if (DestFVF & WINED3DFVF_PSIZE)
3262  dest_ptr += sizeof(DWORD);
3263 
3264  if (DestFVF & WINED3DFVF_NORMAL)
3265  {
3267  const float *normal = (const float *)(element->data.addr + i * element->stride);
3268  /* AFAIK this should go into the lighting information */
3269  FIXME("Didn't expect the destination to have a normal\n");
3270  copy_and_next(dest_ptr, normal, 3 * sizeof(float));
3271  }
3272 
3273  if (DestFVF & WINED3DFVF_DIFFUSE)
3274  {
3276  const DWORD *color_d = (const DWORD *)(element->data.addr + i * element->stride);
3277  if (!(stream_info->use_map & (1u << WINED3D_FFP_DIFFUSE)))
3278  {
3279  static BOOL warned = FALSE;
3280 
3281  if(!warned) {
3282  ERR("No diffuse color in source, but destination has one\n");
3283  warned = TRUE;
3284  }
3285 
3286  *( (DWORD *) dest_ptr) = 0xffffffff;
3287  dest_ptr += sizeof(DWORD);
3288  }
3289  else
3290  {
3291  copy_and_next(dest_ptr, color_d, sizeof(DWORD));
3292  }
3293  }
3294 
3295  if (DestFVF & WINED3DFVF_SPECULAR)
3296  {
3297  /* What's the color value in the feedback buffer? */
3299  const DWORD *color_s = (const DWORD *)(element->data.addr + i * element->stride);
3300  if (!(stream_info->use_map & (1u << WINED3D_FFP_SPECULAR)))
3301  {
3302  static BOOL warned = FALSE;
3303 
3304  if(!warned) {
3305  ERR("No specular color in source, but destination has one\n");
3306  warned = TRUE;
3307  }
3308 
3309  *(DWORD *)dest_ptr = 0xff000000;
3310  dest_ptr += sizeof(DWORD);
3311  }
3312  else
3313  {
3314  copy_and_next(dest_ptr, color_s, sizeof(DWORD));
3315  }
3316  }
3317 
3318  for (tex_index = 0; tex_index < numTextures; ++tex_index)
3319  {
3320  const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_TEXCOORD0 + tex_index];
3321  const float *tex_coord = (const float *)(element->data.addr + i * element->stride);
3322  if (!(stream_info->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + tex_index))))
3323  {
3324  ERR("No source texture, but destination requests one\n");
3325  dest_ptr += GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
3326  }
3327  else
3328  {
3329  copy_and_next(dest_ptr, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
3330  }
3331  }
3332  }
3333 
3334  wined3d_resource_unmap(&dest->resource, 0);
3335 
3336  return WINED3D_OK;
3337 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define WINED3D_TS_WORLD_MATRIX(index)
Definition: wined3d.h:664
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
#define TRUE
Definition: types.h:120
HRESULT hr
Definition: shlfolder.c:183
void CDECL wined3d_device_get_transform(const struct wined3d_device *device, enum wined3d_transform_state state, struct wined3d_matrix *matrix)
Definition: device.c:1540
HRESULT CDECL wined3d_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx)
Definition: resource.c:382
#define WARN(fmt,...)
Definition: debug.h:111
#define WINED3DFVF_NORMAL
Definition: wined3d.h:968
#define WINED3DFVF_TEXCOUNT_MASK
Definition: wined3d.h:972
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
static const MAT2 mat
Definition: font.c:66
#define WINED3DFVF_POSITION_MASK
Definition: wined3d.h:959
#define WINED3DFVF_PSIZE
Definition: wined3d.h:969
#define DWORD
Definition: nt_native.h:44
static void stream_info(IStream *stream, HGLOBAL *hmem, int *size, int *pos)
#define GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_num)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned int BOOL
Definition: ntddk_ex.h:94
HRESULT CDECL wined3d_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx, struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags)
Definition: resource.c:344
Definition: devices.h:37
#define FIXME(fmt,...)
Definition: debug.h:110
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) DECLSPEC_HIDDEN
Definition: utils.c:923
GLdouble GLdouble z
Definition: glext.h:5874
#define eps
#define TRACE(s)
Definition: solgame.cpp:4
LONG HRESULT
Definition: typedefs.h:77
#define WINED3D_OK
Definition: wined3d.h:37
unsigned long DWORD
Definition: ntddk_ex.h:95
#define WINED3DFVF_XYZRHW
Definition: wined3d.h:961
#define WINED3D_MAP_WRITE
Definition: wined3d.h:938
unsigned char BYTE
Definition: mem.h:68
#define WINED3DFVF_XYZ
Definition: wined3d.h:960
void CDECL wined3d_device_get_viewport(const struct wined3d_device *device, struct wined3d_viewport *viewport)
Definition: device.c:1950
#define ERR(fmt,...)
Definition: debug.h:109
static float(__cdecl *square_half_float)(float x
#define WINED3DFVF_DIFFUSE
Definition: wined3d.h:970
unsigned int UINT
Definition: ndis.h:50
void multiply_matrix(D3DMATRIX *dst, const D3DMATRIX *src1, const D3DMATRIX *src2) DECLSPEC_HIDDEN
Definition: utils.c:1173
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define copy_and_next(dest, src, size)
Definition: device.c:3069
static char * dest
Definition: rtl.c:135
GLfloat GLfloat p
Definition: glext.h:8902
#define WINED3DFVF_TEXCOUNT_SHIFT
Definition: wined3d.h:973
Definition: palette.c:467
#define WINED3DFVF_SPECULAR
Definition: wined3d.h:971

Referenced by wined3d_device_process_vertices().

◆ resolve_depth_buffer()

static void resolve_depth_buffer ( struct wined3d_device device)
static

Definition at line 1957 of file device.c.

1958 {
1959  const struct wined3d_state *state = &device->state;
1960  struct wined3d_rendertarget_view *src_view;
1961  struct wined3d_resource *dst_resource;
1962  struct wined3d_texture *dst_texture;
1963 
1964  if (!(dst_texture = state->textures[0]))
1965  return;
1966  dst_resource = &dst_texture->resource;
1967  if (!(dst_resource->format_flags & WINED3DFMT_FLAG_DEPTH))
1968  return;
1969  if (!(src_view = state->fb->depth_stencil))
1970  return;
1971 
1973  src_view->resource, src_view->sub_resource_idx, dst_resource->format->id);
1974 }
struct wined3d_resource resource
unsigned int format_flags
const struct wined3d_format * format
Definition: devices.h:37
static int state
Definition: maze.c:121
#define WINED3DFMT_FLAG_DEPTH
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)
Definition: device.c:4346
struct wined3d_resource * resource

Referenced by wined3d_device_set_render_state().

◆ WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL ( winediag  )

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( d3d  )

◆ wined3d_device_acquire_focus_window()

HRESULT CDECL wined3d_device_acquire_focus_window ( struct wined3d_device device,
HWND  window 
)

Definition at line 938 of file device.c.

939 {
940  TRACE("device %p, window %p.\n", device, window);
941 
943  {
944  ERR("Failed to register window %p.\n", window);
945  return E_FAIL;
946  }
947 
948  InterlockedExchangePointer((void **)&device->focus_window, window);
949  SetWindowPos(window, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
950 
951  return WINED3D_OK;
952 }
#define E_FAIL
Definition: ddrawi.h:102
Definition: devices.h:37
#define TRACE(s)
Definition: solgame.cpp:4
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
#define WINED3D_OK
Definition: wined3d.h:37
BOOL wined3d_register_window(HWND window, struct wined3d_device *device)
Definition: wined3d_main.c:432
static IHTMLWindow2 * window
Definition: events.c:77
#define SWP_NOSIZE
Definition: winuser.h:1230
#define ERR(fmt,...)
Definition: debug.h:109
#define SWP_NOMOVE
Definition: winuser.h:1229
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)

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

◆ wined3d_device_begin_scene()

HRESULT CDECL wined3d_device_begin_scene ( struct wined3d_device device)

Definition at line 3602 of file device.c.

3603 {
3604  /* At the moment we have no need for any functionality at the beginning
3605  * of a scene. */
3606  TRACE("device %p.\n", device);
3607 
3608  if (device->inScene)
3609  {
3610  WARN("Already in scene, returning WINED3DERR_INVALIDCALL.\n");
3611  return WINED3DERR_INVALIDCALL;
3612  }
3613  device->inScene = TRUE;
3614  return WINED3D_OK;
3615 }
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
#define TRUE
Definition: types.h:120
#define WARN(fmt,...)
Definition: debug.h:111
Definition: devices.h:37
#define TRACE(s)
Definition: solgame.cpp:4
#define WINED3D_OK
Definition: wined3d.h:37

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

◆ wined3d_device_begin_stateblock()

HRESULT CDECL wined3d_device_begin_stateblock ( struct wined3d_device device)

Definition at line 3555 of file device.c.

3556 {
3557  struct wined3d_stateblock *stateblock;
3558  HRESULT hr;
3559 
3560  TRACE("device %p.\n", device);
3561 
3562  if (device->recording)
3563  return WINED3DERR_INVALIDCALL;
3564 
3566  if (FAILED(hr))
3567  return hr;
3568 
3569  device->recording = stateblock;
3570  device->update_state = &stateblock->state;
3571 
3572  TRACE("Recording stateblock %p.\n", stateblock);
3573 
3574  return WINED3D_OK;
3575 }
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
HRESULT hr
Definition: shlfolder.c:183
struct wined3d_state state
HRESULT CDECL wined3d_stateblock_create(struct wined3d_device *device, enum wined3d_stateblock_type type, struct wined3d_stateblock **stateblock)
Definition: stateblock.c:1372
Definition: devices.h:37
#define TRACE(s)
Definition: solgame.cpp:4
LONG HRESULT
Definition: typedefs.h:77
#define WINED3D_OK
Definition: wined3d.h:37

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

◆ wined3d_device_clear()

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

Definition at line 3633 of file device.c.

3635 {
3636  TRACE("device %p, rect_count %u, rects %p, flags %#x, color %s, depth %.8e, stencil %u.\n",
3637  device, rect_count, rects, flags, debug_color(color), depth, stencil);
3638 
3639  if (!rect_count && rects)
3640  {
3641  WARN("Rects is %p, but rect_count is 0, ignoring clear\n", rects);
3642  return WINED3D_OK;
3643  }
3644 
3646  {
3647  struct wined3d_rendertarget_view *ds = device->fb.depth_stencil;
3648  if (!ds)
3649  {
3650  WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
3651  /* TODO: What about depth stencil buffers without stencil bits? */
3652  return WINED3DERR_INVALIDCALL;
3653  }
3654  else if (flags & WINED3DCLEAR_TARGET)
3655  {
3656  if (ds->width < device->fb.render_targets[0]->width
3657  || ds->height < device->fb.render_targets[0]->height)
3658  {
3659  WARN("Silently ignoring depth and target clear with mismatching sizes\n");
3660  return WINED3D_OK;
3661  }
3662  }
3663  }
3664 
3665  wined3d_cs_emit_clear(device->cs, rect_count, rects, flags, color, depth, stencil);
3666 
3667  return WINED3D_OK;
3668 }
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
void wined3d_cs_emit_clear(struct wined3d_cs *cs, DWORD rect_count, const RECT *rects, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
Definition: cs.c:536
#define WARN(fmt,...)
Definition: debug.h:111
#define ds
Definition: i386-dis.c:434
#define WINED3DCLEAR_STENCIL
Definition: wined3d.h:999
const char * debug_color(const struct wined3d_color *color)
Definition: utils.c:3948
GLint GLfloat GLint stencil
Definition: glext.h:6260
#define WINED3DCLEAR_ZBUFFER
Definition: wined3d.h:998
GLuint color
Definition: glext.h:6243
Definition: devices.h:37
#define TRACE(s)
Definition: solgame.cpp:4
#define WINED3D_OK
Definition: wined3d.h:37
GLbitfield flags
Definition: glext.h:7161
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
#define WINED3DCLEAR_TARGET
Definition: wined3d.h:997

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

◆ wined3d_device_clear_rendertarget_view()

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

Definition at line 4392 of file device.c.

4395 {
4396  struct wined3d_resource *resource;
4397  RECT r;
4398 
4399  TRACE("device %p, view %p, rect %s, flags %#x, color %s, depth %.8e, stencil %u.\n",
4401 
4402  if (!flags)
4403  return WINED3D_OK;
4404 
4405  resource = view->resource;
4406  if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
4407  {
4408  FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type));
4409  return WINED3DERR_INVALIDCALL;
4410  }
4411 
4412  if (view->layer_count > 1)
4413  {
4414  FIXME("Layered clears not implemented.\n");
4415  return WINED3DERR_INVALIDCALL;
4416  }
4417 
4418  if (!rect)
4419  {
4420  SetRect(&r, 0, 0, view->width, view->height);
4421  rect = &r;
4422  }
4423  else
4424  {
4425  struct wined3d_box b = {rect->left, rect->top, rect->right, rect->bottom, 0, 1};
4426  struct wined3d_texture *texture = texture_from_resource(view->resource);
4427  HRESULT hr;
4428 
4430  view->sub_resource_idx % texture->level_count, &b)))
4431  return hr;
4432  }
4433 
4435 
4436  return WINED3D_OK;
4437 }
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
HRESULT hr
Definition: shlfolder.c:183
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
HRESULT wined3d_texture_check_box_dimensions(const struct wined3d_texture *texture, unsigned int level, const struct wined3d_box *box)
Definition: texture.c:1128
int resource
Definition: rdpsnd_sgi.c:44
& rect
Definition: startmenu.cpp:1413
const char * debug_color(const struct wined3d_color *color)
Definition: utils.c:3948
GLint GLfloat GLint stencil
Definition: glext.h:6260
GLuint color
Definition: glext.h:6243
Definition: devices.h:37
#define FIXME(fmt,...)
Definition: debug.h:110
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define TRACE(s)
Definition: solgame.cpp:4
GLenum GLuint texture
Definition: glext.h:6295
LONG HRESULT
Definition: typedefs.h:77
const char * wine_dbgstr_rect(const RECT *rect)
#define WINED3D_OK
Definition: wined3d.h:37
GLbitfield flags
Definition: glext.h:7161
static struct wined3d_texture * texture_from_resource(struct wined3d_resource *resource)
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)
const char * debug_d3dresourcetype(enum wined3d_resource_type resource_type)
Definition: utils.c:4329
void wined3d_cs_emit_clear_rendertarget_view(struct wined3d_cs *cs, struct wined3d_rendertarget_view *view, const RECT *rect, DWORD flags, const struct wined3d_color *color, float depth, DWORD stencil)
Definition: cs.c:574

Referenced by d3d9_device_ColorFill(), and ddraw_surface_blt().

◆ wined3d_device_clear_unordered_access_view_uint()

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

Definition at line 4439 of file device.c.

4441 {
4442  TRACE("device %p, view %p, clear_value %s.\n", device, view, debug_uvec4(clear_value));
4443 
4445 }
Definition: devices.h:37
void wined3d_cs_emit_clear_unordered_access_view_uint(struct wined3d_cs *cs, struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value)
Definition: cs.c:2381
#define TRACE(s)
Definition: solgame.cpp:4
const char * debug_uvec4(const struct wined3d_uvec4 *v)
Definition: utils.c:3964

◆ wined3d_device_copy_resource()

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

Definition at line 4043 of file device.c.

4045 {
4046  struct wined3d_texture *dst_texture, *src_texture;
4047  struct wined3d_box box;
4048  unsigned int i, j;
4049 
4050  TRACE("device %p, dst_resource %p, src_resource %p.\n", device, dst_resource, src_resource);
4051 
4052  if (src_resource == dst_resource)
4053  {
4054  WARN("Source and destination are the same resource.\n");
4055  return;
4056  }
4057 
4058  if (src_resource->type != dst_resource->type)
4059  {
4060  WARN("Resource types (%s / %s) don't match.\n",
4061  debug_d3dresourcetype(dst_resource->type),
4062  debug_d3dresourcetype(src_resource->type));
4063  return;
4064  }
4065 
4066  if (src_resource->width != dst_resource->width
4067  || src_resource->height != dst_resource->height
4068  || src_resource->depth != dst_resource->depth)
4069  {
4070  WARN("Resource dimensions (%ux%ux%u / %ux%ux%u) don't match.\n",
4071  dst_resource->width, dst_resource->height, dst_resource->depth,
4072  src_resource->width, src_resource->height, src_resource->depth);
4073  return;
4074  }
4075 
4076  if (src_resource->format->typeless_id != dst_resource->format->typeless_id
4077  || (!src_resource->format->typeless_id && src_resource->format->id != dst_resource->format->id))
4078  {
4079  WARN("Resource formats %s and %s are incompatible.\n",
4080  debug_d3dformat(dst_resource->format->id),
4081  debug_d3dformat(src_resource->format->id));
4082  return;
4083  }
4084 
4085  if (dst_resource->type == WINED3D_RTYPE_BUFFER)
4086  {
4087  wined3d_box_set(&box, 0, 0, src_resource->size, 1, 0, 1);
4088  wined3d_cs_emit_blt_sub_resource(device->cs, dst_resource, 0, &box,
4089  src_resource, 0, &box, WINED3D_BLT_RAW, NULL, WINED3D_TEXF_POINT);
4090  return;
4091  }
4092 
4093  dst_texture = texture_from_resource(dst_resource);
4094  src_texture = texture_from_resource(src_resource);
4095 
4096  if (src_texture->layer_count != dst_texture->layer_count
4097  || src_texture->level_count != dst_texture->level_count)
4098  {
4099  WARN("Subresource layouts (%ux%u / %ux%u) don't match.\n",
4100  dst_texture->layer_count, dst_texture->level_count,
4101  src_texture->layer_count, src_texture->level_count);
4102  return;
4103  }
4104 
4105  for (i = 0; i < dst_texture->level_count; ++i)
4106  {
4107  wined3d_box_set(&box, 0, 0,
4108  wined3d_texture_get_level_width(dst_texture, i),
4109  wined3d_texture_get_level_height(dst_texture, i),
4110  0, wined3d_texture_get_level_depth(dst_texture, i));
4111  for (j = 0; j < dst_texture->layer_count; ++j)
4112  {
4113  unsigned int idx = j * dst_texture->level_count + i;
4114 
4115  wined3d_cs_emit_blt_sub_resource(device->cs, dst_resource, idx, &box,
4116  src_resource, idx, &box, WINED3D_BLT_RAW, NULL, WINED3D_TEXF_POINT);
4117  }
4118  }
4119 }
enum wined3d_resource_type type
static unsigned int wined3d_texture_get_level_height(const struct wined3d_texture *texture, unsigned int level)
static unsigned int wined3d_texture_get_level_width(const struct wined3d_texture *texture, unsigned int level)
#define WARN(fmt,...)
Definition: debug.h:111
static unsigned int wined3d_texture_get_level_depth(const struct wined3d_texture *texture, unsigned int level)
static void wined3d_box_set(struct wined3d_box *box, unsigned int left, unsigned int top, unsigned int right, unsigned int bottom, unsigned int front, unsigned int back)
Definition: wined3d.h:2789
const struct wined3d_format * format
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define WINED3D_BLT_RAW
Definition: wined3d.h:1366
Definition: devices.h:37
unsigned int idx
Definition: utils.c:41
smooth NULL
Definition: ftsmooth.c:416
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define TRACE(s)
Definition: solgame.cpp:4
static struct wined3d_texture * texture_from_resource(struct wined3d_resource *resource)
const char * debug_d3dresourcetype(enum wined3d_resource_type resource_type)
Definition: utils.c:4329
void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *dst_resource, unsigned int dst_sub_resource_idx, const struct wined3d_box *dst_box, struct wined3d_resource *src_resource, unsigned int src_sub_resource_idx, const struct wined3d_box *src_box, DWORD flags, const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
Definition: cs.c:2172
const char * debug_d3dformat(enum wined3d_format_id format_id)
Definition: utils.c:3980
Definition: palette.c:467

◆ wined3d_device_copy_sub_resource_region()

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

Definition at line 4121 of file device.c.

4125 {
4126  struct wined3d_box dst_box, b;
4127 
4128  TRACE("device %p, dst_resource %p, dst_sub_resource_idx %u, dst_x %u, dst_y %u, dst_z %u, "
4129  "src_resource %p, src_sub_resource_idx %u, src_box %s.\n",
4130  device, dst_resource, dst_sub_resource_idx, dst_x, dst_y, dst_z,
4131  src_resource, src_sub_resource_idx, debug_box(src_box));
4132 
4133  if (src_resource == dst_resource && src_sub_resource_idx == dst_sub_resource_idx)
4134  {
4135  WARN("Source and destination are the same sub-resource.\n");
4136  return WINED3DERR_INVALIDCALL;
4137  }
4138 
4139  if (src_resource->type != dst_resource->type)
4140  {
4141  WARN("Resource types (%s / %s) don't match.\n",
4142  debug_d3dresourcetype(dst_resource->type),
4143  debug_d3dresourcetype(src_resource->type));
4144  return WINED3DERR_INVALIDCALL;
4145  }
4146 
4147  if (src_resource->format->typeless_id != dst_resource->format->typeless_id
4148  || (!src_resource->format->typeless_id && src_resource->format->id != dst_resource->format->id))
4149  {
4150  WARN("Resource formats %s and %s are incompatible.\n",
4151  debug_d3dformat(dst_resource->format->id),
4152  debug_d3dformat(src_resource->format->id));
4153  return WINED3DERR_INVALIDCALL;
4154  }
4155 
4156  if (dst_resource->type == WINED3D_RTYPE_BUFFER)
4157  {
4158  if (dst_sub_resource_idx)
4159  {
4160  WARN("Invalid dst_sub_resource_idx %u.\n", dst_sub_resource_idx);
4161  return WINED3DERR_INVALIDCALL;
4162  }
4163 
4164  if (src_sub_resource_idx)
4165  {
4166  WARN("Invalid src_sub_resource_idx %u.\n", src_sub_resource_idx);
4167  return WINED3DERR_INVALIDCALL;
4168  }
4169 
4170  if (!src_box)
4171  {
4172  unsigned int dst_w;
4173 
4174  dst_w = dst_resource->size - dst_x;
4175  wined3d_box_set(&b, 0, 0, min(src_resource->size, dst_w), 1, 0, 1);
4176  src_box = &b;
4177  }
4178  else if ((src_box->left >= src_box->right
4179  || src_box->top >= src_box->bottom
4180  || src_box->front >= src_box->back))
4181  {
4182  WARN("Invalid box %s specified.\n", debug_box(src_box));
4183  return WINED3DERR_INVALIDCALL;
4184  }
4185 
4186  if (src_box->right > src_resource->size || dst_x >= dst_resource->size
4187  || src_box->right - src_box->left > dst_resource->size - dst_x)
4188  {
4189  WARN("Invalid range specified, dst_offset %u, src_offset %u, size %u.\n",
4190  dst_x, src_box->left, src_box->right - src_box->left);
4191  return WINED3DERR_INVALIDCALL;
4192  }
4193 
4194  wined3d_box_set(&dst_box, dst_x, 0, dst_x + (src_box->right - src_box->left), 1, 0, 1);
4195  }
4196  else if (dst_resource->type == WINED3D_RTYPE_TEXTURE_2D)
4197  {
4198  struct wined3d_texture *dst_texture = texture_from_resource(dst_resource);
4199  struct wined3d_texture *src_texture = texture_from_resource(src_resource);
4200  unsigned int src_level = src_sub_resource_idx % src_texture->level_count;
4201 
4202  if (dst_sub_resource_idx >= dst_texture->level_count * dst_texture->layer_count)
4203  {
4204  WARN("Invalid destination sub-resource %u.\n", dst_sub_resource_idx);
4205  return WINED3DERR_INVALIDCALL;
4206  }
4207 
4208  if (src_sub_resource_idx >= src_texture->level_count * src_texture->layer_count)
4209  {
4210  WARN("Invalid source sub-resource %u.\n", src_sub_resource_idx);
4211  return WINED3DERR_INVALIDCALL;
4212  }
4213 
4214 #if !defined(STAGING_CSMT)
4215  if (dst_texture->sub_resources[dst_sub_resource_idx].map_count)
4216  {
4217  WARN("Destination sub-resource %u is mapped.\n", dst_sub_resource_idx);
4218  return WINED3DERR_INVALIDCALL;
4219  }
4220 
4221  if (src_texture->sub_resources[src_sub_resource_idx].map_count)
4222  {
4223  WARN("Source sub-resource %u is mapped.\n", src_sub_resource_idx);
4224  return WINED3DERR_INVALIDCALL;
4225 #else /* STAGING_CSMT */
4226  if (dst_texture->sub_resources[dst_sub_resource_idx].map_count ||
4227  src_texture->sub_resources[src_sub_resource_idx].map_count)
4228  {
4229  struct wined3d_device *device = dst_texture->resource.device;
4230  device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
4231  if (dst_texture->sub_resources[dst_sub_resource_idx].map_count ||
4232  src_texture->sub_resources[src_sub_resource_idx].map_count)
4233  {
4234  WARN("Destination or source sub-resource is mapped.\n");
4235  return WINEDDERR_SURFACEBUSY;
4236  }
4237 #endif /* STAGING_CSMT */
4238  }
4239 
4240  if (!src_box)
4241  {
4242  unsigned int src_w, src_h, dst_w, dst_h, dst_level;
4243 
4244  src_w = wined3d_texture_get_level_width(src_texture, src_level);
4245  src_h = wined3d_texture_get_level_height(src_texture, src_level);
4246 
4247  dst_level = dst_sub_resource_idx % dst_texture->level_count;
4248  dst_w = wined3d_texture_get_level_width(dst_texture, dst_level) - dst_x;
4249  dst_h = wined3d_texture_get_level_height(dst_texture, dst_level) - dst_y;
4250 
4251  wined3d_box_set(&b, 0, 0, min(src_w, dst_w), min(src_h, dst_h), 0, 1);
4252  src_box = &b;
4253  }
4254  else if (FAILED(wined3d_texture_check_box_dimensions(src_texture, src_level, src_box)))
4255  {
4256  WARN("Invalid source box %s.\n", debug_box(src_box));
4257  return WINED3DERR_INVALIDCALL;
4258  }
4259 
4260  wined3d_box_set(&dst_box, dst_x, dst_y, dst_x + (src_box->right - src_box->left),
4261  dst_y + (src_box->bottom - src_box->top), 0, 1);
4263  dst_sub_resource_idx % dst_texture->level_count, &dst_box)))
4264  {
4265  WARN("Invalid destination box %s.\n", debug_box(&dst_box));
4266  return WINED3DERR_INVALIDCALL;
4267  }
4268  }
4269  else
4270  {
4271  FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(dst_resource->type));
4272  return WINED3DERR_INVALIDCALL;
4273  }
4274 
4275  wined3d_cs_emit_blt_sub_resource(device->cs, dst_resource, dst_sub_resource_idx, &dst_box,
4276  src_resource, src_sub_resource_idx, src_box, WINED3D_BLT_RAW, NULL, WINED3D_TEXF_POINT);
4277 
4278  return WINED3D_OK;
4279 }
enum wined3d_resource_type type
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
static unsigned int wined3d_texture_get_level_height(const struct wined3d_texture *texture, unsigned int level)
UINT left
Definition: wined3d.h:1839
static unsigned int wined3d_texture_get_level_width(const struct wined3d_texture *texture, unsigned int level)
UINT back
Definition: wined3d.h:1844
#define WARN(fmt,...)
Definition: debug.h:111
const char * debug_box(const struct wined3d_box *box)
Definition: utils.c:3939
struct wined3d_resource resource
UINT front
Definition: wined3d.h:1843
UINT top
Definition: wined3d.h:1840
HRESULT wined3d_texture_check_box_dimensions(const struct wined3d_texture *texture, unsigned int level, const struct wined3d_box *box)
Definition: texture.c:1128
static void wined3d_box_set(struct wined3d_box *box, unsigned int left, unsigned int top, unsigned int right, unsigned int bottom, unsigned int front, unsigned int back)
Definition: wined3d.h:2789
const struct wined3d_format * format
#define WINED3D_BLT_RAW
Definition: wined3d.h:1366
Definition: devices.h:37
#define FIXME(fmt,...)
Definition: debug.h:110
smooth NULL
Definition: ftsmooth.c:416
#define b
Definition: ke_i.h:79
UINT right
Definition: wined3d.h:1841
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define TRACE(s)
Definition: solgame.cpp:4
#define WINED3D_OK
Definition: wined3d.h:37
UINT bottom
Definition: wined3d.h:1842
static struct wined3d_texture * texture_from_resource(struct wined3d_resource *resource)
struct wined3d_texture::wined3d_texture_sub_resource sub_resources[1]
#define min(a, b)
Definition: monoChain.cc:55
const char * debug_d3dresourcetype(enum wined3d_resource_type resource_type)
Definition: utils.c:4329
#define WINEDDERR_SURFACEBUSY
Definition: wined3d.h:51
void wined3d_cs_emit_blt_sub_resource(struct wined3d_cs *cs, struct wined3d_resource *dst_resource, unsigned int dst_sub_resource_idx, const struct wined3d_box *dst_box, struct wined3d_resource *src_resource, unsigned int src_sub_resource_idx, const struct wined3d_box *src_box, DWORD flags, const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
Definition: cs.c:2172
const char * debug_d3dformat(enum wined3d_format_id format_id)
Definition: utils.c:3980

Referenced by d3d9_device_UpdateSurface().

◆ wined3d_device_copy_uav_counter()

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

Definition at line 4028 of file device.c.

4030 {
4031  TRACE("device %p, dst_buffer %p, offset %u, uav %p.\n",
4032  device, dst_buffer, offset, uav);
4033 
4034  if (offset + sizeof(GLuint) > dst_buffer->resource.size)
4035  {
4036  WARN("Offset %u too large.\n", offset);
4037  return;
4038  }
4039 
4040  wined3d_cs_emit_copy_uav_counter(device->cs, dst_buffer, offset, uav);
4041 }
void wined3d_cs_emit_copy_uav_counter(struct wined3d_cs *cs, struct wined3d_buffer *dst_buffer, unsigned int offset, struct wined3d_unordered_access_view *uav)
Definition: cs.c:2410
#define WARN(fmt,...)
Definition: debug.h:111
GLintptr offset
Definition: glext.h:5920
struct wined3d_resource resource
Definition: devices.h:37
#define TRACE(s)
Definition: solgame.cpp:4
unsigned int GLuint
Definition: gl.h:159

◆ wined3d_device_create_cursor_texture()

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

Definition at line 4544 of file device.c.

4546 {
4547  unsigned int texture_level = sub_resource_idx % cursor_image->level_count;
4549  struct wined3d_resource_desc desc;
4550  struct wined3d_map_desc map_desc;
4551  struct wined3d_texture *texture;
4552  HRESULT hr;
4553 
4554  if (FAILED(wined3d_resource_map(&cursor_image->resource, sub_resource_idx, &map_desc, NULL, WINED3D_MAP_READ)))
4555  {
4556  ERR("Failed to map source texture.\n");
4557  return NULL;
4558  }
4559 
4560  data.data = map_desc.data;
4561  data.row_pitch = map_desc.row_pitch;
4562  data.slice_pitch = map_desc.slice_pitch;
4563 
4564  desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
4566  desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
4567  desc.multisample_quality = 0;
4568  desc.usage = WINED3DUSAGE_DYNAMIC;
4570  desc.width = wined3d_texture_get_level_width(cursor_image, texture_level);
4571  desc.height = wined3d_texture_get_level_height(cursor_image, texture_level);
4572  desc.depth = 1;
4573  desc.size = 0;
4574 
4577  wined3d_resource_unmap(&cursor_image->resource, sub_resource_idx);
4578  if (FAILED(hr))
4579  {
4580  ERR("Failed to create cursor texture.\n");
4581  return NULL;
4582  }
4583 
4584  return texture;
4585 }
static unsigned int wined3d_texture_get_level_height(const struct wined3d_texture *texture, unsigned int level)
HRESULT hr
Definition: shlfolder.c:183
static unsigned int wined3d_texture_get_level_width(const struct wined3d_texture *texture, unsigned int level)
#define WINED3DUSAGE_DYNAMIC
Definition: wined3d.h:907
HRESULT CDECL wined3d_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx)
Definition: resource.c:382
struct wined3d_resource resource
HRESULT CDECL wined3d_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx, struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags)
Definition: resource.c:344
Definition: devices.h:37
static const WCHAR desc[]
Definition: protectdata.c:36
smooth NULL
Definition: ftsmooth.c:416
#define WINED3D_MAP_READ
Definition: wined3d.h:939
GLenum GLuint texture
Definition: glext.h:6295
LONG HRESULT
Definition: typedefs.h:77
GLint