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/format/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 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 = 1u << 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 && pattern)
 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 |= 1u << 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    ctx->emit_immediate(ctx, immed);
 234 }
 235
 236
 237 /**
 238  * Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
 239  */
 240 static int
 241 free_bit(uint bitfield)
 242 {
 243    return ffs(~bitfield) - 1;
 244 }
 245
 246
 247 /**
 248  * TGSI transform prolog
 249  * Before the first instruction, insert our new code to sample the
 250  * stipple texture (using the fragment coord register) then kill the
 251  * fragment if the stipple texture bit is off.
 252  *
 253  * Insert:
 254  *   declare new registers
 255  *   MUL texTemp, INPUT[wincoord], 1/32;
 256  *   TEX texTemp, texTemp, sampler;
 257  *   KILL_IF -texTemp;   # if -texTemp < 0, kill fragment
 258  *   [...original code...]
 259  */
 260 static void
 261 pstip_transform_prolog(struct tgsi_transform_context *ctx)
 262 {
 263    struct pstip_transform_context *pctx =
 264       (struct pstip_transform_context *) ctx;
 265    int wincoordInput;
 266    int texTemp;
 267    int sampIdx;
 268
 269    STATIC_ASSERT(sizeof(pctx->samplersUsed) * 8 >= PIPE_MAX_SAMPLERS);
 270
 271    /* find free texture sampler */
 272    pctx->freeSampler = free_bit(pctx->samplersUsed);
 273    if (pctx->freeSampler < 0 || pctx->freeSampler >= PIPE_MAX_SAMPLERS)
 274       pctx->freeSampler = PIPE_MAX_SAMPLERS - 1;
 275
 276    if (pctx->wincoordInput < 0)
 277       wincoordInput = pctx->maxInput + 1;
 278    else
 279       wincoordInput = pctx->wincoordInput;
 280
 281    if (pctx->wincoordInput < 0) {
 282       struct tgsi_full_declaration decl;
 283
 284       decl = tgsi_default_full_declaration();
 285       /* declare new position input reg */
 286       decl.Declaration.File = pctx->wincoordFile;
 287       decl.Declaration.Semantic = 1;
 288       decl.Semantic.Name = TGSI_SEMANTIC_POSITION;
 289       decl.Range.First =
 290       decl.Range.Last = wincoordInput;
 291
 292       if (pctx->wincoordFile == TGSI_FILE_INPUT) {
 293          decl.Declaration.Interpolate = 1;
 294          decl.Interp.Interpolate = TGSI_INTERPOLATE_LINEAR;
 295       }
 296
 297       ctx->emit_declaration(ctx, &decl);
 298    }
 299
 300    sampIdx = pctx->hasFixedUnit ? (int)pctx->fixedUnit : pctx->freeSampler;
 301
 302    /* declare new sampler */
 303    tgsi_transform_sampler_decl(ctx, sampIdx);
 304
 305    /* if the src shader has SVIEW decl's for each SAMP decl, we
 306     * need to continue the trend and ensure there is a matching
 307     * SVIEW for the new SAMP we just created
 308     */
 309    if (pctx->info.file_max[TGSI_FILE_SAMPLER_VIEW] != -1) {
 310       tgsi_transform_sampler_view_decl(ctx,
 311                                        sampIdx,
 312                                        TGSI_TEXTURE_2D,
 313                                        TGSI_RETURN_TYPE_FLOAT);
 314    }
 315
 316    /* Declare temp[0] reg if not already declared.
 317     * We can always use temp[0] since this code is before
 318     * the rest of the shader.
 319     */
 320    texTemp = 0;
 321    if ((pctx->tempsUsed & (1 << texTemp)) == 0) {
 322       tgsi_transform_temp_decl(ctx, texTemp);
 323    }
 324
 325    /* emit immediate = {1/32, 1/32, 1, 1}
 326     * The index/position of this immediate will be pctx->numImmed
 327     */
 328    tgsi_transform_immediate_decl(ctx, 1.0/32.0, 1.0/32.0, 1.0, 1.0);
 329
 330    /*
 331     * Insert new MUL/TEX/KILL_IF instructions at start of program
 332     * Take gl_FragCoord, divide by 32 (stipple size), sample the
 333     * texture and kill fragment if needed.
 334     *
 335     * We'd like to use non-normalized texcoords to index into a RECT
 336     * texture, but we can only use REPEAT wrap mode with normalized
 337     * texcoords.  Darn.
 338     */
 339
 340    /* XXX invert wincoord if origin isn't lower-left... */
 341
 342    /* MUL texTemp, INPUT[wincoord], 1/32; */
 343    tgsi_transform_op2_inst(ctx, TGSI_OPCODE_MUL,
 344                            TGSI_FILE_TEMPORARY, texTemp,
 345                            TGSI_WRITEMASK_XYZW,
 346                            pctx->wincoordFile, wincoordInput,
 347                            TGSI_FILE_IMMEDIATE, pctx->numImmed, false);
 348
 349    /* TEX texTemp, texTemp, sampler, 2D; */
 350    tgsi_transform_tex_inst(ctx,
 351                            TGSI_FILE_TEMPORARY, texTemp,
 352                            TGSI_FILE_TEMPORARY, texTemp,
 353                            TGSI_TEXTURE_2D, sampIdx);
 354
 355    /* KILL_IF -texTemp;   # if -texTemp < 0, kill fragment */
 356    tgsi_transform_kill_inst(ctx,
 357                             TGSI_FILE_TEMPORARY, texTemp,
 358                             TGSI_SWIZZLE_W, TRUE);
 359 }
 360
 361
 362 /**
 363  * Given a fragment shader, return a new fragment shader which
 364  * samples a stipple texture and executes KILL.
 365  *
 366  * \param samplerUnitOut  returns the index of the sampler unit which
 367  *                        will be used to sample the stipple texture;
 368  *                        if NULL, the fixed unit is used
 369  * \param fixedUnit       fixed texture unit used for the stipple texture
 370  * \param wincoordFile    TGSI_FILE_INPUT or TGSI_FILE_SYSTEM_VALUE,
 371  *                        depending on which one is supported by the driver
 372  *                        for TGSI_SEMANTIC_POSITION in the fragment shader
 373  */
 374 struct tgsi_token *
 375 util_pstipple_create_fragment_shader(const struct tgsi_token *tokens,
 376                                      unsigned *samplerUnitOut,
 377                                      unsigned fixedUnit,
 378                                      unsigned wincoordFile)
 379 {
 380    struct pstip_transform_context transform;
 381    const uint newLen = tgsi_num_tokens(tokens) + NUM_NEW_TOKENS;
 382    struct tgsi_token *new_tokens;
 383
 384    new_tokens = tgsi_alloc_tokens(newLen);
 385    if (!new_tokens) {
 386       return NULL;
 387    }
 388
 389    /* Setup shader transformation info/context.
 390     */
 391    memset(&transform, 0, sizeof(transform));
 392    transform.wincoordInput = -1;
 393    transform.wincoordFile = wincoordFile;
 394    transform.maxInput = -1;
 395    transform.coordOrigin = TGSI_FS_COORD_ORIGIN_UPPER_LEFT;
 396    transform.hasFixedUnit = !samplerUnitOut;
 397    transform.fixedUnit = fixedUnit;
 398    transform.base.prolog = pstip_transform_prolog;
 399    transform.base.transform_declaration = pstip_transform_decl;
 400    transform.base.transform_immediate = pstip_transform_immed;
 401
 402    tgsi_scan_shader(tokens, &transform.info);
 403
 404    transform.coordOrigin =
 405       transform.info.properties[TGSI_PROPERTY_FS_COORD_ORIGIN];
 406
 407    tgsi_transform_shader(tokens, new_tokens, newLen, &transform.base);
 408
 409 #if 0 /* DEBUG */
 410    tgsi_dump(fs->tokens, 0);
 411    tgsi_dump(new_fs->tokens, 0);
 412 #endif
 413
 414    if (samplerUnitOut) {
 415       assert(transform.freeSampler < PIPE_MAX_SAMPLERS);
 416       *samplerUnitOut = transform.freeSampler;
 417    }
 418
 419    return new_tokens;
 420 }