ReactOS  0.4.14-dev-49-gfb4591c
shader.c File Reference
#include "config.h"
#include "wine/port.h"
#include <stdio.h>
#include <string.h>
#include "wined3d_private.h"
Include dependency graph for shader.c:

Go to the source code of this file.

Classes

struct  shader_none_priv
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (d3d_shader)
 
static void shader_dump_src_param (struct wined3d_string_buffer *buffer, const struct wined3d_shader_src_param *param, const struct wined3d_shader_version *shader_version)
 
const chardebug_d3dshaderinstructionhandler (enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx)
 
static const charshader_semantic_name_from_usage (enum wined3d_decl_usage usage)
 
static enum wined3d_decl_usage shader_usage_from_semantic_name (const char *name)
 
static enum wined3d_sysval_semantic shader_sysval_semantic_from_usage (enum wined3d_decl_usage usage)
 
BOOL shader_match_semantic (const char *semantic_name, enum wined3d_decl_usage usage)
 
static void shader_signature_from_semantic (struct wined3d_shader_signature_element *e, const struct wined3d_shader_semantic *s)
 
static void shader_signature_from_usage (struct wined3d_shader_signature_element *e, enum wined3d_decl_usage usage, UINT usage_idx, UINT reg_idx, DWORD write_mask)
 
static const struct wined3d_shader_frontendshader_select_frontend (enum wined3d_shader_byte_code_format format)
 
void string_buffer_clear (struct wined3d_string_buffer *buffer)
 
BOOL string_buffer_init (struct wined3d_string_buffer *buffer)
 
void string_buffer_free (struct wined3d_string_buffer *buffer)
 
BOOL string_buffer_resize (struct wined3d_string_buffer *buffer, int rc)
 
int shader_vaddline (struct wined3d_string_buffer *buffer, const char *format, va_list args)
 
int shader_addline (struct wined3d_string_buffer *buffer, const char *format,...)
 
struct wined3d_string_bufferstring_buffer_get (struct wined3d_string_buffer_list *list)
 
static int string_buffer_vsprintf (struct wined3d_string_buffer *buffer, const char *format, va_list args)
 
void string_buffer_sprintf (struct wined3d_string_buffer *buffer, const char *format,...)
 
void string_buffer_release (struct wined3d_string_buffer_list *list, struct wined3d_string_buffer *buffer)
 
void string_buffer_list_init (struct wined3d_string_buffer_list *list)
 
void string_buffer_list_cleanup (struct wined3d_string_buffer_list *list)
 
static unsigned int shader_get_float_offset (enum wined3d_shader_register_type register_type, UINT register_idx)
 
static void shader_delete_constant_list (struct list *clist)
 
static void shader_set_limits (struct wined3d_shader *shader)
 
static BOOL shader_record_register_usage (struct wined3d_shader *shader, struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_shader_register *reg, enum wined3d_shader_type shader_type, unsigned int constf_size)
 
static void shader_record_sample (struct wined3d_shader_reg_maps *reg_maps, unsigned int resource_idx, unsigned int sampler_idx, unsigned int bind_idx)
 
static unsigned int get_instr_extra_regcount (enum WINED3D_SHADER_INSTRUCTION_HANDLER instr, unsigned int param)
 
static HRESULT shader_reg_maps_add_tgsm (struct wined3d_shader_reg_maps *reg_maps, unsigned int register_idx, unsigned int size, unsigned int stride)
 
static HRESULT shader_record_shader_phase (struct wined3d_shader *shader, struct wined3d_shader_phase **current_phase, const struct wined3d_shader_instruction *ins, const DWORD *current_instruction_ptr, const DWORD *previous_instruction_ptr)
 
static HRESULT shader_calculate_clip_or_cull_distance_mask (const struct wined3d_shader_signature_element *e, unsigned int *mask)
 
static void wined3d_insert_interpolation_mode (DWORD *packed_interpolation_mode, unsigned int register_idx, enum wined3d_shader_interpolation_mode mode)
 
static HRESULT shader_get_registers_used (struct wined3d_shader *shader, const struct wined3d_shader_frontend *fe, struct wined3d_shader_reg_maps *reg_maps, struct wined3d_shader_signature *input_signature, struct wined3d_shader_signature *output_signature, DWORD constf_size)
 
static void shader_cleanup_reg_maps (struct wined3d_shader_reg_maps *reg_maps)
 
unsigned int shader_find_free_input_register (const struct wined3d_shader_reg_maps *reg_maps, unsigned int max)
 
static void shader_dump_global_flags (struct wined3d_string_buffer *buffer, DWORD global_flags)
 
static void shader_dump_sync_flags (struct wined3d_string_buffer *buffer, DWORD sync_flags)
 
static void shader_dump_uav_flags (struct wined3d_string_buffer *buffer, DWORD uav_flags)
 
static void shader_dump_tessellator_domain (struct wined3d_string_buffer *buffer, enum wined3d_tessellator_domain domain)
 
static void shader_dump_tessellator_output_primitive (struct wined3d_string_buffer *buffer, enum wined3d_tessellator_output_primitive output_primitive)
 
static void shader_dump_tessellator_partitioning (struct wined3d_string_buffer *buffer, enum wined3d_tessellator_partitioning partitioning)
 
static void shader_dump_shader_input_sysval_semantic (struct wined3d_string_buffer *buffer, enum wined3d_shader_input_sysval_semantic semantic)
 
static void shader_dump_decl_usage (struct wined3d_string_buffer *buffer, const struct wined3d_shader_semantic *semantic, unsigned int flags, const struct wined3d_shader_version *shader_version)
 
static void shader_dump_register (struct wined3d_string_buffer *buffer, const struct wined3d_shader_register *reg, const struct wined3d_shader_version *shader_version)
 
static void shader_dump_dst_param (struct wined3d_string_buffer *buffer, const struct wined3d_shader_dst_param *param, const struct wined3d_shader_version *shader_version)
 
HRESULT shader_generate_code (const struct wined3d_shader *shader, struct wined3d_string_buffer *buffer, const struct wined3d_shader_reg_maps *reg_maps, void *backend_ctx, const DWORD *start, const DWORD *end)
 
static void shader_dump_ins_modifiers (struct wined3d_string_buffer *buffer, const struct wined3d_shader_dst_param *dst)
 
static void shader_dump_primitive_type (struct wined3d_string_buffer *buffer, const struct wined3d_shader_primitive_type *primitive_type)
 
static void shader_dump_interpolation_mode (struct wined3d_string_buffer *buffer, enum wined3d_shader_interpolation_mode interpolation_mode)
 
static void shader_trace_init (const struct wined3d_shader_frontend *fe, void *fe_data)
 
static void shader_cleanup (struct wined3d_shader *shader)
 
static void shader_none_handle_instruction (const struct wined3d_shader_instruction *ins)
 
static void shader_none_precompile (void *shader_priv, struct wined3d_shader *shader)
 
static void shader_none_select_compute (void *shader_priv, struct wined3d_context *context, const struct wined3d_state *state)
 
static void shader_none_update_float_vertex_constants (struct wined3d_device *device, UINT start, UINT count)
 
static void shader_none_update_float_pixel_constants (struct wined3d_device *device, UINT start, UINT count)
 
static void shader_none_load_constants (void *shader_priv, struct wined3d_context *context, const struct wined3d_state *state)
 
static void shader_none_destroy (struct wined3d_shader *shader)
 
static void shader_none_free_context_data (struct wined3d_context *context)
 
static void shader_none_init_context_state (struct wined3d_context *context)
 
static void shader_none_select (void *shader_priv, struct wined3d_context *context, const struct wined3d_state *state)
 
static void shader_none_disable (void *shader_priv, struct wined3d_context *context)
 
static HRESULT shader_none_alloc (struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe, const struct fragment_pipeline *fragment_pipe)
 
static void shader_none_free (struct wined3d_device *device)
 
static BOOL shader_none_allocate_context_data (struct wined3d_context *context)
 
static void shader_none_get_caps (const struct wined3d_gl_info *gl_info, struct shader_caps *caps)
 
static BOOL shader_none_color_fixup_supported (struct color_fixup_desc fixup)
 
static BOOL shader_none_has_ffp_proj_control (void *shader_priv)
 
static HRESULT shader_set_function (struct wined3d_shader *shader, DWORD float_const_count, enum wined3d_shader_type type, unsigned int max_version)
 
ULONG CDECL wined3d_shader_incref (struct wined3d_shader *shader)
 
static void wined3d_shader_init_object (void *object)
 
static void wined3d_shader_destroy_object (void *object)
 
ULONG CDECL wined3d_shader_decref (struct wined3d_shader *shader)
 
void *CDECL wined3d_shader_get_parent (const struct wined3d_shader *shader)
 
HRESULT CDECL wined3d_shader_get_byte_code (const struct wined3d_shader *shader, void *byte_code, UINT *byte_code_size)
 
HRESULT CDECL wined3d_shader_set_local_constants_float (struct wined3d_shader *shader, UINT start_idx, const float *src_data, UINT count)
 
static void init_interpolation_compile_args (DWORD *interpolation_args, const struct wined3d_shader *pixel_shader, const struct wined3d_gl_info *gl_info)
 
void find_vs_compile_args (const struct wined3d_state *state, const struct wined3d_shader *shader, WORD swizzle_map, struct vs_compile_args *args, const struct wined3d_context *context)
 
static BOOL match_usage (BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2)
 
BOOL vshader_get_input (const struct wined3d_shader *shader, BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum)
 
static HRESULT shader_signature_calculate_strings_length (const struct wined3d_shader_signature *signature, SIZE_T *total)
 
static HRESULT shader_signature_copy (struct wined3d_shader_signature *dst, const struct wined3d_shader_signature *src, char **signature_strings)
 
static HRESULT shader_init (struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, DWORD float_const_count, enum wined3d_shader_type type, void *parent, const struct wined3d_parent_ops *parent_ops)
 
static HRESULT vertex_shader_init (struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
 
static HRESULT geometry_shader_init (struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, const struct wined3d_stream_output_desc *so_desc, void *parent, const struct wined3d_parent_ops *parent_ops)
 
void find_ds_compile_args (const struct wined3d_state *state, const struct wined3d_shader *shader, struct ds_compile_args *args, const struct wined3d_context *context)
 
void find_gs_compile_args (const struct wined3d_state *state, const struct wined3d_shader *shader, struct gs_compile_args *args, const struct wined3d_context *context)
 
void find_ps_compile_args (const struct wined3d_state *state, const struct wined3d_shader *shader, BOOL position_transformed, struct ps_compile_args *args, const struct wined3d_context *context)
 
static HRESULT pixel_shader_init (struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
 
void pixelshader_update_resource_types (struct wined3d_shader *shader, WORD tex_types)
 
HRESULT CDECL wined3d_shader_create_cs (struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
 
HRESULT CDECL wined3d_shader_create_ds (struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
 
HRESULT CDECL wined3d_shader_create_gs (struct wined3d_device *device, const struct wined3d_shader_desc *desc, const struct wined3d_stream_output_desc *so_desc, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
 
HRESULT CDECL wined3d_shader_create_hs (struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
 
HRESULT CDECL wined3d_shader_create_ps (struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
 
HRESULT CDECL wined3d_shader_create_vs (struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader)
 

Variables

const float wined3d_srgb_const0 [] = {0.41666f, 1.055f, 0.055f, 12.92f}
 
const float wined3d_srgb_const1 [] = {0.0031308f, 0.0f, 0.0f, 0.0f}
 
static const char *const shader_opcode_names []
 
static const char *const semantic_names []
 
struct {
   enum wined3d_shader_input_sysval_semantic   sysval_semantic
 
   const char *   sysval_name
 
shader_input_sysval_semantic_names []
 
const struct wined3d_shader_backend_ops none_shader_backend
 

Function Documentation

◆ debug_d3dshaderinstructionhandler()

const char* debug_d3dshaderinstructionhandler ( enum WINED3D_SHADER_INSTRUCTION_HANDLER  handler_idx)

Definition at line 334 of file shader.c.

335 {
336  if (handler_idx >= ARRAY_SIZE(shader_opcode_names))
337  return wine_dbg_sprintf("UNRECOGNIZED(%#x)", handler_idx);
338 
339  return shader_opcode_names[handler_idx];
340 }
static const char *const shader_opcode_names[]
Definition: shader.c:40
const char * wine_dbg_sprintf(const char *format,...)
Definition: compat.c:271
#define ARRAY_SIZE(a)
Definition: main.h:24

Referenced by shader_arb_handle_instruction(), shader_get_registers_used(), shader_glsl_binop(), shader_glsl_compare(), shader_glsl_handle_instruction(), shader_glsl_map2gl(), shader_glsl_sample(), shader_glsl_unary_op(), shader_hw_map2gl(), shader_hw_mnxn(), shader_hw_scalar_op(), shader_record_shader_phase(), and shader_sm1_validate_instruction().

◆ find_ds_compile_args()

void find_ds_compile_args ( const struct wined3d_state state,
const struct wined3d_shader shader,
struct ds_compile_args args,
const struct wined3d_context context 
)

Definition at line 3748 of file shader.c.

3750 {
3751  const struct wined3d_shader *geometry_shader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
3752  const struct wined3d_shader *pixel_shader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
3753  const struct wined3d_shader *hull_shader = state->shader[WINED3D_SHADER_TYPE_HULL];
3754  const struct wined3d_gl_info *gl_info = context->gl_info;
3755 
3756  args->tessellator_output_primitive = hull_shader->u.hs.tessellator_output_primitive;
3757  args->tessellator_partitioning = hull_shader->u.hs.tessellator_partitioning;
3758 
3759  args->output_count = geometry_shader ? geometry_shader->limits->packed_input
3760  : pixel_shader ? pixel_shader->limits->packed_input : shader->limits->packed_output;
3761  args->next_shader_type = geometry_shader ? WINED3D_SHADER_TYPE_GEOMETRY : WINED3D_SHADER_TYPE_PIXEL;
3762 
3763  args->render_offscreen = context->render_offscreen;
3764 
3765  init_interpolation_compile_args(args->interpolation_mode,
3766  args->next_shader_type == WINED3D_SHADER_TYPE_PIXEL ? pixel_shader : NULL, gl_info);
3767 
3768  args->padding = 0;
3769 }
static void init_interpolation_compile_args(DWORD *interpolation_args, const struct wined3d_shader *pixel_shader, const struct wined3d_gl_info *gl_info)
Definition: shader.c:3449
const struct wined3d_shader_limits * limits
union wined3d_shader::@274 u
Definition: http.c:6587
Definition: match.c:390
smooth NULL
Definition: ftsmooth.c:416
GLuint shader
Definition: glext.h:6030
static int state
Definition: maze.c:121
struct wined3d_hull_shader hs

Referenced by set_glsl_shader_program().

◆ find_gs_compile_args()

void find_gs_compile_args ( const struct wined3d_state state,
const struct wined3d_shader shader,
struct gs_compile_args args,
const struct wined3d_context context 
)

Definition at line 3771 of file shader.c.

3773 {
3774  const struct wined3d_shader *pixel_shader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
3775  const struct wined3d_gl_info *gl_info = context->gl_info;
3776 
3777  args->output_count = pixel_shader ? pixel_shader->limits->packed_input : shader->limits->packed_output;
3778 
3779  init_interpolation_compile_args(args->interpolation_mode, pixel_shader, gl_info);
3780 }
static void init_interpolation_compile_args(DWORD *interpolation_args, const struct wined3d_shader *pixel_shader, const struct wined3d_gl_info *gl_info)
Definition: shader.c:3449
const struct wined3d_shader_limits * limits
Definition: http.c:6587
Definition: match.c:390
GLuint shader
Definition: glext.h:6030
static int state
Definition: maze.c:121

Referenced by set_glsl_shader_program().

◆ find_ps_compile_args()

void find_ps_compile_args ( const struct wined3d_state state,
const struct wined3d_shader shader,
BOOL  position_transformed,
struct ps_compile_args args,
const struct wined3d_context context 
)

Definition at line 3782 of file shader.c.

3784 {
3785  const struct wined3d_d3d_info *d3d_info = context->d3d_info;
3786  const struct wined3d_gl_info *gl_info = context->gl_info;
3787  const struct wined3d_texture *texture;
3788  unsigned int i;
3789 
3790  memset(args, 0, sizeof(*args)); /* FIXME: Make sure all bits are set. */
3792  {
3793  static unsigned int warned = 0;
3794 
3795  args->srgb_correction = 1;
3796  if (state->render_states[WINED3D_RS_ALPHABLENDENABLE] && !warned++)
3797  WARN("Blending into a sRGB render target with no GL_ARB_framebuffer_sRGB "
3798  "support, expect rendering artifacts.\n");
3799  }
3800 
3801  if (shader->reg_maps.shader_version.major == 1
3802  && shader->reg_maps.shader_version.minor <= 3)
3803  {
3804  for (i = 0; i < shader->limits->sampler; ++i)
3805  {
3807 
3809  {
3810  DWORD tex_transform = flags & ~WINED3D_TTFF_PROJECTED;
3811 
3812  if (!state->shader[WINED3D_SHADER_TYPE_VERTEX])
3813  {
3814  enum wined3d_shader_resource_type resource_type = shader->reg_maps.resource_info[i].type;
3815  unsigned int j;
3816  unsigned int index = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
3817  DWORD max_valid = WINED3D_TTFF_COUNT4;
3818 
3819  for (j = 0; j < state->vertex_declaration->element_count; ++j)
3820  {
3822  &state->vertex_declaration->elements[j];
3823 
3824  if (element->usage == WINED3D_DECL_USAGE_TEXCOORD
3825  && element->usage_idx == index)
3826  {
3827  max_valid = element->format->component_count;
3828  break;
3829  }
3830  }
3831  if (!tex_transform || tex_transform > max_valid)
3832  {
3833  WARN("Fixing up projected texture transform flags from %#x to %#x.\n",
3834  tex_transform, max_valid);
3835  tex_transform = max_valid;
3836  }
3837  if ((resource_type == WINED3D_SHADER_RESOURCE_TEXTURE_1D && tex_transform > WINED3D_TTFF_COUNT1)
3838  || (resource_type == WINED3D_SHADER_RESOURCE_TEXTURE_2D
3839  && tex_transform > WINED3D_TTFF_COUNT2)
3840  || (resource_type == WINED3D_SHADER_RESOURCE_TEXTURE_3D
3841  && tex_transform > WINED3D_TTFF_COUNT3))
3842  tex_transform |= WINED3D_PSARGS_PROJECTED;
3843  else
3844  {
3845  WARN("Application requested projected texture with unsuitable texture coordinates.\n");
3846  WARN("(texture unit %u, transform flags %#x, sampler type %u).\n",
3847  i, tex_transform, resource_type);
3848  }
3849  }
3850  else
3852 
3853  args->tex_transform |= tex_transform << i * WINED3D_PSARGS_TEXTRANSFORM_SHIFT;
3854  }
3855  }
3856  }
3857  if (shader->reg_maps.shader_version.major == 1
3858  && shader->reg_maps.shader_version.minor <= 4)
3859  {
3860  for (i = 0; i < shader->limits->sampler; ++i)
3861  {
3862  const struct wined3d_texture *texture = state->textures[i];
3863 
3864  if (!shader->reg_maps.resource_info[i].type)
3865  continue;
3866 
3867  /* Treat unbound textures as 2D. The dummy texture will provide
3868  * the proper sample value. The tex_types bitmap defaults to
3869  * 2D because of the memset. */
3870  if (!texture)
3871  continue;
3872 
3873  switch (texture->target)
3874  {
3875  /* RECT textures are distinguished from 2D textures via np2_fixup */
3877  case GL_TEXTURE_2D:
3878  break;
3879 
3880  case GL_TEXTURE_3D:
3882  break;
3883 
3886  break;
3887  }
3888  }
3889  }
3890 
3891  if (shader->reg_maps.shader_version.major >= 4)
3892  {
3893  /* In SM4+ we use dcl_sampler in order to determine if we should use shadow sampler. */
3894  args->shadow = 0;
3895  for (i = 0 ; i < MAX_FRAGMENT_SAMPLERS; ++i)
3896  args->color_fixup[i] = COLOR_FIXUP_IDENTITY;
3897  args->np2_fixup = 0;
3898  }
3899  else
3900  {
3901  for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
3902  {
3903  if (!shader->reg_maps.resource_info[i].type)
3904  continue;
3905 
3906  texture = state->textures[i];
3907  if (!texture)
3908  {
3909  args->color_fixup[i] = COLOR_FIXUP_IDENTITY;
3910  continue;
3911  }
3912  if (can_use_texture_swizzle(gl_info, texture->resource.format))
3913  args->color_fixup[i] = COLOR_FIXUP_IDENTITY;
3914  else
3915  args->color_fixup[i] = texture->resource.format->color_fixup;
3916 
3917  if (texture->resource.format_flags & WINED3DFMT_FLAG_SHADOW)
3918  args->shadow |= 1u << i;
3919 
3920  /* Flag samplers that need NP2 texcoord fixup. */
3921  if (!(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
3922  args->np2_fixup |= (1u << i);
3923  }
3924  }
3925 
3926  if (shader->reg_maps.shader_version.major >= 3)
3927  {
3928  if (position_transformed)
3929  args->vp_mode = pretransformed;
3930  else if (use_vs(state))
3931  args->vp_mode = vertexshader;
3932  else
3933  args->vp_mode = fixedfunction;
3935  }
3936  else
3937  {
3938  args->vp_mode = vertexshader;
3939  if (state->render_states[WINED3D_RS_FOGENABLE])
3940  {
3941  switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
3942  {
3943  case WINED3D_FOG_NONE:
3944  if (position_transformed || use_vs(state))
3945  {
3947  break;
3948  }
3949 
3950  switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
3951  {
3952  case WINED3D_FOG_NONE: /* Fall through. */
3954  case WINED3D_FOG_EXP: args->fog = WINED3D_FFP_PS_FOG_EXP; break;
3955  case WINED3D_FOG_EXP2: args->fog = WINED3D_FFP_PS_FOG_EXP2; break;
3956  }
3957  break;
3958 
3960  case WINED3D_FOG_EXP: args->fog = WINED3D_FFP_PS_FOG_EXP; break;
3961  case WINED3D_FOG_EXP2: args->fog = WINED3D_FFP_PS_FOG_EXP2; break;
3962  }
3963  }
3964  else
3965  {
3967  }
3968  }
3969 
3970  if (context->d3d_info->limits.varying_count < wined3d_max_compat_varyings(context->gl_info))
3971  {
3972  const struct wined3d_shader *vs = state->shader[WINED3D_SHADER_TYPE_VERTEX];
3973 
3974  args->texcoords_initialized = 0;
3975  for (i = 0; i < MAX_TEXTURES; ++i)
3976  {
3977  if (vs)
3978  {
3979  if (state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.output_registers & (1u << i))
3980  args->texcoords_initialized |= 1u << i;
3981  }
3982  else
3983  {
3984  const struct wined3d_stream_info *si = &context->stream_info;
3985  unsigned int coord_idx = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
3986 
3987  if ((state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX] >> WINED3D_FFP_TCI_SHIFT)
3989  || (coord_idx < MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx)))))
3990  args->texcoords_initialized |= 1u << i;
3991  }
3992  }
3993  }
3994  else
3995  {
3996  args->texcoords_initialized = (1u << MAX_TEXTURES) - 1;
3997  }
3998 
3999  args->pointsprite = state->render_states[WINED3D_RS_POINTSPRITEENABLE]
4000  && state->gl_primitive_type == GL_POINTS;
4001 
4002  if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
4003  args->alpha_test_func = WINED3D_CMP_ALWAYS - 1;
4004  else
4005  args->alpha_test_func = (state->render_states[WINED3D_RS_ALPHATESTENABLE]
4007  : WINED3D_CMP_ALWAYS) - 1;
4008 
4009  if (d3d_info->emulated_flatshading)
4010  args->flatshading = state->render_states[WINED3D_RS_SHADEMODE] == WINED3D_SHADE_FLAT;
4011 
4012  args->render_offscreen = shader->reg_maps.vpos && gl_info->supported[ARB_FRAGMENT_COORD_CONVENTIONS]
4013  ? context->render_offscreen : 0;
4014 
4015  args->dual_source_blend = wined3d_dualblend_enabled(state, gl_info);
4016 }
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 MAX_TEXTURES
#define GL_POINTS
Definition: gl.h:190
Definition: http.c:6587
#define WINED3D_TEXTURE_POW2_MAT_IDENT
static BOOL can_use_texture_swizzle(const struct wined3d_gl_info *gl_info, const struct wined3d_format *format)
#define WARN(fmt,...)
Definition: debug.h:111
static enum wined3d_cmp_func wined3d_sanitize_cmp_func(enum wined3d_cmp_func func)
#define WINED3D_FFP_TCI_MASK
Definition: match.c:390
#define WINED3D_PSARGS_TEXTYPE_SHIFT
#define GL_TEXTURE_CUBE_MAP_ARB
Definition: glext.h:1230
#define GL_TEXTURE_RECTANGLE_ARB
Definition: glext.h:1614
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define WINED3D_PSARGS_TEXTRANSFORM_SHIFT
BOOL supported[WINED3D_GL_EXT_COUNT]
#define GL_TEXTURE_3D
Definition: gl.h:1515
struct wined3d_vertex_shader vs
GLuint index
Definition: glext.h:6031
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
static BOOL wined3d_dualblend_enabled(const struct wined3d_state *state, const struct wined3d_gl_info *gl_info)
wined3d_shader_resource_type
GLuint shader
Definition: glext.h:6030
GLenum GLuint texture
Definition: glext.h:6295
#define MAX_FRAGMENT_SAMPLERS
unsigned long DWORD
Definition: ntddk_ex.h:95
static const struct color_fixup_desc COLOR_FIXUP_IDENTITY
GLbitfield flags
Definition: glext.h:7161
static int state
Definition: maze.c:121
#define WINED3D_FFP_TCI_SHIFT
unsigned int wined3d_max_compat_varyings(const struct wined3d_gl_info *gl_info)
Definition: utils.c:5737
#define GL_TEXTURE_2D
Definition: gl.h:645
#define WINED3D_PSARGS_PROJECTED
static BOOL use_vs(const struct wined3d_state *state)
#define WINED3DFMT_FLAG_SHADOW
#define memset(x, y, z)
Definition: compat.h:39
static BOOL needs_srgb_write(const struct wined3d_context *context, const struct wined3d_state *state, const struct wined3d_fb_state *fb)

Referenced by find_arb_ps_compile_args(), and set_glsl_shader_program().

◆ find_vs_compile_args()

void find_vs_compile_args ( const struct wined3d_state state,
const struct wined3d_shader shader,
WORD  swizzle_map,
struct vs_compile_args args,
const struct wined3d_context context 
)

Definition at line 3463 of file shader.c.

3465 {
3466  const struct wined3d_shader *geometry_shader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
3467  const struct wined3d_shader *pixel_shader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
3468  const struct wined3d_shader *hull_shader = state->shader[WINED3D_SHADER_TYPE_HULL];
3469  const struct wined3d_d3d_info *d3d_info = context->d3d_info;
3470  const struct wined3d_gl_info *gl_info = context->gl_info;
3471 
3472  args->fog_src = state->render_states[WINED3D_RS_FOGTABLEMODE]
3474  args->clip_enabled = state->render_states[WINED3D_RS_CLIPPING]
3475  && state->render_states[WINED3D_RS_CLIPPLANEENABLE];
3476  args->point_size = state->gl_primitive_type == GL_POINTS;
3477  args->per_vertex_point_size = shader->reg_maps.point_size;
3478  args->next_shader_type = hull_shader? WINED3D_SHADER_TYPE_HULL
3480  if (shader->reg_maps.shader_version.major >= 4)
3481  args->next_shader_input_count = hull_shader ? hull_shader->limits->packed_input
3482  : geometry_shader ? geometry_shader->limits->packed_input
3483  : pixel_shader ? pixel_shader->limits->packed_input : 0;
3484  else
3485  args->next_shader_input_count = 0;
3486  args->swizzle_map = swizzle_map;
3487  if (d3d_info->emulated_flatshading)
3488  args->flatshading = state->render_states[WINED3D_RS_SHADEMODE] == WINED3D_SHADE_FLAT;
3489  else
3490  args->flatshading = 0;
3491 
3492  init_interpolation_compile_args(args->interpolation_mode,
3493  args->next_shader_type == WINED3D_SHADER_TYPE_PIXEL ? pixel_shader : NULL, gl_info);
3494 }
static void init_interpolation_compile_args(DWORD *interpolation_args, const struct wined3d_shader *pixel_shader, const struct wined3d_gl_info *gl_info)
Definition: shader.c:3449
#define GL_POINTS
Definition: gl.h:190
const struct wined3d_shader_limits * limits
Definition: http.c:6587
Definition: match.c:390
smooth NULL
Definition: ftsmooth.c:416
GLuint shader
Definition: glext.h:6030
static int state
Definition: maze.c:121

Referenced by find_arb_vs_compile_args(), and set_glsl_shader_program().

◆ geometry_shader_init()

static HRESULT geometry_shader_init ( struct wined3d_shader shader,
struct wined3d_device device,
const struct wined3d_shader_desc desc,
const struct wined3d_stream_output_desc so_desc,
void parent,
const struct wined3d_parent_ops parent_ops 
)
static

Definition at line 3722 of file shader.c.

3725 {
3726  struct wined3d_stream_output_element *elements = NULL;
3727  HRESULT hr;
3728 
3729  if (so_desc && !(elements = heap_calloc(so_desc->element_count, sizeof(*elements))))
3730  return E_OUTOFMEMORY;
3731 
3733  {
3734  heap_free(elements);
3735  return hr;
3736  }
3737 
3738  if (so_desc)
3739  {
3740  shader->u.gs.so_desc = *so_desc;
3741  shader->u.gs.so_desc.elements = elements;
3742  memcpy(elements, so_desc->elements, so_desc->element_count * sizeof(*elements));
3743  }
3744 
3745  return WINED3D_OK;
3746 }
unsigned int element_count
Definition: wined3d.h:2072
HRESULT hr
Definition: shlfolder.c:183
static void * heap_calloc(SIZE_T count, SIZE_T size)
Definition: heap.h:49
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
Definition: devices.h:37
const struct builtin_class_descr * desc
Definition: regcontrol.c:48
smooth NULL
Definition: ftsmooth.c:416
GLuint shader
Definition: glext.h:6030
r parent
Definition: btrfs.c:2897
LONG HRESULT
Definition: typedefs.h:77
#define WINED3D_OK
Definition: wined3d.h:37
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, DWORD float_const_count, enum wined3d_shader_type type, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: shader.c:3582
struct wined3d_stream_output_element * elements
Definition: wined3d.h:2071
static BOOL heap_free(void *mem)
Definition: appwiz.h:75

Referenced by wined3d_shader_create_gs().

◆ get_instr_extra_regcount()

static unsigned int get_instr_extra_regcount ( enum WINED3D_SHADER_INSTRUCTION_HANDLER  instr,
unsigned int  param 
)
static

Definition at line 857 of file shader.c.

858 {
859  switch (instr)
860  {
861  case WINED3DSIH_M4x4:
862  case WINED3DSIH_M3x4:
863  return param == 1 ? 3 : 0;
864 
865  case WINED3DSIH_M4x3:
866  case WINED3DSIH_M3x3:
867  return param == 1 ? 2 : 0;
868 
869  case WINED3DSIH_M3x2:
870  return param == 1 ? 1 : 0;
871 
872  default:
873  return 0;
874  }
875 }
GLfloat param
Definition: glext.h:5796

Referenced by shader_get_registers_used().

◆ init_interpolation_compile_args()

static void init_interpolation_compile_args ( DWORD interpolation_args,
const struct wined3d_shader pixel_shader,
const struct wined3d_gl_info gl_info 
)
static

Definition at line 3449 of file shader.c.

3451 {
3453  || !pixel_shader || pixel_shader->reg_maps.shader_version.major < 4)
3454  {
3455  memset(interpolation_args, 0, sizeof(pixel_shader->u.ps.interpolation_mode));
3456  return;
3457  }
3458 
3459  memcpy(interpolation_args, pixel_shader->u.ps.interpolation_mode,
3460  sizeof(pixel_shader->u.ps.interpolation_mode));
3461 }
union wined3d_shader::@274 u
struct wined3d_pixel_shader ps
struct wined3d_shader_reg_maps reg_maps
static BOOL needs_interpolation_qualifiers_for_shader_outputs(const struct wined3d_gl_info *gl_info)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define memset(x, y, z)
Definition: compat.h:39

Referenced by find_ds_compile_args(), find_gs_compile_args(), and find_vs_compile_args().

◆ match_usage()

static BOOL match_usage ( BYTE  usage1,
BYTE  usage_idx1,
BYTE  usage2,
BYTE  usage_idx2 
)
static

Definition at line 3496 of file shader.c.

3497 {
3498  if (usage_idx1 != usage_idx2)
3499  return FALSE;
3500  if (usage1 == usage2)
3501  return TRUE;
3502  if (usage1 == WINED3D_DECL_USAGE_POSITION && usage2 == WINED3D_DECL_USAGE_POSITIONT)
3503  return TRUE;
3504  if (usage2 == WINED3D_DECL_USAGE_POSITION && usage1 == WINED3D_DECL_USAGE_POSITIONT)
3505  return TRUE;
3506 
3507  return FALSE;
3508 }
#define TRUE
Definition: types.h:120

Referenced by vshader_get_input().

◆ pixel_shader_init()

static HRESULT pixel_shader_init ( struct wined3d_shader shader,
struct wined3d_device device,
const struct wined3d_shader_desc desc,
void parent,
const struct wined3d_parent_ops parent_ops 
)
static

Definition at line 4018 of file shader.c.

4020 {
4021  const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
4022  unsigned int i, highest_reg_used = 0, num_regs_used = 0;
4023  HRESULT hr;
4024 
4025  if (FAILED(hr = shader_init(shader, device, desc, device->adapter->d3d_info.limits.ps_uniform_count,
4026  WINED3D_SHADER_TYPE_PIXEL, parent, parent_ops)))
4027  return hr;
4028 
4029  for (i = 0; i < MAX_REG_INPUT; ++i)
4030  {
4031  if (shader->u.ps.input_reg_used & (1u << i))
4032  {
4033  ++num_regs_used;
4034  highest_reg_used = i;
4035  }
4036  }
4037 
4038  /* Don't do any register mapping magic if it is not needed, or if we can't
4039  * achieve anything anyway */
4040  if (highest_reg_used < (gl_info->limits.glsl_varyings / 4)
4041  || num_regs_used > (gl_info->limits.glsl_varyings / 4)
4042  || shader->reg_maps.shader_version.major >= 4)
4043  {
4044  if (num_regs_used > (gl_info->limits.glsl_varyings / 4))
4045  {
4046  /* This happens with relative addressing. The input mapper function
4047  * warns about this if the higher registers are declared too, so
4048  * don't write a FIXME here */
4049  WARN("More varying registers used than supported\n");
4050  }
4051 
4052  for (i = 0; i < MAX_REG_INPUT; ++i)
4053  {
4054  shader->u.ps.input_reg_map[i] = i;
4055  }
4056 
4057  shader->u.ps.declared_in_count = highest_reg_used + 1;
4058  }
4059  else
4060  {
4061  shader->u.ps.declared_in_count = 0;
4062  for (i = 0; i < MAX_REG_INPUT; ++i)
4063  {
4064  if (shader->u.ps.input_reg_used & (1u << i))
4065  shader->u.ps.input_reg_map[i] = shader->u.ps.declared_in_count++;
4066  else shader->u.ps.input_reg_map[i] = ~0U;
4067  }
4068  }
4069 
4070  return WINED3D_OK;
4071 }
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
HRESULT hr
Definition: shlfolder.c:183
#define WARN(fmt,...)
Definition: debug.h:111
#define U(x)
Definition: wordpad.c:44
#define MAX_REG_INPUT
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Definition: devices.h:37
const struct builtin_class_descr * desc
Definition: regcontrol.c:48
GLuint shader
Definition: glext.h:6030
r parent
Definition: btrfs.c:2897
LONG HRESULT
Definition: typedefs.h:77
#define WINED3D_OK
Definition: wined3d.h:37
static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, DWORD float_const_count, enum wined3d_shader_type type, void *parent, const struct wined3d_parent_ops *parent_ops)
Definition: shader.c:3582
struct wined3d_gl_limits limits

Referenced by wined3d_shader_create_ps().

◆ pixelshader_update_resource_types()

void pixelshader_update_resource_types ( struct wined3d_shader shader,
WORD  tex_types 
)

Definition at line 4073 of file shader.c.

4074 {
4075  struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
4076  struct wined3d_shader_resource_info *resource_info = reg_maps->resource_info;
4077  unsigned int i;
4078 
4079  if (reg_maps->shader_version.major != 1) return;
4080 
4081  for (i = 0; i < shader->limits->sampler; ++i)
4082  {
4083  /* We don't sample from this sampler. */
4084  if (!resource_info[i].type)
4085  continue;
4086 
4087  switch ((tex_types >> i * WINED3D_PSARGS_TEXTYPE_SHIFT) & WINED3D_PSARGS_TEXTYPE_MASK)
4088  {
4089  case WINED3D_SHADER_TEX_2D:
4090  resource_info[i].type = WINED3D_SHADER_RESOURCE_TEXTURE_2D;
4091  break;
4092 
4093  case WINED3D_SHADER_TEX_3D:
4094  resource_info[i].type = WINED3D_SHADER_RESOURCE_TEXTURE_3D;
4095  break;
4096 
4098  resource_info[i].type = WINED3D_SHADER_RESOURCE_TEXTURE_CUBE;
4099  break;
4100  }
4101  }
4102 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
struct wined3d_shader_resource_info resource_info[MAX_SHADER_RESOURCE_VIEWS]
#define WINED3D_PSARGS_TEXTYPE_SHIFT
#define WINED3D_PSARGS_TEXTYPE_MASK
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
GLuint shader
Definition: glext.h:6030
enum wined3d_shader_resource_type type
struct wined3d_shader_version shader_version

Referenced by find_arb_pshader(), and find_glsl_pshader().

◆ shader_addline()

int shader_addline ( struct wined3d_string_buffer buffer,
const char format,
  ... 
)

Definition at line 478 of file shader.c.

479 {
480  va_list args;
481  int ret;
482 
483  for (;;)
484  {
485  va_start(args, format);
487  va_end(args);
488  if (!ret)
489  return ret;
491  return -1;
492  }
493 }
int shader_vaddline(struct wined3d_string_buffer *buffer, const char *format, va_list args)
Definition: shader.c:464
GLuint buffer
Definition: glext.h:5915
Definition: match.c:390
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
#define va_end(ap)
Definition: acmsvcex.h:90
char * va_list
Definition: acmsvcex.h:78
BOOL string_buffer_resize(struct wined3d_string_buffer *buffer, int rc)
Definition: shader.c:446
int ret
#define va_start(ap, A)
Definition: acmsvcex.h:91
#define args
Definition: format.c:66

Referenced by arbfp_add_linear_fog(), arbfp_add_sRGB_correction(), arbfp_gen_plain_shader(), gen_arbfp_ffp_shader(), gen_color_correction(), gen_ffp_instr(), gen_nv12_read(), gen_p8_shader(), gen_planar_yuv_read(), gen_yuv_shader(), gen_yv12_read(), get_argreg(), PRINTF_ATTR(), pshader_hw_bem(), pshader_hw_cmp(), pshader_hw_cnd(), pshader_hw_dp2add(), pshader_hw_tex(), pshader_hw_texbem(), pshader_hw_texcoord(), pshader_hw_texdepth(), pshader_hw_texdp3(), pshader_hw_texdp3tex(), pshader_hw_texkill(), pshader_hw_texm3x2depth(), pshader_hw_texm3x2pad(), pshader_hw_texm3x2tex(), pshader_hw_texm3x3(), pshader_hw_texm3x3pad(), pshader_hw_texm3x3spec(), pshader_hw_texm3x3tex(), pshader_hw_texm3x3vspec(), pshader_hw_texreg2ar(), pshader_hw_texreg2gb(), shader_arb_add_instruction_modifiers(), shader_arb_append_imm_vec4(), shader_arb_generate_pshader(), shader_arb_generate_vshader(), shader_arb_get_src_param(), shader_arb_handle_instruction(), shader_arb_request_a0(), shader_dump_decl_usage(), shader_dump_dst_param(), shader_dump_global_flags(), shader_dump_ins_modifiers(), shader_dump_interpolation_mode(), shader_dump_primitive_type(), shader_dump_register(), shader_dump_shader_input_sysval_semantic(), shader_dump_src_param(), shader_dump_sync_flags(), shader_dump_tessellator_domain(), shader_dump_tessellator_output_primitive(), shader_dump_tessellator_partitioning(), shader_dump_uav_flags(), shader_generate_arb_declarations(), shader_generate_glsl_declarations(), shader_glsl_add_instruction_modifiers(), shader_glsl_add_version_declaration(), shader_glsl_append_dst_ext(), shader_glsl_append_imm_ivec(), shader_glsl_append_imm_vec4(), shader_glsl_append_sampler_binding_qualifier(), shader_glsl_atomic(), shader_glsl_bem(), shader_glsl_binop(), shader_glsl_bitwise_op(), shader_glsl_break(), shader_glsl_breakc(), shader_glsl_bufinfo(), shader_glsl_call(), shader_glsl_callnz(), shader_glsl_case(), shader_glsl_cast(), shader_glsl_cnd(), shader_glsl_color_correction_ext(), shader_glsl_compare(), shader_glsl_conditional_move(), shader_glsl_continue(), shader_glsl_cross(), shader_glsl_cut(), shader_glsl_declare_generic_vertex_attribute(), shader_glsl_declare_shader_inputs(), shader_glsl_declare_shader_outputs(), shader_glsl_declare_typed_vertex_attribute(), shader_glsl_default(), shader_glsl_dot(), shader_glsl_dp2add(), shader_glsl_dst(), shader_glsl_else(), shader_glsl_emit(), shader_glsl_enable_extensions(), shader_glsl_end(), shader_glsl_expp(), shader_glsl_ffp_fragment_op(), shader_glsl_ffp_vertex_lighting(), shader_glsl_ffp_vertex_lighting_footer(), shader_glsl_fixup_position(), shader_glsl_float16(), shader_glsl_gather4(), shader_glsl_gen_sample_c_lz(), shader_glsl_generate_alpha_test(), shader_glsl_generate_clip_or_cull_distances(), shader_glsl_generate_compute_shader(), shader_glsl_generate_conditional_op(), shader_glsl_generate_default_control_point_phase(), shader_glsl_generate_domain_shader(), shader_glsl_generate_ds_epilogue(), shader_glsl_generate_ffp_fragment_shader(), shader_glsl_generate_ffp_vertex_shader(), shader_glsl_generate_fog_code(), shader_glsl_generate_geometry_shader(), shader_glsl_generate_hull_shader(), shader_glsl_generate_patch_constant_name(), shader_glsl_generate_patch_constant_setup(), shader_glsl_generate_ps_epilogue(), shader_glsl_generate_pshader(), shader_glsl_generate_shader_phase(), shader_glsl_generate_shader_phase_invocation(), shader_glsl_generate_sm4_output_setup(), shader_glsl_generate_srgb_write_correction(), shader_glsl_generate_stream_output_setup(), shader_glsl_generate_vs3_rasterizer_input_setup(), shader_glsl_generate_vs_epilogue(), shader_glsl_generate_vshader(), shader_glsl_get_ffp_fragment_op_arg(), shader_glsl_ifc(), shader_glsl_input_pack(), shader_glsl_label(), shader_glsl_ld_raw_structured(), shader_glsl_ld_uav(), shader_glsl_lit(), shader_glsl_loop(), shader_glsl_lrp(), shader_glsl_mad(), shader_glsl_map2gl(), shader_glsl_mov(), shader_glsl_mul_extended(), shader_glsl_nrm(), shader_glsl_pow(), shader_glsl_relop(), shader_glsl_rep(), shader_glsl_resinfo(), shader_glsl_ret(), shader_glsl_scalar_op(), shader_glsl_setup_sm3_rasterizer_input(), shader_glsl_setup_sm4_shader_output(), shader_glsl_setup_vs3_output(), shader_glsl_sgn(), shader_glsl_sincos(), shader_glsl_store_raw_structured(), shader_glsl_store_uav(), shader_glsl_swapc(), shader_glsl_switch(), shader_glsl_sync(), shader_glsl_texbem(), shader_glsl_texcoord(), shader_glsl_texdepth(), shader_glsl_texdp3(), shader_glsl_texkill(), shader_glsl_texm3x2depth(), shader_glsl_texm3x2pad(), shader_glsl_texm3x2tex(), shader_glsl_texm3x3(), shader_glsl_texm3x3pad(), shader_glsl_texm3x3spec(), shader_glsl_texm3x3tex(), shader_glsl_texm3x3vspec(), shader_glsl_uav_counter(), shader_glsl_udiv(), shader_glsl_unary_op(), shader_hw_break(), shader_hw_breakc(), shader_hw_call(), shader_hw_dsy(), shader_hw_else(), shader_hw_endif(), shader_hw_endloop(), shader_hw_endrep(), shader_hw_ifc(), shader_hw_label(), shader_hw_loop(), shader_hw_lrp(), shader_hw_map2gl(), shader_hw_mov(), shader_hw_nrm(), shader_hw_pow(), shader_hw_rep(), shader_hw_ret(), shader_hw_sample(), shader_hw_scalar_op(), shader_hw_sgn(), shader_hw_sincos(), shader_trace_init(), and vshader_add_footer().

◆ shader_calculate_clip_or_cull_distance_mask()

static HRESULT shader_calculate_clip_or_cull_distance_mask ( const struct wined3d_shader_signature_element e,
unsigned int mask 
)
static

Definition at line 959 of file shader.c.

961 {
962  /* Clip and cull distances are packed in 4 component registers. 0 and 1 are
963  * the only allowed semantic indices.
964  */
965  if (e->semantic_idx >= MAX_CLIP_DISTANCES / 4)
966  {
967  *mask = 0;
968  WARN("Invalid clip/cull distance index %u.\n", e->semantic_idx);
969  return WINED3DERR_INVALIDCALL;
970  }
971 
972  *mask = (e->mask & WINED3DSP_WRITEMASK_ALL) << (4 * e->semantic_idx);
973  return WINED3D_OK;
974 }
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
#define WARN(fmt,...)
Definition: debug.h:111
GLenum GLint GLuint mask
Definition: glext.h:6028
#define e
Definition: ke_i.h:82
#define WINED3D_OK
Definition: wined3d.h:37
#define MAX_CLIP_DISTANCES
#define WINED3DSP_WRITEMASK_ALL

Referenced by shader_get_registers_used().

◆ shader_cleanup()

static void shader_cleanup ( struct wined3d_shader shader)
static

Definition at line 3088 of file shader.c.

3089 {
3090  if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_HULL)
3091  {
3092  heap_free(shader->u.hs.phases.control_point);
3093  heap_free(shader->u.hs.phases.fork);
3094  heap_free(shader->u.hs.phases.join);
3095  }
3096  else if (shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
3097  {
3098  heap_free(shader->u.gs.so_desc.elements);
3099  }
3100 
3101  heap_free(shader->patch_constant_signature.elements);
3102  heap_free(shader->output_signature.elements);
3103  heap_free(shader->input_signature.elements);
3104  heap_free(shader->signature_strings);
3105  shader->device->shader_backend->shader_destroy(shader);
3106  shader_cleanup_reg_maps(&shader->reg_maps);
3107  heap_free(shader->function);
3108  shader_delete_constant_list(&shader->constantsF);
3109  shader_delete_constant_list(&shader->constantsB);
3110  shader_delete_constant_list(&shader->constantsI);
3111  list_remove(&shader->shader_list_entry);
3112 
3113  if (shader->frontend && shader->frontend_data)
3114  shader->frontend->shader_free(shader->frontend_data);
3115 }
static void shader_delete_constant_list(struct list *clist)
Definition: shader.c:583
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
GLuint shader
Definition: glext.h:6030
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
static void shader_cleanup_reg_maps(struct wined3d_shader_reg_maps *reg_maps)
Definition: shader.c:1824

Referenced by shader_init(), and wined3d_shader_destroy_object().

◆ shader_cleanup_reg_maps()

static void shader_cleanup_reg_maps ( struct wined3d_shader_reg_maps reg_maps)
static

Definition at line 1824 of file shader.c.

1825 {
1826  struct wined3d_shader_indexable_temp *reg, *reg_next;
1827 
1828  heap_free(reg_maps->constf);
1829  heap_free(reg_maps->sampler_map.entries);
1830 
1832  heap_free(reg);
1833  list_init(&reg_maps->indexable_temps);
1834 
1835  heap_free(reg_maps->tgsm);
1836 }
struct wined3d_shader_tgsm * tgsm
uint32_t entry
Definition: isohybrid.c:63
struct wined3d_shader_sampler_map sampler_map
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
static int reg
Definition: i386-dis.c:1275
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
static BOOL heap_free(void *mem)
Definition: appwiz.h:75

Referenced by shader_cleanup().

◆ shader_delete_constant_list()

static void shader_delete_constant_list ( struct list clist)
static

Definition at line 583 of file shader.c.

584 {
585  struct wined3d_shader_lconst *constant, *constant_next;
586 
587  LIST_FOR_EACH_ENTRY_SAFE(constant, constant_next, clist, struct wined3d_shader_lconst, entry)
589  list_init(clist);
590 }
uint32_t entry
Definition: isohybrid.c:63
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
static BOOL heap_free(void *mem)
Definition: appwiz.h:75

Referenced by shader_cleanup().

◆ shader_dump_decl_usage()

static void shader_dump_decl_usage ( struct wined3d_string_buffer buffer,
const struct wined3d_shader_semantic semantic,
unsigned int  flags,
const struct wined3d_shader_version shader_version 
)
static

Definition at line 1992 of file shader.c.

1995 {
1996  shader_addline(buffer, "dcl");
1997 
1998  if (semantic->reg.reg.type == WINED3DSPR_SAMPLER)
1999  {
2000  switch (semantic->resource_type)
2001  {
2003  shader_addline(buffer, "_2d");
2004  break;
2005 
2007  shader_addline(buffer, "_3d");
2008  break;
2009 
2011  shader_addline(buffer, "_cube");
2012  break;
2013 
2014  default:
2015  shader_addline(buffer, "_unknown_resource_type(%#x)", semantic->resource_type);
2016  break;
2017  }
2018  }
2019  else if (semantic->reg.reg.type == WINED3DSPR_RESOURCE || semantic->reg.reg.type == WINED3DSPR_UAV)
2020  {
2021  if (semantic->reg.reg.type == WINED3DSPR_RESOURCE)
2022  shader_addline(buffer, "_resource_");
2023  else
2024  shader_addline(buffer, "_uav_");
2025  switch (semantic->resource_type)
2026  {
2028  shader_addline(buffer, "buffer");
2029  break;
2030 
2032  shader_addline(buffer, "texture1d");
2033  break;
2034 
2036  shader_addline(buffer, "texture2d");
2037  break;
2038 
2040  shader_addline(buffer, "texture2dms");
2041  break;
2042 
2044  shader_addline(buffer, "texture3d");
2045  break;
2046 
2048  shader_addline(buffer, "texturecube");
2049  break;
2050 
2052  shader_addline(buffer, "texture1darray");
2053  break;
2054 
2056  shader_addline(buffer, "texture2darray");
2057  break;
2058 
2060  shader_addline(buffer, "texture2dmsarray");
2061  break;
2062 
2064  shader_addline(buffer, "texturecubearray");
2065  break;
2066 
2067  default:
2068  shader_addline(buffer, "unknown");
2069  break;
2070  }
2071  if (semantic->reg.reg.type == WINED3DSPR_UAV)
2073  switch (semantic->resource_data_type)
2074  {
2075  case WINED3D_DATA_FLOAT:
2076  shader_addline(buffer, " (float)");
2077  break;
2078 
2079  case WINED3D_DATA_INT:
2080  shader_addline(buffer, " (int)");
2081  break;
2082 
2083  case WINED3D_DATA_UINT:
2084  shader_addline(buffer, " (uint)");
2085  break;
2086 
2087  case WINED3D_DATA_UNORM:
2088  shader_addline(buffer, " (unorm)");
2089  break;
2090 
2091  case WINED3D_DATA_SNORM:
2092  shader_addline(buffer, " (snorm)");
2093  break;
2094 
2095  default:
2096  shader_addline(buffer, " (unknown)");
2097  break;
2098  }
2099  }
2100  else
2101  {
2102  /* Pixel shaders 3.0 don't have usage semantics. */
2103  if (shader_version->major < 3 && shader_version->type == WINED3D_SHADER_TYPE_PIXEL)
2104  return;
2105  else
2106  shader_addline(buffer, "_");
2107 
2108  switch (semantic->usage)
2109  {
2111  shader_addline(buffer, "position%u", semantic->usage_idx);
2112  break;
2113 
2115  shader_addline(buffer, "blend");
2116  break;
2117 
2119  shader_addline(buffer, "weight");
2120  break;
2121 
2123  shader_addline(buffer, "normal%u", semantic->usage_idx);
2124  break;
2125 
2127  shader_addline(buffer, "psize");
2128  break;
2129 
2131  if (!semantic->usage_idx)
2132  shader_addline(buffer, "color");
2133  else
2134  shader_addline(buffer, "specular%u", (semantic->usage_idx - 1));
2135  break;
2136 
2138  shader_addline(buffer, "texture%u", semantic->usage_idx);
2139  break;
2140 
2142  shader_addline(buffer, "tangent");
2143  break;
2144 
2146  shader_addline(buffer, "binormal");
2147  break;
2148 
2150  shader_addline(buffer, "tessfactor");
2151  break;
2152 
2154  shader_addline(buffer, "positionT%u", semantic->usage_idx);
2155  break;
2156 
2158  shader_addline(buffer, "fog");
2159  break;
2160 
2162  shader_addline(buffer, "depth");
2163  break;
2164 
2166  shader_addline(buffer, "sample");
2167  break;
2168 
2169  default:
2170  shader_addline(buffer, "<unknown_semantic(%#x)>", semantic->usage);
2171  FIXME("Unrecognised semantic usage %#x.\n", semantic->usage);
2172  }
2173  }
2174 }
enum wined3d_shader_type type
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915
static void shader_dump_uav_flags(struct wined3d_string_buffer *buffer, DWORD uav_flags)
Definition: shader.c:1892
enum wined3d_decl_usage usage
#define FIXME(fmt,...)
Definition: debug.h:110
enum wined3d_shader_resource_type resource_type
GLbitfield flags
Definition: glext.h:7161
enum wined3d_data_type resource_data_type
struct wined3d_shader_dst_param reg

Referenced by shader_trace_init().

◆ shader_dump_dst_param()

static void shader_dump_dst_param ( struct wined3d_string_buffer buffer,
const struct wined3d_shader_dst_param param,
const struct wined3d_shader_version shader_version 
)
static

Definition at line 2471 of file shader.c.

2473 {
2474  DWORD write_mask = param->write_mask;
2475 
2476  shader_dump_register(buffer, &param->reg, shader_version);
2477 
2478  if (write_mask && write_mask != WINED3DSP_WRITEMASK_ALL)
2479  {
2480  static const char write_mask_chars[] = "xyzw";
2481 
2482  shader_addline(buffer, ".");
2483  if (write_mask & WINED3DSP_WRITEMASK_0)
2484  shader_addline(buffer, "%c", write_mask_chars[0]);
2485  if (write_mask & WINED3DSP_WRITEMASK_1)
2486  shader_addline(buffer, "%c", write_mask_chars[1]);
2487  if (write_mask & WINED3DSP_WRITEMASK_2)
2488  shader_addline(buffer, "%c", write_mask_chars[2]);
2489  if (write_mask & WINED3DSP_WRITEMASK_3)
2490  shader_addline(buffer, "%c", write_mask_chars[3]);
2491  }
2492 }
#define WINED3DSP_WRITEMASK_0
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915
GLfloat param
Definition: glext.h:5796
unsigned long DWORD
Definition: ntddk_ex.h:95
#define WINED3DSP_WRITEMASK_1
#define WINED3DSP_WRITEMASK_2
static void shader_dump_register(struct wined3d_string_buffer *buffer, const struct wined3d_shader_register *reg, const struct wined3d_shader_version *shader_version)
Definition: shader.c:2176
#define WINED3DSP_WRITEMASK_ALL
#define WINED3DSP_WRITEMASK_3

Referenced by shader_trace_init().

◆ shader_dump_global_flags()

static void shader_dump_global_flags ( struct wined3d_string_buffer buffer,
DWORD  global_flags 
)
static

Definition at line 1847 of file shader.c.

1848 {
1849  if (global_flags & WINED3DSGF_REFACTORING_ALLOWED)
1850  {
1851  shader_addline(buffer, "refactoringAllowed");
1852  global_flags &= ~WINED3DSGF_REFACTORING_ALLOWED;
1853  if (global_flags)
1854  shader_addline(buffer, " | ");
1855  }
1856 
1857  if (global_flags & WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL)
1858  {
1859  shader_addline(buffer, "forceEarlyDepthStencil");
1860  global_flags &= ~WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL;
1861  if (global_flags)
1862  shader_addline(buffer, " | ");
1863  }
1864 
1866  {
1867  shader_addline(buffer, "enableRawAndStructuredBuffers");
1869  }
1870 
1871  if (global_flags)
1872  shader_addline(buffer, "unknown_flags(%#x)", global_flags);
1873 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915

Referenced by shader_trace_init().

◆ shader_dump_ins_modifiers()

static void shader_dump_ins_modifiers ( struct wined3d_string_buffer buffer,
const struct wined3d_shader_dst_param dst 
)
static

Definition at line 2613 of file shader.c.

2615 {
2616  DWORD mmask = dst->modifiers;
2617 
2618  switch (dst->shift)
2619  {
2620  case 0: break;
2621  case 13: shader_addline(buffer, "_d8"); break;
2622  case 14: shader_addline(buffer, "_d4"); break;
2623  case 15: shader_addline(buffer, "_d2"); break;
2624  case 1: shader_addline(buffer, "_x2"); break;
2625  case 2: shader_addline(buffer, "_x4"); break;
2626  case 3: shader_addline(buffer, "_x8"); break;
2627  default: shader_addline(buffer, "_unhandled_shift(%d)", dst->shift); break;
2628  }
2629 
2630  if (mmask & WINED3DSPDM_SATURATE) shader_addline(buffer, "_sat");
2631  if (mmask & WINED3DSPDM_PARTIALPRECISION) shader_addline(buffer, "_pp");
2632  if (mmask & WINED3DSPDM_MSAMPCENTROID) shader_addline(buffer, "_centroid");
2633 
2635  if (mmask) FIXME("Unrecognised modifier %#x.\n", mmask);
2636 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915
#define FIXME(fmt,...)
Definition: debug.h:110
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum GLenum dst
Definition: glext.h:6340

Referenced by shader_trace_init().

◆ shader_dump_interpolation_mode()

static void shader_dump_interpolation_mode ( struct wined3d_string_buffer buffer,
enum wined3d_shader_interpolation_mode  interpolation_mode 
)
static

Definition at line 2685 of file shader.c.

2687 {
2688  switch (interpolation_mode)
2689  {
2690  case WINED3DSIM_CONSTANT:
2691  shader_addline(buffer, "constant");
2692  break;
2693  case WINED3DSIM_LINEAR:
2694  shader_addline(buffer, "linear");
2695  break;
2697  shader_addline(buffer, "linear centroid");
2698  break;
2700  shader_addline(buffer, "linear noperspective");
2701  break;
2703  shader_addline(buffer, "linear sample");
2704  break;
2706  shader_addline(buffer, "linear noperspective centroid");
2707  break;
2709  shader_addline(buffer, "linear noperspective sample");
2710  break;
2711  default:
2712  shader_addline(buffer, "<unrecognized_interpolation_mode %#x>", interpolation_mode);
2713  break;
2714  }
2715 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915

Referenced by shader_trace_init().

◆ shader_dump_primitive_type()

static void shader_dump_primitive_type ( struct wined3d_string_buffer buffer,
const struct wined3d_shader_primitive_type primitive_type 
)
static

Definition at line 2638 of file shader.c.

2640 {
2641  switch (primitive_type->type)
2642  {
2643  case WINED3D_PT_UNDEFINED:
2644  shader_addline(buffer, "undefined");
2645  break;
2646  case WINED3D_PT_POINTLIST:
2647  shader_addline(buffer, "pointlist");
2648  break;
2649  case WINED3D_PT_LINELIST:
2650  shader_addline(buffer, "linelist");
2651  break;
2652  case WINED3D_PT_LINESTRIP:
2653  shader_addline(buffer, "linestrip");
2654  break;
2656  shader_addline(buffer, "trianglelist");
2657  break;
2659  shader_addline(buffer, "trianglestrip");
2660  break;
2662  shader_addline(buffer, "trianglefan");
2663  break;
2665  shader_addline(buffer, "linelist_adj");
2666  break;
2668  shader_addline(buffer, "linestrip_adj");
2669  break;
2671  shader_addline(buffer, "trianglelist_adj");
2672  break;
2674  shader_addline(buffer, "trianglestrip_adj");
2675  break;
2676  case WINED3D_PT_PATCH:
2677  shader_addline(buffer, "patch%u", primitive_type->patch_vertex_count);
2678  break;
2679  default:
2680  shader_addline(buffer, "<unrecognized_primitive_type %#x>", primitive_type->type);
2681  break;
2682  }
2683 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
enum wined3d_primitive_type type
GLuint buffer
Definition: glext.h:5915

Referenced by shader_trace_init().

◆ shader_dump_register()

static void shader_dump_register ( struct wined3d_string_buffer buffer,
const struct wined3d_shader_register reg,
const struct wined3d_shader_version shader_version 
)
static

Definition at line 2176 of file shader.c.

2178 {
2179  static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
2180  static const char * const misctype_reg_names[] = {"vPos", "vFace"};
2181  UINT offset = reg->idx[0].offset;
2182 
2183  switch (reg->type)
2184  {
2185  case WINED3DSPR_TEMP:
2186  shader_addline(buffer, "r");
2187  break;
2188 
2189  case WINED3DSPR_INPUT:
2190  shader_addline(buffer, "v");
2191  break;
2192 
2193  case WINED3DSPR_CONST:
2194  case WINED3DSPR_CONST2:
2195  case WINED3DSPR_CONST3:
2196  case WINED3DSPR_CONST4:
2197  shader_addline(buffer, "c");
2199  break;
2200 
2201  case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
2202  shader_addline(buffer, "%c", shader_version->type == WINED3D_SHADER_TYPE_PIXEL ? 't' : 'a');
2203  break;
2204 
2205  case WINED3DSPR_RASTOUT:
2206  shader_addline(buffer, "%s", rastout_reg_names[offset]);
2207  break;
2208 
2209  case WINED3DSPR_COLOROUT:
2210  shader_addline(buffer, "oC");
2211  break;
2212 
2213  case WINED3DSPR_DEPTHOUT:
2214  shader_addline(buffer, "oDepth");
2215  break;
2216 
2217  case WINED3DSPR_DEPTHOUTGE:
2218  shader_addline(buffer, "oDepthGE");
2219  break;
2220 
2221  case WINED3DSPR_DEPTHOUTLE:
2222  shader_addline(buffer, "oDepthLE");
2223  break;
2224 
2225  case WINED3DSPR_ATTROUT:
2226  shader_addline(buffer, "oD");
2227  break;
2228 
2229  case WINED3DSPR_TEXCRDOUT:
2230  /* Vertex shaders >= 3.0 use general purpose output registers
2231  * (WINED3DSPR_OUTPUT), which can include an address token. */
2232  if (shader_version->major >= 3)
2233  shader_addline(buffer, "o");
2234  else
2235  shader_addline(buffer, "oT");
2236  break;
2237 
2238  case WINED3DSPR_CONSTINT:
2239  shader_addline(buffer, "i");
2240  break;
2241 
2242  case WINED3DSPR_CONSTBOOL:
2243  shader_addline(buffer, "b");
2244  break;
2245 
2246  case WINED3DSPR_LABEL:
2247  shader_addline(buffer, "l");
2248  break;
2249 
2250  case WINED3DSPR_LOOP:
2251  shader_addline(buffer, "aL");
2252  break;
2253 
2254  case WINED3DSPR_SAMPLER:
2255  shader_addline(buffer, "s");
2256  break;
2257 
2258  case WINED3DSPR_MISCTYPE:
2259  if (offset > 1)
2260  {
2261  FIXME("Unhandled misctype register %u.\n", offset);
2262  shader_addline(buffer, "<unhandled misctype %#x>", offset);
2263  }
2264  else
2265  {
2266  shader_addline(buffer, "%s", misctype_reg_names[offset]);
2267  }
2268  break;
2269 
2270  case WINED3DSPR_PREDICATE:
2271  shader_addline(buffer, "p");
2272  break;
2273 
2274  case WINED3DSPR_IMMCONST:
2275  shader_addline(buffer, "l");
2276  break;
2277 
2279  shader_addline(buffer, "cb");
2280  break;
2281 
2283  shader_addline(buffer, "icb");
2284  break;
2285 
2286  case WINED3DSPR_PRIMID:
2287  shader_addline(buffer, "primID");
2288  break;
2289 
2290  case WINED3DSPR_NULL:
2291  shader_addline(buffer, "null");
2292  break;
2293 
2294  case WINED3DSPR_RESOURCE:
2295  shader_addline(buffer, "t");
2296  break;
2297 
2298  case WINED3DSPR_UAV:
2299  shader_addline(buffer, "u");
2300  break;
2301 
2302  case WINED3DSPR_OUTPOINTID:
2303  shader_addline(buffer, "vOutputControlPointID");
2304  break;
2305 
2306  case WINED3DSPR_FORKINSTID:
2307  shader_addline(buffer, "vForkInstanceId");
2308  break;
2309 
2310  case WINED3DSPR_JOININSTID:
2311  shader_addline(buffer, "vJoinInstanceId");
2312  break;
2313 
2315  shader_addline(buffer, "vicp");
2316  break;
2317 
2319  shader_addline(buffer, "vocp");
2320  break;
2321 
2322  case WINED3DSPR_PATCHCONST:
2323  shader_addline(buffer, "vpc");
2324  break;
2325 
2326  case WINED3DSPR_TESSCOORD:
2327  shader_addline(buffer, "vDomainLocation");
2328  break;
2329 
2331  shader_addline(buffer, "g");
2332  break;
2333 
2334  case WINED3DSPR_THREADID:
2335  shader_addline(buffer, "vThreadID");
2336  break;
2337 
2339  shader_addline(buffer, "vThreadGroupID");
2340  break;
2341 
2343  shader_addline(buffer, "vThreadIDInGroup");
2344  break;
2345 
2347  shader_addline(buffer, "vThreadIDInGroupFlattened");
2348  break;
2349 
2350  case WINED3DSPR_IDXTEMP:
2351  shader_addline(buffer, "x");
2352  break;
2353 
2354  case WINED3DSPR_STREAM:
2355  shader_addline(buffer, "m");
2356  break;
2357 
2359  shader_addline(buffer, "fb");
2360  break;
2361 
2363  shader_addline(buffer, "fp");
2364  break;
2365 
2366  case WINED3DSPR_COVERAGE:
2367  shader_addline(buffer, "vCoverage");
2368  break;
2369 
2370  case WINED3DSPR_SAMPLEMASK:
2371  shader_addline(buffer, "oMask");
2372  break;
2373 
2374  case WINED3DSPR_GSINSTID:
2375  shader_addline(buffer, "vGSInstanceID");
2376  break;
2377 
2378  default:
2379  shader_addline(buffer, "<unhandled_rtype(%#x)>", reg->type);
2380  break;
2381  }
2382 
2383  if (reg->type == WINED3DSPR_IMMCONST)
2384  {
2385  shader_addline(buffer, "(");
2386  switch (reg->immconst_type)
2387  {
2389  switch (reg->data_type)
2390  {
2391  case WINED3D_DATA_FLOAT:
2392  shader_addline(buffer, "%.8e", *(const float *)reg->u.immconst_data);
2393  break;
2394  case WINED3D_DATA_INT:
2395  shader_addline(buffer, "%d", reg->u.immconst_data[0]);
2396  break;
2397  case WINED3D_DATA_RESOURCE:
2398  case WINED3D_DATA_SAMPLER:
2399  case WINED3D_DATA_UINT:
2400  shader_addline(buffer, "%u", reg->u.immconst_data[0]);
2401  break;
2402  default:
2403  shader_addline(buffer, "<unhandled data type %#x>", reg->data_type);
2404  break;
2405  }
2406  break;
2407 
2408  case WINED3D_IMMCONST_VEC4:
2409  switch (reg->data_type)
2410  {
2411  case WINED3D_DATA_FLOAT:
2412  shader_addline(buffer, "%.8e, %.8e, %.8e, %.8e",
2413  *(const float *)&reg->u.immconst_data[0], *(const float *)&reg->u.immconst_data[1],
2414  *(const float *)&reg->u.immconst_data[2], *(const float *)&reg->u.immconst_data[3]);
2415  break;
2416  case WINED3D_DATA_INT:
2417  shader_addline(buffer, "%d, %d, %d, %d",
2418  reg->u.immconst_data[0], reg->u.immconst_data[1],
2419  reg->u.immconst_data[2], reg->u.immconst_data[3]);
2420  break;
2421  case WINED3D_DATA_RESOURCE:
2422  case WINED3D_DATA_SAMPLER:
2423  case WINED3D_DATA_UINT:
2424  shader_addline(buffer, "%u, %u, %u, %u",
2425  reg->u.immconst_data[0], reg->u.immconst_data[1],
2426  reg->u.immconst_data[2], reg->u.immconst_data[3]);
2427  break;
2428  default:
2429  shader_addline(buffer, "<unhandled data type %#x>", reg->data_type);
2430  break;
2431  }
2432  break;
2433 
2434  default:
2435  shader_addline(buffer, "<unhandled immconst_type %#x>", reg->immconst_type);
2436  break;
2437  }
2438  shader_addline(buffer, ")");
2439  }
2440  else if (reg->type != WINED3DSPR_RASTOUT
2441  && reg->type != WINED3DSPR_MISCTYPE
2442  && reg->type != WINED3DSPR_NULL)
2443  {
2444  if (offset != ~0u)
2445  {
2446  shader_addline(buffer, "[");
2447  if (reg->idx[0].rel_addr)
2448  {
2449  shader_dump_src_param(buffer, reg->idx[0].rel_addr, shader_version);
2450  shader_addline(buffer, " + ");
2451  }
2452  shader_addline(buffer, "%u]", offset);
2453 
2454  if (reg->idx[1].offset != ~0u)
2455  {
2456  shader_addline(buffer, "[");
2457  if (reg->idx[1].rel_addr)
2458  {
2459  shader_dump_src_param(buffer, reg->idx[1].rel_addr, shader_version);
2460  shader_addline(buffer, " + ");
2461  }
2462  shader_addline(buffer, "%u]", reg->idx[1].offset);
2463  }
2464  }
2465 
2466  if (reg->type == WINED3DSPR_FUNCTIONPOINTER)
2467  shader_addline(buffer, "[%u]", reg->u.fp_body_idx);
2468  }
2469 }
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
enum wined3d_shader_type type
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLintptr offset
Definition: glext.h:5920
GLuint buffer
Definition: glext.h:5915
#define FIXME(fmt,...)
Definition: debug.h:110
static unsigned int shader_get_float_offset(enum wined3d_shader_register_type register_type, UINT register_idx)
Definition: shader.c:569
static void shader_dump_src_param(struct wined3d_string_buffer *buffer, const struct wined3d_shader_src_param *param, const struct wined3d_shader_version *shader_version)
Definition: shader.c:2494
unsigned int UINT
Definition: ndis.h:50
static int reg
Definition: i386-dis.c:1275

Referenced by shader_dump_dst_param(), and shader_dump_src_param().

◆ shader_dump_shader_input_sysval_semantic()

static void shader_dump_shader_input_sysval_semantic ( struct wined3d_string_buffer buffer,
enum wined3d_shader_input_sysval_semantic  semantic 
)
static

Definition at line 1975 of file shader.c.

1977 {
1978  unsigned int i;
1979 
1981  {
1983  {
1985  return;
1986  }
1987  }
1988 
1989  shader_addline(buffer, "unknown_shader_input_sysval_semantic(%#x)", semantic);
1990 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
enum wined3d_shader_input_sysval_semantic sysval_semantic
Definition: shader.c:302
GLuint buffer
Definition: glext.h:5915
static const struct @262 shader_input_sysval_semantic_names[]
const char * sysval_name
Definition: shader.c:303
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define ARRAY_SIZE(a)
Definition: main.h:24

Referenced by shader_trace_init().

◆ shader_dump_src_param()

static void shader_dump_src_param ( struct wined3d_string_buffer buffer,
const struct wined3d_shader_src_param param,
const struct wined3d_shader_version shader_version 
)
static

Definition at line 2494 of file shader.c.

2496 {
2497  enum wined3d_shader_src_modifier src_modifier = param->modifiers;
2498  DWORD swizzle = param->swizzle;
2499 
2500  if (src_modifier == WINED3DSPSM_NEG
2501  || src_modifier == WINED3DSPSM_BIASNEG
2502  || src_modifier == WINED3DSPSM_SIGNNEG
2503  || src_modifier == WINED3DSPSM_X2NEG
2504  || src_modifier == WINED3DSPSM_ABSNEG)
2505  shader_addline(buffer, "-");
2506  else if (src_modifier == WINED3DSPSM_COMP)
2507  shader_addline(buffer, "1-");
2508  else if (src_modifier == WINED3DSPSM_NOT)
2509  shader_addline(buffer, "!");
2510 
2511  if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG)
2512  shader_addline(buffer, "abs(");
2513 
2514  shader_dump_register(buffer, &param->reg, shader_version);
2515 
2516  switch (src_modifier)
2517  {
2518  case WINED3DSPSM_NONE: break;
2519  case WINED3DSPSM_NEG: break;
2520  case WINED3DSPSM_NOT: break;
2521  case WINED3DSPSM_BIAS: shader_addline(buffer, "_bias"); break;
2522  case WINED3DSPSM_BIASNEG: shader_addline(buffer, "_bias"); break;
2523  case WINED3DSPSM_SIGN: shader_addline(buffer, "_bx2"); break;
2524  case WINED3DSPSM_SIGNNEG: shader_addline(buffer, "_bx2"); break;
2525  case WINED3DSPSM_COMP: break;
2526  case WINED3DSPSM_X2: shader_addline(buffer, "_x2"); break;
2527  case WINED3DSPSM_X2NEG: shader_addline(buffer, "_x2"); break;
2528  case WINED3DSPSM_DZ: shader_addline(buffer, "_dz"); break;
2529  case WINED3DSPSM_DW: shader_addline(buffer, "_dw"); break;
2530  case WINED3DSPSM_ABSNEG: shader_addline(buffer, ")"); break;
2531  case WINED3DSPSM_ABS: shader_addline(buffer, ")"); break;
2532  default: shader_addline(buffer, "_unknown_modifier(%#x)", src_modifier);
2533  }
2534 
2536  {
2537  static const char swizzle_chars[] = "xyzw";
2538  DWORD swizzle_x = swizzle & 0x03;
2539  DWORD swizzle_y = (swizzle >> 2) & 0x03;
2540  DWORD swizzle_z = (swizzle >> 4) & 0x03;
2541  DWORD swizzle_w = (swizzle >> 6) & 0x03;
2542 
2543  if (swizzle_x == swizzle_y
2544  && swizzle_x == swizzle_z
2545  && swizzle_x == swizzle_w)
2546  {
2547  shader_addline(buffer, ".%c", swizzle_chars[swizzle_x]);
2548  }
2549  else
2550  {
2551  shader_addline(buffer, ".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
2552  swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]);
2553  }
2554  }
2555 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915
#define WINED3DSP_NOSWIZZLE
GLfloat param
Definition: glext.h:5796
unsigned long DWORD
Definition: ntddk_ex.h:95
wined3d_shader_src_modifier
static void shader_dump_register(struct wined3d_string_buffer *buffer, const struct wined3d_shader_register *reg, const struct wined3d_shader_version *shader_version)
Definition: shader.c:2176
GLuint GLenum swizzle
Definition: glext.h:9511

Referenced by shader_dump_register(), and shader_trace_init().

◆ shader_dump_sync_flags()

static void shader_dump_sync_flags ( struct wined3d_string_buffer buffer,
DWORD  sync_flags 
)
static

Definition at line 1875 of file shader.c.

1876 {
1877  if (sync_flags & WINED3DSSF_GROUP_SHARED_MEMORY)
1878  {
1879  shader_addline(buffer, "_g");
1880  sync_flags &= ~WINED3DSSF_GROUP_SHARED_MEMORY;
1881  }
1882  if (sync_flags & WINED3DSSF_THREAD_GROUP)
1883  {
1884  shader_addline(buffer, "_t");
1885  sync_flags &= ~WINED3DSSF_THREAD_GROUP;
1886  }
1887 
1888  if (sync_flags)
1889  shader_addline(buffer, "_unknown_flags(%#x)", sync_flags);
1890 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915

Referenced by shader_trace_init().

◆ shader_dump_tessellator_domain()

static void shader_dump_tessellator_domain ( struct wined3d_string_buffer buffer,
enum wined3d_tessellator_domain  domain 
)
static

Definition at line 1909 of file shader.c.

1911 {
1912  switch (domain)
1913  {
1915  shader_addline(buffer, "line");
1916  break;
1918  shader_addline(buffer, "triangle");
1919  break;
1921  shader_addline(buffer, "quad");
1922  break;
1923  default:
1924  shader_addline(buffer, "unknown_tessellator_domain(%#x)", domain);
1925  break;
1926  }
1927 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915

Referenced by shader_trace_init().

◆ shader_dump_tessellator_output_primitive()

static void shader_dump_tessellator_output_primitive ( struct wined3d_string_buffer buffer,
enum wined3d_tessellator_output_primitive  output_primitive 
)
static

Definition at line 1929 of file shader.c.

1931 {
1932  switch (output_primitive)
1933  {
1935  shader_addline(buffer, "point");
1936  break;
1938  shader_addline(buffer, "line");
1939  break;
1941  shader_addline(buffer, "triangle_cw");
1942  break;
1944  shader_addline(buffer, "triangle_ccw");
1945  break;
1946  default:
1947  shader_addline(buffer, "unknown_tessellator_output_primitive(%#x)", output_primitive);
1948  break;
1949  }
1950 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915

Referenced by shader_trace_init().

◆ shader_dump_tessellator_partitioning()

static void shader_dump_tessellator_partitioning ( struct wined3d_string_buffer buffer,
enum wined3d_tessellator_partitioning  partitioning 
)
static

Definition at line 1952 of file shader.c.

1954 {
1955  switch (partitioning)
1956  {
1958  shader_addline(buffer, "integer");
1959  break;
1961  shader_addline(buffer, "pow2");
1962  break;
1964  shader_addline(buffer, "fractional_odd");
1965  break;
1967  shader_addline(buffer, "fractional_even");
1968  break;
1969  default:
1970  shader_addline(buffer, "unknown_tessellator_partitioning(%#x)", partitioning);
1971  break;
1972  }
1973 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915

Referenced by shader_trace_init().

◆ shader_dump_uav_flags()

static void shader_dump_uav_flags ( struct wined3d_string_buffer buffer,
DWORD  uav_flags 
)
static

Definition at line 1892 of file shader.c.

1893 {
1894  if (uav_flags & WINED3DSUF_GLOBALLY_COHERENT)
1895  {
1896  shader_addline(buffer, "_glc");
1897  uav_flags &= ~WINED3DSUF_GLOBALLY_COHERENT;
1898  }
1899  if (uav_flags & WINED3DSUF_ORDER_PRESERVING_COUNTER)
1900  {
1901  shader_addline(buffer, "_opc");
1903  }
1904 
1905  if (uav_flags)
1906  shader_addline(buffer, "_unknown_flags(%#x)", uav_flags);
1907 }
int shader_addline(struct wined3d_string_buffer *buffer, const char *format,...)
Definition: shader.c:478
GLuint buffer
Definition: glext.h:5915

Referenced by shader_dump_decl_usage(), and shader_trace_init().

◆ shader_find_free_input_register()

unsigned int shader_find_free_input_register ( const struct wined3d_shader_reg_maps reg_maps,
unsigned int  max 
)

Definition at line 1838 of file shader.c.

1839 {
1840  DWORD map = 1u << max;
1841  map |= map - 1;
1842  map &= reg_maps->shader_version.major < 3 ? ~reg_maps->texcoord : ~reg_maps->input_registers;
1843 
1844  return wined3d_log2i(map);
1845 }
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 max(a, b)
Definition: svc.c:63
unsigned long DWORD
Definition: ntddk_ex.h:95
Definition: _map.h:44
struct wined3d_shader_version shader_version
static unsigned int wined3d_log2i(unsigned int x)
Definition: wined3d.h:2759

Referenced by find_arb_pshader().

◆ shader_generate_code()

HRESULT shader_generate_code ( const struct wined3d_shader shader,
struct wined3d_string_buffer buffer,
const struct wined3d_shader_reg_maps reg_maps,
void backend_ctx,
const DWORD start,
const DWORD end 
)

Definition at line 2558 of file shader.c.

2561 {
2562  struct wined3d_device *device = shader->device;
2563  const struct wined3d_shader_frontend *fe = shader->frontend;
2564  void *fe_data = shader->frontend_data;
2565  struct wined3d_shader_version shader_version;
2567  struct wined3d_shader_instruction ins;
2568  struct wined3d_shader_tex_mx tex_mx;
2569  struct wined3d_shader_context ctx;
2570  const DWORD *ptr;
2571 
2572  /* Initialize current parsing state. */
2573  tex_mx.current_row = 0;
2574  state.current_loop_depth = 0;
2575  state.current_loop_reg = 0;
2576  state.in_subroutine = FALSE;
2577 
2578  ctx.shader = shader;
2579  ctx.gl_info = &device->adapter->gl_info;
2580  ctx.reg_maps = reg_maps;
2581  ctx.buffer = buffer;
2582  ctx.tex_mx = &tex_mx;
2583  ctx.state = &state;
2584  ctx.backend_data = backend_ctx;
2585  ins.ctx = &ctx;
2586 
2587  fe->shader_read_header(fe_data, &ptr, &shader_version);
2588  if (start)
2589  ptr = start;
2590 
2591  while (!fe->shader_is_end(fe_data, &ptr) && ptr != end)
2592  {
2593  /* Read opcode. */
2594  fe->shader_read_instruction(fe_data, &ptr, &ins);
2595 
2596  /* Unknown opcode and its parameters. */
2597  if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
2598  {
2599  WARN("Encountered unrecognised or invalid instruction.\n");
2600  return WINED3DERR_INVALIDCALL;
2601  }
2602 
2603  if (ins.predicate)
2604  FIXME("Predicates not implemented.\n");
2605 
2606  /* Call appropriate function for output target */
2607  device->shader_backend->shader_handle_instruction(&ins);
2608  }
2609 
2610  return WINED3D_OK;
2611 }
#define WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
#define WARN(fmt,...)
Definition: debug.h:111
struct wined3d_shader_tex_mx * tex_mx
GLuint buffer
Definition: glext.h:5915
GLuint GLuint end
Definition: gl.h:1545
void(* shader_read_header)(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
BOOL(* shader_is_end)(void *data, const DWORD **ptr)
void(* shader_read_instruction)(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins)
Definition: devices.h:37
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
GLuint shader
Definition: glext.h:6030
#define WINED3D_OK
Definition: wined3d.h:37
unsigned long DWORD
Definition: ntddk_ex.h:95
static int state
Definition: maze.c:121
GLuint start
Definition: gl.h:1545
const struct wined3d_shader_reg_maps * reg_maps

Referenced by shader_arb_generate_pshader(), shader_arb_generate_vshader(), shader_glsl_generate_compute_shader(), shader_glsl_generate_domain_shader(), shader_glsl_generate_geometry_shader(), shader_glsl_generate_hull_shader(), shader_glsl_generate_pshader(), shader_glsl_generate_shader_phase(), and shader_glsl_generate_vshader().

◆ shader_get_float_offset()

static unsigned int shader_get_float_offset ( enum wined3d_shader_register_type  register_type,
UINT  register_idx 
)
static

Definition at line 569 of file shader.c.

570 {
571  switch (register_type)
572  {
573  case WINED3DSPR_CONST: return register_idx;
574  case WINED3DSPR_CONST2: return 2048 + register_idx;
575  case WINED3DSPR_CONST3: return 4096 + register_idx;
576  case WINED3DSPR_CONST4: return 6144 + register_idx;
577  default:
578  FIXME("Unsupported register type: %u.\n", register_type);
579  return register_idx;
580  }
581 }
#define FIXME(fmt,...)
Definition: debug.h:110

Referenced by shader_dump_register(), and shader_trace_init().

◆ shader_get_registers_used()

static HRESULT shader_get_registers_used ( struct wined3d_shader shader,
const struct wined3d_shader_frontend fe,
struct wined3d_shader_reg_maps reg_maps,
struct wined3d_shader_signature input_signature,
struct wined3d_shader_signature output_signature,
DWORD  constf_size 
)
static

Definition at line 987 of file shader.c.

990 {
991  struct wined3d_shader_signature_element input_signature_elements[max(MAX_ATTRIBS, MAX_REG_INPUT)];
992  struct wined3d_shader_signature_element output_signature_elements[MAX_REG_OUTPUT];
993  unsigned int cur_loop_depth = 0, max_loop_depth = 0;
994  struct wined3d_shader_version shader_version;
995  struct wined3d_shader_phase *phase = NULL;
996  const DWORD *ptr, *prev_ins, *current_ins;
997  void *fe_data = shader->frontend_data;
998  unsigned int i;
999  HRESULT hr;
1000 
1001  memset(reg_maps, 0, sizeof(*reg_maps));
1002  memset(input_signature_elements, 0, sizeof(input_signature_elements));
1003  memset(output_signature_elements, 0, sizeof(output_signature_elements));
1004  reg_maps->min_rel_offset = ~0U;
1005  list_init(&reg_maps->indexable_temps);
1006 
1007  fe->shader_read_header(fe_data, &ptr, &shader_version);
1008  prev_ins = current_ins = ptr;
1009  reg_maps->shader_version = shader_version;
1010 
1012 
1013  if (!(reg_maps->constf = heap_calloc(((min(shader->limits->constant_float, constf_size) + 31) / 32),
1014  sizeof(*reg_maps->constf))))
1015  {
1016  ERR("Failed to allocate constant map memory.\n");
1017  return E_OUTOFMEMORY;
1018  }
1019 
1020  while (!fe->shader_is_end(fe_data, &ptr))
1021  {
1022  struct wined3d_shader_instruction ins;
1023 
1024  current_ins = ptr;
1025  /* Fetch opcode. */
1026  fe->shader_read_instruction(fe_data, &ptr, &ins);
1027 
1028  /* Unhandled opcode, and its parameters. */
1029  if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
1030  {
1031  WARN("Encountered unrecognised or invalid instruction.\n");
1032  return WINED3DERR_INVALIDCALL;
1033  }
1034 
1035  /* Handle declarations. */
1036  if (ins.handler_idx == WINED3DSIH_DCL
1037  || ins.handler_idx == WINED3DSIH_DCL_UAV_TYPED)
1038  {
1039  struct wined3d_shader_semantic *semantic = &ins.declaration.semantic;
1040  unsigned int reg_idx = semantic->reg.reg.idx[0].offset;
1041 
1042  switch (semantic->reg.reg.type)
1043  {
1044  /* Mark input registers used. */
1045  case WINED3DSPR_INPUT:
1046  if (reg_idx >= MAX_REG_INPUT)
1047  {
1048  ERR("Invalid input register index %u.\n", reg_idx);
1049  break;
1050  }
1051  if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL && shader_version.major == 3
1052  && semantic->usage == WINED3D_DECL_USAGE_POSITION && !semantic->usage_idx)
1053  return WINED3DERR_INVALIDCALL;
1054  reg_maps->input_registers |= 1u << reg_idx;
1055  shader_signature_from_semantic(&input_signature_elements[reg_idx], semantic);
1056  break;
1057 
1058  /* Vertex shader: mark 3.0 output registers used, save token. */
1059  case WINED3DSPR_OUTPUT:
1060  if (reg_idx >= MAX_REG_OUTPUT)
1061  {
1062  ERR("Invalid output register index %u.\n", reg_idx);
1063  break;
1064  }
1065  reg_maps->output_registers |= 1u << reg_idx;
1066  shader_signature_from_semantic(&output_signature_elements[reg_idx], semantic);
1067  if (semantic->usage == WINED3D_DECL_USAGE_FOG)
1068  reg_maps->fog = 1;
1069  if (semantic->usage == WINED3D_DECL_USAGE_PSIZE)
1070  reg_maps->point_size = 1;
1071  break;
1072 
1073  case WINED3DSPR_SAMPLER:
1074  shader_record_sample(reg_maps, reg_idx, reg_idx, reg_idx);
1075  case WINED3DSPR_RESOURCE:
1076  if (reg_idx >= ARRAY_SIZE(reg_maps->resource_info))
1077  {
1078  ERR("Invalid resource index %u.\n", reg_idx);
1079  break;
1080  }
1081  reg_maps->resource_info[reg_idx].type = semantic->resource_type;
1082  reg_maps->resource_info[reg_idx].data_type = semantic->resource_data_type;
1083  break;
1084 
1085  case WINED3DSPR_UAV:
1086  if (reg_idx >= ARRAY_SIZE(reg_maps->uav_resource_info))
1087  {
1088  ERR("Invalid UAV resource index %u.\n", reg_idx);
1089  break;
1090  }
1091  reg_maps->uav_resource_info[reg_idx].type = semantic->resource_type;
1092  reg_maps->uav_resource_info[reg_idx].data_type = semantic->resource_data_type;
1093  if (ins.flags)
1094  FIXME("Ignoring typed UAV flags %#x.\n", ins.flags);
1095  break;
1096 
1097  default:
1098  TRACE("Not recording DCL register type %#x.\n", semantic->reg.reg.type);
1099  break;
1100  }
1101  }
1102  else if (ins.handler_idx == WINED3DSIH_DCL_CONSTANT_BUFFER)
1103  {
1104  struct wined3d_shader_register *reg = &ins.declaration.src.reg;
1105  if (reg->idx[0].offset >= WINED3D_MAX_CBS)
1106  ERR("Invalid CB index %u.\n", reg->idx[0].offset);
1107  else
1108  reg_maps->cb_sizes[reg->idx[0].offset] = reg->idx[1].offset;
1109  }
1110  else if (ins.handler_idx == WINED3DSIH_DCL_GLOBAL_FLAGS)
1111  {
1112  if (ins.flags & WINED3DSGF_FORCE_EARLY_DEPTH_STENCIL)
1113  {
1114  if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1115  shader->u.ps.force_early_depth_stencil = TRUE;
1116  else
1117  FIXME("Invalid instruction %#x for shader type %#x.\n",
1118  ins.handler_idx, shader_version.type);
1119  }
1120  else
1121  {
1122  WARN("Ignoring global flags %#x.\n", ins.flags);
1123  }
1124  }
1125  else if (ins.handler_idx == WINED3DSIH_DCL_GS_INSTANCES)
1126  {
1127  if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
1128  shader->u.gs.instance_count = ins.declaration.count;
1129  else
1130  FIXME("Invalid instruction %#x for shader type %#x.\n",
1131  ins.handler_idx, shader_version.type);
1132  }
1133  else if (ins.handler_idx == WINED3DSIH_DCL_HS_FORK_PHASE_INSTANCE_COUNT
1134  || ins.handler_idx == WINED3DSIH_DCL_HS_JOIN_PHASE_INSTANCE_COUNT)
1135  {
1136  if (phase)
1137  phase->instance_count = ins.declaration.count;
1138  else
1139  FIXME("Instruction %s outside of shader phase.\n",
1140  debug_d3dshaderinstructionhandler(ins.handler_idx));
1141  }
1142  else if (ins.handler_idx == WINED3DSIH_DCL_IMMEDIATE_CONSTANT_BUFFER)
1143  {
1144  if (reg_maps->icb)
1145  FIXME("Multiple immediate constant buffers.\n");
1146  reg_maps->icb = ins.declaration.icb;
1147  }
1148  else if (ins.handler_idx == WINED3DSIH_DCL_INDEXABLE_TEMP)
1149  {
1150  if (phase)
1151  {
1152  FIXME("Indexable temporary registers not supported.\n");
1153  }
1154  else
1155  {
1157 
1158  if (!(reg = heap_alloc(sizeof(*reg))))
1159  return E_OUTOFMEMORY;
1160 
1161  *reg = ins.declaration.indexable_temp;
1162  list_add_tail(&reg_maps->indexable_temps, &reg->entry);
1163  }
1164  }
1165  else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PRIMITIVE)
1166  {
1167  if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
1168  shader->u.gs.input_type = ins.declaration.primitive_type.type;
1169  else
1170  FIXME("Invalid instruction %#x for shader type %#x.\n",
1171  ins.handler_idx, shader_version.type);
1172  }
1173  else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PS)
1174  {
1175  unsigned int reg_idx = ins.declaration.dst.reg.idx[0].offset;
1176  if (reg_idx >= MAX_REG_INPUT)
1177  {
1178  ERR("Invalid register index %u.\n", reg_idx);
1179  break;
1180  }
1181  if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1182  wined3d_insert_interpolation_mode(shader->u.ps.interpolation_mode, reg_idx, ins.flags);
1183  else
1184  FIXME("Invalid instruction %#x for shader type %#x.\n",
1185  ins.handler_idx, shader_version.type);
1186  }
1187  else if (ins.handler_idx == WINED3DSIH_DCL_OUTPUT)
1188  {
1189  if (ins.declaration.dst.reg.type == WINED3DSPR_DEPTHOUT
1190  || ins.declaration.dst.reg.type == WINED3DSPR_DEPTHOUTGE
1191  || ins.declaration.dst.reg.type == WINED3DSPR_DEPTHOUTLE)
1192  {
1193  if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1194  shader->u.ps.depth_output = ins.declaration.dst.reg.type;
1195  else
1196  FIXME("Invalid instruction %#x for shader type %#x.\n",
1197  ins.handler_idx, shader_version.type);
1198  }
1199  }
1200  else if (ins.handler_idx == WINED3DSIH_DCL_OUTPUT_CONTROL_POINT_COUNT)
1201  {
1202  if (shader_version.type == WINED3D_SHADER_TYPE_HULL)
1203  shader->u.hs.output_vertex_count = ins.declaration.count;
1204  else
1205  FIXME("Invalid instruction %#x for shader type %#x.\n", ins.handler_idx, shader_version.type);
1206  }
1207  else if (ins.handler_idx == WINED3DSIH_DCL_OUTPUT_TOPOLOGY)
1208  {
1209  if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
1210  shader->u.gs.output_type = ins.declaration.primitive_type.type;
1211  else
1212  FIXME("Invalid instruction %#x for shader type %#x.\n",
1213  ins.handler_idx, shader_version.type);
1214  }
1215  else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_RAW)
1216  {
1217  unsigned int reg_idx = ins.declaration.dst.reg.idx[0].offset;
1218  if (reg_idx >= ARRAY_SIZE(reg_maps->resource_info))
1219  {
1220  ERR("Invalid resource index %u.\n", reg_idx);
1221  break;
1222  }
1223  reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
1224  reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
1225  reg_maps->resource_info[reg_idx].flags = WINED3D_VIEW_BUFFER_RAW;
1226  }
1227  else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_STRUCTURED)
1228  {
1229  unsigned int reg_idx = ins.declaration.structured_resource.reg.reg.idx[0].offset;
1230  if (reg_idx >= ARRAY_SIZE(reg_maps->resource_info))
1231  {
1232  ERR("Invalid resource index %u.\n", reg_idx);
1233  break;
1234  }
1235  reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
1236  reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
1237  reg_maps->resource_info[reg_idx].flags = 0;
1238  reg_maps->resource_info[reg_idx].stride = ins.declaration.structured_resource.byte_stride / 4;
1239  }
1240  else if (ins.handler_idx == WINED3DSIH_DCL_SAMPLER)
1241  {
1242  if (ins.flags & WINED3DSI_SAMPLER_COMPARISON_MODE)
1243  reg_maps->sampler_comparison_mode |= (1u << ins.declaration.dst.reg.idx[0].offset);
1244  }
1245  else if (ins.handler_idx == WINED3DSIH_DCL_TEMPS)
1246  {
1247  if (phase)
1248  phase->temporary_count = ins.declaration.count;
1249  else
1250  reg_maps->temporary_count = ins.declaration.count;
1251  }
1252  else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_DOMAIN)
1253  {
1254  if (shader_version.type == WINED3D_SHADER_TYPE_DOMAIN)
1255  shader->u.ds.tessellator_domain = ins.declaration.tessellator_domain;
1256  else if (shader_version.type != WINED3D_SHADER_TYPE_HULL)
1257  FIXME("Invalid instruction %#x for shader type %#x.\n", ins.handler_idx, shader_version.type);
1258  }
1259  else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE)
1260  {
1261  if (shader_version.type == WINED3D_SHADER_TYPE_HULL)
1262  shader->u.hs.tessellator_output_primitive = ins.declaration.tessellator_output_primitive;
1263  else
1264  FIXME("Invalid instruction %#x for shader type %#x.\n", ins.handler_idx, shader_version.type);
1265  }
1266  else if (ins.handler_idx == WINED3DSIH_DCL_TESSELLATOR_PARTITIONING)
1267  {
1268  if (shader_version.type == WINED3D_SHADER_TYPE_HULL)
1269  shader->u.hs.tessellator_partitioning = ins.declaration.tessellator_partitioning;
1270  else
1271  FIXME("Invalid instruction %#x for shader type %#x.\n", ins.handler_idx, shader_version.type);
1272  }
1273  else if (ins.handler_idx == WINED3DSIH_DCL_TGSM_RAW)
1274  {
1275  if (FAILED(hr = shader_reg_maps_add_tgsm(reg_maps, ins.declaration.tgsm_raw.reg.reg.idx[0].offset,
1276  ins.declaration.tgsm_raw.byte_count / 4, 0)))
1277  return hr;
1278  }
1279  else if (ins.handler_idx == WINED3DSIH_DCL_TGSM_STRUCTURED)
1280  {
1281  unsigned int stride = ins.declaration.tgsm_structured.byte_stride / 4;
1282  unsigned int size = stride * ins.declaration.tgsm_structured.structure_count;
1283  if (FAILED(hr = shader_reg_maps_add_tgsm(reg_maps,
1284  ins.declaration.tgsm_structured.reg.reg.idx[0].offset, size, stride)))
1285  return hr;
1286  }
1287  else if (ins.handler_idx == WINED3DSIH_DCL_THREAD_GROUP)
1288  {
1289  if (shader_version.type == WINED3D_SHADER_TYPE_COMPUTE)
1290  {
1291  shader->u.cs.thread_group_size = ins.declaration.thread_group_size;
1292  }
1293  else
1294  {
1295  FIXME("Invalid instruction %#x for shader type %#x.\n",
1296  ins.handler_idx, shader_version.type);
1297  }
1298  }
1299  else if (ins.handler_idx == WINED3DSIH_DCL_UAV_RAW)
1300  {
1301  unsigned int reg_idx = ins.declaration.dst.reg.idx[0].offset;
1302  if (reg_idx >= ARRAY_SIZE(reg_maps->uav_resource_info))
1303  {
1304  ERR("Invalid UAV resource index %u.\n", reg_idx);
1305  break;
1306  }
1307  if (ins.flags)
1308  FIXME("Ignoring raw UAV flags %#x.\n", ins.flags);
1309  reg_maps->uav_resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
1310  reg_maps->uav_resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
1311  reg_maps->uav_resource_info[reg_idx].flags = WINED3D_VIEW_BUFFER_RAW;
1312  }
1313  else if (ins.handler_idx == WINED3DSIH_DCL_UAV_STRUCTURED)
1314  {
1315  unsigned int reg_idx = ins.declaration.structured_resource.reg.reg.idx[0].offset;
1316  if (reg_idx >= ARRAY_SIZE(reg_maps->uav_resource_info))
1317  {
1318  ERR("Invalid UAV resource index %u.\n", reg_idx);
1319  break;
1320  }
1321  if (ins.flags)
1322  FIXME("Ignoring structured UAV flags %#x.\n", ins.flags);
1323  reg_maps->uav_resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
1324  reg_maps->uav_resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
1325  reg_maps->uav_resource_info[reg_idx].flags = 0;
1326  reg_maps->uav_resource_info[reg_idx].stride = ins.declaration.structured_resource.byte_stride / 4;
1327  }
1328  else if (ins.handler_idx == WINED3DSIH_DCL_VERTICES_OUT)
1329  {
1330  if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
1331  shader->u.gs.vertices_out = ins.declaration.count;
1332  else
1333  FIXME("Invalid instruction %#x for shader type %#x.\n",
1334  ins.handler_idx, shader_version.type);
1335  }
1336  else if (ins.handler_idx == WINED3DSIH_DEF)
1337  {
1338  struct wined3d_shader_lconst *lconst;
1339  float *value;
1340 
1341  if (!(lconst = heap_alloc(sizeof(*lconst))))
1342  return E_OUTOFMEMORY;
1343 
1344  lconst->idx = ins.dst[0].reg.idx[0].offset;
1345  memcpy(lconst->value, ins.src[0].reg.u.immconst_data, 4 * sizeof(DWORD));
1346  value = (float *)lconst->value;
1347 
1348  /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
1349  if (shader_version.major == 1 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1350  {
1351  if (value[0] < -1.0f) value[0] = -1.0f;
1352  else if (value[0] > 1.0f) value[0] = 1.0f;
1353  if (value[1] < -1.0f) value[1] = -1.0f;
1354  else if (value[1] > 1.0f) value[1] = 1.0f;
1355  if (value[2] < -1.0f) value[2] = -1.0f;
1356  else if (value[2] > 1.0f) value[2] = 1.0f;
1357  if (value[3] < -1.0f) value[3] = -1.0f;
1358  else if (value[3] > 1.0f) value[3] = 1.0f;
1359  }
1360 
1361  list_add_head(&shader->constantsF, &lconst->entry);
1362 
1363  if (isinf(value[0]) || isnan(value[0]) || isinf(value[1]) || isnan(value[1])
1364  || isinf(value[2]) || isnan(value[2]) || isinf(value[3]) || isnan(value[3]))
1365  {
1366  shader->lconst_inf_or_nan = TRUE;
1367  }
1368  }
1369  else if (ins.handler_idx == WINED3DSIH_DEFI)
1370  {
1371  struct wined3d_shader_lconst *lconst;
1372 
1373  if (!(lconst = heap_alloc(sizeof(*lconst))))
1374  return E_OUTOFMEMORY;
1375 
1376  lconst->idx = ins.dst[0].reg.idx[0].offset;
1377  memcpy(lconst->value, ins.src[0].reg.u.immconst_data, 4 * sizeof(DWORD));
1378 
1379  list_add_head(&shader->constantsI, &lconst->entry);
1380  reg_maps->local_int_consts |= (1u << lconst->idx);
1381  }
1382  else if (ins.handler_idx == WINED3DSIH_DEFB)
1383  {
1384  struct wined3d_shader_lconst *lconst;
1385 
1386  if (!(lconst = heap_alloc(sizeof(*lconst))))
1387  return E_OUTOFMEMORY;
1388 
1389  lconst->idx = ins.dst[0].reg.idx[0].offset;
1390  memcpy(lconst->value, ins.src[0].reg.u.immconst_data, sizeof(DWORD));
1391 
1392  list_add_head(&shader->constantsB, &lconst->entry);
1393  reg_maps->local_bool_consts |= (1u << lconst->idx);
1394  }
1395  /* Handle shader phases. */
1396  else if (ins.handler_idx == WINED3DSIH_HS_CONTROL_POINT_PHASE
1397  || ins.handler_idx == WINED3DSIH_HS_FORK_PHASE
1398  || ins.handler_idx == WINED3DSIH_HS_JOIN_PHASE)
1399  {
1400  if (FAILED(hr = shader_record_shader_phase(shader, &phase, &ins, current_ins, prev_ins)))
1401  return hr;
1402  }
1403  /* For subroutine prototypes. */
1404  else if (ins.handler_idx == WINED3DSIH_LABEL)
1405  {
1406  reg_maps->labels |= 1u << ins.src[0].reg.idx[0].offset;
1407  }
1408  /* Set texture, address, temporary registers. */
1409  else
1410  {
1411  BOOL color0_mov = FALSE;
1412  unsigned int i;
1413 
1414  /* This will loop over all the registers and try to
1415  * make a bitmask of the ones we're interested in.
1416  *
1417  * Relative addressing tokens are ignored, but that's
1418  * okay, since we'll catch any address registers when
1419  * they are initialized (required by spec). */
1420  for (i = 0; i < ins.dst_count; ++i)
1421  {
1422  if (!shader_record_register_usage(shader, reg_maps, &ins.dst[i].reg,
1423  shader_version.type, constf_size))
1424  return WINED3DERR_INVALIDCALL;
1425 
1426  if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX)
1427  {
1428  UINT idx = ins.dst[i].reg.idx[0].offset;
1429 
1430  switch (ins.dst[i].reg.type)
1431  {
1432  case WINED3DSPR_RASTOUT:
1433  if (shader_version.major >= 3)
1434  break;
1435  switch (idx)
1436  {
1437  case 0: /* oPos */
1438  reg_maps->output_registers |= 1u << 10;
1439  shader_signature_from_usage(&output_signature_elements[10],
1441  break;
1442 
1443  case 1: /* oFog */
1444  reg_maps->output_registers |= 1u << 11;
1445  shader_signature_from_usage(&output_signature_elements[11],
1447  break;
1448 
1449  case 2: /* oPts */
1450  reg_maps->output_registers |= 1u << 11;
1451  shader_signature_from_usage(&output_signature_elements[11],
1453  break;
1454  }
1455  break;
1456 
1457  case WINED3DSPR_ATTROUT:
1458  if (shader_version.major >= 3)
1459  break;
1460  if (idx < 2)
1461  {
1462  idx += 8;
1463  if (reg_maps->output_registers & (1u << idx))
1464  {
1465  output_signature_elements[idx].mask |= ins.dst[i].write_mask;
1466  }
1467  else
1468  {
1469  reg_maps->output_registers |= 1u << idx;
1470  shader_signature_from_usage(&output_signature_elements[idx],
1471  WINED3D_DECL_USAGE_COLOR, idx - 8, idx, ins.dst[i].write_mask);
1472  }
1473  }
1474  break;
1475 
1476  case WINED3DSPR_TEXCRDOUT: /* WINED3DSPR_OUTPUT */
1477  if (shader_version.major >= 3)
1478  {
1479  if (idx >= ARRAY_SIZE(reg_maps->u.output_registers_mask))
1480  {
1481  WARN("Invalid output register index %u.\n", idx);
1482  break;
1483  }
1484  reg_maps->u.output_registers_mask[idx] |= ins.dst[i].write_mask;
1485  break;
1486  }
1487  if (idx >= ARRAY_SIZE(reg_maps->u.texcoord_mask))
1488  {
1489  WARN("Invalid texcoord index %u.\n", idx);
1490  break;
1491  }
1492  reg_maps->u.texcoord_mask[idx] |= ins.dst[i].write_mask;
1493  if (reg_maps->output_registers & (1u << idx))
1494  {
1495  output_signature_elements[idx].mask |= ins.dst[i].write_mask;
1496  }
1497  else
1498  {
1499  reg_maps->output_registers |= 1u << idx;
1500  shader_signature_from_usage(&output_signature_elements[idx],
1501  WINED3D_DECL_USAGE_TEXCOORD, idx, idx, ins.dst[i].write_mask);
1502  }
1503  break;
1504 
1505  default:
1506  break;
1507  }
1508  }
1509 
1510  if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1511  {
1512  if (ins.dst[i].reg.type == WINED3DSPR_COLOROUT && !ins.dst[i].reg.idx[0].offset)
1513  {
1514  /* Many 2.0 and 3.0 pixel shaders end with a MOV from a temp register to
1515  * COLOROUT 0. If we know this in advance, the ARB shader backend can skip
1516  * the mov and perform the sRGB write correction from the source register.
1517  *
1518  * However, if the mov is only partial, we can't do this, and if the write
1519  * comes from an instruction other than MOV it is hard to do as well. If
1520  * COLOROUT 0 is overwritten partially later, the marker is dropped again. */
1521  shader->u.ps.color0_mov = FALSE;
1522  if (ins.handler_idx == WINED3DSIH_MOV
1523  && ins.dst[i].write_mask == WINED3DSP_WRITEMASK_ALL)
1524  {
1525  /* Used later when the source register is read. */
1526  color0_mov = TRUE;
1527  }
1528  }
1529  /* Also drop the MOV marker if the source register is overwritten prior to the shader
1530  * end
1531  */
1532  else if (ins.dst[i].reg.type == WINED3DSPR_TEMP
1533  && ins.dst[i].reg.idx[0].offset == shader->u.ps.color0_reg)
1534  {
1535  shader->u.ps.color0_mov = FALSE;
1536  }
1537  }
1538 
1539  /* Declare 1.x samplers implicitly, based on the destination reg. number. */
1540  if (shader_version.major == 1
1541  && (ins.handler_idx == WINED3DSIH_TEX
1542  || ins.handler_idx == WINED3DSIH_TEXBEM
1543  || ins.handler_idx == WINED3DSIH_TEXBEML
1544  || ins.handler_idx == WINED3DSIH_TEXDP3TEX
1545  || ins.handler_idx == WINED3DSIH_TEXM3x2TEX
1546  || ins.handler_idx == WINED3DSIH_TEXM3x3SPEC
1547  || ins.handler_idx == WINED3DSIH_TEXM3x3TEX
1548  || ins.handler_idx == WINED3DSIH_TEXM3x3VSPEC
1549  || ins.handler_idx == WINED3DSIH_TEXREG2AR
1550  || ins.handler_idx == WINED3DSIH_TEXREG2GB
1551  || ins.handler_idx == WINED3DSIH_TEXREG2RGB))
1552  {
1553  unsigned int reg_idx = ins.dst[i].reg.idx[0].offset;
1554 
1555  if (reg_idx >= ARRAY_SIZE(reg_maps->resource_info))
1556  {
1557  WARN("Invalid 1.x sampler index %u.\n", reg_idx);
1558  continue;
1559  }
1560 
1561  TRACE("Setting fake 2D resource for 1.x pixelshader.\n");
1562  reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_TEXTURE_2D;
1563  reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_FLOAT;
1564  shader_record_sample(reg_maps, reg_idx, reg_idx, reg_idx);
1565 
1566  /* texbem is only valid with < 1.4 pixel shaders */
1567  if (ins.handler_idx == WINED3DSIH_TEXBEM
1568  || ins.handler_idx == WINED3DSIH_TEXBEML)
1569  {
1570  reg_maps->bumpmat |= 1u << reg_idx;
1571  if (ins.handler_idx == WINED3DSIH_TEXBEML)
1572  {
1573  reg_maps->luminanceparams |= 1u << reg_idx;
1574  }
1575  }
1576  }
1577  else if (ins.handler_idx == WINED3DSIH_BEM)
1578  {
1579  reg_maps->bumpmat |= 1u << ins.dst[i].reg.idx[0].offset;
1580  }
1581  }
1582 
1583  if (ins.handler_idx == WINED3DSIH_IMM_ATOMIC_ALLOC || ins.handler_idx == WINED3DSIH_IMM_ATOMIC_CONSUME)
1584  {
1585  unsigned int reg_idx = ins.src[0].reg.idx[0].offset;
1586  if (reg_idx >= MAX_UNORDERED_ACCESS_VIEWS)
1587  {
1588  ERR("Invalid UAV index %u.\n", reg_idx);
1589  break;
1590  }
1591  reg_maps->uav_counter_mask |= (1u << reg_idx);
1592  }
1593  else if ((WINED3DSIH_ATOMIC_AND <= ins.handler_idx && ins.handler_idx <= WINED3DSIH_ATOMIC_XOR)
1594  || (WINED3DSIH_IMM_ATOMIC_AND <= ins.handler_idx && ins.handler_idx <= WINED3DSIH_IMM_ATOMIC_XOR)
1595  || (ins.handler_idx == WINED3DSIH_BUFINFO && ins.src[0].reg.type == WINED3DSPR_UAV)
1596  || ins.handler_idx == WINED3DSIH_LD_UAV_TYPED
1597  || (ins.handler_idx == WINED3DSIH_LD_RAW && ins.src[1].reg.type == WINED3DSPR_UAV)
1598  || (ins.handler_idx == WINED3DSIH_LD_STRUCTURED && ins.src[2].reg.type == WINED3DSPR_UAV))
1599  {
1600  unsigned int reg_idx;
1601  if (ins.handler_idx == WINED3DSIH_LD_UAV_TYPED || ins.handler_idx == WINED3DSIH_LD_RAW)
1602  reg_idx = ins.src[1].reg.idx[0].offset;
1603  else if (ins.handler_idx == WINED3DSIH_LD_STRUCTURED)
1604  reg_idx = ins.src[2].reg.idx[0].offset;
1605  else if (WINED3DSIH_ATOMIC_AND <= ins.handler_idx && ins.handler_idx <= WINED3DSIH_ATOMIC_XOR)
1606  reg_idx = ins.dst[0].reg.idx[0].offset;
1607  else if (ins.handler_idx == WINED3DSIH_BUFINFO)
1608  reg_idx = ins.src[0].reg.idx[0].offset;
1609  else
1610  reg_idx = ins.dst[1].reg.idx[0].offset;
1611  if (reg_idx >= MAX_UNORDERED_ACCESS_VIEWS)
1612  {
1613  ERR("Invalid UAV index %u.\n", reg_idx);
1614  break;
1615  }
1616  reg_maps->uav_read_mask |= (1u << reg_idx);
1617  }
1618  else if (ins.handler_idx == WINED3DSIH_NRM)
1619  {
1620  reg_maps->usesnrm = 1;
1621  }
1622  else if (ins.handler_idx == WINED3DSIH_DSY
1623  || ins.handler_idx == WINED3DSIH_DSY_COARSE
1624  || ins.handler_idx == WINED3DSIH_DSY_FINE)
1625  {
1626  reg_maps->usesdsy = 1;
1627  }
1628  else if (ins.handler_idx == WINED3DSIH_DSX
1629  || ins.handler_idx == WINED3DSIH_DSX_COARSE
1630  || ins.handler_idx == WINED3DSIH_DSX_FINE)
1631  {
1632  reg_maps->usesdsx = 1;
1633  }
1634  else if (ins.handler_idx == WINED3DSIH_TEXLDD) reg_maps->usestexldd = 1;
1635  else if (ins.handler_idx == WINED3DSIH_TEXLDL) reg_maps->usestexldl = 1;
1636  else if (ins.handler_idx == WINED3DSIH_MOVA) reg_maps->usesmova = 1;
1637  else if (ins.handler_idx == WINED3DSIH_IFC) reg_maps->usesifc = 1;
1638  else if (ins.handler_idx == WINED3DSIH_CALL) reg_maps->usescall = 1;
1639  else if (ins.handler_idx == WINED3DSIH_POW) reg_maps->usespow = 1;
1640  else if (ins.handler_idx == WINED3DSIH_LOOP
1641  || ins.handler_idx == WINED3DSIH_REP)
1642  {
1643  ++cur_loop_depth;
1644  if (cur_loop_depth > max_loop_depth)
1645  max_loop_depth = cur_loop_depth;
1646  }
1647  else if (ins.handler_idx == WINED3DSIH_ENDLOOP
1648  || ins.handler_idx == WINED3DSIH_ENDREP)
1649  {
1650  --cur_loop_depth;
1651  }
1652  else if (ins.handler_idx == WINED3DSIH_GATHER4
1653  || ins.handler_idx == WINED3DSIH_GATHER4_C
1654  || ins.handler_idx == WINED3DSIH_SAMPLE
1655  || ins.handler_idx == WINED3DSIH_SAMPLE_B
1656  || ins.handler_idx == WINED3DSIH_SAMPLE_C
1657  || ins.handler_idx == WINED3DSIH_SAMPLE_C_LZ
1658  || ins.handler_idx == WINED3DSIH_SAMPLE_GRAD
1659  || ins.handler_idx == WINED3DSIH_SAMPLE_LOD)
1660  {
1661  shader_record_sample(reg_maps, ins.src[1].reg.idx[0].offset,
1662  ins.src[2].reg.idx[0].offset, reg_maps->sampler_map.count);
1663  }
1664  else if (ins.handler_idx == WINED3DSIH_GATHER4_PO
1665  || ins.handler_idx == WINED3DSIH_GATHER4_PO_C)
1666  {
1667  shader_record_sample(reg_maps, ins.src[2].reg.idx[0].offset,
1668  ins.src[3].reg.idx[0].offset, reg_maps->sampler_map.count);
1669  }
1670  else if (ins.handler_idx == WINED3DSIH_BUFINFO && ins.src[0].reg.type == WINED3DSPR_RESOURCE)
1671  {
1672  shader_record_sample(reg_maps, ins.src[0].reg.idx[0].offset,
1673  WINED3D_SAMPLER_DEFAULT, reg_maps->sampler_map.count);
1674  }
1675  else if (ins.handler_idx == WINED3DSIH_LD
1676  || ins.handler_idx == WINED3DSIH_LD2DMS
1677  || (ins.handler_idx == WINED3DSIH_LD_RAW && ins.src[1].reg.type == WINED3DSPR_RESOURCE)
1678  || (ins.handler_idx == WINED3DSIH_RESINFO && ins.src[1].reg.type == WINED3DSPR_RESOURCE))
1679  {
1680  shader_record_sample(reg_maps, ins.src[1].reg.idx[0].offset,
1681  WINED3D_SAMPLER_DEFAULT, reg_maps->sampler_map.count);
1682  }
1683  else if (ins.handler_idx == WINED3DSIH_LD_STRUCTURED
1684  && ins.src[2].reg.type == WINED3DSPR_RESOURCE)
1685  {
1686  shader_record_sample(reg_maps, ins.src[2].reg.idx[0].offset,
1687  WINED3D_SAMPLER_DEFAULT, reg_maps->sampler_map.count);
1688  }
1689 
1690  if (ins.predicate)
1691  if (!shader_record_register_usage(shader, reg_maps, &ins.predicate->reg,
1692  shader_version.type, constf_size))
1693  return WINED3DERR_INVALIDCALL;
1694 
1695  for (i = 0; i < ins.src_count; ++i)
1696  {
1697  unsigned int count = get_instr_extra_regcount(ins.handler_idx, i);
1698  struct wined3d_shader_register reg = ins.src[i].reg;
1699 
1700  if (!shader_record_register_usage(shader, reg_maps, &ins.src[i].reg,
1701  shader_version.type, constf_size))
1702  return WINED3DERR_INVALIDCALL;
1703  while (count)
1704  {
1705  ++reg.idx[0].offset;
1706  if (!shader_record_register_usage(shader, reg_maps, &reg,
1707  shader_version.type, constf_size))
1708  return WINED3DERR_INVALIDCALL;
1709  --count;
1710  }
1711 
1712  if (color0_mov)
1713  {
1714  if (ins.src[i].reg.type == WINED3DSPR_TEMP
1715  && ins.src[i].swizzle == WINED3DSP_NOSWIZZLE)
1716  {
1717  shader->u.ps.color0_mov = TRUE;
1718  shader->u.ps.color0_reg = ins.src[i].reg.idx[0].offset;
1719  }
1720  }
1721  }
1722  }
1723 
1724  prev_ins = current_ins;
1725  }
1726  reg_maps->loop_depth = max_loop_depth;
1727 
1728  if (phase)
1729  {
1730  phase->end = prev_ins;
1731  phase = NULL;
1732  }
1733 
1734  /* PS before 2.0 don't have explicit color outputs. Instead the value of
1735  * R0 is written to the render target. */
1736  if (shader_version.major < 2 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1737  reg_maps->rt_mask |= (1u << 0);
1738 
1739  if (input_signature->elements)
1740  {
1741  for (i = 0; i < input_signature->element_count; ++i)
1742  {
1743  if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX)
1744  {
1745  if (input_signature->elements[i].register_idx >= ARRAY_SIZE(shader->u.vs.attributes))
1746  {
1747  WARN("Invalid input signature register index %u.\n", input_signature->elements[i].register_idx);
1748  return WINED3DERR_INVALIDCALL;
1749  }
1750  }
1751  else if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
1752  {
1753  if (input_signature->elements[i].sysval_semantic == WINED3D_SV_POSITION)
1754  reg_maps->vpos = 1;
1755  else if (input_signature->elements[i].sysval_semantic == WINED3D_SV_IS_FRONT_FACE)
1756  reg_maps->usesfacing = 1;
1757  }
1758  reg_maps->input_registers |= 1u << input_signature->elements[i].register_idx;
1759  }
1760  }
1761  else if (!input_signature->elements && reg_maps->input_registers)
1762  {
1763  unsigned int count = wined3d_popcount(reg_maps->input_registers);
1765  unsigned int i;
1766 
1767  if (!(input_signature->elements = heap_calloc(count, sizeof(*input_signature->elements))))
1768  return E_OUTOFMEMORY;
1769  input_signature->element_count = count;
1770 
1771  e = input_signature->elements;
1772  for (i = 0; i < ARRAY_SIZE(input_signature_elements); ++i)
1773  {
1774  if (!(reg_maps->input_registers & (1u << i)))
1775  continue;
1776  input_signature_elements[i].register_idx = i;
1777  *e++ = input_signature_elements[i];
1778  }
1779  }
1780 
1781  if (output_signature->elements)
1782  {
1783  for (i = 0; i < output_signature->element_count; ++i)
1784  {
1785  const struct wined3d_shader_signature_element *e = &output_signature->elements[i];
1786  unsigned int mask;
1787 
1788  reg_maps->output_registers |= 1u << e->register_idx;
1789  if (e->sysval_semantic == WINED3D_SV_CLIP_DISTANCE)
1790  {
1792  return hr;
1793  reg_maps->clip_distance_mask |= mask;
1794  }
1795  else if (e->sysval_semantic == WINED3D_SV_CULL_DISTANCE)
1796  {
1798  return hr;
1799  reg_maps->cull_distance_mask |= mask;
1800  }
1801  }
1802  }
1803  else if (reg_maps->output_registers)
1804  {
1805  unsigned int count = wined3d_popcount(reg_maps->output_registers);
1807 
1808  if (!(output_signature->elements = heap_calloc(count, sizeof(*output_signature->elements))))
1809  return E_OUTOFMEMORY;
1810  output_signature->element_count = count;
1811 
1812  e = output_signature->elements;
1813  for (i = 0; i < ARRAY_SIZE(output_signature_elements); ++i)
1814  {
1815  if (!(reg_maps->output_registers & (1u << i)))
1816  continue;
1817  *e++ = output_signature_elements[i];
1818  }
1819  }
1820 
1821  return WINED3D_OK;
1822 }
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 WINED3DERR_INVALIDCALL
Definition: wined3d.h:48
static void shader_record_sample(struct wined3d_shader_reg_maps *reg_maps, unsigned int resource_idx, unsigned int sampler_idx, unsigned int bind_idx)
Definition: shader.c:812
#define max(a, b)
Definition: svc.c:63
#define WINED3DSP_WRITEMASK_0
#define TRUE
Definition: types.h:120
unsigned int temporary_count
HRESULT hr
Definition: shlfolder.c:183
GLuint GLuint GLsizei count
Definition: gl.h:1545
static unsigned int wined3d_popcount(unsigned int x)
#define WARN(fmt,...)
Definition: debug.h:111
#define U(x)
Definition: wordpad.c:44
#define WINED3D_MAX_CBS
static BOOL shader_record_register_usage(struct wined3d_shader *shader, struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_shader_register *reg, enum wined3d_shader_type shader_type, unsigned int constf_size)
Definition: shader.c:696
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
Definition: list.h:96
#define MAX_REG_OUTPUT
const char * debug_d3dshaderinstructionhandler(enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx)
Definition: shader.c:334
#define WINED3DSI_SAMPLER_COMPARISON_MODE
void(* shader_read_header)(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
static void * heap_calloc(SIZE_T count, SIZE_T size)
Definition: heap.h:49
struct wined3d_shader_resource_info resource_info[MAX_SHADER_RESOURCE_VIEWS]
BOOL(* shader_is_end)(void *data, const DWORD **ptr)
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
#define MAX_REG_INPUT
void(* shader_read_instruction)(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins)
enum wined3d_decl_usage usage
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
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
static unsigned int get_instr_extra_regcount(enum WINED3D_SHADER_INSTRUCTION_HANDLER instr, unsigned int param)
Definition: shader.c:857
GLenum GLint GLuint mask
Definition: glext.h:6028
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define WINED3D_SAMPLER_DEFAULT
unsigned int BOOL
Definition: ntddk_ex.h:94
#define e
Definition: ke_i.h:82
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
unsigned int idx
Definition: utils.c:41
smooth NULL
Definition: ftsmooth.c:416
union wined3d_shader_reg_maps::@264 u
DWORD texcoord_mask[MAX_REG_TEXCRD]
#define MAX_UNORDERED_ACCESS_VIEWS
static void wined3d_insert_interpolation_mode(DWORD *packed_interpolation_mode, unsigned int register_idx, enum wined3d_shader_interpolation_mode mode)
Definition: shader.c:976
#define WINED3DSP_NOSWIZZLE
GLuint shader
Definition: glext.h:6030
BYTE output_registers_mask[MAX_REG_OUTPUT]
GLfloat f
Definition: glext.h:7540
unsigned int instance_count
#define TRACE(s)
Definition: solgame.cpp:4
GLsizei stride
Definition: glext.h:5848
GLsizeiptr size
Definition: glext.h:5919
if(!(yy_init))
Definition: macro.lex.yy.c:714
LONG HRESULT
Definition: typedefs.h:77
int isinf(double x)
#define WINED3D_OK
Definition: wined3d.h:37
enum wined3d_shader_resource_type resource_type
unsigned long DWORD
Definition: ntddk_ex.h:95
#define WINED3DSP_WRITEMASK_1
static void shader_set_limits(struct wined3d_shader *shader)
Definition: shader.c:592
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define WINED3DSP_WRITEMASK_ALL
GLsizei const GLfloat * value
Definition: glext.h:6069
#define ERR(fmt,...)
Definition: debug.h:109
int isnan(double x)
struct wined3d_shader_sampler_map sampler_map
static HRESULT shader_record_shader_phase(struct wined3d_shader *shader, struct wined3d_shader_phase **current_phase, const struct wined3d_shader_instruction *ins, const DWORD *current_instruction_ptr, const DWORD *previous_instruction_ptr)
Definition: shader.c:904
#define ARRAY_SIZE(a)
Definition: main.h:24
UINT cb_sizes[WINED3D_MAX_CBS]
struct wined3d_shader_version shader_version
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50