src/gallium/state_trackers/xorg/xorg_exa_tgsi.c

   1 #include "xorg_exa_tgsi.h"
   2
   3 /*### stupidity defined in X11/extensions/XI.h */
   4 #undef Absolute
   5
   6 #include "pipe/p_format.h"
   7 #include "pipe/p_context.h"
   8 #include "pipe/p_state.h"
   9 #include "pipe/p_inlines.h"
  10 #include "pipe/p_shader_tokens.h"
  11
  12 #include "util/u_memory.h"
  13 #include "util/u_simple_shaders.h"
  14
  15 #include "tgsi/tgsi_ureg.h"
  16
  17 #include "cso_cache/cso_context.h"
  18
  19 #define UNSUPPORTED_OP 0
  20
  21 struct shader_id {
  22    int op : 8;
  23    int mask : 1;
  24    int component_alpha : 1;
  25    int is_fill : 1;
  26 };
  27
  28 /* SAMP[0]  = dst
  29  * SAMP[1]  = src
  30  * SAMP[2]  = mask
  31  * IN[0]    = pos dst
  32  * IN[1]    = pos src
  33  * IN[2]    = pos mask
  34  * CONST[0] = (0, 0, 0, 1)
  35  */
  36 struct xorg_render_ops_tgsi {
  37    int op;
  38 };
  39
  40
  41 static const char over_op[] =
  42    "SUB TEMP[3], CONST[0].wwww, TEMP[1].wwww\n"
  43    "MUL TEMP[3], TEMP[0], TEMP[3]\n"
  44    "ADD TEMP[0], TEMP[3], TEMP[0]\n";
  45
  46 static const struct xorg_render_ops_tgsi ops_map[] = {
  47    {PictOpClear},
  48    {PictOpSrc},
  49    {PictOpDst},
  50    {PictOpOver},
  51    {PictOpOverReverse},
  52    {PictOpIn},
  53    {PictOpInReverse},
  54    {PictOpOut},
  55    {PictOpOutReverse},
  56    {PictOpAtop},
  57    {PictOpAtopReverse},
  58    {PictOpXor},
  59    {PictOpAdd},
  60    {PictOpSaturate},
  61 };
  62
  63
  64 static INLINE void
  65 create_preamble(struct ureg_program *ureg)
  66 {
  67 }
  68
  69
  70 static INLINE void
  71 src_in_mask(struct ureg_program *ureg,
  72             struct ureg_dst dst,
  73             struct ureg_src src,
  74             struct ureg_src mask)
  75 {
  76    /* MUL dst, src, mask.wwww */
  77    ureg_MUL(ureg, dst, src,
  78             ureg_scalar(mask, TGSI_SWIZZLE_W));
  79 }
  80
  81 static INLINE
  82 struct shader_id shader_state(int op,
  83                               PicturePtr src_picture,
  84                               PicturePtr mask_picture,
  85                               PicturePtr dst_picture)
  86 {
  87    struct shader_id sid;
  88
  89    sid.op = op;
  90    sid.mask = (mask_picture != 0);
  91    sid.component_alpha = (mask_picture->componentAlpha);
  92    sid.is_fill = (src_picture->pSourcePict != 0);
  93    if (sid.is_fill) {
  94       sid.is_fill =
  95          (src_picture->pSourcePict->type == SourcePictTypeSolidFill);
  96    }
  97
  98    return sid;
  99 }
 100
 101 struct xorg_shader xorg_shader_construct(struct exa_context *exa,
 102                                          int op,
 103                                          PicturePtr src_picture,
 104                                          PicturePtr mask_picture,
 105                                          PicturePtr dst_picture)
 106 {
 107    struct ureg_program *ureg;
 108    struct ureg_src dst_sampler, src_sampler, mask_sampler;
 109    struct ureg_src dst_pos, src_pos, mask_pos;
 110    struct ureg_src src, mask;
 111    struct shader_id sid = shader_state(op, src_picture,
 112                                        mask_picture,
 113                                        dst_picture);
 114    struct xorg_shader shader = {0};
 115
 116    ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
 117    if (ureg == NULL)
 118       return shader;
 119
 120    if (sid.is_fill)
 121       return shader;
 122
 123 #if 0  /* unused right now */
 124    dst_sampler = ureg_DECL_sampler(ureg);
 125    dst_pos = ureg_DECL_fs_input(ureg,
 126                                 TGSI_SEMANTIC_POSITION,
 127                                 0,
 128                                 TGSI_INTERPOLATE_PERSPECTIVE);
 129 #endif
 130
 131    src_sampler = ureg_DECL_sampler(ureg);
 132    src_pos = ureg_DECL_fs_input(ureg,
 133                                 TGSI_SEMANTIC_POSITION,
 134                                 1,
 135                                 TGSI_INTERPOLATE_PERSPECTIVE);
 136
 137    if (sid.mask) {
 138       mask_sampler = ureg_DECL_sampler(ureg);
 139       src_pos = ureg_DECL_fs_input(ureg,
 140                                    TGSI_SEMANTIC_POSITION,
 141                                    2,
 142                                    TGSI_INTERPOLATE_PERSPECTIVE);
 143    }
 144
 145    ureg_TEX(ureg, ureg_dst(src),
 146             TGSI_TEXTURE_2D, src_pos, src_sampler);
 147
 148    if (sid.mask) {
 149       ureg_TEX(ureg, ureg_dst(mask),
 150                TGSI_TEXTURE_2D, mask_pos, mask_sampler);
 151       /* src IN mask */
 152       src_in_mask(ureg, ureg_dst(src), src, mask);
 153    }
 154
 155    ureg_END(ureg);
 156
 157    return shader;
 158 }