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 static dri_bo *upload_default_color( struct brw_context *brw,
  70                                      const GLfloat *color )
  71 {
  72    struct brw_sampler_default_color sdc;
  73
  74    COPY_4V(sdc.color, color);
  75
  76    return brw_cache_data(&brw->cache, BRW_SAMPLER_DEFAULT_COLOR,
  77                          &sdc, sizeof(sdc), NULL, 0);
  78 }
  79
  80
  81 struct wm_sampler_key {
  82    int sampler_count;
  83
  84    struct wm_sampler_entry {
  85       GLenum tex_target;
  86       GLenum wrap_r, wrap_s, wrap_t;
  87       float maxlod, minlod;
  88       float lod_bias;
  89       float max_aniso;
  90       GLenum minfilter, magfilter;
  91       GLenum comparemode, comparefunc;
  92
  93       /** If target is cubemap, take context setting.
  94        */
  95       GLboolean seamless_cube_map;
  96    } sampler[BRW_MAX_TEX_UNIT];
  97 };
  98
  99 /**
 100  * Sets the sampler state for a single unit based off of the sampler key
 101  * entry.
 102  */
 103 static void brw_update_sampler_state(struct wm_sampler_entry *key,
 104                                      dri_bo *sdc_bo,
 105                                      struct brw_sampler_state *sampler)
 106 {
 107    memset(sampler, 0, sizeof(*sampler));
 108
 109    switch (key->minfilter) {
 110    case GL_NEAREST:
 111       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 112       sampler->ss0.mip_filter = BRW_MIPFILTER_NONE;
 113       break;
 114    case GL_LINEAR:
 115       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 116       sampler->ss0.mip_filter = BRW_MIPFILTER_NONE;
 117       break;
 118    case GL_NEAREST_MIPMAP_NEAREST:
 119       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 120       sampler->ss0.mip_filter = BRW_MIPFILTER_NEAREST;
 121       break;
 122    case GL_LINEAR_MIPMAP_NEAREST:
 123       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 124       sampler->ss0.mip_filter = BRW_MIPFILTER_NEAREST;
 125       break;
 126    case GL_NEAREST_MIPMAP_LINEAR:
 127       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 128       sampler->ss0.mip_filter = BRW_MIPFILTER_LINEAR;
 129       break;
 130    case GL_LINEAR_MIPMAP_LINEAR:
 131       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 132       sampler->ss0.mip_filter = BRW_MIPFILTER_LINEAR;
 133       break;
 134    default:
 135       break;
 136    }
 137
 138    /* Set Anisotropy:
 139     */
 140    if (key->max_aniso > 1.0) {
 141       sampler->ss0.min_filter = BRW_MAPFILTER_ANISOTROPIC;
 142       sampler->ss0.mag_filter = BRW_MAPFILTER_ANISOTROPIC;
 143
 144       if (key->max_aniso > 2.0) {
 145          sampler->ss3.max_aniso = MIN2((key->max_aniso - 2) / 2,
 146                                        BRW_ANISORATIO_16);
 147       }
 148    }
 149    else {
 150       switch (key->magfilter) {
 151       case GL_NEAREST:
 152          sampler->ss0.mag_filter = BRW_MAPFILTER_NEAREST;
 153          break;
 154       case GL_LINEAR:
 155          sampler->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
 156          break;
 157       default:
 158          break;
 159       }
 160    }
 161
 162    sampler->ss1.r_wrap_mode = translate_wrap_mode(key->wrap_r);
 163    sampler->ss1.s_wrap_mode = translate_wrap_mode(key->wrap_s);
 164    sampler->ss1.t_wrap_mode = translate_wrap_mode(key->wrap_t);
 165
 166    /* Cube-maps on 965 and later must use the same wrap mode for all 3
 167     * coordinate dimensions.  Futher, only CUBE and CLAMP are valid.
 168     */
 169    if (key->tex_target == GL_TEXTURE_CUBE_MAP) {
 170       if (key->seamless_cube_map &&
 171           (key->minfilter != GL_NEAREST || key->magfilter != GL_NEAREST)) {
 172          sampler->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 173          sampler->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 174          sampler->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 175       } else {
 176          sampler->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
 177          sampler->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
 178          sampler->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
 179       }
 180    } else if (key->tex_target == GL_TEXTURE_1D) {
 181       /* There's a bug in 1D texture sampling - it actually pays
 182        * attention to the wrap_t value, though it should not.
 183        * Override the wrap_t value here to GL_REPEAT to keep
 184        * any nonexistent border pixels from floating in.
 185        */
 186       sampler->ss1.t_wrap_mode = BRW_TEXCOORDMODE_WRAP;
 187    }
 188
 189
 190    /* Set shadow function:
 191     */
 192    if (key->comparemode == GL_COMPARE_R_TO_TEXTURE_ARB) {
 193       /* Shadowing is "enabled" by emitting a particular sampler
 194        * message (sample_c).  So need to recompile WM program when
 195        * shadow comparison is enabled on each/any texture unit.
 196        */
 197       sampler->ss0.shadow_function =
 198          intel_translate_shadow_compare_func(key->comparefunc);
 199    }
 200
 201    /* Set LOD bias:
 202     */
 203    sampler->ss0.lod_bias = S_FIXED(CLAMP(key->lod_bias, -16, 15), 6);
 204
 205    sampler->ss0.lod_preclamp = 1; /* OpenGL mode */
 206    sampler->ss0.default_color_mode = 0; /* OpenGL/DX10 mode */
 207
 208    /* Set BaseMipLevel, MaxLOD, MinLOD:
 209     *
 210     * XXX: I don't think that using firstLevel, lastLevel works,
 211     * because we always setup the surface state as if firstLevel ==
 212     * level zero.  Probably have to subtract firstLevel from each of
 213     * these:
 214     */
 215    sampler->ss0.base_level = U_FIXED(0, 1);
 216
 217    sampler->ss1.max_lod = U_FIXED(CLAMP(key->maxlod, 0, 13), 6);
 218    sampler->ss1.min_lod = U_FIXED(CLAMP(key->minlod, 0, 13), 6);
 219
 220    sampler->ss2.default_color_pointer = sdc_bo->offset >> 5; /* reloc */
 221 }
 222
 223
 224 /** Sets up the cache key for sampler state for all texture units */
 225 static void
 226 brw_wm_sampler_populate_key(struct brw_context *brw,
 227                             struct wm_sampler_key *key)
 228 {
 229    GLcontext *ctx = &brw->intel.ctx;
 230    int unit;
 231
 232    key->sampler_count = 0;
 233
 234    for (unit = 0; unit < BRW_MAX_TEX_UNIT; unit++) {
 235       if (ctx->Texture.Unit[unit]._ReallyEnabled) {
 236          struct wm_sampler_entry *entry = &key->sampler[unit];
 237          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 238          struct gl_texture_object *texObj = texUnit->_Current;
 239          struct intel_texture_object *intelObj = intel_texture_object(texObj);
 240          struct gl_texture_image *firstImage =
 241             texObj->Image[0][intelObj->firstLevel];
 242
 243          memset(entry, 0, sizeof(*entry));
 244
 245          entry->tex_target = texObj->Target;
 246
 247          entry->seamless_cube_map = (texObj->Target == GL_TEXTURE_CUBE_MAP)
 248             ? ctx->Texture.CubeMapSeamless : GL_FALSE;
 249
 250          entry->wrap_r = texObj->WrapR;
 251          entry->wrap_s = texObj->WrapS;
 252          entry->wrap_t = texObj->WrapT;
 253
 254          entry->maxlod = texObj->MaxLod;
 255          entry->minlod = texObj->MinLod;
 256          entry->lod_bias = texUnit->LodBias + texObj->LodBias;
 257          entry->max_aniso = texObj->MaxAnisotropy;
 258          entry->minfilter = texObj->MinFilter;
 259          entry->magfilter = texObj->MagFilter;
 260          entry->comparemode = texObj->CompareMode;
 261          entry->comparefunc = texObj->CompareFunc;
 262
 263          dri_bo_unreference(brw->wm.sdc_bo[unit]);
 264          if (firstImage->_BaseFormat == GL_DEPTH_COMPONENT) {
 265             float bordercolor[4] = {
 266                texObj->BorderColor.f[0],
 267                texObj->BorderColor.f[0],
 268                texObj->BorderColor.f[0],
 269                texObj->BorderColor.f[0]
 270             };
 271             /* GL specs that border color for depth textures is taken from the
 272              * R channel, while the hardware uses A.  Spam R into all the
 273              * channels for safety.
 274              */
 275             brw->wm.sdc_bo[unit] = upload_default_color(brw, bordercolor);
 276          } else {
 277             brw->wm.sdc_bo[unit] = upload_default_color(brw,
 278                                                         texObj->BorderColor.f);
 279          }
 280          key->sampler_count = unit + 1;
 281       }
 282    }
 283 }
 284
 285 /* All samplers must be uploaded in a single contiguous array, which
 286  * complicates various things.  However, this is still too confusing -
 287  * FIXME: simplify all the different new texture state flags.
 288  */
 289 static void upload_wm_samplers( struct brw_context *brw )
 290 {
 291    GLcontext *ctx = &brw->intel.ctx;
 292    struct wm_sampler_key key;
 293    int i, sampler_key_size;
 294
 295    brw_wm_sampler_populate_key(brw, &key);
 296
 297    if (brw->wm.sampler_count != key.sampler_count) {
 298       brw->wm.sampler_count = key.sampler_count;
 299       brw->state.dirty.cache |= CACHE_NEW_SAMPLER;
 300    }
 301
 302    dri_bo_unreference(brw->wm.sampler_bo);
 303    brw->wm.sampler_bo = NULL;
 304    if (brw->wm.sampler_count == 0)
 305       return;
 306
 307    /* Only include the populated portion of the key in the search. */
 308    sampler_key_size = offsetof(struct wm_sampler_key,
 309                                sampler[key.sampler_count]);
 310    brw->wm.sampler_bo = brw_search_cache(&brw->cache, BRW_SAMPLER,
 311                                          &key, sampler_key_size,
 312                                          brw->wm.sdc_bo, key.sampler_count,
 313                                          NULL);
 314
 315    /* If we didnt find it in the cache, compute the state and put it in the
 316     * cache.
 317     */
 318    if (brw->wm.sampler_bo == NULL) {
 319       struct brw_sampler_state sampler[BRW_MAX_TEX_UNIT];
 320
 321       memset(sampler, 0, sizeof(sampler));
 322       for (i = 0; i < key.sampler_count; i++) {
 323          if (brw->wm.sdc_bo[i] == NULL)
 324             continue;
 325
 326          brw_update_sampler_state(&key.sampler[i], brw->wm.sdc_bo[i],
 327                                   &sampler[i]);
 328       }
 329
 330       brw->wm.sampler_bo = brw_upload_cache(&brw->cache, BRW_SAMPLER,
 331                                             &key, sampler_key_size,
 332                                             brw->wm.sdc_bo, key.sampler_count,
 333                                             &sampler, sizeof(sampler));
 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