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 {
 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
 221 /** Sets up the cache key for sampler state for all texture units */
 222 static void
 223 brw_wm_sampler_populate_key(struct brw_context *brw,
 224                             struct wm_sampler_key *key)
 225 {
 226    GLcontext *ctx = &brw->intel.ctx;
 227    int unit;
 228
 229    memset(key, 0, sizeof(*key));
 230
 231    for (unit = 0; unit < BRW_MAX_TEX_UNIT; unit++) {
 232       if (ctx->Texture.Unit[unit]._ReallyEnabled) {
 233          struct wm_sampler_entry *entry = &key->sampler[unit];
 234          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 235          struct gl_texture_object *texObj = texUnit->_Current;
 236          struct intel_texture_object *intelObj = intel_texture_object(texObj);
 237          struct gl_texture_image *firstImage =
 238             texObj->Image[0][intelObj->firstLevel];
 239
 240          entry->tex_target = texObj->Target;
 241
 242          entry->wrap_r = texObj->WrapR;
 243          entry->wrap_s = texObj->WrapS;
 244          entry->wrap_t = texObj->WrapT;
 245
 246          entry->maxlod = texObj->MaxLod;
 247          entry->minlod = texObj->MinLod;
 248          entry->lod_bias = texUnit->LodBias + texObj->LodBias;
 249          entry->max_aniso = texObj->MaxAnisotropy;
 250          entry->minfilter = texObj->MinFilter;
 251          entry->magfilter = texObj->MagFilter;
 252          entry->comparemode = texObj->CompareMode;
 253          entry->comparefunc = texObj->CompareFunc;
 254
 255          dri_bo_unreference(brw->wm.sdc_bo[unit]);
 256          if (firstImage->_BaseFormat == GL_DEPTH_COMPONENT) {
 257             float bordercolor[4] = {
 258                texObj->BorderColor[0],
 259                texObj->BorderColor[0],
 260                texObj->BorderColor[0],
 261                texObj->BorderColor[0]
 262             };
 263             /* GL specs that border color for depth textures is taken from the
 264              * R channel, while the hardware uses A.  Spam R into all the
 265              * channels for safety.
 266              */
 267             brw->wm.sdc_bo[unit] = upload_default_color(brw, bordercolor);
 268          } else {
 269             brw->wm.sdc_bo[unit] = upload_default_color(brw,
 270                                                         texObj->BorderColor);
 271          }
 272          key->sampler_count = unit + 1;
 273       }
 274    }
 275 }
 276
 277 /* All samplers must be uploaded in a single contiguous array, which
 278  * complicates various things.  However, this is still too confusing -
 279  * FIXME: simplify all the different new texture state flags.
 280  */
 281 static void upload_wm_samplers( struct brw_context *brw )
 282 {
 283    GLcontext *ctx = &brw->intel.ctx;
 284    struct wm_sampler_key key;
 285    int i;
 286
 287    brw_wm_sampler_populate_key(brw, &key);
 288
 289    if (brw->wm.sampler_count != key.sampler_count) {
 290       brw->wm.sampler_count = key.sampler_count;
 291       brw->state.dirty.cache |= CACHE_NEW_SAMPLER;
 292    }
 293
 294    dri_bo_unreference(brw->wm.sampler_bo);
 295    brw->wm.sampler_bo = NULL;
 296    if (brw->wm.sampler_count == 0)
 297       return;
 298
 299    brw->wm.sampler_bo = brw_search_cache(&brw->cache, BRW_SAMPLER,
 300                                          &key, sizeof(key),
 301                                          brw->wm.sdc_bo, key.sampler_count,
 302                                          NULL);
 303
 304    /* If we didnt find it in the cache, compute the state and put it in the
 305     * cache.
 306     */
 307    if (brw->wm.sampler_bo == NULL) {
 308       struct brw_sampler_state sampler[BRW_MAX_TEX_UNIT];
 309
 310       memset(sampler, 0, sizeof(sampler));
 311       for (i = 0; i < key.sampler_count; i++) {
 312          if (brw->wm.sdc_bo[i] == NULL)
 313             continue;
 314
 315          brw_update_sampler_state(&key.sampler[i], brw->wm.sdc_bo[i],
 316                                   &sampler[i]);
 317       }
 318
 319       brw->wm.sampler_bo = brw_upload_cache(&brw->cache, BRW_SAMPLER,
 320                                             &key, sizeof(key),
 321                                             brw->wm.sdc_bo, key.sampler_count,
 322                                             &sampler, sizeof(sampler),
 323                                             NULL, NULL);
 324
 325       /* Emit SDC relocations */
 326       for (i = 0; i < BRW_MAX_TEX_UNIT; i++) {
 327          if (!ctx->Texture.Unit[i]._ReallyEnabled)
 328             continue;
 329
 330          dri_bo_emit_reloc(brw->wm.sampler_bo,
 331                            I915_GEM_DOMAIN_SAMPLER, 0,
 332                            0,
 333                            i * sizeof(struct brw_sampler_state) +
 334                            offsetof(struct brw_sampler_state, ss2),
 335                            brw->wm.sdc_bo[i]);
 336       }
 337    }
 338 }
 339
 340 const struct brw_tracked_state brw_wm_samplers = {
 341    .dirty = {
 342       .mesa = _NEW_TEXTURE,
 343       .brw = 0,
 344       .cache = 0
 345    },
 346    .prepare = upload_wm_samplers,
 347 };
 348
 349