src/mesa/drivers/dri/i965/brw_clip.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
  36 #include "intel_batchbuffer.h"
  37
  38 #include "brw_defines.h"
  39 #include "brw_context.h"
  40 #include "brw_eu.h"
  41 #include "brw_util.h"
  42 #include "brw_state.h"
  43 #include "brw_clip.h"
  44
  45 #define FRONT_UNFILLED_BIT  0x1
  46 #define BACK_UNFILLED_BIT   0x2
  47
  48
  49 static void compile_clip_prog( struct brw_context *brw,
  50                              struct brw_clip_prog_key *key )
  51 {
  52    struct intel_context *intel = &brw->intel;
  53    struct brw_clip_compile c;
  54    const GLuint *program;
  55    GLuint program_size;
  56    GLuint delta;
  57    GLuint i;
  58
  59    memset(&c, 0, sizeof(c));
  60
  61    /* Begin the compilation:
  62     */
  63    brw_init_compile(brw, &c.func);
  64
  65    c.func.single_program_flow = 1;
  66
  67    c.key = *key;
  68
  69    /* Need to locate the two positions present in vertex + header.
  70     * These are currently hardcoded:
  71     */
  72    c.header_position_offset = ATTR_SIZE;
  73
  74    if (intel->gen == 5)
  75        delta = 3 * REG_SIZE;
  76    else
  77        delta = REG_SIZE;
  78
  79    for (i = 0; i < VERT_RESULT_MAX; i++)
  80       if (c.key.attrs & BITFIELD64_BIT(i)) {
  81          c.offset[i] = delta;
  82          delta += ATTR_SIZE;
  83       }
  84
  85    c.nr_attrs = brw_count_bits(c.key.attrs);
  86
  87    if (intel->gen == 5)
  88        c.nr_regs = (c.nr_attrs + 1) / 2 + 3;  /* are vertices packed, or reg-aligned? */
  89    else
  90        c.nr_regs = (c.nr_attrs + 1) / 2 + 1;  /* are vertices packed, or reg-aligned? */
  91
  92    c.nr_bytes = c.nr_regs * REG_SIZE;
  93
  94    c.prog_data.clip_mode = c.key.clip_mode; /* XXX */
  95
  96    /* For some reason the thread is spawned with only 4 channels
  97     * unmasked.
  98     */
  99    brw_set_mask_control(&c.func, BRW_MASK_DISABLE);
 100
 101
 102    /* Would ideally have the option of producing a program which could
 103     * do all three:
 104     */
 105    switch (key->primitive) {
 106    case GL_TRIANGLES:
 107       if (key->do_unfilled)
 108          brw_emit_unfilled_clip( &c );
 109       else
 110          brw_emit_tri_clip( &c );
 111       break;
 112    case GL_LINES:
 113       brw_emit_line_clip( &c );
 114       break;
 115    case GL_POINTS:
 116       brw_emit_point_clip( &c );
 117       break;
 118    default:
 119       assert(0);
 120       return;
 121    }
 122
 123
 124
 125    /* get the program
 126     */
 127    program = brw_get_program(&c.func, &program_size);
 128
 129     if (INTEL_DEBUG & DEBUG_CLIP) {
 130       printf("clip:\n");
 131       for (i = 0; i < program_size / sizeof(struct brw_instruction); i++)
 132          brw_disasm(stdout, &((struct brw_instruction *)program)[i],
 133                     intel->gen);
 134       printf("\n");
 135     }
 136
 137    /* Upload
 138     */
 139    dri_bo_unreference(brw->clip.prog_bo);
 140    brw->clip.prog_bo = brw_upload_cache_with_auxdata(&brw->cache,
 141                                                      BRW_CLIP_PROG,
 142                                                      &c.key, sizeof(c.key),
 143                                                      NULL, 0,
 144                                                      program, program_size,
 145                                                      &c.prog_data,
 146                                                      sizeof(c.prog_data),
 147                                                      &brw->clip.prog_data);
 148 }
 149
 150 /* Calculate interpolants for triangle and line rasterization.
 151  */
 152 static void upload_clip_prog(struct brw_context *brw)
 153 {
 154    struct intel_context *intel = &brw->intel;
 155    GLcontext *ctx = &intel->ctx;
 156    struct brw_clip_prog_key key;
 157
 158    memset(&key, 0, sizeof(key));
 159
 160    /* Populate the key:
 161     */
 162    /* BRW_NEW_REDUCED_PRIMITIVE */
 163    key.primitive = brw->intel.reduced_primitive;
 164    /* CACHE_NEW_VS_PROG */
 165    key.attrs = brw->vs.prog_data->outputs_written;
 166    /* _NEW_LIGHT */
 167    key.do_flat_shading = (ctx->Light.ShadeModel == GL_FLAT);
 168    key.pv_first = (ctx->Light.ProvokingVertex == GL_FIRST_VERTEX_CONVENTION);
 169    /* _NEW_TRANSFORM */
 170    key.nr_userclip = brw_count_bits(ctx->Transform.ClipPlanesEnabled);
 171
 172    if (intel->gen == 5)
 173        key.clip_mode = BRW_CLIPMODE_KERNEL_CLIP;
 174    else
 175        key.clip_mode = BRW_CLIPMODE_NORMAL;
 176
 177    /* _NEW_POLYGON */
 178    if (key.primitive == GL_TRIANGLES) {
 179       if (ctx->Polygon.CullFlag &&
 180           ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
 181          key.clip_mode = BRW_CLIPMODE_REJECT_ALL;
 182       else {
 183          GLuint fill_front = CLIP_CULL;
 184          GLuint fill_back = CLIP_CULL;
 185          GLuint offset_front = 0;
 186          GLuint offset_back = 0;
 187
 188          if (!ctx->Polygon.CullFlag ||
 189              ctx->Polygon.CullFaceMode != GL_FRONT) {
 190             switch (ctx->Polygon.FrontMode) {
 191             case GL_FILL:
 192                fill_front = CLIP_FILL;
 193                offset_front = 0;
 194                break;
 195             case GL_LINE:
 196                fill_front = CLIP_LINE;
 197                offset_front = ctx->Polygon.OffsetLine;
 198                break;
 199             case GL_POINT:
 200                fill_front = CLIP_POINT;
 201                offset_front = ctx->Polygon.OffsetPoint;
 202                break;
 203             }
 204          }
 205
 206          if (!ctx->Polygon.CullFlag ||
 207              ctx->Polygon.CullFaceMode != GL_BACK) {
 208             switch (ctx->Polygon.BackMode) {
 209             case GL_FILL:
 210                fill_back = CLIP_FILL;
 211                offset_back = 0;
 212                break;
 213             case GL_LINE:
 214                fill_back = CLIP_LINE;
 215                offset_back = ctx->Polygon.OffsetLine;
 216                break;
 217             case GL_POINT:
 218                fill_back = CLIP_POINT;
 219                offset_back = ctx->Polygon.OffsetPoint;
 220                break;
 221             }
 222          }
 223
 224          if (ctx->Polygon.BackMode != GL_FILL ||
 225              ctx->Polygon.FrontMode != GL_FILL) {
 226             key.do_unfilled = 1;
 227
 228             /* Most cases the fixed function units will handle.  Cases where
 229              * one or more polygon faces are unfilled will require help:
 230              */
 231             key.clip_mode = BRW_CLIPMODE_CLIP_NON_REJECTED;
 232
 233             if (offset_back || offset_front) {
 234                /* _NEW_POLYGON, _NEW_BUFFERS */
 235                key.offset_units = ctx->Polygon.OffsetUnits * brw->intel.polygon_offset_scale;
 236                key.offset_factor = ctx->Polygon.OffsetFactor * ctx->DrawBuffer->_MRD;
 237             }
 238
 239             switch (ctx->Polygon.FrontFace) {
 240             case GL_CCW:
 241                key.fill_ccw = fill_front;
 242                key.fill_cw = fill_back;
 243                key.offset_ccw = offset_front;
 244                key.offset_cw = offset_back;
 245                if (ctx->Light.Model.TwoSide &&
 246                    key.fill_cw != CLIP_CULL)
 247                   key.copy_bfc_cw = 1;
 248                break;
 249             case GL_CW:
 250                key.fill_cw = fill_front;
 251                key.fill_ccw = fill_back;
 252                key.offset_cw = offset_front;
 253                key.offset_ccw = offset_back;
 254                if (ctx->Light.Model.TwoSide &&
 255                    key.fill_ccw != CLIP_CULL)
 256                   key.copy_bfc_ccw = 1;
 257                break;
 258             }
 259          }
 260       }
 261    }
 262
 263    dri_bo_unreference(brw->clip.prog_bo);
 264    brw->clip.prog_bo = brw_search_cache(&brw->cache, BRW_CLIP_PROG,
 265                                         &key, sizeof(key),
 266                                         NULL, 0,
 267                                         &brw->clip.prog_data);
 268    if (brw->clip.prog_bo == NULL)
 269       compile_clip_prog( brw, &key );
 270 }
 271
 272
 273 const struct brw_tracked_state brw_clip_prog = {
 274    .dirty = {
 275       .mesa  = (_NEW_LIGHT |
 276                 _NEW_TRANSFORM |
 277                 _NEW_POLYGON |
 278                 _NEW_BUFFERS),
 279       .brw   = (BRW_NEW_REDUCED_PRIMITIVE),
 280       .cache = CACHE_NEW_VS_PROG
 281    },
 282    .prepare = upload_clip_prog
 283 };