src/mesa/drivers/dri/i965/brw_sf_state.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
  34 #include "brw_context.h"
  35 #include "brw_state.h"
  36 #include "brw_defines.h"
  37 #include "macros.h"
  38 #include "intel_fbo.h"
  39
  40 static int upload_sf_vp(struct brw_context *brw)
  41 {
  42    GLcontext *ctx = &brw->intel.ctx;
  43    const GLfloat depth_scale = 1.0F / ctx->DrawBuffer->_DepthMaxF;
  44    struct brw_sf_viewport sfv;
  45    struct intel_renderbuffer *irb =
  46       intel_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]);
  47    GLfloat y_scale, y_bias;
  48
  49    memset(&sfv, 0, sizeof(sfv));
  50
  51    if (ctx->DrawBuffer->Name) {
  52       /* User-created FBO */
  53       if (irb && !irb->RenderToTexture) {
  54          y_scale = -1.0;
  55          y_bias = ctx->DrawBuffer->Height;
  56       } else {
  57          y_scale = 1.0;
  58          y_bias = 0;
  59       }
  60    } else {
  61       y_scale = -1.0;
  62       y_bias = ctx->DrawBuffer->Height;
  63    }
  64
  65    /* _NEW_VIEWPORT, BRW_NEW_METAOPS */
  66
  67    if (!brw->metaops.active) {
  68       const GLfloat *v = ctx->Viewport._WindowMap.m;
  69
  70       sfv.viewport.m00 = v[MAT_SX];
  71       sfv.viewport.m11 = v[MAT_SY] * y_scale;
  72       sfv.viewport.m22 = v[MAT_SZ] * depth_scale;
  73       sfv.viewport.m30 = v[MAT_TX];
  74       sfv.viewport.m31 = v[MAT_TY] * y_scale + y_bias;
  75       sfv.viewport.m32 = v[MAT_TZ] * depth_scale;
  76    } else {
  77       sfv.viewport.m00 =   1;
  78       sfv.viewport.m11 = - 1;
  79       sfv.viewport.m22 =   1;
  80       sfv.viewport.m30 =   0;
  81       sfv.viewport.m31 =   ctx->DrawBuffer->Height;
  82       sfv.viewport.m32 =   0;
  83    }
  84
  85    /* _NEW_SCISSOR */
  86
  87    /* The scissor only needs to handle the intersection of drawable and
  88     * scissor rect.  Clipping to the boundaries of static shared buffers
  89     * for front/back/depth is covered by looping over cliprects in brw_draw.c.
  90     *
  91     * Note that the hardware's coordinates are inclusive, while Mesa's min is
  92     * inclusive but max is exclusive.
  93     */
  94    sfv.scissor.xmin = ctx->DrawBuffer->_Xmin;
  95    sfv.scissor.xmax = ctx->DrawBuffer->_Xmax - 1;
  96    sfv.scissor.ymin = ctx->DrawBuffer->Height - ctx->DrawBuffer->_Ymax;
  97    sfv.scissor.ymax = ctx->DrawBuffer->Height - ctx->DrawBuffer->_Ymin - 1;
  98
  99    dri_bo_unreference(brw->sf.vp_bo);
 100    brw->sf.vp_bo = brw_cache_data( &brw->cache, BRW_SF_VP, &sfv, NULL, 0 );
 101
 102    return dri_bufmgr_check_aperture_space(brw->sf.vp_bo);
 103 }
 104
 105 const struct brw_tracked_state brw_sf_vp = {
 106    .dirty = {
 107       .mesa  = (_NEW_VIEWPORT |
 108                 _NEW_SCISSOR),
 109       .brw   = BRW_NEW_METAOPS,
 110       .cache = 0
 111    },
 112    .prepare = upload_sf_vp
 113 };
 114
 115 struct brw_sf_unit_key {
 116    unsigned int total_grf;
 117    unsigned int urb_entry_read_length;
 118
 119    unsigned int nr_urb_entries, urb_size, sfsize;
 120
 121    GLenum front_face, cull_face;
 122    GLboolean scissor, line_smooth, point_sprite, point_attenuated;
 123    float line_width;
 124    float point_size;
 125 };
 126
 127 static void
 128 sf_unit_populate_key(struct brw_context *brw, struct brw_sf_unit_key *key)
 129 {
 130    memset(key, 0, sizeof(*key));
 131
 132    /* CACHE_NEW_SF_PROG */
 133    key->total_grf = brw->sf.prog_data->total_grf;
 134    key->urb_entry_read_length = brw->sf.prog_data->urb_read_length;
 135
 136    /* BRW_NEW_URB_FENCE */
 137    key->nr_urb_entries = brw->urb.nr_sf_entries;
 138    key->urb_size = brw->urb.vsize;
 139    key->sfsize = brw->urb.sfsize;
 140
 141    key->scissor = brw->attribs.Scissor->Enabled;
 142    key->front_face = brw->attribs.Polygon->FrontFace;
 143
 144    if (brw->attribs.Polygon->CullFlag)
 145       key->cull_face = brw->attribs.Polygon->CullFaceMode;
 146    else
 147       key->cull_face = GL_NONE;
 148
 149    key->line_width = brw->attribs.Line->Width;
 150    key->line_smooth = brw->attribs.Line->SmoothFlag;
 151
 152    key->point_sprite = brw->attribs.Point->PointSprite;
 153    key->point_size = brw->attribs.Point->Size;
 154    key->point_attenuated = brw->attribs.Point->_Attenuated;
 155 }
 156
 157 static dri_bo *
 158 sf_unit_create_from_key(struct brw_context *brw, struct brw_sf_unit_key *key,
 159                         dri_bo **reloc_bufs)
 160 {
 161    struct brw_sf_unit_state sf;
 162    dri_bo *bo;
 163
 164    memset(&sf, 0, sizeof(sf));
 165
 166    sf.thread0.grf_reg_count = ALIGN(key->total_grf, 16) / 16 - 1;
 167    sf.thread0.kernel_start_pointer = brw->sf.prog_bo->offset >> 6; /* reloc */
 168
 169    sf.thread1.floating_point_mode = BRW_FLOATING_POINT_NON_IEEE_754;
 170
 171    sf.thread3.dispatch_grf_start_reg = 3;
 172    sf.thread3.urb_entry_read_offset = 1;
 173    sf.thread3.urb_entry_read_length = key->urb_entry_read_length;
 174
 175    sf.thread4.nr_urb_entries = key->nr_urb_entries;
 176    sf.thread4.urb_entry_allocation_size = key->sfsize - 1;
 177    sf.thread4.max_threads = MIN2(12, key->nr_urb_entries / 2) - 1;
 178
 179    if (INTEL_DEBUG & DEBUG_SINGLE_THREAD)
 180       sf.thread4.max_threads = 0;
 181
 182    if (INTEL_DEBUG & DEBUG_STATS)
 183       sf.thread4.stats_enable = 1;
 184
 185    /* CACHE_NEW_SF_VP */
 186    sf.sf5.sf_viewport_state_offset = brw->sf.vp_bo->offset >> 5; /* reloc */
 187
 188    sf.sf5.viewport_transform = 1;
 189
 190    /* _NEW_SCISSOR */
 191    if (key->scissor)
 192       sf.sf6.scissor = 1;
 193
 194    /* _NEW_POLYGON */
 195    if (key->front_face == GL_CCW)
 196       sf.sf5.front_winding = BRW_FRONTWINDING_CCW;
 197    else
 198       sf.sf5.front_winding = BRW_FRONTWINDING_CW;
 199
 200    switch (key->cull_face) {
 201    case GL_FRONT:
 202       sf.sf6.cull_mode = BRW_CULLMODE_FRONT;
 203       break;
 204    case GL_BACK:
 205       sf.sf6.cull_mode = BRW_CULLMODE_BACK;
 206       break;
 207    case GL_FRONT_AND_BACK:
 208       sf.sf6.cull_mode = BRW_CULLMODE_BOTH;
 209       break;
 210    case GL_NONE:
 211       sf.sf6.cull_mode = BRW_CULLMODE_NONE;
 212       break;
 213    default:
 214       assert(0);
 215       break;
 216    }
 217
 218    /* _NEW_LINE */
 219    /* XXX use ctx->Const.Min/MaxLineWidth here */
 220    sf.sf6.line_width = CLAMP(key->line_width, 1.0, 5.0) * (1<<1);
 221
 222    sf.sf6.line_endcap_aa_region_width = 1;
 223    if (key->line_smooth)
 224       sf.sf6.aa_enable = 1;
 225    else if (sf.sf6.line_width <= 0x2)
 226        sf.sf6.line_width = 0;
 227
 228    /* _NEW_POINT */
 229    sf.sf6.point_rast_rule = BRW_RASTRULE_UPPER_RIGHT;   /* opengl conventions */
 230    /* XXX clamp max depends on AA vs. non-AA */
 231
 232    sf.sf7.sprite_point = key->point_sprite;
 233    sf.sf7.point_size = CLAMP(nearbyint(key->point_size), 1, 255) * (1<<3);
 234    sf.sf7.use_point_size_state = !key->point_attenuated;
 235    sf.sf7.aa_line_distance_mode = 0;
 236
 237    /* might be BRW_NEW_PRIMITIVE if we have to adjust pv for polygons:
 238     */
 239    sf.sf7.trifan_pv = 2;
 240    sf.sf7.linestrip_pv = 1;
 241    sf.sf7.tristrip_pv = 2;
 242    sf.sf7.line_last_pixel_enable = 0;
 243
 244    /* Set bias for OpenGL rasterization rules:
 245     */
 246    sf.sf6.dest_org_vbias = 0x8;
 247    sf.sf6.dest_org_hbias = 0x8;
 248
 249    bo = brw_upload_cache(&brw->cache, BRW_SF_UNIT,
 250                          key, sizeof(*key),
 251                          reloc_bufs, 2,
 252                          &sf, sizeof(sf),
 253                          NULL, NULL);
 254
 255    /* Emit SF program relocation */
 256    intel_bo_emit_reloc(bo,
 257                        DRM_GEM_DOMAIN_I915_INSTRUCTION, 0,
 258                        sf.thread0.grf_reg_count << 1,
 259                        offsetof(struct brw_sf_unit_state, thread0),
 260                        brw->sf.prog_bo);
 261
 262    /* Emit SF viewport relocation */
 263    intel_bo_emit_reloc(bo,
 264                        DRM_GEM_DOMAIN_I915_INSTRUCTION, 0,
 265                        sf.sf5.front_winding | (sf.sf5.viewport_transform << 1),
 266                        offsetof(struct brw_sf_unit_state, sf5),
 267                        brw->sf.vp_bo);
 268
 269    return bo;
 270 }
 271
 272 static int upload_sf_unit( struct brw_context *brw )
 273 {
 274    struct brw_sf_unit_key key;
 275    dri_bo *reloc_bufs[2];
 276    int ret = 0;
 277
 278    sf_unit_populate_key(brw, &key);
 279
 280    reloc_bufs[0] = brw->sf.prog_bo;
 281    reloc_bufs[1] = brw->sf.vp_bo;
 282
 283    dri_bo_unreference(brw->sf.state_bo);
 284    brw->sf.state_bo = brw_search_cache(&brw->cache, BRW_SF_UNIT,
 285                                        &key, sizeof(key),
 286                                        reloc_bufs, 2,
 287                                        NULL);
 288    if (brw->sf.state_bo == NULL) {
 289       brw->sf.state_bo = sf_unit_create_from_key(brw, &key, reloc_bufs);
 290    }
 291
 292    if (reloc_bufs[0])
 293      ret |= dri_bufmgr_check_aperture_space(reloc_bufs[0]);
 294
 295    if (reloc_bufs[1])
 296      ret |= dri_bufmgr_check_aperture_space(reloc_bufs[1]);
 297
 298    ret |= dri_bufmgr_check_aperture_space(brw->sf.state_bo);
 299    return ret;
 300 }
 301
 302 const struct brw_tracked_state brw_sf_unit = {
 303    .dirty = {
 304       .mesa  = (_NEW_POLYGON |
 305                 _NEW_LINE |
 306                 _NEW_POINT |
 307                 _NEW_SCISSOR),
 308       .brw   = (BRW_NEW_URB_FENCE |
 309                 BRW_NEW_METAOPS),
 310       .cache = (CACHE_NEW_SF_VP |
 311                 CACHE_NEW_SF_PROG)
 312    },
 313    .prepare = upload_sf_unit,
 314 };