src/mesa/state_tracker/st_atom_texture.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * 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, sub license, 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 portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28  /*
  29   * Authors:
  30   *   Keith Whitwell <keithw@vmware.com>
  31   *   Brian Paul
  32   */
  33
  34
  35 #include "main/macros.h"
  36 #include "main/mtypes.h"
  37 #include "main/samplerobj.h"
  38 #include "main/texobj.h"
  39 #include "program/prog_instruction.h"
  40
  41 #include "st_context.h"
  42 #include "st_atom.h"
  43 #include "st_texture.h"
  44 #include "st_format.h"
  45 #include "st_cb_texture.h"
  46 #include "pipe/p_context.h"
  47 #include "util/u_format.h"
  48 #include "util/u_inlines.h"
  49 #include "cso_cache/cso_context.h"
  50
  51
  52 /**
  53  * Return swizzle1(swizzle2)
  54  */
  55 static unsigned
  56 swizzle_swizzle(unsigned swizzle1, unsigned swizzle2)
  57 {
  58    unsigned i, swz[4];
  59
  60    for (i = 0; i < 4; i++) {
  61       unsigned s = GET_SWZ(swizzle1, i);
  62       switch (s) {
  63       case SWIZZLE_X:
  64       case SWIZZLE_Y:
  65       case SWIZZLE_Z:
  66       case SWIZZLE_W:
  67          swz[i] = GET_SWZ(swizzle2, s);
  68          break;
  69       case SWIZZLE_ZERO:
  70          swz[i] = SWIZZLE_ZERO;
  71          break;
  72       case SWIZZLE_ONE:
  73          swz[i] = SWIZZLE_ONE;
  74          break;
  75       default:
  76          assert(!"Bad swizzle term");
  77          swz[i] = SWIZZLE_X;
  78       }
  79    }
  80
  81    return MAKE_SWIZZLE4(swz[0], swz[1], swz[2], swz[3]);
  82 }
  83
  84
  85 /**
  86  * Given a user-specified texture base format, the actual gallium texture
  87  * format and the current GL_DEPTH_MODE, return a texture swizzle.
  88  *
  89  * Consider the case where the user requests a GL_RGB internal texture
  90  * format the driver actually uses an RGBA format.  The A component should
  91  * be ignored and sampling from the texture should always return (r,g,b,1).
  92  * But if we rendered to the texture we might have written A values != 1.
  93  * By sampling the texture with a ".xyz1" swizzle we'll get the expected A=1.
  94  * This function computes the texture swizzle needed to get the expected
  95  * values.
  96  *
  97  * In the case of depth textures, the GL_DEPTH_MODE state determines the
  98  * texture swizzle.
  99  *
 100  * This result must be composed with the user-specified swizzle to get
 101  * the final swizzle.
 102  */
 103 static unsigned
 104 compute_texture_format_swizzle(GLenum baseFormat, GLenum depthMode,
 105                                enum pipe_format actualFormat)
 106 {
 107    switch (baseFormat) {
 108    case GL_RGBA:
 109       return SWIZZLE_XYZW;
 110    case GL_RGB:
 111       if (util_format_has_alpha(actualFormat))
 112          return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_ONE);
 113       else
 114          return SWIZZLE_XYZW;
 115    case GL_RG:
 116       if (util_format_get_nr_components(actualFormat) > 2)
 117          return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_ZERO, SWIZZLE_ONE);
 118       else
 119          return SWIZZLE_XYZW;
 120    case GL_RED:
 121       if (util_format_get_nr_components(actualFormat) > 1)
 122          return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_ZERO,
 123                               SWIZZLE_ZERO, SWIZZLE_ONE);
 124       else
 125          return SWIZZLE_XYZW;
 126    case GL_ALPHA:
 127       if (util_format_get_nr_components(actualFormat) > 1)
 128          return MAKE_SWIZZLE4(SWIZZLE_ZERO, SWIZZLE_ZERO,
 129                               SWIZZLE_ZERO, SWIZZLE_W);
 130       else
 131          return SWIZZLE_XYZW;
 132    case GL_LUMINANCE:
 133       if (util_format_get_nr_components(actualFormat) > 1)
 134          return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_ONE);
 135       else
 136          return SWIZZLE_XYZW;
 137    case GL_LUMINANCE_ALPHA:
 138       if (util_format_get_nr_components(actualFormat) > 2)
 139          return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W);
 140       else
 141          return SWIZZLE_XYZW;
 142    case GL_INTENSITY:
 143       if (util_format_get_nr_components(actualFormat) > 1)
 144          return SWIZZLE_XXXX;
 145       else
 146          return SWIZZLE_XYZW;
 147    case GL_STENCIL_INDEX:
 148       return SWIZZLE_XYZW;
 149    case GL_DEPTH_STENCIL:
 150       /* fall-through */
 151    case GL_DEPTH_COMPONENT:
 152       /* Now examine the depth mode */
 153       switch (depthMode) {
 154       case GL_LUMINANCE:
 155          return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_ONE);
 156       case GL_INTENSITY:
 157          return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X);
 158       case GL_ALPHA:
 159          return MAKE_SWIZZLE4(SWIZZLE_ZERO, SWIZZLE_ZERO,
 160                               SWIZZLE_ZERO, SWIZZLE_X);
 161       case GL_RED:
 162          return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_ZERO,
 163                               SWIZZLE_ZERO, SWIZZLE_ONE);
 164       default:
 165          assert(!"Unexpected depthMode");
 166          return SWIZZLE_XYZW;
 167       }
 168    default:
 169       assert(!"Unexpected baseFormat");
 170       return SWIZZLE_XYZW;
 171    }
 172 }
 173
 174
 175 static unsigned
 176 get_texture_format_swizzle(const struct st_texture_object *stObj)
 177 {
 178    const struct gl_texture_image *texImage =
 179       stObj->base.Image[0][stObj->base.BaseLevel];
 180    unsigned tex_swizzle;
 181
 182    if (texImage) {
 183       tex_swizzle = compute_texture_format_swizzle(texImage->_BaseFormat,
 184                                                    stObj->base.DepthMode,
 185                                                    stObj->pt->format);
 186    }
 187    else {
 188       tex_swizzle = SWIZZLE_XYZW;
 189    }
 190
 191    /* Combine the texture format swizzle with user's swizzle */
 192    return swizzle_swizzle(stObj->base._Swizzle, tex_swizzle);
 193 }
 194
 195
 196 /**
 197  * Return TRUE if the texture's sampler view swizzle is equal to
 198  * the texture's swizzle.
 199  *
 200  * \param stObj  the st texture object,
 201  */
 202 static boolean
 203 check_sampler_swizzle(const struct st_texture_object *stObj,
 204                       struct pipe_sampler_view *sv)
 205 {
 206    unsigned swizzle = get_texture_format_swizzle(stObj);
 207
 208    return ((sv->swizzle_r != GET_SWZ(swizzle, 0)) ||
 209            (sv->swizzle_g != GET_SWZ(swizzle, 1)) ||
 210            (sv->swizzle_b != GET_SWZ(swizzle, 2)) ||
 211            (sv->swizzle_a != GET_SWZ(swizzle, 3)));
 212 }
 213
 214
 215 static unsigned last_level(struct st_texture_object *stObj)
 216 {
 217    return MIN2(stObj->base._MaxLevel, stObj->pt->last_level);
 218 }
 219
 220
 221 static struct pipe_sampler_view *
 222 st_create_texture_sampler_view_from_stobj(struct pipe_context *pipe,
 223                                           struct st_texture_object *stObj,
 224                                           const struct gl_sampler_object *samp,
 225                                           enum pipe_format format)
 226 {
 227    struct pipe_sampler_view templ;
 228    unsigned swizzle = get_texture_format_swizzle(stObj);
 229
 230    u_sampler_view_default_template(&templ,
 231                                    stObj->pt,
 232                                    format);
 233
 234    if (stObj->pt->target == PIPE_BUFFER) {
 235       unsigned base, size;
 236       unsigned f, n;
 237       const struct util_format_description *desc
 238          = util_format_description(templ.format);
 239
 240       base = stObj->base.BufferOffset;
 241       if (base >= stObj->pt->width0)
 242          return NULL;
 243       size = MIN2(stObj->pt->width0 - base, (unsigned)stObj->base.BufferSize);
 244
 245       f = ((base * 8) / desc->block.bits) * desc->block.width;
 246       n = ((size * 8) / desc->block.bits) * desc->block.width;
 247       if (!n)
 248          return NULL;
 249       templ.u.buf.first_element = f;
 250       templ.u.buf.last_element  = f + (n - 1);
 251    } else {
 252       templ.u.tex.first_level = stObj->base.BaseLevel;
 253       templ.u.tex.last_level = last_level(stObj);
 254       assert(templ.u.tex.first_level <= templ.u.tex.last_level);
 255    }
 256
 257    if (swizzle != SWIZZLE_NOOP) {
 258       templ.swizzle_r = GET_SWZ(swizzle, 0);
 259       templ.swizzle_g = GET_SWZ(swizzle, 1);
 260       templ.swizzle_b = GET_SWZ(swizzle, 2);
 261       templ.swizzle_a = GET_SWZ(swizzle, 3);
 262    }
 263
 264    return pipe->create_sampler_view(pipe, stObj->pt, &templ);
 265 }
 266
 267
 268 static struct pipe_sampler_view *
 269 st_get_texture_sampler_view_from_stobj(struct st_context *st,
 270                                        struct st_texture_object *stObj,
 271                                        const struct gl_sampler_object *samp,
 272                                        enum pipe_format format)
 273 {
 274    struct pipe_sampler_view **sv;
 275
 276    if (!stObj || !stObj->pt) {
 277       return NULL;
 278    }
 279
 280    sv = st_texture_get_sampler_view(st, stObj);
 281
 282    if (stObj->base.StencilSampling &&
 283        util_format_is_depth_and_stencil(format))
 284       format = util_format_stencil_only(format);
 285
 286    /* if sampler view has changed dereference it */
 287    if (*sv) {
 288       if (check_sampler_swizzle(stObj, *sv) ||
 289           (format != (*sv)->format) ||
 290           stObj->base.BaseLevel != (*sv)->u.tex.first_level ||
 291           last_level(stObj) != (*sv)->u.tex.last_level) {
 292          pipe_sampler_view_reference(sv, NULL);
 293       }
 294    }
 295
 296    if (!*sv) {
 297       *sv = st_create_texture_sampler_view_from_stobj(st->pipe, stObj, samp, format);
 298
 299    } else if ((*sv)->context != st->pipe) {
 300       /* Recreate view in correct context, use existing view as template */
 301       struct pipe_sampler_view *new_sv =
 302          st->pipe->create_sampler_view(st->pipe, stObj->pt, *sv);
 303       pipe_sampler_view_reference(sv, NULL);
 304       *sv = new_sv;
 305    }
 306
 307    return *sv;
 308 }
 309
 310 static GLboolean
 311 update_single_texture(struct st_context *st,
 312                       struct pipe_sampler_view **sampler_view,
 313                       GLuint texUnit)
 314 {
 315    struct gl_context *ctx = st->ctx;
 316    const struct gl_sampler_object *samp;
 317    struct gl_texture_object *texObj;
 318    struct st_texture_object *stObj;
 319    enum pipe_format view_format;
 320    GLboolean retval;
 321
 322    samp = _mesa_get_samplerobj(ctx, texUnit);
 323
 324    texObj = ctx->Texture.Unit[texUnit]._Current;
 325
 326    if (!texObj) {
 327       texObj = _mesa_get_fallback_texture(ctx, TEXTURE_2D_INDEX);
 328       samp = &texObj->Sampler;
 329    }
 330    stObj = st_texture_object(texObj);
 331
 332    retval = st_finalize_texture(ctx, st->pipe, texObj);
 333    if (!retval) {
 334       /* out of mem */
 335       return GL_FALSE;
 336    }
 337
 338    /* Determine the format of the texture sampler view */
 339    if (texObj->Target == GL_TEXTURE_BUFFER) {
 340       view_format =
 341          st_mesa_format_to_pipe_format(st, stObj->base._BufferObjectFormat);
 342    }
 343    else {
 344       view_format =
 345          stObj->surface_based ? stObj->surface_format : stObj->pt->format;
 346
 347       /* If sRGB decoding is off, use the linear format */
 348       if (samp->sRGBDecode == GL_SKIP_DECODE_EXT) {
 349          view_format = util_format_linear(view_format);
 350       }
 351    }
 352
 353    *sampler_view = st_get_texture_sampler_view_from_stobj(st, stObj, samp,
 354                                                           view_format);
 355    return GL_TRUE;
 356 }
 357
 358
 359
 360 static void
 361 update_textures(struct st_context *st,
 362                 unsigned shader_stage,
 363                 const struct gl_program *prog,
 364                 unsigned max_units,
 365                 struct pipe_sampler_view **sampler_views,
 366                 unsigned *num_textures)
 367 {
 368    const GLuint old_max = *num_textures;
 369    GLbitfield samplers_used = prog->SamplersUsed;
 370    GLuint unit;
 371
 372    if (samplers_used == 0x0 && old_max == 0)
 373       return;
 374
 375    *num_textures = 0;
 376
 377    /* loop over sampler units (aka tex image units) */
 378    for (unit = 0; unit < max_units; unit++, samplers_used >>= 1) {
 379       struct pipe_sampler_view *sampler_view = NULL;
 380
 381       if (samplers_used & 1) {
 382          const GLuint texUnit = prog->SamplerUnits[unit];
 383          GLboolean retval;
 384
 385          retval = update_single_texture(st, &sampler_view, texUnit);
 386          if (retval == GL_FALSE)
 387             continue;
 388
 389          *num_textures = unit + 1;
 390       }
 391       else if (samplers_used == 0 && unit >= old_max) {
 392          /* if we've reset all the old views and we have no more new ones */
 393          break;
 394       }
 395
 396       pipe_sampler_view_reference(&(sampler_views[unit]), sampler_view);
 397    }
 398
 399    cso_set_sampler_views(st->cso_context,
 400                          shader_stage,
 401                          *num_textures,
 402                          sampler_views);
 403 }
 404
 405
 406
 407 static void
 408 update_vertex_textures(struct st_context *st)
 409 {
 410    const struct gl_context *ctx = st->ctx;
 411
 412    if (ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits > 0) {
 413       update_textures(st,
 414                       PIPE_SHADER_VERTEX,
 415                       &ctx->VertexProgram._Current->Base,
 416                       ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits,
 417                       st->state.sampler_views[PIPE_SHADER_VERTEX],
 418                       &st->state.num_sampler_views[PIPE_SHADER_VERTEX]);
 419    }
 420 }
 421
 422
 423 static void
 424 update_fragment_textures(struct st_context *st)
 425 {
 426    const struct gl_context *ctx = st->ctx;
 427
 428    update_textures(st,
 429                    PIPE_SHADER_FRAGMENT,
 430                    &ctx->FragmentProgram._Current->Base,
 431                    ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,
 432                    st->state.sampler_views[PIPE_SHADER_FRAGMENT],
 433                    &st->state.num_sampler_views[PIPE_SHADER_FRAGMENT]);
 434 }
 435
 436
 437 static void
 438 update_geometry_textures(struct st_context *st)
 439 {
 440    const struct gl_context *ctx = st->ctx;
 441
 442    if (ctx->GeometryProgram._Current) {
 443       update_textures(st,
 444                       PIPE_SHADER_GEOMETRY,
 445                       &ctx->GeometryProgram._Current->Base,
 446                       ctx->Const.Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits,
 447                       st->state.sampler_views[PIPE_SHADER_GEOMETRY],
 448                       &st->state.num_sampler_views[PIPE_SHADER_GEOMETRY]);
 449    }
 450 }
 451
 452
 453 const struct st_tracked_state st_update_fragment_texture = {
 454    "st_update_texture",                                 /* name */
 455    {                                                    /* dirty */
 456       _NEW_TEXTURE,                                     /* mesa */
 457       ST_NEW_FRAGMENT_PROGRAM,                          /* st */
 458    },
 459    update_fragment_textures                             /* update */
 460 };
 461
 462
 463 const struct st_tracked_state st_update_vertex_texture = {
 464    "st_update_vertex_texture",                          /* name */
 465    {                                                    /* dirty */
 466       _NEW_TEXTURE,                                     /* mesa */
 467       ST_NEW_VERTEX_PROGRAM,                            /* st */
 468    },
 469    update_vertex_textures                               /* update */
 470 };
 471
 472
 473 const struct st_tracked_state st_update_geometry_texture = {
 474    "st_update_geometry_texture",                        /* name */
 475    {                                                    /* dirty */
 476       _NEW_TEXTURE,                                     /* mesa */
 477       ST_NEW_GEOMETRY_PROGRAM,                          /* st */
 478    },
 479    update_geometry_textures                             /* update */
 480 };
 481
 482
 483
 484 static void
 485 finalize_textures(struct st_context *st)
 486 {
 487    struct gl_context *ctx = st->ctx;
 488    struct gl_fragment_program *fprog = ctx->FragmentProgram._Current;
 489    const GLboolean prev_missing_textures = st->missing_textures;
 490    GLuint su;
 491
 492    st->missing_textures = GL_FALSE;
 493
 494    for (su = 0; su < ctx->Const.MaxTextureCoordUnits; su++) {
 495       if (fprog->Base.SamplersUsed & (1 << su)) {
 496          const GLuint texUnit = fprog->Base.SamplerUnits[su];
 497          struct gl_texture_object *texObj
 498             = ctx->Texture.Unit[texUnit]._Current;
 499
 500          if (texObj) {
 501             GLboolean retval;
 502
 503             retval = st_finalize_texture(ctx, st->pipe, texObj);
 504             if (!retval) {
 505                /* out of mem */
 506                st->missing_textures = GL_TRUE;
 507                continue;
 508             }
 509          }
 510       }
 511    }
 512
 513    if (prev_missing_textures != st->missing_textures)
 514       st->dirty.st |= ST_NEW_FRAGMENT_PROGRAM;
 515 }
 516
 517
 518 const struct st_tracked_state st_finalize_textures = {
 519    "st_finalize_textures",              /* name */
 520    {                                    /* dirty */
 521       _NEW_TEXTURE,                     /* mesa */
 522       0,                                /* st */
 523    },
 524    finalize_textures                    /* update */
 525 };