src/mesa/drivers/dri/i965/brw_wm_sampler_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 #include "brw_context.h"
  34 #include "brw_state.h"
  35 #include "brw_defines.h"
  36
  37 #include "main/macros.h"
  38
  39
  40
  41 /* Samplers aren't strictly wm state from the hardware's perspective,
  42  * but that is the only situation in which we use them in this driver.
  43  */
  44
  45
  46
  47 /* The brw (and related graphics cores) do not support GL_CLAMP.  The
  48  * Intel drivers for "other operating systems" implement GL_CLAMP as
  49  * GL_CLAMP_TO_EDGE, so the same is done here.
  50  */
  51 static GLuint translate_wrap_mode( GLenum wrap )
  52 {
  53    switch( wrap ) {
  54    case GL_REPEAT:
  55       return BRW_TEXCOORDMODE_WRAP;
  56    case GL_CLAMP:
  57       return BRW_TEXCOORDMODE_CLAMP;
  58    case GL_CLAMP_TO_EDGE:
  59       return BRW_TEXCOORDMODE_CLAMP; /* conform likes it this way */
  60    case GL_CLAMP_TO_BORDER:
  61       return BRW_TEXCOORDMODE_CLAMP_BORDER;
  62    case GL_MIRRORED_REPEAT:
  63       return BRW_TEXCOORDMODE_MIRROR;
  64    default:
  65       return BRW_TEXCOORDMODE_WRAP;
  66    }
  67 }
  68
  69
  70 static GLuint U_FIXED(GLfloat value, GLuint frac_bits)
  71 {
  72    value *= (1<<frac_bits);
  73    return value < 0 ? 0 : value;
  74 }
  75
  76 static GLint S_FIXED(GLfloat value, GLuint frac_bits)
  77 {
  78    return value * (1<<frac_bits);
  79 }
  80
  81
  82 static dri_bo *upload_default_color( struct brw_context *brw,
  83                                      const GLfloat *color )
  84 {
  85    struct brw_sampler_default_color sdc;
  86
  87    COPY_4V(sdc.color, color);
  88
  89    return brw_cache_data( &brw->cache, BRW_SAMPLER_DEFAULT_COLOR, &sdc,
  90                           NULL, 0 );
  91 }
  92
  93
  94 struct wm_sampler_key {
  95    int sampler_count;
  96
  97    struct wm_sampler_entry {
  98       GLenum tex_target;
  99       GLenum wrap_r, wrap_s, wrap_t;
 100       float maxlod, minlod;
 101       float lod_bias;
 102       float max_aniso;
 103       GLenum minfilter, magfilter;
 104       GLenum comparemode, comparefunc;
 105       dri_bo *sdc_bo;
 106    } sampler[BRW_MAX_TEX_UNIT];
 107 };
 108
 109 /**
 110  * Sets the sampler state for a single unit based off of the sampler key
 111  * entry.
 112  */
 113 static void brw_update_sampler_state(struct wm_sampler_entry *key,
 114                                      dri_bo *sdc_bo,
 115                                      struct brw_sampler_state *sampler)
 116 {
 117    _mesa_memset(sampler, 0, sizeof(*sampler));
 118
 119    switch (key->minfilter) {
 120    case GL_NEAREST:
 121       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 122       sampler->ss0.mip_filter = BRW_MIPFILTER_NONE;
 123       break;
 124    case GL_LINEAR:
 125       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 126       sampler->ss0.mip_filter = BRW_MIPFILTER_NONE;
 127       break;
 128    case GL_NEAREST_MIPMAP_NEAREST:
 129       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 130       sampler->ss0.mip_filter = BRW_MIPFILTER_NEAREST;
 131       break;
 132    case GL_LINEAR_MIPMAP_NEAREST:
 133       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 134       sampler->ss0.mip_filter = BRW_MIPFILTER_NEAREST;
 135       break;
 136    case GL_NEAREST_MIPMAP_LINEAR:
 137       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 138       sampler->ss0.mip_filter = BRW_MIPFILTER_LINEAR;
 139       break;
 140    case GL_LINEAR_MIPMAP_LINEAR:
 141       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 142       sampler->ss0.mip_filter = BRW_MIPFILTER_LINEAR;
 143       break;
 144    default:
 145       break;
 146    }
 147
 148    /* Set Anisotropy:
 149     */
 150    if (key->max_aniso > 1.0) {
 151       sampler->ss0.min_filter = BRW_MAPFILTER_ANISOTROPIC;
 152       sampler->ss0.mag_filter = BRW_MAPFILTER_ANISOTROPIC;
 153
 154       if (key->max_aniso > 2.0) {
 155          sampler->ss3.max_aniso = MAX2((key->max_aniso - 2) / 2,
 156                                        BRW_ANISORATIO_16);
 157       }
 158    }
 159    else {
 160       switch (key->magfilter) {
 161       case GL_NEAREST:
 162          sampler->ss0.mag_filter = BRW_MAPFILTER_NEAREST;
 163          break;
 164       case GL_LINEAR:
 165          sampler->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
 166          break;
 167       default:
 168          break;
 169       }
 170    }
 171
 172    if (key->tex_target == GL_TEXTURE_CUBE_MAP &&
 173        (key->minfilter != GL_NEAREST || key->magfilter != GL_NEAREST)) {
 174       /* If we're using anything but nearest sampling for a cube map, we
 175        * need to set this wrap mode to avoid GPU lock-ups.
 176        */
 177       sampler->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 178       sampler->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 179       sampler->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 180    }
 181    else {
 182       sampler->ss1.r_wrap_mode = translate_wrap_mode(key->wrap_r);
 183       sampler->ss1.s_wrap_mode = translate_wrap_mode(key->wrap_s);
 184       sampler->ss1.t_wrap_mode = translate_wrap_mode(key->wrap_t);
 185    }
 186
 187    /* Set shadow function:
 188     */
 189    if (key->comparemode == GL_COMPARE_R_TO_TEXTURE_ARB) {
 190       /* Shadowing is "enabled" by emitting a particular sampler
 191        * message (sample_c).  So need to recompile WM program when
 192        * shadow comparison is enabled on each/any texture unit.
 193        */
 194       sampler->ss0.shadow_function =
 195          intel_translate_shadow_compare_func(key->comparefunc);
 196    }
 197
 198    /* Set LOD bias:
 199     */
 200    sampler->ss0.lod_bias = S_FIXED(CLAMP(key->lod_bias, -16, 15), 6);
 201
 202    sampler->ss0.lod_preclamp = 1; /* OpenGL mode */
 203    sampler->ss0.default_color_mode = 0; /* OpenGL/DX10 mode */
 204
 205    /* Set BaseMipLevel, MaxLOD, MinLOD:
 206     *
 207     * XXX: I don't think that using firstLevel, lastLevel works,
 208     * because we always setup the surface state as if firstLevel ==
 209     * level zero.  Probably have to subtract firstLevel from each of
 210     * these:
 211     */
 212    sampler->ss0.base_level = U_FIXED(0, 1);
 213
 214    sampler->ss1.max_lod = U_FIXED(MIN2(MAX2(key->maxlod, 0), 13), 6);
 215    sampler->ss1.min_lod = U_FIXED(MIN2(MAX2(key->minlod, 0), 13), 6);
 216
 217    sampler->ss2.default_color_pointer = sdc_bo->offset >> 5; /* reloc */
 218 }
 219
 220 /** Sets up the cache key for sampler state for all texture units */
 221 static void
 222 brw_wm_sampler_populate_key(struct brw_context *brw,
 223                             struct wm_sampler_key *key)
 224 {
 225    GLcontext *ctx = &brw->intel.ctx;
 226    int unit;
 227
 228    memset(key, 0, sizeof(*key));
 229
 230    for (unit = 0; unit < BRW_MAX_TEX_UNIT; unit++) {
 231       if (ctx->Texture.Unit[unit]._ReallyEnabled) {
 232          struct wm_sampler_entry *entry = &key->sampler[unit];
 233          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 234          struct gl_texture_object *texObj = texUnit->_Current;
 235          struct intel_texture_object *intelObj = intel_texture_object(texObj);
 236          struct gl_texture_image *firstImage =
 237             texObj->Image[0][intelObj->firstLevel];
 238
 239          entry->tex_target = texObj->Target;
 240
 241          entry->wrap_r = texObj->WrapR;
 242          entry->wrap_s = texObj->WrapS;
 243          entry->wrap_t = texObj->WrapT;
 244
 245          entry->maxlod = texObj->MaxLod;
 246          entry->minlod = texObj->MinLod;
 247          entry->lod_bias = texUnit->LodBias + texObj->LodBias;
 248          entry->max_aniso = texObj->MaxAnisotropy;
 249          entry->minfilter = texObj->MinFilter;
 250          entry->magfilter = texObj->MagFilter;
 251          entry->comparemode = texObj->CompareMode;
 252          entry->comparefunc = texObj->CompareFunc;
 253
 254          dri_bo_unreference(brw->wm.sdc_bo[unit]);
 255          if (firstImage->_BaseFormat == GL_DEPTH_COMPONENT) {
 256             float bordercolor[4] = {
 257                texObj->BorderColor[0],
 258                texObj->BorderColor[0],
 259                texObj->BorderColor[0],
 260                texObj->BorderColor[0]
 261             };
 262             /* GL specs that border color for depth textures is taken from the
 263              * R channel, while the hardware uses A.  Spam R into all the
 264              * channels for safety.
 265              */
 266             brw->wm.sdc_bo[unit] = upload_default_color(brw, bordercolor);
 267          } else {
 268             brw->wm.sdc_bo[unit] = upload_default_color(brw,
 269                                                         texObj->BorderColor);
 270          }
 271          key->sampler_count = unit + 1;
 272       }
 273    }
 274 }
 275
 276 /* All samplers must be uploaded in a single contiguous array, which
 277  * complicates various things.  However, this is still too confusing -
 278  * FIXME: simplify all the different new texture state flags.
 279  */
 280 static void upload_wm_samplers( struct brw_context *brw )
 281 {
 282    GLcontext *ctx = &brw->intel.ctx;
 283    struct wm_sampler_key key;
 284    int i;
 285
 286    brw_wm_sampler_populate_key(brw, &key);
 287
 288    if (brw->wm.sampler_count != key.sampler_count) {
 289       brw->wm.sampler_count = key.sampler_count;
 290       brw->state.dirty.cache |= CACHE_NEW_SAMPLER;
 291    }
 292
 293    dri_bo_unreference(brw->wm.sampler_bo);
 294    brw->wm.sampler_bo = NULL;
 295    if (brw->wm.sampler_count == 0)
 296       return;
 297
 298    brw->wm.sampler_bo = brw_search_cache(&brw->cache, BRW_SAMPLER,
 299                                          &key, sizeof(key),
 300                                          brw->wm.sdc_bo, key.sampler_count,
 301                                          NULL);
 302
 303    /* If we didnt find it in the cache, compute the state and put it in the
 304     * cache.
 305     */
 306    if (brw->wm.sampler_bo == NULL) {
 307       struct brw_sampler_state sampler[BRW_MAX_TEX_UNIT];
 308
 309       memset(sampler, 0, sizeof(sampler));
 310       for (i = 0; i < key.sampler_count; i++) {
 311          if (brw->wm.sdc_bo[i] == NULL)
 312             continue;
 313
 314          brw_update_sampler_state(&key.sampler[i], brw->wm.sdc_bo[i],
 315                                   &sampler[i]);
 316       }
 317
 318       brw->wm.sampler_bo = brw_upload_cache(&brw->cache, BRW_SAMPLER,
 319                                             &key, sizeof(key),
 320                                             brw->wm.sdc_bo, key.sampler_count,
 321                                             &sampler, sizeof(sampler),
 322                                             NULL, NULL);
 323
 324       /* Emit SDC relocations */
 325       for (i = 0; i < BRW_MAX_TEX_UNIT; i++) {
 326          if (!ctx->Texture.Unit[i]._ReallyEnabled)
 327             continue;
 328
 329          dri_bo_emit_reloc(brw->wm.sampler_bo,
 330                            I915_GEM_DOMAIN_SAMPLER, 0,
 331                            0,
 332                            i * sizeof(struct brw_sampler_state) +
 333                            offsetof(struct brw_sampler_state, ss2),
 334                            brw->wm.sdc_bo[i]);
 335       }
 336    }
 337 }
 338
 339 const struct brw_tracked_state brw_wm_samplers = {
 340    .dirty = {
 341       .mesa = _NEW_TEXTURE,
 342       .brw = 0,
 343       .cache = 0
 344    },
 345    .prepare = upload_wm_samplers,
 346 };
 347
 348