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