自学教程：C++ ureg_END函数代码示例

static void *create_copy_frag_shader(struct vl_deint_filter *filter, unsigned field){   struct ureg_program *shader;   struct ureg_src i_vtex;   struct ureg_src sampler;   struct ureg_dst o_fragment;   struct ureg_dst t_tex;   shader = ureg_create(PIPE_SHADER_FRAGMENT);   if (!shader) {      return NULL;   }   t_tex = ureg_DECL_temporary(shader);   i_vtex = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   sampler = ureg_DECL_sampler(shader, 2);   o_fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   ureg_MOV(shader, t_tex, i_vtex);   if (field) {      ureg_MOV(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_ZW),               ureg_imm4f(shader, 0, 0, 1.0f, 0));   } else {      ureg_MOV(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_ZW),               ureg_imm1f(shader, 0));   }   ureg_TEX(shader, o_fragment, TGSI_TEXTURE_2D_ARRAY, ureg_src(t_tex), sampler);   ureg_release_temporary(shader, t_tex);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, filter->pipe);}

/** * Make a fragment shader that copies the input color to N output colors. */void *util_make_fragment_clonecolor_shader(struct pipe_context *pipe, int num_cbufs){   struct ureg_program *ureg;   struct ureg_src src;   struct ureg_dst dst[PIPE_MAX_COLOR_BUFS];   int i;   assert(num_cbufs <= PIPE_MAX_COLOR_BUFS);   ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );   if (ureg == NULL)      return NULL;   src = ureg_DECL_fs_input( ureg, TGSI_SEMANTIC_COLOR, 0,                              TGSI_INTERPOLATE_PERSPECTIVE );   for (i = 0; i < num_cbufs; i++)      dst[i] = ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, i );   for (i = 0; i < num_cbufs; i++)      ureg_MOV( ureg, dst[i], src );   ureg_END( ureg );   return ureg_create_shader_and_destroy( ureg, pipe );}

/** * Create a simple vertex shader that just passes through the * vertex position and texcoord (and optionally, color). */static void *make_passthrough_vertex_shader(struct st_context *st,                                GLboolean passColor){   if (!st->drawpix.vert_shaders[passColor]) {      struct ureg_program *ureg = ureg_create( TGSI_PROCESSOR_VERTEX );      if (ureg == NULL)         return NULL;      /* MOV result.pos, vertex.pos; */      ureg_MOV(ureg,                ureg_DECL_output( ureg, TGSI_SEMANTIC_POSITION, 0 ),               ureg_DECL_vs_input( ureg, 0 ));            /* MOV result.texcoord0, vertex.attr[1]; */      ureg_MOV(ureg,                ureg_DECL_output( ureg, TGSI_SEMANTIC_GENERIC, 0 ),               ureg_DECL_vs_input( ureg, 1 ));            if (passColor) {         /* MOV result.color0, vertex.attr[2]; */         ureg_MOV(ureg,                   ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, 0 ),                  ureg_DECL_vs_input( ureg, 2 ));      }      ureg_END( ureg );            st->drawpix.vert_shaders[passColor] =          ureg_create_shader_and_destroy( ureg, st->pipe );   }   return st->drawpix.vert_shaders[passColor];}

/** * Create a simple vertex shader that passes through position and the given * attribute. */static void *create_passthrough_vs(struct pipe_context *pipe, int semantic_name){   struct ureg_program *ureg;   struct ureg_src src[2], constants[3];   struct ureg_dst dst[2], tmp;   int i;   ureg = ureg_create(TGSI_PROCESSOR_VERTEX);   if (!ureg)      return NULL;   /* position is in user coordinates */   src[0] = ureg_DECL_vs_input(ureg, 0);   dst[0] = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);   tmp = ureg_DECL_temporary(ureg);   for (i = 0; i < Elements(constants); i++)      constants[i] = ureg_DECL_constant(ureg, i);   /* transform to clipped coordinates */   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_X), src[0], constants[0]);   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Y), src[0], constants[1]);   ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Z), src[0]);   ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_W), src[0], constants[2]);   ureg_MOV(ureg, dst[0], ureg_src(tmp));   if (semantic_name >= 0) {      src[1] = ureg_DECL_vs_input(ureg, 1);      dst[1] = ureg_DECL_output(ureg, semantic_name, 0);      ureg_MOV(ureg, dst[1], src[1]);   }   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, pipe);}

/** * If we fail to compile a vertex shader we'll use a dummy/fallback shader * that simply emits a (0,0,0,1) vertex position. */static const struct tgsi_token *get_dummy_vertex_shader(void){   static const float zero[4] = { 0.0, 0.0, 0.0, 1.0 };   struct ureg_program *ureg;   const struct tgsi_token *tokens;   struct ureg_src src;   struct ureg_dst dst;   unsigned num_tokens;   ureg = ureg_create(TGSI_PROCESSOR_VERTEX);   if (!ureg)      return NULL;   dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);   src = ureg_DECL_immediate(ureg, zero, 4);   ureg_MOV(ureg, dst, src);   ureg_END(ureg);   tokens = ureg_get_tokens(ureg, &num_tokens);   ureg_destroy(ureg);   return tokens;}

static void *create_frag_shader_rgba(struct vl_compositor *c){   struct ureg_program *shader;   struct ureg_src tc, color, sampler;   struct ureg_dst texel, fragment;   shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (!shader)      return false;   tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   color = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_COLOR, VS_O_COLOR, TGSI_INTERPOLATE_LINEAR);   sampler = ureg_DECL_sampler(shader, 0);   texel = ureg_DECL_temporary(shader);   fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   /*    * fragment = tex(tc, sampler)    */   ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);   ureg_MUL(shader, fragment, ureg_src(texel), color);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, c->pipe);}

void *util_make_vertex_passthrough_shader_with_so(struct pipe_context *pipe,                                    uint num_attribs,                                    const uint *semantic_names,                                    const uint *semantic_indexes,                                    bool window_space,				    const struct pipe_stream_output_info *so){   struct ureg_program *ureg;   uint i;   ureg = ureg_create( PIPE_SHADER_VERTEX );   if (!ureg)      return NULL;   if (window_space)      ureg_property(ureg, TGSI_PROPERTY_VS_WINDOW_SPACE_POSITION, TRUE);   for (i = 0; i < num_attribs; i++) {      struct ureg_src src;      struct ureg_dst dst;      src = ureg_DECL_vs_input( ureg, i );            dst = ureg_DECL_output( ureg,                              semantic_names[i],                              semantic_indexes[i]);            ureg_MOV( ureg, dst, src );   }   ureg_END( ureg );   return ureg_create_shader_with_so_and_destroy( ureg, pipe, so );}

void *util_make_vertex_passthrough_shader_with_so(struct pipe_context *pipe,                                    uint num_attribs,                                    const uint *semantic_names,                                    const uint *semantic_indexes,				    const struct pipe_stream_output_info *so){   struct ureg_program *ureg;   uint i;   ureg = ureg_create( TGSI_PROCESSOR_VERTEX );   if (ureg == NULL)      return NULL;   for (i = 0; i < num_attribs; i++) {      struct ureg_src src;      struct ureg_dst dst;      src = ureg_DECL_vs_input( ureg, i );            dst = ureg_DECL_output( ureg,                              semantic_names[i],                              semantic_indexes[i]);            ureg_MOV( ureg, dst, src );   }   ureg_END( ureg );   return ureg_create_shader_with_so_and_destroy( ureg, pipe, so );}

/** * Make a fragment shader that copies the input color to N output colors. */void *util_make_fragment_cloneinput_shader(struct pipe_context *pipe, int num_cbufs,                                     int input_semantic,                                     int input_interpolate){   struct ureg_program *ureg;   struct ureg_src src;   struct ureg_dst dst[PIPE_MAX_COLOR_BUFS];   int i;   assert(num_cbufs <= PIPE_MAX_COLOR_BUFS);   ureg = ureg_create( PIPE_SHADER_FRAGMENT );   if (!ureg)      return NULL;   src = ureg_DECL_fs_input( ureg, input_semantic, 0,                             input_interpolate );   for (i = 0; i < num_cbufs; i++)      dst[i] = ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, i );   for (i = 0; i < num_cbufs; i++)      ureg_MOV( ureg, dst[i], src );   ureg_END( ureg );   return ureg_create_shader_and_destroy( ureg, pipe );}

/** * If we fail to compile a fragment shader (because it uses too many * registers, for example) we'll use a dummy/fallback shader that * simply emits a constant color (red for debug, black for release). * We hit this with the Unigine/Heaven demo when Shaders = High. * With black, the demo still looks good. */static const struct tgsi_token *get_dummy_fragment_shader(void){#ifdef DEBUG   static const float color[4] = { 1.0, 0.0, 0.0, 0.0 }; /* red */#else   static const float color[4] = { 0.0, 0.0, 0.0, 0.0 }; /* black */#endif   struct ureg_program *ureg;   const struct tgsi_token *tokens;   struct ureg_src src;   struct ureg_dst dst;   unsigned num_tokens;   ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (!ureg)      return NULL;   dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);   src = ureg_DECL_immediate(ureg, color, 4);   ureg_MOV(ureg, dst, src);   ureg_END(ureg);   tokens = ureg_get_tokens(ureg, &num_tokens);   ureg_destroy(ureg);   return tokens;}

static void *fd_prog_blit(struct pipe_context *pctx, int rts, bool depth){	int i;	struct ureg_src tc;	struct ureg_program *ureg;	debug_assert(rts <= MAX_RENDER_TARGETS);	ureg = ureg_create(PIPE_SHADER_FRAGMENT);	if (!ureg)		return NULL;	tc = ureg_DECL_fs_input(			ureg, TGSI_SEMANTIC_GENERIC, 0, TGSI_INTERPOLATE_PERSPECTIVE);	for (i = 0; i < rts; i++)		ureg_TEX(ureg, ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, i),				 TGSI_TEXTURE_2D, tc, ureg_DECL_sampler(ureg, i));	if (depth)		ureg_TEX(ureg,				 ureg_writemask(						 ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0),						 TGSI_WRITEMASK_Z),				 TGSI_TEXTURE_2D, tc, ureg_DECL_sampler(ureg, rts));	ureg_END(ureg);	return ureg_create_shader_and_destroy(ureg, pctx);}

void *util_make_fs_msaa_resolve(struct pipe_context *pipe,                          enum tgsi_texture_type tgsi_tex, unsigned nr_samples,                          enum tgsi_return_type stype){   struct ureg_program *ureg;   struct ureg_src sampler, coord;   struct ureg_dst out, tmp_sum, tmp_coord, tmp;   unsigned i;   ureg = ureg_create(PIPE_SHADER_FRAGMENT);   if (!ureg)      return NULL;   /* Declarations. */   sampler = ureg_DECL_sampler(ureg, 0);   ureg_DECL_sampler_view(ureg, 0, tgsi_tex, stype, stype, stype, stype);   coord = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_GENERIC, 0,                              TGSI_INTERPOLATE_LINEAR);   out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);   tmp_sum = ureg_DECL_temporary(ureg);   tmp_coord = ureg_DECL_temporary(ureg);   tmp = ureg_DECL_temporary(ureg);   /* Instructions. */   ureg_MOV(ureg, tmp_sum, ureg_imm1f(ureg, 0));   ureg_F2U(ureg, tmp_coord, coord);   for (i = 0; i < nr_samples; i++) {      /* Read one sample. */      ureg_MOV(ureg, ureg_writemask(tmp_coord, TGSI_WRITEMASK_W),               ureg_imm1u(ureg, i));      ureg_TXF(ureg, tmp, tgsi_tex, ureg_src(tmp_coord), sampler);      if (stype == TGSI_RETURN_TYPE_UINT)         ureg_U2F(ureg, tmp, ureg_src(tmp));      else if (stype == TGSI_RETURN_TYPE_SINT)         ureg_I2F(ureg, tmp, ureg_src(tmp));      /* Add it to the sum.*/      ureg_ADD(ureg, tmp_sum, ureg_src(tmp_sum), ureg_src(tmp));   }   /* Calculate the average and return. */   ureg_MUL(ureg, tmp_sum, ureg_src(tmp_sum),            ureg_imm1f(ureg, 1.0 / nr_samples));   if (stype == TGSI_RETURN_TYPE_UINT)      ureg_F2U(ureg, out, ureg_src(tmp_sum));   else if (stype == TGSI_RETURN_TYPE_SINT)      ureg_F2I(ureg, out, ureg_src(tmp_sum));   else      ureg_MOV(ureg, out, ureg_src(tmp_sum));   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, pipe);}

/** * Make a simple fragment texture shader which reads the texture unit 0 and 1 * and writes it as depth and stencil, respectively. */void *util_make_fragment_tex_shader_writedepthstencil(struct pipe_context *pipe,                                                unsigned tex_target,                                                unsigned interp_mode,                                                bool load_level_zero,                                                bool use_txf){   struct ureg_program *ureg;   struct ureg_src depth_sampler, stencil_sampler;   struct ureg_src tex;   struct ureg_dst out, depth, stencil;   struct ureg_src imm;   ureg = ureg_create( PIPE_SHADER_FRAGMENT );   if (!ureg)      return NULL;   depth_sampler = ureg_DECL_sampler( ureg, 0 );   ureg_DECL_sampler_view(ureg, 0, tex_target,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT);   stencil_sampler = ureg_DECL_sampler( ureg, 1 );   ureg_DECL_sampler_view(ureg, 0, tex_target,                          TGSI_RETURN_TYPE_UINT,                          TGSI_RETURN_TYPE_UINT,                          TGSI_RETURN_TYPE_UINT,                          TGSI_RETURN_TYPE_UINT);   tex = ureg_DECL_fs_input( ureg,                             TGSI_SEMANTIC_GENERIC, 0,                             interp_mode );   out = ureg_DECL_output( ureg,                           TGSI_SEMANTIC_COLOR,                           0 );   depth = ureg_DECL_output( ureg,                             TGSI_SEMANTIC_POSITION,                             0 );   stencil = ureg_DECL_output( ureg,                             TGSI_SEMANTIC_STENCIL,                             0 );   imm = ureg_imm4f( ureg, 0, 0, 0, 1 );   ureg_MOV( ureg, out, imm );   ureg_load_tex(ureg, ureg_writemask(depth, TGSI_WRITEMASK_Z), tex,                 depth_sampler, tex_target, load_level_zero, use_txf);   ureg_load_tex(ureg, ureg_writemask(stencil, TGSI_WRITEMASK_Y), tex,                 stencil_sampler, tex_target, load_level_zero, use_txf);   ureg_END( ureg );   return ureg_create_shader_and_destroy( ureg, pipe );}

void *st_pbo_create_vs(struct st_context *st){   struct pipe_screen *pscreen = st->pipe->screen;   bool use_nir = PIPE_SHADER_IR_NIR ==      pscreen->get_shader_param(pscreen, PIPE_SHADER_VERTEX,                                PIPE_SHADER_CAP_PREFERRED_IR);   if (use_nir) {      unsigned inputs[] =  {  VERT_ATTRIB_POS, SYSTEM_VALUE_INSTANCE_ID, };      unsigned outputs[] = { VARYING_SLOT_POS,       VARYING_SLOT_LAYER  };      return st_nir_make_passthrough_shader(st, "st/pbo VS",                                            MESA_SHADER_VERTEX,                                            st->pbo.layers ? 2 : 1,                                            inputs, outputs, NULL, (1 << 1));   }   struct ureg_program *ureg;   struct ureg_src in_pos;   struct ureg_src in_instanceid;   struct ureg_dst out_pos;   struct ureg_dst out_layer;   ureg = ureg_create(PIPE_SHADER_VERTEX);   if (!ureg)      return NULL;   in_pos = ureg_DECL_vs_input(ureg, TGSI_SEMANTIC_POSITION);   out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);   if (st->pbo.layers) {      in_instanceid = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_INSTANCEID, 0);      if (!st->pbo.use_gs)         out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);   }   /* out_pos = in_pos */   ureg_MOV(ureg, out_pos, in_pos);   if (st->pbo.layers) {      if (st->pbo.use_gs) {         /* out_pos.z = i2f(gl_InstanceID) */         ureg_I2F(ureg, ureg_writemask(out_pos, TGSI_WRITEMASK_Z),                        ureg_scalar(in_instanceid, TGSI_SWIZZLE_X));      } else {         /* out_layer = gl_InstanceID */         ureg_MOV(ureg, ureg_writemask(out_layer, TGSI_WRITEMASK_X),                        ureg_scalar(in_instanceid, TGSI_SWIZZLE_X));      }   }   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, st->pipe);}

static void *create_yuv_shader(struct pipe_context *pipe, struct ureg_program *ureg){    struct ureg_src y_sampler, u_sampler, v_sampler;    struct ureg_src pos;    struct ureg_src matrow0, matrow1, matrow2;    struct ureg_dst y, u, v, rgb;    struct ureg_dst out = ureg_DECL_output(ureg,					   TGSI_SEMANTIC_COLOR,					   0);    pos = ureg_DECL_fs_input(ureg,			     TGSI_SEMANTIC_GENERIC, 0,			     TGSI_INTERPOLATE_PERSPECTIVE);    rgb = ureg_DECL_temporary(ureg);    y = ureg_DECL_temporary(ureg);    u = ureg_DECL_temporary(ureg);    v = ureg_DECL_temporary(ureg);    y_sampler = ureg_DECL_sampler(ureg, 0);    u_sampler = ureg_DECL_sampler(ureg, 1);    v_sampler = ureg_DECL_sampler(ureg, 2);    matrow0 = ureg_DECL_constant(ureg, 0);    matrow1 = ureg_DECL_constant(ureg, 1);    matrow2 = ureg_DECL_constant(ureg, 2);    ureg_TEX(ureg, y, TGSI_TEXTURE_2D, pos, y_sampler);    ureg_TEX(ureg, u, TGSI_TEXTURE_2D, pos, u_sampler);    ureg_TEX(ureg, v, TGSI_TEXTURE_2D, pos, v_sampler);    ureg_SUB(ureg, u, ureg_src(u), ureg_scalar(matrow0, TGSI_SWIZZLE_W));    ureg_SUB(ureg, v, ureg_src(v), ureg_scalar(matrow0, TGSI_SWIZZLE_W));    ureg_MUL(ureg, rgb, ureg_scalar(ureg_src(y), TGSI_SWIZZLE_X), matrow0);    ureg_MAD(ureg, rgb,	     ureg_scalar(ureg_src(u), TGSI_SWIZZLE_X), matrow1, ureg_src(rgb));    ureg_MAD(ureg, rgb,	     ureg_scalar(ureg_src(v), TGSI_SWIZZLE_X), matrow2, ureg_src(rgb));    /* rgb.a = 1; */    ureg_MOV(ureg, ureg_writemask(rgb, TGSI_WRITEMASK_W),	     ureg_scalar(matrow0, TGSI_SWIZZLE_X));    ureg_MOV(ureg, out, ureg_src(rgb));    ureg_release_temporary(ureg, rgb);    ureg_release_temporary(ureg, y);    ureg_release_temporary(ureg, u);    ureg_release_temporary(ureg, v);    ureg_END(ureg);    return ureg_create_shader_and_destroy(ureg, pipe);}

static void *create_vs(struct pipe_context *pipe, unsigned vs_traits){    struct ureg_program *ureg;    struct ureg_src src;    struct ureg_dst dst;    struct ureg_src const0, const1;    boolean is_fill = (vs_traits & VS_FILL) != 0;    boolean is_composite = (vs_traits & VS_COMPOSITE) != 0;    boolean has_mask = (vs_traits & VS_MASK) != 0;    boolean is_yuv = (vs_traits & VS_YUV) != 0;    unsigned input_slot = 0;    ureg = ureg_create(TGSI_PROCESSOR_VERTEX);    if (ureg == NULL)	return 0;    const0 = ureg_DECL_constant(ureg, 0);    const1 = ureg_DECL_constant(ureg, 1);    /* it has to be either a fill or a composite op */    debug_assert((is_fill ^ is_composite) ^ is_yuv);    src = ureg_DECL_vs_input(ureg, input_slot++);    dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);    src = vs_normalize_coords(ureg, src, const0, const1);    ureg_MOV(ureg, dst, src);    if (is_yuv) {	src = ureg_DECL_vs_input(ureg, input_slot++);	dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 0);	ureg_MOV(ureg, dst, src);    }    if (is_composite) {	src = ureg_DECL_vs_input(ureg, input_slot++);	dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 0);	ureg_MOV(ureg, dst, src);    }    if (is_fill) {	src = ureg_DECL_vs_input(ureg, input_slot++);	dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);	ureg_MOV(ureg, dst, src);    }    if (has_mask) {	src = ureg_DECL_vs_input(ureg, input_slot++);	dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 1);	ureg_MOV(ureg, dst, src);    }    ureg_END(ureg);    return ureg_create_shader_and_destroy(ureg, pipe);}

void *util_make_empty_fragment_shader(struct pipe_context *pipe){   struct ureg_program *ureg = ureg_create(PIPE_SHADER_FRAGMENT);   if (!ureg)      return NULL;   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, pipe);}

void *util_make_empty_fragment_shader(struct pipe_context *pipe){   struct ureg_program *ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (ureg == NULL)      return NULL;   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, pipe);}

static void *create_frag_shader(struct vl_matrix_filter *filter, unsigned num_offsets,                   struct vertex2f *offsets, const float *matrix_values){   struct ureg_program *shader;   struct ureg_src i_vtex;   struct ureg_src sampler;   struct ureg_dst tmp;   struct ureg_dst t_sum;   struct ureg_dst o_fragment;   unsigned i;   shader = ureg_create(PIPE_SHADER_FRAGMENT);   if (!shader) {      return NULL;   }   i_vtex = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   sampler = ureg_DECL_sampler(shader, 0);   ureg_DECL_sampler_view(shader, 0, TGSI_TEXTURE_2D,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT,                          TGSI_RETURN_TYPE_FLOAT);   tmp = ureg_DECL_temporary(shader);   t_sum = ureg_DECL_temporary(shader);   o_fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   ureg_MOV(shader, t_sum, ureg_imm1f(shader, 0.0f));   for (i = 0; i < num_offsets; ++i) {      if (matrix_values[i] == 0.0f)         continue;      if (!is_vec_zero(offsets[i])) {         ureg_ADD(shader, ureg_writemask(tmp, TGSI_WRITEMASK_XY),                  i_vtex, ureg_imm2f(shader, offsets[i].x, offsets[i].y));         ureg_MOV(shader, ureg_writemask(tmp, TGSI_WRITEMASK_ZW),                  ureg_imm1f(shader, 0.0f));         ureg_TEX(shader, tmp, TGSI_TEXTURE_2D, ureg_src(tmp), sampler);      } else {         ureg_TEX(shader, tmp, TGSI_TEXTURE_2D, i_vtex, sampler);      }      ureg_MAD(shader, t_sum, ureg_src(tmp), ureg_imm1f(shader, matrix_values[i]),               ureg_src(t_sum));   }   ureg_MOV(shader, o_fragment, ureg_src(t_sum));   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, filter->pipe);}

static void *create_ref_vert_shader(struct vl_mc *r){   struct ureg_program *shader;   struct ureg_src mv_scale;   struct ureg_src vmv[2];   struct ureg_dst t_vpos;   struct ureg_dst o_vmv[2];   unsigned i;   shader = ureg_create(TGSI_PROCESSOR_VERTEX);   if (!shader)      return NULL;   vmv[0] = ureg_DECL_vs_input(shader, VS_I_MV_TOP);   vmv[1] = ureg_DECL_vs_input(shader, VS_I_MV_BOTTOM);   t_vpos = calc_position(r, shader, ureg_imm2f(shader,      (float)VL_MACROBLOCK_WIDTH / r->buffer_width,      (float)VL_MACROBLOCK_HEIGHT / r->buffer_height)   );   o_vmv[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTOP);   o_vmv[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_VBOTTOM);   /*    * mv_scale.xy = 0.5 / (dst.width, dst.height);    * mv_scale.z = 1.0f / 4.0f    * mv_scale.w = 1.0f / 255.0f    *    * // Apply motion vectors    * o_vmv[0..1].xy = vmv[0..1] * mv_scale + t_vpos    * o_vmv[0..1].zw = vmv[0..1] * mv_scale    *    */   mv_scale = ureg_imm4f(shader,      0.5f / r->buffer_width,      0.5f / r->buffer_height,      1.0f / 4.0f,      1.0f / PIPE_VIDEO_MV_WEIGHT_MAX);   for (i = 0; i < 2; ++i) {      ureg_MAD(shader, ureg_writemask(o_vmv[i], TGSI_WRITEMASK_XY), mv_scale, vmv[i], ureg_src(t_vpos));      ureg_MUL(shader, ureg_writemask(o_vmv[i], TGSI_WRITEMASK_ZW), mv_scale, vmv[i]);   }   ureg_release_temporary(shader, t_vpos);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, r->pipe);}

void *util_make_geometry_passthrough_shader(struct pipe_context *pipe,                                      uint num_attribs,                                      const ubyte *semantic_names,                                      const ubyte *semantic_indexes){   static const unsigned zero[4] = {0, 0, 0, 0};   struct ureg_program *ureg;   struct ureg_dst dst[PIPE_MAX_SHADER_OUTPUTS];   struct ureg_src src[PIPE_MAX_SHADER_INPUTS];   struct ureg_src imm;   unsigned i;   ureg = ureg_create(PIPE_SHADER_GEOMETRY);   if (!ureg)      return NULL;   ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, PIPE_PRIM_POINTS);   ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, PIPE_PRIM_POINTS);   ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES, 1);   ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS, 1);   imm = ureg_DECL_immediate_uint(ureg, zero, 4);   /**    * Loop over all the attribs and declare the corresponding    * declarations in the geometry shader    */   for (i = 0; i < num_attribs; i++) {      src[i] = ureg_DECL_input(ureg, semantic_names[i],                               semantic_indexes[i], 0, 1);      src[i] = ureg_src_dimension(src[i], 0);      dst[i] = ureg_DECL_output(ureg, semantic_names[i], semantic_indexes[i]);   }   /* MOV dst[i] src[i] */   for (i = 0; i < num_attribs; i++) {      ureg_MOV(ureg, dst[i], src[i]);   }   /* EMIT IMM[0] */   ureg_insn(ureg, TGSI_OPCODE_EMIT, NULL, 0, &imm, 1, 0);   /* END */   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, pipe);}

static void *create_frag_shader_palette(struct vl_compositor *c, bool include_cc){   struct ureg_program *shader;   struct ureg_src csc[3];   struct ureg_src tc;   struct ureg_src sampler;   struct ureg_src palette;   struct ureg_dst texel;   struct ureg_dst fragment;   unsigned i;   shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (!shader)      return false;   for (i = 0; include_cc && i < 3; ++i)      csc[i] = ureg_DECL_constant(shader, i);   tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   sampler = ureg_DECL_sampler(shader, 0);   palette = ureg_DECL_sampler(shader, 1);   texel = ureg_DECL_temporary(shader);   fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   /*    * texel = tex(tc, sampler)    * fragment.xyz = tex(texel, palette) * csc    * fragment.a = texel.a    */   ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);   ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_src(texel));   if (include_cc) {      ureg_TEX(shader, texel, TGSI_TEXTURE_1D, ureg_src(texel), palette);      for (i = 0; i < 3; ++i)         ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));   } else {      ureg_TEX(shader, ureg_writemask(fragment, TGSI_WRITEMASK_XYZ),               TGSI_TEXTURE_1D, ureg_src(texel), palette);   }   ureg_release_temporary(shader, texel);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, c->pipe);}

/** * Make a simple fragment texture shader which reads the texture unit 0 and 1 * and writes it as depth and stencil, respectively. */void *util_make_fragment_tex_shader_writedepthstencil(struct pipe_context *pipe,                                                unsigned tex_target,                                                unsigned interp_mode){   struct ureg_program *ureg;   struct ureg_src depth_sampler, stencil_sampler;   struct ureg_src tex;   struct ureg_dst out, depth, stencil;   struct ureg_src imm;   ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );   if (ureg == NULL)      return NULL;   depth_sampler = ureg_DECL_sampler( ureg, 0 );   stencil_sampler = ureg_DECL_sampler( ureg, 1 );   tex = ureg_DECL_fs_input( ureg,                             TGSI_SEMANTIC_GENERIC, 0,                             interp_mode );   out = ureg_DECL_output( ureg,                           TGSI_SEMANTIC_COLOR,                           0 );   depth = ureg_DECL_output( ureg,                             TGSI_SEMANTIC_POSITION,                             0 );   stencil = ureg_DECL_output( ureg,                             TGSI_SEMANTIC_STENCIL,                             0 );   imm = ureg_imm4f( ureg, 0, 0, 0, 1 );   ureg_MOV( ureg, out, imm );   ureg_TEX( ureg,             ureg_writemask(depth, TGSI_WRITEMASK_Z),             tex_target, tex, depth_sampler );   ureg_TEX( ureg,             ureg_writemask(stencil, TGSI_WRITEMASK_Y),             tex_target, tex, stencil_sampler );   ureg_END( ureg );   return ureg_create_shader_and_destroy( ureg, pipe );}

static void *create_mismatch_vert_shader(struct vl_idct *idct){    struct ureg_program *shader;    struct ureg_src vpos;    struct ureg_src scale;    struct ureg_dst t_tex;    struct ureg_dst o_vpos, o_addr[2];    shader = ureg_create(TGSI_PROCESSOR_VERTEX);    if (!shader)        return NULL;    vpos = ureg_DECL_vs_input(shader, VS_I_VPOS);    t_tex = ureg_DECL_temporary(shader);    o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, VS_O_VPOS);    o_addr[0] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR0);    o_addr[1] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, VS_O_L_ADDR1);    /*     * scale = (VL_BLOCK_WIDTH, VL_BLOCK_HEIGHT) / (dst.width, dst.height)     *     * t_vpos = vpos + 7 / VL_BLOCK_WIDTH     * o_vpos.xy = t_vpos * scale     *     * o_addr = calc_addr(...)     *     */    scale = ureg_imm2f(shader,                       (float)VL_BLOCK_WIDTH / idct->buffer_width,                       (float)VL_BLOCK_HEIGHT / idct->buffer_height);    ureg_MAD(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_XY), vpos, scale, scale);    ureg_MOV(shader, ureg_writemask(o_vpos, TGSI_WRITEMASK_ZW), ureg_imm1f(shader, 1.0f));    ureg_MUL(shader, ureg_writemask(t_tex, TGSI_WRITEMASK_XY), vpos, scale);    calc_addr(shader, o_addr, ureg_src(t_tex), ureg_src(t_tex), false, false, idct->buffer_width / 4);    ureg_release_temporary(shader, t_tex);    ureg_END(shader);    return ureg_create_shader_and_destroy(shader, idct->pipe);}

void *st_pbo_create_gs(struct st_context *st){   static const int zero = 0;   struct ureg_program *ureg;   struct ureg_dst out_pos;   struct ureg_dst out_layer;   struct ureg_src in_pos;   struct ureg_src imm;   unsigned i;   ureg = ureg_create(PIPE_SHADER_GEOMETRY);   if (!ureg)      return NULL;   ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, PIPE_PRIM_TRIANGLES);   ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, PIPE_PRIM_TRIANGLE_STRIP);   ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES, 3);   out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);   out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);   in_pos = ureg_DECL_input(ureg, TGSI_SEMANTIC_POSITION, 0, 0, 1);   imm = ureg_DECL_immediate_int(ureg, &zero, 1);   for (i = 0; i < 3; ++i) {      struct ureg_src in_pos_vertex = ureg_src_dimension(in_pos, i);      /* out_pos = in_pos[i] */      ureg_MOV(ureg, out_pos, in_pos_vertex);      /* out_layer.x = f2i(in_pos[i].z) */      ureg_F2I(ureg, ureg_writemask(out_layer, TGSI_WRITEMASK_X),                     ureg_scalar(in_pos_vertex, TGSI_SWIZZLE_Z));      ureg_EMIT(ureg, ureg_scalar(imm, TGSI_SWIZZLE_X));   }   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, st->pipe);}

void *st_pbo_create_vs(struct st_context *st){   struct ureg_program *ureg;   struct ureg_src in_pos;   struct ureg_src in_instanceid;   struct ureg_dst out_pos;   struct ureg_dst out_layer;   ureg = ureg_create(PIPE_SHADER_VERTEX);   if (!ureg)      return NULL;   in_pos = ureg_DECL_vs_input(ureg, TGSI_SEMANTIC_POSITION);   out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);   if (st->pbo.layers) {      in_instanceid = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_INSTANCEID, 0);      if (!st->pbo.use_gs)         out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);   }   /* out_pos = in_pos */   ureg_MOV(ureg, out_pos, in_pos);   if (st->pbo.layers) {      if (st->pbo.use_gs) {         /* out_pos.z = i2f(gl_InstanceID) */         ureg_I2F(ureg, ureg_writemask(out_pos, TGSI_WRITEMASK_Z),                        ureg_scalar(in_instanceid, TGSI_SWIZZLE_X));      } else {         /* out_layer = gl_InstanceID */         ureg_MOV(ureg, out_layer, in_instanceid);      }   }   ureg_END(ureg);   return ureg_create_shader_and_destroy(ureg, st->pipe);}

static void *create_frag_shader_video_buffer(struct vl_compositor *c){   struct ureg_program *shader;   struct ureg_src tc;   struct ureg_src csc[3];   struct ureg_src sampler[3];   struct ureg_dst texel;   struct ureg_dst fragment;   unsigned i;   shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);   if (!shader)      return false;   tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, VS_O_VTEX, TGSI_INTERPOLATE_LINEAR);   for (i = 0; i < 3; ++i) {      csc[i] = ureg_DECL_constant(shader, i);      sampler[i] = ureg_DECL_sampler(shader, i);   }   texel = ureg_DECL_temporary(shader);   fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);   /*    * texel.xyz = tex(tc, sampler[i])    * fragment = csc * texel    */   for (i = 0; i < 3; ++i)      ureg_TEX(shader, ureg_writemask(texel, TGSI_WRITEMASK_X << i), TGSI_TEXTURE_3D, tc, sampler[i]);   ureg_MOV(shader, ureg_writemask(texel, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));   for (i = 0; i < 3; ++i)      ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));   ureg_MOV(shader, ureg_writemask(fragment, TGSI_WRITEMASK_W), ureg_imm1f(shader, 1.0f));   ureg_release_temporary(shader, texel);   ureg_END(shader);   return ureg_create_shader_and_destroy(shader, c->pipe);}

/** * Make simple fragment texture shader: *  IMM {0,0,0,1}                         // (if writemask != 0xf) *  MOV OUT[0], IMM[0]                    // (if writemask != 0xf) *  TEX OUT[0].writemask, IN[0], SAMP[0], 2D; *  END; * * /param tex_target  one of PIPE_TEXTURE_x * /parma interp_mode  either TGSI_INTERPOLATE_LINEAR or PERSPECTIVE * /param writemask  mask of TGSI_WRITEMASK_x */void *util_make_fragment_tex_shader_writemask(struct pipe_context *pipe,                                        unsigned tex_target,                                        unsigned interp_mode,                                        unsigned writemask ){   struct ureg_program *ureg;   struct ureg_src sampler;   struct ureg_src tex;   struct ureg_dst out;   assert(interp_mode == TGSI_INTERPOLATE_LINEAR ||          interp_mode == TGSI_INTERPOLATE_PERSPECTIVE);   ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );   if (ureg == NULL)      return NULL;      sampler = ureg_DECL_sampler( ureg, 0 );   tex = ureg_DECL_fs_input( ureg,                              TGSI_SEMANTIC_GENERIC, 0,                              interp_mode );   out = ureg_DECL_output( ureg,                            TGSI_SEMANTIC_COLOR,                           0 );   if (writemask != TGSI_WRITEMASK_XYZW) {      struct ureg_src imm = ureg_imm4f( ureg, 0, 0, 0, 1 );      ureg_MOV( ureg, out, imm );   }   ureg_TEX( ureg,              ureg_writemask(out, writemask),             tex_target, tex, sampler );   ureg_END( ureg );   return ureg_create_shader_and_destroy( ureg, pipe );}