ReactOS 0.4.15-dev-6067-g0b695a6
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{
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 ERR(fmt,...)
Definition: debug.h:110
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define FAILED(hr)
Definition: intsafe.h:51
static const WCHAR desc[]
Definition: protectdata.c:36
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
#define memset(x, y, z)
Definition: compat.h:39
HRESULT hr
Definition: shlfolder.c:183
Definition: devices.h:37
const struct wined3d_parent_ops wined3d_null_parent_ops
Definition: directx.c:6815
@ WINED3D_TEXF_NONE
Definition: wined3d.h:685
@ WINED3D_TEXF_POINT
Definition: wined3d.h:686
@ WINED3D_TEXF_LINEAR
Definition: wined3d.h:687
@ WINED3D_TADDRESS_WRAP
Definition: wined3d.h:639
@ WINED3D_TADDRESS_CLAMP
Definition: wined3d.h:641
@ WINED3D_CMP_NEVER
Definition: wined3d.h:452

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
695 {
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
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 ARRAY_SIZE(A)
Definition: main.h:33
#define WARN(fmt,...)
Definition: debug.h:112
void context_active_texture(struct wined3d_context *context, const struct wined3d_gl_info *gl_info, unsigned int unit)
Definition: context.c:2717
void context_bind_dummy_textures(const struct wined3d_device *device, const struct wined3d_context *context)
Definition: context.c:1764
unsigned long DWORD
Definition: ntddk_ex.h:95
#define GL_TRUE
Definition: gl.h:174
#define GL_TEXTURE_CUBE_MAP
Definition: gl.h:1788
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
Definition: gl.h:1795
#define GL_RGBA8
Definition: gl.h:762
unsigned int GLuint
Definition: gl.h:159
#define GL_TEXTURE_3D
Definition: gl.h:1515
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_RGBA
Definition: gl.h:503
#define GL_TEXTURE_CUBE_MAP_POSITIVE_X
Definition: gl.h:1790
#define GL_UNSIGNED_INT_8_8_8_8
Definition: gl.h:1494
#define GL_TEXTURE_2D
Definition: gl.h:645
#define GL_TEXTURE_1D
Definition: gl.h:644
GLuint buffer
Definition: glext.h:5915
GLuint color
Definition: glext.h:6243
const GLuint * textures
Definition: glext.h:8098
#define GL_TEXTURE_BUFFER
Definition: glext.h:748
#define GL_TEXTURE_1D_ARRAY
Definition: glext.h:533
#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY
Definition: glext.h:1941
#define GL_TEXTURE_2D_MULTISAMPLE
Definition: glext.h:1939
#define GL_STATIC_DRAW
Definition: glext.h:350
#define GL_TEXTURE_RECTANGLE_ARB
Definition: glext.h:1614
#define GL_TEXTURE_CUBE_MAP_ARRAY
Definition: glext.h:920
#define GL_TEXTURE_2D_ARRAY
Definition: glext.h:535
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 TRACE(s)
Definition: solgame.cpp:4
Definition: http.c:7252
BOOL supported[WINED3D_GL_EXT_COUNT]
struct opengl_funcs gl_ops
#define WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR
Definition: wined3d.h:1325
@ ARB_TEXTURE_BUFFER_OBJECT
Definition: wined3d_gl.h:108
@ ARB_TEXTURE_CUBE_MAP
Definition: wined3d_gl.h:113
@ ARB_CLEAR_TEXTURE
Definition: wined3d_gl.h:48
@ EXT_TEXTURE3D
Definition: wined3d_gl.h:171
@ ARB_TEXTURE_MULTISAMPLE
Definition: wined3d_gl.h:122
@ ARB_TEXTURE_RECTANGLE
Definition: wined3d_gl.h:125
@ EXT_TEXTURE_ARRAY
Definition: wined3d_gl.h:172
@ ARB_TEXTURE_CUBE_MAP_ARRAY
Definition: wined3d_gl.h:114
#define GL_EXTCALL(f)
#define checkGLcall(A)

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:
108
109 case GL_LINES:
110 return WINED3D_PT_LINELIST;
111
112 case GL_LINE_STRIP:
114
115 case GL_TRIANGLES:
117
120
121 case GL_TRIANGLE_FAN:
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:
143 }
144}
#define FIXME(fmt,...)
Definition: debug.h:111
const char * debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type)
Definition: utils.c:4346
#define GL_TRIANGLE_FAN
Definition: gl.h:196
#define GL_LINE_STRIP
Definition: gl.h:193
#define GL_LINES
Definition: gl.h:191
#define GL_TRIANGLES
Definition: gl.h:194
#define GL_POINTS
Definition: gl.h:190
#define GL_TRIANGLE_STRIP
Definition: gl.h:195
#define GL_TRIANGLE_STRIP_ADJACENCY_ARB
Definition: glext.h:1765
#define GL_LINE_STRIP_ADJACENCY_ARB
Definition: glext.h:1763
#define GL_LINES_ADJACENCY_ARB
Definition: glext.h:1762
#define GL_TRIANGLES_ADJACENCY_ARB
Definition: glext.h:1764
#define GL_PATCHES
Definition: glext.h:2090
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
@ WINED3D_PT_LINESTRIP_ADJ
Definition: wined3d.h:79
@ WINED3D_PT_LINELIST
Definition: wined3d.h:73
@ WINED3D_PT_UNDEFINED
Definition: wined3d.h:71
@ WINED3D_PT_PATCH
Definition: wined3d.h:82
@ WINED3D_PT_POINTLIST
Definition: wined3d.h:72
@ WINED3D_PT_TRIANGLELIST_ADJ
Definition: wined3d.h:80
@ WINED3D_PT_LINELIST_ADJ
Definition: wined3d.h:78
@ WINED3D_PT_TRIANGLESTRIP_ADJ
Definition: wined3d.h:81
@ WINED3D_PT_TRIANGLESTRIP
Definition: wined3d.h:76
@ WINED3D_PT_LINESTRIP
Definition: wined3d.h:74
@ WINED3D_PT_TRIANGLELIST
Definition: wined3d.h:75
@ WINED3D_PT_TRIANGLEFAN
Definition: wined3d.h:77

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}
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
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
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}

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;
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
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]
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]
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]
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}
static int state
Definition: maze.c:121
#define U(x)
Definition: wordpad.c:45
struct wined3d_context * context_acquire(const struct wined3d_device *device, struct wined3d_texture *texture, unsigned int sub_resource_idx)
Definition: context.c:4242
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_invalidate_state(struct wined3d_context *context, DWORD state)
Definition: context.c:1652
void context_release(struct wined3d_context *context)
Definition: context.c:1571
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
const float wined3d_srgb_const0[]
Definition: shader.c:36
const float wined3d_srgb_const1[]
Definition: shader.c:38
BOOL wined3d_texture_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location)
Definition: texture.c:229
void wined3d_texture_invalidate_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, DWORD location)
Definition: texture.c:159
struct wined3d_texture *__cdecl wined3d_texture_from_resource(struct wined3d_resource *resource)
Definition: texture.c:2210
BOOL wined3d_texture_prepare_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location)
Definition: texture.c:1605
void wined3d_texture_validate_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, DWORD location)
Definition: texture.c:135
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
unsigned int BOOL
Definition: ntddk_ex.h:94
double pow(double x, double y)
Definition: freeldr.c:112
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
#define GL_COLOR_BUFFER_BIT
Definition: gl.h:716
unsigned int GLbitfield
Definition: gl.h:152
#define GL_STENCIL_BUFFER_BIT
Definition: gl.h:712
#define GL_DEPTH_BUFFER_BIT
Definition: gl.h:710
GLenum GLuint texture
Definition: glext.h:6295
#define GL_STENCIL_TEST_TWO_SIDE_EXT
Definition: glext.h:4210
GLbitfield flags
Definition: glext.h:7161
GLint GLfloat GLint stencil
Definition: glext.h:6260
GLenum target
Definition: glext.h:7315
#define ds
Definition: i386-dis.c:443
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
static __inline const char * wine_dbgstr_rect(const RECT *rect)
Definition: debug.h:219
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
const struct wined3d_gl_info * gl_info
struct wined3d_rendertarget_view * depth_stencil
struct wined3d_rendertarget_view * render_targets[MAX_RENDER_TARGET_VIEWS]
struct wined3d_resource * resource
const struct wined3d_format * format
struct wined3d_texture * container
#define max(a, b)
Definition: svc.c:63
#define WINED3DCLEAR_TARGET
Definition: wined3d.h:997
@ WINED3D_RS_ZWRITEENABLE
Definition: wined3d.h:276
@ WINED3D_RS_TWOSIDEDSTENCILMODE
Definition: wined3d.h:368
@ WINED3D_RS_STENCILWRITEMASK
Definition: wined3d.h:313
@ WINED3D_RTYPE_BUFFER
Definition: wined3d.h:698
@ WINED3DFMT_NULL
Definition: wined3d.h:255
#define WINED3DCLEAR_STENCIL
Definition: wined3d.h:999
#define WINED3DCLEAR_ZBUFFER
Definition: wined3d.h:998
static enum wined3d_render_state WINED3D_RS_COLORWRITE(int index)
Definition: wined3d.h:400
@ EXT_STENCIL_TWO_SIDE
Definition: wined3d_gl.h:169
@ ARB_FRAMEBUFFER_SRGB
Definition: wined3d_gl.h:74
static unsigned int wined3d_texture_get_level_pow2_height(const struct wined3d_texture *texture, unsigned int level)
static struct wined3d_surface * wined3d_rendertarget_view_get_surface(const struct wined3d_rendertarget_view *view)
static unsigned int wined3d_texture_get_level_pow2_width(const struct wined3d_texture *texture, unsigned int level)
#define MAX_RENDER_TARGETS
static BOOL needs_srgb_write(const struct wined3d_context *context, const struct wined3d_state *state, const struct wined3d_fb_state *fb)
#define WINED3D_LOCATION_DRAWABLE
#define STATE_RENDER(a)
static struct wined3d_texture * texture_from_resource(struct wined3d_resource *resource)
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)

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}
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:70

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}
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
#define memmove(s1, s2, n)
Definition: mkisofs.h:881

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}
GLuint sampler
Definition: glext.h:7283
uint32_t entry
Definition: isohybrid.c:63
#define WINE_RB_ENTRY_VALUE(element, type, field)
Definition: rbtree.h:31

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];
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
5253err:
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}
static void list_init(struct list_entry *head)
Definition: list.h:51
struct wined3d_cs * wined3d_cs_create(struct wined3d_device *device)
Definition: cs.c:2828
#define E_FAIL
Definition: ddrawi.h:102
device_type
void state_init(void *ipp)
Definition: dhclient.c:210
static int wined3d_sampler_compare(const void *key, const struct wine_rb_entry *entry)
Definition: device.c:5188
const struct StateEntryTemplate misc_state_template[]
Definition: state.c:5100
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:6142
return adapter
#define err(...)
static void wine_rb_destroy(struct wine_rb_tree *tree, wine_rb_traverse_func_t *callback, void *context)
Definition: rbtree.h:198
static void wine_rb_init(struct wine_rb_tree *tree, wine_rb_compare_func_t compare)
Definition: rbtree.h:179
const struct StateEntryTemplate * states
const struct StateEntryTemplate * vp_states
UINT adapter_count
struct wined3d_adapter adapters[1]
ULONG CDECL wined3d_decref(struct wined3d *wined3d)
Definition: directx.c:465
ULONG CDECL wined3d_incref(struct wined3d *wined3d)
Definition: directx.c:456
void state_cleanup(struct wined3d_state *state)
Definition: stateblock.c:528
#define WINED3D_OK
Definition: wined3d.h:37
#define WINED3D_STATE_INIT_DEFAULT

◆ 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)
973
974 wined3d_device_set_depth_stencil_view(device, ds_enable ? device->auto_depth_stencil_view : NULL);
975}
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
void CDECL wined3d_device_set_depth_stencil_view(struct wined3d_device *device, struct wined3d_rendertarget_view *view)
Definition: device.c:4524
struct wined3d_swapchain_desc desc

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
5272
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}
void context_invalidate_compute_state(struct wined3d_context *context, DWORD state_id)
Definition: context.c:1642
unsigned int idx
Definition: utils.c:41
#define CHAR_BIT
Definition: urlcache.c:62
#define shift
Definition: input.c:1755
#define STATE_IS_COMPUTE(a)
static void wined3d_from_cs(const struct wined3d_cs *cs)
static BOOL isStateDirty(const struct wined3d_context *context, DWORD state)
unsigned char BYTE
Definition: xxhash.c:193

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}

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;
569 desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
570 desc.multisample_quality = 0;
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
598out:
599 if (dcb) DeleteDC(dcb);
600 if (hbm) DeleteObject(hbm);
601}
HRESULT CDECL wined3d_texture_get_dc(struct wined3d_texture *texture, unsigned int sub_resource_idx, HDC *dc)
Definition: texture.c:3623
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
ULONG CDECL wined3d_texture_decref(struct wined3d_texture *texture)
Definition: texture.c:1023
HRESULT CDECL wined3d_texture_release_dc(struct wined3d_texture *texture, unsigned int sub_resource_idx, HDC dc)
Definition: texture.c:3671
HRESULT CDECL wined3d_texture_set_color_key(struct wined3d_texture *texture, DWORD flags, const struct wined3d_color_key *color_key)
Definition: texture.c:1235
static VOID NTAPI BitBlt(_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_reads_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG BitsPerPixel, _In_ ULONG Delta)
Definition: common.c:49
pKey DeleteObject()
const char * filename
Definition: ioapi.h:137
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
_In_ HBITMAP hbm
Definition: ntgdi.h:2776
static FILE * out
Definition: regtests2xml.c:44
#define ERR_(ch,...)
Definition: debug.h:156
const char int int int static __inline const char * wine_dbgstr_a(const char *s)
Definition: debug.h:187
Definition: bl.h:1331
@ WINED3D_MULTISAMPLE_NONE
Definition: wined3d.h:554
#define WINED3D_RESOURCE_ACCESS_GPU
Definition: wined3d.h:55
@ WINED3D_RTYPE_TEXTURE_2D
Definition: wined3d.h:700
#define WINED3D_CKEY_SRC_BLT
Definition: wined3d.h:1336
@ WINED3DFMT_B5G6R5_UNORM
Definition: wined3d.h:221
#define WINED3D_TEXTURE_CREATE_MAPPABLE
Definition: wined3d.h:1558
#define WINED3DUSAGE_DYNAMIC
Definition: wined3d.h:907
#define WINED3D_TEXTURE_CREATE_GET_DC
Definition: wined3d.h:1561
int WINAPI GetObjectA(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define SRCCOPY
Definition: wingdi.h:333
BOOL WINAPI DeleteDC(_In_ HDC)
#define IMAGE_BITMAP
Definition: winuser.h:211
#define LR_LOADFROMFILE
Definition: winuser.h:1086
#define LR_CREATEDIBSECTION
Definition: winuser.h:1092
HANDLE WINAPI LoadImageA(_In_opt_ HINSTANCE hInst, _In_ LPCSTR name, _In_ UINT type, _In_ int cx, _In_ int cy, _In_ UINT fuLoad)
Definition: cursoricon.c:2147

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++)
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}
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
static UINT WPARAM wparam
Definition: combo.c:716
static UINT WPARAM LPARAM lparam
Definition: combo.c:716
static IHTMLWindow2 * window
Definition: events.c:77
static HANDLE proc()
Definition: pdb.c:34
Definition: tftpd.h:60
void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activate)
Definition: swapchain.c:1149
#define WINED3D_HANDLE_RESTORE
Definition: wined3d.h:1321
void wined3d_unregister_window(HWND window)
Definition: wined3d_main.c:470
#define WM_SYSCOMMAND
Definition: winuser.h:1731
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
LRESULT WINAPI DefWindowProcA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define WM_ACTIVATEAPP
Definition: winuser.h:1622
#define WM_DESTROY
Definition: winuser.h:1599
LRESULT WINAPI CallWindowProcW(_In_ WNDPROC, _In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define SC_RESTORE
Definition: winuser.h:2588
LRESULT WINAPI CallWindowProcA(_In_ WNDPROC, _In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by wined3d_wndproc().

◆ device_resource_add()

void device_resource_add ( struct wined3d_device device,
struct wined3d_resource resource 
)

Definition at line 5081 of file device.c.

5082{
5083 TRACE("device %p, resource %p.\n", device, resource);
5084
5086
5087 list_add_head(&device->resources, &resource->resource_list_entry);
5088}
static void list_add_head(struct list_entry *head, struct list_entry *entry)
Definition: list.h:76
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
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}
static void device_resource_remove(struct wined3d_device *device, struct wined3d_resource *resource)
Definition: device.c:5090
const char * debug_d3dresourcetype(enum wined3d_resource_type resource_type)
Definition: utils.c:4329
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
wined3d_resource_type
Definition: wined3d.h:696
@ WINED3D_RTYPE_TEXTURE_1D
Definition: wined3d.h:699
@ WINED3D_RTYPE_TEXTURE_3D
Definition: wined3d.h:701
#define MAX_STREAMS
#define MAX_COMBINED_SAMPLERS
static struct wined3d_buffer * buffer_from_resource(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}
static void list_remove(struct list_entry *entry)
Definition: list.h:90

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}
Arabic default style
Definition: afstyles.h:94
#define WS_CAPTION
Definition: pedump.c:624
#define WS_SYSMENU
Definition: pedump.c:629
#define WS_POPUP
Definition: pedump.c:616
#define WS_THICKFRAME
Definition: pedump.c:630

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
93 return GL_PATCHES;
94
95 default:
96 FIXME("Unhandled primitive type %s.\n", debug_d3dprimitivetype(primitive_type));
98 return ~0u;
99 }
100}

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 GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
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)

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");
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
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}
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) DECLSPEC_HIDDEN
Definition: utils.c:923
void multiply_matrix(D3DMATRIX *dst, const D3DMATRIX *src1, const D3DMATRIX *src2) DECLSPEC_HIDDEN
Definition: utils.c:1173
#define GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_num)
#define copy_and_next(dest, src, size)
Definition: device.c:3069
void CDECL wined3d_device_get_viewport(const struct wined3d_device *device, struct wined3d_viewport *viewport)
Definition: device.c:1950
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
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
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLfloat GLfloat p
Definition: glext.h:8902
GLdouble GLdouble z
Definition: glext.h:5874
static const MAT2 mat
Definition: font.c:66
static char * dest
Definition: rtl.c:135
static void stream_info(IStream *stream, HGLOBAL *hmem, int *size, int *pos)
static float(__cdecl *square_half_float)(float x
#define DWORD
Definition: nt_native.h:44
@ normal
Definition: optimize.h:166
Definition: palette.c:468
#define WINED3DFVF_PSIZE
Definition: wined3d.h:969
#define WINED3D_TS_WORLD_MATRIX(index)
Definition: wined3d.h:664
#define WINED3DFVF_SPECULAR
Definition: wined3d.h:971
@ WINED3D_RS_CLIPPING
Definition: wined3d.h:323
#define WINED3DFVF_TEXCOUNT_SHIFT
Definition: wined3d.h:973
#define WINED3DFVF_DIFFUSE
Definition: wined3d.h:970
#define WINED3DFVF_POSITION_MASK
Definition: wined3d.h:959
#define WINED3DFVF_XYZ
Definition: wined3d.h:960
#define WINED3DFVF_TEXCOUNT_MASK
Definition: wined3d.h:972
#define WINED3DFVF_XYZRHW
Definition: wined3d.h:961
#define WINED3DFVF_NORMAL
Definition: wined3d.h:968
#define WINED3D_MAP_WRITE
Definition: wined3d.h:938
@ WINED3D_TS_PROJECTION
Definition: wined3d.h:649
@ WINED3D_TS_VIEW
Definition: wined3d.h:648
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
@ WINED3D_FFP_SPECULAR
@ WINED3D_FFP_POSITION
@ WINED3D_FFP_NORMAL
@ WINED3D_FFP_DIFFUSE
@ WINED3D_FFP_TEXCOORD0
#define eps

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}
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
unsigned int format_flags
const struct wined3d_format * format
struct wined3d_resource resource
#define WINED3DFMT_FLAG_DEPTH

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 InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
BOOL wined3d_register_window(HWND window, struct wined3d_device *device)
Definition: wined3d_main.c:432
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
#define SWP_NOMOVE
Definition: winuser.h:1234
#define SWP_NOSIZE
Definition: winuser.h:1235

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");
3612 }
3613 device->inScene = TRUE;
3614 return WINED3D_OK;
3615}

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)
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}
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
@ WINED3D_SBT_RECORDED
Definition: wined3d.h:770

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? */
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}
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
const char * debug_color(const struct wined3d_color *color)
Definition: utils.c:3948

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;
4407 {
4408 FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type));
4410 }
4411
4412 if (view->layer_count > 1)
4413 {
4414 FIXME("Layered clears not implemented.\n");
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};
4427 HRESULT hr;
4428
4430 view->sub_resource_idx % texture->level_count, &b)))
4431 return hr;
4432 }
4433
4435
4436 return WINED3D_OK;
4437}
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
HRESULT wined3d_texture_check_box_dimensions(const struct wined3d_texture *texture, unsigned int level, const struct wined3d_box *box)
Definition: texture.c:1128
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define resource
Definition: kernel32.h:9
& rect
Definition: startmenu.cpp:1413
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)

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}
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
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}
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
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
enum wined3d_resource_type type
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
#define WINED3D_BLT_RAW
Definition: wined3d.h:1366
static unsigned int wined3d_texture_get_level_depth(const struct wined3d_texture *texture, unsigned int level)

◆ 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");
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));
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));
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);
4162 }
4163
4164 if (src_sub_resource_idx)
4165 {
4166 WARN("Invalid src_sub_resource_idx %u.\n", src_sub_resource_idx);
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));
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);
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);
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);
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);
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);
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));
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));
4267 }
4268 }
4269 else
4270 {
4271 FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(dst_resource->type));
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}
const char * debug_box(const struct wined3d_box *box)
Definition: utils.c:3939
#define b
Definition: ke_i.h:79
UINT left
Definition: wined3d.h:1839
UINT right
Definition: wined3d.h:1841
UINT back
Definition: wined3d.h:1844
UINT front
Definition: wined3d.h:1843
UINT bottom
Definition: wined3d.h:1842
UINT top
Definition: wined3d.h:1840
struct wined3d_texture::wined3d_texture_sub_resource sub_resources[1]
#define WINEDDERR_SURFACEBUSY
Definition: wined3d.h:51
@ WINED3D_CS_QUEUE_DEFAULT

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
GLintptr offset
Definition: glext.h:5920
struct wined3d_resource resource

◆ 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;
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}
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define WINED3D_MAP_READ
Definition: wined3d.h:939
@ WINED3DFMT_B8G8R8A8_UNORM
Definition: wined3d.h:223

Referenced by wined3d_device_set_cursor_properties().

◆ wined3d_device_create_primary_opengl_context()

static HRESULT wined3d_device_create_primary_opengl_context ( struct wined3d_device device)
static

Definition at line 1051 of file device.c.

1052{
1054 device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
1055 if (!device->swapchains[0]->num_contexts)
1056 return E_FAIL;
1057
1058 return WINED3D_OK;
1059}
void wined3d_cs_init_object(struct wined3d_cs *cs, void(*callback)(void *object), void *object)
Definition: cs.c:1890
static void wined3d_device_create_primary_opengl_context_cs(void *object)
Definition: device.c:1017

Referenced by wined3d_device_init_3d(), and wined3d_device_reset().

◆ wined3d_device_create_primary_opengl_context_cs()

static void wined3d_device_create_primary_opengl_context_cs ( void object)
static

Definition at line 1017 of file device.c.

1018{
1019 struct wined3d_device *device = object;
1020 struct wined3d_swapchain *swapchain;
1021 struct wined3d_context *context;
1022 struct wined3d_texture *target;
1023 HRESULT hr;
1024
1025 if (FAILED(hr = device->shader_backend->shader_alloc_private(device,
1026 device->adapter->vertex_pipe, device->adapter->fragment_pipe)))
1027 {
1028 ERR("Failed to allocate shader private data, hr %#x.\n", hr);
1029 return;
1030 }
1031
1032 if (!(device->blitter = wined3d_cpu_blitter_create()))
1033 {
1034 ERR("Failed to create CPU blitter.\n");
1035 device->shader_backend->shader_free_private(device);
1036 return;
1037 }
1038 wined3d_ffp_blitter_create(&device->blitter, &device->adapter->gl_info);
1040 wined3d_fbo_blitter_create(&device->blitter, &device->adapter->gl_info);
1041 wined3d_raw_blitter_create(&device->blitter, &device->adapter->gl_info);
1042
1043 swapchain = device->swapchains[0];
1044 target = swapchain->back_buffers ? swapchain->back_buffers[0] : swapchain->front_buffer;
1049}
void wined3d_arbfp_blitter_create(struct wined3d_blitter **next, const struct wined3d_device *device)
static void create_dummy_textures(struct wined3d_device *device, struct wined3d_context *context)
Definition: device.c:604
static void create_default_samplers(struct wined3d_device *device, struct wined3d_context *context)
Definition: device.c:780
void wined3d_fbo_blitter_create(struct wined3d_blitter **next, const struct wined3d_gl_info *gl_info)
Definition: surface.c:2734
struct wined3d_blitter * wined3d_cpu_blitter_create(void)
Definition: surface.c:3983
void wined3d_raw_blitter_create(struct wined3d_blitter **next, const struct wined3d_gl_info *gl_info)
Definition: surface.c:2871
void wined3d_ffp_blitter_create(struct wined3d_blitter **next, const struct wined3d_gl_info *gl_info)
Definition: surface.c:3170
struct wined3d_swapchain * swapchain

Referenced by wined3d_device_create_primary_opengl_context().

◆ wined3d_device_decref()

ULONG CDECL wined3d_device_decref ( struct wined3d_device device)

Definition at line 472 of file device.c.

473{
474 ULONG refcount = InterlockedDecrement(&device->ref);
475
476 TRACE("%p decreasing refcount to %u.\n", device, refcount);
477
478 if (!refcount)
479 {
480 UINT i;
481
483
484 if (device->recording && wined3d_stateblock_decref(device->recording))
485 ERR("Something's still holding the recording stateblock.\n");
486 device->recording = NULL;
487
488 state_cleanup(&device->state);
489
490 for (i = 0; i < ARRAY_SIZE(device->multistate_funcs); ++i)
491 {
492 heap_free(device->multistate_funcs[i]);
493 device->multistate_funcs[i] = NULL;
494 }
495
496 if (!list_empty(&device->resources))
497 {
499
500 ERR("Device released with resources still bound.\n");
501
503 {
504 ERR("Leftover resource %p with type %s (%#x).\n",
506 }
507 }
508
509 if (device->contexts)
510 ERR("Context array not freed!\n");
511 if (device->hardwareCursor)
512 DestroyCursor(device->hardwareCursor);
513 device->hardwareCursor = 0;
514
516
517 wined3d_decref(device->wined3d);
518 device->wined3d = NULL;
520 TRACE("Freed device %p.\n", device);
521 }
522
523 return refcount;
524}
#define InterlockedDecrement
Definition: armddk.h:52
static int list_empty(struct list_entry *head)
Definition: list.h:58
void wined3d_cs_destroy(struct wined3d_cs *cs)
Definition: cs.c:2885
static void device_leftover_sampler(struct wine_rb_entry *entry, void *context)
Definition: device.c:465
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
struct list resource_list_entry
uint32_t ULONG
Definition: typedefs.h:59
ULONG CDECL wined3d_stateblock_decref(struct wined3d_stateblock *stateblock)
Definition: stateblock.c:552
BOOL WINAPI DestroyCursor(_In_ HCURSOR)
Definition: cursoricon.c:2658

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

◆ wined3d_device_delete_opengl_contexts()

static void wined3d_device_delete_opengl_contexts ( struct wined3d_device device)
static

Definition at line 1011 of file device.c.

1012{
1014 device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
1015}
void wined3d_cs_destroy_object(struct wined3d_cs *cs, void(*callback)(void *object), void *object)
Definition: cs.c:1885
static void wined3d_device_delete_opengl_contexts_cs(void *object)
Definition: device.c:977

Referenced by wined3d_device_reset(), and wined3d_device_uninit_3d().

◆ wined3d_device_delete_opengl_contexts_cs()

static void wined3d_device_delete_opengl_contexts_cs ( void object)
static

Definition at line 977 of file device.c.

978{
980 struct wined3d_device *device = object;
981 struct wined3d_context *context;
982 struct wined3d_shader *shader;
983
984 LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
985 {
986 TRACE("Unloading resource %p.\n", resource);
988 }
989
991 {
992 device->shader_backend->shader_destroy(shader);
993 }
994
996 device->blitter->ops->blitter_destroy(device->blitter, context);
997 device->shader_backend->shader_free_private(device);
1001
1002 while (device->context_count)
1003 {
1004 if (device->contexts[0]->swapchain)
1005 swapchain_destroy_contexts(device->contexts[0]->swapchain);
1006 else
1007 context_destroy(device, device->contexts[0]);
1008 }
1009}
void wined3d_cs_emit_unload_resource(struct wined3d_cs *cs, struct wined3d_resource *resource)
Definition: cs.c:1978
void context_destroy(struct wined3d_device *device, struct wined3d_context *context)
Definition: context.c:2290
static void destroy_default_samplers(struct wined3d_device *device, struct wined3d_context *context)
Definition: device.c:828
static void destroy_dummy_textures(struct wined3d_device *device, struct wined3d_context *context)
Definition: device.c:739
GLuint shader
Definition: glext.h:6030
const char cursor[]
Definition: icontest.c:13
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
struct list shader_list_entry
void swapchain_destroy_contexts(struct wined3d_swapchain *swapchain)
Definition: swapchain.c:1079

Referenced by wined3d_device_delete_opengl_contexts().

◆ wined3d_device_dispatch_compute()

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

Definition at line 3700 of file device.c.

3702{
3703 TRACE("device %p, group_count_x %u, group_count_y %u, group_count_z %u.\n",
3704 device, group_count_x, group_count_y, group_count_z);
3705
3706 wined3d_cs_emit_dispatch(device->cs, group_count_x, group_count_y, group_count_z);
3707}
void wined3d_cs_emit_dispatch(struct wined3d_cs *cs, unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z)
Definition: cs.c:738

◆ wined3d_device_dispatch_compute_indirect()

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

Definition at line 3709 of file device.c.

3711{
3712 TRACE("device %p, buffer %p, offset %u.\n", device, buffer, offset);
3713
3715}
void wined3d_cs_emit_dispatch_indirect(struct wined3d_cs *cs, struct wined3d_buffer *buffer, unsigned int offset)
Definition: cs.c:756

◆ wined3d_device_draw_indexed_primitive()

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

Definition at line 3769 of file device.c.

3770{
3771 TRACE("device %p, start_idx %u, index_count %u.\n", device, start_idx, index_count);
3772
3773 if (!device->state.index_buffer)
3774 {
3775 /* D3D9 returns D3DERR_INVALIDCALL when DrawIndexedPrimitive is called
3776 * without an index buffer set. (The first time at least...)
3777 * D3D8 simply dies, but I doubt it can do much harm to return
3778 * D3DERR_INVALIDCALL there as well. */
3779 WARN("Called without a valid index buffer set, returning WINED3DERR_INVALIDCALL.\n");
3781 }
3782
3783 wined3d_cs_emit_draw(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
3784 device->state.base_vertex_index, start_idx, index_count, 0, 0, TRUE);
3785
3786 return WINED3D_OK;
3787}
void wined3d_cs_emit_draw(struct wined3d_cs *cs, GLenum primitive_type, unsigned int patch_vertex_count, int base_vertex_idx, unsigned int start_idx, unsigned int index_count, unsigned int start_instance, unsigned int instance_count, BOOL indexed)
Definition: cs.c:873

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

◆ wined3d_device_draw_indexed_primitive_instanced()

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

Definition at line 3789 of file device.c.

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

◆ wined3d_device_draw_indexed_primitive_instanced_indirect()

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

Definition at line 3799 of file device.c.

3801{
3802 TRACE("device %p, buffer %p, offset %u.\n", device, buffer, offset);
3803
3804 wined3d_cs_emit_draw_indirect(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
3805 buffer, offset, TRUE);
3806}
void wined3d_cs_emit_draw_indirect(struct wined3d_cs *cs, GLenum primitive_type, unsigned int patch_vertex_count, struct wined3d_buffer *buffer, unsigned int offset, BOOL indexed)
Definition: cs.c:898

◆ wined3d_device_draw_primitive()

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

Definition at line 3740 of file device.c.

3741{
3742 TRACE("device %p, start_vertex %u, vertex_count %u.\n", device, start_vertex, vertex_count);
3743
3744 wined3d_cs_emit_draw(device->cs, device->state.gl_primitive_type, device->state.gl_patch_vertices,
3745 0, start_vertex, vertex_count, 0, 0, FALSE);
3746
3747 return WINED3D_OK;
3748}
int vertex_count
Definition: d3drm.c:3367

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

◆ wined3d_device_draw_primitive_instanced()

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

Definition at line 3750 of file device.c.

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

◆ wined3d_device_draw_primitive_instanced_indirect()

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

Definition at line 3760 of file device.c.

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

◆ wined3d_device_end_scene()

HRESULT CDECL wined3d_device_end_scene ( struct wined3d_device device)

Definition at line 3617 of file device.c.

3618{
3619 TRACE("device %p.\n", device);
3620
3621 if (!device->inScene)
3622 {
3623 WARN("Not in scene, returning WINED3DERR_INVALIDCALL.\n");
3625 }
3626
3628
3629 device->inScene = FALSE;
3630 return WINED3D_OK;
3631}
void wined3d_cs_emit_flush(struct wined3d_cs *cs)
Definition: cs.c:930

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

◆ wined3d_device_end_stateblock()

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

Definition at line 3577 of file device.c.

3579{
3580 struct wined3d_stateblock *object = device->recording;
3581
3582 TRACE("device %p, stateblock %p.\n", device, stateblock);
3583
3584 if (!device->recording)
3585 {
3586 WARN("Not recording.\n");
3587 *stateblock = NULL;
3589 }
3590
3592
3593 *stateblock = object;
3594 device->recording = NULL;
3595 device->update_state = &device->state;
3596
3597 TRACE("Returning stateblock %p.\n", *stateblock);
3598
3599 return WINED3D_OK;
3600}
void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
Definition: stateblock.c:290

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

◆ wined3d_device_evict_managed_resources()

void CDECL wined3d_device_evict_managed_resources ( struct wined3d_device device)

Definition at line 4753 of file device.c.

4754{
4756
4757 TRACE("device %p.\n", device);
4758
4760 {
4761 TRACE("Checking resource %p for eviction.\n", resource);
4762
4763 if (wined3d_resource_access_is_managed(resource->access) && !resource->map_count)
4764 {
4765 TRACE("Evicting %p.\n", resource);
4767 }
4768 }
4769}
static BOOL wined3d_resource_access_is_managed(unsigned int access)

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

◆ wined3d_device_get_available_texture_mem()

UINT CDECL wined3d_device_get_available_texture_mem ( const struct wined3d_device device)

Definition at line 1298 of file device.c.

1299{
1300 /* const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; */
1301
1302 TRACE("device %p.\n", device);
1303
1304 /* We can not acquire the context unless there is a swapchain. */
1305 /*
1306 if (device->swapchains && gl_info->supported[NVX_GPU_MEMORY_INFO] &&
1307 !wined3d_settings.emulated_textureram)
1308 {
1309 GLint vram_free_kb;
1310 UINT64 vram_free;
1311
1312 struct wined3d_context *context = context_acquire(device, NULL, 0);
1313 gl_info->gl_ops.gl.p_glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &vram_free_kb);
1314 vram_free = (UINT64)vram_free_kb * 1024;
1315 context_release(context);
1316
1317 TRACE("Total 0x%s bytes. emulation 0x%s left, driver 0x%s left.\n",
1318 wine_dbgstr_longlong(device->adapter->vram_bytes),
1319 wine_dbgstr_longlong(device->adapter->vram_bytes - device->adapter->vram_bytes_used),
1320 wine_dbgstr_longlong(vram_free));
1321
1322 vram_free = min(vram_free, device->adapter->vram_bytes - device->adapter->vram_bytes_used);
1323 return min(UINT_MAX, vram_free);
1324 }
1325 */
1326
1327 TRACE("Emulating 0x%s bytes. 0x%s used, returning 0x%s left.\n",
1328 wine_dbgstr_longlong(device->adapter->vram_bytes),
1329 wine_dbgstr_longlong(device->adapter->vram_bytes_used),
1330 wine_dbgstr_longlong(device->adapter->vram_bytes - device->adapter->vram_bytes_used));
1331
1332 return min(UINT_MAX, device->adapter->vram_bytes - device->adapter->vram_bytes_used);
1333}
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define UINT_MAX
Definition: limits.h:41

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

◆ wined3d_device_get_base_vertex_index()

INT CDECL wined3d_device_get_base_vertex_index ( const struct wined3d_device device)

Definition at line 1924 of file device.c.

1925{
1926 TRACE("device %p.\n", device);
1927
1928 return device->state.base_vertex_index;
1929}

Referenced by d3d8_device_GetIndices().

◆ wined3d_device_get_blend_state()

struct wined3d_blend_state *CDECL wined3d_device_get_blend_state ( const struct wined3d_device device)

Definition at line 1994 of file device.c.

1995{
1996 TRACE("device %p.\n", device);
1997
1998 return device->state.blend_state;
1999}

◆ wined3d_device_get_clip_plane()

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

Definition at line 1811 of file device.c.

1813{
1814 TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
1815
1816 if (plane_idx >= device->adapter->gl_info.limits.user_clip_distances)
1817 {
1818 TRACE("Application has requested clipplane this device doesn't support.\n");
1820 }
1821
1822 *plane = device->state.clip_planes[plane_idx];
1823
1824 return WINED3D_OK;
1825}
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 GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum GLint const GLfloat GLenum GLint const GLushort GLint GLint GLsizei GLsizei GLenum GLsizei GLsizei GLenum GLenum const GLvoid GLenum plane
Definition: glfuncs.h:270

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

◆ wined3d_device_get_clip_status()

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

Definition at line 1838 of file device.c.

1840{
1841 FIXME("device %p, clip_status %p stub!\n", device, clip_status);
1842
1843 if (!clip_status)
1845
1846 return WINED3D_OK;
1847}

Referenced by d3d8_device_GetClipStatus(), and d3d9_device_GetClipStatus().

◆ wined3d_device_get_compute_shader()

struct wined3d_shader *CDECL wined3d_device_get_compute_shader ( const struct wined3d_device device)

Definition at line 2947 of file device.c.

2948{
2949 TRACE("device %p.\n", device);
2950
2951 return device->state.shader[WINED3D_SHADER_TYPE_COMPUTE];
2952}
@ WINED3D_SHADER_TYPE_COMPUTE

◆ wined3d_device_get_constant_buffer()

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

Definition at line 2245 of file device.c.

2247{
2249 {
2250 WARN("Invalid constant buffer index %u.\n", idx);
2251 return NULL;
2252 }
2253
2254 return device->state.cb[shader_type][idx];
2255}
#define MAX_CONSTANT_BUFFERS

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

◆ wined3d_device_get_creation_parameters()

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

Definition at line 5042 of file device.c.

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

Referenced by d3d8_device_GetCreationParameters(), and d3d9_device_GetCreationParameters().

◆ wined3d_device_get_cs_cb()

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

Definition at line 2961 of file device.c.

2962{
2963 TRACE("device %p, idx %u.\n", device, idx);
2964
2966}
static struct wined3d_buffer * wined3d_device_get_constant_buffer(const struct wined3d_device *device, enum wined3d_shader_type shader_type, unsigned int idx)
Definition: device.c:2245

◆ wined3d_device_get_cs_resource_view()

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

Definition at line 2976 of file device.c.

2978{
2979 TRACE("device %p, idx %u.\n", device, idx);
2980
2982}