#include "config.h"
#include "wine/port.h"
#include <limits.h>
#include <stdio.h>
#include "wined3d_private.h"

Include dependency graph for glsl_shader.c:

Go to the source code of this file.

Classes
struct	glsl_dst_param

struct	glsl_src_param

struct	glsl_sample_function

struct	constant_entry

struct	constant_heap

struct	shader_glsl_priv

struct	glsl_vs_program

struct	glsl_hs_program

struct	glsl_ds_program

struct	glsl_gs_program

struct	glsl_ps_program

struct	glsl_cs_program

struct	glsl_shader_prog_link

struct	glsl_program_key

struct	shader_glsl_ctx_priv

struct	glsl_context_data

struct	glsl_ps_compiled_shader

struct	glsl_vs_compiled_shader

struct	glsl_hs_compiled_shader

struct	glsl_ds_compiled_shader

struct	glsl_gs_compiled_shader

struct	glsl_cs_compiled_shader

struct	glsl_shader_private

struct	glsl_ffp_vertex_shader

struct	glsl_ffp_fragment_shader

struct	glsl_ffp_destroy_ctx

Macros
#define	WINED3D_GLSL_SAMPLE_PROJECTED 0x01

#define	WINED3D_GLSL_SAMPLE_LOD 0x02

#define	WINED3D_GLSL_SAMPLE_GRAD 0x04

#define	WINED3D_GLSL_SAMPLE_LOAD 0x08

#define	WINED3D_GLSL_SAMPLE_OFFSET 0x10

#define	WINED3D_TO_STR(u) case u: return #u

Enumerations
enum	heap_node_op { HEAP_NODE_TRAVERSE_LEFT , HEAP_NODE_TRAVERSE_RIGHT , HEAP_NODE_POP }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3d_shader)

	WINE_DECLARE_DEBUG_CHANNEL (d3d)

	WINE_DECLARE_DEBUG_CHANNEL (winediag)

static void	shader_glsl_generate_shader_epilogue (const struct wined3d_shader_context *ctx)

static const char *	debug_gl_shader_type (GLenum type)

static const char *	shader_glsl_get_prefix (enum wined3d_shader_type type)

static unsigned int	shader_glsl_get_version (const struct wined3d_gl_info *gl_info)

static void	shader_glsl_add_version_declaration (struct wined3d_string_buffer buffer, const struct wined3d_gl_info gl_info)

static void	shader_glsl_append_imm_vec4 (struct wined3d_string_buffer buffer, const float values)

static void	shader_glsl_append_imm_ivec (struct wined3d_string_buffer buffer, const int values, unsigned int size)

static const char *	get_info_log_line (const char **ptr)

void	print_glsl_info_log (const struct wined3d_gl_info *gl_info, GLuint id, BOOL program)

static void	shader_glsl_compile (const struct wined3d_gl_info gl_info, GLuint shader, const char src)

static void	shader_glsl_dump_program_source (const struct wined3d_gl_info *gl_info, GLuint program)

void	shader_glsl_validate_link (const struct wined3d_gl_info *gl_info, GLuint program)

static BOOL	shader_glsl_use_layout_qualifier (const struct wined3d_gl_info *gl_info)

static BOOL	shader_glsl_use_layout_binding_qualifier (const struct wined3d_gl_info *gl_info)

static void	shader_glsl_init_uniform_block_bindings (const struct wined3d_gl_info gl_info, struct shader_glsl_priv priv, GLuint program_id, const struct wined3d_shader_reg_maps *reg_maps)

static void	shader_glsl_load_samplers_range (const struct wined3d_gl_info gl_info, struct shader_glsl_priv priv, GLuint program_id, const char prefix, unsigned int base, unsigned int count, const DWORD tex_unit_map)

static unsigned int	shader_glsl_map_tex_unit (const struct wined3d_context context, const struct wined3d_shader_version shader_version, unsigned int sampler_idx)

static void	shader_glsl_append_sampler_binding_qualifier (struct wined3d_string_buffer buffer, const struct wined3d_context context, const struct wined3d_shader_version *shader_version, unsigned int sampler_idx)

static void	shader_glsl_load_samplers (const struct wined3d_context context, struct shader_glsl_priv priv, GLuint program_id, const struct wined3d_shader_reg_maps *reg_maps)

static void	shader_glsl_load_icb (const struct wined3d_gl_info gl_info, struct shader_glsl_priv priv, GLuint program_id, const struct wined3d_shader_reg_maps *reg_maps)

static void	shader_glsl_load_images (const struct wined3d_gl_info gl_info, struct shader_glsl_priv priv, GLuint program_id, const struct wined3d_shader_reg_maps *reg_maps)

static void	shader_glsl_load_program_resources (const struct wined3d_context context, struct shader_glsl_priv priv, GLuint program_id, const struct wined3d_shader *shader)

static void	append_transform_feedback_varying (const char *varyings, unsigned int varying_count, char *strings, unsigned int strings_length, struct wined3d_string_buffer *buffer)

static void	append_transform_feedback_skip_components (const char *varyings, unsigned int varying_count, char *strings, unsigned int strings_length, struct wined3d_string_buffer *buffer, unsigned int component_count)

static void	shader_glsl_generate_transform_feedback_varyings (const struct wined3d_stream_output_desc so_desc, struct wined3d_string_buffer buffer, const char *varyings, unsigned int varying_count, char strings, unsigned int strings_length, GLenum buffer_mode)

static void	shader_glsl_init_transform_feedback (const struct wined3d_context context, struct shader_glsl_priv priv, GLuint program_id, const struct wined3d_shader *shader)

static void	walk_constant_heap (const struct wined3d_gl_info gl_info, const struct wined3d_vec4 constants, const GLint constant_locations, const struct constant_heap heap, unsigned char *stack, DWORD version)

static void	apply_clamped_constant (const struct wined3d_gl_info gl_info, GLint location, const struct wined3d_vec4 data)

static void	walk_constant_heap_clamped (const struct wined3d_gl_info gl_info, const struct wined3d_vec4 constants, const GLint constant_locations, const struct constant_heap heap, unsigned char *stack, DWORD version)

static void	shader_glsl_load_constants_f (const struct wined3d_shader shader, const struct wined3d_gl_info gl_info, const struct wined3d_vec4 constants, const GLint constant_locations, const struct constant_heap heap, unsigned char stack, unsigned int version)

static void	shader_glsl_load_constants_i (const struct wined3d_shader shader, const struct wined3d_gl_info gl_info, const struct wined3d_ivec4 *constants, const GLint locations[WINED3D_MAX_CONSTS_I], WORD constants_set)

static void	shader_glsl_load_constantsB (const struct wined3d_shader shader, const struct wined3d_gl_info gl_info, const GLint locations[WINED3D_MAX_CONSTS_B], const BOOL *constants, WORD constants_set)

static void	reset_program_constant_version (struct wine_rb_entry entry, void context)

static void	shader_glsl_load_np2fixup_constants (const struct glsl_ps_program ps, const struct wined3d_gl_info gl_info, const struct wined3d_state *state)

static void	shader_glsl_ffp_vertex_texmatrix_uniform (const struct wined3d_context context, const struct wined3d_state state, unsigned int tex, struct glsl_shader_prog_link *prog)

static void	shader_glsl_ffp_vertex_material_uniform (const struct wined3d_context context, const struct wined3d_state state, struct glsl_shader_prog_link *prog)

static void	shader_glsl_ffp_vertex_lightambient_uniform (const struct wined3d_context context, const struct wined3d_state state, struct glsl_shader_prog_link *prog)

static void	multiply_vector_matrix (struct wined3d_vec4 dest, const struct wined3d_vec4 src1, const struct wined3d_matrix *src2)

static void	shader_glsl_ffp_vertex_light_uniform (const struct wined3d_context context, const struct wined3d_state state, unsigned int light, const struct wined3d_light_info light_info, struct glsl_shader_prog_link prog)

static void	shader_glsl_pointsize_uniform (const struct wined3d_context context, const struct wined3d_state state, struct glsl_shader_prog_link *prog)

static void	shader_glsl_load_fog_uniform (const struct wined3d_context context, const struct wined3d_state state, struct glsl_shader_prog_link *prog)

static void	shader_glsl_clip_plane_uniform (const struct wined3d_context context, const struct wined3d_state state, unsigned int index, struct glsl_shader_prog_link *prog)

static void	shader_glsl_load_color_key_constant (const struct glsl_ps_program ps, const struct wined3d_gl_info gl_info, const struct wined3d_state *state)

static void	get_normal_matrix (struct wined3d_context context, struct wined3d_matrix mat, float *normal)

static void	shader_glsl_load_constants (void shader_priv, struct wined3d_context context, const struct wined3d_state *state)

static void	update_heap_entry (struct constant_heap *heap, unsigned int idx, DWORD new_version)

static void	shader_glsl_update_float_vertex_constants (struct wined3d_device *device, UINT start, UINT count)

static void	shader_glsl_update_float_pixel_constants (struct wined3d_device *device, UINT start, UINT count)

static unsigned int	vec4_varyings (DWORD shader_major, const struct wined3d_gl_info *gl_info)

static BOOL	needs_legacy_glsl_syntax (const struct wined3d_gl_info *gl_info)

static BOOL	shader_glsl_use_explicit_attrib_location (const struct wined3d_gl_info *gl_info)

static BOOL	shader_glsl_use_interface_blocks (const struct wined3d_gl_info *gl_info)

static const char *	get_attribute_keyword (const struct wined3d_gl_info *gl_info)

static void	PRINTF_ATTR (4, 5)

static const char *	shader_glsl_shader_input_name (const struct wined3d_gl_info *gl_info)

static const char *	shader_glsl_shader_output_name (const struct wined3d_gl_info *gl_info)

static const char *	shader_glsl_interpolation_qualifiers (enum wined3d_shader_interpolation_mode mode)

static enum wined3d_shader_interpolation_mode	wined3d_extract_interpolation_mode (const DWORD *packed_interpolation_mode, unsigned int register_idx)

static void	shader_glsl_declare_shader_inputs (const struct wined3d_gl_info gl_info, struct wined3d_string_buffer buffer, unsigned int element_count, const DWORD *interpolation_mode, BOOL unroll)

static void	shader_glsl_declare_shader_outputs (const struct wined3d_gl_info gl_info, struct wined3d_string_buffer buffer, unsigned int element_count, BOOL rasterizer_setup, const DWORD *interpolation_mode)

static const char *	glsl_primitive_type_from_d3d (enum wined3d_primitive_type primitive_type)

static BOOL	glsl_is_color_reg_read (const struct wined3d_shader *shader, unsigned int idx)

static BOOL	glsl_is_shadow_sampler (const struct wined3d_shader shader, const struct ps_compile_args ps_args, unsigned int resource_idx, unsigned int sampler_idx)

static void	shader_glsl_declare_typed_vertex_attribute (struct wined3d_string_buffer buffer, const struct wined3d_gl_info gl_info, const char vector_type, const char scalar_type, unsigned int index)

static void	shader_glsl_declare_generic_vertex_attribute (struct wined3d_string_buffer buffer, const struct wined3d_gl_info gl_info, const struct wined3d_shader_signature_element *e)

static void	shader_generate_glsl_declarations (const struct wined3d_context context, struct wined3d_string_buffer buffer, const struct wined3d_shader shader, const struct wined3d_shader_reg_maps reg_maps, const struct shader_glsl_ctx_priv *ctx_priv)

static void	shader_glsl_add_src_param (const struct wined3d_shader_instruction ins, const struct wined3d_shader_src_param wined3d_src, DWORD mask, struct glsl_src_param *glsl_src)

static void	shader_glsl_gen_modifier (enum wined3d_shader_src_modifier src_modifier, const char in_reg, const char in_regswizzle, char *out_str)

static void	shader_glsl_fixup_scalar_register_variable (char register_name, const char glsl_variable, const struct wined3d_gl_info *gl_info)

static void	shader_glsl_get_register_name (const struct wined3d_shader_register reg, enum wined3d_data_type data_type, char register_name, BOOL is_color, const struct wined3d_shader_instruction ins)

static void	shader_glsl_write_mask_to_str (DWORD write_mask, char *str)

static DWORD	shader_glsl_get_write_mask (const struct wined3d_shader_dst_param param, char write_mask)

static unsigned int	shader_glsl_get_write_mask_size (DWORD write_mask)

static unsigned int	shader_glsl_swizzle_get_component (DWORD swizzle, unsigned int component_idx)

static void	shader_glsl_swizzle_to_str (DWORD swizzle, BOOL fixup, DWORD mask, char *str)

static void	shader_glsl_get_swizzle (const struct wined3d_shader_src_param param, BOOL fixup, DWORD mask, char swizzle_str)

static void	shader_glsl_sprintf_cast (struct wined3d_string_buffer dst_param, const char src_param, enum wined3d_data_type dst_data_type, enum wined3d_data_type src_data_type)

static void	shader_glsl_add_src_param_ext (const struct wined3d_shader_instruction ins, const struct wined3d_shader_src_param wined3d_src, DWORD mask, struct glsl_src_param *glsl_src, enum wined3d_data_type data_type)

static DWORD	shader_glsl_add_dst_param (const struct wined3d_shader_instruction ins, const struct wined3d_shader_dst_param wined3d_dst, struct glsl_dst_param *glsl_dst)

static DWORD	shader_glsl_append_dst_ext (struct wined3d_string_buffer buffer, const struct wined3d_shader_instruction ins, const struct wined3d_shader_dst_param *dst, enum wined3d_data_type data_type)

static DWORD	shader_glsl_append_dst (struct wined3d_string_buffer buffer, const struct wined3d_shader_instruction ins)

static void	shader_glsl_add_instruction_modifiers (const struct wined3d_shader_instruction *ins)

static const char *	shader_glsl_get_rel_op (enum wined3d_shader_rel_op op)

static BOOL	shader_glsl_has_core_grad (const struct wined3d_gl_info *gl_info)

static void	shader_glsl_get_coord_size (enum wined3d_shader_resource_type resource_type, unsigned int coord_size, unsigned int deriv_size)

static void	shader_glsl_get_sample_function (const struct wined3d_shader_context ctx, DWORD resource_idx, DWORD sampler_idx, DWORD flags, struct glsl_sample_function sample_function)

static void	shader_glsl_release_sample_function (const struct wined3d_shader_context ctx, struct glsl_sample_function sample_function)

static void	shader_glsl_append_fixup_arg (char arguments, const char reg_name, BOOL sign_fixup, enum fixup_channel_source channel_source)

static void	shader_glsl_color_correction_ext (struct wined3d_string_buffer buffer, const char reg_name, DWORD mask, struct color_fixup_desc fixup)

static void	shader_glsl_color_correction (const struct wined3d_shader_instruction *ins, struct color_fixup_desc fixup)

static void	PRINTF_ATTR (9, 10)

static void	shader_glsl_fixup_position (struct wined3d_string_buffer *buffer)

static void	shader_glsl_binop (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_relop (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_unary_op (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_mul_extended (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_udiv (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_mov (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_dot (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_cross (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_cut (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_pow (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_map2gl (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_float16 (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_bitwise_op (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_nop (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_nrm (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_scalar_op (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_expp (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_cast (const struct wined3d_shader_instruction ins, const char vector_constructor, const char *scalar_constructor)

static void	shader_glsl_to_int (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_to_uint (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_to_float (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_compare (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_swapc (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_conditional_move (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_cnd (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_mad (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_mnxn (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_lrp (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_lit (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_dst (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_sincos (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_sgn (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_loop (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_end (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_rep (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_switch (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_case (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_default (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_generate_conditional_op (const struct wined3d_shader_instruction ins, const char op)

static void	shader_glsl_if (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_ifc (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_else (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_emit (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_break (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_breakc (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_conditional_op (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_continue (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_label (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_call (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_callnz (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_ret (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_tex (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texldd (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texldl (const struct wined3d_shader_instruction *ins)

static unsigned int	shader_glsl_find_sampler (const struct wined3d_shader_sampler_map *sampler_map, unsigned int resource_idx, unsigned int sampler_idx)

static void	shader_glsl_atomic (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_uav_counter (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_ld_uav (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_ld_raw_structured (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_store_uav (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_store_raw_structured (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_sync (const struct wined3d_shader_instruction *ins)

static const struct wined3d_shader_resource_info *	shader_glsl_get_resource_info (const struct wined3d_shader_instruction ins, const struct wined3d_shader_register reg)

static void	shader_glsl_bufinfo (const struct wined3d_shader_instruction *ins)

static BOOL	is_multisampled (enum wined3d_shader_resource_type resource_type)

static BOOL	is_mipmapped (enum wined3d_shader_resource_type resource_type)

static void	shader_glsl_resinfo (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_ld (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_sample (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_gen_sample_c_lz (const struct wined3d_shader_instruction ins, unsigned int sampler_bind_idx, const struct glsl_sample_function sample_function, unsigned int coord_size, const char coord_param, const char ref_param)

static void	shader_glsl_sample_c (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_gather4 (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texcoord (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texdp3tex (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texdp3 (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texdepth (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texm3x2depth (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texm3x2pad (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texm3x3pad (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texm3x2tex (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texm3x3tex (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texm3x3 (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texm3x3spec (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texm3x3vspec (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texbem (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_bem (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texreg2ar (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texreg2gb (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texreg2rgb (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_texkill (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_dp2add (const struct wined3d_shader_instruction *ins)

static void	shader_glsl_input_pack (const struct wined3d_shader shader, struct wined3d_string_buffer buffer, const struct wined3d_shader_signature input_signature, const struct wined3d_shader_reg_maps reg_maps, const struct ps_compile_args args, const struct wined3d_gl_info gl_info, BOOL unroll)

static void	add_glsl_program_entry (struct shader_glsl_priv priv, struct glsl_shader_prog_link entry)

static struct glsl_shader_prog_link *	get_glsl_program_entry (const struct shader_glsl_priv priv, const struct glsl_program_key key)

static void	delete_glsl_program_entry (struct shader_glsl_priv priv, const struct wined3d_gl_info gl_info, struct glsl_shader_prog_link *entry)

static void	shader_glsl_setup_vs3_output (struct shader_glsl_priv priv, const struct wined3d_gl_info gl_info, const DWORD map, const struct wined3d_shader_signature input_signature, const struct wined3d_shader_reg_maps reg_maps_in, const struct wined3d_shader_signature output_signature, const struct wined3d_shader_reg_maps *reg_maps_out)

static void	shader_glsl_setup_sm4_shader_output (struct shader_glsl_priv priv, unsigned int input_count, const struct wined3d_shader_signature output_signature, const struct wined3d_shader_reg_maps reg_maps_out, const char output_variable_name, BOOL rasterizer_setup)

static void	shader_glsl_generate_clip_or_cull_distances (struct wined3d_string_buffer buffer, const struct wined3d_shader_signature_element element, DWORD clip_or_cull_distance_mask)

static void	shader_glsl_setup_sm3_rasterizer_input (struct shader_glsl_priv priv, const struct wined3d_gl_info gl_info, const DWORD map, const struct wined3d_shader_signature input_signature, const struct wined3d_shader_reg_maps reg_maps_in, unsigned int input_count, const struct wined3d_shader_signature output_signature, const struct wined3d_shader_reg_maps *reg_maps_out, BOOL per_vertex_point_size)

static GLuint	shader_glsl_generate_vs3_rasterizer_input_setup (struct shader_glsl_priv priv, const struct wined3d_shader vs, const struct wined3d_shader ps, BOOL per_vertex_point_size, BOOL flatshading, const struct wined3d_gl_info gl_info)

static void	shader_glsl_generate_stream_output_setup (struct shader_glsl_priv priv, const struct wined3d_shader shader, const struct wined3d_stream_output_desc *so_desc)

static void	shader_glsl_generate_sm4_output_setup (struct shader_glsl_priv priv, const struct wined3d_shader shader, unsigned int input_count, const struct wined3d_gl_info gl_info, BOOL rasterizer_setup, const DWORD interpolation_mode)

static void	shader_glsl_generate_patch_constant_name (struct wined3d_string_buffer buffer, const struct wined3d_shader_signature_element constant, unsigned int user_constant_idx, const char reg_mask)

static void	shader_glsl_generate_patch_constant_setup (struct wined3d_string_buffer buffer, const struct wined3d_shader_signature signature, BOOL input_setup)

static void	shader_glsl_generate_srgb_write_correction (struct wined3d_string_buffer buffer, const struct wined3d_gl_info gl_info)

static void	shader_glsl_generate_fog_code (struct wined3d_string_buffer buffer, const struct wined3d_gl_info gl_info, enum wined3d_ffp_ps_fog_mode mode)

static void	shader_glsl_generate_alpha_test (struct wined3d_string_buffer buffer, const struct wined3d_gl_info gl_info, enum wined3d_cmp_func alpha_func)

static void	shader_glsl_enable_extensions (struct wined3d_string_buffer buffer, const struct wined3d_gl_info gl_info)

static void	shader_glsl_generate_ps_epilogue (const struct wined3d_gl_info gl_info, struct wined3d_string_buffer buffer, const struct wined3d_shader shader, const struct ps_compile_args args)

static GLuint	shader_glsl_generate_pshader (const struct wined3d_context context, struct wined3d_string_buffer buffer, struct wined3d_string_buffer_list string_buffers, const struct wined3d_shader shader, const struct ps_compile_args args, struct ps_np2fixup_info np2fixup_info)

static void	shader_glsl_generate_vs_epilogue (const struct wined3d_gl_info gl_info, struct wined3d_string_buffer buffer, const struct wined3d_shader shader, const struct vs_compile_args args)

static GLuint	shader_glsl_generate_vshader (const struct wined3d_context context, struct shader_glsl_priv priv, const struct wined3d_shader shader, const struct vs_compile_args args)

static void	shader_glsl_generate_default_control_point_phase (const struct wined3d_shader shader, struct wined3d_string_buffer buffer, const struct wined3d_shader_reg_maps *reg_maps)

static HRESULT	shader_glsl_generate_shader_phase (const struct wined3d_shader shader, struct wined3d_string_buffer buffer, const struct wined3d_shader_reg_maps reg_maps, struct shader_glsl_ctx_priv priv_ctx, const struct wined3d_shader_phase phase, const char phase_name, unsigned phase_idx)

static void	shader_glsl_generate_shader_phase_invocation (struct wined3d_string_buffer buffer, const struct wined3d_shader_phase phase, const char *phase_name, unsigned int phase_idx)

static GLuint	shader_glsl_generate_hull_shader (const struct wined3d_context context, struct shader_glsl_priv priv, const struct wined3d_shader *shader)

static void	shader_glsl_generate_ds_epilogue (const struct wined3d_gl_info gl_info, struct wined3d_string_buffer buffer, const struct wined3d_shader shader, const struct ds_compile_args args)

static GLuint	shader_glsl_generate_domain_shader (const struct wined3d_context context, struct shader_glsl_priv priv, const struct wined3d_shader shader, const struct ds_compile_args args)

static GLuint	shader_glsl_generate_geometry_shader (const struct wined3d_context context, struct shader_glsl_priv priv, const struct wined3d_shader shader, const struct gs_compile_args args)

static GLuint	shader_glsl_generate_compute_shader (const struct wined3d_context context, struct wined3d_string_buffer buffer, struct wined3d_string_buffer_list string_buffers, const struct wined3d_shader shader)

static GLuint	find_glsl_pshader (const struct wined3d_context context, struct wined3d_string_buffer buffer, struct wined3d_string_buffer_list string_buffers, struct wined3d_shader shader, const struct ps_compile_args args, const struct ps_np2fixup_info *np2fixup_info)

static BOOL	vs_args_equal (const struct vs_compile_args stored, const struct vs_compile_args new, const DWORD use_map)

static GLuint	find_glsl_vshader (const struct wined3d_context context, struct shader_glsl_priv priv, struct wined3d_shader shader, const struct vs_compile_args args)

static GLuint	find_glsl_hull_shader (const struct wined3d_context context, struct shader_glsl_priv priv, struct wined3d_shader *shader)

static GLuint	find_glsl_domain_shader (const struct wined3d_context context, struct shader_glsl_priv priv, struct wined3d_shader shader, const struct ds_compile_args args)

static GLuint	find_glsl_geometry_shader (const struct wined3d_context context, struct shader_glsl_priv priv, struct wined3d_shader shader, const struct gs_compile_args args)

static const char *	shader_glsl_ffp_mcs (enum wined3d_material_color_source mcs, const char *material)

static void	shader_glsl_ffp_vertex_lighting_footer (struct wined3d_string_buffer buffer, const struct wined3d_ffp_vs_settings settings, unsigned int idx)

static void	shader_glsl_ffp_vertex_lighting (struct wined3d_string_buffer buffer, const struct wined3d_ffp_vs_settings settings, BOOL legacy_lighting)

static GLuint	shader_glsl_generate_ffp_vertex_shader (struct shader_glsl_priv priv, const struct wined3d_ffp_vs_settings settings, const struct wined3d_gl_info *gl_info)

static const char *	shader_glsl_get_ffp_fragment_op_arg (struct wined3d_string_buffer *buffer, DWORD argnum, unsigned int stage, DWORD arg)

static void	shader_glsl_ffp_fragment_op (struct wined3d_string_buffer *buffer, unsigned int stage, BOOL color, BOOL alpha, DWORD dst, DWORD op, DWORD dw_arg0, DWORD dw_arg1, DWORD dw_arg2)

static GLuint	shader_glsl_generate_ffp_fragment_shader (struct shader_glsl_priv priv, const struct ffp_frag_settings settings, const struct wined3d_context *context)

static struct glsl_ffp_vertex_shader *	shader_glsl_find_ffp_vertex_shader (struct shader_glsl_priv priv, const struct wined3d_gl_info gl_info, const struct wined3d_ffp_vs_settings *settings)

static struct glsl_ffp_fragment_shader *	shader_glsl_find_ffp_fragment_shader (struct shader_glsl_priv priv, const struct ffp_frag_settings args, const struct wined3d_context *context)

static void	shader_glsl_init_vs_uniform_locations (const struct wined3d_gl_info gl_info, struct shader_glsl_priv priv, GLuint program_id, struct glsl_vs_program *vs, unsigned int vs_c_count)

static void	shader_glsl_init_ds_uniform_locations (const struct wined3d_gl_info gl_info, struct shader_glsl_priv priv, GLuint program_id, struct glsl_ds_program *ds)

static void	shader_glsl_init_gs_uniform_locations (const struct wined3d_gl_info gl_info, struct shader_glsl_priv priv, GLuint program_id, struct glsl_gs_program *gs)

static void	shader_glsl_init_ps_uniform_locations (const struct wined3d_gl_info gl_info, struct shader_glsl_priv priv, GLuint program_id, struct glsl_ps_program *ps, unsigned int ps_c_count)

static HRESULT	shader_glsl_compile_compute_shader (struct shader_glsl_priv priv, const struct wined3d_context context, struct wined3d_shader *shader)

static GLuint	find_glsl_compute_shader (const struct wined3d_context context, struct shader_glsl_priv priv, struct wined3d_shader *shader)

static void	set_glsl_compute_shader_program (const struct wined3d_context context, const struct wined3d_state state, struct shader_glsl_priv priv, struct glsl_context_data ctx_data)

static void	set_glsl_shader_program (const struct wined3d_context context, const struct wined3d_state state, struct shader_glsl_priv priv, struct glsl_context_data ctx_data)

static void	shader_glsl_precompile (void shader_priv, struct wined3d_shader shader)

static void	shader_glsl_select (void shader_priv, struct wined3d_context context, const struct wined3d_state *state)

static void	shader_glsl_select_compute (void shader_priv, struct wined3d_context context, const struct wined3d_state *state)

static void	shader_glsl_invalidate_current_program (struct wined3d_context *context)

static void	shader_glsl_disable (void shader_priv, struct wined3d_context context)

static void	shader_glsl_invalidate_contexts_program (struct wined3d_device device, const struct glsl_shader_prog_link program)

static void	shader_glsl_destroy (struct wined3d_shader *shader)

static int	glsl_program_key_compare (const void key, const struct wine_rb_entry entry)

static BOOL	constant_heap_init (struct constant_heap *heap, unsigned int constant_count)

static void	constant_heap_free (struct constant_heap *heap)

static HRESULT	shader_glsl_alloc (struct wined3d_device device, const struct wined3d_vertex_pipe_ops vertex_pipe, const struct fragment_pipeline *fragment_pipe)

static void	shader_glsl_free (struct wined3d_device *device)

static BOOL	shader_glsl_allocate_context_data (struct wined3d_context *context)

static void	shader_glsl_free_context_data (struct wined3d_context *context)

static void	shader_glsl_init_context_state (struct wined3d_context *context)

static unsigned int	shader_glsl_get_shader_model (const struct wined3d_gl_info *gl_info)

static void	shader_glsl_get_caps (const struct wined3d_gl_info gl_info, struct shader_caps caps)

static BOOL	shader_glsl_color_fixup_supported (struct color_fixup_desc fixup)

static void	shader_glsl_handle_instruction (const struct wined3d_shader_instruction *ins)

static BOOL	shader_glsl_has_ffp_proj_control (void *shader_priv)

static void	glsl_vertex_pipe_vp_enable (const struct wined3d_gl_info *gl_info, BOOL enable)

static void	glsl_vertex_pipe_vp_get_caps (const struct wined3d_gl_info gl_info, struct wined3d_vertex_caps caps)

static DWORD	glsl_vertex_pipe_vp_get_emul_mask (const struct wined3d_gl_info *gl_info)

static void *	glsl_vertex_pipe_vp_alloc (const struct wined3d_shader_backend_ops shader_backend, void shader_priv)

static void	shader_glsl_free_ffp_vertex_shader (struct wine_rb_entry entry, void context)

static void	glsl_vertex_pipe_vp_free (struct wined3d_device *device)

static void	glsl_vertex_pipe_nop (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_shader (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_vdecl (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_vs (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_hs (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_geometry_shader (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_pixel_shader (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_world (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_vertexblend (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_view (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_projection (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_viewport (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_texmatrix (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_texmatrix_np2 (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_material (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_light (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_pointsize (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_pointscale (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pointsprite_core (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_shademode (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_vertex_pipe_clip_plane (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_enable (const struct wined3d_gl_info *gl_info, BOOL enable)

static void	glsl_fragment_pipe_get_caps (const struct wined3d_gl_info gl_info, struct fragment_caps caps)

static DWORD	glsl_fragment_pipe_get_emul_mask (const struct wined3d_gl_info *gl_info)

static void *	glsl_fragment_pipe_alloc (const struct wined3d_shader_backend_ops shader_backend, void shader_priv)

static void	shader_glsl_free_ffp_fragment_shader (struct wine_rb_entry entry, void context)

static void	glsl_fragment_pipe_free (struct wined3d_device *device)

static void	glsl_fragment_pipe_shader (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_fogparams (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_fog (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_vdecl (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_vs (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_tex_transform (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_invalidate_constants (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_alpha_test_func (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_core_alpha_test (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_alpha_test (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_core_alpha_test_ref (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_color_key (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static void	glsl_fragment_pipe_shademode (struct wined3d_context context, const struct wined3d_state state, DWORD state_id)

static BOOL	glsl_fragment_pipe_alloc_context_data (struct wined3d_context *context)

static void	glsl_fragment_pipe_free_context_data (struct wined3d_context *context)

Variables
struct {
unsigned int coord_size

unsigned int resinfo_size

const char * type_part

}	resource_type_info []

static const char *const	shift_glsl_tab []

static const SHADER_HANDLER	shader_glsl_instruction_handler_table [WINED3DSIH_TABLE_SIZE]

const struct wined3d_shader_backend_ops	glsl_shader_backend

static const struct StateEntryTemplate	glsl_vertex_pipe_vp_states []

const struct wined3d_vertex_pipe_ops	glsl_vertex_pipe

static const struct StateEntryTemplate	glsl_fragment_pipe_state_template []

const struct fragment_pipeline	glsl_fragment_pipe

Macro Definition Documentation

◆ WINED3D_GLSL_SAMPLE_GRAD

#define WINED3D_GLSL_SAMPLE_GRAD 0x04

Definition at line 49 of file glsl_shader.c.

◆ WINED3D_GLSL_SAMPLE_LOAD

#define WINED3D_GLSL_SAMPLE_LOAD 0x08

Definition at line 50 of file glsl_shader.c.

◆ WINED3D_GLSL_SAMPLE_LOD

#define WINED3D_GLSL_SAMPLE_LOD 0x02

Definition at line 48 of file glsl_shader.c.

◆ WINED3D_GLSL_SAMPLE_OFFSET

#define WINED3D_GLSL_SAMPLE_OFFSET 0x10

Definition at line 51 of file glsl_shader.c.

◆ WINED3D_GLSL_SAMPLE_PROJECTED

#define WINED3D_GLSL_SAMPLE_PROJECTED 0x01

Definition at line 47 of file glsl_shader.c.

◆ WINED3D_TO_STR

#define WINED3D_TO_STR ( u ) case u: return #u

Enumeration Type Documentation

◆ heap_node_op

enum heap_node_op

Enumerator
HEAP_NODE_TRAVERSE_LEFT
HEAP_NODE_TRAVERSE_RIGHT
HEAP_NODE_POP

Definition at line 97 of file glsl_shader.c.

{
    HEAP_NODE_TRAVERSE_LEFT,
    HEAP_NODE_TRAVERSE_RIGHT,
    HEAP_NODE_POP,
};

Function Documentation

◆ add_glsl_program_entry()

static void add_glsl_program_entry	(	struct shader_glsl_priv *	priv,
		struct glsl_shader_prog_link *	entry
	)

static

Definition at line 6569 of file glsl_shader.c.

{
    struct glsl_program_key key;
 
    key.vs_id = entry->vs.id;
    key.hs_id = entry->hs.id;
    key.ds_id = entry->ds.id;
    key.gs_id = entry->gs.id;
    key.ps_id = entry->ps.id;
    key.cs_id = entry->cs.id;
 
    if (wine_rb_put(&priv->program_lookup, &key, &entry->program_lookup_entry) == -1)
    {
        ERR("Failed to insert program entry.\n");
    }
}

Referenced by set_glsl_shader_program(), and shader_glsl_compile_compute_shader().

◆ append_transform_feedback_skip_components()

static void append_transform_feedback_skip_components	(	const char **	varyings,
		unsigned int *	varying_count,
		char **	strings,
		unsigned int *	strings_length,
		struct wined3d_string_buffer *	buffer,
		unsigned int	component_count
	)

static

Definition at line 790 of file glsl_shader.c.

{
    unsigned int j;
 
    for (j = 0; j < component_count / 4; ++j)
    {
        string_buffer_sprintf(buffer, "gl_SkipComponents4");
        append_transform_feedback_varying(varyings, varying_count, strings, strings_length, buffer);
    }
    if (component_count % 4)
    {
        string_buffer_sprintf(buffer, "gl_SkipComponents%u", component_count % 4);
        append_transform_feedback_varying(varyings, varying_count, strings, strings_length, buffer);
    }
}

Referenced by shader_glsl_generate_transform_feedback_varyings().

◆ append_transform_feedback_varying()

static void append_transform_feedback_varying	(	const char **	varyings,
		unsigned int *	varying_count,
		char **	strings,
		unsigned int *	strings_length,
		struct wined3d_string_buffer *	buffer
	)

static

Definition at line 771 of file glsl_shader.c.

{
    if (varyings && *strings)
    {
        char *ptr = *strings;
 
        varyings[*varying_count] = ptr;
 
        memcpy(ptr, buffer->buffer, buffer->content_size + 1);
        ptr += buffer->content_size + 1;
 
        *strings = ptr;
    }
 
    *strings_length += buffer->content_size + 1;
    ++(*varying_count);
}

Referenced by append_transform_feedback_skip_components(), and shader_glsl_generate_transform_feedback_varyings().

◆ apply_clamped_constant()

static void apply_clamped_constant	(	const struct wined3d_gl_info *	gl_info,
		GLint	location,
		const struct wined3d_vec4 *	data
	)

inlinestatic

Definition at line 1045 of file glsl_shader.c.

{
    GLfloat clamped_constant[4];
 
    if (location == -1) return;
 
    clamped_constant[0] = data->x < -1.0f ? -1.0f : data->x > 1.0f ? 1.0f : data->x;
    clamped_constant[1] = data->y < -1.0f ? -1.0f : data->y > 1.0f ? 1.0f : data->y;
    clamped_constant[2] = data->z < -1.0f ? -1.0f : data->z > 1.0f ? 1.0f : data->z;
    clamped_constant[3] = data->w < -1.0f ? -1.0f : data->w > 1.0f ? 1.0f : data->w;
 
    GL_EXTCALL(glUniform4fv(location, 1, clamped_constant));
}

Referenced by walk_constant_heap_clamped().

◆ constant_heap_free()

static void constant_heap_free ( struct constant_heap * heap )

static

Definition at line 10634 of file glsl_shader.c.

{
    heap_free(heap->entries);
}

Referenced by shader_glsl_alloc(), and shader_glsl_free().

◆ constant_heap_init()

static BOOL constant_heap_init	(	struct constant_heap *	heap,
		unsigned int	constant_count
	)

static

Definition at line 10611 of file glsl_shader.c.

{
    SIZE_T size = (constant_count + 1) * sizeof(*heap->entries)
            + constant_count * sizeof(*heap->contained)
            + constant_count * sizeof(*heap->positions);
    void *mem;
 
    if (!(mem = heap_alloc(size)))
    {
        ERR("Failed to allocate memory\n");
        return FALSE;
    }
 
    heap->entries = mem;
    heap->entries[1].version = 0;
    heap->contained = (BOOL *)(heap->entries + constant_count + 1);
    memset(heap->contained, 0, constant_count * sizeof(*heap->contained));
    heap->positions = (unsigned int *)(heap->contained + constant_count);
    heap->size = 1;
 
    return TRUE;
}

Referenced by shader_glsl_alloc().

◆ debug_gl_shader_type()

static const char * debug_gl_shader_type ( GLenum type )

static

Definition at line 347 of file glsl_shader.c.

{
    switch (type)
    {
#define WINED3D_TO_STR(u) case u: return #u
        WINED3D_TO_STR(GL_VERTEX_SHADER);
        WINED3D_TO_STR(GL_TESS_CONTROL_SHADER);
        WINED3D_TO_STR(GL_TESS_EVALUATION_SHADER);
        WINED3D_TO_STR(GL_GEOMETRY_SHADER);
        WINED3D_TO_STR(GL_FRAGMENT_SHADER);
        WINED3D_TO_STR(GL_COMPUTE_SHADER);
#undef WINED3D_TO_STR
        default:
            return wine_dbg_sprintf("UNKNOWN(%#x)", type);
    }
}

Referenced by shader_glsl_dump_program_source().

◆ delete_glsl_program_entry()

static void delete_glsl_program_entry	(	struct shader_glsl_priv *	priv,
		const struct wined3d_gl_info *	gl_info,
		struct glsl_shader_prog_link *	entry
	)

static

Definition at line 6596 of file glsl_shader.c.

{
    wine_rb_remove(&priv->program_lookup, &entry->program_lookup_entry);
 
    GL_EXTCALL(glDeleteProgram(entry->id));
    if (entry->vs.id)
        list_remove(&entry->vs.shader_entry);
    if (entry->hs.id)
        list_remove(&entry->hs.shader_entry);
    if (entry->ds.id)
        list_remove(&entry->ds.shader_entry);
    if (entry->gs.id)
        list_remove(&entry->gs.shader_entry);
    if (entry->ps.id)
        list_remove(&entry->ps.shader_entry);
    if (entry->cs.id)
        list_remove(&entry->cs.shader_entry);
    heap_free(entry);
}

Referenced by shader_glsl_destroy(), shader_glsl_free_ffp_fragment_shader(), and shader_glsl_free_ffp_vertex_shader().

◆ find_glsl_compute_shader()

static GLuint find_glsl_compute_shader	(	const struct wined3d_context *	context,
		struct shader_glsl_priv *	priv,
		struct wined3d_shader *	shader
	)

static

Definition at line 9778 of file glsl_shader.c.

{
    struct glsl_shader_private *shader_data;
 
    if (!shader->backend_data)
    {
        WARN("Failed to find GLSL program for compute shader %p.\n", shader);
        if (FAILED(shader_glsl_compile_compute_shader(priv, context, shader)))
        {
            ERR("Failed to compile compute shader %p.\n", shader);
            return 0;
        }
    }
    shader_data = shader->backend_data;
    return shader_data->gl_shaders.cs[0].id;
}

Referenced by set_glsl_compute_shader_program().

◆ find_glsl_domain_shader()

static GLuint find_glsl_domain_shader	(	const struct wined3d_context *	context,
		struct shader_glsl_priv *	priv,
		struct wined3d_shader *	shader,
		const struct ds_compile_args *	args
	)

static

Definition at line 8264 of file glsl_shader.c.

{
    struct glsl_ds_compiled_shader *gl_shaders, *new_array;
    struct glsl_shader_private *shader_data;
    unsigned int i, new_size;
    GLuint ret;
 
    if (!shader->backend_data)
    {
        if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
        {
            ERR("Failed to allocate backend data.\n");
            return 0;
        }
    }
    shader_data = shader->backend_data;
    gl_shaders = shader_data->gl_shaders.ds;
 
    for (i = 0; i < shader_data->num_gl_shaders; ++i)
    {
        if (!memcmp(&gl_shaders[i].args, args, sizeof(*args)))
            return gl_shaders[i].id;
    }
 
    TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
 
    if (shader_data->num_gl_shaders)
    {
        new_size = shader_data->shader_array_size + 1;
        new_array = heap_realloc(shader_data->gl_shaders.ds, new_size * sizeof(*new_array));
    }
    else
    {
        new_array = heap_alloc(sizeof(*new_array));
        new_size = 1;
    }
 
    if (!new_array)
    {
        ERR("Failed to allocate GL shaders array.\n");
        return 0;
    }
    shader_data->gl_shaders.ds = new_array;
    shader_data->shader_array_size = new_size;
    gl_shaders = new_array;
 
    string_buffer_clear(&priv->shader_buffer);
    ret = shader_glsl_generate_domain_shader(context, priv, shader, args);
    gl_shaders[shader_data->num_gl_shaders].args = *args;
    gl_shaders[shader_data->num_gl_shaders++].id = ret;
 
    return ret;
}

Referenced by set_glsl_shader_program().

◆ find_glsl_geometry_shader()

static GLuint find_glsl_geometry_shader	(	const struct wined3d_context *	context,
		struct shader_glsl_priv *	priv,
		struct wined3d_shader *	shader,
		const struct gs_compile_args *	args
	)

static

Definition at line 8319 of file glsl_shader.c.

{
    struct glsl_gs_compiled_shader *gl_shaders, *new_array;
    struct glsl_shader_private *shader_data;
    unsigned int i, new_size;
    GLuint ret;
 
    if (!shader->backend_data)
    {
        if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
        {
            ERR("Failed to allocate backend data.\n");
            return 0;
        }
    }
    shader_data = shader->backend_data;
    gl_shaders = shader_data->gl_shaders.gs;
 
    for (i = 0; i < shader_data->num_gl_shaders; ++i)
    {
        if (!memcmp(&gl_shaders[i].args, args, sizeof(*args)))
            return gl_shaders[i].id;
    }
 
    TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
 
    if (shader_data->num_gl_shaders)
    {
        new_size = shader_data->shader_array_size + 1;
        new_array = heap_realloc(shader_data->gl_shaders.gs, new_size * sizeof(*new_array));
    }
    else
    {
        new_array = heap_alloc(sizeof(*new_array));
        new_size = 1;
    }
 
    if (!new_array)
    {
        ERR("Failed to allocate GL shaders array.\n");
        return 0;
    }
    shader_data->gl_shaders.gs = new_array;
    shader_data->shader_array_size = new_size;
    gl_shaders = new_array;
 
    string_buffer_clear(&priv->shader_buffer);
    ret = shader_glsl_generate_geometry_shader(context, priv, shader, args);
    gl_shaders[shader_data->num_gl_shaders].args = *args;
    gl_shaders[shader_data->num_gl_shaders++].id = ret;
 
    return ret;
}

Referenced by set_glsl_shader_program().

◆ find_glsl_hull_shader()

static GLuint find_glsl_hull_shader	(	const struct wined3d_context *	context,
		struct shader_glsl_priv *	priv,
		struct wined3d_shader *	shader
	)

static

Definition at line 8219 of file glsl_shader.c.

{
    struct glsl_hs_compiled_shader *gl_shaders, *new_array;
    struct glsl_shader_private *shader_data;
    unsigned int new_size;
    GLuint ret;
 
    if (!shader->backend_data)
    {
        if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
        {
            ERR("Failed to allocate backend data.\n");
            return 0;
        }
    }
    shader_data = shader->backend_data;
    gl_shaders = shader_data->gl_shaders.hs;
 
    if (shader_data->num_gl_shaders > 0)
    {
        assert(shader_data->num_gl_shaders == 1);
        return gl_shaders[0].id;
    }
 
    TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
 
    assert(!shader_data->gl_shaders.hs);
    new_size = 1;
    if (!(new_array = heap_alloc(sizeof(*new_array))))
    {
        ERR("Failed to allocate GL shaders array.\n");
        return 0;
    }
    shader_data->gl_shaders.hs = new_array;
    shader_data->shader_array_size = new_size;
    gl_shaders = new_array;
 
    string_buffer_clear(&priv->shader_buffer);
    ret = shader_glsl_generate_hull_shader(context, priv, shader);
    gl_shaders[shader_data->num_gl_shaders++].id = ret;
 
    return ret;
}

Referenced by set_glsl_shader_program().

◆ find_glsl_pshader()

static GLuint find_glsl_pshader	(	const struct wined3d_context *	context,
		struct wined3d_string_buffer *	buffer,
		struct wined3d_string_buffer_list *	string_buffers,
		struct wined3d_shader *	shader,
		const struct ps_compile_args *	args,
		const struct ps_np2fixup_info **	np2fixup_info
	)

static

Definition at line 8062 of file glsl_shader.c.

{
    struct glsl_ps_compiled_shader *gl_shaders, *new_array;
    struct glsl_shader_private *shader_data;
    struct ps_np2fixup_info *np2fixup;
    UINT i;
    DWORD new_size;
    GLuint ret;
 
    if (!shader->backend_data)
    {
        if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
        {
            ERR("Failed to allocate backend data.\n");
            return 0;
        }
    }
    shader_data = shader->backend_data;
    gl_shaders = shader_data->gl_shaders.ps;
 
    /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
     * so a linear search is more performant than a hashmap or a binary search
     * (cache coherency etc)
     */
    for (i = 0; i < shader_data->num_gl_shaders; ++i)
    {
        if (!memcmp(&gl_shaders[i].args, args, sizeof(*args)))
        {
            if (args->np2_fixup)
                *np2fixup_info = &gl_shaders[i].np2fixup;
            return gl_shaders[i].id;
        }
    }
 
    TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
    if (shader_data->shader_array_size == shader_data->num_gl_shaders)
    {
        if (shader_data->num_gl_shaders)
        {
            new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
            new_array = heap_realloc(shader_data->gl_shaders.ps, new_size * sizeof(*gl_shaders));
        }
        else
        {
            new_array = heap_alloc(sizeof(*gl_shaders));
            new_size = 1;
        }
 
        if(!new_array) {
            ERR("Out of memory\n");
            return 0;
        }
        shader_data->gl_shaders.ps = new_array;
        shader_data->shader_array_size = new_size;
        gl_shaders = new_array;
    }
 
    gl_shaders[shader_data->num_gl_shaders].args = *args;
 
    np2fixup = &gl_shaders[shader_data->num_gl_shaders].np2fixup;
    memset(np2fixup, 0, sizeof(*np2fixup));
    *np2fixup_info = args->np2_fixup ? np2fixup : NULL;
 
    pixelshader_update_resource_types(shader, args->tex_types);
 
    string_buffer_clear(buffer);
    ret = shader_glsl_generate_pshader(context, buffer, string_buffers, shader, args, np2fixup);
    gl_shaders[shader_data->num_gl_shaders++].id = ret;
 
    return ret;
}

Referenced by set_glsl_shader_program().

◆ find_glsl_vshader()

static GLuint find_glsl_vshader	(	const struct wined3d_context *	context,
		struct shader_glsl_priv *	priv,
		struct wined3d_shader *	shader,
		const struct vs_compile_args *	args
	)

static

Definition at line 8155 of file glsl_shader.c.

{
    UINT i;
    DWORD new_size;
    DWORD use_map = context->stream_info.use_map;
    struct glsl_vs_compiled_shader *gl_shaders, *new_array;
    struct glsl_shader_private *shader_data;
    GLuint ret;
 
    if (!shader->backend_data)
    {
        if (!(shader->backend_data = heap_alloc_zero(sizeof(*shader_data))))
        {
            ERR("Failed to allocate backend data.\n");
            return 0;
        }
    }
    shader_data = shader->backend_data;
    gl_shaders = shader_data->gl_shaders.vs;
 
    /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
     * so a linear search is more performant than a hashmap or a binary search
     * (cache coherency etc)
     */
    for (i = 0; i < shader_data->num_gl_shaders; ++i)
    {
        if (vs_args_equal(&gl_shaders[i].args, args, use_map))
            return gl_shaders[i].id;
    }
 
    TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
 
    if (shader_data->shader_array_size == shader_data->num_gl_shaders)
    {
        if (shader_data->num_gl_shaders)
        {
            new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
            new_array = heap_realloc(shader_data->gl_shaders.vs, new_size * sizeof(*gl_shaders));
        }
        else
        {
            new_array = heap_alloc(sizeof(*gl_shaders));
            new_size = 1;
        }
 
        if(!new_array) {
            ERR("Out of memory\n");
            return 0;
        }
        shader_data->gl_shaders.vs = new_array;
        shader_data->shader_array_size = new_size;
        gl_shaders = new_array;
    }
 
    gl_shaders[shader_data->num_gl_shaders].args = *args;
 
    string_buffer_clear(&priv->shader_buffer);
    ret = shader_glsl_generate_vshader(context, priv, shader, args);
    gl_shaders[shader_data->num_gl_shaders++].id = ret;
 
    return ret;
}

Referenced by set_glsl_shader_program().

◆ get_attribute_keyword()

static const char * get_attribute_keyword ( const struct wined3d_gl_info * gl_info )

static

Definition at line 1817 of file glsl_shader.c.

{
    return needs_legacy_glsl_syntax(gl_info) ? "attribute" : "in";
}

Referenced by shader_glsl_declare_generic_vertex_attribute(), shader_glsl_declare_typed_vertex_attribute(), and shader_glsl_generate_ffp_vertex_shader().

◆ get_glsl_program_entry()

static struct glsl_shader_prog_link * get_glsl_program_entry	(	const struct shader_glsl_priv *	priv,
		const struct glsl_program_key *	key
	)

static

Definition at line 6586 of file glsl_shader.c.

{
    struct wine_rb_entry *entry;
 
    entry = wine_rb_get(&priv->program_lookup, key);
    return entry ? WINE_RB_ENTRY_VALUE(entry, struct glsl_shader_prog_link, program_lookup_entry) : NULL;
}

Referenced by set_glsl_compute_shader_program(), and set_glsl_shader_program().

◆ get_info_log_line()

static const char * get_info_log_line ( const char ** ptr )

static

Definition at line 442 of file glsl_shader.c.

{
    const char *p, *q;
 
    p = *ptr;
    if (!(q = strstr(p, "\n")))
    {
        if (!*p) return NULL;
        *ptr += strlen(p);
        return p;
    }
    *ptr = q + 1;
 
    return p;
}

Referenced by print_glsl_info_log(), shader_glsl_compile(), and shader_glsl_dump_program_source().

◆ get_normal_matrix()

static void get_normal_matrix	(	struct wined3d_context *	context,
		struct wined3d_matrix *	mat,
		float *	normal
	)

static

Definition at line 1438 of file glsl_shader.c.

{
    int i, j;
 
    if (context->d3d_info->wined3d_creation_flags & WINED3D_LEGACY_FFP_LIGHTING)
        invert_matrix_3d(mat, mat);
    else
        invert_matrix(mat, mat);
    /* Tests show that singular modelview matrices are used unchanged as normal
     * matrices on D3D3 and older. There seems to be no clearly consistent
     * behavior on newer D3D versions so always follow older ddraw behavior. */
    for (i = 0; i < 3; ++i)
        for (j = 0; j < 3; ++j)
            normal[i * 3 + j] = (&mat->_11)[j * 4 + i];
}

Referenced by shader_glsl_load_constants().

◆ glsl_fragment_pipe_alloc()

static void * glsl_fragment_pipe_alloc	(	const struct wined3d_shader_backend_ops *	shader_backend,
		void *	shader_priv
	)

static

Definition at line 11663 of file glsl_shader.c.

{
    struct shader_glsl_priv *priv;
 
    if (shader_backend == &glsl_shader_backend)
    {
        priv = shader_priv;
        wine_rb_init(&priv->ffp_fragment_shaders, wined3d_ffp_frag_program_key_compare);
        return priv;
    }
 
    FIXME("GLSL fragment pipe without GLSL shader backend not implemented.\n");
 
    return NULL;
}

◆ glsl_fragment_pipe_alloc_context_data()

static BOOL glsl_fragment_pipe_alloc_context_data ( struct wined3d_context * context )

static

Definition at line 11960 of file glsl_shader.c.

{
    return TRUE;
}

◆ glsl_fragment_pipe_alpha_test()

static void glsl_fragment_pipe_alpha_test	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11805 of file glsl_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
 
    if (state->render_states[WINED3D_RS_ALPHATESTENABLE])
    {
        gl_info->gl_ops.gl.p_glEnable(GL_ALPHA_TEST);
        checkGLcall("glEnable(GL_ALPHA_TEST)");
    }
    else
    {
        gl_info->gl_ops.gl.p_glDisable(GL_ALPHA_TEST);
        checkGLcall("glDisable(GL_ALPHA_TEST)");
    }
}

◆ glsl_fragment_pipe_alpha_test_func()

static void glsl_fragment_pipe_alpha_test_func	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11785 of file glsl_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
    GLint func = wined3d_gl_compare_func(state->render_states[WINED3D_RS_ALPHAFUNC]);
    float ref = state->render_states[WINED3D_RS_ALPHAREF] / 255.0f;
 
    if (func)
    {
        gl_info->gl_ops.gl.p_glAlphaFunc(func, ref);
        checkGLcall("glAlphaFunc");
    }
}

◆ glsl_fragment_pipe_color_key()

static void glsl_fragment_pipe_color_key	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11828 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_COLOR_KEY;
}

◆ glsl_fragment_pipe_core_alpha_test()

static void glsl_fragment_pipe_core_alpha_test	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11799 of file glsl_shader.c.

{
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}

◆ glsl_fragment_pipe_core_alpha_test_ref()

static void glsl_fragment_pipe_core_alpha_test_ref	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11822 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_PS_ALPHA_TEST;
}

◆ glsl_fragment_pipe_enable()

static void glsl_fragment_pipe_enable	(	const struct wined3d_gl_info *	gl_info,
		BOOL	enable
	)

static

Definition at line 11615 of file glsl_shader.c.

{
    /* Nothing to do. */
}

◆ glsl_fragment_pipe_fog()

static void glsl_fragment_pipe_fog	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11720 of file glsl_shader.c.

{
    BOOL use_vshader = use_vs(state);
    enum fogsource new_source;
    DWORD fogstart = state->render_states[WINED3D_RS_FOGSTART];
    DWORD fogend = state->render_states[WINED3D_RS_FOGEND];
 
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
 
    if (!state->render_states[WINED3D_RS_FOGENABLE])
        return;
 
    if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3D_FOG_NONE)
    {
        if (use_vshader)
            new_source = FOGSOURCE_VS;
        else if (state->render_states[WINED3D_RS_FOGVERTEXMODE] == WINED3D_FOG_NONE || context->stream_info.position_transformed)
            new_source = FOGSOURCE_COORD;
        else
            new_source = FOGSOURCE_FFP;
    }
    else
    {
        new_source = FOGSOURCE_FFP;
    }
 
    if (new_source != context->fog_source || fogstart == fogend)
    {
        context->fog_source = new_source;
        context->constant_update_mask |= WINED3D_SHADER_CONST_PS_FOG;
    }
}

Referenced by glsl_fragment_pipe_vdecl().

◆ glsl_fragment_pipe_fogparams()

static void glsl_fragment_pipe_fogparams	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11714 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_PS_FOG;
}

◆ glsl_fragment_pipe_free()

static void glsl_fragment_pipe_free ( struct wined3d_device * device )

static

Definition at line 11696 of file glsl_shader.c.

{
    struct shader_glsl_priv *priv = device->fragment_priv;
    struct glsl_ffp_destroy_ctx ctx;
 
    ctx.priv = priv;
    ctx.gl_info = &device->adapter->gl_info;
    wine_rb_destroy(&priv->ffp_fragment_shaders, shader_glsl_free_ffp_fragment_shader, &ctx);
}

◆ glsl_fragment_pipe_free_context_data()

static void glsl_fragment_pipe_free_context_data ( struct wined3d_context * context )

static

Definition at line 11965 of file glsl_shader.c.

11966{

11967}

◆ glsl_fragment_pipe_get_caps()

static void glsl_fragment_pipe_get_caps	(	const struct wined3d_gl_info *	gl_info,
		struct fragment_caps *	caps
	)

static

Definition at line 11620 of file glsl_shader.c.

{
    caps->wined3d_caps = WINED3D_FRAGMENT_CAP_PROJ_CONTROL
            | WINED3D_FRAGMENT_CAP_SRGB_WRITE
            | WINED3D_FRAGMENT_CAP_COLOR_KEY;
    caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_TSSARGTEMP
            | WINED3DPMISCCAPS_PERSTAGECONSTANT;
    caps->TextureOpCaps = WINED3DTEXOPCAPS_DISABLE
            | WINED3DTEXOPCAPS_SELECTARG1
            | WINED3DTEXOPCAPS_SELECTARG2
            | WINED3DTEXOPCAPS_MODULATE4X
            | WINED3DTEXOPCAPS_MODULATE2X
            | WINED3DTEXOPCAPS_MODULATE
            | WINED3DTEXOPCAPS_ADDSIGNED2X
            | WINED3DTEXOPCAPS_ADDSIGNED
            | WINED3DTEXOPCAPS_ADD
            | WINED3DTEXOPCAPS_SUBTRACT
            | WINED3DTEXOPCAPS_ADDSMOOTH
            | WINED3DTEXOPCAPS_BLENDCURRENTALPHA
            | WINED3DTEXOPCAPS_BLENDFACTORALPHA
            | WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
            | WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
            | WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
            | WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
            | WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
            | WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA
            | WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
            | WINED3DTEXOPCAPS_DOTPRODUCT3
            | WINED3DTEXOPCAPS_MULTIPLYADD
            | WINED3DTEXOPCAPS_LERP
            | WINED3DTEXOPCAPS_BUMPENVMAP
            | WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE;
    caps->MaxTextureBlendStages = MAX_TEXTURES;
    caps->MaxSimultaneousTextures = min(gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL], MAX_TEXTURES);
}

◆ glsl_fragment_pipe_get_emul_mask()

static DWORD glsl_fragment_pipe_get_emul_mask ( const struct wined3d_gl_info * gl_info )

static

Definition at line 11656 of file glsl_shader.c.

{
    if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
        return GL_EXT_EMUL_ARB_MULTITEXTURE;
    return 0;
}

◆ glsl_fragment_pipe_invalidate_constants()

static void glsl_fragment_pipe_invalidate_constants	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11779 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_PS;
}

◆ glsl_fragment_pipe_shademode()

static void glsl_fragment_pipe_shademode	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11834 of file glsl_shader.c.

{
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}

◆ glsl_fragment_pipe_shader()

static void glsl_fragment_pipe_shader	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11706 of file glsl_shader.c.

{
    context->last_was_pshader = use_ps(state);
 
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}

◆ glsl_fragment_pipe_tex_transform()

static void glsl_fragment_pipe_tex_transform	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11773 of file glsl_shader.c.

{
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}

◆ glsl_fragment_pipe_vdecl()

static void glsl_fragment_pipe_vdecl	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11754 of file glsl_shader.c.

{
    /* Because of settings->texcoords_initialized and args->texcoords_initialized. */
    if (context->gl_info->limits.glsl_varyings < wined3d_max_compat_varyings(context->gl_info))
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
 
    if (!isStateDirty(context, STATE_RENDER(WINED3D_RS_FOGENABLE)))
        glsl_fragment_pipe_fog(context, state, state_id);
}

◆ glsl_fragment_pipe_vs()

static void glsl_fragment_pipe_vs	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11765 of file glsl_shader.c.

{
    /* Because of settings->texcoords_initialized and args->texcoords_initialized. */
    if (context->gl_info->limits.glsl_varyings < wined3d_max_compat_varyings(context->gl_info))
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}

◆ glsl_is_color_reg_read()

static BOOL glsl_is_color_reg_read	(	const struct wined3d_shader *	shader,
		unsigned int	idx
	)

static

Definition at line 1991 of file glsl_shader.c.

{
    const struct wined3d_shader_signature *input_signature = &shader->input_signature;
    const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
    DWORD input_reg_used = shader->u.ps.input_reg_used;
    unsigned int i;
 
    if (reg_maps->shader_version.major < 3)
        return input_reg_used & (1u << idx);
 
    for (i = 0; i < input_signature->element_count; ++i)
    {
        const struct wined3d_shader_signature_element *input = &input_signature->elements[i];
 
        if (!(reg_maps->input_registers & (1u << input->register_idx)))
            continue;
 
        if (shader_match_semantic(input->semantic_name, WINED3D_DECL_USAGE_COLOR)
                && input->semantic_idx == idx)
            return input_reg_used & (1u << input->register_idx);
    }
    return FALSE;
}

Referenced by shader_glsl_generate_pshader().

◆ glsl_is_shadow_sampler()

static BOOL glsl_is_shadow_sampler	(	const struct wined3d_shader *	shader,
		const struct ps_compile_args *	ps_args,
		unsigned int	resource_idx,
		unsigned int	sampler_idx
	)

static

Definition at line 2015 of file glsl_shader.c.

{
    const struct wined3d_shader_version *version = &shader->reg_maps.shader_version;
 
    if (version->major >= 4)
        return shader->reg_maps.sampler_comparison_mode & (1u << sampler_idx);
    else
        return version->type == WINED3D_SHADER_TYPE_PIXEL && (ps_args->shadow & (1u << resource_idx));
}

Referenced by shader_generate_glsl_declarations(), and shader_glsl_get_sample_function().

◆ glsl_primitive_type_from_d3d()

static const char * glsl_primitive_type_from_d3d ( enum wined3d_primitive_type primitive_type )

static

Definition at line 1960 of file glsl_shader.c.

{
    switch (primitive_type)
    {
        case WINED3D_PT_POINTLIST:
            return "points";
 
        case WINED3D_PT_LINELIST:
            return "lines";
 
        case WINED3D_PT_LINESTRIP:
            return "line_strip";
 
        case WINED3D_PT_TRIANGLELIST:
            return "triangles";
 
        case WINED3D_PT_TRIANGLESTRIP:
            return "triangle_strip";
 
        case WINED3D_PT_LINELIST_ADJ:
            return "lines_adjacency";
 
        case WINED3D_PT_TRIANGLELIST_ADJ:
            return "triangles_adjacency";
 
        default:
            FIXME("Unhandled primitive type %s.\n", debug_d3dprimitivetype(primitive_type));
            return "";
    }
}

Referenced by shader_glsl_generate_geometry_shader().

◆ glsl_program_key_compare()

static int glsl_program_key_compare	(	const void *	key,
		const struct wine_rb_entry *	entry
	)

static

Definition at line 10584 of file glsl_shader.c.

{
    const struct glsl_program_key *k = key;
    const struct glsl_shader_prog_link *prog = WINE_RB_ENTRY_VALUE(entry,
            const struct glsl_shader_prog_link, program_lookup_entry);
 
    if (k->vs_id > prog->vs.id) return 1;
    else if (k->vs_id < prog->vs.id) return -1;
 
    if (k->gs_id > prog->gs.id) return 1;
    else if (k->gs_id < prog->gs.id) return -1;
 
    if (k->ps_id > prog->ps.id) return 1;
    else if (k->ps_id < prog->ps.id) return -1;
 
    if (k->hs_id > prog->hs.id) return 1;
    else if (k->hs_id < prog->hs.id) return -1;
 
    if (k->ds_id > prog->ds.id) return 1;
    else if (k->ds_id < prog->ds.id) return -1;
 
    if (k->cs_id > prog->cs.id) return 1;
    else if (k->cs_id < prog->cs.id) return -1;
 
    return 0;
}

Referenced by shader_glsl_alloc().

◆ glsl_vertex_pipe_clip_plane()

static void glsl_vertex_pipe_clip_plane	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11454 of file glsl_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
    UINT index = state_id - STATE_CLIPPLANE(0);
 
    if (index >= gl_info->limits.user_clip_distances)
        return;
 
    context->constant_update_mask |= WINED3D_SHADER_CONST_VS_CLIP_PLANES;
}

◆ glsl_vertex_pipe_geometry_shader()

static void glsl_vertex_pipe_geometry_shader	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11296 of file glsl_shader.c.

{
    struct glsl_context_data *ctx_data = context->shader_backend_data;
    BOOL rasterization_disabled;
 
    rasterization_disabled = is_rasterization_disabled(state->shader[WINED3D_SHADER_TYPE_GEOMETRY]);
    if (ctx_data->rasterization_disabled != rasterization_disabled)
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
    ctx_data->rasterization_disabled = rasterization_disabled;
 
    if (state->shader[WINED3D_SHADER_TYPE_DOMAIN])
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_DOMAIN;
    else if (state->shader[WINED3D_SHADER_TYPE_VERTEX]
            && state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.shader_version.major >= 4)
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
}

◆ glsl_vertex_pipe_hs()

static void glsl_vertex_pipe_hs	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11284 of file glsl_shader.c.

{
    /* In Direct3D tessellator options (e.g. output primitive type, primitive
     * winding) are defined in Hull Shaders, while in GLSL those are
     * specified in Tessellation Evaluation Shaders. */
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_DOMAIN;
 
    if (state->shader[WINED3D_SHADER_TYPE_VERTEX])
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
}

◆ glsl_vertex_pipe_light()

static void glsl_vertex_pipe_light	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11420 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_LIGHTS;
}

◆ glsl_vertex_pipe_material()

static void glsl_vertex_pipe_material	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11414 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_MATERIAL;
}

◆ glsl_vertex_pipe_nop()

static void glsl_vertex_pipe_nop	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11203 of file glsl_shader.c.

11204 {}

◆ glsl_vertex_pipe_pixel_shader()

static void glsl_vertex_pipe_pixel_shader	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11314 of file glsl_shader.c.

{
    if (state->shader[WINED3D_SHADER_TYPE_GEOMETRY])
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_GEOMETRY;
    else if (state->shader[WINED3D_SHADER_TYPE_DOMAIN])
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_DOMAIN;
    else if (state->shader[WINED3D_SHADER_TYPE_VERTEX]
            && state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.shader_version.major >= 4)
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
}

◆ glsl_vertex_pipe_pointscale()

static void glsl_vertex_pipe_pointscale	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11432 of file glsl_shader.c.

{
    if (!use_vs(state))
        context->constant_update_mask |= WINED3D_SHADER_CONST_VS_POINTSIZE;
}

◆ glsl_vertex_pipe_pointsize()

static void glsl_vertex_pipe_pointsize	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11426 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_VS_POINTSIZE;
}

◆ glsl_vertex_pipe_projection()

static void glsl_vertex_pipe_projection	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11362 of file glsl_shader.c.

{
    /* Table fog behavior depends on the projection matrix. */
    if (state->render_states[WINED3D_RS_FOGENABLE]
            && state->render_states[WINED3D_RS_FOGTABLEMODE] != WINED3D_FOG_NONE)
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_PROJ;
}

Referenced by glsl_vertex_pipe_viewport().

◆ glsl_vertex_pipe_shademode()

static void glsl_vertex_pipe_shademode	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11448 of file glsl_shader.c.

{
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
}

◆ glsl_vertex_pipe_shader()

static void glsl_vertex_pipe_shader	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11206 of file glsl_shader.c.

{
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
}

◆ glsl_vertex_pipe_texmatrix()

static void glsl_vertex_pipe_texmatrix	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11383 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_TEXMATRIX;
}

◆ glsl_vertex_pipe_texmatrix_np2()

static void glsl_vertex_pipe_texmatrix_np2	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11389 of file glsl_shader.c.

{
    DWORD sampler = state_id - STATE_SAMPLER(0);
    const struct wined3d_texture *texture = state->textures[sampler];
    BOOL np2;
 
    if (!texture)
        return;
 
    if (sampler >= MAX_TEXTURES)
        return;
 
    if ((np2 = !(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
            || context->lastWasPow2Texture & (1u << sampler))
    {
        if (np2)
            context->lastWasPow2Texture |= 1u << sampler;
        else
            context->lastWasPow2Texture &= ~(1u << sampler);
 
        context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_TEXMATRIX;
    }
}

◆ glsl_vertex_pipe_vdecl()

static void glsl_vertex_pipe_vdecl	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11212 of file glsl_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
    BOOL normal = !!(context->stream_info.use_map & (1u << WINED3D_FFP_NORMAL));
    const BOOL legacy_clip_planes = needs_legacy_glsl_syntax(gl_info);
    BOOL transformed = context->stream_info.position_transformed;
    BOOL wasrhw = context->last_was_rhw;
    unsigned int i;
 
    context->last_was_rhw = transformed;
 
    /* If the vertex declaration contains a transformed position attribute,
     * the draw uses the fixed function vertex pipeline regardless of any
     * vertex shader set by the application. */
    if (transformed != wasrhw
            || context->stream_info.swizzle_map != context->last_swizzle_map)
        context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
 
    context->last_swizzle_map = context->stream_info.swizzle_map;
 
    if (!use_vs(state))
    {
        if (context->last_was_vshader)
        {
            if (legacy_clip_planes)
                for (i = 0; i < gl_info->limits.user_clip_distances; ++i)
                    clipplane(context, state, STATE_CLIPPLANE(i));
            else
                context->constant_update_mask |= WINED3D_SHADER_CONST_VS_CLIP_PLANES;
        }
 
        context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_TEXMATRIX;
 
        /* Because of settings->texcoords, we have to regenerate the vertex
         * shader on a vdecl change if there aren't enough varyings to just
         * always output all the texture coordinates. */
        if (gl_info->limits.glsl_varyings < wined3d_max_compat_varyings(gl_info)
                || normal != context->last_was_normal)
            context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
 
        if (use_ps(state)
                && state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.shader_version.major == 1
                && state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.shader_version.minor <= 3)
            context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
    }
    else
    {
        if (!context->last_was_vshader)
        {
            /* Vertex shader clipping ignores the view matrix. Update all clip planes. */
            if (legacy_clip_planes)
                for (i = 0; i < gl_info->limits.user_clip_distances; ++i)
                    clipplane(context, state, STATE_CLIPPLANE(i));
            else
                context->constant_update_mask |= WINED3D_SHADER_CONST_VS_CLIP_PLANES;
        }
    }
 
    context->last_was_vshader = use_vs(state);
    context->last_was_normal = normal;
}

◆ glsl_vertex_pipe_vertexblend()

static void glsl_vertex_pipe_vertexblend	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11332 of file glsl_shader.c.

{
    int i = state_id - STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0));
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_VERTEXBLEND_INDEX(i);
}

◆ glsl_vertex_pipe_view()

static void glsl_vertex_pipe_view	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11339 of file glsl_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
    unsigned int k;
 
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_MODELVIEW
            | WINED3D_SHADER_CONST_FFP_LIGHTS
            | WINED3D_SHADER_CONST_FFP_VERTEXBLEND;
 
    if (needs_legacy_glsl_syntax(gl_info))
    {
        for (k = 0; k < gl_info->limits.user_clip_distances; ++k)
        {
            if (!isStateDirty(context, STATE_CLIPPLANE(k)))
                clipplane(context, state, STATE_CLIPPLANE(k));
        }
    }
    else
    {
        context->constant_update_mask |= WINED3D_SHADER_CONST_VS_CLIP_PLANES;
    }
}

◆ glsl_vertex_pipe_viewport()

static void glsl_vertex_pipe_viewport	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11372 of file glsl_shader.c.

{
    if (!isStateDirty(context, STATE_TRANSFORM(WINED3D_TS_PROJECTION)))
        glsl_vertex_pipe_projection(context, state, STATE_TRANSFORM(WINED3D_TS_PROJECTION));
    if (!isStateDirty(context, STATE_RENDER(WINED3D_RS_POINTSCALEENABLE))
            && state->render_states[WINED3D_RS_POINTSCALEENABLE])
        context->constant_update_mask |= WINED3D_SHADER_CONST_VS_POINTSIZE;
    context->constant_update_mask |= WINED3D_SHADER_CONST_POS_FIXUP;
}

◆ glsl_vertex_pipe_vp_alloc()

static void * glsl_vertex_pipe_vp_alloc	(	const struct wined3d_shader_backend_ops *	shader_backend,
		void *	shader_priv
	)

static

Definition at line 11160 of file glsl_shader.c.

{
    struct shader_glsl_priv *priv;
 
    if (shader_backend == &glsl_shader_backend)
    {
        priv = shader_priv;
        wine_rb_init(&priv->ffp_vertex_shaders, wined3d_ffp_vertex_program_key_compare);
        return priv;
    }
 
    FIXME("GLSL vertex pipe without GLSL shader backend not implemented.\n");
 
    return NULL;
}

◆ glsl_vertex_pipe_vp_enable()

static void glsl_vertex_pipe_vp_enable	(	const struct wined3d_gl_info *	gl_info,
		BOOL	enable
	)

static

Definition at line 11131 of file glsl_shader.c.

11131{}

◆ glsl_vertex_pipe_vp_free()

static void glsl_vertex_pipe_vp_free ( struct wined3d_device * device )

static

Definition at line 11193 of file glsl_shader.c.

{
    struct shader_glsl_priv *priv = device->vertex_priv;
    struct glsl_ffp_destroy_ctx ctx;
 
    ctx.priv = priv;
    ctx.gl_info = &device->adapter->gl_info;
    wine_rb_destroy(&priv->ffp_vertex_shaders, shader_glsl_free_ffp_vertex_shader, &ctx);
}

◆ glsl_vertex_pipe_vp_get_caps()

static void glsl_vertex_pipe_vp_get_caps	(	const struct wined3d_gl_info *	gl_info,
		struct wined3d_vertex_caps *	caps
	)

static

Definition at line 11133 of file glsl_shader.c.

{
    caps->xyzrhw = TRUE;
    caps->emulated_flatshading = !needs_legacy_glsl_syntax(gl_info);
    caps->ffp_generic_attributes = TRUE;
    caps->max_active_lights = MAX_ACTIVE_LIGHTS;
    caps->max_vertex_blend_matrices = MAX_VERTEX_BLENDS;
    caps->max_vertex_blend_matrix_index = MAX_VERTEX_INDEX_BLENDS - 1;
    caps->vertex_processing_caps = WINED3DVTXPCAPS_TEXGEN
            | WINED3DVTXPCAPS_MATERIALSOURCE7
            | WINED3DVTXPCAPS_VERTEXFOG
            | WINED3DVTXPCAPS_DIRECTIONALLIGHTS
            | WINED3DVTXPCAPS_POSITIONALLIGHTS
            | WINED3DVTXPCAPS_LOCALVIEWER
            | WINED3DVTXPCAPS_TEXGEN_SPHEREMAP;
    caps->fvf_caps = WINED3DFVFCAPS_PSIZE | 8; /* 8 texture coordinates. */
    caps->max_user_clip_planes = gl_info->limits.user_clip_distances;
    caps->raster_caps = WINED3DPRASTERCAPS_FOGRANGE;
}

◆ glsl_vertex_pipe_vp_get_emul_mask()

static DWORD glsl_vertex_pipe_vp_get_emul_mask ( const struct wined3d_gl_info * gl_info )

static

Definition at line 11153 of file glsl_shader.c.

{
    if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
        return GL_EXT_EMUL_ARB_MULTITEXTURE;
    return 0;
}

◆ glsl_vertex_pipe_vs()

static void glsl_vertex_pipe_vs	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11275 of file glsl_shader.c.

{
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
    /* Different vertex shaders potentially require a different vertex attributes setup. */
    if (!isStateDirty(context, STATE_VDECL))
        context_apply_state(context, state, STATE_VDECL);
}

◆ glsl_vertex_pipe_world()

static void glsl_vertex_pipe_world	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11326 of file glsl_shader.c.

{
    context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_MODELVIEW;
}

◆ glsl_vertex_pointsprite_core()

static void glsl_vertex_pointsprite_core	(	struct wined3d_context *	context,
		const struct wined3d_state *	state,
		DWORD	state_id
	)

static

Definition at line 11439 of file glsl_shader.c.

{
    static unsigned int once;
 
    if (state->gl_primitive_type == GL_POINTS && !state->render_states[WINED3D_RS_POINTSPRITEENABLE] && !once++)
        FIXME("Non-point sprite points not supported in core profile.\n");
}

◆ is_mipmapped()

static BOOL is_mipmapped ( enum wined3d_shader_resource_type resource_type )

static

Definition at line 5665 of file glsl_shader.c.

{
    return resource_type != WINED3D_SHADER_RESOURCE_BUFFER && !is_multisampled(resource_type);
}

Referenced by shader_glsl_ld(), and shader_glsl_resinfo().

◆ is_multisampled()

static BOOL is_multisampled ( enum wined3d_shader_resource_type resource_type )

static

Definition at line 5659 of file glsl_shader.c.

{
    return resource_type == WINED3D_SHADER_RESOURCE_TEXTURE_2DMS
            || resource_type == WINED3D_SHADER_RESOURCE_TEXTURE_2DMSARRAY;
}

Referenced by is_mipmapped(), and shader_glsl_ld().

◆ multiply_vector_matrix()

static void multiply_vector_matrix	(	struct wined3d_vec4 *	dest,
		const struct wined3d_vec4 *	src1,
		const struct wined3d_matrix *	src2
	)

static

Definition at line 1289 of file glsl_shader.c.

{
    struct wined3d_vec4 temp;
 
    temp.x = (src1->x * src2->_11) + (src1->y * src2->_21) + (src1->z * src2->_31) + (src1->w * src2->_41);
    temp.y = (src1->x * src2->_12) + (src1->y * src2->_22) + (src1->z * src2->_32) + (src1->w * src2->_42);
    temp.z = (src1->x * src2->_13) + (src1->y * src2->_23) + (src1->z * src2->_33) + (src1->w * src2->_43);
    temp.w = (src1->x * src2->_14) + (src1->y * src2->_24) + (src1->z * src2->_34) + (src1->w * src2->_44);
 
    *dest = temp;
}

Referenced by shader_glsl_clip_plane_uniform(), and shader_glsl_ffp_vertex_light_uniform().

◆ needs_legacy_glsl_syntax()

static BOOL needs_legacy_glsl_syntax ( const struct wined3d_gl_info * gl_info )

static

Definition at line 1801 of file glsl_shader.c.

{
    return gl_info->glsl_version < MAKEDWORD_VERSION(1, 30);
}

◆ print_glsl_info_log()

void print_glsl_info_log	(	const struct wined3d_gl_info *	gl_info,
		GLuint	id,
		BOOL	program
	)

Definition at line 459 of file glsl_shader.c.

{
    int length = 0;
    char *log;
 
    if (!WARN_ON(d3d_shader) && !FIXME_ON(d3d_shader))
        return;
 
    if (program)
        GL_EXTCALL(glGetProgramiv(id, GL_INFO_LOG_LENGTH, &length));
    else
        GL_EXTCALL(glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length));
 
    /* A size of 1 is just a null-terminated string, so the log should be bigger than
     * that if there are errors. */
    if (length > 1)
    {
        const char *ptr, *line;
 
        log = heap_alloc(length);
        /* The info log is supposed to be zero-terminated, but at least some
         * versions of fglrx don't terminate the string properly. The reported
         * length does include the terminator, so explicitly set it to zero
         * here. */
        log[length - 1] = 0;
        if (program)
            GL_EXTCALL(glGetProgramInfoLog(id, length, NULL, log));
        else
            GL_EXTCALL(glGetShaderInfoLog(id, length, NULL, log));
 
        ptr = log;
        if (gl_info->quirks & WINED3D_QUIRK_INFO_LOG_SPAM)
        {
            WARN("Info log received from GLSL shader #%u:\n", id);
            while ((line = get_info_log_line(&ptr))) WARN("    %.*s", (int)(ptr - line), line);
        }
        else
        {
            FIXME("Info log received from GLSL shader #%u:\n", id);
            while ((line = get_info_log_line(&ptr))) FIXME("    %.*s", (int)(ptr - line), line);
        }
        heap_free(log);
    }
}

Referenced by draw_test_quad(), shader_glsl_compile(), and shader_glsl_validate_link().

◆ PRINTF_ATTR() [1/2]

static void PRINTF_ATTR	(	4	,
		5
	)

static

Definition at line 1822 of file glsl_shader.c.

{
    va_list args;
    int ret;
 
    shader_addline(buffer, "%s%s ", flat ? "flat " : "",
            needs_legacy_glsl_syntax(gl_info) ? "varying" : "in");
    for (;;)
    {
        va_start(args, format);
        ret = shader_vaddline(buffer, format, args);
        va_end(args);
        if (!ret)
            return;
        if (!string_buffer_resize(buffer, ret))
            return;
    }
}

◆ PRINTF_ATTR() [2/2]

static void PRINTF_ATTR	(	9	,
		10
	)

static

Definition at line 3450 of file glsl_shader.c.

{
    static const struct wined3d_shader_texel_offset dummy_offset = {0, 0, 0};
    const struct wined3d_shader_version *version = &ins->ctx->reg_maps->shader_version;
    char dst_swizzle[6];
    struct color_fixup_desc fixup;
    BOOL np2_fixup = FALSE;
    va_list args;
    int ret;
 
    shader_glsl_swizzle_to_str(swizzle, FALSE, ins->dst[0].write_mask, dst_swizzle);
 
    /* If ARB_texture_swizzle is supported we don't need to do anything here.
     * We actually rely on it for vertex shaders and SM4+. */
    if (version->type == WINED3D_SHADER_TYPE_PIXEL && version->major < 4)
    {
        const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
        fixup = priv->cur_ps_args->color_fixup[sampler_bind_idx];
 
        if (priv->cur_ps_args->np2_fixup & (1u << sampler_bind_idx))
            np2_fixup = TRUE;
    }
    else
    {
        fixup = COLOR_FIXUP_IDENTITY;
    }
 
    shader_glsl_append_dst_ext(ins->ctx->buffer, ins, &ins->dst[0], sample_function->data_type);
 
    if (sample_function->output_single_component)
        shader_addline(ins->ctx->buffer, "vec4(");
 
    shader_addline(ins->ctx->buffer, "%s(%s_sampler%u, ",
            sample_function->name->buffer, shader_glsl_get_prefix(version->type), sampler_bind_idx);
 
    for (;;)
    {
        va_start(args, coord_reg_fmt);
        ret = shader_vaddline(ins->ctx->buffer, coord_reg_fmt, args);
        va_end(args);
        if (!ret)
            break;
        if (!string_buffer_resize(ins->ctx->buffer, ret))
            break;
    }
 
    if (np2_fixup)
    {
        const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
        const unsigned char idx = priv->cur_np2fixup_info->idx[sampler_bind_idx];
 
        switch (shader_glsl_get_write_mask_size(sample_function->coord_mask))
        {
            case 1:
                shader_addline(ins->ctx->buffer, " * ps_samplerNP2Fixup[%u].%s",
                        idx >> 1, (idx % 2) ? "z" : "x");
                break;
            case 2:
                shader_addline(ins->ctx->buffer, " * ps_samplerNP2Fixup[%u].%s",
                        idx >> 1, (idx % 2) ? "zw" : "xy");
                break;
            case 3:
                shader_addline(ins->ctx->buffer, " * vec3(ps_samplerNP2Fixup[%u].%s, 1.0)",
                        idx >> 1, (idx % 2) ? "zw" : "xy");
                break;
            case 4:
                shader_addline(ins->ctx->buffer, " * vec4(ps_samplerNP2Fixup[%u].%s, 1.0, 1.0)",
                        idx >> 1, (idx % 2) ? "zw" : "xy");
                break;
        }
    }
    if (sample_function->emulate_lod)
    {
        if (strcmp(bias, "0")) FIXME("Don't know how to emulate lod level %s\n", bias);
        switch (sample_function->emulate_lod)
        {
            case WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY:
                if (!dx) dx = "vec2(0.0, 0.0)";
                if (!dy) dy = "vec2(0.0, 0.0)";
                break;
 
            case WINED3D_SHADER_RESOURCE_TEXTURE_CUBE:
                if (!dx) dx = "vec3(0.0, 0.0, 0.0)";
                if (!dy) dy = "vec3(0.0, 0.0, 0.0)";
                break;
 
            default:
                break;
        }
        if (!offset) offset = &dummy_offset;
    }
    if (dx && dy)
        shader_addline(ins->ctx->buffer, ", %s, %s", dx, dy);
    else if (bias)
        shader_addline(ins->ctx->buffer, ", %s", bias);
    if (sample_function->offset_size)
    {
        int offset_immdata[4] = {offset->u, offset->v, offset->w};
        shader_addline(ins->ctx->buffer, ", ");
        shader_glsl_append_imm_ivec(ins->ctx->buffer, offset_immdata, sample_function->offset_size);
    }
    shader_addline(ins->ctx->buffer, ")");
 
    if (sample_function->output_single_component)
        shader_addline(ins->ctx->buffer, ")");
 
    shader_addline(ins->ctx->buffer, "%s);\n", dst_swizzle);
 
    if (!is_identity_fixup(fixup))
        shader_glsl_color_correction(ins, fixup);
}

◆ reset_program_constant_version()

static void reset_program_constant_version	(	struct wine_rb_entry *	entry,
		void *	context
	)

static

Definition at line 1205 of file glsl_shader.c.

{
    WINE_RB_ENTRY_VALUE(entry, struct glsl_shader_prog_link, program_lookup_entry)->constant_version = 0;
}

Referenced by shader_glsl_load_constants().

◆ set_glsl_compute_shader_program()

static void set_glsl_compute_shader_program	(	const struct wined3d_context *	context,
		const struct wined3d_state *	state,
		struct shader_glsl_priv *	priv,
		struct glsl_context_data *	ctx_data
	)

static

Definition at line 9797 of file glsl_shader.c.

{
    struct glsl_shader_prog_link *entry;
    struct wined3d_shader *shader;
    struct glsl_program_key key;
    GLuint cs_id;
 
    if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_COMPUTE)))
        return;
 
    if (!(shader = state->shader[WINED3D_SHADER_TYPE_COMPUTE]))
    {
        WARN("Compute shader is NULL.\n");
        ctx_data->glsl_program = NULL;
        return;
    }
 
    cs_id = find_glsl_compute_shader(context, priv, shader);
    memset(&key, 0, sizeof(key));
    key.cs_id = cs_id;
    if (!(entry = get_glsl_program_entry(priv, &key)))
        ERR("Failed to find GLSL program for compute shader %p.\n", shader);
    ctx_data->glsl_program = entry;
}

Referenced by shader_glsl_select_compute().

◆ set_glsl_shader_program()

static void set_glsl_shader_program	(	const struct wined3d_context *	context,
		const struct wined3d_state *	state,
		struct shader_glsl_priv *	priv,
		struct glsl_context_data *	ctx_data
	)

static

Definition at line 9824 of file glsl_shader.c.

{
    const struct wined3d_d3d_info *d3d_info = context->d3d_info;
    const struct wined3d_gl_info *gl_info = context->gl_info;
    const struct wined3d_shader *pre_rasterization_shader;
    const struct ps_np2fixup_info *np2fixup_info = NULL;
    struct wined3d_shader *hshader, *dshader, *gshader;
    struct glsl_shader_prog_link *entry = NULL;
    struct wined3d_shader *vshader = NULL;
    struct wined3d_shader *pshader = NULL;
    GLuint reorder_shader_id = 0;
    struct glsl_program_key key;
    GLuint program_id;
    unsigned int i;
    GLuint vs_id = 0;
    GLuint hs_id = 0;
    GLuint ds_id = 0;
    GLuint gs_id = 0;
    GLuint ps_id = 0;
    struct list *ps_list = NULL, *vs_list = NULL;
    WORD attribs_map;
    struct wined3d_string_buffer *tmp_name;
 
    if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_VERTEX)) && ctx_data->glsl_program)
    {
        vs_id = ctx_data->glsl_program->vs.id;
        vs_list = &ctx_data->glsl_program->vs.shader_entry;
 
        if (use_vs(state))
            vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
    }
    else if (use_vs(state))
    {
        struct vs_compile_args vs_compile_args;
 
        vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
 
        find_vs_compile_args(state, vshader, context->stream_info.swizzle_map, &vs_compile_args, context);
        vs_id = find_glsl_vshader(context, priv, vshader, &vs_compile_args);
        vs_list = &vshader->linked_programs;
    }
    else if (priv->vertex_pipe == &glsl_vertex_pipe)
    {
        struct glsl_ffp_vertex_shader *ffp_shader;
        struct wined3d_ffp_vs_settings settings;
 
        wined3d_ffp_get_vs_settings(context, state, &settings);
        ffp_shader = shader_glsl_find_ffp_vertex_shader(priv, gl_info, &settings);
        vs_id = ffp_shader->id;
        vs_list = &ffp_shader->linked_programs;
    }
 
    hshader = state->shader[WINED3D_SHADER_TYPE_HULL];
    if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_HULL)) && ctx_data->glsl_program)
        hs_id = ctx_data->glsl_program->hs.id;
    else if (hshader)
        hs_id = find_glsl_hull_shader(context, priv, hshader);
 
    dshader = state->shader[WINED3D_SHADER_TYPE_DOMAIN];
    if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_DOMAIN)) && ctx_data->glsl_program)
    {
        ds_id = ctx_data->glsl_program->ds.id;
    }
    else if (dshader)
    {
        struct ds_compile_args args;
 
        find_ds_compile_args(state, dshader, &args, context);
        ds_id = find_glsl_domain_shader(context, priv, dshader, &args);
    }
 
    gshader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
    if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_GEOMETRY)) && ctx_data->glsl_program)
    {
        gs_id = ctx_data->glsl_program->gs.id;
    }
    else if (gshader)
    {
        struct gs_compile_args args;
 
        find_gs_compile_args(state, gshader, &args, context);
        gs_id = find_glsl_geometry_shader(context, priv, gshader, &args);
    }
 
    /* A pixel shader is not used when rasterization is disabled. */
    if (is_rasterization_disabled(gshader))
    {
        ps_id = 0;
        ps_list = NULL;
    }
    else if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_PIXEL)) && ctx_data->glsl_program)
    {
        ps_id = ctx_data->glsl_program->ps.id;
        ps_list = &ctx_data->glsl_program->ps.shader_entry;
 
        if (use_ps(state))
            pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
    }
    else if (use_ps(state))
    {
        struct ps_compile_args ps_compile_args;
        pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
        find_ps_compile_args(state, pshader, context->stream_info.position_transformed, &ps_compile_args, context);
        ps_id = find_glsl_pshader(context, &priv->shader_buffer, &priv->string_buffers,
                pshader, &ps_compile_args, &np2fixup_info);
        ps_list = &pshader->linked_programs;
    }
    else if (priv->fragment_pipe == &glsl_fragment_pipe
            && !(vshader && vshader->reg_maps.shader_version.major >= 4))
    {
        struct glsl_ffp_fragment_shader *ffp_shader;
        struct ffp_frag_settings settings;
 
        gen_ffp_frag_op(context, state, &settings, FALSE);
        ffp_shader = shader_glsl_find_ffp_fragment_shader(priv, &settings, context);
        ps_id = ffp_shader->id;
        ps_list = &ffp_shader->linked_programs;
    }
 
    key.vs_id = vs_id;
    key.hs_id = hs_id;
    key.ds_id = ds_id;
    key.gs_id = gs_id;
    key.ps_id = ps_id;
    key.cs_id = 0;
    if ((!vs_id && !hs_id && !ds_id && !gs_id && !ps_id) || (entry = get_glsl_program_entry(priv, &key)))
    {
        ctx_data->glsl_program = entry;
        return;
    }
 
    /* If we get to this point, then no matching program exists, so we create one */
    program_id = GL_EXTCALL(glCreateProgram());
    TRACE("Created new GLSL shader program %u.\n", program_id);
 
    /* Create the entry */
    entry = heap_alloc(sizeof(*entry));
    entry->id = program_id;
    entry->vs.id = vs_id;
    entry->hs.id = hs_id;
    entry->ds.id = ds_id;
    entry->gs.id = gs_id;
    entry->ps.id = ps_id;
    entry->cs.id = 0;
    entry->constant_version = 0;
    entry->shader_controlled_clip_distances = 0;
    entry->ps.np2_fixup_info = np2fixup_info;
    /* Add the hash table entry */
    add_glsl_program_entry(priv, entry);
 
    /* Set the current program */
    ctx_data->glsl_program = entry;
 
    /* Attach GLSL vshader */
    if (vs_id)
    {
        TRACE("Attaching GLSL shader object %u to program %u.\n", vs_id, program_id);
        GL_EXTCALL(glAttachShader(program_id, vs_id));
        checkGLcall("glAttachShader");
 
        list_add_head(vs_list, &entry->vs.shader_entry);
    }
 
    if (vshader)
    {
        attribs_map = vshader->reg_maps.input_registers;
        if (vshader->reg_maps.shader_version.major < 4)
        {
            reorder_shader_id = shader_glsl_generate_vs3_rasterizer_input_setup(priv, vshader, pshader,
                    state->gl_primitive_type == GL_POINTS && vshader->reg_maps.point_size,
                    d3d_info->emulated_flatshading
                    && state->render_states[WINED3D_RS_SHADEMODE] == WINED3D_SHADE_FLAT, gl_info);
            TRACE("Attaching GLSL shader object %u to program %u.\n", reorder_shader_id, program_id);
            GL_EXTCALL(glAttachShader(program_id, reorder_shader_id));
            checkGLcall("glAttachShader");
            /* Flag the reorder function for deletion, it will be freed
             * automatically when the program is destroyed. */
            GL_EXTCALL(glDeleteShader(reorder_shader_id));
        }
    }
    else
    {
        attribs_map = (1u << WINED3D_FFP_ATTRIBS_COUNT) - 1;
    }
 
    if (!shader_glsl_use_explicit_attrib_location(gl_info))
    {
        /* Bind vertex attributes to a corresponding index number to match
         * the same index numbers as ARB_vertex_programs (makes loading
         * vertex attributes simpler). With this method, we can use the
         * exact same code to load the attributes later for both ARB and
         * GLSL shaders.
         *
         * We have to do this here because we need to know the Program ID
         * in order to make the bindings work, and it has to be done prior
         * to linking the GLSL program. */
        tmp_name = string_buffer_get(&priv->string_buffers);
        for (i = 0; attribs_map; attribs_map >>= 1, ++i)
        {
            if (!(attribs_map & 1))
                continue;
 
            string_buffer_sprintf(tmp_name, "vs_in%u", i);
            GL_EXTCALL(glBindAttribLocation(program_id, i, tmp_name->buffer));
            if (vshader && vshader->reg_maps.shader_version.major >= 4)
            {
                string_buffer_sprintf(tmp_name, "vs_in_uint%u", i);
                GL_EXTCALL(glBindAttribLocation(program_id, i, tmp_name->buffer));
                string_buffer_sprintf(tmp_name, "vs_in_int%u", i);
                GL_EXTCALL(glBindAttribLocation(program_id, i, tmp_name->buffer));
            }
        }
        checkGLcall("glBindAttribLocation");
        string_buffer_release(&priv->string_buffers, tmp_name);
 
        if (!needs_legacy_glsl_syntax(gl_info))
        {
            char var[12];
 
            if (wined3d_dualblend_enabled(state, gl_info))
            {
                for (i = 0; i < gl_info->limits.dual_buffers * 2; i++)
                {
                    sprintf(var, "ps_out%u", i);
                    GL_EXTCALL(glBindFragDataLocationIndexed(program_id, i / 2, i % 2, var));
                    checkGLcall("glBindFragDataLocationIndexed");
                }
            }
            else
            {
                for (i = 0; i < gl_info->limits.buffers; i++)
                {
                    sprintf(var, "ps_out%u", i);
                    GL_EXTCALL(glBindFragDataLocation(program_id, i, var));
                    checkGLcall("glBindFragDataLocation");
                }
            }
        }
    }
 
    if (hshader)
    {
        TRACE("Attaching GLSL tessellation control shader object %u to program %u.\n", hs_id, program_id);
        GL_EXTCALL(glAttachShader(program_id, hs_id));
        checkGLcall("glAttachShader");
 
        list_add_head(&hshader->linked_programs, &entry->hs.shader_entry);
    }
 
    if (dshader)
    {
        TRACE("Attaching GLSL tessellation evaluation shader object %u to program %u.\n", ds_id, program_id);
        GL_EXTCALL(glAttachShader(program_id, ds_id));
        checkGLcall("glAttachShader");
 
        list_add_head(&dshader->linked_programs, &entry->ds.shader_entry);
    }
 
    if (gshader)
    {
        TRACE("Attaching GLSL geometry shader object %u to program %u.\n", gs_id, program_id);
        GL_EXTCALL(glAttachShader(program_id, gs_id));
        checkGLcall("glAttachShader");
 
        shader_glsl_init_transform_feedback(context, priv, program_id, gshader);
 
        list_add_head(&gshader->linked_programs, &entry->gs.shader_entry);
    }
 
    /* Attach GLSL pshader */
    if (ps_id)
    {
        TRACE("Attaching GLSL shader object %u to program %u.\n", ps_id, program_id);
        GL_EXTCALL(glAttachShader(program_id, ps_id));
        checkGLcall("glAttachShader");
 
        list_add_head(ps_list, &entry->ps.shader_entry);
    }
 
    /* Link the program */
    TRACE("Linking GLSL shader program %u.\n", program_id);
    GL_EXTCALL(glLinkProgram(program_id));
    shader_glsl_validate_link(gl_info, program_id);
 
    shader_glsl_init_vs_uniform_locations(gl_info, priv, program_id, &entry->vs,
            vshader ? vshader->limits->constant_float : 0);
    shader_glsl_init_ds_uniform_locations(gl_info, priv, program_id, &entry->ds);
    shader_glsl_init_gs_uniform_locations(gl_info, priv, program_id, &entry->gs);
    shader_glsl_init_ps_uniform_locations(gl_info, priv, program_id, &entry->ps,
            pshader ? pshader->limits->constant_float : 0);
    checkGLcall("find glsl program uniform locations");
 
    pre_rasterization_shader = gshader ? gshader : dshader ? dshader : vshader;
    if (pre_rasterization_shader && pre_rasterization_shader->reg_maps.shader_version.major >= 4)
    {
        unsigned int clip_distance_count = wined3d_popcount(pre_rasterization_shader->reg_maps.clip_distance_mask);
        entry->shader_controlled_clip_distances = 1;
        entry->clip_distance_mask = (1u << clip_distance_count) - 1;
    }
 
    if (needs_legacy_glsl_syntax(gl_info))
    {
        if (pshader && pshader->reg_maps.shader_version.major >= 3
                && pshader->u.ps.declared_in_count > vec4_varyings(3, gl_info))
        {
            TRACE("Shader %d needs vertex color clamping disabled.\n", program_id);
            entry->vs.vertex_color_clamp = GL_FALSE;
        }
        else
        {
            entry->vs.vertex_color_clamp = GL_FIXED_ONLY_ARB;
        }
    }
    else
    {
        /* With core profile we never change vertex_color_clamp from
         * GL_FIXED_ONLY_MODE (which is also the initial value) so we never call
         * glClampColorARB(). */
        entry->vs.vertex_color_clamp = GL_FIXED_ONLY_ARB;
    }
 
    /* Set the shader to allow uniform loading on it */
    GL_EXTCALL(glUseProgram(program_id));
    checkGLcall("glUseProgram");
 
    entry->constant_update_mask = 0;
    if (vshader)
    {
        entry->constant_update_mask |= WINED3D_SHADER_CONST_VS_F;
        if (vshader->reg_maps.integer_constants)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_VS_I;
        if (vshader->reg_maps.boolean_constants)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_VS_B;
        if (entry->vs.pos_fixup_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_POS_FIXUP;
 
        shader_glsl_load_program_resources(context, priv, program_id, vshader);
    }
    else
    {
        entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_MODELVIEW
                | WINED3D_SHADER_CONST_FFP_PROJ;
 
        for (i = 1; i < MAX_VERTEX_INDEX_BLENDS; ++i)
        {
            if (entry->vs.modelview_matrix_location[i] != -1)
            {
                entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_VERTEXBLEND;
                break;
            }
        }
 
        for (i = 0; i < MAX_TEXTURES; ++i)
        {
            if (entry->vs.texture_matrix_location[i] != -1)
            {
                entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_TEXMATRIX;
                break;
            }
        }
        if (entry->vs.material_ambient_location != -1 || entry->vs.material_diffuse_location != -1
                || entry->vs.material_specular_location != -1
                || entry->vs.material_emissive_location != -1
                || entry->vs.material_shininess_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_MATERIAL;
        if (entry->vs.light_ambient_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_LIGHTS;
    }
    if (entry->vs.clip_planes_location != -1)
        entry->constant_update_mask |= WINED3D_SHADER_CONST_VS_CLIP_PLANES;
    if (entry->vs.pointsize_min_location != -1)
        entry->constant_update_mask |= WINED3D_SHADER_CONST_VS_POINTSIZE;
 
    if (hshader)
        shader_glsl_load_program_resources(context, priv, program_id, hshader);
 
    if (dshader)
    {
        if (entry->ds.pos_fixup_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_POS_FIXUP;
 
        shader_glsl_load_program_resources(context, priv, program_id, dshader);
    }
 
    if (gshader)
    {
        if (entry->gs.pos_fixup_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_POS_FIXUP;
 
        shader_glsl_load_program_resources(context, priv, program_id, gshader);
    }
 
    if (ps_id)
    {
        if (pshader)
        {
            entry->constant_update_mask |= WINED3D_SHADER_CONST_PS_F;
            if (pshader->reg_maps.integer_constants)
                entry->constant_update_mask |= WINED3D_SHADER_CONST_PS_I;
            if (pshader->reg_maps.boolean_constants)
                entry->constant_update_mask |= WINED3D_SHADER_CONST_PS_B;
            if (entry->ps.ycorrection_location != -1)
                entry->constant_update_mask |= WINED3D_SHADER_CONST_PS_Y_CORR;
 
            shader_glsl_load_program_resources(context, priv, program_id, pshader);
            shader_glsl_load_images(gl_info, priv, program_id, &pshader->reg_maps);
        }
        else
        {
            entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_PS;
 
            shader_glsl_load_samplers(context, priv, program_id, NULL);
        }
 
        for (i = 0; i < MAX_TEXTURES; ++i)
        {
            if (entry->ps.bumpenv_mat_location[i] != -1)
            {
                entry->constant_update_mask |= WINED3D_SHADER_CONST_PS_BUMP_ENV;
                break;
            }
        }
 
        if (entry->ps.fog_color_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_PS_FOG;
        if (entry->ps.alpha_test_ref_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_PS_ALPHA_TEST;
        if (entry->ps.np2_fixup_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_PS_NP2_FIXUP;
        if (entry->ps.color_key_location != -1)
            entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_COLOR_KEY;
    }
}

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ WINED3D_GLSL_SAMPLE_GRAD

◆ WINED3D_GLSL_SAMPLE_LOAD

◆ WINED3D_GLSL_SAMPLE_LOD

◆ WINED3D_GLSL_SAMPLE_OFFSET

◆ WINED3D_GLSL_SAMPLE_PROJECTED

◆ WINED3D_TO_STR

Enumeration Type Documentation

◆ heap_node_op

Function Documentation

◆ add_glsl_program_entry()

◆ append_transform_feedback_skip_components()

◆ append_transform_feedback_varying()

◆ apply_clamped_constant()

◆ constant_heap_free()

◆ constant_heap_init()

◆ debug_gl_shader_type()

◆ delete_glsl_program_entry()

◆ find_glsl_compute_shader()

◆ find_glsl_domain_shader()

◆ find_glsl_geometry_shader()

◆ find_glsl_hull_shader()

◆ find_glsl_pshader()

◆ find_glsl_vshader()

◆ get_attribute_keyword()

◆ get_glsl_program_entry()

◆ get_info_log_line()

◆ get_normal_matrix()

◆ glsl_fragment_pipe_alloc()

◆ glsl_fragment_pipe_alloc_context_data()

◆ glsl_fragment_pipe_alpha_test()

◆ glsl_fragment_pipe_alpha_test_func()

◆ glsl_fragment_pipe_color_key()

◆ glsl_fragment_pipe_core_alpha_test()

◆ glsl_fragment_pipe_core_alpha_test_ref()

◆ glsl_fragment_pipe_enable()

◆ glsl_fragment_pipe_fog()

◆ glsl_fragment_pipe_fogparams()

◆ glsl_fragment_pipe_free()

◆ glsl_fragment_pipe_free_context_data()

◆ glsl_fragment_pipe_get_caps()

◆ glsl_fragment_pipe_get_emul_mask()

◆ glsl_fragment_pipe_invalidate_constants()

◆ glsl_fragment_pipe_shademode()

◆ glsl_fragment_pipe_shader()

◆ glsl_fragment_pipe_tex_transform()

◆ glsl_fragment_pipe_vdecl()

◆ glsl_fragment_pipe_vs()

◆ glsl_is_color_reg_read()

◆ glsl_is_shadow_sampler()

◆ glsl_primitive_type_from_d3d()

◆ glsl_program_key_compare()

◆ glsl_vertex_pipe_clip_plane()

◆ glsl_vertex_pipe_geometry_shader()

◆ glsl_vertex_pipe_hs()

◆ glsl_vertex_pipe_light()

◆ glsl_vertex_pipe_material()

◆ glsl_vertex_pipe_nop()

◆ glsl_vertex_pipe_pixel_shader()

◆ glsl_vertex_pipe_pointscale()

◆ glsl_vertex_pipe_pointsize()

◆ glsl_vertex_pipe_projection()

◆ glsl_vertex_pipe_shademode()

◆ glsl_vertex_pipe_shader()

◆ glsl_vertex_pipe_texmatrix()

◆ glsl_vertex_pipe_texmatrix_np2()

◆ glsl_vertex_pipe_vdecl()

◆ glsl_vertex_pipe_vertexblend()

◆ glsl_vertex_pipe_view()

◆ glsl_vertex_pipe_viewport()

◆ glsl_vertex_pipe_vp_alloc()

◆ glsl_vertex_pipe_vp_enable()

◆ glsl_vertex_pipe_vp_free()

◆ glsl_vertex_pipe_vp_get_caps()

◆ glsl_vertex_pipe_vp_get_emul_mask()