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 = MIN2((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 if (key->tex_target == GL_TEXTURE_1D) {
 182       /* There's a bug in 1D texture sampling - it actually pays
 183        * attention to the wrap_t value, though it should not.
 184        * Override the wrap_t value here to GL_REPEAT to keep
 185        * any nonexistent border pixels from floating in.
 186        */
 187       sampler->ss1.r_wrap_mode = translate_wrap_mode(key->wrap_r);
 188       sampler->ss1.s_wrap_mode = translate_wrap_mode(key->wrap_s);
 189       sampler->ss1.t_wrap_mode = BRW_TEXCOORDMODE_WRAP;
 190    }
 191    else {
 192       sampler->ss1.r_wrap_mode = translate_wrap_mode(key->wrap_r);
 193       sampler->ss1.s_wrap_mode = translate_wrap_mode(key->wrap_s);
 194       sampler->ss1.t_wrap_mode = translate_wrap_mode(key->wrap_t);
 195    }
 196
 197    /* Set shadow function:
 198     */
 199    if (key->comparemode == GL_COMPARE_R_TO_TEXTURE_ARB) {
 200       /* Shadowing is "enabled" by emitting a particular sampler
 201        * message (sample_c).  So need to recompile WM program when
 202        * shadow comparison is enabled on each/any texture unit.
 203        */
 204       sampler->ss0.shadow_function =
 205          intel_translate_shadow_compare_func(key->comparefunc);
 206    }
 207
 208    /* Set LOD bias:
 209     */
 210    sampler->ss0.lod_bias = S_FIXED(CLAMP(key->lod_bias, -16, 15), 6);
 211
 212    sampler->ss0.lod_preclamp = 1; /* OpenGL mode */
 213    sampler->ss0.default_color_mode = 0; /* OpenGL/DX10 mode */
 214
 215    /* Set BaseMipLevel, MaxLOD, MinLOD:
 216     *
 217     * XXX: I don't think that using firstLevel, lastLevel works,
 218     * because we always setup the surface state as if firstLevel ==
 219     * level zero.  Probably have to subtract firstLevel from each of
 220     * these:
 221     */
 222    sampler->ss0.base_level = U_FIXED(0, 1);
 223
 224    sampler->ss1.max_lod = U_FIXED(MIN2(MAX2(key->maxlod, 0), 13), 6);
 225    sampler->ss1.min_lod = U_FIXED(MIN2(MAX2(key->minlod, 0), 13), 6);
 226
 227    sampler->ss2.default_color_pointer = sdc_bo->offset >> 5; /* reloc */
 228 }
 229
 230
 231 /** Sets up the cache key for sampler state for all texture units */
 232 static void
 233 brw_wm_sampler_populate_key(struct brw_context *brw,
 234                             struct wm_sampler_key *key)
 235 {
 236    GLcontext *ctx = &brw->intel.ctx;
 237    int unit;
 238
 239    memset(key, 0, sizeof(*key));
 240
 241    for (unit = 0; unit < BRW_MAX_TEX_UNIT; unit++) {
 242       if (ctx->Texture.Unit[unit]._ReallyEnabled) {
 243          struct wm_sampler_entry *entry = &key->sampler[unit];
 244          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 245          struct gl_texture_object *texObj = texUnit->_Current;
 246          struct intel_texture_object *intelObj = intel_texture_object(texObj);
 247          struct gl_texture_image *firstImage =
 248             texObj->Image[0][intelObj->firstLevel];
 249
 250          entry->tex_target = texObj->Target;
 251
 252          entry->wrap_r = texObj->WrapR;
 253          entry->wrap_s = texObj->WrapS;
 254          entry->wrap_t = texObj->WrapT;
 255
 256          entry->maxlod = texObj->MaxLod;
 257          entry->minlod = texObj->MinLod;
 258          entry->lod_bias = texUnit->LodBias + texObj->LodBias;
 259          entry->max_aniso = texObj->MaxAnisotropy;
 260          entry->minfilter = texObj->MinFilter;
 261          entry->magfilter = texObj->MagFilter;
 262          entry->comparemode = texObj->CompareMode;
 263          entry->comparefunc = texObj->CompareFunc;
 264
 265          dri_bo_unreference(brw->wm.sdc_bo[unit]);
 266          if (firstImage->_BaseFormat == GL_DEPTH_COMPONENT) {
 267             float bordercolor[4] = {
 268                texObj->BorderColor[0],
 269                texObj->BorderColor[0],
 270                texObj->BorderColor[0],
 271                texObj->BorderColor[0]
 272             };
 273             /* GL specs that border color for depth textures is taken from the
 274              * R channel, while the hardware uses A.  Spam R into all the
 275              * channels for safety.
 276              */
 277             brw->wm.sdc_bo[unit] = upload_default_color(brw, bordercolor);
 278          } else {
 279             brw->wm.sdc_bo[unit] = upload_default_color(brw,
 280                                                         texObj->BorderColor);
 281          }
 282          key->sampler_count = unit + 1;
 283       }
 284    }
 285 }
 286
 287 /* All samplers must be uploaded in a single contiguous array, which
 288  * complicates various things.  However, this is still too confusing -
 289  * FIXME: simplify all the different new texture state flags.
 290  */
 291 static void upload_wm_samplers( struct brw_context *brw )
 292 {
 293    GLcontext *ctx = &brw->intel.ctx;
 294    struct wm_sampler_key key;
 295    int i;
 296
 297    brw_wm_sampler_populate_key(brw, &key);
 298
 299    if (brw->wm.sampler_count != key.sampler_count) {
 300       brw->wm.sampler_count = key.sampler_count;
 301       brw->state.dirty.cache |= CACHE_NEW_SAMPLER;
 302    }
 303
 304    dri_bo_unreference(brw->wm.sampler_bo);
 305    brw->wm.sampler_bo = NULL;
 306    if (brw->wm.sampler_count == 0)
 307       return;
 308
 309    brw->wm.sampler_bo = brw_search_cache(&brw->cache, BRW_SAMPLER,
 310                                          &key, sizeof(key),
 311                                          brw->wm.sdc_bo, key.sampler_count,
 312                                          NULL);
 313
 314    /* If we didnt find it in the cache, compute the state and put it in the
 315     * cache.
 316     */
 317    if (brw->wm.sampler_bo == NULL) {
 318       struct brw_sampler_state sampler[BRW_MAX_TEX_UNIT];
 319
 320       memset(sampler, 0, sizeof(sampler));
 321       for (i = 0; i < key.sampler_count; i++) {
 322          if (brw->wm.sdc_bo[i] == NULL)
 323             continue;
 324
 325          brw_update_sampler_state(&key.sampler[i], brw->wm.sdc_bo[i],
 326                                   &sampler[i]);
 327       }
 328
 329       brw->wm.sampler_bo = brw_upload_cache(&brw->cache, BRW_SAMPLER,
 330                                             &key, sizeof(key),
 331                                             brw->wm.sdc_bo, key.sampler_count,
 332                                             &sampler, sizeof(sampler),
 333                                             NULL, NULL);
 334
 335       /* Emit SDC relocations */
 336       for (i = 0; i < BRW_MAX_TEX_UNIT; i++) {
 337          if (!ctx->Texture.Unit[i]._ReallyEnabled)
 338             continue;
 339
 340          dri_bo_emit_reloc(brw->wm.sampler_bo,
 341                            I915_GEM_DOMAIN_SAMPLER, 0,
 342                            0,
 343                            i * sizeof(struct brw_sampler_state) +
 344                            offsetof(struct brw_sampler_state, ss2),
 345                            brw->wm.sdc_bo[i]);
 346       }
 347    }
 348 }
 349
 350 const struct brw_tracked_state brw_wm_samplers = {
 351    .dirty = {
 352       .mesa = _NEW_TEXTURE,
 353       .brw = 0,
 354       .cache = 0
 355    },
 356    .prepare = upload_wm_samplers,
 357 };
 358
 359