arb_program_shader.c File Reference

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

Include dependency graph for arb_program_shader.c:

Go to the source code of this file.

Classes
struct	control_frame
struct	arb_ps_np2fixup_info
struct	arb_ps_compile_args
struct	stb_const_desc
struct	arb_ps_compiled_shader
struct	arb_vs_compile_args
struct	arb_vs_compiled_shader
struct	recorded_instruction
struct	shader_arb_ctx_priv
struct	ps_signature
struct	arb_pshader_private
struct	arb_vshader_private
struct	shader_arb_priv
struct	color_fixup_masks
struct	arbfp_ffp_desc
struct	arbfp_blit_type
struct	arbfp_blit_desc
struct	wined3d_arbfp_blitter

Macros
#define	TEX_PROJ   0x1
#define	TEX_BIAS   0x2
#define	TEX_LOD   0x4
#define	TEX_DERIV   0x10
#define	ARB_FFP_CONST_TFACTOR   0
#define	ARB_FFP_CONST_COLOR_KEY_LOW   ((ARB_FFP_CONST_TFACTOR) + 1)
#define	ARB_FFP_CONST_COLOR_KEY_HIGH   ((ARB_FFP_CONST_COLOR_KEY_LOW) + 1)
#define	ARB_FFP_CONST_SPECULAR_ENABLE   ((ARB_FFP_CONST_COLOR_KEY_HIGH) + 1)
#define	ARB_FFP_CONST_CONSTANT(i)   ((ARB_FFP_CONST_SPECULAR_ENABLE) + 1 + i)
#define	ARB_FFP_CONST_BUMPMAT(i)   ((ARB_FFP_CONST_CONSTANT(7)) + 1 + i)
#define	ARB_FFP_CONST_LUMINANCE(i)   ((ARB_FFP_CONST_BUMPMAT(7)) + 1 + i)
#define	ARBFP_BLIT_PARAM_SIZE   0
#define	ARBFP_BLIT_PARAM_COLOR_KEY_LOW   1
#define	ARBFP_BLIT_PARAM_COLOR_KEY_HIGH   2

Enumerations
enum	arb_helper_value {   ARB_ZERO , ARB_ONE , ARB_TWO , ARB_0001 ,   ARB_EPS , ARB_VS_REL_OFFSET }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3d_shader)
	WINE_DECLARE_DEBUG_CHANNEL (d3d_constants)
	WINE_DECLARE_DEBUG_CHANNEL (d3d)
	WINE_DECLARE_DEBUG_CHANNEL (d3d_perf)
static BOOL	shader_is_pshader_version (enum wined3d_shader_type type)
static BOOL	shader_is_vshader_version (enum wined3d_shader_type type)
static const char *	get_line (const char **ptr)
static const char *	arb_get_helper_value (enum wined3d_shader_type shader, enum arb_helper_value value)
static BOOL	ffp_clip_emul (const struct wined3d_context *context)
static BOOL	need_rel_addr_const (const struct arb_vshader_private *shader_data, const struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_gl_info *gl_info)
static BOOL	use_nv_clip (const struct wined3d_gl_info *gl_info)
static BOOL	need_helper_const (const struct arb_vshader_private *shader_data, const struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_gl_info *gl_info)
static unsigned int	reserved_vs_const (const struct arb_vshader_private *shader_data, const struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_gl_info *gl_info)
static unsigned int	shader_arb_load_constants_f (const struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info, GLuint target_type, unsigned int max_constants, const struct wined3d_vec4 *constants, char *dirty_consts)
static void	shader_arb_load_np2fixup_constants (const struct arb_ps_np2fixup_info *fixup, const struct wined3d_gl_info *gl_info, const struct wined3d_state *state)
static void	shader_arb_ps_local_constants (const struct arb_ps_compiled_shader *gl_shader, const struct wined3d_context *context, const struct wined3d_state *state, UINT rt_height)
static void	shader_arb_vs_local_constants (const struct arb_vs_compiled_shader *gl_shader, const struct wined3d_context *context, const struct wined3d_state *state)
static void	shader_arb_select (void *shader_priv, struct wined3d_context *context, const struct wined3d_state *state)
static void	shader_arb_load_constants_internal (struct shader_arb_priv *priv, struct wined3d_context *context, const struct wined3d_state *state, BOOL usePixelShader, BOOL useVertexShader, BOOL from_shader_select)
static void	shader_arb_load_constants (void *shader_priv, struct wined3d_context *context, const struct wined3d_state *state)
static void	shader_arb_update_float_vertex_constants (struct wined3d_device *device, UINT start, UINT count)
static void	shader_arb_update_float_pixel_constants (struct wined3d_device *device, UINT start, UINT count)
static void	shader_arb_append_imm_vec4 (struct wined3d_string_buffer *buffer, const float *values)
static void	shader_generate_arb_declarations (const struct wined3d_shader *shader, const struct wined3d_shader_reg_maps *reg_maps, struct wined3d_string_buffer *buffer, const struct wined3d_gl_info *gl_info, DWORD *num_clipplanes, const struct shader_arb_ctx_priv *ctx)
static void	shader_arb_get_write_mask (const struct wined3d_shader_instruction *ins, const struct wined3d_shader_dst_param *dst, char *write_mask)
static void	shader_arb_get_swizzle (const struct wined3d_shader_src_param *param, BOOL fixup, char *swizzle_str)
static void	shader_arb_request_a0 (const struct wined3d_shader_instruction *ins, const char *src)
static void	shader_arb_get_src_param (const struct wined3d_shader_instruction *ins, const struct wined3d_shader_src_param *src, unsigned int tmpreg, char *outregstr)
static void	shader_arb_get_register_name (const struct wined3d_shader_instruction *ins, const struct wined3d_shader_register *reg, char *register_name, BOOL *is_color)
static void	shader_arb_get_dst_param (const struct wined3d_shader_instruction *ins, const struct wined3d_shader_dst_param *wined3d_dst, char *str)
static const char *	shader_arb_get_fixup_swizzle (enum fixup_channel_source channel_source)
static struct color_fixup_masks	calc_color_correction (struct color_fixup_desc fixup, DWORD dst_mask)
static void	gen_color_correction (struct wined3d_string_buffer *buffer, const char *dst, const char *src, const char *one, const char *two, struct color_fixup_desc fixup, struct color_fixup_masks masks)
static const char *	shader_arb_get_modifier (const struct wined3d_shader_instruction *ins)
static void	shader_hw_sample (const struct wined3d_shader_instruction *ins, DWORD sampler_idx, const char *dst_str, const char *coord_reg, WORD flags, const char *dsx, const char *dsy)
static void	pshader_hw_bem (const struct wined3d_shader_instruction *ins)
static DWORD	negate_modifiers (DWORD mod, char *extra_char)
static void	pshader_hw_cnd (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_cmp (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_dp2add (const struct wined3d_shader_instruction *ins)
static void	shader_hw_map2gl (const struct wined3d_shader_instruction *ins)
static void	shader_hw_nop (const struct wined3d_shader_instruction *ins)
static DWORD	shader_arb_select_component (DWORD swizzle, DWORD component)
static void	shader_hw_mov (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texkill (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_tex (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texcoord (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texreg2ar (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texreg2gb (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texreg2rgb (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texbem (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texm3x2pad (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texm3x2tex (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texm3x3pad (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texm3x3tex (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texm3x3vspec (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texm3x3spec (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texdepth (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texdp3tex (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texdp3 (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texm3x3 (const struct wined3d_shader_instruction *ins)
static void	pshader_hw_texm3x2depth (const struct wined3d_shader_instruction *ins)
static void	shader_hw_mnxn (const struct wined3d_shader_instruction *ins)
static DWORD	abs_modifier (DWORD mod, BOOL *need_abs)
static void	shader_hw_scalar_op (const struct wined3d_shader_instruction *ins)
static void	shader_hw_nrm (const struct wined3d_shader_instruction *ins)
static void	shader_hw_lrp (const struct wined3d_shader_instruction *ins)
static void	shader_hw_sincos (const struct wined3d_shader_instruction *ins)
static void	shader_hw_sgn (const struct wined3d_shader_instruction *ins)
static void	shader_hw_dsy (const struct wined3d_shader_instruction *ins)
static void	shader_hw_pow (const struct wined3d_shader_instruction *ins)
static void	shader_hw_loop (const struct wined3d_shader_instruction *ins)
static void	shader_hw_rep (const struct wined3d_shader_instruction *ins)
static void	shader_hw_endloop (const struct wined3d_shader_instruction *ins)
static void	shader_hw_endrep (const struct wined3d_shader_instruction *ins)
static const struct control_frame *	find_last_loop (const struct shader_arb_ctx_priv *priv)
static void	shader_hw_break (const struct wined3d_shader_instruction *ins)
static const char *	get_compare (enum wined3d_shader_rel_op op)
static enum wined3d_shader_rel_op	invert_compare (enum wined3d_shader_rel_op op)
static void	shader_hw_breakc (const struct wined3d_shader_instruction *ins)
static void	shader_hw_ifc (const struct wined3d_shader_instruction *ins)
static void	shader_hw_else (const struct wined3d_shader_instruction *ins)
static void	shader_hw_endif (const struct wined3d_shader_instruction *ins)
static void	shader_hw_texldd (const struct wined3d_shader_instruction *ins)
static void	shader_hw_texldl (const struct wined3d_shader_instruction *ins)
static void	shader_hw_label (const struct wined3d_shader_instruction *ins)
static void	vshader_add_footer (struct shader_arb_ctx_priv *priv_ctx, const struct arb_vshader_private *shader_data, const struct arb_vs_compile_args *args, const struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_gl_info *gl_info, struct wined3d_string_buffer *buffer)
static void	shader_hw_ret (const struct wined3d_shader_instruction *ins)
static void	shader_hw_call (const struct wined3d_shader_instruction *ins)
static BOOL	shader_arb_compile (const struct wined3d_gl_info *gl_info, GLenum target, const char *src)
static void	arbfp_add_sRGB_correction (struct wined3d_string_buffer *buffer, const char *fragcolor, const char *tmp1, const char *tmp2, const char *tmp3, const char *tmp4, BOOL condcode)
static const DWORD *	find_loop_control_values (const struct wined3d_shader *shader, DWORD idx)
static void	init_ps_input (const struct wined3d_shader *shader, const struct arb_ps_compile_args *args, struct shader_arb_ctx_priv *priv)
static void	arbfp_add_linear_fog (struct wined3d_string_buffer *buffer, const char *fragcolor, const char *tmp)
static GLuint	shader_arb_generate_pshader (const struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info, struct wined3d_string_buffer *buffer, const struct arb_ps_compile_args *args, struct arb_ps_compiled_shader *compiled)
static int	compare_sig (const struct wined3d_shader_signature *sig1, const struct wined3d_shader_signature *sig2)
static void	clone_sig (struct wined3d_shader_signature *new, const struct wined3d_shader_signature *sig)
static DWORD	find_input_signature (struct shader_arb_priv *priv, const struct wined3d_shader_signature *sig)
static void	init_output_registers (const struct wined3d_shader *shader, const struct wined3d_shader_signature *ps_input_sig, struct shader_arb_ctx_priv *priv_ctx, struct arb_vs_compiled_shader *compiled)
static GLuint	shader_arb_generate_vshader (const struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info, struct wined3d_string_buffer *buffer, const struct arb_vs_compile_args *args, struct arb_vs_compiled_shader *compiled, const struct wined3d_shader_signature *ps_input_sig)
static struct arb_ps_compiled_shader *	find_arb_pshader (struct wined3d_shader *shader, const struct arb_ps_compile_args *args)
static BOOL	vs_args_equal (const struct arb_vs_compile_args *stored, const struct arb_vs_compile_args *new, const DWORD use_map, BOOL skip_int)
static struct arb_vs_compiled_shader *	find_arb_vshader (struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info, DWORD use_map, const struct arb_vs_compile_args *args, const struct wined3d_shader_signature *ps_input_sig)
static void	find_arb_ps_compile_args (const struct wined3d_state *state, const struct wined3d_context *context, const struct wined3d_shader *shader, struct arb_ps_compile_args *args)
static void	find_arb_vs_compile_args (const struct wined3d_state *state, const struct wined3d_context *context, const struct wined3d_shader *shader, struct arb_vs_compile_args *args)
static void	shader_arb_select_compute (void *shader_priv, struct wined3d_context *context, const struct wined3d_state *state)
static void	shader_arb_disable (void *shader_priv, struct wined3d_context *context)
static void	shader_arb_destroy (struct wined3d_shader *shader)
static int	sig_tree_compare (const void *key, const struct wine_rb_entry *entry)
static HRESULT	shader_arb_alloc (struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe, const struct fragment_pipeline *fragment_pipe)
static void	release_signature (struct wine_rb_entry *entry, void *context)
static void	shader_arb_free (struct wined3d_device *device)
static BOOL	shader_arb_allocate_context_data (struct wined3d_context *context)
static void	shader_arb_free_context_data (struct wined3d_context *context)
static void	shader_arb_init_context_state (struct wined3d_context *context)
static void	shader_arb_get_caps (const struct wined3d_gl_info *gl_info, struct shader_caps *caps)
static BOOL	shader_arb_color_fixup_supported (struct color_fixup_desc fixup)
static void	shader_arb_add_instruction_modifiers (const struct wined3d_shader_instruction *ins)
static BOOL	get_bool_const (const struct wined3d_shader_instruction *ins, const struct wined3d_shader *shader, DWORD idx)
static void	get_loop_control_const (const struct wined3d_shader_instruction *ins, const struct wined3d_shader *shader, UINT idx, struct wined3d_shader_loop_control *loop_control)
static void	record_instruction (struct list *list, const struct wined3d_shader_instruction *ins)
static void	free_recorded_instruction (struct list *list)
static void	pop_control_frame (const struct wined3d_shader_instruction *ins)
static void	shader_arb_handle_instruction (const struct wined3d_shader_instruction *ins)
static BOOL	shader_arb_has_ffp_proj_control (void *shader_priv)
static void	shader_arb_precompile (void *shader_priv, struct wined3d_shader *shader)
static void	arbfp_enable (const struct wined3d_gl_info *gl_info, BOOL enable)
static void *	arbfp_alloc (const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv)
static void	arbfp_free_ffpshader (struct wine_rb_entry *entry, void *context)
static void	arbfp_free (struct wined3d_device *device)
static void	arbfp_get_caps (const struct wined3d_gl_info *gl_info, struct fragment_caps *caps)
static DWORD	arbfp_get_emul_mask (const struct wined3d_gl_info *gl_info)
static void	state_texfactor_arbfp (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static void	state_tss_constant_arbfp (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static void	state_arb_specularenable (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static void	set_bumpmat_arbfp (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static void	tex_bumpenvlum_arbfp (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static void	alpha_test_arbfp (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static void	color_key_arbfp (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static const char *	get_argreg (struct wined3d_string_buffer *buffer, DWORD argnum, unsigned int stage, DWORD arg)
static void	gen_ffp_instr (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 const char *	arbfp_texture_target (enum wined3d_gl_resource_type type)
static GLuint	gen_arbfp_ffp_shader (const struct ffp_frag_settings *settings, const struct wined3d_gl_info *gl_info)
static void	fragment_prog_arbfp (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static void	state_arbfp_fog (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static void	textransform (struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
static BOOL	arbfp_alloc_context_data (struct wined3d_context *context)
static void	arbfp_free_context_data (struct wined3d_context *context)
static int	arbfp_blit_type_compare (const void *key, const struct wine_rb_entry *entry)
static void	arbfp_free_blit_shader (struct wine_rb_entry *entry, void *ctx)
static void	arbfp_blitter_destroy (struct wined3d_blitter *blitter, struct wined3d_context *context)
static BOOL	gen_planar_yuv_read (struct wined3d_string_buffer *buffer, const struct arbfp_blit_type *type, char *luminance)
static BOOL	gen_yv12_read (struct wined3d_string_buffer *buffer, const struct arbfp_blit_type *type, char *luminance)
static BOOL	gen_nv12_read (struct wined3d_string_buffer *buffer, const struct arbfp_blit_type *type, char *luminance)
static GLuint	gen_p8_shader (const struct wined3d_gl_info *gl_info, const struct arbfp_blit_type *type)
static void	upload_palette (struct wined3d_arbfp_blitter *blitter, const struct wined3d_texture *texture, struct wined3d_context *context)
static GLuint	gen_yuv_shader (const struct wined3d_gl_info *gl_info, const struct arbfp_blit_type *type)
static GLuint	arbfp_gen_plain_shader (const struct wined3d_gl_info *gl_info, const struct arbfp_blit_type *type)
static HRESULT	arbfp_blit_set (struct wined3d_arbfp_blitter *blitter, struct wined3d_context *context, const struct wined3d_texture *texture, unsigned int sub_resource_idx, const struct wined3d_color_key *color_key)
static void	arbfp_blit_unset (const struct wined3d_gl_info *gl_info)
static BOOL	arbfp_blit_supported (enum wined3d_blit_op blit_op, const struct wined3d_context *context, const struct wined3d_resource *src_resource, DWORD src_location, const struct wined3d_resource *dst_resource, DWORD dst_location)
static DWORD	arbfp_blitter_blit (struct wined3d_blitter *blitter, enum wined3d_blit_op op, struct wined3d_context *context, struct wined3d_surface *src_surface, DWORD src_location, const RECT *src_rect, struct wined3d_surface *dst_surface, DWORD dst_location, const RECT *dst_rect, const struct wined3d_color_key *color_key, enum wined3d_texture_filter_type filter)
static void	arbfp_blitter_clear (struct wined3d_blitter *blitter, struct wined3d_device *device, unsigned int rt_count, const struct wined3d_fb_state *fb, unsigned int rect_count, const RECT *clear_rects, const RECT *draw_rect, DWORD flags, const struct wined3d_color *colour, float depth, DWORD stencil)
void	wined3d_arbfp_blitter_create (struct wined3d_blitter **next, const struct wined3d_device *device)

Variables
static const char *const	shift_tab []
static const SHADER_HANDLER	shader_arb_instruction_handler_table [WINED3DSIH_TABLE_SIZE]
const struct wined3d_shader_backend_ops	arb_program_shader_backend
static const struct StateEntryTemplate	arbfp_fragmentstate_template []
const struct fragment_pipeline	arbfp_fragment_pipeline
static const struct wined3d_blitter_ops	arbfp_blitter_ops

Macro Definition Documentation

ARB_FFP_CONST_BUMPMAT

#define ARB_FFP_CONST_BUMPMAT

(

i

)

((ARB_FFP_CONST_CONSTANT(7)) + 1 + i)

Definition at line 5694 of file arb_program_shader.c.

ARB_FFP_CONST_COLOR_KEY_HIGH

#define ARB_FFP_CONST_COLOR_KEY_HIGH   ((ARB_FFP_CONST_COLOR_KEY_LOW) + 1)

Definition at line 5691 of file arb_program_shader.c.

ARB_FFP_CONST_COLOR_KEY_LOW

#define ARB_FFP_CONST_COLOR_KEY_LOW   ((ARB_FFP_CONST_TFACTOR) + 1)

Definition at line 5690 of file arb_program_shader.c.

ARB_FFP_CONST_CONSTANT

#define ARB_FFP_CONST_CONSTANT

(

i

)

((ARB_FFP_CONST_SPECULAR_ENABLE) + 1 + i)

Definition at line 5693 of file arb_program_shader.c.

ARB_FFP_CONST_LUMINANCE

#define ARB_FFP_CONST_LUMINANCE

(

i

)

((ARB_FFP_CONST_BUMPMAT(7)) + 1 + i)

Definition at line 5695 of file arb_program_shader.c.

ARB_FFP_CONST_SPECULAR_ENABLE

#define ARB_FFP_CONST_SPECULAR_ENABLE   ((ARB_FFP_CONST_COLOR_KEY_HIGH) + 1)

Definition at line 5692 of file arb_program_shader.c.

ARB_FFP_CONST_TFACTOR

#define ARB_FFP_CONST_TFACTOR   0

Definition at line 5689 of file arb_program_shader.c.

ARBFP_BLIT_PARAM_COLOR_KEY_HIGH

#define ARBFP_BLIT_PARAM_COLOR_KEY_HIGH   2

Definition at line 6878 of file arb_program_shader.c.

ARBFP_BLIT_PARAM_COLOR_KEY_LOW

#define ARBFP_BLIT_PARAM_COLOR_KEY_LOW   1

Definition at line 6877 of file arb_program_shader.c.

ARBFP_BLIT_PARAM_SIZE

#define ARBFP_BLIT_PARAM_SIZE   0

Definition at line 6876 of file arb_program_shader.c.

TEX_BIAS

#define TEX_BIAS   0x2

Definition at line 1405 of file arb_program_shader.c.

TEX_DERIV

#define TEX_DERIV   0x10

Definition at line 1407 of file arb_program_shader.c.

TEX_LOD

#define TEX_LOD   0x4

Definition at line 1406 of file arb_program_shader.c.

TEX_PROJ

#define TEX_PROJ   0x1

Definition at line 1404 of file arb_program_shader.c.

Enumeration Type Documentation

arb_helper_value

enum arb_helper_value

Enumerator
ARB_ZERO
ARB_ONE
ARB_TWO
ARB_0001
ARB_EPS
ARB_VS_REL_OFFSET

Definition at line 68 of file arb_program_shader.c.

{
    ARB_ZERO,
    ARB_ONE,
    ARB_TWO,
    ARB_0001,
    ARB_EPS,
 
    ARB_VS_REL_OFFSET
};

Function Documentation

abs_modifier()

static DWORD abs_modifier ( DWORD  mod, BOOL *  need_abs  )

static

Definition at line 2511 of file arb_program_shader.c.

{
    *need_abs = FALSE;
 
    switch(mod)
    {
        case WINED3DSPSM_NONE:      return WINED3DSPSM_ABS;
        case WINED3DSPSM_NEG:       return WINED3DSPSM_ABS;
        case WINED3DSPSM_BIAS:      *need_abs = TRUE; return WINED3DSPSM_BIAS;
        case WINED3DSPSM_BIASNEG:   *need_abs = TRUE; return WINED3DSPSM_BIASNEG;
        case WINED3DSPSM_SIGN:      *need_abs = TRUE; return WINED3DSPSM_SIGN;
        case WINED3DSPSM_SIGNNEG:   *need_abs = TRUE; return WINED3DSPSM_SIGNNEG;
        case WINED3DSPSM_COMP:      *need_abs = TRUE; return WINED3DSPSM_COMP;
        case WINED3DSPSM_X2:        *need_abs = TRUE; return WINED3DSPSM_X2;
        case WINED3DSPSM_X2NEG:     *need_abs = TRUE; return WINED3DSPSM_X2NEG;
        case WINED3DSPSM_DZ:        *need_abs = TRUE; return WINED3DSPSM_DZ;
        case WINED3DSPSM_DW:        *need_abs = TRUE; return WINED3DSPSM_DW;
        case WINED3DSPSM_ABS:       return WINED3DSPSM_ABS;
        case WINED3DSPSM_ABSNEG:    return WINED3DSPSM_ABS;
    }
    FIXME("Unknown modifier %u\n", mod);
    return mod;
}

Referenced by shader_hw_pow(), and shader_hw_scalar_op().

alpha_test_arbfp()

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

static

Definition at line 5953 of file arb_program_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
    int glParm;
    float ref;
 
    TRACE("context %p, state %p, state_id %#x.\n", context, state, state_id);
 
    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");
        return;
    }
 
    ref = ((float)state->render_states[WINED3D_RS_ALPHAREF]) / 255.0f;
    glParm = wined3d_gl_compare_func(state->render_states[WINED3D_RS_ALPHAFUNC]);
 
    if (glParm)
    {
        gl_info->gl_ops.gl.p_glAlphaFunc(glParm, ref);
        checkGLcall("glAlphaFunc");
    }
}

arb_get_helper_value()

static const char * arb_get_helper_value ( enum wined3d_shader_type  shader, enum arb_helper_value  value  )

static

Definition at line 79 of file arb_program_shader.c.

{
    if (shader != WINED3D_SHADER_TYPE_VERTEX && shader != WINED3D_SHADER_TYPE_PIXEL)
    {
        ERR("Unsupported shader type '%s'.\n", debug_shader_type(shader));
        return "bad";
    }
 
    if (shader == WINED3D_SHADER_TYPE_PIXEL)
    {
        switch (value)
        {
            case ARB_ZERO: return "ps_helper_const.x";
            case ARB_ONE: return "ps_helper_const.y";
            case ARB_TWO: return "coefmul.x";
            case ARB_0001: return "ps_helper_const.xxxy";
            case ARB_EPS: return "ps_helper_const.z";
            default: break;
        }
    }
    else
    {
        switch (value)
        {
            case ARB_ZERO: return "helper_const.x";
            case ARB_ONE: return "helper_const.y";
            case ARB_TWO: return "helper_const.z";
            case ARB_EPS: return "helper_const.w";
            case ARB_0001: return "helper_const.xxxy";
            case ARB_VS_REL_OFFSET: return "rel_addr_const.y";
        }
    }
    FIXME("Unmanaged %s shader helper constant requested: %u.\n",
          shader == WINED3D_SHADER_TYPE_PIXEL ? "pixel" : "vertex", value);
    switch (value)
    {
        case ARB_ZERO: return "0.0";
        case ARB_ONE: return "1.0";
        case ARB_TWO: return "2.0";
        case ARB_0001: return "{0.0, 0.0, 0.0, 1.0}";
        case ARB_EPS: return "1e-8";
        default: return "bad";
    }
}

Referenced by pshader_hw_texdepth(), pshader_hw_texm3x2depth(), shader_arb_generate_vshader(), shader_arb_get_src_param(), shader_hw_mov(), shader_hw_nrm(), shader_hw_pow(), shader_hw_sample(), and vshader_add_footer().

arbfp_add_linear_fog()

static void arbfp_add_linear_fog ( struct wined3d_string_buffer *  buffer, const char *  fragcolor, const char *  tmp  )

static

Definition at line 3495 of file arb_program_shader.c.

{
    shader_addline(buffer, "SUB %s.x, state.fog.params.z, fragment.fogcoord.x;\n", tmp);
    shader_addline(buffer, "MUL_SAT %s.x, %s.x, state.fog.params.w;\n", tmp, tmp);
    shader_addline(buffer, "LRP %s.rgb, %s.x, %s, state.fog.color;\n", fragcolor, tmp, fragcolor);
}

Referenced by gen_arbfp_ffp_shader(), and shader_arb_generate_pshader().

arbfp_add_sRGB_correction()

static void arbfp_add_sRGB_correction ( struct wined3d_string_buffer *  buffer, const char *  fragcolor, const char *  tmp1, const char *  tmp2, const char *  tmp3, const char *  tmp4, BOOL  condcode  )

static

Definition at line 3354 of file arb_program_shader.c.

{
    /* Perform sRGB write correction. See GLX_EXT_framebuffer_sRGB */
 
    if(condcode)
    {
        /* Sigh. MOVC CC doesn't work, so use one of the temps as dummy dest */
        shader_addline(buffer, "SUBC %s, %s.x, srgb_consts1.x;\n", tmp1, fragcolor);
        /* Calculate the > 0.0031308 case */
        shader_addline(buffer, "POW %s.x (GE), %s.x, srgb_consts0.x;\n", fragcolor, fragcolor);
        shader_addline(buffer, "POW %s.y (GE), %s.y, srgb_consts0.x;\n", fragcolor, fragcolor);
        shader_addline(buffer, "POW %s.z (GE), %s.z, srgb_consts0.x;\n", fragcolor, fragcolor);
        shader_addline(buffer, "MUL %s.xyz (GE), %s, srgb_consts0.y;\n", fragcolor, fragcolor);
        shader_addline(buffer, "SUB %s.xyz (GE), %s, srgb_consts0.z;\n", fragcolor, fragcolor);
        /* Calculate the < case */
        shader_addline(buffer, "MUL %s.xyz (LT), srgb_consts0.w, %s;\n", fragcolor, fragcolor);
    }
    else
    {
        /* Calculate the > 0.0031308 case */
        shader_addline(buffer, "POW %s.x, %s.x, srgb_consts0.x;\n", tmp1, fragcolor);
        shader_addline(buffer, "POW %s.y, %s.y, srgb_consts0.x;\n", tmp1, fragcolor);
        shader_addline(buffer, "POW %s.z, %s.z, srgb_consts0.x;\n", tmp1, fragcolor);
        shader_addline(buffer, "MUL %s, %s, srgb_consts0.y;\n", tmp1, tmp1);
        shader_addline(buffer, "SUB %s, %s, srgb_consts0.z;\n", tmp1, tmp1);
        /* Calculate the < case */
        shader_addline(buffer, "MUL %s, srgb_consts0.w, %s;\n", tmp2, fragcolor);
        /* Get 1.0 / 0.0 masks for > 0.0031308 and < 0.0031308 */
        shader_addline(buffer, "SLT %s, srgb_consts1.x, %s;\n", tmp3, fragcolor);
        shader_addline(buffer, "SGE %s, srgb_consts1.x, %s;\n", tmp4, fragcolor);
        /* Store the components > 0.0031308 in the destination */
        shader_addline(buffer, "MUL %s.xyz, %s, %s;\n", fragcolor, tmp1, tmp3);
        /* Add the components that are < 0.0031308 */
        shader_addline(buffer, "MAD %s.xyz, %s, %s, %s;\n", fragcolor, tmp2, tmp4, fragcolor);
        /* Move everything into result.color at once. Nvidia hardware cannot handle partial
        * result.color writes(.rgb first, then .a), or handle overwriting already written
        * components. The assembler uses a temporary register in this case, which is usually
        * not allocated from one of our registers that were used earlier.
        */
    }
    /* [0.0;1.0] clamping. Not needed, this is done implicitly */
}

Referenced by gen_arbfp_ffp_shader(), and shader_arb_generate_pshader().

arbfp_alloc()

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

static

Definition at line 5718 of file arb_program_shader.c.

{
    struct shader_arb_priv *priv;
 
    /* Share private data between the shader backend and the pipeline
     * replacement, if both are the arb implementation. This is needed to
     * figure out whether ARBfp should be disabled if no pixel shader is bound
     * or not. */
    if (shader_backend == &arb_program_shader_backend)
        priv = shader_priv;
    else if (!(priv = heap_alloc_zero(sizeof(*priv))))
        return NULL;
 
    wine_rb_init(&priv->fragment_shaders, wined3d_ffp_frag_program_key_compare);
    priv->use_arbfp_fixed_func = TRUE;
 
    return priv;
}

arbfp_alloc_context_data()

static BOOL arbfp_alloc_context_data ( struct wined3d_context *  context )

static

Definition at line 6840 of file arb_program_shader.c.

{
    return TRUE;
}

arbfp_blit_set()

static HRESULT arbfp_blit_set ( struct wined3d_arbfp_blitter *  blitter, struct wined3d_context *  context, const struct wined3d_texture *  texture, unsigned int  sub_resource_idx, const struct wined3d_color_key *  color_key  )

static

Definition at line 7569 of file arb_program_shader.c.

{
    enum complex_fixup fixup;
    const struct wined3d_gl_info *gl_info = context->gl_info;
    struct wine_rb_entry *entry;
    struct arbfp_blit_type type;
    struct arbfp_blit_desc *desc;
    struct wined3d_color float_color_key[2];
    struct wined3d_vec4 size;
    unsigned int level;
    GLuint shader;
 
    level = sub_resource_idx % texture->level_count;
    size.x = wined3d_texture_get_level_pow2_width(texture, level);
    size.y = wined3d_texture_get_level_pow2_height(texture, level);
    size.z = 1.0f;
    size.w = 1.0f;
 
    if (is_complex_fixup(texture->resource.format->color_fixup))
        fixup = get_complex_fixup(texture->resource.format->color_fixup);
    else
        fixup = COMPLEX_FIXUP_NONE;
 
    switch (texture->target)
    {
        case GL_TEXTURE_1D:
            type.res_type = WINED3D_GL_RES_TYPE_TEX_1D;
            break;
 
        case GL_TEXTURE_2D:
            type.res_type = WINED3D_GL_RES_TYPE_TEX_2D;
            break;
 
        case GL_TEXTURE_3D:
            type.res_type = WINED3D_GL_RES_TYPE_TEX_3D;
            break;
 
        case GL_TEXTURE_CUBE_MAP_ARB:
            type.res_type = WINED3D_GL_RES_TYPE_TEX_CUBE;
            break;
 
        case GL_TEXTURE_RECTANGLE_ARB:
            type.res_type = WINED3D_GL_RES_TYPE_TEX_RECT;
            break;
 
        default:
            ERR("Unexpected GL texture type %#x.\n", texture->target);
            type.res_type = WINED3D_GL_RES_TYPE_TEX_2D;
    }
    type.fixup = fixup;
    type.use_color_key = !!color_key;
    type.padding = 0;
 
    if ((entry = wine_rb_get(&blitter->shaders, &type)))
    {
        desc = WINE_RB_ENTRY_VALUE(entry, struct arbfp_blit_desc, entry);
        shader = desc->shader;
    }
    else
    {
        switch (fixup)
        {
            case COMPLEX_FIXUP_NONE:
                if (!is_identity_fixup(texture->resource.format->color_fixup))
                    FIXME("Implement support for sign or swizzle fixups.\n");
                shader = arbfp_gen_plain_shader(gl_info, &type);
                break;
 
            case COMPLEX_FIXUP_P8:
                shader = gen_p8_shader(gl_info, &type);
                break;
 
            case COMPLEX_FIXUP_YUY2:
            case COMPLEX_FIXUP_UYVY:
            case COMPLEX_FIXUP_YV12:
            case COMPLEX_FIXUP_NV12:
                shader = gen_yuv_shader(gl_info, &type);
                break;
        }
 
        if (!shader)
        {
            FIXME("Unsupported complex fixup %#x, not setting a shader\n", fixup);
            return E_NOTIMPL;
        }
 
        if (!(desc = heap_alloc(sizeof(*desc))))
            goto err_out;
 
        desc->type = type;
        desc->shader = shader;
        if (wine_rb_put(&blitter->shaders, &desc->type, &desc->entry) == -1)
        {
err_out:
            ERR("Out of memory\n");
            GL_EXTCALL(glDeleteProgramsARB(1, &shader));
            checkGLcall("GL_EXTCALL(glDeleteProgramsARB(1, &shader))");
            GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0));
            checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0)");
            heap_free(desc);
            return E_OUTOFMEMORY;
        }
    }
 
    if (fixup == COMPLEX_FIXUP_P8)
        upload_palette(blitter, texture, context);
 
    gl_info->gl_ops.gl.p_glEnable(GL_FRAGMENT_PROGRAM_ARB);
    checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB)");
    GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader));
    checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader)");
    GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARBFP_BLIT_PARAM_SIZE, &size.x));
    checkGLcall("glProgramLocalParameter4fvARB");
    if (type.use_color_key)
    {
        wined3d_format_get_float_color_key(texture->resource.format, color_key, float_color_key);
        GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
                ARBFP_BLIT_PARAM_COLOR_KEY_LOW, &float_color_key[0].r));
        GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
                ARBFP_BLIT_PARAM_COLOR_KEY_HIGH, &float_color_key[1].r));
        checkGLcall("glProgramLocalParameter4fvARB");
    }
 
    return WINED3D_OK;
}

Referenced by arbfp_blitter_blit().

arbfp_blit_supported()

static BOOL arbfp_blit_supported ( enum wined3d_blit_op  blit_op, const struct wined3d_context *  context, const struct wined3d_resource *  src_resource, DWORD  src_location, const struct wined3d_resource *  dst_resource, DWORD  dst_location  )

static

Definition at line 7704 of file arb_program_shader.c.

{
    const struct wined3d_format *src_format = src_resource->format;
    const struct wined3d_format *dst_format = dst_resource->format;
    enum complex_fixup src_fixup;
    BOOL decompress;
 
    if (!context->gl_info->supported[ARB_FRAGMENT_PROGRAM])
        return FALSE;
 
    if (blit_op == WINED3D_BLIT_OP_RAW_BLIT && dst_format->id == src_format->id)
    {
        if (dst_format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
            blit_op = WINED3D_BLIT_OP_DEPTH_BLIT;
        else
            blit_op = WINED3D_BLIT_OP_COLOR_BLIT;
    }
 
    switch (blit_op)
    {
        case WINED3D_BLIT_OP_COLOR_BLIT_CKEY:
            if (!context->d3d_info->shader_color_key)
            {
                /* The conversion modifies the alpha channel so the color key might no longer match. */
                TRACE("Color keying not supported with converted textures.\n");
                return FALSE;
            }
        case WINED3D_BLIT_OP_COLOR_BLIT_ALPHATEST:
        case WINED3D_BLIT_OP_COLOR_BLIT:
            break;
 
        default:
            TRACE("Unsupported blit_op=%d\n", blit_op);
            return FALSE;
    }
 
    decompress = src_format && (src_format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED)
            && !(dst_format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED);
    if (!decompress && !(src_resource->access & dst_resource->access & WINED3D_RESOURCE_ACCESS_GPU))
        return FALSE;
 
    src_fixup = get_complex_fixup(src_format->color_fixup);
    if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
    {
        TRACE("Checking support for fixup:\n");
        dump_color_fixup_desc(src_format->color_fixup);
    }
 
    if (!is_identity_fixup(dst_format->color_fixup)
            && (dst_format->id != src_format->id || dst_location != WINED3D_LOCATION_DRAWABLE))
    {
        TRACE("Destination fixups are not supported\n");
        return FALSE;
    }
 
    if (is_identity_fixup(src_format->color_fixup))
    {
        TRACE("[OK]\n");
        return TRUE;
    }
 
     /* We only support YUV conversions. */
    if (!is_complex_fixup(src_format->color_fixup))
    {
        if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
        {
            WARN("Claiming fixup support because of ORM_BACKBUFFER.\n");
            return TRUE;
        }
 
        TRACE("[FAILED]\n");
        return FALSE;
    }
 
    switch(src_fixup)
    {
        case COMPLEX_FIXUP_YUY2:
        case COMPLEX_FIXUP_UYVY:
        case COMPLEX_FIXUP_YV12:
        case COMPLEX_FIXUP_NV12:
        case COMPLEX_FIXUP_P8:
            TRACE("[OK]\n");
            return TRUE;
 
        default:
            FIXME("Unsupported YUV fixup %#x\n", src_fixup);
            TRACE("[FAILED]\n");
            return FALSE;
    }
}

Referenced by arbfp_blitter_blit().

arbfp_blit_type_compare()

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

static

Definition at line 6887 of file arb_program_shader.c.

{
    const struct arbfp_blit_type *ka = key;
    const struct arbfp_blit_type *kb = &WINE_RB_ENTRY_VALUE(entry, const struct arbfp_blit_desc, entry)->type;
 
    return memcmp(ka, kb, sizeof(*ka));
}

Referenced by wined3d_arbfp_blitter_create().

arbfp_blit_unset()

static void arbfp_blit_unset ( const struct wined3d_gl_info *  gl_info )

static

Definition at line 7698 of file arb_program_shader.c.

{
    gl_info->gl_ops.gl.p_glDisable(GL_FRAGMENT_PROGRAM_ARB);
    checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
}

Referenced by arbfp_blitter_blit().

arbfp_blitter_blit()

static DWORD arbfp_blitter_blit ( struct wined3d_blitter *  blitter, enum wined3d_blit_op  op, struct wined3d_context *  context, struct wined3d_surface *  src_surface, DWORD  src_location, const RECT *  src_rect, struct wined3d_surface *  dst_surface, DWORD  dst_location, const RECT *  dst_rect, const struct wined3d_color_key *  color_key, enum wined3d_texture_filter_type  filter  )

static

Definition at line 7797 of file arb_program_shader.c.

{
    unsigned int src_sub_resource_idx = surface_get_sub_resource_idx(src_surface);
    struct wined3d_texture *src_texture = src_surface->container;
    struct wined3d_texture *dst_texture = dst_surface->container;
    struct wined3d_device *device = dst_texture->resource.device;
    struct wined3d_arbfp_blitter *arbfp_blitter;
    struct wined3d_color_key alpha_test_key;
    struct wined3d_blitter *next;
    RECT s, d;
 
    if (!arbfp_blit_supported(op, context, &src_texture->resource, src_location,
            &dst_texture->resource, dst_location))
    {
        if ((next = blitter->next))
            return next->ops->blitter_blit(next, op, context, src_surface, src_location,
                    src_rect, dst_surface, dst_location, dst_rect, color_key, filter);
    }
 
    arbfp_blitter = CONTAINING_RECORD(blitter, struct wined3d_arbfp_blitter, blitter);
 
    /* Now load the surface */
    if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
            && (surface_get_sub_resource(src_surface)->locations
            & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_DRAWABLE))
            == WINED3D_LOCATION_DRAWABLE
            && !wined3d_resource_is_offscreen(&src_texture->resource))
    {
        unsigned int src_level = src_sub_resource_idx % src_texture->level_count;
 
        /* Without FBO blits transferring from the drawable to the texture is
         * expensive, because we have to flip the data in sysmem. Since we can
         * flip in the blitter, we don't actually need that flip anyway. So we
         * use the surface's texture as scratch texture, and flip the source
         * rectangle instead. */
        surface_load_fb_texture(src_surface, FALSE, context);
 
        s = *src_rect;
        s.top = wined3d_texture_get_level_height(src_texture, src_level) - s.top;
        s.bottom = wined3d_texture_get_level_height(src_texture, src_level) - s.bottom;
        src_rect = &s;
    }
    else
        wined3d_texture_load(src_texture, context, FALSE);
 
    context_apply_blit_state(context, device);
 
    if (dst_location == WINED3D_LOCATION_DRAWABLE)
    {
        d = *dst_rect;
        surface_translate_drawable_coords(dst_surface, context->win_handle, &d);
        dst_rect = &d;
    }
 
    if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
    {
        GLenum buffer;
 
        if (dst_location == WINED3D_LOCATION_DRAWABLE)
        {
            TRACE("Destination surface %p is onscreen.\n", dst_surface);
            buffer = wined3d_texture_get_gl_buffer(dst_texture);
        }
        else
        {
            TRACE("Destination surface %p is offscreen.\n", dst_surface);
            buffer = GL_COLOR_ATTACHMENT0;
        }
        context_apply_fbo_state_blit(context, GL_DRAW_FRAMEBUFFER, dst_surface, NULL, dst_location);
        context_set_draw_buffer(context, buffer);
        context_check_fbo_status(context, GL_DRAW_FRAMEBUFFER);
        context_invalidate_state(context, STATE_FRAMEBUFFER);
    }
 
    if (op == WINED3D_BLIT_OP_COLOR_BLIT_ALPHATEST)
    {
        const struct wined3d_format *fmt = src_texture->resource.format;
        alpha_test_key.color_space_low_value = 0;
        alpha_test_key.color_space_high_value = ~(((1u << fmt->alpha_size) - 1) << fmt->alpha_offset);
        color_key = &alpha_test_key;
    }
 
    arbfp_blit_set(arbfp_blitter, context, src_texture, src_sub_resource_idx, color_key);
 
    /* Draw a textured quad */
    draw_textured_quad(src_texture, src_sub_resource_idx, context, src_rect, dst_rect, filter);
 
    /* Leave the opengl state valid for blitting */
    arbfp_blit_unset(context->gl_info);
 
    if (wined3d_settings.strict_draw_ordering
            || (dst_texture->swapchain && (dst_texture->swapchain->front_buffer == dst_texture)))
        context->gl_info->gl_ops.gl.p_glFlush(); /* Flush to ensure ordering across contexts. */
 
    return dst_location;
}

arbfp_blitter_clear()

static void arbfp_blitter_clear ( struct wined3d_blitter *  blitter, struct wined3d_device *  device, unsigned int  rt_count, const struct wined3d_fb_state *  fb, unsigned int  rect_count, const RECT *  clear_rects, const RECT *  draw_rect, DWORD  flags, const struct wined3d_color *  colour, float  depth, DWORD  stencil  )

static

Definition at line 7897 of file arb_program_shader.c.

{
    struct wined3d_blitter *next;
 
    if ((next = blitter->next))
        next->ops->blitter_clear(next, device, rt_count, fb, rect_count,
                clear_rects, draw_rect, flags, colour, depth, stencil);
}

arbfp_blitter_destroy()

static void arbfp_blitter_destroy ( struct wined3d_blitter *  blitter, struct wined3d_context *  context  )

static

Definition at line 6911 of file arb_program_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
    struct wined3d_arbfp_blitter *arbfp_blitter;
    struct wined3d_blitter *next;
 
    if ((next = blitter->next))
        next->ops->blitter_destroy(next, context);
 
    arbfp_blitter = CONTAINING_RECORD(blitter, struct wined3d_arbfp_blitter, blitter);
 
    wine_rb_destroy(&arbfp_blitter->shaders, arbfp_free_blit_shader, context);
    checkGLcall("Delete blit programs");
 
    if (arbfp_blitter->palette_texture)
        gl_info->gl_ops.gl.p_glDeleteTextures(1, &arbfp_blitter->palette_texture);
 
    heap_free(arbfp_blitter);
}

arbfp_enable()

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

static

Definition at line 5704 of file arb_program_shader.c.

{
    if (enable)
    {
        gl_info->gl_ops.gl.p_glEnable(GL_FRAGMENT_PROGRAM_ARB);
        checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB)");
    }
    else
    {
        gl_info->gl_ops.gl.p_glDisable(GL_FRAGMENT_PROGRAM_ARB);
        checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
    }
}

arbfp_free()

static void arbfp_free ( struct wined3d_device *  device )

static

Definition at line 5749 of file arb_program_shader.c.

{
    struct shader_arb_priv *priv = device->fragment_priv;
 
    wine_rb_destroy(&priv->fragment_shaders, arbfp_free_ffpshader, &device->adapter->gl_info);
    priv->use_arbfp_fixed_func = FALSE;
 
    if (device->shader_backend != &arb_program_shader_backend)
        heap_free(device->fragment_priv);
}

arbfp_free_blit_shader()

static void arbfp_free_blit_shader ( struct wine_rb_entry *  entry, void *  ctx  )

static

Definition at line 6896 of file arb_program_shader.c.

{
    struct arbfp_blit_desc *entry_arb = WINE_RB_ENTRY_VALUE(entry, struct arbfp_blit_desc, entry);
    const struct wined3d_gl_info *gl_info;
    struct wined3d_context *context;
 
    context = ctx;
    gl_info = context->gl_info;
 
    GL_EXTCALL(glDeleteProgramsARB(1, &entry_arb->shader));
    checkGLcall("glDeleteProgramsARB(1, &entry_arb->shader)");
    heap_free(entry_arb);
}

Referenced by arbfp_blitter_destroy().

arbfp_free_context_data()

static void arbfp_free_context_data ( struct wined3d_context *  context )

static

Definition at line 6845 of file arb_program_shader.c.

{
}

arbfp_free_ffpshader()

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

static

Definition at line 5738 of file arb_program_shader.c.

{
    const struct wined3d_gl_info *gl_info = context;
    struct arbfp_ffp_desc *entry_arb = WINE_RB_ENTRY_VALUE(entry, struct arbfp_ffp_desc, parent.entry);
 
    GL_EXTCALL(glDeleteProgramsARB(1, &entry_arb->shader));
    checkGLcall("glDeleteProgramsARB(1, &entry_arb->shader)");
    heap_free(entry_arb);
}

Referenced by arbfp_free().

arbfp_gen_plain_shader()

static GLuint arbfp_gen_plain_shader ( const struct wined3d_gl_info *  gl_info, const struct arbfp_blit_type *  type  )

static

Definition at line 7516 of file arb_program_shader.c.

{
    GLuint shader;
    struct wined3d_string_buffer buffer;
    const char *tex_target = arbfp_texture_target(type->res_type);
 
    /* Shader header */
    if (!string_buffer_init(&buffer))
    {
        ERR("Failed to initialize shader buffer.\n");
        return 0;
    }
 
    GL_EXTCALL(glGenProgramsARB(1, &shader));
    if (!shader)
    {
        string_buffer_free(&buffer);
        return 0;
    }
    GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader));
 
    shader_addline(&buffer, "!!ARBfp1.0\n");
 
    if (type->use_color_key)
    {
        shader_addline(&buffer, "TEMP color;\n");
        shader_addline(&buffer, "TEMP less, greater;\n");
        shader_addline(&buffer, "PARAM color_key_low = program.local[%u];\n", ARBFP_BLIT_PARAM_COLOR_KEY_LOW);
        shader_addline(&buffer, "PARAM color_key_high = program.local[%u];\n", ARBFP_BLIT_PARAM_COLOR_KEY_HIGH);
        shader_addline(&buffer, "TEX color, fragment.texcoord[0], texture[0], %s;\n", tex_target);
        shader_addline(&buffer, "SLT less, color, color_key_low;\n"); /* below low key */
        shader_addline(&buffer, "SGE greater, color, color_key_high;\n"); /* above high key */
        shader_addline(&buffer, "ADD less, less, greater;\n"); /* or */
        shader_addline(&buffer, "DP4 less.b, less, less;\n"); /* on any channel */
        shader_addline(&buffer, "SGE less, -less.b, 0.0;\n"); /* logical not */
        shader_addline(&buffer, "KIL -less;\n"); /* discard if true */
        shader_addline(&buffer, "MOV result.color, color;\n");
    }
    else
    {
        shader_addline(&buffer, "TEX result.color, fragment.texcoord[0], texture[0], %s;\n", tex_target);
    }
 
    shader_addline(&buffer, "END\n");
 
    shader_arb_compile(gl_info, GL_FRAGMENT_PROGRAM_ARB, buffer.buffer);
 
    string_buffer_free(&buffer);
 
    return shader;
}

Referenced by arbfp_blit_set().

arbfp_get_caps()

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

static

Definition at line 5760 of file arb_program_shader.c.

{
    caps->wined3d_caps = WINED3D_FRAGMENT_CAP_PROJ_CONTROL
            | WINED3D_FRAGMENT_CAP_SRGB_WRITE
            | WINED3D_FRAGMENT_CAP_COLOR_KEY;
    caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_TSSARGTEMP;
    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;
 
    /* TODO: Implement WINED3DTEXOPCAPS_PREMODULATE */
 
    caps->MaxTextureBlendStages   = MAX_TEXTURES;
    caps->MaxSimultaneousTextures = min(gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL], MAX_TEXTURES);
}

arbfp_get_emul_mask()

static DWORD arbfp_get_emul_mask ( const struct wined3d_gl_info *  gl_info )

static

Definition at line 5798 of file arb_program_shader.c.

{
    return GL_EXT_EMUL_ARB_MULTITEXTURE | GL_EXT_EMUL_EXT_FOG_COORD;
}

arbfp_texture_target()

static const char * arbfp_texture_target ( enum wined3d_gl_resource_type  type )

static

Definition at line 6216 of file arb_program_shader.c.

{
    switch(type)
    {
        case WINED3D_GL_RES_TYPE_TEX_1D:
            return "1D";
        case WINED3D_GL_RES_TYPE_TEX_2D:
            return "2D";
        case WINED3D_GL_RES_TYPE_TEX_3D:
            return "3D";
        case WINED3D_GL_RES_TYPE_TEX_CUBE:
            return "CUBE";
        case WINED3D_GL_RES_TYPE_TEX_RECT:
            return "RECT";
        default:
            return "unexpected_resource_type";
    }
}

Referenced by arbfp_gen_plain_shader(), gen_arbfp_ffp_shader(), gen_nv12_read(), gen_p8_shader(), gen_planar_yuv_read(), and gen_yv12_read().

calc_color_correction()

static struct color_fixup_masks calc_color_correction ( struct color_fixup_desc  fixup, DWORD  dst_mask  )

static

Definition at line 1290 of file arb_program_shader.c.

{
    struct color_fixup_masks masks = {0, 0};
 
    if (is_complex_fixup(fixup))
    {
        enum complex_fixup complex_fixup = get_complex_fixup(fixup);
        FIXME("Complex fixup (%#x) not supported\n", complex_fixup);
        return masks;
    }
 
    if (fixup.x_source != CHANNEL_SOURCE_X)
        masks.source |= WINED3DSP_WRITEMASK_0;
    if (fixup.y_source != CHANNEL_SOURCE_Y)
        masks.source |= WINED3DSP_WRITEMASK_1;
    if (fixup.z_source != CHANNEL_SOURCE_Z)
        masks.source |= WINED3DSP_WRITEMASK_2;
    if (fixup.w_source != CHANNEL_SOURCE_W)
        masks.source |= WINED3DSP_WRITEMASK_3;
    masks.source &= dst_mask;
 
    if (fixup.x_sign_fixup)
        masks.sign |= WINED3DSP_WRITEMASK_0;
    if (fixup.y_sign_fixup)
        masks.sign |= WINED3DSP_WRITEMASK_1;
    if (fixup.z_sign_fixup)
        masks.sign |= WINED3DSP_WRITEMASK_2;
    if (fixup.w_sign_fixup)
        masks.sign |= WINED3DSP_WRITEMASK_3;
    masks.sign &= dst_mask;
 
    return masks;
}

Referenced by gen_arbfp_ffp_shader(), and shader_hw_sample().

clone_sig()

static void clone_sig ( struct wined3d_shader_signature *  new, const struct wined3d_shader_signature *  sig  )

static

Definition at line 3877 of file arb_program_shader.c.

{
    unsigned int i;
    char *name;
 
    new->element_count = sig->element_count;
    new->elements = heap_calloc(new->element_count, sizeof(*new->elements));
    for (i = 0; i < sig->element_count; ++i)
    {
        new->elements[i] = sig->elements[i];
 
        if (!new->elements[i].semantic_name)
            continue;
 
        /* Clone the semantic string */
        name = heap_alloc(strlen(sig->elements[i].semantic_name) + 1);
        strcpy(name, sig->elements[i].semantic_name);
        new->elements[i].semantic_name = name;
    }
}

Referenced by find_input_signature().

color_key_arbfp()

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

static

Definition at line 5983 of file arb_program_shader.c.

{
    const struct wined3d_texture *texture = state->textures[0];
    const struct wined3d_gl_info *gl_info = context->gl_info;
    struct wined3d_device *device = context->device;
    struct wined3d_color float_key[2];
 
    if (!texture)
        return;
 
    if (device->shader_backend == &arb_program_shader_backend)
    {
        struct shader_arb_priv *priv;
 
        /* Don't load the parameter if we're using an arbfp pixel shader,
         * otherwise we'll overwrite application provided constants. */
        if (use_ps(state))
            return;
 
        priv = device->shader_priv;
        priv->pshader_const_dirty[ARB_FFP_CONST_COLOR_KEY_LOW] = 1;
        priv->pshader_const_dirty[ARB_FFP_CONST_COLOR_KEY_HIGH] = 1;
        priv->highest_dirty_ps_const = max(priv->highest_dirty_ps_const, ARB_FFP_CONST_COLOR_KEY_HIGH + 1);
    }
 
    wined3d_format_get_float_color_key(texture->resource.format, &texture->async.src_blt_color_key, float_key);
 
    GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_COLOR_KEY_LOW, &float_key[0].r));
    checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_COLOR_KEY_LOW, &float_key[0].r)");
    GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_COLOR_KEY_HIGH, &float_key[1].r));
    checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_COLOR_KEY_HIGH, &float_key[1].r)");
}

Referenced by fragment_prog_arbfp().

compare_sig()

static int compare_sig ( const struct wined3d_shader_signature *  sig1, const struct wined3d_shader_signature *  sig2  )

static

Definition at line 3837 of file arb_program_shader.c.

{
    unsigned int i;
    int ret;
 
    if (sig1->element_count != sig2->element_count)
        return sig1->element_count < sig2->element_count ? -1 : 1;
 
    for (i = 0; i < sig1->element_count; ++i)
    {
        const struct wined3d_shader_signature_element *e1, *e2;
 
        e1 = &sig1->elements[i];
        e2 = &sig2->elements[i];
 
        if (!e1->semantic_name || !e2->semantic_name)
        {
            /* Compare pointers, not contents. One string is NULL (element
             * does not exist), the other one is not NULL. */
            if (e1->semantic_name != e2->semantic_name)
                return e1->semantic_name < e2->semantic_name ? -1 : 1;
            continue;
        }
 
        if ((ret = strcmp(e1->semantic_name, e2->semantic_name)))
            return ret;
        if (e1->semantic_idx != e2->semantic_idx)
            return e1->semantic_idx < e2->semantic_idx ? -1 : 1;
        if (e1->sysval_semantic != e2->sysval_semantic)
            return e1->sysval_semantic < e2->sysval_semantic ? -1 : 1;
        if (e1->component_type != e2->component_type)
            return e1->component_type < e2->component_type ? -1 : 1;
        if (e1->register_idx != e2->register_idx)
            return e1->register_idx < e2->register_idx ? -1 : 1;
        if (e1->mask != e2->mask)
            return e1->mask < e2->mask ? -1 : 1;
    }
    return 0;
}

Referenced by sig_tree_compare().

ffp_clip_emul()

static BOOL ffp_clip_emul ( const struct wined3d_context *  context )

inlinestatic

Definition at line 124 of file arb_program_shader.c.

{
    return context->lowest_disabled_stage < 7;
}

Referenced by find_arb_vs_compile_args().

find_arb_ps_compile_args()

static void find_arb_ps_compile_args ( const struct wined3d_state *  state, const struct wined3d_context *  context, const struct wined3d_shader *  shader, struct arb_ps_compile_args *  args  )

static

Definition at line 4430 of file arb_program_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
    const struct wined3d_d3d_info *d3d_info = context->d3d_info;
    int i;
    WORD int_skip;
 
    find_ps_compile_args(state, shader, context->stream_info.position_transformed, &args->super, context);
 
    /* This forces all local boolean constants to 1 to make them stateblock independent */
    args->bools = shader->reg_maps.local_bool_consts;
 
    for (i = 0; i < WINED3D_MAX_CONSTS_B; ++i)
    {
        if (state->ps_consts_b[i])
            args->bools |= ( 1u << i);
    }
 
    /* Only enable the clip plane emulation KIL if at least one clipplane is enabled. The KIL instruction
     * is quite expensive because it forces the driver to disable early Z discards. It is cheaper to
     * duplicate the shader than have a no-op KIL instruction in every shader
     */
    if (!d3d_info->vs_clipping && use_vs(state)
            && state->render_states[WINED3D_RS_CLIPPING]
            && state->render_states[WINED3D_RS_CLIPPLANEENABLE])
        args->clip = 1;
    else
        args->clip = 0;
 
    /* Skip if unused or local, or supported natively */
    int_skip = ~shader->reg_maps.integer_constants | shader->reg_maps.local_int_consts;
    if (int_skip == 0xffff || gl_info->supported[NV_FRAGMENT_PROGRAM_OPTION])
    {
        memset(args->loop_ctrl, 0, sizeof(args->loop_ctrl));
        return;
    }
 
    for (i = 0; i < WINED3D_MAX_CONSTS_I; ++i)
    {
        if (int_skip & (1u << i))
        {
            args->loop_ctrl[i][0] = 0;
            args->loop_ctrl[i][1] = 0;
            args->loop_ctrl[i][2] = 0;
        }
        else
        {
            args->loop_ctrl[i][0] = state->ps_consts_i[i].x;
            args->loop_ctrl[i][1] = state->ps_consts_i[i].y;
            args->loop_ctrl[i][2] = state->ps_consts_i[i].z;
        }
    }
}

Referenced by shader_arb_select().

find_arb_pshader()

static struct arb_ps_compiled_shader * find_arb_pshader ( struct wined3d_shader *  shader, const struct arb_ps_compile_args *  args  )

static

Definition at line 4244 of file arb_program_shader.c.

{
    struct wined3d_device *device = shader->device;
    const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
    const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
    UINT i;
    DWORD new_size;
    struct arb_ps_compiled_shader *new_array;
    struct wined3d_string_buffer buffer;
    struct arb_pshader_private *shader_data;
    GLuint ret;
 
    if (!shader->backend_data)
    {
        struct shader_arb_priv *priv = device->shader_priv;
 
        shader->backend_data = heap_alloc_zero(sizeof(*shader_data));
        shader_data = shader->backend_data;
        shader_data->clamp_consts = shader->reg_maps.shader_version.major == 1;
 
        if (shader->reg_maps.shader_version.major < 3)
            shader_data->input_signature_idx = ~0U;
        else
            shader_data->input_signature_idx = find_input_signature(priv, &shader->input_signature);
 
        TRACE("Shader got assigned input signature index %u\n", shader_data->input_signature_idx);
 
        if (!d3d_info->vs_clipping)
            shader_data->clipplane_emulation = shader_find_free_input_register(&shader->reg_maps,
                    d3d_info->limits.ffp_blend_stages - 1);
        else
            shader_data->clipplane_emulation = ~0U;
    }
    shader_data = shader->backend_data;
 
    /* 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(&shader_data->gl_shaders[i].args, args, sizeof(*args)))
            return &shader_data->gl_shaders[i];
    }
 
    TRACE("No matching GL shader found, compiling a new shader\n");
    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 = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, shader_data->gl_shaders,
                                    new_size * sizeof(*shader_data->gl_shaders));
        }
        else
        {
            new_array = heap_alloc_zero(sizeof(*shader_data->gl_shaders));
            new_size = 1;
        }
 
        if(!new_array) {
            ERR("Out of memory\n");
            return 0;
        }
        shader_data->gl_shaders = new_array;
        shader_data->shader_array_size = new_size;
    }
 
    shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
 
    pixelshader_update_resource_types(shader, args->super.tex_types);
 
    if (!string_buffer_init(&buffer))
    {
        ERR("Failed to initialize shader buffer.\n");
        return 0;
    }
 
    ret = shader_arb_generate_pshader(shader, gl_info, &buffer, args,
            &shader_data->gl_shaders[shader_data->num_gl_shaders]);
    string_buffer_free(&buffer);
    shader_data->gl_shaders[shader_data->num_gl_shaders].prgId = ret;
 
    return &shader_data->gl_shaders[shader_data->num_gl_shaders++];
}

Referenced by shader_arb_select().

find_arb_vs_compile_args()

static void find_arb_vs_compile_args ( const struct wined3d_state *  state, const struct wined3d_context *  context, const struct wined3d_shader *  shader, struct arb_vs_compile_args *  args  )

static

Definition at line 4486 of file arb_program_shader.c.

{
    const struct wined3d_device *device = shader->device;
    const struct wined3d_adapter *adapter = device->adapter;
    const struct wined3d_gl_info *gl_info = context->gl_info;
    const struct wined3d_d3d_info *d3d_info = context->d3d_info;
    int i;
    WORD int_skip;
 
    find_vs_compile_args(state, shader, context->stream_info.swizzle_map, &args->super, context);
 
    args->clip.boolclip_compare = 0;
    if (use_ps(state))
    {
        const struct wined3d_shader *ps = state->shader[WINED3D_SHADER_TYPE_PIXEL];
        const struct arb_pshader_private *shader_priv = ps->backend_data;
        args->ps_signature = shader_priv->input_signature_idx;
 
        args->clip.boolclip.clip_texcoord = shader_priv->clipplane_emulation + 1;
    }
    else
    {
        args->ps_signature = ~0;
        if (!d3d_info->vs_clipping && adapter->fragment_pipe == &arbfp_fragment_pipeline)
            args->clip.boolclip.clip_texcoord = ffp_clip_emul(context) ? d3d_info->limits.ffp_blend_stages : 0;
        /* Otherwise: Setting boolclip_compare set clip_texcoord to 0 */
    }
 
    if (args->clip.boolclip.clip_texcoord)
    {
        if (state->render_states[WINED3D_RS_CLIPPING])
            args->clip.boolclip.clipplane_mask = (unsigned char)state->render_states[WINED3D_RS_CLIPPLANEENABLE];
        /* clipplane_mask was set to 0 by setting boolclip_compare to 0 */
    }
 
    /* This forces all local boolean constants to 1 to make them stateblock independent */
    args->clip.boolclip.bools = shader->reg_maps.local_bool_consts;
    /* TODO: Figure out if it would be better to store bool constants as bitmasks in the stateblock */
    for (i = 0; i < WINED3D_MAX_CONSTS_B; ++i)
    {
        if (state->vs_consts_b[i])
            args->clip.boolclip.bools |= (1u << i);
    }
 
    args->vertex.samplers[0] = context->tex_unit_map[MAX_FRAGMENT_SAMPLERS + 0];
    args->vertex.samplers[1] = context->tex_unit_map[MAX_FRAGMENT_SAMPLERS + 1];
    args->vertex.samplers[2] = context->tex_unit_map[MAX_FRAGMENT_SAMPLERS + 2];
    args->vertex.samplers[3] = 0;
 
    /* Skip if unused or local */
    int_skip = ~shader->reg_maps.integer_constants | shader->reg_maps.local_int_consts;
    /* This is about flow control, not clipping. */
    if (int_skip == 0xffff || gl_info->supported[NV_VERTEX_PROGRAM2_OPTION])
    {
        memset(args->loop_ctrl, 0, sizeof(args->loop_ctrl));
        return;
    }
 
    for (i = 0; i < WINED3D_MAX_CONSTS_I; ++i)
    {
        if (int_skip & (1u << i))
        {
            args->loop_ctrl[i][0] = 0;
            args->loop_ctrl[i][1] = 0;
            args->loop_ctrl[i][2] = 0;
        }
        else
        {
            args->loop_ctrl[i][0] = state->vs_consts_i[i].x;
            args->loop_ctrl[i][1] = state->vs_consts_i[i].y;
            args->loop_ctrl[i][2] = state->vs_consts_i[i].z;
        }
    }
}

Referenced by shader_arb_select().

find_arb_vshader()

static struct arb_vs_compiled_shader * find_arb_vshader ( struct wined3d_shader *  shader, const struct wined3d_gl_info *  gl_info, DWORD  use_map, const struct arb_vs_compile_args *  args, const struct wined3d_shader_signature *  ps_input_sig  )

static

Definition at line 4343 of file arb_program_shader.c.

{
    UINT i;
    DWORD new_size;
    struct arb_vs_compiled_shader *new_array;
    struct wined3d_string_buffer buffer;
    struct arb_vshader_private *shader_data;
    GLuint ret;
 
    if (!shader->backend_data)
    {
        const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
 
        shader->backend_data = heap_alloc_zero(sizeof(*shader_data));
        shader_data = shader->backend_data;
 
        if ((gl_info->quirks & WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT)
                && reg_maps->min_rel_offset <= reg_maps->max_rel_offset)
        {
            if (reg_maps->max_rel_offset - reg_maps->min_rel_offset > 127)
            {
                FIXME("The difference between the minimum and maximum relative offset is > 127.\n");
                FIXME("Which this OpenGL implementation does not support. Try using GLSL.\n");
                FIXME("Min: %u, Max: %u.\n", reg_maps->min_rel_offset, reg_maps->max_rel_offset);
            }
            else if (reg_maps->max_rel_offset - reg_maps->min_rel_offset > 63)
                shader_data->rel_offset = reg_maps->min_rel_offset + 63;
            else if (reg_maps->max_rel_offset > 63)
                shader_data->rel_offset = reg_maps->min_rel_offset;
        }
    }
    shader_data = shader->backend_data;
 
    /* 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(&shader_data->gl_shaders[i].args, args,
                use_map, gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]))
        {
            return &shader_data->gl_shaders[i];
        }
    }
 
    TRACE("No matching GL shader found, compiling a new shader\n");
 
    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 = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, shader_data->gl_shaders,
                                    new_size * sizeof(*shader_data->gl_shaders));
        }
        else
        {
            new_array = heap_alloc_zero(sizeof(*shader_data->gl_shaders));
            new_size = 1;
        }
 
        if(!new_array) {
            ERR("Out of memory\n");
            return 0;
        }
        shader_data->gl_shaders = new_array;
        shader_data->shader_array_size = new_size;
    }
 
    shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
 
    if (!string_buffer_init(&buffer))
    {
        ERR("Failed to initialize shader buffer.\n");
        return 0;
    }
 
    ret = shader_arb_generate_vshader(shader, gl_info, &buffer, args,
            &shader_data->gl_shaders[shader_data->num_gl_shaders],
            ps_input_sig);
    string_buffer_free(&buffer);
    shader_data->gl_shaders[shader_data->num_gl_shaders].prgId = ret;
 
    return &shader_data->gl_shaders[shader_data->num_gl_shaders++];
}

Referenced by shader_arb_select().

find_input_signature()

static DWORD find_input_signature ( struct shader_arb_priv *  priv, const struct wined3d_shader_signature *  sig  )

static

Definition at line 3898 of file arb_program_shader.c.

{
    struct wine_rb_entry *entry = wine_rb_get(&priv->signature_tree, sig);
    struct ps_signature *found_sig;
 
    if (entry)
    {
        found_sig = WINE_RB_ENTRY_VALUE(entry, struct ps_signature, entry);
        TRACE("Found existing signature %u\n", found_sig->idx);
        return found_sig->idx;
    }
    found_sig = heap_alloc_zero(sizeof(*found_sig));
    clone_sig(&found_sig->sig, sig);
    found_sig->idx = priv->ps_sig_number++;
    TRACE("New signature stored and assigned number %u\n", found_sig->idx);
    if(wine_rb_put(&priv->signature_tree, sig, &found_sig->entry) == -1)
    {
        ERR("Failed to insert program entry.\n");
    }
    return found_sig->idx;
}

Referenced by find_arb_pshader().

find_last_loop()

static const struct control_frame * find_last_loop ( const struct shader_arb_ctx_priv *  priv )

static

Definition at line 2970 of file arb_program_shader.c.

{
    struct control_frame *control_frame;
 
    LIST_FOR_EACH_ENTRY(control_frame, &priv->control_frames, struct control_frame, entry)
    {
        if(control_frame->type == LOOP || control_frame->type == REP) return control_frame;
    }
    ERR("Could not find loop for break\n");
    return NULL;
}

Referenced by shader_hw_break(), and shader_hw_breakc().

find_loop_control_values()

static const DWORD * find_loop_control_values ( const struct wined3d_shader *  shader, DWORD  idx  )

static

Definition at line 3398 of file arb_program_shader.c.

{
    const struct wined3d_shader_lconst *constant;
 
    LIST_FOR_EACH_ENTRY(constant, &shader->constantsI, struct wined3d_shader_lconst, entry)
    {
        if (constant->idx == idx)
        {
            return constant->value;
        }
    }
    return NULL;
}

Referenced by shader_arb_generate_pshader(), and shader_arb_generate_vshader().

fragment_prog_arbfp()

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

static

Definition at line 6538 of file arb_program_shader.c.

{
    const struct wined3d_gl_info *gl_info = context->gl_info;
    const struct wined3d_device *device = context->device;
    struct shader_arb_priv *priv = device->fragment_priv;
    BOOL use_pshader = use_ps(state);
    struct ffp_frag_settings settings;
    const struct arbfp_ffp_desc *desc;
    unsigned int i;
 
    TRACE("context %p, state %p, state_id %#x.\n", context, state, state_id);
 
    if (isStateDirty(context, STATE_RENDER(WINED3D_RS_FOGENABLE)))
    {
        if (!use_pshader && device->shader_backend == &arb_program_shader_backend && context->last_was_pshader)
        {
            /* Reload fixed function constants since they collide with the
             * pixel shader constants. */
            for (i = 0; i < MAX_TEXTURES; ++i)
            {
                set_bumpmat_arbfp(context, state, STATE_TEXTURESTAGE(i, WINED3D_TSS_BUMPENV_MAT00));
                state_tss_constant_arbfp(context, state, STATE_TEXTURESTAGE(i, WINED3D_TSS_CONSTANT));
            }
            state_texfactor_arbfp(context, state, STATE_RENDER(WINED3D_RS_TEXTUREFACTOR));
            state_arb_specularenable(context, state, STATE_RENDER(WINED3D_RS_SPECULARENABLE));
            color_key_arbfp(context, state, STATE_COLOR_KEY);
        }
        else if (use_pshader)
        {
            context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
        }
        return;
    }
 
    if (!use_pshader)
    {
        /* Find or create a shader implementing the fixed function pipeline
         * settings, then activate it. */
        gen_ffp_frag_op(context, state, &settings, FALSE);
        desc = (const struct arbfp_ffp_desc *)find_ffp_frag_shader(&priv->fragment_shaders, &settings);
        if (!desc)
        {
            struct arbfp_ffp_desc *new_desc;
 
            if (!(new_desc = heap_alloc(sizeof(*new_desc))))
            {
                ERR("Out of memory\n");
                return;
            }
 
            new_desc->parent.settings = settings;
            new_desc->shader = gen_arbfp_ffp_shader(&settings, gl_info);
            add_ffp_frag_shader(&priv->fragment_shaders, &new_desc->parent);
            TRACE("Allocated fixed function replacement shader descriptor %p\n", new_desc);
            desc = new_desc;
        }
 
        /* Now activate the replacement program. GL_FRAGMENT_PROGRAM_ARB is already active (however, note the
         * comment above the shader_select call below). If e.g. GLSL is active, the shader_select call will
         * deactivate it.
         */
        GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, desc->shader));
        checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, desc->shader)");
        priv->current_fprogram_id = desc->shader;
 
        if (device->shader_backend == &arb_program_shader_backend && context->last_was_pshader)
        {
            /* Reload fixed function constants since they collide with the
             * pixel shader constants. */
            for (i = 0; i < MAX_TEXTURES; ++i)
            {
                set_bumpmat_arbfp(context, state, STATE_TEXTURESTAGE(i, WINED3D_TSS_BUMPENV_MAT00));
                state_tss_constant_arbfp(context, state, STATE_TEXTURESTAGE(i, WINED3D_TSS_CONSTANT));
            }
            state_texfactor_arbfp(context, state, STATE_RENDER(WINED3D_RS_TEXTUREFACTOR));
            state_arb_specularenable(context, state, STATE_RENDER(WINED3D_RS_SPECULARENABLE));
            color_key_arbfp(context, state, STATE_COLOR_KEY);
        }
        context->last_was_pshader = FALSE;
    }
    else if (!context->last_was_pshader)
    {
        if (device->shader_backend == &arb_program_shader_backend)
            context->constant_update_mask |= WINED3D_SHADER_CONST_PS_F;
        context->last_was_pshader = TRUE;
    }
 
    context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}

Referenced by state_arbfp_fog(), and textransform().

free_recorded_instruction()

static void free_recorded_instruction ( struct list *  list )

static

Definition at line 5398 of file arb_program_shader.c.

{
    struct recorded_instruction *rec_ins, *entry2;
    unsigned int i;
 
    LIST_FOR_EACH_ENTRY_SAFE(rec_ins, entry2, list, struct recorded_instruction, entry)
    {
        list_remove(&rec_ins->entry);
        if (rec_ins->ins.dst)
        {
            heap_free((void *)rec_ins->ins.dst->reg.idx[0].rel_addr);
            heap_free((void *)rec_ins->ins.dst);
        }
        if (rec_ins->ins.src)
        {
            for (i = 0; i < rec_ins->ins.src_count; ++i)
            {
                heap_free((void *)rec_ins->ins.src[i].reg.idx[0].rel_addr);
            }
            heap_free((void *)rec_ins->ins.src);
        }
        heap_free(rec_ins);
    }
}

Referenced by shader_arb_handle_instruction().

gen_arbfp_ffp_shader()

static GLuint gen_arbfp_ffp_shader ( const struct ffp_frag_settings *  settings, const struct wined3d_gl_info *  gl_info  )

static

Definition at line 6235 of file arb_program_shader.c.

{
    BYTE tex_read = 0, bump_used = 0, luminance_used = 0, constant_used = 0;
    BOOL tempreg_used = FALSE, tfactor_used = FALSE;
    unsigned int stage, lowest_disabled_stage;
    struct wined3d_string_buffer buffer;
    struct color_fixup_masks masks;
    BOOL custom_linear_fog = FALSE;
    const char *textype, *instr;
    DWORD arg0, arg1, arg2;
    char colorcor_dst[8];
    BOOL op_equal;
    GLuint ret;
 
    if (!string_buffer_init(&buffer))
    {
        ERR("Failed to initialize shader buffer.\n");
        return 0;
    }
 
    shader_addline(&buffer, "!!ARBfp1.0\n");
 
    if (settings->color_key_enabled)
    {
        shader_addline(&buffer, "PARAM color_key_low = program.env[%u];\n", ARB_FFP_CONST_COLOR_KEY_LOW);
        shader_addline(&buffer, "PARAM color_key_high = program.env[%u];\n", ARB_FFP_CONST_COLOR_KEY_HIGH);
        tex_read |= 1;
    }
 
    /* Find out which textures are read */
    for (stage = 0; stage < MAX_TEXTURES; ++stage)
    {
        if (settings->op[stage].cop == WINED3D_TOP_DISABLE)
            break;
 
        arg0 = settings->op[stage].carg0 & WINED3DTA_SELECTMASK;
        arg1 = settings->op[stage].carg1 & WINED3DTA_SELECTMASK;
        arg2 = settings->op[stage].carg2 & WINED3DTA_SELECTMASK;
 
        if (arg0 == WINED3DTA_TEXTURE || arg1 == WINED3DTA_TEXTURE || arg2 == WINED3DTA_TEXTURE)
            tex_read |= 1u << stage;
        if (settings->op[stage].dst == tempreg)
            tempreg_used = TRUE;
        if (arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP)
            tempreg_used = TRUE;
        if (arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR)
            tfactor_used = TRUE;
        if (arg0 == WINED3DTA_CONSTANT || arg1 == WINED3DTA_CONSTANT || arg2 == WINED3DTA_CONSTANT)
            constant_used |= 1u << stage;
 
        switch (settings->op[stage].cop)
        {
            case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
                luminance_used |= 1u << stage;
                /* fall through */
            case WINED3D_TOP_BUMPENVMAP:
                bump_used |= 1u << stage;
                /* fall through */
            case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
            case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
                tex_read |= 1u << stage;
                break;
 
            case WINED3D_TOP_BLEND_FACTOR_ALPHA:
                tfactor_used = TRUE;
                break;
 
            default:
                break;
        }
 
        if (settings->op[stage].aop == WINED3D_TOP_DISABLE)
            continue;
 
        arg0 = settings->op[stage].aarg0 & WINED3DTA_SELECTMASK;
        arg1 = settings->op[stage].aarg1 & WINED3DTA_SELECTMASK;
        arg2 = settings->op[stage].aarg2 & WINED3DTA_SELECTMASK;
 
        if (arg0 == WINED3DTA_TEXTURE || arg1 == WINED3DTA_TEXTURE || arg2 == WINED3DTA_TEXTURE)
            tex_read |= 1u << stage;
        if (arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP)
            tempreg_used = TRUE;
        if (arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR)
            tfactor_used = TRUE;
        if (arg0 == WINED3DTA_CONSTANT || arg1 == WINED3DTA_CONSTANT || arg2 == WINED3DTA_CONSTANT)
            constant_used |= 1u << stage;
    }
    lowest_disabled_stage = stage;
 
    switch (settings->fog)
    {
        case WINED3D_FFP_PS_FOG_OFF:                                                         break;
        case WINED3D_FFP_PS_FOG_LINEAR:
            if (gl_info->quirks & WINED3D_QUIRK_BROKEN_ARB_FOG)
            {
                custom_linear_fog = TRUE;
                break;
            }
            shader_addline(&buffer, "OPTION ARB_fog_linear;\n");
            break;
 
        case WINED3D_FFP_PS_FOG_EXP:    shader_addline(&buffer, "OPTION ARB_fog_exp;\n");    break;
        case WINED3D_FFP_PS_FOG_EXP2:   shader_addline(&buffer, "OPTION ARB_fog_exp2;\n");   break;
        default: FIXME("Unexpected fog setting %d\n", settings->fog);
    }
 
    shader_addline(&buffer, "PARAM const = {1, 2, 4, 0.5};\n");
    shader_addline(&buffer, "TEMP TMP;\n");
    shader_addline(&buffer, "TEMP ret;\n");
    if (tempreg_used || settings->sRGB_write) shader_addline(&buffer, "TEMP tempreg;\n");
    shader_addline(&buffer, "TEMP arg0;\n");
    shader_addline(&buffer, "TEMP arg1;\n");
    shader_addline(&buffer, "TEMP arg2;\n");
    for (stage = 0; stage < MAX_TEXTURES; ++stage)
    {
        if (constant_used & (1u << stage))
            shader_addline(&buffer, "PARAM const%u = program.env[%u];\n", stage, ARB_FFP_CONST_CONSTANT(stage));
 
        if (!(tex_read & (1u << stage)))
            continue;
 
        shader_addline(&buffer, "TEMP tex%u;\n", stage);
 
        if (!(bump_used & (1u << stage)))
            continue;
        shader_addline(&buffer, "PARAM bumpmat%u = program.env[%u];\n", stage, ARB_FFP_CONST_BUMPMAT(stage));
 
        if (!(luminance_used & (1u << stage)))
            continue;
        shader_addline(&buffer, "PARAM luminance%u = program.env[%u];\n", stage, ARB_FFP_CONST_LUMINANCE(stage));
    }
    if (tfactor_used)
        shader_addline(&buffer, "PARAM tfactor = program.env[%u];\n", ARB_FFP_CONST_TFACTOR);
    shader_addline(&buffer, "PARAM specular_enable = program.env[%u];\n", ARB_FFP_CONST_SPECULAR_ENABLE);
 
    if (settings->sRGB_write)
    {
        shader_addline(&buffer, "PARAM srgb_consts0 = ");
        shader_arb_append_imm_vec4(&buffer, wined3d_srgb_const0);
        shader_addline(&buffer, ";\n");
        shader_addline(&buffer, "PARAM srgb_consts1 = ");
        shader_arb_append_imm_vec4(&buffer, wined3d_srgb_const1);
        shader_addline(&buffer, ";\n");
    }
 
    if (lowest_disabled_stage < 7 && settings->emul_clipplanes)
        shader_addline(&buffer, "KIL fragment.texcoord[7];\n");
 
    if (tempreg_used || settings->sRGB_write)
        shader_addline(&buffer, "MOV tempreg, 0.0;\n");
 
    /* Generate texture sampling instructions */
    for (stage = 0; stage < MAX_TEXTURES && settings->op[stage].cop != WINED3D_TOP_DISABLE; ++stage)
    {
        if (!(tex_read & (1u << stage)))
            continue;
 
        textype = arbfp_texture_target(settings->op[stage].tex_type);
 
        if(settings->op[stage].projected == proj_none) {
            instr = "TEX";
        } else if(settings->op[stage].projected == proj_count4 ||
                  settings->op[stage].projected == proj_count3) {
            instr = "TXP";
        } else {
            FIXME("Unexpected projection mode %d\n", settings->op[stage].projected);
            instr = "TXP";
        }
 
        if (stage > 0
                && (settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP
                || settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE))
        {
            shader_addline(&buffer, "SWZ arg1, bumpmat%u, x, z, 0, 0;\n", stage - 1);
            shader_addline(&buffer, "DP3 ret.x, arg1, tex%u;\n", stage - 1);
            shader_addline(&buffer, "SWZ arg1, bumpmat%u, y, w, 0, 0;\n", stage - 1);
            shader_addline(&buffer, "DP3 ret.y, arg1, tex%u;\n", stage - 1);
 
            /* with projective textures, texbem only divides the static texture coord, not the displacement,
             * so multiply the displacement with the dividing parameter before passing it to TXP
             */
            if (settings->op[stage].projected != proj_none) {
                if(settings->op[stage].projected == proj_count4) {
                    shader_addline(&buffer, "MOV ret.w, fragment.texcoord[%u].w;\n", stage);
                    shader_addline(&buffer, "MUL ret.xyz, ret, fragment.texcoord[%u].w, fragment.texcoord[%u];\n", stage, stage);
                } else {
                    shader_addline(&buffer, "MOV ret.w, fragment.texcoord[%u].z;\n", stage);
                    shader_addline(&buffer, "MAD ret.xyz, ret, fragment.texcoord[%u].z, fragment.texcoord[%u];\n", stage, stage);
                }
            } else {
                shader_addline(&buffer, "ADD ret, ret, fragment.texcoord[%u];\n", stage);
            }
 
            shader_addline(&buffer, "%s tex%u, ret, texture[%u], %s;\n",
                    instr, stage, stage, textype);
            if (settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
            {
                shader_addline(&buffer, "MAD_SAT ret.x, tex%u.z, luminance%u.x, luminance%u.y;\n",
                               stage - 1, stage - 1, stage - 1);
                shader_addline(&buffer, "MUL tex%u, tex%u, ret.x;\n", stage, stage);
            }
        } else if(settings->op[stage].projected == proj_count3) {
            shader_addline(&buffer, "MOV ret, fragment.texcoord[%u];\n", stage);
            shader_addline(&buffer, "MOV ret.w, ret.z;\n");
            shader_addline(&buffer, "%s tex%u, ret, texture[%u], %s;\n",
                            instr, stage, stage, textype);
        } else {
            shader_addline(&buffer, "%s tex%u, fragment.texcoord[%u], texture[%u], %s;\n",
                            instr, stage, stage, stage, textype);
        }
 
        sprintf(colorcor_dst, "tex%u", stage);
        masks = calc_color_correction(settings->op[stage].color_fixup, WINED3DSP_WRITEMASK_ALL);
        gen_color_correction(&buffer, colorcor_dst, colorcor_dst, "const.x", "const.y",
                settings->op[stage].color_fixup, masks);
    }
 
    if (settings->color_key_enabled)
    {
        shader_addline(&buffer, "SLT TMP, tex0, color_key_low;\n"); /* below low key */
        shader_addline(&buffer, "SGE ret, tex0, color_key_high;\n"); /* above high key */
        shader_addline(&buffer, "ADD TMP, TMP, ret;\n"); /* or */
        shader_addline(&buffer, "DP4 TMP.b, TMP, TMP;\n"); /* on any channel */
        shader_addline(&buffer, "SGE TMP, -TMP.b, 0.0;\n"); /* logical not */
        shader_addline(&buffer, "KIL -TMP;\n"); /* discard if true */
    }
 
    shader_addline(&buffer, "MOV ret, fragment.color.primary;\n");
 
    /* Generate the main shader */
    for (stage = 0; stage < MAX_TEXTURES; ++stage)
    {
        if (settings->op[stage].cop == WINED3D_TOP_DISABLE)
            break;
 
        if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG1
                && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG1)
            op_equal = settings->op[stage].carg1 == settings->op[stage].aarg1;
        else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG1
                && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG2)
            op_equal = settings->op[stage].carg1 == settings->op[stage].aarg2;
        else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG2
                && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG1)
            op_equal = settings->op[stage].carg2 == settings->op[stage].aarg1;
        else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG2
                && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG2)
            op_equal = settings->op[stage].carg2 == settings->op[stage].aarg2;
        else
            op_equal = settings->op[stage].aop   == settings->op[stage].cop
                    && settings->op[stage].carg0 == settings->op[stage].aarg0
                    && settings->op[stage].carg1 == settings->op[stage].aarg1
                    && settings->op[stage].carg2 == settings->op[stage].aarg2;
 
        if (settings->op[stage].aop == WINED3D_TOP_DISABLE)
        {
            gen_ffp_instr(&buffer, stage, TRUE, FALSE, settings->op[stage].dst,
                          settings->op[stage].cop, settings->op[stage].carg0,
                          settings->op[stage].carg1, settings->op[stage].carg2);
        }
        else if (op_equal)
        {
            gen_ffp_instr(&buffer, stage, TRUE, TRUE, settings->op[stage].dst,
                          settings->op[stage].cop, settings->op[stage].carg0,
                          settings->op[stage].carg1, settings->op[stage].carg2);
        }
        else if (settings->op[stage].cop != WINED3D_TOP_BUMPENVMAP
                && settings->op[stage].cop != WINED3D_TOP_BUMPENVMAP_LUMINANCE)
        {
            gen_ffp_instr(&buffer, stage, TRUE, FALSE, settings->op[stage].dst,
                          settings->op[stage].cop, settings->op[stage].carg0,
                          settings->op[stage].carg1, settings->op[stage].carg2);
            gen_ffp_instr(&buffer, stage, FALSE, TRUE, settings->op[stage].dst,
                          settings->op[stage].aop, settings->op[stage].aarg0,
                          settings->op[stage].aarg1, settings->op[stage].aarg2);
        }
    }
 
    if (settings->sRGB_write || custom_linear_fog)
    {
        shader_addline(&buffer, "MAD ret, fragment.color.secondary, specular_enable, ret;\n");
        if (settings->sRGB_write)
            arbfp_add_sRGB_correction(&buffer, "ret", "arg0", "arg1", "arg2", "tempreg", FALSE);
        if (custom_linear_fog)
            arbfp_add_linear_fog(&buffer, "ret", "arg0");
        shader_addline(&buffer, "MOV result.color, ret;\n");
    }
    else
    {
        shader_addline(&buffer, "MAD result.color, fragment.color.secondary, specular_enable, ret;\n");
    }
 
    /* Footer */
    shader_addline(&buffer, "END\n");
 
    /* Generate the shader */
    GL_EXTCALL(glGenProgramsARB(1, &ret));
    GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ret));
    shader_arb_compile(gl_info, GL_FRAGMENT_PROGRAM_ARB, buffer.buffer);
 
    string_buffer_free(&buffer);
    return ret;
}

Referenced by fragment_prog_arbfp().

gen_color_correction()

static void gen_color_correction ( struct wined3d_string_buffer *  buffer, const char *  dst, const char *  src, const char *  one, const char *  two, struct color_fixup_desc  fixup, struct color_fixup_masks  masks  )

static

Definition at line 1324 of file arb_program_shader.c.

{
    const char *sign_fixup_src = dst;
 
    if (masks.source)
    {
        if (masks.sign)
            sign_fixup_src = "TA";
 
        shader_addline(buffer, "SWZ %s, %s, %s, %s, %s, %s;\n", sign_fixup_src, src,
                shader_arb_get_fixup_swizzle(fixup.x_source), shader_arb_get_fixup_swizzle(fixup.y_source),
                shader_arb_get_fixup_swizzle(fixup.z_source), shader_arb_get_fixup_swizzle(fixup.w_source));
    }
    else if (masks.sign)
    {
        sign_fixup_src = src;
    }
 
    if (masks.sign)
    {
        char reg_mask[6];
        char *ptr = reg_mask;
 
        if (masks.sign != WINED3DSP_WRITEMASK_ALL)
        {
            *ptr++ = '.';
            if (masks.sign & WINED3DSP_WRITEMASK_0)
                *ptr++ = 'x';
            if (masks.sign & WINED3DSP_WRITEMASK_1)
                *ptr++ = 'y';
            if (masks.sign & WINED3DSP_WRITEMASK_2)
                *ptr++ = 'z';
            if (masks.sign & WINED3DSP_WRITEMASK_3)
                *ptr++ = 'w';
        }
        *ptr = '\0';
 
        shader_addline(buffer, "MAD %s%s, %s, %s, -%s;\n", dst, reg_mask, sign_fixup_src, two, one);
    }
}

Referenced by gen_arbfp_ffp_shader(), and shader_hw_sample().

gen_ffp_instr()

static void gen_ffp_instr ( 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

Definition at line 6086 of file arb_program_shader.c.

{
    const char *dstmask, *dstreg, *arg0, *arg1, *arg2;
    unsigned int mul = 1;
 
    if(color && alpha) dstmask = "";
    else if(color) dstmask = ".xyz";
    else dstmask = ".w";
 
    if(dst == tempreg) dstreg = "tempreg";
    else dstreg = "ret";
 
    arg0 = get_argreg(buffer, 0, stage, dw_arg0);
    arg1 = get_argreg(buffer, 1, stage, dw_arg1);
    arg2 = get_argreg(buffer, 2, stage, dw_arg2);
 
    switch (op)
    {
        case WINED3D_TOP_DISABLE:
            break;
 
        case WINED3D_TOP_SELECT_ARG2:
            arg1 = arg2;
            /* FALLTHROUGH */
        case WINED3D_TOP_SELECT_ARG1:
            shader_addline(buffer, "MOV %s%s, %s;\n", dstreg, dstmask, arg1);
            break;
 
        case WINED3D_TOP_MODULATE_4X:
            mul = 2;
            /* FALLTHROUGH */
        case WINED3D_TOP_MODULATE_2X:
            mul *= 2;
            /* FALLTHROUGH */
        case WINED3D_TOP_MODULATE:
            shader_addline(buffer, "MUL %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
            break;
 
        case WINED3D_TOP_ADD_SIGNED_2X:
            mul = 2;
            /* FALLTHROUGH */
        case WINED3D_TOP_ADD_SIGNED:
            shader_addline(buffer, "SUB arg2, %s, const.w;\n", arg2);
            arg2 = "arg2";
            /* FALLTHROUGH */
        case WINED3D_TOP_ADD:
            shader_addline(buffer, "ADD_SAT %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
            break;
 
        case WINED3D_TOP_SUBTRACT:
            shader_addline(buffer, "SUB_SAT %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
            break;
 
        case WINED3D_TOP_ADD_SMOOTH:
            shader_addline(buffer, "SUB arg1, const.x, %s;\n", arg1);
            shader_addline(buffer, "MAD_SAT %s%s, arg1, %s, %s;\n", dstreg, dstmask, arg2, arg1);
            break;
 
        case WINED3D_TOP_BLEND_CURRENT_ALPHA:
            arg0 = get_argreg(buffer, 0, stage, WINED3DTA_CURRENT);
            shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
            break;
        case WINED3D_TOP_BLEND_FACTOR_ALPHA:
            arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TFACTOR);
            shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
            break;
        case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
            arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TEXTURE);
            shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
            break;
        case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
            arg0 = get_argreg(buffer, 0, stage, WINED3DTA_DIFFUSE);
            shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
            break;
 
        case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
            arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TEXTURE);
            shader_addline(buffer, "SUB arg0.w, const.x, %s.w;\n", arg0);
            shader_addline(buffer, "MAD_SAT %s%s, %s, arg0.w, %s;\n", dstreg, dstmask, arg2, arg1);
            break;
 
        /* D3DTOP_PREMODULATE ???? */
 
        case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
            shader_addline(buffer, "SUB arg0.w, const.x, %s;\n", arg1);
            shader_addline(buffer, "MAD_SAT %s%s, arg0.w, %s, %s;\n", dstreg, dstmask, arg2, arg1);
            break;
        case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
            shader_addline(buffer, "MAD_SAT %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg1, arg2, arg1);
            break;
        case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
            shader_addline(buffer, "SUB arg0, const.x, %s;\n", arg1);
            shader_addline(buffer, "MAD_SAT %s%s, arg0, %s, %s.w;\n", dstreg, dstmask, arg2, arg1);
            break;
        case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
            shader_addline(buffer, "MAD_SAT %s%s, %s, %s, %s.w;\n", dstreg, dstmask, arg1, arg2, arg1);
            break;
 
        case WINED3D_TOP_DOTPRODUCT3:
            mul = 4;
            shader_addline(buffer, "SUB arg1, %s, const.w;\n", arg1);
            shader_addline(buffer, "SUB arg2, %s, const.w;\n", arg2);
            shader_addline(buffer, "DP3_SAT %s%s, arg1, arg2;\n", dstreg, dstmask);
            break;
 
        case WINED3D_TOP_MULTIPLY_ADD:
            shader_addline(buffer, "MAD_SAT %s%s, %s, %s, %s;\n", dstreg, dstmask, arg1, arg2, arg0);
            break;
 
        case WINED3D_TOP_LERP:
            /* The msdn is not quite right here */
            shader_addline(buffer, "LRP %s%s, %s, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
            break;
 
        case WINED3D_TOP_BUMPENVMAP:
        case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
            /* Those are handled in the first pass of the shader(generation pass 1 and 2) already */
            break;
 
        default:
            FIXME("Unhandled texture op %08x\n", op);
    }
 
    if (mul == 2)
        shader_addline(buffer, "MUL_SAT %s%s, %s, const.y;\n", dstreg, dstmask, dstreg);
    else if (mul == 4)
        shader_addline(buffer, "MUL_SAT %s%s, %s, const.z;\n", dstreg, dstmask, dstreg);
}

Referenced by gen_arbfp_ffp_shader().

gen_nv12_read()

static BOOL gen_nv12_read ( struct wined3d_string_buffer *  buffer, const struct arbfp_blit_type *  type, char *  luminance  )

static

Definition at line 7168 of file arb_program_shader.c.

{
    const char *tex;
    static const float nv12_coef[]
            = {2.0f / 3.0f, 1.0f / 3.0f, 1.0f, 1.0f};
 
    tex = arbfp_texture_target(type->res_type);
 
    /* NV12 surfaces contain a WxH sized luminance plane, followed by a (W/2)x(H/2)
     * sized plane where each component is an UV pair. So the effective
     * bitdepth is 12 bits per pixel If the whole texture is interpreted as luminance
     * data it looks approximately like this:
     *
     *        +----------------------------------+----
     *        |                                  |
     *        |                                  |
     *        |                                  |
     *        |                                  |
     *        |                                  |   2
     *        |            LUMINANCE             |   -
     *        |                                  |   3
     *        |                                  |
     *        |                                  |
     *        |                                  |
     *        |                                  |
     *        +----------------------------------+----
     *        |UVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUV|
     *        |UVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUVUV|
     *        |                                  |   1
     *        |                                  |   -
     *        |                                  |   3
     *        |                                  |
     *        |                                  |
     *        +----------------------------------+----
     *
     * When reading from rectangle textures, keep in mind that the input y coordinates
     * go from 0 to d3d_height, whereas the opengl texture height is 1.5 * d3d_height. */
 
    shader_addline(buffer, "PARAM nv12_coef = ");
    shader_arb_append_imm_vec4(buffer, nv12_coef);
    shader_addline(buffer, ";\n");
 
    shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
    /* We only have half the number of chroma pixels. */
    shader_addline(buffer, "MUL texcrd.x, texcrd.x, coef.y;\n");
 
    if (type->res_type == WINED3D_GL_RES_TYPE_TEX_2D)
    {
        shader_addline(buffer, "RCP chroma.w, size.x;\n");
        shader_addline(buffer, "RCP chroma.z, size.y;\n");
 
        shader_addline(buffer, "MAD texcrd.y, texcrd.y, nv12_coef.y, nv12_coef.x;\n");
 
        /* We must not allow filtering horizontally, this would mix U and V.
         * Vertical filtering is ok. However, bear in mind that the pixel center is at
         * 0.5, so add 0.5. */
 
        /* Convert to non-normalized coordinates so we can find the
         * individual pixel. */
        shader_addline(buffer, "MUL texcrd.x, texcrd.x, size.x;\n");
        shader_addline(buffer, "FLR texcrd.x, texcrd.x;\n");
        /* Multiply by 2 since chroma components are stored in UV pixel pairs,
         * add 0.5 to hit the center of the pixel. */
        shader_addline(buffer, "MAD texcrd.x, texcrd.x, coef.z, coef.y;\n");
 
        /* Convert back to normalized coordinates. */
        shader_addline(buffer, "MUL texcrd.x, texcrd.x, chroma.w;\n");
 
        /* Clamp, keep the half pixel origin in mind. */
        shader_addline(buffer, "MAD temp.y, coef.y, chroma.z, nv12_coef.x;\n");
        shader_addline(buffer, "MAX texcrd.y, temp.y, texcrd.y;\n");
        shader_addline(buffer, "MAD temp.y, -coef.y, chroma.z, nv12_coef.z;\n");
        shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
    }
    else
    {
        /* Read from [size - size+size/2] */
        shader_addline(buffer, "MAD texcrd.y, texcrd.y, coef.y, size.y;\n");
 
        shader_addline(buffer, "FLR texcrd.x, texcrd.x;\n");
        /* Multiply by 2 since chroma components are stored in UV pixel pairs,
         * add 0.5 to hit the center of the pixel. */
        shader_addline(buffer, "MAD texcrd.x, texcrd.x, coef.z, coef.y;\n");
 
        /* Clamp */
        shader_addline(buffer, "MAD temp.y, size.y, coef.y, size.y;\n");
        shader_addline(buffer, "ADD temp.y, temp.y, -coef.y;\n");
        shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
        shader_addline(buffer, "ADD temp.y, size.y, coef.y;\n");
        shader_addline(buffer, "MAX texcrd.y, temp.y, texcrd.y;\n");
    }
    /* Read the texture, put the result into the output register. */
    shader_addline(buffer, "TEX temp, texcrd, texture[0], %s;\n", tex);
    shader_addline(buffer, "MOV chroma.y, temp.w;\n");
 
    if (type->res_type == WINED3D_GL_RES_TYPE_TEX_2D)
    {
        /* Add 1/size.x */
        shader_addline(buffer, "ADD texcrd.x, texcrd.x, chroma.w;\n");
    }
    else
    {
        /* Add 1 */
        shader_addline(buffer, "ADD texcrd.x, texcrd.x, coef.x;\n");
    }
    shader_addline(buffer, "TEX temp, texcrd, texture[0], %s;\n", tex);
    shader_addline(buffer, "MOV chroma.x, temp.w;\n");
 
    /* Sample the luminance value. It is in the top 2/3rd of the texture, so scale the y coordinate.
     * Clamp the y coordinate to prevent the chroma values from bleeding into the sampled luminance
     * values due to filtering. */
    shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
    if (type->res_type == WINED3D_GL_RES_TYPE_TEX_2D)
    {
        /* Multiply the y coordinate by 2/3 and clamp it */
        shader_addline(buffer, "MUL texcrd.y, texcrd.y, nv12_coef.x;\n");
        shader_addline(buffer, "MAD temp.y, -coef.y, chroma.w, nv12_coef.x;\n");
        shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
        shader_addline(buffer, "TEX luminance, texcrd, texture[0], %s;\n", tex);
    }
    else
    {
        /* Reading from texture_rectangles is pretty straightforward, just use the unmodified
         * texture coordinate. It is still a good idea to clamp it though, since the opengl texture
         * is bigger
         */
        shader_addline(buffer, "ADD temp.x, size.y, -coef.y;\n");
        shader_addline(buffer, "MIN texcrd.y, texcrd.y, size.x;\n");
        shader_addline(buffer, "TEX luminance, texcrd, texture[0], %s;\n", tex);
    }
    *luminance = 'a';
 
    return TRUE;
}

Referenced by gen_yuv_shader().

gen_p8_shader()

static GLuint gen_p8_shader ( const struct wined3d_gl_info *  gl_info, const struct arbfp_blit_type *  type  )

static

Definition at line 7305 of file arb_program_shader.c.

{
    GLuint shader;
    struct wined3d_string_buffer buffer;
    const char *tex_target = arbfp_texture_target(type->res_type);
 
    /* This should not happen because we only use this conversion for
     * present blits which don't use color keying. */
    if (type->use_color_key)
        FIXME("Implement P8 color keying.\n");
 
    /* Shader header */
    if (!string_buffer_init(&buffer))
    {
        ERR("Failed to initialize shader buffer.\n");
        return 0;
    }
 
    GL_EXTCALL(glGenProgramsARB(1, &shader));
    GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader));
    if (!shader)
    {
        string_buffer_free(&buffer);
        return 0;
    }
 
    shader_addline(&buffer, "!!ARBfp1.0\n");
    shader_addline(&buffer, "TEMP index;\n");
 
    /* { 255/256, 0.5/255*255/256, 0, 0 } */
    shader_addline(&buffer, "PARAM constants = { 0.996, 0.00195, 0, 0 };\n");
 
    /* The alpha-component contains the palette index */
    shader_addline(&buffer, "TEX index, fragment.texcoord[0], texture[0], %s;\n", tex_target);
 
    /* Scale the index by 255/256 and add a bias of '0.5' in order to sample in the middle */
    shader_addline(&buffer, "MAD index.a, index.a, constants.x, constants.y;\n");
 
    /* Use the alpha-component as an index in the palette to get the final color */
    shader_addline(&buffer, "TEX result.color, index.a, texture[1], 1D;\n");
    shader_addline(&buffer, "END\n");
 
    shader_arb_compile(gl_info, GL_FRAGMENT_PROGRAM_ARB, buffer.buffer);
 
    string_buffer_free(&buffer);
 
    return shader;
}

Referenced by arbfp_blit_set().

gen_planar_yuv_read()

static BOOL gen_planar_yuv_read ( struct wined3d_string_buffer *  buffer, const struct arbfp_blit_type *  type, char *  luminance  )

static

Definition at line 6931 of file arb_program_shader.c.

{
    char chroma;
    const char *tex, *texinstr = "TXP";
 
    if (type->fixup == COMPLEX_FIXUP_UYVY)
    {
        chroma = 'x';
        *luminance = 'w';
    }
    else
    {
        chroma = 'w';
        *luminance = 'x';
    }
 
    tex = arbfp_texture_target(type->res_type);
    if (type->res_type == WINED3D_GL_RES_TYPE_TEX_RECT)
        texinstr = "TEX";
 
    /* First we have to read the chroma values. This means we need at least two pixels(no filtering),
     * or 4 pixels(with filtering). To get the unmodified chromas, we have to rid ourselves of the
     * filtering when we sample the texture.
     *
     * These are the rules for reading the chroma:
     *
     * Even pixel: Cr
     * Even pixel: U
     * Odd pixel: V
     *
     * So we have to get the sampling x position in non-normalized coordinates in integers
     */
    if (type->res_type != WINED3D_GL_RES_TYPE_TEX_RECT)
    {
        shader_addline(buffer, "MUL texcrd.xy, fragment.texcoord[0], size.x;\n");
        shader_addline(buffer, "MOV texcrd.w, size.x;\n");
    }
    else
    {
        shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
    }
    /* We must not allow filtering between pixel x and x+1, this would mix U and V
     * Vertical filtering is ok. However, bear in mind that the pixel center is at
     * 0.5, so add 0.5.
     */
    shader_addline(buffer, "FLR texcrd.x, texcrd.x;\n");
    shader_addline(buffer, "ADD texcrd.x, texcrd.x, coef.y;\n");
 
    /* Divide the x coordinate by 0.5 and get the fraction. This gives 0.25 and 0.75 for the
     * even and odd pixels respectively
     */
    shader_addline(buffer, "MUL texcrd2, texcrd, coef.y;\n");
    shader_addline(buffer, "FRC texcrd2, texcrd2;\n");
 
    /* Sample Pixel 1 */
    shader_addline(buffer, "%s luminance, texcrd, texture[0], %s;\n", texinstr, tex);
 
    /* Put the value into either of the chroma values */
    shader_addline(buffer, "SGE temp.x, texcrd2.x, coef.y;\n");
    shader_addline(buffer, "MUL chroma.x, luminance.%c, temp.x;\n", chroma);
    shader_addline(buffer, "SLT temp.x, texcrd2.x, coef.y;\n");
    shader_addline(buffer, "MUL chroma.y, luminance.%c, temp.x;\n", chroma);
 
    /* Sample pixel 2. If we read an even pixel(SLT above returned 1), sample
     * the pixel right to the current one. Otherwise, sample the left pixel.
     * Bias and scale the SLT result to -1;1 and add it to the texcrd.x.
     */
    shader_addline(buffer, "MAD temp.x, temp.x, coef.z, -coef.x;\n");
    shader_addline(buffer, "ADD texcrd.x, texcrd, temp.x;\n");
    shader_addline(buffer, "%s luminance, texcrd, texture[0], %s;\n", texinstr, tex);
 
    /* Put the value into the other chroma */
    shader_addline(buffer, "SGE temp.x, texcrd2.x, coef.y;\n");
    shader_addline(buffer, "MAD chroma.y, luminance.%c, temp.x, chroma.y;\n", chroma);
    shader_addline(buffer, "SLT temp.x, texcrd2.x, coef.y;\n");
    shader_addline(buffer, "MAD chroma.x, luminance.%c, temp.x, chroma.x;\n", chroma);
 
    /* TODO: If filtering is enabled, sample a 2nd pair of pixels left or right of
     * the current one and lerp the two U and V values
     */
 
    /* This gives the correctly filtered luminance value */
    shader_addline(buffer, "TEX luminance, fragment.texcoord[0], texture[0], %s;\n", tex);
 
    return TRUE;
}

Referenced by gen_yuv_shader().

gen_yuv_shader()

static GLuint gen_yuv_shader ( const struct wined3d_gl_info *  gl_info, const struct arbfp_blit_type *  type  )

static

Definition at line 7392 of file arb_program_shader.c.

{
    GLuint shader;
    struct wined3d_string_buffer buffer;
    char luminance_component;
 
    if (type->use_color_key)
        FIXME("Implement YUV color keying.\n");
 
    /* Shader header */
    if (!string_buffer_init(&buffer))
    {
        ERR("Failed to initialize shader buffer.\n");
        return 0;
    }
 
    GL_EXTCALL(glGenProgramsARB(1, &shader));
    checkGLcall("GL_EXTCALL(glGenProgramsARB(1, &shader))");
    GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader));
    checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader)");
    if (!shader)
    {
        string_buffer_free(&buffer);
        return 0;
    }
 
    /* The YUY2 and UYVY formats contain two pixels packed into a 32 bit macropixel,
     * giving effectively 16 bit per pixel. The color consists of a luminance(Y) and
     * two chroma(U and V) values. Each macropixel has two luminance values, one for
     * each single pixel it contains, and one U and one V value shared between both
     * pixels.
     *
     * The data is loaded into an A8L8 texture. With YUY2, the luminance component
     * contains the luminance and alpha the chroma. With UYVY it is vice versa. Thus
     * take the format into account when generating the read swizzles
     *
     * Reading the Y value is straightforward - just sample the texture. The hardware
     * takes care of filtering in the horizontal and vertical direction.
     *
     * Reading the U and V values is harder. We have to avoid filtering horizontally,
     * because that would mix the U and V values of one pixel or two adjacent pixels.
     * Thus floor the texture coordinate and add 0.5 to get an unfiltered read,
     * regardless of the filtering setting. Vertical filtering works automatically
     * though - the U and V values of two rows are mixed nicely.
     *
     * Apart of avoiding filtering issues, the code has to know which value it just
     * read, and where it can find the other one. To determine this, it checks if
     * it sampled an even or odd pixel, and shifts the 2nd read accordingly.
     *
     * Handling horizontal filtering of U and V values requires reading a 2nd pair
     * of pixels, extracting U and V and mixing them. This is not implemented yet.
     *
     * An alternative implementation idea is to load the texture as A8R8G8B8 texture,
     * with width / 2. This way one read gives all 3 values, finding U and V is easy
     * in an unfiltered situation. Finding the luminance on the other hand requires
     * finding out if it is an odd or even pixel. The real drawback of this approach
     * is filtering. This would have to be emulated completely in the shader, reading
     * up two 2 packed pixels in up to 2 rows and interpolating both horizontally and
     * vertically. Beyond that it would require adjustments to the texture handling
     * code to deal with the width scaling
     */
    shader_addline(&buffer, "!!ARBfp1.0\n");
    shader_addline(&buffer, "TEMP luminance;\n");
    shader_addline(&buffer, "TEMP temp;\n");
    shader_addline(&buffer, "TEMP chroma;\n");
    shader_addline(&buffer, "TEMP texcrd;\n");
    shader_addline(&buffer, "TEMP texcrd2;\n");
    shader_addline(&buffer, "PARAM coef = {1.0, 0.5, 2.0, 0.25};\n");
    shader_addline(&buffer, "PARAM yuv_coef = {1.403, 0.344, 0.714, 1.770};\n");
    shader_addline(&buffer, "PARAM size = program.local[%u];\n", ARBFP_BLIT_PARAM_SIZE);
 
    switch (type->fixup)
    {
        case COMPLEX_FIXUP_UYVY:
        case COMPLEX_FIXUP_YUY2:
            if (!gen_planar_yuv_read(&buffer, type, &luminance_component))
            {
                string_buffer_free(&buffer);
                return 0;
            }
            break;
 
        case COMPLEX_FIXUP_YV12:
            if (!gen_yv12_read(&buffer, type, &luminance_component))
            {
                string_buffer_free(&buffer);
                return 0;
            }
            break;
 
        case COMPLEX_FIXUP_NV12:
            if (!gen_nv12_read(&buffer, type, &luminance_component))
            {
                string_buffer_free(&buffer);
                return 0;
            }
            break;
 
        default:
            FIXME("Unsupported YUV fixup %#x\n", type->fixup);
            string_buffer_free(&buffer);
            return 0;
    }
 
    /* Calculate the final result. Formula is taken from
     * http://www.fourcc.org/fccyvrgb.php. Note that the chroma
     * ranges from -0.5 to 0.5
     */
    shader_addline(&buffer, "SUB chroma.xy, chroma, coef.y;\n");
 
    shader_addline(&buffer, "MAD result.color.x, chroma.x, yuv_coef.x, luminance.%c;\n", luminance_component);
    shader_addline(&buffer, "MAD temp.x, -chroma.y, yuv_coef.y, luminance.%c;\n", luminance_component);
    shader_addline(&buffer, "MAD result.color.y, -chroma.x, yuv_coef.z, temp.x;\n");
    shader_addline(&buffer, "MAD result.color.z, chroma.y, yuv_coef.w, luminance.%c;\n", luminance_component);
    shader_addline(&buffer, "END\n");
 
    shader_arb_compile(gl_info, GL_FRAGMENT_PROGRAM_ARB, buffer.buffer);
 
    string_buffer_free(&buffer);
 
    return shader;
}

Referenced by arbfp_blit_set().

gen_yv12_read()

static BOOL gen_yv12_read ( struct wined3d_string_buffer *  buffer, const struct arbfp_blit_type *  type, char *  luminance  )

static

Definition at line 7019 of file arb_program_shader.c.

{
    const char *tex;
    static const float yv12_coef[]
            = {2.0f / 3.0f, 1.0f / 6.0f, (2.0f / 3.0f) + (1.0f / 6.0f), 1.0f / 3.0f};
 
    tex = arbfp_texture_target(type->res_type);
 
    /* YV12 surfaces contain a WxH sized luminance plane, followed by a (W/2)x(H/2)
     * V and a (W/2)x(H/2) U plane, each with 8 bit per pixel. So the effective
     * bitdepth is 12 bits per pixel. Since the U and V planes have only half the
     * pitch of the luminance plane, the packing into the gl texture is a bit
     * unfortunate. If the whole texture is interpreted as luminance data it looks
     * approximately like this:
     *
     *        +----------------------------------+----
     *        |                                  |
     *        |                                  |
     *        |                                  |
     *        |                                  |
     *        |                                  |   2
     *        |            LUMINANCE             |   -
     *        |                                  |   3
     *        |                                  |
     *        |                                  |
     *        |                                  |
     *        |                                  |
     *        +----------------+-----------------+----
     *        |                |                 |
     *        |  V even rows   |  V odd rows     |
     *        |                |                 |   1
     *        +----------------+------------------   -
     *        |                |                 |   3
     *        |  U even rows   |  U odd rows     |
     *        |                |                 |
     *        +----------------+-----------------+----
     *        |                |                 |
     *        |     0.5        |       0.5       |
     *
     * So it appears as if there are 4 chroma images, but in fact the odd rows
     * in the chroma images are in the same row as the even ones. So it is
     * kinda tricky to read
     *
     * When reading from rectangle textures, keep in mind that the input y coordinates
     * go from 0 to d3d_height, whereas the opengl texture height is 1.5 * d3d_height
     */
    shader_addline(buffer, "PARAM yv12_coef = ");
    shader_arb_append_imm_vec4(buffer, yv12_coef);
    shader_addline(buffer, ";\n");
 
    shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
    /* the chroma planes have only half the width */
    shader_addline(buffer, "MUL texcrd.x, texcrd.x, coef.y;\n");
 
    /* The first value is between 2/3 and 5/6th of the texture's height, so scale+bias
     * the coordinate. Also read the right side of the image when reading odd lines
     *
     * Don't forget to clamp the y values in into the range, otherwise we'll get filtering
     * bleeding
     */
    if (type->res_type == WINED3D_GL_RES_TYPE_TEX_2D)
    {
 
        shader_addline(buffer, "RCP chroma.w, size.y;\n");
 
        shader_addline(buffer, "MUL texcrd2.y, texcrd.y, size.y;\n");
 
        shader_addline(buffer, "FLR texcrd2.y, texcrd2.y;\n");
        shader_addline(buffer, "MAD texcrd.y, texcrd.y, yv12_coef.y, yv12_coef.x;\n");
 
        /* Read odd lines from the right side(add size * 0.5 to the x coordinate */
        shader_addline(buffer, "ADD texcrd2.x, texcrd2.y, yv12_coef.y;\n"); /* To avoid 0.5 == 0.5 comparisons */
        shader_addline(buffer, "FRC texcrd2.x, texcrd2.x;\n");
        shader_addline(buffer, "SGE texcrd2.x, texcrd2.x, coef.y;\n");
        shader_addline(buffer, "MAD texcrd.x, texcrd2.x, coef.y, texcrd.x;\n");
 
        /* clamp, keep the half pixel origin in mind */
        shader_addline(buffer, "MAD temp.y, coef.y, chroma.w, yv12_coef.x;\n");
        shader_addline(buffer, "MAX texcrd.y, temp.y, texcrd.y;\n");
        shader_addline(buffer, "MAD temp.y, -coef.y, chroma.w, yv12_coef.z;\n");
        shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
    }
    else
    {
        /* Read from [size - size+size/4] */
        shader_addline(buffer, "FLR texcrd.y, texcrd.y;\n");
        shader_addline(buffer, "MAD texcrd.y, texcrd.y, coef.w, size.y;\n");
 
        /* Read odd lines from the right side(add size * 0.5 to the x coordinate */
        shader_addline(buffer, "ADD texcrd2.x, texcrd.y, yv12_coef.y;\n"); /* To avoid 0.5 == 0.5 comparisons */
        shader_addline(buffer, "FRC texcrd2.x, texcrd2.x;\n");
        shader_addline(buffer, "SGE texcrd2.x, texcrd2.x, coef.y;\n");
        shader_addline(buffer, "MUL texcrd2.x, texcrd2.x, size.x;\n");
        shader_addline(buffer, "MAD texcrd.x, texcrd2.x, coef.y, texcrd.x;\n");
 
        /* Make sure to read exactly from the pixel center */
        shader_addline(buffer, "FLR texcrd.y, texcrd.y;\n");
        shader_addline(buffer, "ADD texcrd.y, texcrd.y, coef.y;\n");
 
        /* Clamp */
        shader_addline(buffer, "MAD temp.y, size.y, coef.w, size.y;\n");
        shader_addline(buffer, "ADD temp.y, temp.y, -coef.y;\n");
        shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
        shader_addline(buffer, "ADD temp.y, size.y, coef.y;\n");
        shader_addline(buffer, "MAX texcrd.y, temp.y, texcrd.y;\n");
    }
    /* Read the texture, put the result into the output register */
    shader_addline(buffer, "TEX temp, texcrd, texture[0], %s;\n", tex);
    shader_addline(buffer, "MOV chroma.x, temp.w;\n");
 
    /* The other chroma value is 1/6th of the texture lower, from 5/6th to 6/6th
     * No need to clamp because we're just reusing the already clamped value from above
     */
    if (type->res_type == WINED3D_GL_RES_TYPE_TEX_2D)
        shader_addline(buffer, "ADD texcrd.y, texcrd.y, yv12_coef.y;\n");
    else
        shader_addline(buffer, "MAD texcrd.y, size.y, coef.w, texcrd.y;\n");
    shader_addline(buffer, "TEX temp, texcrd, texture[0], %s;\n", tex);
    shader_addline(buffer, "MOV chroma.y, temp.w;\n");
 
    /* Sample the luminance value. It is in the top 2/3rd of the texture, so scale the y coordinate.
     * Clamp the y coordinate to prevent the chroma values from bleeding into the sampled luminance
     * values due to filtering
     */
    shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
    if (type->res_type == WINED3D_GL_RES_TYPE_TEX_2D)
    {
        /* Multiply the y coordinate by 2/3 and clamp it */
        shader_addline(buffer, "MUL texcrd.y, texcrd.y, yv12_coef.x;\n");
        shader_addline(buffer, "MAD temp.y, -coef.y, chroma.w, yv12_coef.x;\n");
        shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
        shader_addline(buffer, "TEX luminance, texcrd, texture[0], %s;\n", tex);
    }
    else
    {
        /* Reading from texture_rectangles is pretty straightforward, just use the unmodified
         * texture coordinate. It is still a good idea to clamp it though, since the opengl texture
         * is bigger
         */
        shader_addline(buffer, "ADD temp.x, size.y, -coef.y;\n");
        shader_addline(buffer, "MIN texcrd.y, texcrd.y, size.x;\n");
        shader_addline(buffer, "TEX luminance, texcrd, texture[0], %s;\n", tex);
    }
    *luminance = 'a';
 
    return TRUE;
}

Referenced by gen_yuv_shader().

get_argreg()

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

static

Definition at line 6016 of file arb_program_shader.c.

{
    const char *ret;
 
    if(arg == ARG_UNUSED) return "unused"; /* This is the marker for unused registers */
 
    switch(arg & WINED3DTA_SELECTMASK) {
        case WINED3DTA_DIFFUSE:
            ret = "fragment.color.primary"; break;
 
        case WINED3DTA_CURRENT:
            ret = "ret";
            break;
 
        case WINED3DTA_TEXTURE:
            switch(stage) {
                case 0: ret = "tex0"; break;
                case 1: ret = "tex1"; break;
                case 2: ret = "tex2"; break;
                case 3: ret = "tex3"; break;
                case 4: ret = "tex4"; break;
                case 5: ret = "tex5"; break;
                case 6: ret = "tex6"; break;
                case 7: ret = "tex7"; break;
                default: ret = "unknown texture";
            }
            break;
 
        case WINED3DTA_TFACTOR:
            ret = "tfactor"; break;
 
        case WINED3DTA_SPECULAR:
            ret = "fragment.color.secondary"; break;
 
        case WINED3DTA_TEMP:
            ret = "tempreg"; break;
 
        case WINED3DTA_CONSTANT:
            switch(stage) {
                case 0: ret = "const0"; break;
                case 1: ret = "const1"; break;
                case 2: ret = "const2"; break;
                case 3: ret = "const3"; break;
                case 4: ret = "const4"; break;
                case 5: ret = "const5"; break;
                case 6: ret = "const6"; break;
                case 7: ret = "const7"; break;
                default: ret = "unknown constant";
            }
            break;
 
        default:
            return "unknown";
    }
 
    if(arg & WINED3DTA_COMPLEMENT) {
        shader_addline(buffer, "SUB arg%u, const.x, %s;\n", argnum, ret);
        if(argnum == 0) ret = "arg0";
        if(argnum == 1) ret = "arg1";
        if(argnum == 2) ret = "arg2";
    }
    if(arg & WINED3DTA_ALPHAREPLICATE) {
        shader_addline(buffer, "MOV arg%u, %s.w;\n", argnum, ret);
        if(argnum == 0) ret = "arg0";
        if(argnum == 1) ret = "arg1";
        if(argnum == 2) ret = "arg2";
    }
    return ret;
}

Referenced by gen_ffp_instr().

get_bool_const()

static BOOL get_bool_const ( const struct wined3d_shader_instruction *  ins, const struct wined3d_shader *  shader, DWORD  idx  )

static

Definition at line 5253 of file arb_program_shader.c.

{
    const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
    BOOL vshader = shader_is_vshader_version(reg_maps->shader_version.type);
    const struct wined3d_shader_lconst *constant;
    WORD