src/gallium/state_trackers/vega/asm_fill.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.  All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial portions
  15  * of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  20  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  **************************************************************************/
  26
  27 #ifndef ASM_FILL_H
  28 #define ASM_FILL_H
  29
  30 #include "tgsi/tgsi_ureg.h"
  31
  32 typedef void (* ureg_func)( struct ureg_program *ureg,
  33                             struct ureg_dst *out,
  34                             struct ureg_src *in,
  35                             struct ureg_src *sampler,
  36                             struct ureg_dst *temp,
  37                             struct ureg_src *constant);
  38
  39 static INLINE void
  40 solid_fill( struct ureg_program *ureg,
  41             struct ureg_dst *out,
  42             struct ureg_src *in,
  43             struct ureg_src *sampler,
  44             struct ureg_dst *temp,
  45             struct ureg_src *constant)
  46 {
  47    ureg_MOV(ureg, *out, constant[2]);
  48 }
  49
  50 /**
  51  * Perform frag-coord-to-paint-coord transform.  The transformation is in
  52  * CONST[4..6].
  53  */
  54 #define PAINT_TRANSFORM                                                 \
  55    ureg_MOV(ureg, ureg_writemask(temp[0], TGSI_WRITEMASK_XY), in[0]);   \
  56    ureg_MOV(ureg,                                                       \
  57             ureg_writemask(temp[0], TGSI_WRITEMASK_Z),                  \
  58             ureg_scalar(constant[3], TGSI_SWIZZLE_Y));                  \
  59    ureg_DP3(ureg, temp[1], constant[4], ureg_src(temp[0]));             \
  60    ureg_DP3(ureg, temp[2], constant[5], ureg_src(temp[0]));             \
  61    ureg_DP3(ureg, temp[3], constant[6], ureg_src(temp[0]));             \
  62    ureg_RCP(ureg, temp[3], ureg_src(temp[3]));                          \
  63    ureg_MUL(ureg, temp[1], ureg_src(temp[1]), ureg_src(temp[3]));       \
  64    ureg_MUL(ureg, temp[2], ureg_src(temp[2]), ureg_src(temp[3]));       \
  65    ureg_MOV(ureg,                                                       \
  66             ureg_writemask(temp[4], TGSI_WRITEMASK_X),                  \
  67             ureg_src(temp[1]));                                         \
  68    ureg_MOV(ureg,                                                       \
  69             ureg_writemask(temp[4], TGSI_WRITEMASK_Y),                  \
  70             ureg_src(temp[2]));
  71
  72 static INLINE void
  73 linear_grad( struct ureg_program *ureg,
  74              struct ureg_dst *out,
  75              struct ureg_src *in,
  76              struct ureg_src *sampler,
  77              struct ureg_dst *temp,
  78              struct ureg_src *constant)
  79 {
  80    PAINT_TRANSFORM
  81
  82    /* grad = DP2((x, y), CONST[2].xy) * CONST[2].z */
  83    ureg_MUL(ureg, temp[0],
  84             ureg_scalar(constant[2], TGSI_SWIZZLE_Y),
  85             ureg_scalar(ureg_src(temp[4]), TGSI_SWIZZLE_Y));
  86    ureg_MAD(ureg, temp[1],
  87             ureg_scalar(constant[2], TGSI_SWIZZLE_X),
  88             ureg_scalar(ureg_src(temp[4]), TGSI_SWIZZLE_X),
  89             ureg_src(temp[0]));
  90    ureg_MUL(ureg, temp[2], ureg_src(temp[1]),
  91             ureg_scalar(constant[2], TGSI_SWIZZLE_Z));
  92
  93    ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[2]), sampler[0]);
  94 }
  95
  96 static INLINE void
  97 radial_grad( struct ureg_program *ureg,
  98              struct ureg_dst *out,
  99              struct ureg_src *in,
 100              struct ureg_src *sampler,
 101              struct ureg_dst *temp,
 102              struct ureg_src *constant)
 103 {
 104    PAINT_TRANSFORM
 105
 106    /*
 107     * Calculate (sqrt(B^2 + AC) - B) / A, where
 108     *
 109     *   A is CONST[2].z,
 110     *   B is DP2((x, y), CONST[2].xy), and
 111     *   C is DP2((x, y), (x, y)).
 112     */
 113
 114    /* B and C */
 115    ureg_DP2(ureg, temp[0], ureg_src(temp[4]), constant[2]);
 116    ureg_DP2(ureg, temp[1], ureg_src(temp[4]), ureg_src(temp[4]));
 117
 118    /* the square root */
 119    ureg_MUL(ureg, temp[2], ureg_src(temp[0]), ureg_src(temp[0]));
 120    ureg_MAD(ureg, temp[3], ureg_src(temp[1]),
 121          ureg_scalar(constant[2], TGSI_SWIZZLE_Z), ureg_src(temp[2]));
 122    ureg_RSQ(ureg, temp[3], ureg_src(temp[3]));
 123    ureg_RCP(ureg, temp[3], ureg_src(temp[3]));
 124
 125    ureg_SUB(ureg, temp[3], ureg_src(temp[3]), ureg_src(temp[0]));
 126    ureg_RCP(ureg, temp[0], ureg_scalar(constant[2], TGSI_SWIZZLE_Z));
 127    ureg_MUL(ureg, temp[0], ureg_src(temp[0]), ureg_src(temp[3]));
 128
 129    ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[0]), sampler[0]);
 130 }
 131
 132
 133 static INLINE void
 134 pattern( struct ureg_program *ureg,
 135          struct ureg_dst     *out,
 136          struct ureg_src     *in,
 137          struct ureg_src     *sampler,
 138          struct ureg_dst     *temp,
 139          struct ureg_src     *constant)
 140 {
 141    PAINT_TRANSFORM
 142
 143    /* (s, t) = (x / tex_width, y / tex_height) */
 144    ureg_RCP(ureg, temp[0],
 145             ureg_swizzle(constant[3],
 146                          TGSI_SWIZZLE_Z,
 147                          TGSI_SWIZZLE_W,
 148                          TGSI_SWIZZLE_Z,
 149                          TGSI_SWIZZLE_W));
 150    ureg_MOV(ureg, temp[1], ureg_src(temp[4]));
 151    ureg_MUL(ureg,
 152             ureg_writemask(temp[1], TGSI_WRITEMASK_X),
 153             ureg_src(temp[1]),
 154             ureg_src(temp[0]));
 155    ureg_MUL(ureg,
 156             ureg_writemask(temp[1], TGSI_WRITEMASK_Y),
 157             ureg_src(temp[1]),
 158             ureg_src(temp[0]));
 159
 160    ureg_TEX(ureg, *out, TGSI_TEXTURE_2D, ureg_src(temp[1]), sampler[0]);
 161 }
 162
 163 static INLINE void
 164 paint_degenerate( struct ureg_program *ureg,
 165                   struct ureg_dst *out,
 166                   struct ureg_src *in,
 167                   struct ureg_src *sampler,
 168                   struct ureg_dst *temp,
 169                   struct ureg_src *constant)
 170 {
 171    /* CONST[3].y is 1.0f */
 172    ureg_MOV(ureg, temp[1], ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
 173    ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[1]), sampler[0]);
 174 }
 175
 176 static INLINE void
 177 image_normal( struct ureg_program *ureg,
 178               struct ureg_dst *out,
 179               struct ureg_src *in,
 180               struct ureg_src *sampler,
 181               struct ureg_dst *temp,
 182               struct ureg_src *constant)
 183 {
 184    /* store and pass image color in TEMP[1] */
 185    ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
 186    ureg_MOV(ureg, *out, ureg_src(temp[1]));
 187 }
 188
 189
 190 static INLINE void
 191 image_multiply( struct ureg_program *ureg,
 192                 struct ureg_dst *out,
 193                 struct ureg_src *in,
 194                 struct ureg_src *sampler,
 195                 struct ureg_dst *temp,
 196                 struct ureg_src *constant)
 197 {
 198    /* store and pass image color in TEMP[1] */
 199    ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
 200    ureg_MUL(ureg, *out, ureg_src(temp[0]), ureg_src(temp[1]));
 201 }
 202
 203
 204 static INLINE void
 205 image_stencil( struct ureg_program *ureg,
 206                struct ureg_dst *out,
 207                struct ureg_src *in,
 208                struct ureg_src *sampler,
 209                struct ureg_dst *temp,
 210                struct ureg_src *constant)
 211 {
 212    /* store and pass image color in TEMP[1] */
 213    ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
 214    ureg_MOV(ureg, *out, ureg_src(temp[0]));
 215 }
 216
 217 static INLINE void
 218 color_transform( struct ureg_program *ureg,
 219                  struct ureg_dst *out,
 220                  struct ureg_src *in,
 221                  struct ureg_src *sampler,
 222                  struct ureg_dst *temp,
 223                  struct ureg_src *constant)
 224 {
 225    /* note that TEMP[1] may already be used for image color */
 226
 227    ureg_MAD(ureg, temp[2], ureg_src(temp[0]), constant[0], constant[1]);
 228    /* clamp to [0.0f, 1.0f] */
 229    ureg_CLAMP(ureg, temp[2],
 230               ureg_src(temp[2]),
 231               ureg_scalar(constant[3], TGSI_SWIZZLE_X),
 232               ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
 233    ureg_MOV(ureg, *out, ureg_src(temp[2]));
 234 }
 235
 236 static INLINE void
 237 alpha_normal( struct ureg_program *ureg,
 238               struct ureg_dst *out,
 239               struct ureg_src *in,
 240               struct ureg_src *sampler,
 241               struct ureg_dst *temp,
 242               struct ureg_src *constant)
 243 {
 244    /* save per-channel alpha in TEMP[1] */
 245    ureg_MOV(ureg, temp[1], ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W));
 246
 247    ureg_MOV(ureg, *out, ureg_src(temp[0]));
 248 }
 249
 250 static INLINE void
 251 alpha_per_channel( struct ureg_program *ureg,
 252                    struct ureg_dst *out,
 253                    struct ureg_src *in,
 254                    struct ureg_src *sampler,
 255                    struct ureg_dst *temp,
 256                    struct ureg_src *constant)
 257 {
 258    /* save per-channel alpha in TEMP[1] */
 259    ureg_MUL(ureg,
 260             ureg_writemask(temp[1], TGSI_WRITEMASK_W),
 261             ureg_src(temp[0]),
 262             ureg_src(temp[1]));
 263    ureg_MUL(ureg,
 264             ureg_writemask(temp[1], TGSI_WRITEMASK_XYZ),
 265             ureg_src(temp[1]),
 266             ureg_scalar(ureg_src(temp[1]), TGSI_SWIZZLE_W));
 267
 268    /* update alpha */
 269    ureg_MOV(ureg,
 270             ureg_writemask(temp[0], TGSI_WRITEMASK_W),
 271             ureg_src(temp[1]));
 272    ureg_MOV(ureg, *out, ureg_src(temp[0]));
 273 }
 274
 275 /**
 276  * Premultiply src and dst.
 277  */
 278 static INLINE void
 279 blend_premultiply( struct ureg_program *ureg,
 280                    struct ureg_src src,
 281                    struct ureg_src src_channel_alpha,
 282                    struct ureg_src dst)
 283 {
 284    /* premultiply src */
 285    ureg_MUL(ureg,
 286             ureg_writemask(ureg_dst(src), TGSI_WRITEMASK_XYZ),
 287             src,
 288             src_channel_alpha);
 289    /* premultiply dst */
 290    ureg_MUL(ureg,
 291             ureg_writemask(ureg_dst(dst), TGSI_WRITEMASK_XYZ),
 292             dst,
 293             ureg_scalar(dst, TGSI_SWIZZLE_W));
 294 }
 295
 296 /**
 297  * Unpremultiply src.
 298  */
 299 static INLINE void
 300 blend_unpremultiply( struct ureg_program *ureg,
 301                      struct ureg_src src,
 302                      struct ureg_src one,
 303                      struct ureg_dst temp[1])
 304 {
 305    /* replace 0.0f by 1.0f before calculating reciprocal */
 306    ureg_CMP(ureg,
 307             temp[0],
 308             ureg_negate(ureg_scalar(src, TGSI_SWIZZLE_W)),
 309             ureg_scalar(src, TGSI_SWIZZLE_W),
 310             one);
 311    ureg_RCP(ureg, temp[0], ureg_src(temp[0]));
 312
 313    ureg_MUL(ureg,
 314             ureg_writemask(ureg_dst(src), TGSI_WRITEMASK_XYZ),
 315             src,
 316             ureg_src(temp[0]));
 317 }
 318
 319 /**
 320  * Emit instructions for the specified blend mode.  Colors will be
 321  * unpremultiplied.  Two temporary registers are required.
 322  *
 323  * The output is written back to src.
 324  */
 325 static INLINE void
 326 blend_generic(struct ureg_program *ureg,
 327               VGBlendMode mode,
 328               struct ureg_src src,
 329               struct ureg_src src_channel_alpha,
 330               struct ureg_src dst,
 331               struct ureg_src one,
 332               struct ureg_dst temp[2])
 333 {
 334    struct ureg_dst out;
 335
 336    blend_premultiply(ureg, src, src_channel_alpha, dst);
 337
 338    /* blend in-place */
 339    out = ureg_dst(src);
 340
 341    switch (mode) {
 342    case VG_BLEND_SRC:
 343       ureg_MOV(ureg, out, src);
 344       break;
 345    case VG_BLEND_SRC_OVER:
 346       /* RGBA_out = RGBA_src + (1 - A_src) * RGBA_dst */
 347       ureg_SUB(ureg, temp[0], one, src_channel_alpha);
 348       ureg_MAD(ureg, out, ureg_src(temp[0]), dst, src);
 349       break;
 350    case VG_BLEND_DST_OVER:
 351       /* RGBA_out = RGBA_dst + (1 - A_dst) * RGBA_src */
 352       ureg_SUB(ureg, temp[0], one, ureg_scalar(dst, TGSI_SWIZZLE_W));
 353       ureg_MAD(ureg, out, ureg_src(temp[0]), src, dst);
 354       break;
 355    case VG_BLEND_SRC_IN:
 356       ureg_MUL(ureg, out, src, ureg_scalar(dst, TGSI_SWIZZLE_W));
 357       break;
 358    case VG_BLEND_DST_IN:
 359       ureg_MUL(ureg, out, dst, src_channel_alpha);
 360       break;
 361    case VG_BLEND_MULTIPLY:
 362       /*
 363        * RGB_out = (1 - A_dst) * RGB_src + (1 - A_src) * RGB_dst +
 364        *           RGB_src * RGB_dst
 365        */
 366       ureg_MAD(ureg, temp[0],
 367             ureg_scalar(dst, TGSI_SWIZZLE_W), ureg_negate(src), src);
 368       ureg_MAD(ureg, temp[1],
 369             src_channel_alpha, ureg_negate(dst), dst);
 370       ureg_MAD(ureg, temp[1], src, dst, ureg_src(temp[1]));
 371       ureg_ADD(ureg, out, ureg_src(temp[0]), ureg_src(temp[1]));
 372       /* alpha is src over */
 373       ureg_ADD(ureg, ureg_writemask(out, TGSI_WRITEMASK_W),
 374             src, ureg_src(temp[1]));
 375       break;
 376    case VG_BLEND_SCREEN:
 377       /* RGBA_out = RGBA_src + (1 - RGBA_src) * RGBA_dst */
 378       ureg_SUB(ureg, temp[0], one, src);
 379       ureg_MAD(ureg, out, ureg_src(temp[0]), dst, src);
 380       break;
 381    case VG_BLEND_DARKEN:
 382    case VG_BLEND_LIGHTEN:
 383       /* src over */
 384       ureg_SUB(ureg, temp[0], one, src_channel_alpha);
 385       ureg_MAD(ureg, temp[0], ureg_src(temp[0]), dst, src);
 386       /* dst over */
 387       ureg_SUB(ureg, temp[1], one, ureg_scalar(dst, TGSI_SWIZZLE_W));
 388       ureg_MAD(ureg, temp[1], ureg_src(temp[1]), src, dst);
 389       /* take min/max for colors */
 390       if (mode == VG_BLEND_DARKEN) {
 391          ureg_MIN(ureg, ureg_writemask(out, TGSI_WRITEMASK_XYZ),
 392                ureg_src(temp[0]), ureg_src(temp[1]));
 393       }
 394       else {
 395          ureg_MAX(ureg, ureg_writemask(out, TGSI_WRITEMASK_XYZ),
 396                ureg_src(temp[0]), ureg_src(temp[1]));
 397       }
 398       break;
 399    case VG_BLEND_ADDITIVE:
 400       /* RGBA_out = RGBA_src + RGBA_dst */
 401       ureg_ADD(ureg, temp[0], src, dst);
 402       ureg_MIN(ureg, out, ureg_src(temp[0]), one);
 403       break;
 404    default:
 405       assert(0);
 406       break;
 407    }
 408
 409    blend_unpremultiply(ureg, src, one, temp);
 410 }
 411
 412 static INLINE void
 413 blend_multiply( struct ureg_program *ureg,
 414                 struct ureg_dst *out,
 415                 struct ureg_src *in,
 416                 struct ureg_src *sampler,
 417                 struct ureg_dst *temp,
 418                 struct ureg_src *constant)
 419 {
 420    ureg_TEX(ureg, temp[2], TGSI_TEXTURE_2D, in[0], sampler[2]);
 421
 422    blend_generic(ureg, VG_BLEND_MULTIPLY,
 423                  ureg_src(temp[0]),
 424                  ureg_src(temp[1]),
 425                  ureg_src(temp[2]),
 426                  ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
 427                  temp + 3);
 428
 429    ureg_MOV(ureg, *out, ureg_src(temp[0]));
 430 }
 431
 432 static INLINE void
 433 blend_screen( struct ureg_program *ureg,
 434               struct ureg_dst     *out,
 435               struct ureg_src     *in,
 436               struct ureg_src     *sampler,
 437               struct ureg_dst     *temp,
 438               struct ureg_src     *constant)
 439 {
 440    ureg_TEX(ureg, temp[2], TGSI_TEXTURE_2D, in[0], sampler[2]);
 441
 442    blend_generic(ureg, VG_BLEND_SCREEN,
 443                  ureg_src(temp[0]),
 444                  ureg_src(temp[1]),
 445                  ureg_src(temp[2]),
 446                  ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
 447                  temp + 3);
 448
 449    ureg_MOV(ureg, *out, ureg_src(temp[0]));
 450 }
 451
 452 static INLINE void
 453 blend_darken( struct ureg_program *ureg,
 454               struct ureg_dst     *out,
 455               struct ureg_src     *in,
 456               struct ureg_src     *sampler,
 457               struct ureg_dst     *temp,
 458               struct ureg_src     *constant)
 459 {
 460    ureg_TEX(ureg, temp[2], TGSI_TEXTURE_2D, in[0], sampler[2]);
 461
 462    blend_generic(ureg, VG_BLEND_DARKEN,
 463                  ureg_src(temp[0]),
 464                  ureg_src(temp[1]),
 465                  ureg_src(temp[2]),
 466                  ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
 467                  temp + 3);
 468
 469    ureg_MOV(ureg, *out, ureg_src(temp[0]));
 470 }
 471
 472 static INLINE void
 473 blend_lighten( struct ureg_program *ureg,
 474                struct ureg_dst     *out,
 475                struct ureg_src     *in,
 476                struct ureg_src     *sampler,
 477                struct ureg_dst *temp,
 478                struct ureg_src     *constant)
 479 {
 480    ureg_TEX(ureg, temp[2], TGSI_TEXTURE_2D, in[0], sampler[2]);
 481
 482    blend_generic(ureg, VG_BLEND_LIGHTEN,
 483                  ureg_src(temp[0]),
 484                  ureg_src(temp[1]),
 485                  ureg_src(temp[2]),
 486                  ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
 487                  temp + 3);
 488
 489    ureg_MOV(ureg, *out, ureg_src(temp[0]));
 490 }
 491
 492 static INLINE void
 493 mask( struct ureg_program *ureg,
 494       struct ureg_dst *out,
 495       struct ureg_src *in,
 496       struct ureg_src *sampler,
 497       struct ureg_dst *temp,
 498       struct ureg_src *constant)
 499 {
 500    ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[0], sampler[1]);
 501    ureg_MUL(ureg, ureg_writemask(temp[0], TGSI_WRITEMASK_W),
 502             ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W),
 503             ureg_scalar(ureg_src(temp[1]), TGSI_SWIZZLE_W));
 504    ureg_MOV(ureg, *out, ureg_src(temp[0]));
 505 }
 506
 507 static INLINE void
 508 premultiply( struct ureg_program *ureg,
 509                 struct ureg_dst *out,
 510                 struct ureg_src *in,
 511                 struct ureg_src *sampler,
 512                 struct ureg_dst *temp,
 513                 struct ureg_src *constant)
 514 {
 515    ureg_MUL(ureg,
 516             ureg_writemask(temp[0], TGSI_WRITEMASK_XYZ),
 517             ureg_src(temp[0]),
 518             ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W));
 519 }
 520
 521 static INLINE void
 522 unpremultiply( struct ureg_program *ureg,
 523                 struct ureg_dst *out,
 524                 struct ureg_src *in,
 525                 struct ureg_src *sampler,
 526                 struct ureg_dst *temp,
 527                 struct ureg_src *constant)
 528 {
 529    ureg_TEX(ureg, temp[0], TGSI_TEXTURE_2D, in[0], sampler[1]);
 530 }
 531
 532
 533 static INLINE void
 534 color_bw( struct ureg_program *ureg,
 535                 struct ureg_dst *out,
 536                 struct ureg_src *in,
 537                 struct ureg_src *sampler,
 538                 struct ureg_dst *temp,
 539                 struct ureg_src *constant)
 540 {
 541    ureg_ADD(ureg, temp[1],
 542             ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
 543             ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
 544    ureg_RCP(ureg, temp[2], ureg_src(temp[1]));
 545    ureg_ADD(ureg, temp[1],
 546             ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
 547             ureg_src(temp[2]));
 548    ureg_ADD(ureg, ureg_writemask(temp[2], TGSI_WRITEMASK_X),
 549             ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_X),
 550             ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_Y));
 551    ureg_ADD(ureg, ureg_writemask(temp[2], TGSI_WRITEMASK_X),
 552             ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_Z),
 553             ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_X));
 554    ureg_SGE(ureg,
 555             ureg_writemask(temp[0], TGSI_WRITEMASK_XYZ),
 556             ureg_scalar(ureg_src(temp[2]), TGSI_SWIZZLE_X),
 557             ureg_src(temp[1]));
 558   ureg_SGE(ureg,
 559            ureg_writemask(temp[0], TGSI_WRITEMASK_W),
 560            ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W),
 561            ureg_scalar(ureg_src(temp[2]), TGSI_SWIZZLE_Y));
 562   ureg_MOV(ureg, *out, ureg_src(temp[0]));
 563 }
 564
 565
 566 struct shader_asm_info {
 567    VGint id;
 568    ureg_func func;
 569
 570    VGboolean needs_position;
 571
 572    VGint start_const;
 573    VGint num_consts;
 574
 575    VGint start_sampler;
 576    VGint num_samplers;
 577
 578    VGint start_temp;
 579    VGint num_temps;
 580 };
 581
 582
 583 /* paint types */
 584 static const struct shader_asm_info shaders_paint_asm[] = {
 585    {VEGA_SOLID_FILL_SHADER, solid_fill,
 586     VG_FALSE, 2, 1, 0, 0, 0, 0},
 587    {VEGA_LINEAR_GRADIENT_SHADER, linear_grad,
 588     VG_TRUE,  2, 5, 0, 1, 0, 5},
 589    {VEGA_RADIAL_GRADIENT_SHADER, radial_grad,
 590     VG_TRUE,  2, 5, 0, 1, 0, 5},
 591    {VEGA_PATTERN_SHADER, pattern,
 592     VG_TRUE,  3, 4, 0, 1, 0, 5},
 593    {VEGA_PAINT_DEGENERATE_SHADER, paint_degenerate,
 594     VG_FALSE,  3, 1, 0, 1, 0, 2}
 595 };
 596
 597 /* image draw modes */
 598 static const struct shader_asm_info shaders_image_asm[] = {
 599    {VEGA_IMAGE_NORMAL_SHADER, image_normal,
 600     VG_TRUE,  0, 0, 3, 1, 0, 2},
 601    {VEGA_IMAGE_MULTIPLY_SHADER, image_multiply,
 602     VG_TRUE,  0, 0, 3, 1, 0, 2},
 603    {VEGA_IMAGE_STENCIL_SHADER, image_stencil,
 604     VG_TRUE,  0, 0, 3, 1, 0, 2}
 605 };
 606
 607 static const struct shader_asm_info shaders_color_transform_asm[] = {
 608    {VEGA_COLOR_TRANSFORM_SHADER, color_transform,
 609     VG_FALSE, 0, 4, 0, 0, 0, 3}
 610 };
 611
 612 static const struct shader_asm_info shaders_alpha_asm[] = {
 613    {VEGA_ALPHA_NORMAL_SHADER, alpha_normal,
 614     VG_FALSE, 0, 0, 0, 0, 0, 2},
 615    {VEGA_ALPHA_PER_CHANNEL_SHADER, alpha_per_channel,
 616     VG_FALSE, 0, 0, 0, 0, 0, 2}
 617 };
 618
 619 /* extra blend modes */
 620 static const struct shader_asm_info shaders_blend_asm[] = {
 621    {VEGA_BLEND_MULTIPLY_SHADER, blend_multiply,
 622     VG_TRUE,  3, 1, 2, 1, 0, 5},
 623    {VEGA_BLEND_SCREEN_SHADER, blend_screen,
 624     VG_TRUE,  3, 1, 2, 1, 0, 5},
 625    {VEGA_BLEND_DARKEN_SHADER, blend_darken,
 626     VG_TRUE,  3, 1, 2, 1, 0, 5},
 627    {VEGA_BLEND_LIGHTEN_SHADER, blend_lighten,
 628     VG_TRUE,  3, 1, 2, 1, 0, 5},
 629 };
 630
 631 static const struct shader_asm_info shaders_mask_asm[] = {
 632    {VEGA_MASK_SHADER, mask,
 633     VG_TRUE,  0, 0, 1, 1, 0, 2}
 634 };
 635
 636 /* premultiply */
 637 static const struct shader_asm_info shaders_premultiply_asm[] = {
 638    {VEGA_PREMULTIPLY_SHADER, premultiply,
 639     VG_FALSE,  0, 0, 0, 0, 0, 1},
 640    {VEGA_UNPREMULTIPLY_SHADER, unpremultiply,
 641     VG_FALSE,  0, 0, 0, 0, 0, 1},
 642 };
 643
 644 /* color transform to black and white */
 645 static const struct shader_asm_info shaders_bw_asm[] = {
 646    {VEGA_BW_SHADER, color_bw,
 647     VG_FALSE,  3, 1, 0, 0, 0, 3},
 648 };
 649
 650 #endif