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 #include "main/samplerobj.h"
  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 uint32_t
  48 translate_wrap_mode(GLenum wrap, bool using_nearest)
  49 {
  50    switch( wrap ) {
  51    case GL_REPEAT:
  52       return BRW_TEXCOORDMODE_WRAP;
  53    case GL_CLAMP:
  54       /* GL_CLAMP is the weird mode where coordinates are clamped to
  55        * [0.0, 1.0], so linear filtering of coordinates outside of
  56        * [0.0, 1.0] give you half edge texel value and half border
  57        * color.  The fragment shader will clamp the coordinates, and
  58        * we set clamp_border here, which gets the result desired.  We
  59        * just use clamp(_to_edge) for nearest, because for nearest
  60        * clamping to 1.0 gives border color instead of the desired
  61        * edge texels.
  62        */
  63       if (using_nearest)
  64          return BRW_TEXCOORDMODE_CLAMP;
  65       else
  66          return BRW_TEXCOORDMODE_CLAMP_BORDER;
  67    case GL_CLAMP_TO_EDGE:
  68       return BRW_TEXCOORDMODE_CLAMP;
  69    case GL_CLAMP_TO_BORDER:
  70       return BRW_TEXCOORDMODE_CLAMP_BORDER;
  71    case GL_MIRRORED_REPEAT:
  72       return BRW_TEXCOORDMODE_MIRROR;
  73    default:
  74       return BRW_TEXCOORDMODE_WRAP;
  75    }
  76 }
  77
  78 /**
  79  * Upload SAMPLER_BORDER_COLOR_STATE.
  80  */
  81 void
  82 upload_default_color(struct brw_context *brw, struct gl_sampler_object *sampler,
  83                      int unit, int ss_index)
  84 {
  85    struct gl_context *ctx = &brw->ctx;
  86    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
  87    struct gl_texture_object *texObj = texUnit->_Current;
  88    struct gl_texture_image *firstImage = texObj->Image[0][texObj->BaseLevel];
  89    float color[4];
  90
  91    switch (firstImage->_BaseFormat) {
  92    case GL_DEPTH_COMPONENT:
  93       /* GL specs that border color for depth textures is taken from the
  94        * R channel, while the hardware uses A.  Spam R into all the
  95        * channels for safety.
  96        */
  97       color[0] = sampler->BorderColor.f[0];
  98       color[1] = sampler->BorderColor.f[0];
  99       color[2] = sampler->BorderColor.f[0];
 100       color[3] = sampler->BorderColor.f[0];
 101       break;
 102    case GL_ALPHA:
 103       color[0] = 0.0;
 104       color[1] = 0.0;
 105       color[2] = 0.0;
 106       color[3] = sampler->BorderColor.f[3];
 107       break;
 108    case GL_INTENSITY:
 109       color[0] = sampler->BorderColor.f[0];
 110       color[1] = sampler->BorderColor.f[0];
 111       color[2] = sampler->BorderColor.f[0];
 112       color[3] = sampler->BorderColor.f[0];
 113       break;
 114    case GL_LUMINANCE:
 115       color[0] = sampler->BorderColor.f[0];
 116       color[1] = sampler->BorderColor.f[0];
 117       color[2] = sampler->BorderColor.f[0];
 118       color[3] = 1.0;
 119       break;
 120    case GL_LUMINANCE_ALPHA:
 121       color[0] = sampler->BorderColor.f[0];
 122       color[1] = sampler->BorderColor.f[0];
 123       color[2] = sampler->BorderColor.f[0];
 124       color[3] = sampler->BorderColor.f[3];
 125       break;
 126    default:
 127       color[0] = sampler->BorderColor.f[0];
 128       color[1] = sampler->BorderColor.f[1];
 129       color[2] = sampler->BorderColor.f[2];
 130       color[3] = sampler->BorderColor.f[3];
 131       break;
 132    }
 133
 134    /* In some cases we use an RGBA surface format for GL RGB textures,
 135     * where we've initialized the A channel to 1.0.  We also have to set
 136     * the border color alpha to 1.0 in that case.
 137     */
 138    if (firstImage->_BaseFormat == GL_RGB)
 139       color[3] = 1.0;
 140
 141    if (brw->gen == 5 || brw->gen == 6) {
 142       struct gen5_sampler_default_color *sdc;
 143
 144       sdc = brw_state_batch(brw, AUB_TRACE_SAMPLER_DEFAULT_COLOR,
 145                             sizeof(*sdc), 32, &brw->wm.sdc_offset[ss_index]);
 146
 147       memset(sdc, 0, sizeof(*sdc));
 148
 149       UNCLAMPED_FLOAT_TO_UBYTE(sdc->ub[0], color[0]);
 150       UNCLAMPED_FLOAT_TO_UBYTE(sdc->ub[1], color[1]);
 151       UNCLAMPED_FLOAT_TO_UBYTE(sdc->ub[2], color[2]);
 152       UNCLAMPED_FLOAT_TO_UBYTE(sdc->ub[3], color[3]);
 153
 154       UNCLAMPED_FLOAT_TO_USHORT(sdc->us[0], color[0]);
 155       UNCLAMPED_FLOAT_TO_USHORT(sdc->us[1], color[1]);
 156       UNCLAMPED_FLOAT_TO_USHORT(sdc->us[2], color[2]);
 157       UNCLAMPED_FLOAT_TO_USHORT(sdc->us[3], color[3]);
 158
 159       UNCLAMPED_FLOAT_TO_SHORT(sdc->s[0], color[0]);
 160       UNCLAMPED_FLOAT_TO_SHORT(sdc->s[1], color[1]);
 161       UNCLAMPED_FLOAT_TO_SHORT(sdc->s[2], color[2]);
 162       UNCLAMPED_FLOAT_TO_SHORT(sdc->s[3], color[3]);
 163
 164       sdc->hf[0] = _mesa_float_to_half(color[0]);
 165       sdc->hf[1] = _mesa_float_to_half(color[1]);
 166       sdc->hf[2] = _mesa_float_to_half(color[2]);
 167       sdc->hf[3] = _mesa_float_to_half(color[3]);
 168
 169       sdc->b[0] = sdc->s[0] >> 8;
 170       sdc->b[1] = sdc->s[1] >> 8;
 171       sdc->b[2] = sdc->s[2] >> 8;
 172       sdc->b[3] = sdc->s[3] >> 8;
 173
 174       sdc->f[0] = color[0];
 175       sdc->f[1] = color[1];
 176       sdc->f[2] = color[2];
 177       sdc->f[3] = color[3];
 178    } else {
 179       struct brw_sampler_default_color *sdc;
 180
 181       sdc = brw_state_batch(brw, AUB_TRACE_SAMPLER_DEFAULT_COLOR,
 182                             sizeof(*sdc), 32, &brw->wm.sdc_offset[ss_index]);
 183
 184       COPY_4V(sdc->color, color);
 185    }
 186 }
 187
 188 /**
 189  * Sets the sampler state for a single unit based off of the sampler key
 190  * entry.
 191  */
 192 static void brw_update_sampler_state(struct brw_context *brw,
 193                                      int unit,
 194                                      int ss_index,
 195                                      struct brw_sampler_state *sampler)
 196 {
 197    struct gl_context *ctx = &brw->ctx;
 198    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 199    struct gl_texture_object *texObj = texUnit->_Current;
 200    struct gl_sampler_object *gl_sampler = _mesa_get_samplerobj(ctx, unit);
 201    bool using_nearest = false;
 202
 203    /* These don't use samplers at all. */
 204    if (texObj->Target == GL_TEXTURE_BUFFER)
 205       return;
 206
 207    switch (gl_sampler->MinFilter) {
 208    case GL_NEAREST:
 209       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 210       sampler->ss0.mip_filter = BRW_MIPFILTER_NONE;
 211       using_nearest = true;
 212       break;
 213    case GL_LINEAR:
 214       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 215       sampler->ss0.mip_filter = BRW_MIPFILTER_NONE;
 216       break;
 217    case GL_NEAREST_MIPMAP_NEAREST:
 218       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 219       sampler->ss0.mip_filter = BRW_MIPFILTER_NEAREST;
 220       break;
 221    case GL_LINEAR_MIPMAP_NEAREST:
 222       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 223       sampler->ss0.mip_filter = BRW_MIPFILTER_NEAREST;
 224       break;
 225    case GL_NEAREST_MIPMAP_LINEAR:
 226       sampler->ss0.min_filter = BRW_MAPFILTER_NEAREST;
 227       sampler->ss0.mip_filter = BRW_MIPFILTER_LINEAR;
 228       break;
 229    case GL_LINEAR_MIPMAP_LINEAR:
 230       sampler->ss0.min_filter = BRW_MAPFILTER_LINEAR;
 231       sampler->ss0.mip_filter = BRW_MIPFILTER_LINEAR;
 232       break;
 233    default:
 234       break;
 235    }
 236
 237    /* Set Anisotropy:
 238     */
 239    if (gl_sampler->MaxAnisotropy > 1.0) {
 240       sampler->ss0.min_filter = BRW_MAPFILTER_ANISOTROPIC;
 241       sampler->ss0.mag_filter = BRW_MAPFILTER_ANISOTROPIC;
 242
 243       if (gl_sampler->MaxAnisotropy > 2.0) {
 244          sampler->ss3.max_aniso = MIN2((gl_sampler->MaxAnisotropy - 2) / 2,
 245                                        BRW_ANISORATIO_16);
 246       }
 247    }
 248    else {
 249       switch (gl_sampler->MagFilter) {
 250       case GL_NEAREST:
 251          sampler->ss0.mag_filter = BRW_MAPFILTER_NEAREST;
 252          using_nearest = true;
 253          break;
 254       case GL_LINEAR:
 255          sampler->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
 256          break;
 257       default:
 258          break;
 259       }
 260    }
 261
 262    sampler->ss1.r_wrap_mode = translate_wrap_mode(gl_sampler->WrapR,
 263                                                   using_nearest);
 264    sampler->ss1.s_wrap_mode = translate_wrap_mode(gl_sampler->WrapS,
 265                                                   using_nearest);
 266    sampler->ss1.t_wrap_mode = translate_wrap_mode(gl_sampler->WrapT,
 267                                                   using_nearest);
 268
 269    if (brw->gen >= 6 &&
 270        sampler->ss0.min_filter != sampler->ss0.mag_filter)
 271         sampler->ss0.min_mag_neq = 1;
 272
 273    /* Cube-maps on 965 and later must use the same wrap mode for all 3
 274     * coordinate dimensions.  Futher, only CUBE and CLAMP are valid.
 275     */
 276    if (texObj->Target == GL_TEXTURE_CUBE_MAP ||
 277        texObj->Target == GL_TEXTURE_CUBE_MAP_ARRAY) {
 278       if (ctx->Texture.CubeMapSeamless &&
 279           (gl_sampler->MinFilter != GL_NEAREST ||
 280            gl_sampler->MagFilter != GL_NEAREST)) {
 281          sampler->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 282          sampler->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 283          sampler->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CUBE;
 284       } else {
 285          sampler->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
 286          sampler->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
 287          sampler->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
 288       }
 289    } else if (texObj->Target == GL_TEXTURE_1D) {
 290       /* There's a bug in 1D texture sampling - it actually pays
 291        * attention to the wrap_t value, though it should not.
 292        * Override the wrap_t value here to GL_REPEAT to keep
 293        * any nonexistent border pixels from floating in.
 294        */
 295       sampler->ss1.t_wrap_mode = BRW_TEXCOORDMODE_WRAP;
 296    }
 297
 298
 299    /* Set shadow function:
 300     */
 301    if (gl_sampler->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) {
 302       /* Shadowing is "enabled" by emitting a particular sampler
 303        * message (sample_c).  So need to recompile WM program when
 304        * shadow comparison is enabled on each/any texture unit.
 305        */
 306       sampler->ss0.shadow_function =
 307          intel_translate_shadow_compare_func(gl_sampler->CompareFunc);
 308    }
 309
 310    /* Set LOD bias:
 311     */
 312    sampler->ss0.lod_bias = S_FIXED(CLAMP(texUnit->LodBias +
 313                                          gl_sampler->LodBias, -16, 15), 6);
 314
 315    sampler->ss0.lod_preclamp = 1; /* OpenGL mode */
 316    sampler->ss0.default_color_mode = 0; /* OpenGL/DX10 mode */
 317
 318    /* Set BaseMipLevel, MaxLOD, MinLOD:
 319     *
 320     * XXX: I don't think that using firstLevel, lastLevel works,
 321     * because we always setup the surface state as if firstLevel ==
 322     * level zero.  Probably have to subtract firstLevel from each of
 323     * these:
 324     */
 325    sampler->ss0.base_level = U_FIXED(0, 1);
 326
 327    sampler->ss1.max_lod = U_FIXED(CLAMP(gl_sampler->MaxLod, 0, 13), 6);
 328    sampler->ss1.min_lod = U_FIXED(CLAMP(gl_sampler->MinLod, 0, 13), 6);
 329
 330    /* On Gen6+, the sampler can handle non-normalized texture
 331     * rectangle coordinates natively
 332     */
 333    if (brw->gen >= 6 && texObj->Target == GL_TEXTURE_RECTANGLE) {
 334       sampler->ss3.non_normalized_coord = 1;
 335    }
 336
 337    upload_default_color(brw, gl_sampler, unit, ss_index);
 338
 339    if (brw->gen >= 6) {
 340       sampler->ss2.default_color_pointer = brw->wm.sdc_offset[ss_index] >> 5;
 341    } else {
 342       /* reloc */
 343       sampler->ss2.default_color_pointer = (brw->batch.bo->offset +
 344                                             brw->wm.sdc_offset[ss_index]) >> 5;
 345
 346       drm_intel_bo_emit_reloc(brw->batch.bo,
 347                               brw->sampler.offset +
 348                               ss_index * sizeof(struct brw_sampler_state) +
 349                               offsetof(struct brw_sampler_state, ss2),
 350                               brw->batch.bo, brw->wm.sdc_offset[ss_index],
 351                               I915_GEM_DOMAIN_SAMPLER, 0);
 352    }
 353
 354    if (sampler->ss0.min_filter != BRW_MAPFILTER_NEAREST)
 355       sampler->ss3.address_round |= BRW_ADDRESS_ROUNDING_ENABLE_U_MIN |
 356                                     BRW_ADDRESS_ROUNDING_ENABLE_V_MIN |
 357                                     BRW_ADDRESS_ROUNDING_ENABLE_R_MIN;
 358    if (sampler->ss0.mag_filter != BRW_MAPFILTER_NEAREST)
 359       sampler->ss3.address_round |= BRW_ADDRESS_ROUNDING_ENABLE_U_MAG |
 360                                     BRW_ADDRESS_ROUNDING_ENABLE_V_MAG |
 361                                     BRW_ADDRESS_ROUNDING_ENABLE_R_MAG;
 362 }
 363
 364
 365 static void
 366 brw_upload_samplers(struct brw_context *brw)
 367 {
 368    struct gl_context *ctx = &brw->ctx;
 369    struct brw_sampler_state *samplers;
 370
 371    /* BRW_NEW_VERTEX_PROGRAM and BRW_NEW_FRAGMENT_PROGRAM */
 372    struct gl_program *vs = (struct gl_program *) brw->vertex_program;
 373    struct gl_program *fs = (struct gl_program *) brw->fragment_program;
 374
 375    GLbitfield SamplersUsed = vs->SamplersUsed | fs->SamplersUsed;
 376
 377    /* ARB programs use the texture unit number as the sampler index, so we
 378     * need to find the highest unit used.  A bit-count will not work.
 379     */
 380    brw->sampler.count = _mesa_fls(SamplersUsed);
 381
 382    if (brw->sampler.count == 0)
 383       return;
 384
 385    samplers = brw_state_batch(brw, AUB_TRACE_SAMPLER_STATE,
 386                               brw->sampler.count * sizeof(*samplers),
 387                               32, &brw->sampler.offset);
 388    memset(samplers, 0, brw->sampler.count * sizeof(*samplers));
 389
 390    for (unsigned s = 0; s < brw->sampler.count; s++) {
 391       if (SamplersUsed & (1 << s)) {
 392          const unsigned unit = (fs->SamplersUsed & (1 << s)) ?
 393             fs->SamplerUnits[s] : vs->SamplerUnits[s];
 394          if (ctx->Texture.Unit[unit]._ReallyEnabled)
 395             brw_update_sampler_state(brw, unit, s, &samplers[s]);
 396       }
 397    }
 398
 399    brw->state.dirty.cache |= CACHE_NEW_SAMPLER;
 400 }
 401
 402 const struct brw_tracked_state brw_samplers = {
 403    .dirty = {
 404       .mesa = _NEW_TEXTURE,
 405       .brw = BRW_NEW_BATCH |
 406              BRW_NEW_VERTEX_PROGRAM |
 407              BRW_NEW_FRAGMENT_PROGRAM,
 408       .cache = 0
 409    },
 410    .emit = brw_upload_samplers,
 411 };
 412
 413