ReactOS 0.4.15-dev-7889-g76290a6
cs.c File Reference
#include "config.h"
#include "wine/port.h"
#include "wined3d_private.h"
Include dependency graph for cs.c:

Go to the source code of this file.

Classes

struct  wined3d_cs_packet
 
struct  wined3d_cs_nop
 
struct  wined3d_cs_present
 
struct  wined3d_cs_clear
 
struct  wined3d_cs_dispatch
 
struct  wined3d_cs_draw
 
struct  wined3d_cs_flush
 
struct  wined3d_cs_set_predication
 
struct  wined3d_cs_set_viewport
 
struct  wined3d_cs_set_scissor_rect
 
struct  wined3d_cs_set_rendertarget_view
 
struct  wined3d_cs_set_depth_stencil_view
 
struct  wined3d_cs_set_vertex_declaration
 
struct  wined3d_cs_set_stream_source
 
struct  wined3d_cs_set_stream_source_freq
 
struct  wined3d_cs_set_stream_output
 
struct  wined3d_cs_set_index_buffer
 
struct  wined3d_cs_set_constant_buffer
 
struct  wined3d_cs_set_texture
 
struct  wined3d_cs_set_color_key
 
struct  wined3d_cs_set_shader_resource_view
 
struct  wined3d_cs_set_unordered_access_view
 
struct  wined3d_cs_set_sampler
 
struct  wined3d_cs_set_shader
 
struct  wined3d_cs_set_blend_state
 
struct  wined3d_cs_set_rasterizer_state
 
struct  wined3d_cs_set_render_state
 
struct  wined3d_cs_set_texture_state
 
struct  wined3d_cs_set_sampler_state
 
struct  wined3d_cs_set_transform
 
struct  wined3d_cs_set_clip_plane
 
struct  wined3d_cs_set_material
 
struct  wined3d_cs_set_light
 
struct  wined3d_cs_set_light_enable
 
struct  wined3d_cs_push_constants
 
struct  wined3d_cs_reset_state
 
struct  wined3d_cs_callback
 
struct  wined3d_cs_query_issue
 
struct  wined3d_cs_preload_resource
 
struct  wined3d_cs_unload_resource
 
struct  wined3d_cs_map
 
struct  wined3d_cs_unmap
 
struct  wined3d_cs_blt_sub_resource
 
struct  wined3d_cs_update_sub_resource
 
struct  wined3d_cs_add_dirty_texture_region
 
struct  wined3d_cs_clear_unordered_access_view
 
struct  wined3d_cs_copy_uav_counter
 
struct  wined3d_cs_generate_mipmaps
 
struct  wined3d_cs_stop
 

Macros

#define WINED3D_INITIAL_CS_SIZE   4096
 

Enumerations

enum  wined3d_cs_op {
  WINED3D_CS_OP_NOP , WINED3D_CS_OP_PRESENT , WINED3D_CS_OP_CLEAR , WINED3D_CS_OP_DISPATCH ,
  WINED3D_CS_OP_DRAW , WINED3D_CS_OP_FLUSH , WINED3D_CS_OP_SET_PREDICATION , WINED3D_CS_OP_SET_VIEWPORT ,
  WINED3D_CS_OP_SET_SCISSOR_RECT , WINED3D_CS_OP_SET_RENDERTARGET_VIEW , WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW , WINED3D_CS_OP_SET_VERTEX_DECLARATION ,
  WINED3D_CS_OP_SET_STREAM_SOURCE , WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ , WINED3D_CS_OP_SET_STREAM_OUTPUT , WINED3D_CS_OP_SET_INDEX_BUFFER ,
  WINED3D_CS_OP_SET_CONSTANT_BUFFER , WINED3D_CS_OP_SET_TEXTURE , WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW , WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW ,
  WINED3D_CS_OP_SET_SAMPLER , WINED3D_CS_OP_SET_SHADER , WINED3D_CS_OP_SET_BLEND_STATE , WINED3D_CS_OP_SET_RASTERIZER_STATE ,
  WINED3D_CS_OP_SET_RENDER_STATE , WINED3D_CS_OP_SET_TEXTURE_STATE , WINED3D_CS_OP_SET_SAMPLER_STATE , WINED3D_CS_OP_SET_TRANSFORM ,
  WINED3D_CS_OP_SET_CLIP_PLANE , WINED3D_CS_OP_SET_COLOR_KEY , WINED3D_CS_OP_SET_MATERIAL , WINED3D_CS_OP_SET_LIGHT ,
  WINED3D_CS_OP_SET_LIGHT_ENABLE , WINED3D_CS_OP_PUSH_CONSTANTS , WINED3D_CS_OP_RESET_STATE , WINED3D_CS_OP_CALLBACK ,
  WINED3D_CS_OP_QUERY_ISSUE , WINED3D_CS_OP_PRELOAD_RESOURCE , WINED3D_CS_OP_UNLOAD_RESOURCE , WINED3D_CS_OP_MAP ,
  WINED3D_CS_OP_UNMAP , WINED3D_CS_OP_BLT_SUB_RESOURCE , WINED3D_CS_OP_UPDATE_SUB_RESOURCE , WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION ,
  WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW , WINED3D_CS_OP_COPY_UAV_COUNTER , WINED3D_CS_OP_GENERATE_MIPMAPS , WINED3D_CS_OP_STOP
}
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (d3d)
 
static void wined3d_cs_exec_nop (struct wined3d_cs *cs, const void *data)
 
static void wined3d_cs_exec_present (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_present (struct wined3d_cs *cs, struct wined3d_swapchain *swapchain, const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override, DWORD swap_interval, DWORD flags)
 
static void wined3d_cs_exec_clear (struct wined3d_cs *cs, const void *data)
 
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)
 
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)
 
static void acquire_shader_resources (const struct wined3d_state *state, unsigned int shader_mask)
 
static void release_shader_resources (const struct wined3d_state *state, unsigned int shader_mask)
 
static void acquire_unordered_access_resources (const struct wined3d_shader *shader, struct wined3d_unordered_access_view *const *views)
 
static void release_unordered_access_resources (const struct wined3d_shader *shader, struct wined3d_unordered_access_view *const *views)
 
static void wined3d_cs_exec_dispatch (struct wined3d_cs *cs, const void *data)
 
static void acquire_compute_pipeline_resources (const struct wined3d_state *state)
 
void wined3d_cs_emit_dispatch (struct wined3d_cs *cs, unsigned int group_count_x, unsigned int group_count_y, unsigned int group_count_z)
 
void wined3d_cs_emit_dispatch_indirect (struct wined3d_cs *cs, struct wined3d_buffer *buffer, unsigned int offset)
 
static void wined3d_cs_exec_draw (struct wined3d_cs *cs, const void *data)
 
static void acquire_graphics_pipeline_resources (const struct wined3d_state *state, BOOL indexed, const struct wined3d_gl_info *gl_info)
 
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)
 
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)
 
static void wined3d_cs_exec_flush (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_flush (struct wined3d_cs *cs)
 
static void wined3d_cs_exec_set_predication (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_predication (struct wined3d_cs *cs, struct wined3d_query *predicate, BOOL value)
 
static void wined3d_cs_exec_set_viewport (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_viewport (struct wined3d_cs *cs, const struct wined3d_viewport *viewport)
 
static void wined3d_cs_exec_set_scissor_rect (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_scissor_rect (struct wined3d_cs *cs, const RECT *rect)
 
static void wined3d_cs_exec_set_rendertarget_view (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_rendertarget_view (struct wined3d_cs *cs, unsigned int view_idx, struct wined3d_rendertarget_view *view)
 
static void wined3d_cs_exec_set_depth_stencil_view (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_depth_stencil_view (struct wined3d_cs *cs, struct wined3d_rendertarget_view *view)
 
static void wined3d_cs_exec_set_vertex_declaration (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_vertex_declaration (struct wined3d_cs *cs, struct wined3d_vertex_declaration *declaration)
 
static void wined3d_cs_exec_set_stream_source (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_stream_source (struct wined3d_cs *cs, UINT stream_idx, struct wined3d_buffer *buffer, UINT offset, UINT stride)
 
static void wined3d_cs_exec_set_stream_source_freq (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_stream_source_freq (struct wined3d_cs *cs, UINT stream_idx, UINT frequency, UINT flags)
 
static void wined3d_cs_exec_set_stream_output (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_stream_output (struct wined3d_cs *cs, UINT stream_idx, struct wined3d_buffer *buffer, UINT offset)
 
static void wined3d_cs_exec_set_index_buffer (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_index_buffer (struct wined3d_cs *cs, struct wined3d_buffer *buffer, enum wined3d_format_id format_id, unsigned int offset)
 
static void wined3d_cs_exec_set_constant_buffer (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_constant_buffer (struct wined3d_cs *cs, enum wined3d_shader_type type, UINT cb_idx, struct wined3d_buffer *buffer)
 
static void wined3d_cs_exec_set_texture (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_texture (struct wined3d_cs *cs, UINT stage, struct wined3d_texture *texture)
 
static void wined3d_cs_exec_set_shader_resource_view (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_shader_resource_view (struct wined3d_cs *cs, enum wined3d_shader_type type, UINT view_idx, struct wined3d_shader_resource_view *view)
 
static void wined3d_cs_exec_set_unordered_access_view (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_unordered_access_view (struct wined3d_cs *cs, enum wined3d_pipeline pipeline, unsigned int view_idx, struct wined3d_unordered_access_view *view, unsigned int initial_count)
 
static void wined3d_cs_exec_set_sampler (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_sampler (struct wined3d_cs *cs, enum wined3d_shader_type type, UINT sampler_idx, struct wined3d_sampler *sampler)
 
static void wined3d_cs_exec_set_shader (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_shader (struct wined3d_cs *cs, enum wined3d_shader_type type, struct wined3d_shader *shader)
 
static void wined3d_cs_exec_set_blend_state (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_blend_state (struct wined3d_cs *cs, struct wined3d_blend_state *state)
 
static void wined3d_cs_exec_set_rasterizer_state (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_rasterizer_state (struct wined3d_cs *cs, struct wined3d_rasterizer_state *rasterizer_state)
 
static void wined3d_cs_exec_set_render_state (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_render_state (struct wined3d_cs *cs, enum wined3d_render_state state, DWORD value)
 
static void wined3d_cs_exec_set_texture_state (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_texture_state (struct wined3d_cs *cs, UINT stage, enum wined3d_texture_stage_state state, DWORD value)
 
static void wined3d_cs_exec_set_sampler_state (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_sampler_state (struct wined3d_cs *cs, UINT sampler_idx, enum wined3d_sampler_state state, DWORD value)
 
static void wined3d_cs_exec_set_transform (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_transform (struct wined3d_cs *cs, enum wined3d_transform_state state, const struct wined3d_matrix *matrix)
 
static void wined3d_cs_exec_set_clip_plane (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_clip_plane (struct wined3d_cs *cs, UINT plane_idx, const struct wined3d_vec4 *plane)
 
static void wined3d_cs_exec_set_color_key (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_color_key (struct wined3d_cs *cs, struct wined3d_texture *texture, WORD flags, const struct wined3d_color_key *color_key)
 
static void wined3d_cs_exec_set_material (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_material (struct wined3d_cs *cs, const struct wined3d_material *material)
 
static void wined3d_cs_exec_set_light (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_light (struct wined3d_cs *cs, const struct wined3d_light_info *light)
 
static void wined3d_cs_exec_set_light_enable (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_set_light_enable (struct wined3d_cs *cs, unsigned int idx, BOOL enable)
 
static void wined3d_cs_st_push_constants (struct wined3d_cs *cs, enum wined3d_push_constants p, unsigned int start_idx, unsigned int count, const void *constants)
 
static void wined3d_cs_exec_push_constants (struct wined3d_cs *cs, const void *data)
 
static void wined3d_cs_mt_push_constants (struct wined3d_cs *cs, enum wined3d_push_constants p, unsigned int start_idx, unsigned int count, const void *constants)
 
static void wined3d_cs_exec_reset_state (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_reset_state (struct wined3d_cs *cs)
 
static void wined3d_cs_exec_callback (struct wined3d_cs *cs, const void *data)
 
static void wined3d_cs_emit_callback (struct wined3d_cs *cs, void(*callback)(void *object), void *object)
 
void wined3d_cs_destroy_object (struct wined3d_cs *cs, void(*callback)(void *object), void *object)
 
void wined3d_cs_init_object (struct wined3d_cs *cs, void(*callback)(void *object), void *object)
 
static void wined3d_cs_exec_query_issue (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_query_issue (struct wined3d_cs *cs, struct wined3d_query *query, DWORD flags)
 
static void wined3d_cs_exec_preload_resource (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_preload_resource (struct wined3d_cs *cs, struct wined3d_resource *resource)
 
static void wined3d_cs_exec_unload_resource (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_unload_resource (struct wined3d_cs *cs, struct wined3d_resource *resource)
 
static void wined3d_cs_exec_map (struct wined3d_cs *cs, const void *data)
 
HRESULT wined3d_cs_map (struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx, struct wined3d_map_desc *map_desc, const struct wined3d_box *box, unsigned int flags)
 
static void wined3d_cs_exec_unmap (struct wined3d_cs *cs, const void *data)
 
HRESULT wined3d_cs_unmap (struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx)
 
static void wined3d_cs_exec_blt_sub_resource (struct wined3d_cs *cs, const void *data)
 
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)
 
static void wined3d_cs_exec_update_sub_resource (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_update_sub_resource (struct wined3d_cs *cs, struct wined3d_resource *resource, unsigned int sub_resource_idx, const struct wined3d_box *box, const void *data, unsigned int row_pitch, unsigned int slice_pitch)
 
static void wined3d_cs_exec_add_dirty_texture_region (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_add_dirty_texture_region (struct wined3d_cs *cs, struct wined3d_texture *texture, unsigned int layer)
 
static void wined3d_cs_exec_clear_unordered_access_view (struct wined3d_cs *cs, const void *data)
 
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)
 
static void wined3d_cs_exec_copy_uav_counter (struct wined3d_cs *cs, const void *data)
 
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)
 
static void wined3d_cs_exec_generate_mipmaps (struct wined3d_cs *cs, const void *data)
 
void wined3d_cs_emit_generate_mipmaps (struct wined3d_cs *cs, struct wined3d_shader_resource_view *view)
 
static void wined3d_cs_emit_stop (struct wined3d_cs *cs)
 
static voidwined3d_cs_st_require_space (struct wined3d_cs *cs, size_t size, enum wined3d_cs_queue_id queue_id)
 
static void wined3d_cs_st_submit (struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
 
static void wined3d_cs_st_finish (struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
 
static BOOL wined3d_cs_queue_is_empty (const struct wined3d_cs *cs, const struct wined3d_cs_queue *queue)
 
static void wined3d_cs_queue_submit (struct wined3d_cs_queue *queue, struct wined3d_cs *cs)
 
static void wined3d_cs_mt_submit (struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
 
static voidwined3d_cs_queue_require_space (struct wined3d_cs_queue *queue, size_t size, struct wined3d_cs *cs)
 
static voidwined3d_cs_mt_require_space (struct wined3d_cs *cs, size_t size, enum wined3d_cs_queue_id queue_id)
 
static void wined3d_cs_mt_finish (struct wined3d_cs *cs, enum wined3d_cs_queue_id queue_id)
 
static void poll_queries (struct wined3d_cs *cs)
 
static void wined3d_cs_wait_event (struct wined3d_cs *cs)
 
static DWORD WINAPI wined3d_cs_run (void *ctx)
 
struct wined3d_cswined3d_cs_create (struct wined3d_device *device)
 
void wined3d_cs_destroy (struct wined3d_cs *cs)
 

Variables

struct {
   size_t   offset
 
   size_t   size
 
   DWORD   mask
 
wined3d_cs_push_constant_info []
 
static void(*const wined3d_cs_op_handlers [])(struct wined3d_cs *cs, const void *data)
 
static const struct wined3d_cs_ops wined3d_cs_st_ops
 
static const struct wined3d_cs_ops wined3d_cs_mt_ops
 

Macro Definition Documentation

◆ WINED3D_INITIAL_CS_SIZE

#define WINED3D_INITIAL_CS_SIZE   4096

Definition at line 25 of file cs.c.

Enumeration Type Documentation

◆ wined3d_cs_op

Enumerator
WINED3D_CS_OP_NOP 
WINED3D_CS_OP_PRESENT 
WINED3D_CS_OP_CLEAR 
WINED3D_CS_OP_DISPATCH 
WINED3D_CS_OP_DRAW 
WINED3D_CS_OP_FLUSH 
WINED3D_CS_OP_SET_PREDICATION 
WINED3D_CS_OP_SET_VIEWPORT 
WINED3D_CS_OP_SET_SCISSOR_RECT 
WINED3D_CS_OP_SET_RENDERTARGET_VIEW 
WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW 
WINED3D_CS_OP_SET_VERTEX_DECLARATION 
WINED3D_CS_OP_SET_STREAM_SOURCE 
WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ 
WINED3D_CS_OP_SET_STREAM_OUTPUT 
WINED3D_CS_OP_SET_INDEX_BUFFER 
WINED3D_CS_OP_SET_CONSTANT_BUFFER 
WINED3D_CS_OP_SET_TEXTURE 
WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW 
WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW 
WINED3D_CS_OP_SET_SAMPLER 
WINED3D_CS_OP_SET_SHADER 
WINED3D_CS_OP_SET_BLEND_STATE 
WINED3D_CS_OP_SET_RASTERIZER_STATE 
WINED3D_CS_OP_SET_RENDER_STATE 
WINED3D_CS_OP_SET_TEXTURE_STATE 
WINED3D_CS_OP_SET_SAMPLER_STATE 
WINED3D_CS_OP_SET_TRANSFORM 
WINED3D_CS_OP_SET_CLIP_PLANE 
WINED3D_CS_OP_SET_COLOR_KEY 
WINED3D_CS_OP_SET_MATERIAL 
WINED3D_CS_OP_SET_LIGHT 
WINED3D_CS_OP_SET_LIGHT_ENABLE 
WINED3D_CS_OP_PUSH_CONSTANTS 
WINED3D_CS_OP_RESET_STATE 
WINED3D_CS_OP_CALLBACK 
WINED3D_CS_OP_QUERY_ISSUE 
WINED3D_CS_OP_PRELOAD_RESOURCE 
WINED3D_CS_OP_UNLOAD_RESOURCE 
WINED3D_CS_OP_MAP 
WINED3D_CS_OP_UNMAP 
WINED3D_CS_OP_BLT_SUB_RESOURCE 
WINED3D_CS_OP_UPDATE_SUB_RESOURCE 
WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION 
WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW 
WINED3D_CS_OP_COPY_UAV_COUNTER 
WINED3D_CS_OP_GENERATE_MIPMAPS 
WINED3D_CS_OP_STOP 

Definition at line 27 of file cs.c.

28{
77};
@ WINED3D_CS_OP_MAP
Definition: cs.c:68
@ WINED3D_CS_OP_SET_SCISSOR_RECT
Definition: cs.c:37
@ WINED3D_CS_OP_CLEAR_UNORDERED_ACCESS_VIEW
Definition: cs.c:73
@ WINED3D_CS_OP_COPY_UAV_COUNTER
Definition: cs.c:74
@ WINED3D_CS_OP_SET_SHADER_RESOURCE_VIEW
Definition: cs.c:47
@ WINED3D_CS_OP_SET_TEXTURE_STATE
Definition: cs.c:54
@ WINED3D_CS_OP_ADD_DIRTY_TEXTURE_REGION
Definition: cs.c:72
@ WINED3D_CS_OP_SET_LIGHT
Definition: cs.c:60
@ WINED3D_CS_OP_SET_DEPTH_STENCIL_VIEW
Definition: cs.c:39
@ WINED3D_CS_OP_STOP
Definition: cs.c:76
@ WINED3D_CS_OP_SET_INDEX_BUFFER
Definition: cs.c:44
@ WINED3D_CS_OP_SET_VERTEX_DECLARATION
Definition: cs.c:40
@ WINED3D_CS_OP_SET_STREAM_OUTPUT
Definition: cs.c:43
@ WINED3D_CS_OP_CLEAR
Definition: cs.c:31
@ WINED3D_CS_OP_NOP
Definition: cs.c:29
@ WINED3D_CS_OP_QUERY_ISSUE
Definition: cs.c:65
@ WINED3D_CS_OP_SET_LIGHT_ENABLE
Definition: cs.c:61
@ WINED3D_CS_OP_SET_TEXTURE
Definition: cs.c:46
@ WINED3D_CS_OP_PUSH_CONSTANTS
Definition: cs.c:62
@ WINED3D_CS_OP_UPDATE_SUB_RESOURCE
Definition: cs.c:71
@ WINED3D_CS_OP_RESET_STATE
Definition: cs.c:63
@ WINED3D_CS_OP_SET_UNORDERED_ACCESS_VIEW
Definition: cs.c:48
@ WINED3D_CS_OP_SET_VIEWPORT
Definition: cs.c:36
@ WINED3D_CS_OP_UNMAP
Definition: cs.c:69
@ WINED3D_CS_OP_PRELOAD_RESOURCE
Definition: cs.c:66
@ WINED3D_CS_OP_SET_RENDER_STATE
Definition: cs.c:53
@ WINED3D_CS_OP_SET_RASTERIZER_STATE
Definition: cs.c:52
@ WINED3D_CS_OP_SET_SAMPLER
Definition: cs.c:49
@ WINED3D_CS_OP_SET_STREAM_SOURCE
Definition: cs.c:41
@ WINED3D_CS_OP_BLT_SUB_RESOURCE
Definition: cs.c:70
@ WINED3D_CS_OP_DRAW
Definition: cs.c:33
@ WINED3D_CS_OP_SET_RENDERTARGET_VIEW
Definition: cs.c:38
@ WINED3D_CS_OP_SET_BLEND_STATE
Definition: cs.c:51
@ WINED3D_CS_OP_SET_CONSTANT_BUFFER
Definition: cs.c:45
@ WINED3D_CS_OP_SET_MATERIAL
Definition: cs.c:59
@ WINED3D_CS_OP_FLUSH
Definition: cs.c:34
@ WINED3D_CS_OP_SET_CLIP_PLANE
Definition: cs.c:57
@ WINED3D_CS_OP_SET_SAMPLER_STATE
Definition: cs.c:55
@ WINED3D_CS_OP_PRESENT
Definition: cs.c:30
@ WINED3D_CS_OP_SET_PREDICATION
Definition: cs.c:35
@ WINED3D_CS_OP_GENERATE_MIPMAPS
Definition: cs.c:75
@ WINED3D_CS_OP_SET_SHADER
Definition: cs.c:50
@ WINED3D_CS_OP_DISPATCH
Definition: cs.c:32
@ WINED3D_CS_OP_SET_STREAM_SOURCE_FREQ
Definition: cs.c:42
@ WINED3D_CS_OP_UNLOAD_RESOURCE
Definition: cs.c:67
@ WINED3D_CS_OP_SET_COLOR_KEY
Definition: cs.c:58
@ WINED3D_CS_OP_SET_TRANSFORM
Definition: cs.c:56
@ WINED3D_CS_OP_CALLBACK
Definition: cs.c:64

Function Documentation

◆ acquire_compute_pipeline_resources()

static void acquire_compute_pipeline_resources ( const struct wined3d_state state)
static

Definition at line 731 of file cs.c.

732{
735 state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
736}
static int state
Definition: maze.c:121
static void acquire_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
Definition: cs.c:610
static void acquire_unordered_access_resources(const struct wined3d_shader *shader, struct wined3d_unordered_access_view *const *views)
Definition: cs.c:676
@ WINED3D_PIPELINE_COMPUTE
@ WINED3D_SHADER_TYPE_COMPUTE

Referenced by wined3d_cs_emit_dispatch(), and wined3d_cs_emit_dispatch_indirect().

◆ acquire_graphics_pipeline_resources()

static void acquire_graphics_pipeline_resources ( const struct wined3d_state state,
BOOL  indexed,
const struct wined3d_gl_info gl_info 
)
static

Definition at line 839 of file cs.c.

841{
842 unsigned int i;
843
844 if (indexed)
845 wined3d_resource_acquire(&state->index_buffer->resource);
846 for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
847 {
848 if (state->streams[i].buffer)
849 wined3d_resource_acquire(&state->streams[i].buffer->resource);
850 }
851 for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
852 {
853 if (state->stream_output[i].buffer)
854 wined3d_resource_acquire(&state->stream_output[i].buffer->resource);
855 }
856 for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
857 {
858 if (state->textures[i])
859 wined3d_resource_acquire(&state->textures[i]->resource);
860 }
861 for (i = 0; i < gl_info->limits.buffers; ++i)
862 {
863 if (state->fb->render_targets[i])
864 wined3d_resource_acquire(state->fb->render_targets[i]->resource);
865 }
866 if (state->fb->depth_stencil)
867 wined3d_resource_acquire(state->fb->depth_stencil->resource);
870 state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
871}
#define ARRAY_SIZE(A)
Definition: main.h:33
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
struct wined3d_gl_limits limits
static void wined3d_resource_acquire(struct wined3d_resource *resource)
@ WINED3D_PIPELINE_GRAPHICS
@ WINED3D_SHADER_TYPE_PIXEL

Referenced by wined3d_cs_emit_draw(), and wined3d_cs_emit_draw_indirect().

◆ acquire_shader_resources()

static void acquire_shader_resources ( const struct wined3d_state state,
unsigned int  shader_mask 
)
static

Definition at line 610 of file cs.c.

611{
614 struct wined3d_shader *shader;
615 unsigned int i, j;
616
617 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
618 {
619 if (!(shader_mask & (1u << i)))
620 continue;
621
622 if (!(shader = state->shader[i]))
623 continue;
624
625 for (j = 0; j < WINED3D_MAX_CBS; ++j)
626 {
627 if (state->cb[i][j])
628 wined3d_resource_acquire(&state->cb[i][j]->resource);
629 }
630
631 for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
632 {
633 entry = &shader->reg_maps.sampler_map.entries[j];
634
635 if (!(view = state->shader_resource_view[i][entry->resource_idx]))
636 continue;
637
639 }
640 }
641}
GLuint shader
Definition: glext.h:6030
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
uint32_t entry
Definition: isohybrid.c:63
#define WINED3D_MAX_CBS
@ WINED3D_SHADER_TYPE_COUNT

Referenced by acquire_compute_pipeline_resources(), and acquire_graphics_pipeline_resources().

◆ acquire_unordered_access_resources()

static void acquire_unordered_access_resources ( const struct wined3d_shader shader,
struct wined3d_unordered_access_view *const views 
)
static

Definition at line 676 of file cs.c.

678{
679 unsigned int i;
680
681 if (!shader)
682 return;
683
684 for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
685 {
686 if (!shader->reg_maps.uav_resource_info[i].type)
687 continue;
688
689 if (!views[i])
690 continue;
691
693 }
694}
#define MAX_UNORDERED_ACCESS_VIEWS

Referenced by acquire_compute_pipeline_resources(), and acquire_graphics_pipeline_resources().

◆ poll_queries()

static void poll_queries ( struct wined3d_cs cs)
static

Definition at line 2727 of file cs.c.

2728{
2729 struct wined3d_query *query, *cursor;
2730
2732 {
2733 if (!query->query_ops->query_poll(query, 0))
2734 continue;
2735
2736 list_remove(&query->poll_list_entry);
2737 list_init(&query->poll_list_entry);
2738 InterlockedIncrement(&query->counter_retrieved);
2739 }
2740}
#define InterlockedIncrement
Definition: armddk.h:53
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static void list_init(struct list_entry *head)
Definition: list.h:51
#define cs
Definition: i386-dis.c:442
const char cursor[]
Definition: icontest.c:13
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
struct list poll_list_entry

Referenced by wined3d_cs_run().

◆ release_shader_resources()

static void release_shader_resources ( const struct wined3d_state state,
unsigned int  shader_mask 
)
static

Definition at line 643 of file cs.c.

644{
647 struct wined3d_shader *shader;
648 unsigned int i, j;
649
650 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
651 {
652 if (!(shader_mask & (1u << i)))
653 continue;
654
655 if (!(shader = state->shader[i]))
656 continue;
657
658 for (j = 0; j < WINED3D_MAX_CBS; ++j)
659 {
660 if (state->cb[i][j])
661 wined3d_resource_release(&state->cb[i][j]->resource);
662 }
663
664 for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
665 {
666 entry = &shader->reg_maps.sampler_map.entries[j];
667
668 if (!(view = state->shader_resource_view[i][entry->resource_idx]))
669 continue;
670
672 }
673 }
674}
static void wined3d_resource_release(struct wined3d_resource *resource)

Referenced by wined3d_cs_exec_dispatch(), and wined3d_cs_exec_draw().

◆ release_unordered_access_resources()

static void release_unordered_access_resources ( const struct wined3d_shader shader,
struct wined3d_unordered_access_view *const views 
)
static

Definition at line 696 of file cs.c.

698{
699 unsigned int i;
700
701 if (!shader)
702 return;
703
704 for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
705 {
706 if (!shader->reg_maps.uav_resource_info[i].type)
707 continue;
708
709 if (!views[i])
710 continue;
711
713 }
714}

Referenced by wined3d_cs_exec_dispatch(), and wined3d_cs_exec_draw().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( d3d  )

◆ wined3d_cs_create()

struct wined3d_cs * wined3d_cs_create ( struct wined3d_device device)

Definition at line 2828 of file cs.c.

2829{
2830 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2831 struct wined3d_cs *cs;
2832
2833 if (!(cs = heap_alloc_zero(sizeof(*cs))))
2834 return NULL;
2835
2836 cs->ops = &wined3d_cs_st_ops;
2837 cs->device = device;
2838
2839 state_init(&cs->state, &cs->fb, gl_info, &device->adapter->d3d_info,
2841
2842 cs->data_size = WINED3D_INITIAL_CS_SIZE;
2843 if (!(cs->data = heap_alloc(cs->data_size)))
2844 goto fail;
2845
2848 {
2849 cs->ops = &wined3d_cs_mt_ops;
2850
2851 if (!(cs->event = CreateEventW(NULL, FALSE, FALSE, NULL)))
2852 {
2853 ERR("Failed to create command stream event.\n");
2854 heap_free(cs->data);
2855 goto fail;
2856 }
2857
2858 if (!(GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
2859 (const WCHAR *)wined3d_cs_run, &cs->wined3d_module)))
2860 {
2861 ERR("Failed to get wined3d module handle.\n");
2862 CloseHandle(cs->event);
2863 heap_free(cs->data);
2864 goto fail;
2865 }
2866
2867 if (!(cs->thread = CreateThread(NULL, 0, wined3d_cs_run, cs, 0, NULL)))
2868 {
2869 ERR("Failed to create wined3d command stream thread.\n");
2870 FreeLibrary(cs->wined3d_module);
2871 CloseHandle(cs->event);
2872 heap_free(cs->data);
2873 goto fail;
2874 }
2875 }
2876
2877 return cs;
2878
2879fail:
2880 state_cleanup(&cs->state);
2881 heap_free(cs);
2882 return NULL;
2883}
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
#define ERR(fmt,...)
Definition: debug.h:110
static DWORD WINAPI wined3d_cs_run(void *ctx)
Definition: cs.c:2761
static const struct wined3d_cs_ops wined3d_cs_st_ops
Definition: cs.c:2569
#define WINED3D_INITIAL_CS_SIZE
Definition: cs.c:25
static const struct wined3d_cs_ops wined3d_cs_mt_ops
Definition: cs.c:2716
void state_init(void *ipp)
Definition: dhclient.c:210
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
#define CloseHandle
Definition: compat.h:739
#define FreeLibrary(x)
Definition: compat.h:748
PPEB Peb
Definition: dllmain.c:27
BOOL WINAPI GetModuleHandleExW(IN DWORD dwFlags, IN LPCWSTR lpwModuleName OPTIONAL, OUT HMODULE *phModule)
Definition: loader.c:866
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
#define NtCurrentTeb
NTSYSAPI ULONG NTAPI RtlIsCriticalSectionLockedByThread(_In_ PRTL_CRITICAL_SECTION CriticalSection)
PVOID LoaderLock
Definition: ntddk_ex.h:295
Definition: devices.h:37
struct wined3d_device * device
unsigned int cs_multithreaded
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
void state_cleanup(struct wined3d_state *state)
Definition: stateblock.c:528
#define WINED3D_STATE_NO_REF
#define WINED3D_STATE_INIT_DEFAULT
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by device_init().

◆ wined3d_cs_destroy()

void wined3d_cs_destroy ( struct wined3d_cs cs)

Definition at line 2885 of file cs.c.

2886{
2887 if (cs->thread)
2888 {
2890 CloseHandle(cs->thread);
2891 if (!CloseHandle(cs->event))
2892 ERR("Closing event failed.\n");
2893 }
2894
2895 state_cleanup(&cs->state);
2896 heap_free(cs->data);
2897 heap_free(cs);
2898}
static void wined3d_cs_emit_stop(struct wined3d_cs *cs)
Definition: cs.c:2449

Referenced by wined3d_device_decref().

◆ wined3d_cs_destroy_object()

◆ wined3d_cs_emit_add_dirty_texture_region()

void wined3d_cs_emit_add_dirty_texture_region ( struct wined3d_cs cs,
struct wined3d_texture texture,
unsigned int  layer 
)

Definition at line 2353 of file cs.c.

2355{
2357
2358 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2360 op->texture = texture;
2361 op->layer = layer;
2362
2364
2365 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2366}
UINT op
Definition: effect.c:236
GLenum GLuint texture
Definition: glext.h:6295
GLenum GLuint GLint GLint layer
Definition: glext.h:7007
@ WINED3D_CS_QUEUE_DEFAULT

Referenced by wined3d_texture_add_dirty_region().

◆ wined3d_cs_emit_blt_sub_resource()

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 at line 2172 of file cs.c.

2176{
2178
2179 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2181 op->dst_resource = dst_resource;
2182 op->dst_sub_resource_idx = dst_sub_resource_idx;
2183 op->dst_box = *dst_box;
2184 op->src_resource = src_resource;
2185 op->src_sub_resource_idx = src_sub_resource_idx;
2186 op->src_box = *src_box;
2187 op->flags = flags;
2188 if (fx)
2189 op->fx = *fx;
2190 else
2191 memset(&op->fx, 0, sizeof(op->fx));
2192 op->filter = filter;
2193
2195 if (src_resource)
2197
2198 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2200 cs->ops->finish(cs, WINED3D_CS_QUEUE_DEFAULT);
2201}
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glext.h:7005
GLbitfield flags
Definition: glext.h:7161
#define memset(x, y, z)
Definition: compat.h:39
struct wined3d_resource * dst_resource
Definition: cs.c:391
struct wined3d_box src_box
Definition: cs.c:396
struct wined3d_resource * src_resource
Definition: cs.c:394
unsigned int src_sub_resource_idx
Definition: cs.c:395
struct wined3d_box dst_box
Definition: cs.c:393
unsigned int dst_sub_resource_idx
Definition: cs.c:392
GLfixed fx
Definition: tritemp.h:484
#define WINED3D_BLT_SYNCHRONOUS
Definition: wined3d.h:1367

Referenced by wined3d_device_copy_resource(), wined3d_device_copy_sub_resource_region(), wined3d_device_update_texture(), and wined3d_texture_blt().

◆ wined3d_cs_emit_callback()

static void wined3d_cs_emit_callback ( struct wined3d_cs cs,
void(*)(void *object callback,
void object 
)
static

Definition at line 1873 of file cs.c.

1874{
1875 struct wined3d_cs_callback *op;
1876
1877 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1878 op->opcode = WINED3D_CS_OP_CALLBACK;
1879 op->callback = callback;
1880 op->object = object;
1881
1882 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1883}
void * object
Definition: cs.c:347

Referenced by wined3d_cs_destroy_object(), and wined3d_cs_init_object().

◆ wined3d_cs_emit_clear()

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 at line 536 of file cs.c.

538{
539 unsigned int rt_count = cs->device->adapter->gl_info.limits.buffers;
540 const struct wined3d_state *state = &cs->device->state;
541 const struct wined3d_viewport *vp = &state->viewport;
542 struct wined3d_cs_clear *op;
543 unsigned int i;
544
545 op = cs->ops->require_space(cs, FIELD_OFFSET(struct wined3d_cs_clear, rects[rect_count]),
547 op->opcode = WINED3D_CS_OP_CLEAR;
548 op->flags = flags;
549 op->rt_count = rt_count;
550 op->fb = &cs->fb;
551 SetRect(&op->draw_rect, vp->x, vp->y, vp->x + vp->width, vp->y + vp->height);
552 if (state->render_states[WINED3D_RS_SCISSORTESTENABLE])
553 IntersectRect(&op->draw_rect, &op->draw_rect, &state->scissor_rect);
554 op->color = *color;
555 op->depth = depth;
556 op->stencil = stencil;
557 op->rect_count = rect_count;
558 memcpy(op->rects, rects, sizeof(*rects) * rect_count);
559
561 {
562 for (i = 0; i < rt_count; ++i)
563 {
564 if (state->fb->render_targets[i])
565 wined3d_resource_acquire(state->fb->render_targets[i]->resource);
566 }
567 }
569 wined3d_resource_acquire(state->fb->depth_stencil->resource);
570
571 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
572}
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
GLuint color
Definition: glext.h:6243
GLint GLfloat GLint stencil
Definition: glext.h:6260
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned int rt_count
Definition: cs.c:105
RECT rects[1]
Definition: cs.c:112
unsigned int rect_count
Definition: cs.c:111
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define WINED3DCLEAR_TARGET
Definition: wined3d.h:997
@ WINED3D_RS_SCISSORTESTENABLE
Definition: wined3d.h:358
#define WINED3DCLEAR_STENCIL
Definition: wined3d.h:999
#define WINED3DCLEAR_ZBUFFER
Definition: wined3d.h:998
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)

Referenced by wined3d_device_clear().

◆ wined3d_cs_emit_clear_rendertarget_view()

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 at line 574 of file cs.c.

576{
577 struct wined3d_cs_clear *op;
578 size_t size;
579
580 size = FIELD_OFFSET(struct wined3d_cs_clear, rects[1]) + sizeof(struct wined3d_fb_state);
581 op = cs->ops->require_space(cs, size, WINED3D_CS_QUEUE_DEFAULT);
582 op->fb = (void *)&op->rects[1];
583
584 op->opcode = WINED3D_CS_OP_CLEAR;
585 op->flags = flags;
587 {
588 op->rt_count = 1;
589 op->fb->render_targets[0] = view;
590 op->fb->depth_stencil = NULL;
591 op->color = *color;
592 }
593 else
594 {
595 op->rt_count = 0;
596 op->fb->render_targets[0] = NULL;
597 op->fb->depth_stencil = view;
598 op->depth = depth;
599 op->stencil = stencil;
600 }
601 SetRect(&op->draw_rect, 0, 0, view->width, view->height);
602 op->rect_count = 1;
603 op->rects[0] = *rect;
604
606
607 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
608}
size_t size
Definition: cs.c:1781
GLsizeiptr size
Definition: glext.h:5919
if(dx< 0)
Definition: linetemp.h:194
& rect
Definition: startmenu.cpp:1413

Referenced by wined3d_device_clear_rendertarget_view().

◆ wined3d_cs_emit_clear_unordered_access_view_uint()

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 at line 2381 of file cs.c.

2383{
2385
2386 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2388 op->view = view;
2389 op->clear_value = *clear_value;
2390
2391 wined3d_resource_acquire(view->resource);
2392
2393 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2394}
struct wined3d_unordered_access_view * view
Definition: cs.c:424
struct wined3d_uvec4 clear_value
Definition: cs.c:425

Referenced by wined3d_device_clear_unordered_access_view_uint().

◆ wined3d_cs_emit_copy_uav_counter()

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 at line 2410 of file cs.c.

2412{
2414
2415 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2417 op->buffer = dst_buffer;
2418 op->offset = offset;
2419 op->view = uav;
2420
2421 wined3d_resource_acquire(&dst_buffer->resource);
2423
2424 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2425}
size_t offset
Definition: cs.c:1780
struct wined3d_resource resource
struct wined3d_resource * resource

Referenced by wined3d_device_copy_uav_counter().

◆ wined3d_cs_emit_dispatch()

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 at line 738 of file cs.c.

740{
741 const struct wined3d_state *state = &cs->device->state;
742 struct wined3d_cs_dispatch *op;
743
744 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
745 op->opcode = WINED3D_CS_OP_DISPATCH;
746 op->parameters.indirect = FALSE;
747 op->parameters.u.direct.group_count_x = group_count_x;
748 op->parameters.u.direct.group_count_y = group_count_y;
749 op->parameters.u.direct.group_count_z = group_count_z;
750
752
753 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
754}
static void acquire_compute_pipeline_resources(const struct wined3d_state *state)
Definition: cs.c:731

Referenced by wined3d_device_dispatch_compute().

◆ wined3d_cs_emit_dispatch_indirect()

void wined3d_cs_emit_dispatch_indirect ( struct wined3d_cs cs,
struct wined3d_buffer buffer,
unsigned int  offset 
)

Definition at line 756 of file cs.c.

758{
759 const struct wined3d_state *state = &cs->device->state;
760 struct wined3d_cs_dispatch *op;
761
762 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
763 op->opcode = WINED3D_CS_OP_DISPATCH;
764 op->parameters.indirect = TRUE;
765 op->parameters.u.indirect.buffer = buffer;
766 op->parameters.u.indirect.offset = offset;
767
770
771 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
772}
#define TRUE
Definition: types.h:120
GLuint buffer
Definition: glext.h:5915

Referenced by wined3d_device_dispatch_compute_indirect().

◆ wined3d_cs_emit_draw()

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 at line 873 of file cs.c.

876{
877 const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
878 const struct wined3d_state *state = &cs->device->state;
879 struct wined3d_cs_draw *op;
880
881 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
882 op->opcode = WINED3D_CS_OP_DRAW;
883 op->primitive_type = primitive_type;
884 op->patch_vertex_count = patch_vertex_count;
885 op->parameters.indirect = FALSE;
886 op->parameters.u.direct.base_vertex_idx = base_vertex_idx;
887 op->parameters.u.direct.start_idx = start_idx;
888 op->parameters.u.direct.index_count = index_count;
889 op->parameters.u.direct.start_instance = start_instance;
890 op->parameters.u.direct.instance_count = instance_count;
891 op->parameters.indexed = indexed;
892
894
895 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
896}
static void acquire_graphics_pipeline_resources(const struct wined3d_state *state, BOOL indexed, const struct wined3d_gl_info *gl_info)
Definition: cs.c:839
GLint patch_vertex_count
Definition: cs.c:125
GLenum primitive_type
Definition: cs.c:124

Referenced by wined3d_device_draw_indexed_primitive(), wined3d_device_draw_indexed_primitive_instanced(), wined3d_device_draw_primitive(), and wined3d_device_draw_primitive_instanced().

◆ wined3d_cs_emit_draw_indirect()

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 at line 898 of file cs.c.

900{
901 const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
902 const struct wined3d_state *state = &cs->device->state;
903 struct wined3d_cs_draw *op;
904
905 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
906 op->opcode = WINED3D_CS_OP_DRAW;
907 op->primitive_type = primitive_type;
908 op->patch_vertex_count = patch_vertex_count;
909 op->parameters.indirect = TRUE;
910 op->parameters.u.indirect.buffer = buffer;
911 op->parameters.u.indirect.offset = offset;
912 op->parameters.indexed = indexed;
913
916
917 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
918}

Referenced by wined3d_device_draw_indexed_primitive_instanced_indirect(), and wined3d_device_draw_primitive_instanced_indirect().

◆ wined3d_cs_emit_flush()

void wined3d_cs_emit_flush ( struct wined3d_cs cs)

Definition at line 930 of file cs.c.

931{
932 struct wined3d_cs_flush *op;
933
934 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
935 op->opcode = WINED3D_CS_OP_FLUSH;
936
937 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
938 cs->queries_flushed = TRUE;
939}

Referenced by wined3d_device_end_scene(), and wined3d_query_get_data().

◆ wined3d_cs_emit_generate_mipmaps()

void wined3d_cs_emit_generate_mipmaps ( struct wined3d_cs cs,
struct wined3d_shader_resource_view view 
)

Definition at line 2436 of file cs.c.

2437{
2439
2440 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2442 op->view = view;
2443
2444 wined3d_resource_acquire(view->resource);
2445
2446 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2447}
struct wined3d_shader_resource_view * view
Definition: cs.c:439

Referenced by wined3d_shader_resource_view_generate_mipmaps().

◆ wined3d_cs_emit_preload_resource()

void wined3d_cs_emit_preload_resource ( struct wined3d_cs cs,
struct wined3d_resource resource 
)

Definition at line 1956 of file cs.c.

1957{
1959
1960 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1962 op->resource = resource;
1963
1965
1966 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1967}
#define resource
Definition: kernel32.h:9

Referenced by wined3d_resource_preload().

◆ wined3d_cs_emit_present()

void wined3d_cs_emit_present ( struct wined3d_cs cs,
struct wined3d_swapchain swapchain,
const RECT src_rect,
const RECT dst_rect,
HWND  dst_window_override,
DWORD  swap_interval,
DWORD  flags 
)

Definition at line 477 of file cs.c.

480{
481 struct wined3d_cs_present *op;
482 unsigned int i;
483 LONG pending;
484
485 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
486 op->opcode = WINED3D_CS_OP_PRESENT;
487 op->dst_window_override = dst_window_override;
488 op->swapchain = swapchain;
489 op->src_rect = *src_rect;
490 op->dst_rect = *dst_rect;
491 op->swap_interval = swap_interval;
492 op->flags = flags;
493
494 pending = InterlockedIncrement(&cs->pending_presents);
495
496 wined3d_resource_acquire(&swapchain->front_buffer->resource);
497 for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
498 {
499 wined3d_resource_acquire(&swapchain->back_buffers[i]->resource);
500 }
501
502 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
503
504 /* Limit input latency by limiting the number of presents that we can get
505 * ahead of the worker thread. We have a constant limit here, but
506 * IDXGIDevice1 allows tuning this. */
507 while (pending > 1)
508 {
510 pending = InterlockedCompareExchange(&cs->pending_presents, 0, 0);
511 }
512}
#define InterlockedCompareExchange
Definition: interlocked.h:104
long LONG
Definition: pedump.c:60
HWND dst_window_override
Definition: cs.c:93
DWORD swap_interval
Definition: cs.c:97
RECT src_rect
Definition: cs.c:95
struct wined3d_swapchain * swapchain
Definition: cs.c:94
RECT dst_rect
Definition: cs.c:96
static void wined3d_pause(void)

Referenced by wined3d_swapchain_present().

◆ wined3d_cs_emit_query_issue()

void wined3d_cs_emit_query_issue ( struct wined3d_cs cs,
struct wined3d_query query,
DWORD  flags 
)

Definition at line 1934 of file cs.c.

1935{
1936 struct wined3d_cs_query_issue *op;
1937
1938 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1939 op->opcode = WINED3D_CS_OP_QUERY_ISSUE;
1940 op->query = query;
1941 op->flags = flags;
1942
1943 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1944 cs->queries_flushed = FALSE;
1945}
struct wined3d_query * query
Definition: cs.c:353

Referenced by wined3d_query_issue().

◆ wined3d_cs_emit_reset_state()

void wined3d_cs_emit_reset_state ( struct wined3d_cs cs)

Definition at line 1856 of file cs.c.

1857{
1858 struct wined3d_cs_reset_state *op;
1859
1860 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1861 op->opcode = WINED3D_CS_OP_RESET_STATE;
1862
1863 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1864}

Referenced by wined3d_device_reset().

◆ wined3d_cs_emit_set_blend_state()

void wined3d_cs_emit_set_blend_state ( struct wined3d_cs cs,
struct wined3d_blend_state state 
)

Definition at line 1457 of file cs.c.

1458{
1460
1461 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1463 op->state = state;
1464
1465 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1466}

Referenced by wined3d_device_set_blend_state().

◆ wined3d_cs_emit_set_clip_plane()

void wined3d_cs_emit_set_clip_plane ( struct wined3d_cs cs,
UINT  plane_idx,
const struct wined3d_vec4 plane 
)

Definition at line 1582 of file cs.c.

1583{
1585
1586 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1588 op->plane_idx = plane_idx;
1589 op->plane = *plane;
1590
1591 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1592}
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 wined3d_device_set_clip_plane().

◆ wined3d_cs_emit_set_color_key()

void wined3d_cs_emit_set_color_key ( struct wined3d_cs cs,
struct wined3d_texture texture,
WORD  flags,
const struct wined3d_color_key color_key 
)

Definition at line 1657 of file cs.c.

1659{
1661
1662 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1664 op->texture = texture;
1665 op->flags = flags;
1666 if (color_key)
1667 {
1668 op->color_key = *color_key;
1669 op->set = 1;
1670 }
1671 else
1672 op->set = 0;
1673
1674 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1675}
struct wined3d_color_key color_key
Definition: cs.c:226

Referenced by wined3d_texture_set_color_key().

◆ wined3d_cs_emit_set_constant_buffer()

void wined3d_cs_emit_set_constant_buffer ( struct wined3d_cs cs,
enum wined3d_shader_type  type,
UINT  cb_idx,
struct wined3d_buffer buffer 
)

Definition at line 1228 of file cs.c.

1230{
1232
1233 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1235 op->type = type;
1236 op->cb_idx = cb_idx;
1237 op->buffer = buffer;
1238
1239 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1240}
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545

Referenced by wined3d_device_set_constant_buffer().

◆ wined3d_cs_emit_set_depth_stencil_view()

void wined3d_cs_emit_set_depth_stencil_view ( struct wined3d_cs cs,
struct wined3d_rendertarget_view view 
)

Definition at line 1057 of file cs.c.

1058{
1060
1061 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1063 op->view = view;
1064
1065 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1066}
struct wined3d_rendertarget_view * view
Definition: cs.c:163

Referenced by wined3d_device_set_depth_stencil_view().

◆ wined3d_cs_emit_set_index_buffer()

void wined3d_cs_emit_set_index_buffer ( struct wined3d_cs cs,
struct wined3d_buffer buffer,
enum wined3d_format_id  format_id,
unsigned int  offset 
)

Definition at line 1198 of file cs.c.

1200{
1202
1203 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1205 op->buffer = buffer;
1206 op->format_id = format_id;
1207 op->offset = offset;
1208
1209 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1210}
static UINT format_id
Definition: clipboard.c:1343

Referenced by wined3d_device_set_index_buffer().

◆ wined3d_cs_emit_set_light()

void wined3d_cs_emit_set_light ( struct wined3d_cs cs,
const struct wined3d_light_info light 
)

Definition at line 1733 of file cs.c.

1734{
1735 struct wined3d_cs_set_light *op;
1736
1737 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1738 op->opcode = WINED3D_CS_OP_SET_LIGHT;
1739 op->light = *light;
1740
1741 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1742}
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 light
Definition: glfuncs.h:170

Referenced by wined3d_device_set_light().

◆ wined3d_cs_emit_set_light_enable()

void wined3d_cs_emit_set_light_enable ( struct wined3d_cs cs,
unsigned int  idx,
BOOL  enable 
)

Definition at line 1766 of file cs.c.

1767{
1769
1770 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1772 op->idx = idx;
1773 op->enable = enable;
1774
1775 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1776}
unsigned int idx
Definition: utils.c:41
GLboolean enable
Definition: glext.h:11120

Referenced by wined3d_device_set_light_enable().

◆ wined3d_cs_emit_set_material()

void wined3d_cs_emit_set_material ( struct wined3d_cs cs,
const struct wined3d_material material 
)

Definition at line 1685 of file cs.c.

1686{
1688
1689 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1691 op->material = *material;
1692
1693 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1694}
struct wined3d_material material
Definition: cs.c:313

Referenced by wined3d_device_set_material().

◆ wined3d_cs_emit_set_predication()

void wined3d_cs_emit_set_predication ( struct wined3d_cs cs,
struct wined3d_query predicate,
BOOL  value 
)

Definition at line 949 of file cs.c.

950{
952
953 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
955 op->predicate = predicate;
956 op->value = value;
957
958 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
959}
struct wined3d_query * predicate
Definition: cs.c:137

Referenced by wined3d_device_set_predication().

◆ wined3d_cs_emit_set_rasterizer_state()

void wined3d_cs_emit_set_rasterizer_state ( struct wined3d_cs cs,
struct wined3d_rasterizer_state rasterizer_state 
)

Definition at line 1476 of file cs.c.

1478{
1480
1481 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1483 op->state = rasterizer_state;
1484
1485 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1486}

Referenced by wined3d_device_set_rasterizer_state().

◆ wined3d_cs_emit_set_render_state()

void wined3d_cs_emit_set_render_state ( struct wined3d_cs cs,
enum wined3d_render_state  state,
DWORD  value 
)

Definition at line 1496 of file cs.c.

1497{
1499
1500 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1502 op->state = state;
1503 op->value = value;
1504
1505 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1506}

Referenced by wined3d_device_set_render_state().

◆ wined3d_cs_emit_set_rendertarget_view()

void wined3d_cs_emit_set_rendertarget_view ( struct wined3d_cs cs,
unsigned int  view_idx,
struct wined3d_rendertarget_view view 
)

Definition at line 1007 of file cs.c.

1009{
1011
1012 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1014 op->view_idx = view_idx;
1015 op->view = view;
1016
1017 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1018}
struct wined3d_rendertarget_view * view
Definition: cs.c:157

Referenced by wined3d_device_set_rendertarget_view().

◆ wined3d_cs_emit_set_sampler()

void wined3d_cs_emit_set_sampler ( struct wined3d_cs cs,
enum wined3d_shader_type  type,
UINT  sampler_idx,
struct wined3d_sampler sampler 
)

Definition at line 1411 of file cs.c.

1413{
1414 struct wined3d_cs_set_sampler *op;
1415
1416 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1417 op->opcode = WINED3D_CS_OP_SET_SAMPLER;
1418 op->type = type;
1419 op->sampler_idx = sampler_idx;
1420 op->sampler = sampler;
1421
1422 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1423}
GLuint sampler
Definition: glext.h:7283

Referenced by wined3d_device_set_sampler().

◆ wined3d_cs_emit_set_sampler_state()

void wined3d_cs_emit_set_sampler_state ( struct wined3d_cs cs,
UINT  sampler_idx,
enum wined3d_sampler_state  state,
DWORD  value 
)

Definition at line 1538 of file cs.c.

1540{
1542
1543 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1545 op->sampler_idx = sampler_idx;
1546 op->state = state;
1547 op->value = value;
1548
1549 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1550}

Referenced by wined3d_device_set_sampler_state(), and wined3d_texture_set_lod().

◆ wined3d_cs_emit_set_scissor_rect()

void wined3d_cs_emit_set_scissor_rect ( struct wined3d_cs cs,
const RECT rect 
)

Definition at line 988 of file cs.c.

989{
991
992 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
994 op->rect = *rect;
995
996 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
997}

Referenced by wined3d_device_reset(), wined3d_device_set_rendertarget_view(), and wined3d_device_set_scissor_rect().

◆ wined3d_cs_emit_set_shader()

void wined3d_cs_emit_set_shader ( struct wined3d_cs cs,
enum wined3d_shader_type  type,
struct wined3d_shader shader 
)

◆ wined3d_cs_emit_set_shader_resource_view()

void wined3d_cs_emit_set_shader_resource_view ( struct wined3d_cs cs,
enum wined3d_shader_type  type,
UINT  view_idx,
struct wined3d_shader_resource_view view 
)

Definition at line 1352 of file cs.c.

1354{
1356
1357 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1359 op->type = type;
1360 op->view_idx = view_idx;
1361 op->view = view;
1362
1363 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1364}
struct wined3d_shader_resource_view * view
Definition: cs.c:234

Referenced by wined3d_device_set_shader_resource_view().

◆ wined3d_cs_emit_set_stream_output()

void wined3d_cs_emit_set_stream_output ( struct wined3d_cs cs,
UINT  stream_idx,
struct wined3d_buffer buffer,
UINT  offset 
)

Definition at line 1166 of file cs.c.

1168{
1170
1171 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1173 op->stream_idx = stream_idx;
1174 op->buffer = buffer;
1175 op->offset = offset;
1176
1177 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1178}

Referenced by wined3d_device_set_stream_output().

◆ wined3d_cs_emit_set_stream_source()

void wined3d_cs_emit_set_stream_source ( struct wined3d_cs cs,
UINT  stream_idx,
struct wined3d_buffer buffer,
UINT  offset,
UINT  stride 
)

Definition at line 1107 of file cs.c.

1109{
1111
1112 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1114 op->stream_idx = stream_idx;
1115 op->buffer = buffer;
1116 op->offset = offset;
1117 op->stride = stride;
1118
1119 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1120}
GLsizei stride
Definition: glext.h:5848

Referenced by wined3d_device_set_stream_source().

◆ wined3d_cs_emit_set_stream_source_freq()

void wined3d_cs_emit_set_stream_source_freq ( struct wined3d_cs cs,
UINT  stream_idx,
UINT  frequency,
UINT  flags 
)

Definition at line 1134 of file cs.c.

1135{
1137
1138 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1140 op->stream_idx = stream_idx;
1141 op->frequency = frequency;
1142 op->flags = flags;
1143
1144 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1145}
static LARGE_INTEGER * frequency
Definition: time.c:106

Referenced by wined3d_device_set_stream_source_freq().

◆ wined3d_cs_emit_set_texture()

void wined3d_cs_emit_set_texture ( struct wined3d_cs cs,
UINT  stage,
struct wined3d_texture texture 
)

Definition at line 1321 of file cs.c.

1322{
1323 struct wined3d_cs_set_texture *op;
1324
1325 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1326 op->opcode = WINED3D_CS_OP_SET_TEXTURE;
1327 op->stage = stage;
1328 op->texture = texture;
1329
1330 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1331}

Referenced by wined3d_device_set_texture().

◆ wined3d_cs_emit_set_texture_state()

void wined3d_cs_emit_set_texture_state ( struct wined3d_cs cs,
UINT  stage,
enum wined3d_texture_stage_state  state,
DWORD  value 
)

Definition at line 1516 of file cs.c.

1518{
1520
1521 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1523 op->stage = stage;
1524 op->state = state;
1525 op->value = value;
1526
1527 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1528}

Referenced by wined3d_device_set_texture_stage_state().

◆ wined3d_cs_emit_set_transform()

void wined3d_cs_emit_set_transform ( struct wined3d_cs cs,
enum wined3d_transform_state  state,
const struct wined3d_matrix matrix 
)

Definition at line 1561 of file cs.c.

1563{
1565
1566 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1568 op->state = state;
1569 op->matrix = *matrix;
1570
1571 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1572}
GLuint GLenum matrix
Definition: glext.h:9407

Referenced by wined3d_device_set_transform().

◆ wined3d_cs_emit_set_unordered_access_view()

void wined3d_cs_emit_set_unordered_access_view ( struct wined3d_cs cs,
enum wined3d_pipeline  pipeline,
unsigned int  view_idx,
struct wined3d_unordered_access_view view,
unsigned int  initial_count 
)

Definition at line 1385 of file cs.c.

1387{
1389
1390 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1392 op->pipeline = pipeline;
1393 op->view_idx = view_idx;
1394 op->view = view;
1395 op->initial_count = initial_count;
1396
1397 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1398}
enum wined3d_pipeline pipeline
Definition: cs.c:240
struct wined3d_unordered_access_view * view
Definition: cs.c:242

Referenced by wined3d_device_set_pipeline_unordered_access_view().

◆ wined3d_cs_emit_set_vertex_declaration()

void wined3d_cs_emit_set_vertex_declaration ( struct wined3d_cs cs,
struct wined3d_vertex_declaration declaration 
)

Definition at line 1076 of file cs.c.

1077{
1079
1080 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1082 op->declaration = declaration;
1083
1084 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1085}
struct wined3d_vertex_declaration * declaration
Definition: cs.c:169

Referenced by wined3d_device_set_vertex_declaration().

◆ wined3d_cs_emit_set_viewport()

void wined3d_cs_emit_set_viewport ( struct wined3d_cs cs,
const struct wined3d_viewport viewport 
)

Definition at line 969 of file cs.c.

970{
972
973 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
975 op->viewport = *viewport;
976
977 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
978}
struct wined3d_viewport viewport
Definition: cs.c:144

Referenced by wined3d_device_reset(), wined3d_device_set_rendertarget_view(), and wined3d_device_set_viewport().

◆ wined3d_cs_emit_stop()

static void wined3d_cs_emit_stop ( struct wined3d_cs cs)
static

Definition at line 2449 of file cs.c.

2450{
2451 struct wined3d_cs_stop *op;
2452
2453 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
2454 op->opcode = WINED3D_CS_OP_STOP;
2455
2456 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2457 cs->ops->finish(cs, WINED3D_CS_QUEUE_DEFAULT);
2458}

Referenced by wined3d_cs_destroy().

◆ wined3d_cs_emit_unload_resource()

void wined3d_cs_emit_unload_resource ( struct wined3d_cs cs,
struct wined3d_resource resource 
)

Definition at line 1978 of file cs.c.

1979{
1981
1982 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_DEFAULT);
1984 op->resource = resource;
1985
1987
1988 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
1989}

Referenced by wined3d_device_delete_opengl_contexts_cs(), wined3d_device_evict_managed_resources(), and wined3d_texture_update_desc().

◆ wined3d_cs_emit_update_sub_resource()

void wined3d_cs_emit_update_sub_resource ( struct wined3d_cs cs,
struct wined3d_resource resource,
unsigned int  sub_resource_idx,
const struct wined3d_box box,
const void data,
unsigned int  row_pitch,
unsigned int  slice_pitch 
)

Definition at line 2260 of file cs.c.

2263{
2265#if defined(STAGING_CSMT)
2266 size_t data_size, size;
2267
2268 if (resource->type != WINED3D_RTYPE_BUFFER && resource->format_flags & WINED3DFMT_FLAG_BLOCKS)
2269 goto no_async;
2270
2271 data_size = 0;
2272 switch (resource->type)
2273 {
2275 data_size += (box->back - box->front - 1) * slice_pitch;
2276 /* fall-through */
2278 data_size += (box->bottom - box->top - 1) * row_pitch;
2279 /* fall-through */
2281 data_size += (box->right - box->left) * resource->format->byte_count;
2282 break;
2284 data_size = box->right - box->left;
2285 break;
2286 case WINED3D_RTYPE_NONE:
2287 return;
2288 }
2289
2290 size = FIELD_OFFSET(struct wined3d_cs_update_sub_resource, copy_data[data_size]);
2291 if (!cs->ops->check_space(cs, size, WINED3D_CS_QUEUE_DEFAULT))
2292 goto no_async;
2293
2294 op = cs->ops->require_space(cs, size, WINED3D_CS_QUEUE_DEFAULT);
2296 op->resource = resource;
2297 op->sub_resource_idx = sub_resource_idx;
2298 op->box = *box;
2299 op->data.row_pitch = row_pitch;
2300 op->data.slice_pitch = slice_pitch;
2301 op->data.data = op->copy_data;
2302 memcpy(op->copy_data, data, data_size);
2303
2305
2306 cs->ops->submit(cs, WINED3D_CS_QUEUE_DEFAULT);
2307 return;
2308
2309no_async:
2311#endif /* STAGING_CSMT */
2312
2313 op = cs->ops->require_space(cs, sizeof(*op), WINED3D_CS_QUEUE_MAP);
2315 op->resource = resource;
2316 op->sub_resource_idx = sub_resource_idx;
2317 op->box = *box;
2318 op->data.row_pitch = row_pitch;
2319 op->data.slice_pitch = slice_pitch;
2320 op->data.data = data;
2321
2323
2324 cs->ops->submit(cs, WINED3D_CS_QUEUE_MAP);
2325#if !defined(STAGING_CSMT)
2326 /* The data pointer may go away, so we need to wait until it is read.
2327 * Copying the data may be faster if it's small. */
2328#endif /* STAGING_CSMT */
2329 cs->ops->finish(cs, WINED3D_CS_QUEUE_MAP);
2330}
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
Definition: palette.c:468
struct wined3d_box box
Definition: cs.c:407
unsigned int sub_resource_idx
Definition: cs.c:406
@ WINED3D_RTYPE_TEXTURE_2D
Definition: wined3d.h:700
@ WINED3D_RTYPE_TEXTURE_1D
Definition: wined3d.h:699
@ WINED3D_RTYPE_NONE
Definition: wined3d.h:697
@ WINED3D_RTYPE_BUFFER
Definition: wined3d.h:698
@ WINED3D_RTYPE_TEXTURE_3D
Definition: wined3d.h:701
#define WINED3DFMT_FLAG_BLOCKS
static void wined3d_resource_wait_idle(struct wined3d_resource *resource)
@ WINED3D_CS_QUEUE_MAP

Referenced by wined3d_device_update_sub_resource().

◆ wined3d_cs_exec_add_dirty_texture_region()

static void wined3d_cs_exec_add_dirty_texture_region ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 2332 of file cs.c.

2333{
2335 struct wined3d_texture *texture = op->texture;
2336 unsigned int sub_resource_idx, i;
2337 struct wined3d_context *context;
2338
2339 context = context_acquire(cs->device, NULL, 0);
2340 sub_resource_idx = op->layer * texture->level_count;
2341 for (i = 0; i < texture->level_count; ++i, ++sub_resource_idx)
2342 {
2345 else
2346 ERR("Failed to load location %s.\n", wined3d_debug_location(texture->resource.map_binding));
2347 }
2349
2351}
struct wined3d_context * context_acquire(const struct wined3d_device *device, struct wined3d_texture *texture, unsigned int sub_resource_idx)
Definition: context.c:4242
void context_release(struct wined3d_context *context)
Definition: context.c:1571
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
const char * wined3d_debug_location(DWORD location)
Definition: utils.c:6396
Definition: http.c:7252
unsigned int sub_resource_idx

◆ wined3d_cs_exec_blt_sub_resource()

static void wined3d_cs_exec_blt_sub_resource ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 2052 of file cs.c.

2053{
2054 const struct wined3d_cs_blt_sub_resource *op = data;
2055
2056 if (op->dst_resource->type == WINED3D_RTYPE_BUFFER)
2057 {
2058 wined3d_buffer_copy(buffer_from_resource(op->dst_resource), op->dst_box.left,
2059 buffer_from_resource(op->src_resource), op->src_box.left,
2060 op->src_box.right - op->src_box.left);
2061 }
2062 else if (op->dst_resource->type == WINED3D_RTYPE_TEXTURE_2D)
2063 {
2064 struct wined3d_surface *dst_surface, *src_surface;
2065 struct wined3d_texture *dst_texture, *src_texture;
2066 RECT dst_rect, src_rect;
2067
2068 dst_texture = texture_from_resource(op->dst_resource);
2069 src_texture = texture_from_resource(op->src_resource);
2070 dst_surface = dst_texture->sub_resources[op->dst_sub_resource_idx].u.surface;
2071 src_surface = src_texture->sub_resources[op->src_sub_resource_idx].u.surface;
2072 SetRect(&dst_rect, op->dst_box.left, op->dst_box.top, op->dst_box.right, op->dst_box.bottom);
2073 SetRect(&src_rect, op->src_box.left, op->src_box.top, op->src_box.right, op->src_box.bottom);
2074
2075 if (FAILED(wined3d_surface_blt(dst_surface, &dst_rect, src_surface,
2076 &src_rect, op->flags, &op->fx, op->filter)))
2077 FIXME("Blit failed.\n");
2078 }
2079 else if (op->dst_resource->type == WINED3D_RTYPE_TEXTURE_3D)
2080 {
2081 struct wined3d_texture *src_texture, *dst_texture;
2082 unsigned int level, update_w, update_h, update_d;
2083 unsigned int row_pitch, slice_pitch;
2084 struct wined3d_context *context;
2085 struct wined3d_bo_address addr;
2086
2087 if (op->flags & ~WINED3D_BLT_RAW)
2088 {
2089 FIXME("Flags %#x not implemented for %s resources.\n",
2090 op->flags, debug_d3dresourcetype(op->dst_resource->type));
2091 goto error;
2092 }
2093
2094 if (!(op->flags & WINED3D_BLT_RAW) && op->src_resource->format != op->dst_resource->format)
2095 {
2096 FIXME("Format conversion not implemented for %s resources.\n",
2097 debug_d3dresourcetype(op->dst_resource->type));
2098 goto error;
2099 }
2100
2101 update_w = op->dst_box.right - op->dst_box.left;
2102 update_h = op->dst_box.bottom - op->dst_box.top;
2103 update_d = op->dst_box.back - op->dst_box.front;
2104 if (op->src_box.right - op->src_box.left != update_w
2105 || op->src_box.bottom - op->src_box.top != update_h
2106 || op->src_box.back - op->src_box.front != update_d)
2107 {
2108 FIXME("Stretching not implemented for %s resources.\n",
2109 debug_d3dresourcetype(op->dst_resource->type));
2110 goto error;
2111 }
2112
2113 if (op->src_box.left || op->src_box.top || op->src_box.front)
2114 {
2115 FIXME("Source box %s not supported for %s resources.\n",
2116 debug_box(&op->src_box), debug_d3dresourcetype(op->dst_resource->type));
2117 goto error;
2118 }
2119
2120 dst_texture = texture_from_resource(op->dst_resource);
2121 src_texture = texture_from_resource(op->src_resource);
2122
2123 context = context_acquire(cs->device, NULL, 0);
2124
2125 if (!wined3d_texture_load_location(src_texture, op->src_sub_resource_idx,
2126 context, src_texture->resource.map_binding))
2127 {
2128 ERR("Failed to load source sub-resource into %s.\n",
2129 wined3d_debug_location(src_texture->resource.map_binding));
2131 goto error;
2132 }
2133
2134 level = op->dst_sub_resource_idx % dst_texture->level_count;
2135 if (update_w == wined3d_texture_get_level_width(dst_texture, level)
2136 && update_h == wined3d_texture_get_level_height(dst_texture, level)
2137 && update_d == wined3d_texture_get_level_depth(dst_texture, level))
2138 {
2140 }
2141 else if (!wined3d_texture_load_location(dst_texture, op->dst_sub_resource_idx,
2143 {
2144 ERR("Failed to load destination sub-resource.\n");
2146 goto error;
2147 }
2148
2149 wined3d_texture_get_memory(src_texture, op->src_sub_resource_idx, &addr, src_texture->resource.map_binding);
2150 wined3d_texture_get_pitch(src_texture, op->src_sub_resource_idx % src_texture->level_count,
2151 &row_pitch, &slice_pitch);
2152
2154 wined3d_texture_upload_data(dst_texture, op->dst_sub_resource_idx, context, &op->dst_box,
2155 wined3d_const_bo_address(&addr), row_pitch, slice_pitch);
2156 wined3d_texture_validate_location(dst_texture, op->dst_sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
2157 wined3d_texture_invalidate_location(dst_texture, op->dst_sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
2158
2160 }
2161 else
2162 {
2163 FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(op->dst_resource->type));
2164 }
2165
2166error:
2167 if (op->src_resource)
2168 wined3d_resource_release(op->src_resource);
2169 wined3d_resource_release(op->dst_resource);
2170}
#define FIXME(fmt,...)
Definition: debug.h:111
void wined3d_buffer_copy(struct wined3d_buffer *dst_buffer, unsigned int dst_offset, struct wined3d_buffer *src_buffer, unsigned int src_offset, unsigned int size)
Definition: buffer.c:1195
HRESULT wined3d_surface_blt(struct wined3d_surface *dst_surface, const RECT *dst_rect, struct wined3d_surface *src_surface, const RECT *src_rect, DWORD flags, const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
Definition: surface.c:3998
void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
Definition: texture.c:1546
void wined3d_texture_bind_and_dirtify(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
Definition: texture.c:868
void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, const struct wined3d_context *context, const struct wined3d_box *box, const struct wined3d_const_bo_address *data, unsigned int row_pitch, unsigned int slice_pitch)
Definition: texture.c:1696
void wined3d_texture_get_memory(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_bo_address *data, DWORD locations)
Definition: texture.c:285
void wined3d_texture_validate_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, DWORD location)
Definition: texture.c:135
void CDECL wined3d_texture_get_pitch(const struct wined3d_texture *texture, unsigned int level, unsigned int *row_pitch, unsigned int *slice_pitch)
Definition: texture.c:1168
const char * debug_box(const struct wined3d_box *box)
Definition: utils.c:3939
const char * debug_d3dresourcetype(enum wined3d_resource_type resource_type)
Definition: utils.c:4329
GLint level
Definition: gl.h:1546
GLenum const GLvoid * addr
Definition: glext.h:9621
#define FAILED(hr)
Definition: intsafe.h:51
#define error(str)
Definition: mkdosfs.c:1605
unsigned int slice_pitch
unsigned int row_pitch
struct wined3d_resource resource
struct wined3d_texture::wined3d_texture_sub_resource sub_resources[1]
#define WINED3D_BLT_RAW
Definition: wined3d.h:1366
static unsigned int wined3d_texture_get_level_height(const struct wined3d_texture *texture, unsigned int level)
static unsigned int wined3d_texture_get_level_width(const struct wined3d_texture *texture, unsigned int level)
#define WINED3D_LOCATION_TEXTURE_RGB
static struct wined3d_texture * texture_from_resource(struct wined3d_resource *resource)
static struct wined3d_buffer * buffer_from_resource(struct wined3d_resource *resource)
static unsigned int wined3d_texture_get_level_depth(const struct wined3d_texture *texture, unsigned int level)

◆ wined3d_cs_exec_callback()

static void wined3d_cs_exec_callback ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1866 of file cs.c.

1867{
1868 const struct wined3d_cs_callback *op = data;
1869
1870 op->callback(op->object);
1871}

◆ wined3d_cs_exec_clear()

static void wined3d_cs_exec_clear ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 514 of file cs.c.

515{
516 const struct wined3d_cs_clear *op = data;
517 struct wined3d_device *device;
518 unsigned int i;
519
520 device = cs->device;
521 device->blitter->ops->blitter_clear(device->blitter, device, op->rt_count, op->fb,
522 op->rect_count, op->rects, &op->draw_rect, op->flags, &op->color, op->depth, op->stencil);
523
524 if (op->flags & WINED3DCLEAR_TARGET)
525 {
526 for (i = 0; i < op->rt_count; ++i)
527 {
528 if (op->fb->render_targets[i])
529 wined3d_resource_release(op->fb->render_targets[i]->resource);
530 }
531 }
533 wined3d_resource_release(op->fb->depth_stencil->resource);
534}

◆ wined3d_cs_exec_clear_unordered_access_view()

static void wined3d_cs_exec_clear_unordered_access_view ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 2368 of file cs.c.

2369{
2371 struct wined3d_unordered_access_view *view = op->view;
2372 struct wined3d_context *context;
2373
2374 context = context_acquire(cs->device, NULL, 0);
2377
2378 wined3d_resource_release(view->resource);
2379}
void wined3d_unordered_access_view_clear_uint(struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value, struct wined3d_context *context)
Definition: view.c:1004

◆ wined3d_cs_exec_copy_uav_counter()

static void wined3d_cs_exec_copy_uav_counter ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 2396 of file cs.c.

2397{
2398 const struct wined3d_cs_copy_uav_counter *op = data;
2399 struct wined3d_unordered_access_view *view = op->view;
2400 struct wined3d_context *context;
2401
2402 context = context_acquire(cs->device, NULL, 0);
2405
2406 wined3d_resource_release(&op->buffer->resource);
2407 wined3d_resource_release(view->resource);
2408}
void wined3d_unordered_access_view_copy_counter(struct wined3d_unordered_access_view *view, struct wined3d_buffer *buffer, unsigned int offset, struct wined3d_context *context)
Definition: view.c:1063

◆ wined3d_cs_exec_dispatch()

static void wined3d_cs_exec_dispatch ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 716 of file cs.c.

717{
718 const struct wined3d_cs_dispatch *op = data;
719 struct wined3d_state *state = &cs->state;
720
721 dispatch_compute(cs->device, state, &op->parameters);
722
723 if (op->parameters.indirect)
724 wined3d_resource_release(&op->parameters.u.indirect.buffer->resource);
725
728 state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
729}
static void release_unordered_access_resources(const struct wined3d_shader *shader, struct wined3d_unordered_access_view *const *views)
Definition: cs.c:696
static void release_shader_resources(const struct wined3d_state *state, unsigned int shader_mask)
Definition: cs.c:643
void dispatch_compute(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_dispatch_parameters *parameters)
Definition: context.c:4327

◆ wined3d_cs_exec_draw()

static void wined3d_cs_exec_draw ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 774 of file cs.c.

775{
776 const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
777 struct wined3d_state *state = &cs->state;
778 const struct wined3d_cs_draw *op = data;
779 int load_base_vertex_idx;
780 unsigned int i;
781
782 /* ARB_draw_indirect always supports a base vertex offset. */
783 if (!op->parameters.indirect && !gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX])
784 load_base_vertex_idx = op->parameters.u.direct.base_vertex_idx;
785 else
786 load_base_vertex_idx = 0;
787
788 if (state->load_base_vertex_index != load_base_vertex_idx)
789 {
790 state->load_base_vertex_index = load_base_vertex_idx;
792 }
793
794 if (state->gl_primitive_type != op->primitive_type)
795 {
796 if (state->gl_primitive_type == GL_POINTS || op->primitive_type == GL_POINTS)
798 state->gl_primitive_type = op->primitive_type;
799 }
800 state->gl_patch_vertices = op->patch_vertex_count;
801
802 draw_primitive(cs->device, state, &op->parameters);
803
804 if (op->parameters.indirect)
805 {
806 struct wined3d_buffer *buffer = op->parameters.u.indirect.buffer;
808 }
809
810 if (op->parameters.indexed)
811 wined3d_resource_release(&state->index_buffer->resource);
812 for (i = 0; i < ARRAY_SIZE(state->streams); ++i)
813 {
814 if (state->streams[i].buffer)
815 wined3d_resource_release(&state->streams[i].buffer->resource);
816 }
817 for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
818 {
819 if (state->stream_output[i].buffer)
820 wined3d_resource_release(&state->stream_output[i].buffer->resource);
821 }
822 for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
823 {
824 if (state->textures[i])
825 wined3d_resource_release(&state->textures[i]->resource);
826 }
827 for (i = 0; i < gl_info->limits.buffers; ++i)
828 {
829 if (state->fb->render_targets[i])
830 wined3d_resource_release(state->fb->render_targets[i]->resource);
831 }
832 if (state->fb->depth_stencil)
833 wined3d_resource_release(state->fb->depth_stencil->resource);
836 state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
837}
void draw_primitive(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_draw_parameters *parameters)
Definition: context.c:4924
void device_invalidate_state(const struct wined3d_device *device, DWORD state)
Definition: device.c:5263
#define GL_POINTS
Definition: gl.h:190
BOOL supported[WINED3D_GL_EXT_COUNT]
@ ARB_DRAW_ELEMENTS_BASE_VERTEX
Definition: wined3d_gl.h:62
#define STATE_BASEVERTEXINDEX
#define STATE_POINT_ENABLE

◆ wined3d_cs_exec_flush()

static void wined3d_cs_exec_flush ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 920 of file cs.c.

921{
922 struct wined3d_context *context;
923
924 context = context_acquire(cs->device, NULL, 0);
925 if (context->valid)
926 context->gl_info->gl_ops.gl.p_glFlush();
928}

◆ wined3d_cs_exec_generate_mipmaps()

static void wined3d_cs_exec_generate_mipmaps ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 2427 of file cs.c.

2428{
2429 const struct wined3d_cs_generate_mipmaps *op = data;
2430 struct wined3d_shader_resource_view *view = op->view;
2431
2433 wined3d_resource_release(view->resource);
2434}
void shader_resource_view_generate_mipmaps(struct wined3d_shader_resource_view *view)
Definition: view.c:851

◆ wined3d_cs_exec_map()

static void wined3d_cs_exec_map ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1991 of file cs.c.

1992{
1993 const struct wined3d_cs_map *op = data;
1994 struct wined3d_resource *resource = op->resource;
1995
1996 *op->hr = resource->resource_ops->resource_sub_resource_map(resource,
1997 op->sub_resource_idx, op->map_desc, op->box, op->flags);
1998}

◆ wined3d_cs_exec_nop()

static void wined3d_cs_exec_nop ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 447 of file cs.c.

448{
449}

◆ wined3d_cs_exec_preload_resource()

static void wined3d_cs_exec_preload_resource ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1947 of file cs.c.

1948{
1949 const struct wined3d_cs_preload_resource *op = data;
1950 struct wined3d_resource *resource = op->resource;
1951
1952 resource->resource_ops->resource_preload(resource);
1954}

◆ wined3d_cs_exec_present()

static void wined3d_cs_exec_present ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 451 of file cs.c.

452{
453 const struct wined3d_cs_present *op = data;
454 struct wined3d_swapchain *swapchain;
455 unsigned int i;
456
457 swapchain = op->swapchain;
458 wined3d_swapchain_set_window(swapchain, op->dst_window_override);
459
460 if (op->swap_interval && swapchain->desc.swap_interval != op->swap_interval)
461 {
462 swapchain->desc.swap_interval = op->swap_interval;
464 }
465
466 swapchain->swapchain_ops->swapchain_present(swapchain, &op->src_rect, &op->dst_rect, op->flags);
467
468 wined3d_resource_release(&swapchain->front_buffer->resource);
469 for (i = 0; i < swapchain->desc.backbuffer_count; ++i)
470 {
471 wined3d_resource_release(&swapchain->back_buffers[i]->resource);
472 }
473
474 InterlockedDecrement(&cs->pending_presents);
475}
#define InterlockedDecrement
Definition: armddk.h:52
struct wined3d_texture ** back_buffers
struct wined3d_swapchain_desc desc
const struct wined3d_swapchain_ops * swapchain_ops
struct wined3d_texture * front_buffer
void swapchain_update_swap_interval(struct wined3d_swapchain *swapchain)
Definition: swapchain.c:1144
void CDECL wined3d_swapchain_set_window(struct wined3d_swapchain *swapchain, HWND window)
Definition: swapchain.c:140

◆ wined3d_cs_exec_push_constants()

static void wined3d_cs_exec_push_constants ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1821 of file cs.c.

1822{
1823 const struct wined3d_cs_push_constants *op = data;
1824
1825 wined3d_cs_st_push_constants(cs, op->type, op->start_idx, op->count, op->constants);
1826}
static void wined3d_cs_st_push_constants(struct wined3d_cs *cs, enum wined3d_push_constants p, unsigned int start_idx, unsigned int count, const void *constants)
Definition: cs.c:1800

◆ wined3d_cs_exec_query_issue()

static void wined3d_cs_exec_query_issue ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1895 of file cs.c.

1896{
1897 const struct wined3d_cs_query_issue *op = data;
1898 struct wined3d_query *query = op->query;
1899 BOOL poll;
1900
1901 poll = query->query_ops->query_issue(query, op->flags);
1902
1903 if (!cs->thread)
1904 return;
1905
1906 if (poll && list_empty(&query->poll_list_entry))
1907 {
1908 list_add_tail(&cs->query_poll_list, &query->poll_list_entry);
1909 return;
1910 }
1911
1912 /* This can happen if occlusion queries are restarted. This discards the
1913 * old result, since polling it could result in a GL error. */
1914 if ((op->flags & WINED3DISSUE_BEGIN) && !poll && !list_empty(&query->poll_list_entry))
1915 {
1916 list_remove(&query->poll_list_entry);
1917 list_init(&query->poll_list_entry);
1918 InterlockedIncrement(&query->counter_retrieved);
1919 return;
1920 }
1921
1922 /* This can happen when an occlusion query is ended without being started,
1923 * in which case we don't want to poll, but still have to counter-balance
1924 * the increment of the main counter.
1925 *
1926 * This can also happen if an event query is re-issued before the first
1927 * fence was reached. In this case the query is already in the list and
1928 * the poll function will check the new fence. We have to counter-balance
1929 * the discarded increment. */
1930 if (op->flags & WINED3DISSUE_END)
1931 InterlockedIncrement(&query->counter_retrieved);
1932}
static int list_empty(struct list_entry *head)
Definition: list.h:58
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
unsigned int BOOL
Definition: ntddk_ex.h:94
#define WINED3DISSUE_BEGIN
Definition: wined3d.h:761
#define WINED3DISSUE_END
Definition: wined3d.h:762
#define poll
Definition: wintirpc.h:59

◆ wined3d_cs_exec_reset_state()

static void wined3d_cs_exec_reset_state ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1846 of file cs.c.

1847{
1848 struct wined3d_adapter *adapter = cs->device->adapter;
1849
1850 state_cleanup(&cs->state);
1851 memset(&cs->state, 0, sizeof(cs->state));
1852 state_init(&cs->state, &cs->fb, &adapter->gl_info, &adapter->d3d_info,
1854}
return adapter

◆ wined3d_cs_exec_set_blend_state()

static void wined3d_cs_exec_set_blend_state ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1449 of file cs.c.

1450{
1451 const struct wined3d_cs_set_blend_state *op = data;
1452
1453 cs->state.blend_state = op->state;
1455}
#define STATE_BLEND

◆ wined3d_cs_exec_set_clip_plane()

static void wined3d_cs_exec_set_clip_plane ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1574 of file cs.c.

1575{
1576 const struct wined3d_cs_set_clip_plane *op = data;
1577
1578 cs->state.clip_planes[op->plane_idx] = op->plane;
1579 device_invalidate_state(cs->device, STATE_CLIPPLANE(op->plane_idx));
1580}
#define STATE_CLIPPLANE(a)

◆ wined3d_cs_exec_set_color_key()

static void wined3d_cs_exec_set_color_key ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1594 of file cs.c.

1595{
1596 const struct wined3d_cs_set_color_key *op = data;
1597 struct wined3d_texture *texture = op->texture;
1598
1599 if (op->set)
1600 {
1601 switch (op->flags)
1602 {
1604 texture->async.dst_blt_color_key = op->color_key;
1605 texture->async.color_key_flags |= WINED3D_CKEY_DST_BLT;
1606 break;
1607
1609 texture->async.dst_overlay_color_key = op->color_key;
1610 texture->async.color_key_flags |= WINED3D_CKEY_DST_OVERLAY;
1611 break;
1612
1614 if (texture == cs->state.textures[0])
1615 {
1617 if (!(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
1619 }
1620
1621 texture->async.src_blt_color_key = op->color_key;
1622 texture->async.color_key_flags |= WINED3D_CKEY_SRC_BLT;
1623 break;
1624
1626 texture->async.src_overlay_color_key = op->color_key;
1627 texture->async.color_key_flags |= WINED3D_CKEY_SRC_OVERLAY;
1628 break;
1629 }
1630 }
1631 else
1632 {
1633 switch (op->flags)
1634 {
1636 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_BLT;
1637 break;
1638
1640 texture->async.color_key_flags &= ~WINED3D_CKEY_DST_OVERLAY;
1641 break;
1642
1644 if (texture == cs->state.textures[0] && texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1646
1647 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_BLT;
1648 break;
1649
1651 texture->async.color_key_flags &= ~WINED3D_CKEY_SRC_OVERLAY;
1652 break;
1653 }
1654 }
1655}
#define WINED3D_CKEY_DST_BLT
Definition: wined3d.h:1334
@ WINED3D_RS_COLORKEYENABLE
Definition: wined3d.h:300
#define WINED3D_CKEY_SRC_OVERLAY
Definition: wined3d.h:1337
#define WINED3D_CKEY_SRC_BLT
Definition: wined3d.h:1336
#define WINED3D_CKEY_DST_OVERLAY
Definition: wined3d.h:1335
#define STATE_RENDER(a)
#define STATE_COLOR_KEY

◆ wined3d_cs_exec_set_constant_buffer()

static void wined3d_cs_exec_set_constant_buffer ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1212 of file cs.c.

1213{
1214 const struct wined3d_cs_set_constant_buffer *op = data;
1215 struct wined3d_buffer *prev;
1216
1217 prev = cs->state.cb[op->type][op->cb_idx];
1218 cs->state.cb[op->type][op->cb_idx] = op->buffer;
1219
1220 if (op->buffer)
1221 InterlockedIncrement(&op->buffer->resource.bind_count);
1222 if (prev)
1223 InterlockedDecrement(&prev->resource.bind_count);
1224
1226}
#define STATE_CONSTANT_BUFFER(a)

◆ wined3d_cs_exec_set_depth_stencil_view()

static void wined3d_cs_exec_set_depth_stencil_view ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1020 of file cs.c.

1021{
1023 struct wined3d_device *device = cs->device;
1024 struct wined3d_rendertarget_view *prev;
1025
1026 if ((prev = cs->state.fb->depth_stencil))
1027 {
1028 struct wined3d_surface *prev_surface = wined3d_rendertarget_view_get_surface(prev);
1029
1030 if (prev_surface && (device->swapchains[0]->desc.flags & WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
1031 || prev_surface->container->flags & WINED3D_TEXTURE_DISCARD))
1032 {
1035 }
1036 }
1037
1038 cs->fb.depth_stencil = op->view;
1039
1040 if (!prev != !op->view)
1041 {
1042 /* Swapping NULL / non NULL depth stencil affects the depth and tests */
1048 }
1049 else if (prev && prev->format->depth_bias_scale != op->view->format->depth_bias_scale)
1050 {
1052 }
1053
1055}
const struct wined3d_format * format
struct wined3d_texture * container
@ WINED3D_RS_STENCILENABLE
Definition: wined3d.h:306
@ WINED3D_RS_ZENABLE
Definition: wined3d.h:269
@ WINED3D_RS_DEPTHBIAS
Definition: wined3d.h:378
@ WINED3D_RS_DEPTHBIASCLAMP
Definition: wined3d.h:392
@ WINED3D_RS_STENCILWRITEMASK
Definition: wined3d.h:313
#define WINED3D_SWAPCHAIN_DISCARD_DEPTHSTENCIL
Definition: wined3d.h:878
static struct wined3d_surface * wined3d_rendertarget_view_get_surface(const struct wined3d_rendertarget_view *view)
#define WINED3D_TEXTURE_DISCARD
#define WINED3D_LOCATION_DISCARDED
#define STATE_FRAMEBUFFER

◆ wined3d_cs_exec_set_index_buffer()

static void wined3d_cs_exec_set_index_buffer ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1180 of file cs.c.

1181{
1182 const struct wined3d_cs_set_index_buffer *op = data;
1183 struct wined3d_buffer *prev;
1184
1185 prev = cs->state.index_buffer;
1186 cs->state.index_buffer = op->buffer;
1187 cs->state.index_format = op->format_id;
1188 cs->state.index_offset = op->offset;
1189
1190 if (op->buffer)
1191 InterlockedIncrement(&op->buffer->resource.bind_count);
1192 if (prev)
1193 InterlockedDecrement(&prev->resource.bind_count);
1194
1196}
#define STATE_INDEXBUFFER

◆ wined3d_cs_exec_set_light()

static void wined3d_cs_exec_set_light ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1696 of file cs.c.

1697{
1698 const struct wined3d_cs_set_light *op = data;
1699 struct wined3d_light_info *light_info;
1700 unsigned int light_idx, hash_idx;
1701
1702 light_idx = op->light.OriginalIndex;
1703
1704 if (!(light_info = wined3d_state_get_light(&cs->state, light_idx)))
1705 {
1706 TRACE("Adding new light.\n");
1707 if (!(light_info = heap_alloc_zero(sizeof(*light_info))))
1708 {
1709 ERR("Failed to allocate light info.\n");
1710 return;
1711 }
1712
1713 hash_idx = LIGHTMAP_HASHFUNC(light_idx);
1714 list_add_head(&cs->state.light_map[hash_idx], &light_info->entry);
1715 light_info->glIndex = -1;
1716 light_info->OriginalIndex = light_idx;
1717 }
1718
1719 if (light_info->glIndex != -1)
1720 {
1721 if (light_info->OriginalParms.type != op->light.OriginalParms.type)
1723 device_invalidate_state(cs->device, STATE_ACTIVELIGHT(light_info->glIndex));
1724 }
1725
1726 light_info->OriginalParms = op->light.OriginalParms;
1727 light_info->position = op->light.position;
1728 light_info->direction = op->light.direction;
1729 light_info->exponent = op->light.exponent;
1730 light_info->cutoff = op->light.cutoff;
1731}
static void list_add_head(struct list_entry *head, struct list_entry *entry)
Definition: list.h:76
#define TRACE(s)
Definition: solgame.cpp:4
struct wined3d_vec4 position
struct wined3d_light OriginalParms
struct wined3d_vec4 direction
struct wined3d_light_info * wined3d_state_get_light(const struct wined3d_state *state, unsigned int idx)
Definition: stateblock.c:567
#define STATE_LIGHT_TYPE
#define STATE_ACTIVELIGHT(a)
#define LIGHTMAP_HASHFUNC(x)

◆ wined3d_cs_exec_set_light_enable()

static void wined3d_cs_exec_set_light_enable ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1744 of file cs.c.

1745{
1746 const struct wined3d_cs_set_light_enable *op = data;
1747 struct wined3d_device *device = cs->device;
1748 struct wined3d_light_info *light_info;
1749 int prev_idx;
1750
1751 if (!(light_info = wined3d_state_get_light(&cs->state, op->idx)))
1752 {
1753 ERR("Light doesn't exist.\n");
1754 return;
1755 }
1756
1757 prev_idx = light_info->glIndex;
1758 wined3d_state_enable_light(&cs->state, &device->adapter->d3d_info, light_info, op->enable);
1759 if (light_info->glIndex != prev_idx)
1760 {
1762 device_invalidate_state(device, STATE_ACTIVELIGHT(op->enable ? light_info->glIndex : prev_idx));
1763 }
1764}
void wined3d_state_enable_light(struct wined3d_state *state, const struct wined3d_d3d_info *d3d_info, struct wined3d_light_info *light_info, BOOL enable)
Definition: stateblock.c:582

◆ wined3d_cs_exec_set_material()

static void wined3d_cs_exec_set_material ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1677 of file cs.c.

1678{
1679 const struct wined3d_cs_set_material *op = data;
1680
1681 cs->state.material = op->material;
1683}
#define STATE_MATERIAL

◆ wined3d_cs_exec_set_predication()

static void wined3d_cs_exec_set_predication ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 941 of file cs.c.

942{
943 const struct wined3d_cs_set_predication *op = data;
944
945 cs->state.predicate = op->predicate;
946 cs->state.predicate_value = op->value;
947}

◆ wined3d_cs_exec_set_rasterizer_state()

static void wined3d_cs_exec_set_rasterizer_state ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1468 of file cs.c.

1469{
1470 const struct wined3d_cs_set_rasterizer_state *op = data;
1471
1472 cs->state.rasterizer_state = op->state;
1474}
#define STATE_FRONTFACE

◆ wined3d_cs_exec_set_render_state()

static void wined3d_cs_exec_set_render_state ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1488 of file cs.c.

1489{
1490 const struct wined3d_cs_set_render_state *op = data;
1491
1492 cs->state.render_states[op->state] = op->value;
1493 device_invalidate_state(cs->device, STATE_RENDER(op->state));
1494}

◆ wined3d_cs_exec_set_rendertarget_view()

static void wined3d_cs_exec_set_rendertarget_view ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 999 of file cs.c.

1000{
1002
1003 cs->fb.render_targets[op->view_idx] = op->view;
1005}

◆ wined3d_cs_exec_set_sampler()

static void wined3d_cs_exec_set_sampler ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1400 of file cs.c.

1401{
1402 const struct wined3d_cs_set_sampler *op = data;
1403
1404 cs->state.sampler[op->type][op->sampler_idx] = op->sampler;
1405 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1407 else
1409}
#define STATE_GRAPHICS_SHADER_RESOURCE_BINDING
#define STATE_COMPUTE_SHADER_RESOURCE_BINDING

◆ wined3d_cs_exec_set_sampler_state()

static void wined3d_cs_exec_set_sampler_state ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1530 of file cs.c.

1531{
1532 const struct wined3d_cs_set_sampler_state *op = data;
1533
1534 cs->state.sampler_states[op->sampler_idx][op->state] = op->value;
1535 device_invalidate_state(cs->device, STATE_SAMPLER(op->sampler_idx));
1536}
#define STATE_SAMPLER(num)

◆ wined3d_cs_exec_set_scissor_rect()

static void wined3d_cs_exec_set_scissor_rect ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 980 of file cs.c.

981{
982 const struct wined3d_cs_set_scissor_rect *op = data;
983
984 cs->state.scissor_rect = op->rect;
986}
#define STATE_SCISSORRECT

◆ wined3d_cs_exec_set_shader()

static void wined3d_cs_exec_set_shader ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1425 of file cs.c.

1426{
1427 const struct wined3d_cs_set_shader *op = data;
1428
1429 cs->state.shader[op->type] = op->shader;
1430 device_invalidate_state(cs->device, STATE_SHADER(op->type));
1431 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1433 else
1435}
#define STATE_SHADER(a)

◆ wined3d_cs_exec_set_shader_resource_view()

static void wined3d_cs_exec_set_shader_resource_view ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1333 of file cs.c.

1334{
1336 struct wined3d_shader_resource_view *prev;
1337
1338 prev = cs->state.shader_resource_view[op->type][op->view_idx];
1339 cs->state.shader_resource_view[op->type][op->view_idx] = op->view;
1340
1341 if (op->view)
1342 InterlockedIncrement(&op->view->resource->bind_count);
1343 if (prev)
1344 InterlockedDecrement(&prev->resource->bind_count);
1345
1346 if (op->type != WINED3D_SHADER_TYPE_COMPUTE)
1348 else
1350}
struct wined3d_resource * resource

◆ wined3d_cs_exec_set_stream_output()

static void wined3d_cs_exec_set_stream_output ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1147 of file cs.c.

1148{
1149 const struct wined3d_cs_set_stream_output *op = data;
1151 struct wined3d_buffer *prev;
1152
1153 stream = &cs->state.stream_output[op->stream_idx];
1154 prev = stream->buffer;
1155 stream->buffer = op->buffer;
1156 stream->offset = op->offset;
1157
1158 if (op->buffer)
1159 InterlockedIncrement(&op->buffer->resource.bind_count);
1160 if (prev)
1161 InterlockedDecrement(&prev->resource.bind_count);
1162
1164}
Definition: parse.h:23
#define STATE_STREAM_OUTPUT

◆ wined3d_cs_exec_set_stream_source()

static void wined3d_cs_exec_set_stream_source ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1087 of file cs.c.

1088{
1089 const struct wined3d_cs_set_stream_source *op = data;
1091 struct wined3d_buffer *prev;
1092
1093 stream = &cs->state.streams[op->stream_idx];
1094 prev = stream->buffer;
1095 stream->buffer = op->buffer;
1096 stream->offset = op->offset;
1097 stream->stride = op->stride;
1098
1099 if (op->buffer)
1100 InterlockedIncrement(&op->buffer->resource.bind_count);
1101 if (prev)
1102 InterlockedDecrement(&prev->resource.bind_count);
1103
1105}
#define STATE_STREAMSRC

◆ wined3d_cs_exec_set_stream_source_freq()

static void wined3d_cs_exec_set_stream_source_freq ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1122 of file cs.c.

1123{
1126
1127 stream = &cs->state.streams[op->stream_idx];
1128 stream->frequency = op->frequency;
1129 stream->flags = op->flags;
1130
1132}

◆ wined3d_cs_exec_set_texture()

static void wined3d_cs_exec_set_texture ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1242 of file cs.c.

1243{
1244 const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info;
1245 const struct wined3d_d3d_info *d3d_info = &cs->device->adapter->d3d_info;
1246 const struct wined3d_cs_set_texture *op = data;
1247 struct wined3d_texture *prev;
1248 BOOL old_use_color_key = FALSE, new_use_color_key = FALSE;
1249
1250 prev = cs->state.textures[op->stage];
1251 cs->state.textures[op->stage] = op->texture;
1252
1253 if (op->texture)
1254 {
1255 const struct wined3d_format *new_format = op->texture->resource.format;
1256 const struct wined3d_format *old_format = prev ? prev->resource.format : NULL;
1257 unsigned int old_fmt_flags = prev ? prev->resource.format_flags : 0;
1258 unsigned int new_fmt_flags = op->texture->resource.format_flags;
1259
1260 if (InterlockedIncrement(&op->texture->resource.bind_count) == 1)
1261 op->texture->sampler = op->stage;
1262
1263 if (!prev || op->texture->target != prev->target
1264 || (!is_same_fixup(new_format->color_fixup, old_format->color_fixup)
1265 && !(can_use_texture_swizzle(gl_info, new_format) && can_use_texture_swizzle(gl_info, old_format)))
1266 || (new_fmt_flags & WINED3DFMT_FLAG_SHADOW) != (old_fmt_flags & WINED3DFMT_FLAG_SHADOW))
1268
1269 if (!prev && op->stage < d3d_info->limits.ffp_blend_stages)
1270 {
1271 /* The source arguments for color and alpha ops have different
1272 * meanings when a NULL texture is bound, so the COLOR_OP and
1273 * ALPHA_OP have to be dirtified. */
1276 }
1277
1278 if (!op->stage && op->texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1279 new_use_color_key = TRUE;
1280 }
1281
1282 if (prev)
1283 {
1284 if (InterlockedDecrement(&prev->resource.bind_count) && prev->sampler == op->stage)
1285 {
1286 unsigned int i;
1287
1288 /* Search for other stages the texture is bound to. Shouldn't
1289 * happen if applications bind textures to a single stage only. */
1290 TRACE("Searching for other stages the texture is bound to.\n");
1291 for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
1292 {
1293 if (cs->state.textures[i] == prev)
1294 {
1295 TRACE("Texture is also bound to stage %u.\n", i);
1296 prev->sampler = i;
1297 break;
1298 }
1299 }
1300 }
1301
1302 if (!op->texture && op->stage < d3d_info->limits.ffp_blend_stages)
1303 {
1306 }
1307
1308 if (!op->stage && prev->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1309 old_use_color_key = TRUE;
1310 }
1311
1312 device_invalidate_state(cs->device, STATE_SAMPLER(op->stage));
1313
1314 if (new_use_color_key != old_use_color_key)
1316
1317 if (new_use_color_key)
1319}
struct wined3d_d3d_limits limits
struct color_fixup_desc color_fixup
struct wined3d_texture::wined3d_texture_async async
@ WINED3D_TSS_ALPHA_OP
Definition: wined3d.h:578
@ WINED3D_TSS_COLOR_OP
Definition: wined3d.h:575
#define WINED3DFMT_FLAG_SHADOW
static BOOL is_same_fixup(struct color_fixup_desc f1, struct color_fixup_desc f2)
#define STATE_TEXTURESTAGE(stage, num)
#define MAX_COMBINED_SAMPLERS
static BOOL can_use_texture_swizzle(const struct wined3d_gl_info *gl_info, const struct wined3d_format *format)

◆ wined3d_cs_exec_set_texture_state()

static void wined3d_cs_exec_set_texture_state ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1508 of file cs.c.

1509{
1510 const struct wined3d_cs_set_texture_state *op = data;
1511
1512 cs->state.texture_states[op->stage][op->state] = op->value;
1513 device_invalidate_state(cs->device, STATE_TEXTURESTAGE(op->stage, op->state));
1514}

◆ wined3d_cs_exec_set_transform()

static void wined3d_cs_exec_set_transform ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1552 of file cs.c.

1553{
1554 const struct wined3d_cs_set_transform *op = data;
1555
1556 cs->state.transforms[op->state] = op->matrix;
1557 if (op->state < WINED3D_TS_WORLD_MATRIX(cs->device->adapter->d3d_info.limits.ffp_vertex_blend_matrices))
1558 device_invalidate_state(cs->device, STATE_TRANSFORM(op->state));
1559}
#define WINED3D_TS_WORLD_MATRIX(index)
Definition: wined3d.h:664
#define STATE_TRANSFORM(a)

◆ wined3d_cs_exec_set_unordered_access_view()

static void wined3d_cs_exec_set_unordered_access_view ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1366 of file cs.c.

1367{
1369 struct wined3d_unordered_access_view *prev;
1370
1371 prev = cs->state.unordered_access_view[op->pipeline][op->view_idx];
1372 cs->state.unordered_access_view[op->pipeline][op->view_idx] = op->view;
1373
1374 if (op->view)
1375 InterlockedIncrement(&op->view->resource->bind_count);
1376 if (prev)
1377 InterlockedDecrement(&prev->resource->bind_count);
1378
1379 if (op->view && op->initial_count != ~0u)
1380 wined3d_unordered_access_view_set_counter(op->view, op->initial_count);
1381
1383}
void wined3d_unordered_access_view_set_counter(struct wined3d_unordered_access_view *view, unsigned int value)
Definition: view.c:1046
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define STATE_UNORDERED_ACCESS_VIEW_BINDING(a)

◆ wined3d_cs_exec_set_vertex_declaration()

static void wined3d_cs_exec_set_vertex_declaration ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1068 of file cs.c.

1069{
1071
1072 cs->state.vertex_declaration = op->declaration;
1074}
#define STATE_VDECL

◆ wined3d_cs_exec_set_viewport()

static void wined3d_cs_exec_set_viewport ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 961 of file cs.c.

962{
963 const struct wined3d_cs_set_viewport *op = data;
964
965 cs->state.viewport = op->viewport;
967}
#define STATE_VIEWPORT

◆ wined3d_cs_exec_unload_resource()

static void wined3d_cs_exec_unload_resource ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 1969 of file cs.c.

1970{
1971 const struct wined3d_cs_unload_resource *op = data;
1972 struct wined3d_resource *resource = op->resource;
1973
1974 resource->resource_ops->resource_unload(resource);
1976}

◆ wined3d_cs_exec_unmap()

static void wined3d_cs_exec_unmap ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 2025 of file cs.c.

2026{
2027 const struct wined3d_cs_unmap *op = data;
2028 struct wined3d_resource *resource = op->resource;
2029
2030 *op->hr = resource->resource_ops->resource_sub_resource_unmap(resource, op->sub_resource_idx);
2031}

◆ wined3d_cs_exec_update_sub_resource()

static void wined3d_cs_exec_update_sub_resource ( struct wined3d_cs cs,
const void data 
)
static

Definition at line 2203 of file cs.c.

2204{
2205 const struct wined3d_cs_update_sub_resource *op = data;
2206 struct wined3d_resource *resource = op->resource;
2207 const struct wined3d_box *box = &op->box;
2208 unsigned int width, height, depth, level;
2210 struct wined3d_context *context;
2211 struct wined3d_texture *texture;
2212
2213 context = context_acquire(cs->device, NULL, 0);
2214
2215 if (resource->type == WINED3D_RTYPE_BUFFER)
2216 {
2218
2220 {
2221 ERR("Failed to load buffer location.\n");
2222 goto done;
2223 }
2224
2227 goto done;
2228 }
2229
2231
2232 level = op->sub_resource_idx % texture->level_count;
2236
2237 addr.buffer_object = 0;
2238 addr.addr = op->data.data;
2239
2240 /* Only load the sub-resource for partial updates. */
2241 if (!box->left && !box->top && !box->front
2242 && box->right == width && box->bottom == height && box->back == depth)
2244 else
2247
2248 wined3d_texture_upload_data(texture, op->sub_resource_idx, context,
2249 box, &addr, op->data.row_pitch, op->data.slice_pitch);
2250
2253
2254done:
2256
2258}
void wined3d_buffer_upload_data(struct wined3d_buffer *buffer, struct wined3d_context *context, const struct wined3d_box *box, const void *data)
Definition: buffer.c:1219
BOOL wined3d_buffer_load_location(struct wined3d_buffer *buffer, struct wined3d_context *context, DWORD location)
Definition: buffer.c:641
void wined3d_buffer_invalidate_location(struct wined3d_buffer *buffer, DWORD location)
Definition: buffer.c:130
struct wined3d_texture *__cdecl wined3d_texture_from_resource(struct wined3d_resource *resource)
Definition: texture.c:2210
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
#define WINED3D_LOCATION_BUFFER

◆ wined3d_cs_init_object()

void wined3d_cs_init_object ( struct wined3d_cs cs,
void(*)(void *object callback,
void object 
)

Definition at line 1890 of file cs.c.

1891{
1893}