src/mesa/drivers/dri/i965/brw_sf_emit.c

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a copy of this software and associated documentation files (the
   8  "Software"), to deal in the Software without restriction, including
   9  without limitation the rights to use, copy, modify, merge, publish,
  10  distribute, sublicense, and/or sell copies of the Software, and to
  11  permit persons to whom the Software is furnished to do so, subject to
  12  the following conditions:
  13
  14  The above copyright notice and this permission notice (including the
  15  next paragraph) shall be included in all copies or substantial
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   */
  31
  32
  33 #include "glheader.h"
  34 #include "macros.h"
  35 #include "enums.h"
  36
  37 #include "intel_batchbuffer.h"
  38
  39 #include "brw_defines.h"
  40 #include "brw_context.h"
  41 #include "brw_eu.h"
  42 #include "brw_util.h"
  43 #include "brw_sf.h"
  44
  45
  46 static struct brw_reg get_vert_attr(struct brw_sf_compile *c,
  47                                     struct brw_reg vert,
  48                                     GLuint attr)
  49 {
  50    GLuint off = c->attr_to_idx[attr] / 2;
  51    GLuint sub = c->attr_to_idx[attr] % 2;
  52
  53    return brw_vec4_grf(vert.nr + off, sub * 4);
  54 }
  55
  56 static GLboolean have_attr(struct brw_sf_compile *c,
  57                            GLuint attr)
  58 {
  59    return (c->key.attrs & (1<<attr)) ? 1 : 0;
  60 }
  61
  62
  63
  64 /***********************************************************************
  65  * Twoside lighting
  66  */
  67 static void copy_bfc( struct brw_sf_compile *c,
  68                       struct brw_reg vert )
  69 {
  70    struct brw_compile *p = &c->func;
  71    GLuint i;
  72
  73    for (i = 0; i < 2; i++) {
  74       if (have_attr(c, VERT_RESULT_COL0+i) &&
  75           have_attr(c, VERT_RESULT_BFC0+i))
  76          brw_MOV(p,
  77                  get_vert_attr(c, vert, VERT_RESULT_COL0+i),
  78                  get_vert_attr(c, vert, VERT_RESULT_BFC0+i));
  79    }
  80 }
  81
  82
  83 static void do_twoside_color( struct brw_sf_compile *c )
  84 {
  85    struct brw_compile *p = &c->func;
  86    struct brw_instruction *if_insn;
  87    GLuint backface_conditional = c->key.frontface_ccw ? BRW_CONDITIONAL_G : BRW_CONDITIONAL_L;
  88
  89    /* Already done in clip program:
  90     */
  91    if (c->key.primitive == SF_UNFILLED_TRIS)
  92       return;
  93
  94    /* XXX: What happens if BFC isn't present?  This could only happen
  95     * for user-supplied vertex programs, as t_vp_build.c always does
  96     * the right thing.
  97     */
  98    if (!(have_attr(c, VERT_RESULT_COL0) && have_attr(c, VERT_RESULT_BFC0)) &&
  99        !(have_attr(c, VERT_RESULT_COL1) && have_attr(c, VERT_RESULT_BFC1)))
 100       return;
 101
 102    /* Need to use BRW_EXECUTE_4 and also do an 4-wide compare in order
 103     * to get all channels active inside the IF.  In the clipping code
 104     * we run with NoMask, so it's not an option and we can use
 105     * BRW_EXECUTE_1 for all comparisions.
 106     */
 107    brw_push_insn_state(p);
 108    brw_CMP(p, vec4(brw_null_reg()), backface_conditional, c->det, brw_imm_f(0));
 109    if_insn = brw_IF(p, BRW_EXECUTE_4);
 110    {
 111       switch (c->nr_verts) {
 112       case 3: copy_bfc(c, c->vert[2]);
 113       case 2: copy_bfc(c, c->vert[1]);
 114       case 1: copy_bfc(c, c->vert[0]);
 115       }
 116    }
 117    brw_ENDIF(p, if_insn);
 118    brw_pop_insn_state(p);
 119 }
 120
 121
 122
 123 /***********************************************************************
 124  * Flat shading
 125  */
 126
 127 #define VERT_RESULT_COLOR_BITS ((1<<VERT_RESULT_COL0) | \
 128                                  (1<<VERT_RESULT_COL1))
 129
 130 static void copy_colors( struct brw_sf_compile *c,
 131                      struct brw_reg dst,
 132                      struct brw_reg src)
 133 {
 134    struct brw_compile *p = &c->func;
 135    GLuint i;
 136
 137    for (i = VERT_RESULT_COL0; i <= VERT_RESULT_COL1; i++) {
 138       if (have_attr(c,i))
 139          brw_MOV(p,
 140                  get_vert_attr(c, dst, i),
 141                  get_vert_attr(c, src, i));
 142    }
 143 }
 144
 145
 146
 147 /* Need to use a computed jump to copy flatshaded attributes as the
 148  * vertices are ordered according to y-coordinate before reaching this
 149  * point, so the PV could be anywhere.
 150  */
 151 static void do_flatshade_triangle( struct brw_sf_compile *c )
 152 {
 153    struct brw_compile *p = &c->func;
 154    struct brw_reg ip = brw_ip_reg();
 155    GLuint nr = brw_count_bits(c->key.attrs & VERT_RESULT_COLOR_BITS);
 156    if (!nr)
 157       return;
 158
 159    /* Already done in clip program:
 160     */
 161    if (c->key.primitive == SF_UNFILLED_TRIS)
 162       return;
 163
 164    brw_push_insn_state(p);
 165
 166    brw_MUL(p, c->pv, c->pv, brw_imm_ud(nr*2+1));
 167    brw_JMPI(p, ip, ip, c->pv);
 168
 169    copy_colors(c, c->vert[1], c->vert[0]);
 170    copy_colors(c, c->vert[2], c->vert[0]);
 171    brw_JMPI(p, ip, ip, brw_imm_ud(nr*4+1));
 172
 173    copy_colors(c, c->vert[0], c->vert[1]);
 174    copy_colors(c, c->vert[2], c->vert[1]);
 175    brw_JMPI(p, ip, ip, brw_imm_ud(nr*2));
 176
 177    copy_colors(c, c->vert[0], c->vert[2]);
 178    copy_colors(c, c->vert[1], c->vert[2]);
 179
 180    brw_pop_insn_state(p);
 181 }
 182
 183
 184 static void do_flatshade_line( struct brw_sf_compile *c )
 185 {
 186    struct brw_compile *p = &c->func;
 187    struct brw_reg ip = brw_ip_reg();
 188    GLuint nr = brw_count_bits(c->key.attrs & VERT_RESULT_COLOR_BITS);
 189
 190    if (!nr)
 191       return;
 192
 193    /* Already done in clip program:
 194     */
 195    if (c->key.primitive == SF_UNFILLED_TRIS)
 196       return;
 197
 198    brw_push_insn_state(p);
 199
 200    brw_MUL(p, c->pv, c->pv, brw_imm_ud(nr+1));
 201    brw_JMPI(p, ip, ip, c->pv);
 202    copy_colors(c, c->vert[1], c->vert[0]);
 203
 204    brw_JMPI(p, ip, ip, brw_imm_ud(nr));
 205    copy_colors(c, c->vert[0], c->vert[1]);
 206
 207    brw_pop_insn_state(p);
 208 }
 209
 210
 211
 212 /***********************************************************************
 213  * Triangle setup.
 214  */
 215
 216
 217 static void alloc_regs( struct brw_sf_compile *c )
 218 {
 219    GLuint reg, i;
 220
 221    /* Values computed by fixed function unit:
 222     */
 223    c->pv  = retype(brw_vec1_grf(1, 1), BRW_REGISTER_TYPE_UD);
 224    c->det = brw_vec1_grf(1, 2);
 225    c->dx0 = brw_vec1_grf(1, 3);
 226    c->dx2 = brw_vec1_grf(1, 4);
 227    c->dy0 = brw_vec1_grf(1, 5);
 228    c->dy2 = brw_vec1_grf(1, 6);
 229
 230    /* z and 1/w passed in seperately:
 231     */
 232    c->z[0]     = brw_vec1_grf(2, 0);
 233    c->inv_w[0] = brw_vec1_grf(2, 1);
 234    c->z[1]     = brw_vec1_grf(2, 2);
 235    c->inv_w[1] = brw_vec1_grf(2, 3);
 236    c->z[2]     = brw_vec1_grf(2, 4);
 237    c->inv_w[2] = brw_vec1_grf(2, 5);
 238
 239    /* The vertices:
 240     */
 241    reg = 3;
 242    for (i = 0; i < c->nr_verts; i++) {
 243       c->vert[i] = brw_vec8_grf(reg, 0);
 244       reg += c->nr_attr_regs;
 245    }
 246
 247    /* Temporaries, allocated after last vertex reg.
 248     */
 249    c->inv_det = brw_vec1_grf(reg, 0);  reg++;
 250    c->a1_sub_a0 = brw_vec8_grf(reg, 0);  reg++;
 251    c->a2_sub_a0 = brw_vec8_grf(reg, 0);  reg++;
 252    c->tmp = brw_vec8_grf(reg, 0);  reg++;
 253
 254    /* Note grf allocation:
 255     */
 256    c->prog_data.total_grf = reg;
 257
 258
 259    /* Outputs of this program - interpolation coefficients for
 260     * rasterization:
 261     */
 262    c->m1Cx = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 1, 0);
 263    c->m2Cy = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 2, 0);
 264    c->m3C0 = brw_vec8_reg(BRW_MESSAGE_REGISTER_FILE, 3, 0);
 265 }
 266
 267
 268 static void copy_z_inv_w( struct brw_sf_compile *c )
 269 {
 270    struct brw_compile *p = &c->func;
 271    GLuint i;
 272
 273    brw_push_insn_state(p);
 274
 275    /* Copy both scalars with a single MOV:
 276     */
 277    for (i = 0; i < c->nr_verts; i++)
 278       brw_MOV(p, vec2(suboffset(c->vert[i], 2)), vec2(c->z[i]));
 279
 280    brw_pop_insn_state(p);
 281 }
 282
 283
 284 static void invert_det( struct brw_sf_compile *c)
 285 {
 286    /* Looks like we invert all 8 elements just to get 1/det in
 287     * position 2 !?!
 288     */
 289    brw_math(&c->func,
 290             c->inv_det,
 291             BRW_MATH_FUNCTION_INV,
 292             BRW_MATH_SATURATE_NONE,
 293             0,
 294             c->det,
 295             BRW_MATH_DATA_SCALAR,
 296             BRW_MATH_PRECISION_FULL);
 297
 298 }
 299
 300 #define NON_PERPECTIVE_ATTRS  (FRAG_BIT_WPOS | \
 301                                FRAG_BIT_COL0 | \
 302                                FRAG_BIT_COL1)
 303
 304 static GLboolean calculate_masks( struct brw_sf_compile *c,
 305                                   GLuint reg,
 306                                   GLushort *pc,
 307                                   GLushort *pc_persp,
 308                                   GLushort *pc_linear)
 309 {
 310    GLboolean is_last_attr = (reg == c->nr_setup_regs - 1);
 311    GLuint persp_mask = c->key.attrs & ~NON_PERPECTIVE_ATTRS;
 312    GLuint linear_mask;
 313
 314    if (c->key.do_flat_shading)
 315       linear_mask = c->key.attrs & ~(FRAG_BIT_COL0|FRAG_BIT_COL1);
 316    else
 317       linear_mask = c->key.attrs;
 318
 319    *pc_persp = 0;
 320    *pc_linear = 0;
 321    *pc = 0xf;
 322
 323    if (persp_mask & (1 << c->idx_to_attr[reg*2]))
 324       *pc_persp = 0xf;
 325
 326    if (linear_mask & (1 << c->idx_to_attr[reg*2]))
 327       *pc_linear = 0xf;
 328
 329    /* Maybe only processs one attribute on the final round:
 330     */
 331    if (reg*2+1 < c->nr_setup_attrs) {
 332       *pc |= 0xf0;
 333
 334       if (persp_mask & (1 << c->idx_to_attr[reg*2+1]))
 335          *pc_persp |= 0xf0;
 336
 337       if (linear_mask & (1 << c->idx_to_attr[reg*2+1]))
 338          *pc_linear |= 0xf0;
 339    }
 340
 341    return is_last_attr;
 342 }
 343
 344
 345
 346 void brw_emit_tri_setup( struct brw_sf_compile *c, GLboolean allocate)
 347 {
 348    struct brw_compile *p = &c->func;
 349    GLuint i;
 350
 351    c->nr_verts = 3;
 352
 353    if (allocate)
 354       alloc_regs(c);
 355
 356    invert_det(c);
 357    copy_z_inv_w(c);
 358
 359    if (c->key.do_twoside_color)
 360       do_twoside_color(c);
 361
 362    if (c->key.do_flat_shading)
 363       do_flatshade_triangle(c);
 364
 365
 366    for (i = 0; i < c->nr_setup_regs; i++)
 367    {
 368       /* Pair of incoming attributes:
 369        */
 370       struct brw_reg a0 = offset(c->vert[0], i);
 371       struct brw_reg a1 = offset(c->vert[1], i);
 372       struct brw_reg a2 = offset(c->vert[2], i);
 373       GLushort pc, pc_persp, pc_linear;
 374       GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
 375
 376       if (pc_persp)
 377       {
 378          brw_set_predicate_control_flag_value(p, pc_persp);
 379          brw_MUL(p, a0, a0, c->inv_w[0]);
 380          brw_MUL(p, a1, a1, c->inv_w[1]);
 381          brw_MUL(p, a2, a2, c->inv_w[2]);
 382       }
 383
 384
 385       /* Calculate coefficients for interpolated values:
 386        */
 387       if (pc_linear)
 388       {
 389          brw_set_predicate_control_flag_value(p, pc_linear);
 390
 391          brw_ADD(p, c->a1_sub_a0, a1, negate(a0));
 392          brw_ADD(p, c->a2_sub_a0, a2, negate(a0));
 393
 394          /* calculate dA/dx
 395           */
 396          brw_MUL(p, brw_null_reg(), c->a1_sub_a0, c->dy2);
 397          brw_MAC(p, c->tmp, c->a2_sub_a0, negate(c->dy0));
 398          brw_MUL(p, c->m1Cx, c->tmp, c->inv_det);
 399
 400          /* calculate dA/dy
 401           */
 402          brw_MUL(p, brw_null_reg(), c->a2_sub_a0, c->dx0);
 403          brw_MAC(p, c->tmp, c->a1_sub_a0, negate(c->dx2));
 404          brw_MUL(p, c->m2Cy, c->tmp, c->inv_det);
 405       }
 406
 407       {
 408          brw_set_predicate_control_flag_value(p, pc);
 409          /* start point for interpolation
 410           */
 411          brw_MOV(p, c->m3C0, a0);
 412
 413          /* Copy m0..m3 to URB.  m0 is implicitly copied from r0 in
 414           * the send instruction:
 415           */
 416          brw_urb_WRITE(p,
 417                        brw_null_reg(),
 418                        0,
 419                        brw_vec8_grf(0, 0), /* r0, will be copied to m0 */
 420                        0,       /* allocate */
 421                        1,       /* used */
 422                        4,       /* msg len */
 423                        0,       /* response len */
 424                        last,    /* eot */
 425                        last,    /* writes complete */
 426                        i*4,     /* offset */
 427                        BRW_URB_SWIZZLE_TRANSPOSE); /* XXX: Swizzle control "SF to windower" */
 428       }
 429    }
 430 }
 431
 432
 433
 434 void brw_emit_line_setup( struct brw_sf_compile *c, GLboolean allocate)
 435 {
 436    struct brw_compile *p = &c->func;
 437    GLuint i;
 438
 439
 440    c->nr_verts = 2;
 441
 442    if (allocate)
 443       alloc_regs(c);
 444
 445    invert_det(c);
 446    copy_z_inv_w(c);
 447
 448    if (c->key.do_flat_shading)
 449       do_flatshade_line(c);
 450
 451    for (i = 0; i < c->nr_setup_regs; i++)
 452    {
 453       /* Pair of incoming attributes:
 454        */
 455       struct brw_reg a0 = offset(c->vert[0], i);
 456       struct brw_reg a1 = offset(c->vert[1], i);
 457       GLushort pc, pc_persp, pc_linear;
 458       GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
 459
 460       if (pc_persp)
 461       {
 462          brw_set_predicate_control_flag_value(p, pc_persp);
 463          brw_MUL(p, a0, a0, c->inv_w[0]);
 464          brw_MUL(p, a1, a1, c->inv_w[1]);
 465       }
 466
 467       /* Calculate coefficients for position, color:
 468        */
 469       if (pc_linear) {
 470          brw_set_predicate_control_flag_value(p, pc_linear);
 471
 472          brw_ADD(p, c->a1_sub_a0, a1, negate(a0));
 473
 474          brw_MUL(p, c->tmp, c->a1_sub_a0, c->dx0);
 475          brw_MUL(p, c->m1Cx, c->tmp, c->inv_det);
 476
 477          brw_MUL(p, c->tmp, c->a1_sub_a0, c->dy0);
 478          brw_MUL(p, c->m2Cy, c->tmp, c->inv_det);
 479       }
 480
 481       {
 482          brw_set_predicate_control_flag_value(p, pc);
 483
 484          /* start point for interpolation
 485           */
 486          brw_MOV(p, c->m3C0, a0);
 487
 488          /* Copy m0..m3 to URB.
 489           */
 490          brw_urb_WRITE(p,
 491                        brw_null_reg(),
 492                        0,
 493                        brw_vec8_grf(0, 0),
 494                        0,       /* allocate */
 495                        1,       /* used */
 496                        4,       /* msg len */
 497                        0,       /* response len */
 498                        last,    /* eot */
 499                        last,    /* writes complete */
 500                        i*4,     /* urb destination offset */
 501                        BRW_URB_SWIZZLE_TRANSPOSE);
 502       }
 503    }
 504 }
 505
 506 void brw_emit_point_sprite_setup( struct brw_sf_compile *c, GLboolean allocate)
 507 {
 508    struct brw_compile *p = &c->func;
 509    GLuint i;
 510
 511    c->nr_verts = 1;
 512
 513    if (allocate)
 514       alloc_regs(c);
 515
 516    copy_z_inv_w(c);
 517    for (i = 0; i < c->nr_setup_regs; i++)
 518    {
 519       struct brw_sf_point_tex *tex = &c->point_attrs[c->idx_to_attr[2*i]];
 520       struct brw_reg a0 = offset(c->vert[0], i);
 521       GLushort pc, pc_persp, pc_linear;
 522       GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
 523
 524       if (pc_persp)
 525       {
 526           if (!tex->CoordReplace) {
 527               brw_set_predicate_control_flag_value(p, pc_persp);
 528               brw_MUL(p, a0, a0, c->inv_w[0]);
 529           }
 530       }
 531
 532       if (tex->CoordReplace) {
 533           /* Caculate 1.0/PointWidth */
 534           brw_math(&c->func,
 535                   c->tmp,
 536                   BRW_MATH_FUNCTION_INV,
 537                   BRW_MATH_SATURATE_NONE,
 538                   0,
 539                   c->dx0,
 540                   BRW_MATH_DATA_SCALAR,
 541                   BRW_MATH_PRECISION_FULL);
 542
 543           if (c->key.SpriteOrigin == GL_UPPER_LEFT) {
 544                 brw_MUL(p, c->m1Cx, c->tmp, c->inv_w[0]);
 545                 brw_MOV(p, vec1(suboffset(c->m1Cx, 1)), brw_imm_f(0.0));
 546                 brw_MUL(p, c->m2Cy, c->tmp, negate(c->inv_w[0]));
 547                 brw_MOV(p, vec1(suboffset(c->m2Cy, 0)), brw_imm_f(0.0));
 548           } else {
 549                 brw_MUL(p, c->m1Cx, c->tmp, c->inv_w[0]);
 550                 brw_MOV(p, vec1(suboffset(c->m1Cx, 1)), brw_imm_f(0.0));
 551                 brw_MUL(p, c->m2Cy, c->tmp, c->inv_w[0]);
 552                 brw_MOV(p, vec1(suboffset(c->m2Cy, 0)), brw_imm_f(0.0));
 553           }
 554       } else {
 555           brw_MOV(p, c->m1Cx, brw_imm_ud(0));
 556           brw_MOV(p, c->m2Cy, brw_imm_ud(0));
 557       }
 558
 559       {
 560          brw_set_predicate_control_flag_value(p, pc);
 561          if (tex->CoordReplace) {
 562              if (c->key.SpriteOrigin == GL_UPPER_LEFT) {
 563                  brw_MUL(p, c->m3C0, c->inv_w[0], brw_imm_f(1.0));
 564                  brw_MOV(p, vec1(suboffset(c->m3C0, 0)), brw_imm_f(0.0));
 565              }
 566              else
 567                  brw_MOV(p, c->m3C0, brw_imm_f(0.0));
 568          } else {
 569                 brw_MOV(p, c->m3C0, a0); /* constant value */
 570          }
 571
 572          /* Copy m0..m3 to URB.
 573           */
 574          brw_urb_WRITE(p,
 575                        brw_null_reg(),
 576                        0,
 577                        brw_vec8_grf(0, 0),
 578                        0,       /* allocate */
 579                        1,       /* used */
 580                        4,       /* msg len */
 581                        0,       /* response len */
 582                        last,    /* eot */
 583                        last,    /* writes complete */
 584                        i*4,     /* urb destination offset */
 585                        BRW_URB_SWIZZLE_TRANSPOSE);
 586       }
 587    }
 588 }
 589
 590 /* Points setup - several simplifications as all attributes are
 591  * constant across the face of the point (point sprites excluded!)
 592  */
 593 void brw_emit_point_setup( struct brw_sf_compile *c, GLboolean allocate)
 594 {
 595    struct brw_compile *p = &c->func;
 596    GLuint i;
 597
 598    c->nr_verts = 1;
 599
 600    if (allocate)
 601       alloc_regs(c);
 602
 603    copy_z_inv_w(c);
 604
 605    brw_MOV(p, c->m1Cx, brw_imm_ud(0)); /* zero - move out of loop */
 606    brw_MOV(p, c->m2Cy, brw_imm_ud(0)); /* zero - move out of loop */
 607
 608    for (i = 0; i < c->nr_setup_regs; i++)
 609    {
 610       struct brw_reg a0 = offset(c->vert[0], i);
 611       GLushort pc, pc_persp, pc_linear;
 612       GLboolean last = calculate_masks(c, i, &pc, &pc_persp, &pc_linear);
 613
 614       if (pc_persp)
 615       {
 616          /* This seems odd as the values are all constant, but the
 617           * fragment shader will be expecting it:
 618           */
 619          brw_set_predicate_control_flag_value(p, pc_persp);
 620          brw_MUL(p, a0, a0, c->inv_w[0]);
 621       }
 622
 623
 624       /* The delta values are always zero, just send the starting
 625        * coordinate.  Again, this is to fit in with the interpolation
 626        * code in the fragment shader.
 627        */
 628       {
 629          brw_set_predicate_control_flag_value(p, pc);
 630
 631          brw_MOV(p, c->m3C0, a0); /* constant value */
 632
 633          /* Copy m0..m3 to URB.
 634           */
 635          brw_urb_WRITE(p,
 636                        brw_null_reg(),
 637                        0,
 638                        brw_vec8_grf(0, 0),
 639                        0,       /* allocate */
 640                        1,       /* used */
 641                        4,       /* msg len */
 642                        0,       /* response len */
 643                        last,    /* eot */
 644                        last,    /* writes complete */
 645                        i*4,     /* urb destination offset */
 646                        BRW_URB_SWIZZLE_TRANSPOSE);
 647       }
 648    }
 649 }
 650
 651 void brw_emit_anyprim_setup( struct brw_sf_compile *c )
 652 {
 653    struct brw_compile *p = &c->func;
 654    struct brw_reg ip = brw_ip_reg();
 655    struct brw_reg payload_prim = brw_uw1_reg(BRW_GENERAL_REGISTER_FILE, 1, 0);
 656    struct brw_reg payload_attr = get_element_ud(brw_vec1_reg(BRW_GENERAL_REGISTER_FILE, 1, 0), 0);
 657    struct brw_reg primmask;
 658    struct brw_instruction *jmp;
 659    struct brw_reg v1_null_ud = vec1(retype(brw_null_reg(), BRW_REGISTER_TYPE_UD));
 660
 661    GLuint saveflag;
 662
 663    c->nr_verts = 3;
 664    alloc_regs(c);
 665
 666    primmask = retype(get_element(c->tmp, 0), BRW_REGISTER_TYPE_UD);
 667
 668    brw_MOV(p, primmask, brw_imm_ud(1));
 669    brw_SHL(p, primmask, primmask, payload_prim);
 670
 671    brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
 672    brw_AND(p, v1_null_ud, primmask, brw_imm_ud((1<<_3DPRIM_TRILIST) |
 673                                                (1<<_3DPRIM_TRISTRIP) |
 674                                                (1<<_3DPRIM_TRIFAN) |
 675                                                (1<<_3DPRIM_TRISTRIP_REVERSE) |
 676                                                (1<<_3DPRIM_POLYGON) |
 677                                                (1<<_3DPRIM_RECTLIST) |
 678                                                (1<<_3DPRIM_TRIFAN_NOSTIPPLE)));
 679    jmp = brw_JMPI(p, ip, ip, brw_imm_w(0));
 680    {
 681       saveflag = p->flag_value;
 682       brw_push_insn_state(p);
 683       brw_emit_tri_setup( c, GL_FALSE );
 684       brw_pop_insn_state(p);
 685       p->flag_value = saveflag;
 686       /* note - thread killed in subroutine, so must
 687        * restore the flag which is changed when building
 688        * the subroutine. fix #13240
 689        */
 690    }
 691    brw_land_fwd_jump(p, jmp);
 692
 693    brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
 694    brw_AND(p, v1_null_ud, primmask, brw_imm_ud((1<<_3DPRIM_LINELIST) |
 695                                                (1<<_3DPRIM_LINESTRIP) |
 696                                                (1<<_3DPRIM_LINELOOP) |
 697                                                (1<<_3DPRIM_LINESTRIP_CONT) |
 698                                                (1<<_3DPRIM_LINESTRIP_BF) |
 699                                                (1<<_3DPRIM_LINESTRIP_CONT_BF)));
 700    jmp = brw_JMPI(p, ip, ip, brw_imm_w(0));
 701    {
 702       saveflag = p->flag_value;
 703       brw_push_insn_state(p);
 704       brw_emit_line_setup( c, GL_FALSE );
 705       brw_pop_insn_state(p);
 706       p->flag_value = saveflag;
 707       /* note - thread killed in subroutine */
 708    }
 709    brw_land_fwd_jump(p, jmp);
 710
 711    brw_set_conditionalmod(p, BRW_CONDITIONAL_Z);
 712    brw_AND(p, v1_null_ud, payload_attr, brw_imm_ud(1<<BRW_SPRITE_POINT_ENABLE));
 713    jmp = brw_JMPI(p, ip, ip, brw_imm_w(0));
 714    {
 715       saveflag = p->flag_value;
 716       brw_push_insn_state(p);
 717       brw_emit_point_sprite_setup( c, GL_FALSE );
 718       brw_pop_insn_state(p);
 719       p->flag_value = saveflag;
 720    }
 721    brw_land_fwd_jump(p, jmp);
 722
 723    brw_emit_point_setup( c, GL_FALSE );
 724 }
 725
 726
 727
 728