src/mesa/drivers/dri/i965/brw_clip_unfilled.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 #include "main/glheader.h"
  33 #include "main/macros.h"
  34 #include "main/enums.h"
  35 #include "program/program.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_clip.h"
  43
  44
  45
  46 /* This is performed against the original triangles, so no indirection
  47  * required:
  48 BZZZT!
  49  */
  50 static void compute_tri_direction( struct brw_clip_compile *c )
  51 {
  52    struct brw_compile *p = &c->func;
  53    struct brw_reg e = c->reg.tmp0;
  54    struct brw_reg f = c->reg.tmp1;
  55    GLuint hpos_offset = brw_vert_result_to_offset(&c->vue_map,
  56                                                   VERT_RESULT_HPOS);
  57    struct brw_reg v0 = byte_offset(c->reg.vertex[0], hpos_offset);
  58    struct brw_reg v1 = byte_offset(c->reg.vertex[1], hpos_offset);
  59    struct brw_reg v2 = byte_offset(c->reg.vertex[2], hpos_offset);
  60
  61
  62    struct brw_reg v0n = get_tmp(c);
  63    struct brw_reg v1n = get_tmp(c);
  64    struct brw_reg v2n = get_tmp(c);
  65
  66    /* Convert to NDC.
  67     * NOTE: We can't modify the original vertex coordinates,
  68     * as it may impact further operations.
  69     * So, we have to keep normalized coordinates in temp registers.
  70     *
  71     * TBD-KC
  72     * Try to optimize unnecessary MOV's.
  73     */
  74    brw_MOV(p, v0n, v0);
  75    brw_MOV(p, v1n, v1);
  76    brw_MOV(p, v2n, v2);
  77
  78    brw_clip_project_position(c, v0n);
  79    brw_clip_project_position(c, v1n);
  80    brw_clip_project_position(c, v2n);
  81
  82    /* Calculate the vectors of two edges of the triangle:
  83     */
  84    brw_ADD(p, e, v0n, negate(v2n));
  85    brw_ADD(p, f, v1n, negate(v2n));
  86
  87    /* Take their crossproduct:
  88     */
  89    brw_set_access_mode(p, BRW_ALIGN_16);
  90    brw_MUL(p, vec4(brw_null_reg()), brw_swizzle(e, 1,2,0,3),  brw_swizzle(f,2,0,1,3));
  91    brw_MAC(p, vec4(e),  negate(brw_swizzle(e, 2,0,1,3)), brw_swizzle(f,1,2,0,3));
  92    brw_set_access_mode(p, BRW_ALIGN_1);
  93
  94    brw_MUL(p, c->reg.dir, c->reg.dir, vec4(e));
  95 }
  96
  97
  98 static void cull_direction( struct brw_clip_compile *c )
  99 {
 100    struct brw_compile *p = &c->func;
 101    GLuint conditional;
 102
 103    assert (!(c->key.fill_ccw == CLIP_CULL &&
 104              c->key.fill_cw == CLIP_CULL));
 105
 106    if (c->key.fill_ccw == CLIP_CULL)
 107       conditional = BRW_CONDITIONAL_GE;
 108    else
 109       conditional = BRW_CONDITIONAL_L;
 110
 111    brw_CMP(p,
 112            vec1(brw_null_reg()),
 113            conditional,
 114            get_element(c->reg.dir, 2),
 115            brw_imm_f(0));
 116
 117    brw_IF(p, BRW_EXECUTE_1);
 118    {
 119       brw_clip_kill_thread(c);
 120    }
 121    brw_ENDIF(p);
 122 }
 123
 124
 125
 126 static void copy_bfc( struct brw_clip_compile *c )
 127 {
 128    struct brw_compile *p = &c->func;
 129    GLuint conditional;
 130
 131    /* Do we have any colors to copy?
 132     */
 133    if (!(brw_clip_have_vert_result(c, VERT_RESULT_COL0) &&
 134          brw_clip_have_vert_result(c, VERT_RESULT_BFC0)) &&
 135        !(brw_clip_have_vert_result(c, VERT_RESULT_COL1) &&
 136          brw_clip_have_vert_result(c, VERT_RESULT_BFC1)))
 137       return;
 138
 139    /* In some wierd degnerate cases we can end up testing the
 140     * direction twice, once for culling and once for bfc copying.  Oh
 141     * well, that's what you get for setting wierd GL state.
 142     */
 143    if (c->key.copy_bfc_ccw)
 144       conditional = BRW_CONDITIONAL_GE;
 145    else
 146       conditional = BRW_CONDITIONAL_L;
 147
 148    brw_CMP(p,
 149            vec1(brw_null_reg()),
 150            conditional,
 151            get_element(c->reg.dir, 2),
 152            brw_imm_f(0));
 153
 154    brw_IF(p, BRW_EXECUTE_1);
 155    {
 156       GLuint i;
 157
 158       for (i = 0; i < 3; i++) {
 159          if (brw_clip_have_vert_result(c, VERT_RESULT_COL0) &&
 160              brw_clip_have_vert_result(c, VERT_RESULT_BFC0))
 161             brw_MOV(p,
 162                     byte_offset(c->reg.vertex[i],
 163                                 brw_vert_result_to_offset(&c->vue_map,
 164                                                           VERT_RESULT_COL0)),
 165                     byte_offset(c->reg.vertex[i],
 166                                 brw_vert_result_to_offset(&c->vue_map,
 167                                                           VERT_RESULT_BFC0)));
 168
 169          if (brw_clip_have_vert_result(c, VERT_RESULT_COL1) &&
 170              brw_clip_have_vert_result(c, VERT_RESULT_BFC1))
 171             brw_MOV(p,
 172                     byte_offset(c->reg.vertex[i],
 173                                 brw_vert_result_to_offset(&c->vue_map,
 174                                                           VERT_RESULT_COL1)),
 175                     byte_offset(c->reg.vertex[i],
 176                                 brw_vert_result_to_offset(&c->vue_map,
 177                                                           VERT_RESULT_BFC1)));
 178       }
 179    }
 180    brw_ENDIF(p);
 181 }
 182
 183
 184
 185
 186 /*
 187   GLfloat iz    = 1.0 / dir.z;
 188   GLfloat ac    = dir.x * iz;
 189   GLfloat bc    = dir.y * iz;
 190   offset = ctx->Polygon.OffsetUnits * DEPTH_SCALE;
 191   offset += MAX2( abs(ac), abs(bc) ) * ctx->Polygon.OffsetFactor;
 192   offset *= MRD;
 193 */
 194 static void compute_offset( struct brw_clip_compile *c )
 195 {
 196    struct brw_compile *p = &c->func;
 197    struct brw_reg off = c->reg.offset;
 198    struct brw_reg dir = c->reg.dir;
 199
 200    brw_math_invert(p, get_element(off, 2), get_element(dir, 2));
 201    brw_MUL(p, vec2(off), dir, get_element(off, 2));
 202
 203    brw_CMP(p,
 204            vec1(brw_null_reg()),
 205            BRW_CONDITIONAL_GE,
 206            brw_abs(get_element(off, 0)),
 207            brw_abs(get_element(off, 1)));
 208
 209    brw_SEL(p, vec1(off), brw_abs(get_element(off, 0)), brw_abs(get_element(off, 1)));
 210    brw_set_predicate_control(p, BRW_PREDICATE_NONE);
 211
 212    brw_MUL(p, vec1(off), off, brw_imm_f(c->key.offset_factor));
 213    brw_ADD(p, vec1(off), off, brw_imm_f(c->key.offset_units));
 214 }
 215
 216
 217 static void merge_edgeflags( struct brw_clip_compile *c )
 218 {
 219    struct brw_compile *p = &c->func;
 220    struct brw_reg tmp0 = get_element_ud(c->reg.tmp0, 0);
 221
 222    brw_AND(p, tmp0, get_element_ud(c->reg.R0, 2), brw_imm_ud(PRIM_MASK));
 223    brw_CMP(p,
 224            vec1(brw_null_reg()),
 225            BRW_CONDITIONAL_EQ,
 226            tmp0,
 227            brw_imm_ud(_3DPRIM_POLYGON));
 228
 229    /* Get away with using reg.vertex because we know that this is not
 230     * a _3DPRIM_TRISTRIP_REVERSE:
 231     */
 232    brw_IF(p, BRW_EXECUTE_1);
 233    {
 234       brw_set_conditionalmod(p, BRW_CONDITIONAL_EQ);
 235       brw_AND(p, vec1(brw_null_reg()), get_element_ud(c->reg.R0, 2), brw_imm_ud(1<<8));
 236       brw_MOV(p, byte_offset(c->reg.vertex[0],
 237                              brw_vert_result_to_offset(&c->vue_map,
 238                                                        VERT_RESULT_EDGE)),
 239               brw_imm_f(0));
 240       brw_set_predicate_control(p, BRW_PREDICATE_NONE);
 241
 242       brw_set_conditionalmod(p, BRW_CONDITIONAL_EQ);
 243       brw_AND(p, vec1(brw_null_reg()), get_element_ud(c->reg.R0, 2), brw_imm_ud(1<<9));
 244       brw_MOV(p, byte_offset(c->reg.vertex[2],
 245                              brw_vert_result_to_offset(&c->vue_map,
 246                                                        VERT_RESULT_EDGE)),
 247               brw_imm_f(0));
 248       brw_set_predicate_control(p, BRW_PREDICATE_NONE);
 249    }
 250    brw_ENDIF(p);
 251 }
 252
 253
 254
 255 static void apply_one_offset( struct brw_clip_compile *c,
 256                           struct brw_indirect vert )
 257 {
 258    struct brw_compile *p = &c->func;
 259    GLuint ndc_offset = brw_vert_result_to_offset(&c->vue_map,
 260                                                  BRW_VERT_RESULT_NDC);
 261    struct brw_reg z = deref_1f(vert, ndc_offset +
 262                                2 * type_sz(BRW_REGISTER_TYPE_F));
 263
 264    brw_ADD(p, z, z, vec1(c->reg.offset));
 265 }
 266
 267
 268
 269 /***********************************************************************
 270  * Output clipped polygon as an unfilled primitive:
 271  */
 272 static void emit_lines(struct brw_clip_compile *c,
 273                        GLboolean do_offset)
 274 {
 275    struct brw_compile *p = &c->func;
 276    struct brw_instruction *loop;
 277    struct brw_indirect v0 = brw_indirect(0, 0);
 278    struct brw_indirect v1 = brw_indirect(1, 0);
 279    struct brw_indirect v0ptr = brw_indirect(2, 0);
 280    struct brw_indirect v1ptr = brw_indirect(3, 0);
 281
 282    /* Need a seperate loop for offset:
 283     */
 284    if (do_offset) {
 285       brw_MOV(p, c->reg.loopcount, c->reg.nr_verts);
 286       brw_MOV(p, get_addr_reg(v0ptr), brw_address(c->reg.inlist));
 287
 288       loop = brw_DO(p, BRW_EXECUTE_1);
 289       {
 290          brw_MOV(p, get_addr_reg(v0), deref_1uw(v0ptr, 0));
 291          brw_ADD(p, get_addr_reg(v0ptr), get_addr_reg(v0ptr), brw_imm_uw(2));
 292
 293          apply_one_offset(c, v0);
 294
 295          brw_set_conditionalmod(p, BRW_CONDITIONAL_G);
 296          brw_ADD(p, c->reg.loopcount, c->reg.loopcount, brw_imm_d(-1));
 297       }
 298       brw_WHILE(p, loop);
 299    }
 300
 301    /* v1ptr = &inlist[nr_verts]
 302     * *v1ptr = v0
 303     */
 304    brw_MOV(p, c->reg.loopcount, c->reg.nr_verts);
 305    brw_MOV(p, get_addr_reg(v0ptr), brw_address(c->reg.inlist));
 306    brw_ADD(p, get_addr_reg(v1ptr), get_addr_reg(v0ptr), retype(c->reg.nr_verts, BRW_REGISTER_TYPE_UW));
 307    brw_ADD(p, get_addr_reg(v1ptr), get_addr_reg(v1ptr), retype(c->reg.nr_verts, BRW_REGISTER_TYPE_UW));
 308    brw_MOV(p, deref_1uw(v1ptr, 0), deref_1uw(v0ptr, 0));
 309
 310    loop = brw_DO(p, BRW_EXECUTE_1);
 311    {
 312       brw_MOV(p, get_addr_reg(v0), deref_1uw(v0ptr, 0));
 313       brw_MOV(p, get_addr_reg(v1), deref_1uw(v0ptr, 2));
 314       brw_ADD(p, get_addr_reg(v0ptr), get_addr_reg(v0ptr), brw_imm_uw(2));
 315
 316       /* draw edge if edgeflag != 0 */
 317       brw_CMP(p,
 318               vec1(brw_null_reg()), BRW_CONDITIONAL_NZ,
 319               deref_1f(v0, brw_vert_result_to_offset(&c->vue_map,
 320                                                      VERT_RESULT_EDGE)),
 321               brw_imm_f(0));
 322       brw_IF(p, BRW_EXECUTE_1);
 323       {
 324          brw_clip_emit_vue(c, v0, 1, 0, (_3DPRIM_LINESTRIP << 2) | R02_PRIM_START);
 325          brw_clip_emit_vue(c, v1, 1, 0, (_3DPRIM_LINESTRIP << 2) | R02_PRIM_END);
 326       }
 327       brw_ENDIF(p);
 328
 329       brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ);
 330       brw_ADD(p, c->reg.loopcount, c->reg.loopcount, brw_imm_d(-1));
 331    }
 332    brw_WHILE(p, loop);
 333 }
 334
 335
 336
 337 static void emit_points(struct brw_clip_compile *c,
 338                         GLboolean do_offset )
 339 {
 340    struct brw_compile *p = &c->func;
 341    struct brw_instruction *loop;
 342
 343    struct brw_indirect v0 = brw_indirect(0, 0);
 344    struct brw_indirect v0ptr = brw_indirect(2, 0);
 345
 346    brw_MOV(p, c->reg.loopcount, c->reg.nr_verts);
 347    brw_MOV(p, get_addr_reg(v0ptr), brw_address(c->reg.inlist));
 348
 349    loop = brw_DO(p, BRW_EXECUTE_1);
 350    {
 351       brw_MOV(p, get_addr_reg(v0), deref_1uw(v0ptr, 0));
 352       brw_ADD(p, get_addr_reg(v0ptr), get_addr_reg(v0ptr), brw_imm_uw(2));
 353
 354       /* draw if edgeflag != 0
 355        */
 356       brw_CMP(p,
 357               vec1(brw_null_reg()), BRW_CONDITIONAL_NZ,
 358               deref_1f(v0, brw_vert_result_to_offset(&c->vue_map,
 359                                                      VERT_RESULT_EDGE)),
 360               brw_imm_f(0));
 361       brw_IF(p, BRW_EXECUTE_1);
 362       {
 363          if (do_offset)
 364             apply_one_offset(c, v0);
 365
 366          brw_clip_emit_vue(c, v0, 1, 0, (_3DPRIM_POINTLIST << 2) | R02_PRIM_START | R02_PRIM_END);
 367       }
 368       brw_ENDIF(p);
 369
 370       brw_set_conditionalmod(p, BRW_CONDITIONAL_NZ);
 371       brw_ADD(p, c->reg.loopcount, c->reg.loopcount, brw_imm_d(-1));
 372    }
 373    brw_WHILE(p, loop);
 374 }
 375
 376
 377
 378
 379
 380
 381
 382 static void emit_primitives( struct brw_clip_compile *c,
 383                              GLuint mode,
 384                              GLboolean do_offset )
 385 {
 386    switch (mode) {
 387    case CLIP_FILL:
 388       brw_clip_tri_emit_polygon(c);
 389       break;
 390
 391    case CLIP_LINE:
 392       emit_lines(c, do_offset);
 393       break;
 394
 395    case CLIP_POINT:
 396       emit_points(c, do_offset);
 397       break;
 398
 399    case CLIP_CULL:
 400       assert(0);
 401       break;
 402    }
 403 }
 404
 405
 406
 407 static void emit_unfilled_primitives( struct brw_clip_compile *c )
 408 {
 409    struct brw_compile *p = &c->func;
 410
 411    /* Direction culling has already been done.
 412     */
 413    if (c->key.fill_ccw != c->key.fill_cw &&
 414        c->key.fill_ccw != CLIP_CULL &&
 415        c->key.fill_cw != CLIP_CULL)
 416    {
 417       brw_CMP(p,
 418               vec1(brw_null_reg()),
 419               BRW_CONDITIONAL_GE,
 420               get_element(c->reg.dir, 2),
 421               brw_imm_f(0));
 422
 423       brw_IF(p, BRW_EXECUTE_1);
 424       {
 425          emit_primitives(c, c->key.fill_ccw, c->key.offset_ccw);
 426       }
 427       brw_ELSE(p);
 428       {
 429          emit_primitives(c, c->key.fill_cw, c->key.offset_cw);
 430       }
 431       brw_ENDIF(p);
 432    }
 433    else if (c->key.fill_cw != CLIP_CULL) {
 434       emit_primitives(c, c->key.fill_cw, c->key.offset_cw);
 435    }
 436    else if (c->key.fill_ccw != CLIP_CULL) {
 437       emit_primitives(c, c->key.fill_ccw, c->key.offset_ccw);
 438    }
 439 }
 440
 441
 442
 443
 444 static void check_nr_verts( struct brw_clip_compile *c )
 445 {
 446    struct brw_compile *p = &c->func;
 447
 448    brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_L, c->reg.nr_verts, brw_imm_d(3));
 449    brw_IF(p, BRW_EXECUTE_1);
 450    {
 451       brw_clip_kill_thread(c);
 452    }
 453    brw_ENDIF(p);
 454 }
 455
 456
 457 void brw_emit_unfilled_clip( struct brw_clip_compile *c )
 458 {
 459    struct brw_compile *p = &c->func;
 460
 461    c->need_direction = ((c->key.offset_ccw || c->key.offset_cw) ||
 462                         (c->key.fill_ccw != c->key.fill_cw) ||
 463                         c->key.fill_ccw == CLIP_CULL ||
 464                         c->key.fill_cw == CLIP_CULL ||
 465                         c->key.copy_bfc_cw ||
 466                         c->key.copy_bfc_ccw);
 467
 468    brw_clip_tri_alloc_regs(c, 3 + c->key.nr_userclip + 6);
 469    brw_clip_tri_init_vertices(c);
 470    brw_clip_init_ff_sync(c);
 471
 472    assert(brw_clip_have_vert_result(c, VERT_RESULT_EDGE));
 473
 474    if (c->key.fill_ccw == CLIP_CULL &&
 475        c->key.fill_cw == CLIP_CULL) {
 476       brw_clip_kill_thread(c);
 477       return;
 478    }
 479
 480    merge_edgeflags(c);
 481
 482    /* Need to use the inlist indirection here:
 483     */
 484    if (c->need_direction)
 485       compute_tri_direction(c);
 486
 487    if (c->key.fill_ccw == CLIP_CULL ||
 488        c->key.fill_cw == CLIP_CULL)
 489       cull_direction(c);
 490
 491    if (c->key.offset_ccw ||
 492        c->key.offset_cw)
 493       compute_offset(c);
 494
 495    if (c->key.copy_bfc_ccw ||
 496        c->key.copy_bfc_cw)
 497       copy_bfc(c);
 498
 499    /* Need to do this whether we clip or not:
 500     */
 501    if (c->key.do_flat_shading)
 502       brw_clip_tri_flat_shade(c);
 503
 504    brw_clip_init_clipmask(c);
 505    brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_NZ, c->reg.planemask, brw_imm_ud(0));
 506    brw_IF(p, BRW_EXECUTE_1);
 507    {
 508       brw_clip_init_planes(c);
 509       brw_clip_tri(c);
 510       check_nr_verts(c);
 511    }
 512    brw_ENDIF(p);
 513
 514    emit_unfilled_primitives(c);
 515    brw_clip_kill_thread(c);
 516 }
 517
 518
 519