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