src/gallium/auxiliary/util/u_pstipple.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 VMware, Inc.
   4  * Copyright 2010 VMware, Inc.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 /**
  30  * Polygon stipple helper module.  Drivers/GPUs which don't support polygon
  31  * stipple natively can use this module to simulate it.
  32  *
  33  * Basically, modify fragment shader to sample the 32x32 stipple pattern
  34  * texture and do a fragment kill for the 'off' bits.
  35  *
  36  * This was originally a 'draw' module stage, but since we don't need
  37  * vertex window coords or anything, it can be a stand-alone utility module.
  38  *
  39  * Authors:  Brian Paul
  40  */
  41
  42
  43 #include "pipe/p_context.h"
  44 #include "pipe/p_defines.h"
  45 #include "pipe/p_shader_tokens.h"
  46 #include "util/u_inlines.h"
  47
  48 #include "util/u_format.h"
  49 #include "util/u_memory.h"
  50 #include "util/u_pstipple.h"
  51 #include "util/u_sampler.h"
  52
  53 #include "tgsi/tgsi_transform.h"
  54 #include "tgsi/tgsi_dump.h"
  55 #include "tgsi/tgsi_scan.h"
  56
  57 /** Approx number of new tokens for instructions in pstip_transform_inst() */
  58 #define NUM_NEW_TOKENS 53
  59
  60
  61 static void
  62 util_pstipple_update_stipple_texture(struct pipe_context *pipe,
  63                                      struct pipe_resource *tex,
  64                                      const uint32_t pattern[32])
  65 {
  66    static const uint bit31 = 1 << 31;
  67    struct pipe_transfer *transfer;
  68    ubyte *data;
  69    int i, j;
  70
  71    /* map texture memory */
  72    data = pipe_transfer_map(pipe, tex, 0, 0,
  73                             PIPE_TRANSFER_WRITE, 0, 0, 32, 32, &transfer);
  74
  75    /*
  76     * Load alpha texture.
  77     * Note: 0 means keep the fragment, 255 means kill it.
  78     * We'll negate the texel value and use KILL_IF which kills if value
  79     * is negative.
  80     */
  81    for (i = 0; i < 32; i++) {
  82       for (j = 0; j < 32; j++) {
  83          if (pattern[i] & (bit31 >> j)) {
  84             /* fragment "on" */
  85             data[i * transfer->stride + j] = 0;
  86          }
  87          else {
  88             /* fragment "off" */
  89             data[i * transfer->stride + j] = 255;
  90          }
  91       }
  92    }
  93
  94    /* unmap */
  95    pipe->transfer_unmap(pipe, transfer);
  96 }
  97
  98
  99 /**
 100  * Create a 32x32 alpha8 texture that encodes the given stipple pattern.
 101  */
 102 struct pipe_resource *
 103 util_pstipple_create_stipple_texture(struct pipe_context *pipe,
 104                                      const uint32_t pattern[32])
 105 {
 106    struct pipe_screen *screen = pipe->screen;
 107    struct pipe_resource templat, *tex;
 108
 109    memset(&templat, 0, sizeof(templat));
 110    templat.target = PIPE_TEXTURE_2D;
 111    templat.format = PIPE_FORMAT_A8_UNORM;
 112    templat.last_level = 0;
 113    templat.width0 = 32;
 114    templat.height0 = 32;
 115    templat.depth0 = 1;
 116    templat.array_size = 1;
 117    templat.bind = PIPE_BIND_SAMPLER_VIEW;
 118
 119    tex = screen->resource_create(screen, &templat);
 120
 121    if (tex)
 122       util_pstipple_update_stipple_texture(pipe, tex, pattern);
 123
 124    return tex;
 125 }
 126
 127
 128 /**
 129  * Create sampler view to sample the stipple texture.
 130  */
 131 struct pipe_sampler_view *
 132 util_pstipple_create_sampler_view(struct pipe_context *pipe,
 133                                   struct pipe_resource *tex)
 134 {
 135    struct pipe_sampler_view templat, *sv;
 136
 137    u_sampler_view_default_template(&templat, tex, tex->format);
 138    sv = pipe->create_sampler_view(pipe, tex, &templat);
 139
 140    return sv;
 141 }
 142
 143
 144 /**
 145  * Create the sampler CSO that'll be used for stippling.
 146  */
 147 void *
 148 util_pstipple_create_sampler(struct pipe_context *pipe)
 149 {
 150    struct pipe_sampler_state templat;
 151    void *s;
 152
 153    memset(&templat, 0, sizeof(templat));
 154    templat.wrap_s = PIPE_TEX_WRAP_REPEAT;
 155    templat.wrap_t = PIPE_TEX_WRAP_REPEAT;
 156    templat.wrap_r = PIPE_TEX_WRAP_REPEAT;
 157    templat.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 158    templat.min_img_filter = PIPE_TEX_FILTER_NEAREST;
 159    templat.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
 160    templat.normalized_coords = 1;
 161    templat.min_lod = 0.0f;
 162    templat.max_lod = 0.0f;
 163
 164    s = pipe->create_sampler_state(pipe, &templat);
 165    return s;
 166 }
 167
 168
 169
 170 /**
 171  * Subclass of tgsi_transform_context, used for transforming the
 172  * user's fragment shader to add the extra texture sample and fragment kill
 173  * instructions.
 174  */
 175 struct pstip_transform_context {
 176    struct tgsi_transform_context base;
 177    struct tgsi_shader_info info;
 178    uint tempsUsed;  /**< bitmask */
 179    int wincoordInput;
 180    unsigned wincoordFile;
 181    int maxInput;
 182    uint samplersUsed;  /**< bitfield of samplers used */
 183    int freeSampler;  /** an available sampler for the pstipple */
 184    int numImmed;
 185    uint coordOrigin;
 186    unsigned fixedUnit;
 187    bool hasFixedUnit;
 188 };
 189
 190
 191 /**
 192  * TGSI declaration transform callback.
 193  * Track samplers used, temps used, inputs used.
 194  */
 195 static void
 196 pstip_transform_decl(struct tgsi_transform_context *ctx,
 197                      struct tgsi_full_declaration *decl)
 198 {
 199    struct pstip_transform_context *pctx =
 200       (struct pstip_transform_context *) ctx;
 201
 202    /* XXX we can use tgsi_shader_info instead of some of this */
 203
 204    if (decl->Declaration.File == TGSI_FILE_SAMPLER) {
 205       uint i;
 206       for (i = decl->Range.First; i <= decl->Range.Last; i++) {
 207          pctx->samplersUsed |= 1 << i;
 208       }
 209    }
 210    else if (decl->Declaration.File == pctx->wincoordFile) {
 211       pctx->maxInput = MAX2(pctx->maxInput, (int) decl->Range.Last);
 212       if (decl->Semantic.Name == TGSI_SEMANTIC_POSITION)
 213          pctx->wincoordInput = (int) decl->Range.First;
 214    }
 215    else if (decl->Declaration.File == TGSI_FILE_TEMPORARY) {
 216       uint i;
 217       for (i = decl->Range.First; i <= decl->Range.Last; i++) {
 218          pctx->tempsUsed |= (1 << i);
 219       }
 220    }
 221
 222    ctx->emit_declaration(ctx, decl);
 223 }
 224
 225
 226 static void
 227 pstip_transform_immed(struct tgsi_transform_context *ctx,
 228                       struct tgsi_full_immediate *immed)
 229 {
 230    struct pstip_transform_context *pctx =
 231       (struct pstip_transform_context *) ctx;
 232    pctx->numImmed++;
 233 }
 234
 235
 236 /**
 237  * Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
 238  */
 239 static int
 240 free_bit(uint bitfield)
 241 {
 242    return ffs(~bitfield) - 1;
 243 }
 244
 245
 246 /**
 247  * TGSI transform prolog
 248  * Before the first instruction, insert our new code to sample the
 249  * stipple texture (using the fragment coord register) then kill the
 250  * fragment if the stipple texture bit is off.
 251  *
 252  * Insert:
 253  *   declare new registers
 254  *   MUL texTemp, INPUT[wincoord], 1/32;
 255  *   TEX texTemp, texTemp, sampler;
 256  *   KILL_IF -texTemp;   # if -texTemp < 0, kill fragment
 257  *   [...original code...]
 258  */
 259 static void
 260 pstip_transform_prolog(struct tgsi_transform_context *ctx)
 261 {
 262    struct pstip_transform_context *pctx =
 263       (struct pstip_transform_context *) ctx;
 264    int wincoordInput;
 265    int texTemp;
 266    int sampIdx;
 267
 268    /* find free texture sampler */
 269    pctx->freeSampler = free_bit(pctx->samplersUsed);
 270    if (pctx->freeSampler >= PIPE_MAX_SAMPLERS)
 271       pctx->freeSampler = PIPE_MAX_SAMPLERS - 1;
 272
 273    if (pctx->wincoordInput < 0)
 274       wincoordInput = pctx->maxInput + 1;
 275    else
 276       wincoordInput = pctx->wincoordInput;
 277
 278    if (pctx->wincoordInput < 0) {
 279       struct tgsi_full_declaration decl;
 280
 281       decl = tgsi_default_full_declaration();
 282       /* declare new position input reg */
 283       decl.Declaration.File = pctx->wincoordFile;
 284       decl.Declaration.Semantic = 1;
 285       decl.Semantic.Name = TGSI_SEMANTIC_POSITION;
 286       decl.Range.First =
 287       decl.Range.Last = wincoordInput;
 288
 289       if (pctx->wincoordFile == TGSI_FILE_INPUT) {
 290          decl.Declaration.Interpolate = 1;
 291          decl.Interp.Interpolate = TGSI_INTERPOLATE_LINEAR;
 292       }
 293
 294       ctx->emit_declaration(ctx, &decl);
 295    }
 296
 297    sampIdx = pctx->hasFixedUnit ? pctx->fixedUnit : pctx->freeSampler;
 298
 299    /* declare new sampler */
 300    tgsi_transform_sampler_decl(ctx, sampIdx);
 301
 302    /* if the src shader has SVIEW decl's for each SAMP decl, we
 303     * need to continue the trend and ensure there is a matching
 304     * SVIEW for the new SAMP we just created
 305     */
 306    if (pctx->info.file_max[TGSI_FILE_SAMPLER_VIEW] != -1) {
 307       tgsi_transform_sampler_view_decl(ctx,
 308                                        sampIdx,
 309                                        TGSI_TEXTURE_2D,
 310                                        TGSI_RETURN_TYPE_FLOAT);
 311    }
 312
 313    /* Declare temp[0] reg if not already declared.
 314     * We can always use temp[0] since this code is before
 315     * the rest of the shader.
 316     */
 317    texTemp = 0;
 318    if ((pctx->tempsUsed & (1 << texTemp)) == 0) {
 319       tgsi_transform_temp_decl(ctx, texTemp);
 320    }
 321
 322    /* emit immediate = {1/32, 1/32, 1, 1}
 323     * The index/position of this immediate will be pctx->numImmed
 324     */
 325    tgsi_transform_immediate_decl(ctx, 1.0/32.0, 1.0/32.0, 1.0, 1.0);
 326
 327    /*
 328     * Insert new MUL/TEX/KILL_IF instructions at start of program
 329     * Take gl_FragCoord, divide by 32 (stipple size), sample the
 330     * texture and kill fragment if needed.
 331     *
 332     * We'd like to use non-normalized texcoords to index into a RECT
 333     * texture, but we can only use REPEAT wrap mode with normalized
 334     * texcoords.  Darn.
 335     */
 336
 337    /* XXX invert wincoord if origin isn't lower-left... */
 338
 339    /* MUL texTemp, INPUT[wincoord], 1/32; */
 340    tgsi_transform_op2_inst(ctx, TGSI_OPCODE_MUL,
 341                            TGSI_FILE_TEMPORARY, texTemp,
 342                            TGSI_WRITEMASK_XYZW,
 343                            pctx->wincoordFile, wincoordInput,
 344                            TGSI_FILE_IMMEDIATE, pctx->numImmed);
 345
 346    /* TEX texTemp, texTemp, sampler; */
 347    tgsi_transform_tex_2d_inst(ctx,
 348                               TGSI_FILE_TEMPORARY, texTemp,
 349                               TGSI_FILE_TEMPORARY, texTemp,
 350                               sampIdx);
 351
 352    /* KILL_IF -texTemp;   # if -texTemp < 0, kill fragment */
 353    tgsi_transform_kill_inst(ctx,
 354                             TGSI_FILE_TEMPORARY, texTemp,
 355                             TGSI_SWIZZLE_W, TRUE);
 356 }
 357
 358
 359 /**
 360  * Given a fragment shader, return a new fragment shader which
 361  * samples a stipple texture and executes KILL.
 362  *
 363  * \param samplerUnitOut  returns the index of the sampler unit which
 364  *                        will be used to sample the stipple texture;
 365  *                        if NULL, the fixed unit is used
 366  * \param fixedUnit       fixed texture unit used for the stipple texture
 367  * \param wincoordFile    TGSI_FILE_INPUT or TGSI_FILE_SYSTEM_VALUE,
 368  *                        depending on which one is supported by the driver
 369  *                        for TGSI_SEMANTIC_POSITION in the fragment shader
 370  */
 371 struct tgsi_token *
 372 util_pstipple_create_fragment_shader(const struct tgsi_token *tokens,
 373                                      unsigned *samplerUnitOut,
 374                                      unsigned fixedUnit,
 375                                      unsigned wincoordFile)
 376 {
 377    struct pstip_transform_context transform;
 378    const uint newLen = tgsi_num_tokens(tokens) + NUM_NEW_TOKENS;
 379    struct tgsi_token *new_tokens;
 380
 381    new_tokens = tgsi_alloc_tokens(newLen);
 382    if (!new_tokens) {
 383       return NULL;
 384    }
 385
 386    /* Setup shader transformation info/context.
 387     */
 388    memset(&transform, 0, sizeof(transform));
 389    transform.wincoordInput = -1;
 390    transform.wincoordFile = wincoordFile;
 391    transform.maxInput = -1;
 392    transform.coordOrigin = TGSI_FS_COORD_ORIGIN_UPPER_LEFT;
 393    transform.hasFixedUnit = !samplerUnitOut;
 394    transform.fixedUnit = fixedUnit;
 395    transform.base.prolog = pstip_transform_prolog;
 396    transform.base.transform_declaration = pstip_transform_decl;
 397    transform.base.transform_immediate = pstip_transform_immed;
 398
 399    tgsi_scan_shader(tokens, &transform.info);
 400
 401    transform.coordOrigin =
 402       transform.info.properties[TGSI_PROPERTY_FS_COORD_ORIGIN];
 403
 404    tgsi_transform_shader(tokens, new_tokens, newLen, &transform.base);
 405
 406 #if 0 /* DEBUG */
 407    tgsi_dump(fs->tokens, 0);
 408    tgsi_dump(new_fs->tokens, 0);
 409 #endif
 410
 411    if (samplerUnitOut) {
 412       assert(transform.freeSampler < PIPE_MAX_SAMPLERS);
 413       *samplerUnitOut = transform.freeSampler;
 414    }
 415
 416    return new_tokens;
 417 }