src/gallium/auxiliary/draw/draw_pipe_pstipple.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 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  * Polygon stipple stage:  implement polygon stipple with texture map and
  30  * fragment program.  The fragment program samples the texture using the
  31  * fragment window coordinate register and does a fragment kill for the
  32  * stipple-failing fragments.
  33  *
  34  * Authors:  Brian Paul
  35  */
  36
  37
  38 #include "pipe/p_context.h"
  39 #include "pipe/p_defines.h"
  40 #include "pipe/p_shader_tokens.h"
  41 #include "util/u_inlines.h"
  42
  43 #include "util/u_format.h"
  44 #include "util/u_math.h"
  45 #include "util/u_memory.h"
  46 #include "util/u_sampler.h"
  47
  48 #include "tgsi/tgsi_transform.h"
  49 #include "tgsi/tgsi_dump.h"
  50
  51 #include "draw_context.h"
  52 #include "draw_pipe.h"
  53
  54
  55 /** Approx number of new tokens for instructions in pstip_transform_inst() */
  56 #define NUM_NEW_TOKENS 53
  57
  58
  59 /**
  60  * Subclass of pipe_shader_state to carry extra fragment shader info.
  61  */
  62 struct pstip_fragment_shader
  63 {
  64    struct pipe_shader_state state;
  65    void *driver_fs;
  66    void *pstip_fs;
  67    uint sampler_unit;
  68 };
  69
  70
  71 /**
  72  * Subclass of draw_stage
  73  */
  74 struct pstip_stage
  75 {
  76    struct draw_stage stage;
  77
  78    void *sampler_cso;
  79    struct pipe_resource *texture;
  80    struct pipe_sampler_view *sampler_view;
  81    uint num_samplers;
  82    uint num_sampler_views;
  83
  84    /*
  85     * Currently bound state
  86     */
  87    struct pstip_fragment_shader *fs;
  88    struct {
  89       void *samplers[PIPE_MAX_SAMPLERS];
  90       struct pipe_sampler_view *sampler_views[PIPE_MAX_SHADER_SAMPLER_VIEWS];
  91       const struct pipe_poly_stipple *stipple;
  92    } state;
  93
  94    /*
  95     * Driver interface/override functions
  96     */
  97    void * (*driver_create_fs_state)(struct pipe_context *,
  98                                     const struct pipe_shader_state *);
  99    void (*driver_bind_fs_state)(struct pipe_context *, void *);
 100    void (*driver_delete_fs_state)(struct pipe_context *, void *);
 101
 102    void (*driver_bind_sampler_states)(struct pipe_context *, unsigned,
 103                                       unsigned, unsigned, void **);
 104
 105    void (*driver_set_sampler_views)(struct pipe_context *,
 106                                     unsigned shader, unsigned start,
 107                                     unsigned count,
 108                                     struct pipe_sampler_view **);
 109
 110    void (*driver_set_polygon_stipple)(struct pipe_context *,
 111                                       const struct pipe_poly_stipple *);
 112
 113    struct pipe_context *pipe;
 114 };
 115
 116
 117
 118 /**
 119  * Subclass of tgsi_transform_context, used for transforming the
 120  * user's fragment shader to add the extra texture sample and fragment kill
 121  * instructions.
 122  */
 123 struct pstip_transform_context {
 124    struct tgsi_transform_context base;
 125    uint tempsUsed;  /**< bitmask */
 126    int wincoordInput;
 127    int maxInput;
 128    uint samplersUsed;  /**< bitfield of samplers used */
 129    bool hasSview;
 130    int freeSampler;  /** an available sampler for the pstipple */
 131    int texTemp;  /**< temp registers */
 132    int numImmed;
 133 };
 134
 135
 136 /**
 137  * TGSI declaration transform callback.
 138  * Look for a free sampler, a free input attrib, and two free temp regs.
 139  */
 140 static void
 141 pstip_transform_decl(struct tgsi_transform_context *ctx,
 142                      struct tgsi_full_declaration *decl)
 143 {
 144    struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
 145
 146    if (decl->Declaration.File == TGSI_FILE_SAMPLER) {
 147       uint i;
 148       for (i = decl->Range.First;
 149            i <= decl->Range.Last; i++) {
 150          pctx->samplersUsed |= 1 << i;
 151       }
 152    }
 153    else if (decl->Declaration.File == TGSI_FILE_SAMPLER_VIEW) {
 154       pctx->hasSview = true;
 155    }
 156    else if (decl->Declaration.File == TGSI_FILE_INPUT) {
 157       pctx->maxInput = MAX2(pctx->maxInput, (int) decl->Range.Last);
 158       if (decl->Semantic.Name == TGSI_SEMANTIC_POSITION)
 159          pctx->wincoordInput = (int) decl->Range.First;
 160    }
 161    else if (decl->Declaration.File == TGSI_FILE_TEMPORARY) {
 162       uint i;
 163       for (i = decl->Range.First;
 164            i <= decl->Range.Last; i++) {
 165          pctx->tempsUsed |= (1 << i);
 166       }
 167    }
 168
 169    ctx->emit_declaration(ctx, decl);
 170 }
 171
 172
 173 /**
 174  * TGSI immediate declaration transform callback.
 175  * We're just counting the number of immediates here.
 176  */
 177 static void
 178 pstip_transform_immed(struct tgsi_transform_context *ctx,
 179                       struct tgsi_full_immediate *immed)
 180 {
 181    struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
 182    ctx->emit_immediate(ctx, immed); /* emit to output shader */
 183    pctx->numImmed++;
 184 }
 185
 186
 187 /**
 188  * Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
 189  */
 190 static int
 191 free_bit(uint bitfield)
 192 {
 193    return ffs(~bitfield) - 1;
 194 }
 195
 196
 197 /**
 198  * TGSI transform prolog callback.
 199  */
 200 static void
 201 pstip_transform_prolog(struct tgsi_transform_context *ctx)
 202 {
 203    struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
 204    uint i;
 205    int wincoordInput;
 206
 207    /* find free sampler */
 208    pctx->freeSampler = free_bit(pctx->samplersUsed);
 209    if (pctx->freeSampler >= PIPE_MAX_SAMPLERS)
 210       pctx->freeSampler = PIPE_MAX_SAMPLERS - 1;
 211
 212    if (pctx->wincoordInput < 0)
 213       wincoordInput = pctx->maxInput + 1;
 214    else
 215       wincoordInput = pctx->wincoordInput;
 216
 217    /* find one free temp reg */
 218    for (i = 0; i < 32; i++) {
 219       if ((pctx->tempsUsed & (1 << i)) == 0) {
 220       /* found a free temp */
 221       if (pctx->texTemp < 0)
 222          pctx->texTemp  = i;
 223       else
 224          break;
 225       }
 226    }
 227    assert(pctx->texTemp >= 0);
 228
 229    if (pctx->wincoordInput < 0) {
 230       /* declare new position input reg */
 231       tgsi_transform_input_decl(ctx, wincoordInput,
 232                                 TGSI_SEMANTIC_POSITION, 1,
 233                                 TGSI_INTERPOLATE_LINEAR);
 234    }
 235
 236    /* declare new sampler */
 237    tgsi_transform_sampler_decl(ctx, pctx->freeSampler);
 238
 239    /* if the src shader has SVIEW decl's for each SAMP decl, we
 240     * need to continue the trend and ensure there is a matching
 241     * SVIEW for the new SAMP we just created
 242     */
 243    if (pctx->hasSview) {
 244       tgsi_transform_sampler_view_decl(ctx,
 245                                        pctx->freeSampler,
 246                                        TGSI_TEXTURE_2D,
 247                                        TGSI_RETURN_TYPE_FLOAT);
 248    }
 249
 250    /* declare new temp regs */
 251    tgsi_transform_temp_decl(ctx, pctx->texTemp);
 252
 253    /* emit immediate = {1/32, 1/32, 1, 1}
 254     * The index/position of this immediate will be pctx->numImmed
 255     */
 256    tgsi_transform_immediate_decl(ctx, 1.0/32.0, 1.0/32.0, 1.0, 1.0);
 257
 258    /*
 259     * Insert new MUL/TEX/KILL_IF instructions at start of program
 260     * Take gl_FragCoord, divide by 32 (stipple size), sample the
 261     * texture and kill fragment if needed.
 262     *
 263     * We'd like to use non-normalized texcoords to index into a RECT
 264     * texture, but we can only use GL_REPEAT wrap mode with normalized
 265     * texcoords.  Darn.
 266     */
 267
 268    /* MUL texTemp, INPUT[wincoord], 1/32; */
 269    tgsi_transform_op2_inst(ctx, TGSI_OPCODE_MUL,
 270                            TGSI_FILE_TEMPORARY, pctx->texTemp,
 271                            TGSI_WRITEMASK_XYZW,
 272                            TGSI_FILE_INPUT, wincoordInput,
 273                            TGSI_FILE_IMMEDIATE, pctx->numImmed);
 274
 275    /* TEX texTemp, texTemp, sampler; */
 276    tgsi_transform_tex_2d_inst(ctx,
 277                               TGSI_FILE_TEMPORARY, pctx->texTemp,
 278                               TGSI_FILE_TEMPORARY, pctx->texTemp,
 279                               pctx->freeSampler);
 280
 281    /* KILL_IF -texTemp.wwww;   # if -texTemp < 0, KILL fragment */
 282    tgsi_transform_kill_inst(ctx,
 283                             TGSI_FILE_TEMPORARY, pctx->texTemp, TGSI_SWIZZLE_W);
 284 }
 285
 286
 287
 288 /**
 289  * Generate the frag shader we'll use for doing polygon stipple.
 290  * This will be the user's shader prefixed with a TEX and KIL instruction.
 291  */
 292 static boolean
 293 generate_pstip_fs(struct pstip_stage *pstip)
 294 {
 295    const struct pipe_shader_state *orig_fs = &pstip->fs->state;
 296    /*struct draw_context *draw = pstip->stage.draw;*/
 297    struct pipe_shader_state pstip_fs;
 298    struct pstip_transform_context transform;
 299    const uint newLen = tgsi_num_tokens(orig_fs->tokens) + NUM_NEW_TOKENS;
 300
 301    pstip_fs = *orig_fs; /* copy to init */
 302    pstip_fs.tokens = tgsi_alloc_tokens(newLen);
 303    if (pstip_fs.tokens == NULL)
 304       return FALSE;
 305
 306    memset(&transform, 0, sizeof(transform));
 307    transform.wincoordInput = -1;
 308    transform.maxInput = -1;
 309    transform.texTemp = -1;
 310    transform.base.prolog = pstip_transform_prolog;
 311    transform.base.transform_declaration = pstip_transform_decl;
 312    transform.base.transform_immediate = pstip_transform_immed;
 313
 314    tgsi_transform_shader(orig_fs->tokens,
 315                          (struct tgsi_token *) pstip_fs.tokens,
 316                          newLen, &transform.base);
 317
 318 #if 0 /* DEBUG */
 319    tgsi_dump(orig_fs->tokens, 0);
 320    tgsi_dump(pstip_fs.tokens, 0);
 321 #endif
 322
 323    assert(pstip->fs);
 324
 325    pstip->fs->sampler_unit = transform.freeSampler;
 326    assert(pstip->fs->sampler_unit < PIPE_MAX_SAMPLERS);
 327
 328    pstip->fs->pstip_fs = pstip->driver_create_fs_state(pstip->pipe, &pstip_fs);
 329
 330    FREE((void *)pstip_fs.tokens);
 331
 332    if (!pstip->fs->pstip_fs)
 333       return FALSE;
 334
 335    return TRUE;
 336 }
 337
 338
 339 /**
 340  * Load texture image with current stipple pattern.
 341  */
 342 static void
 343 pstip_update_texture(struct pstip_stage *pstip)
 344 {
 345    static const uint bit31 = 1 << 31;
 346    struct pipe_context *pipe = pstip->pipe;
 347    struct pipe_transfer *transfer;
 348    const uint *stipple = pstip->state.stipple->stipple;
 349    uint i, j;
 350    ubyte *data;
 351
 352    data = pipe_transfer_map(pipe, pstip->texture, 0, 0,
 353                                 PIPE_TRANSFER_WRITE, 0, 0, 32, 32, &transfer);
 354
 355    /*
 356     * Load alpha texture.
 357     * Note: 0 means keep the fragment, 255 means kill it.
 358     * We'll negate the texel value and use KILL_IF which kills if value
 359     * is negative.
 360     */
 361    for (i = 0; i < 32; i++) {
 362       for (j = 0; j < 32; j++) {
 363          if (stipple[i] & (bit31 >> j)) {
 364             /* fragment "on" */
 365             data[i * transfer->stride + j] = 0;
 366          }
 367          else {
 368             /* fragment "off" */
 369             data[i * transfer->stride + j] = 255;
 370          }
 371       }
 372    }
 373
 374    /* unmap */
 375    pipe_transfer_unmap(pipe, transfer);
 376 }
 377
 378
 379 /**
 380  * Create the texture map we'll use for stippling.
 381  */
 382 static boolean
 383 pstip_create_texture(struct pstip_stage *pstip)
 384 {
 385    struct pipe_context *pipe = pstip->pipe;
 386    struct pipe_screen *screen = pipe->screen;
 387    struct pipe_resource texTemp;
 388    struct pipe_sampler_view viewTempl;
 389
 390    memset(&texTemp, 0, sizeof(texTemp));
 391    texTemp.target = PIPE_TEXTURE_2D;
 392    texTemp.format = PIPE_FORMAT_A8_UNORM; /* XXX verify supported by driver! */
 393    texTemp.last_level = 0;
 394    texTemp.width0 = 32;
 395    texTemp.height0 = 32;
 396    texTemp.depth0 = 1;
 397    texTemp.array_size = 1;
 398    texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
 399
 400    pstip->texture = screen->resource_create(screen, &texTemp);
 401    if (pstip->texture == NULL)
 402       return FALSE;
 403
 404    u_sampler_view_default_template(&viewTempl,
 405                                    pstip->texture,
 406                                    pstip->texture->format);
 407    pstip->sampler_view = pipe->create_sampler_view(pipe,
 408                                                    pstip->texture,
 409                                                    &viewTempl);
 410    if (!pstip->sampler_view) {
 411       return FALSE;
 412    }
 413
 414    return TRUE;
 415 }
 416
 417
 418 /**
 419  * Create the sampler CSO that'll be used for stippling.
 420  */
 421 static boolean
 422 pstip_create_sampler(struct pstip_stage *pstip)
 423 {
 424    struct pipe_sampler_state sampler;
 425    struct pipe_context *pipe = pstip->pipe;
 426
 427    memset(&sampler, 0, sizeof(sampler));
 428    sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
 429    sampler.wrap_t = PIPE_TEX_WRAP_REPEAT;
 430    sampler.wrap_r = PIPE_TEX_WRAP_REPEAT;
 431    sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
 432    sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
 433    sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
 434    sampler.normalized_coords = 1;
 435    sampler.min_lod = 0.0f;
 436    sampler.max_lod = 0.0f;
 437
 438    pstip->sampler_cso = pipe->create_sampler_state(pipe, &sampler);
 439    if (pstip->sampler_cso == NULL)
 440       return FALSE;
 441
 442    return TRUE;
 443 }
 444
 445
 446 /**
 447  * When we're about to draw our first stipple polygon in a batch, this function
 448  * is called to tell the driver to bind our modified fragment shader.
 449  */
 450 static boolean
 451 bind_pstip_fragment_shader(struct pstip_stage *pstip)
 452 {
 453    struct draw_context *draw = pstip->stage.draw;
 454    if (!pstip->fs->pstip_fs &&
 455        !generate_pstip_fs(pstip))
 456       return FALSE;
 457
 458    draw->suspend_flushing = TRUE;
 459    pstip->driver_bind_fs_state(pstip->pipe, pstip->fs->pstip_fs);
 460    draw->suspend_flushing = FALSE;
 461    return TRUE;
 462 }
 463
 464
 465 static INLINE struct pstip_stage *
 466 pstip_stage( struct draw_stage *stage )
 467 {
 468    return (struct pstip_stage *) stage;
 469 }
 470
 471
 472 static void
 473 pstip_first_tri(struct draw_stage *stage, struct prim_header *header)
 474 {
 475    struct pstip_stage *pstip = pstip_stage(stage);
 476    struct pipe_context *pipe = pstip->pipe;
 477    struct draw_context *draw = stage->draw;
 478    uint num_samplers;
 479
 480    assert(stage->draw->rasterizer->poly_stipple_enable);
 481
 482    /* bind our fragprog */
 483    if (!bind_pstip_fragment_shader(pstip)) {
 484       stage->tri = draw_pipe_passthrough_tri;
 485       stage->tri(stage, header);
 486       return;
 487    }
 488
 489
 490    /* how many samplers? */
 491    /* we'll use sampler/texture[pstip->sampler_unit] for the stipple */
 492    num_samplers = MAX2(pstip->num_sampler_views, pstip->num_samplers);
 493    num_samplers = MAX2(num_samplers, pstip->fs->sampler_unit + 1);
 494
 495    /* plug in our sampler, texture */
 496    pstip->state.samplers[pstip->fs->sampler_unit] = pstip->sampler_cso;
 497    pipe_sampler_view_reference(&pstip->state.sampler_views[pstip->fs->sampler_unit],
 498                                pstip->sampler_view);
 499
 500    assert(num_samplers <= PIPE_MAX_SAMPLERS);
 501
 502    draw->suspend_flushing = TRUE;
 503
 504    pstip->driver_bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0,
 505                                      num_samplers, pstip->state.samplers);
 506
 507    pstip->driver_set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0,
 508                                    num_samplers, pstip->state.sampler_views);
 509
 510    draw->suspend_flushing = FALSE;
 511
 512    /* now really draw first triangle */
 513    stage->tri = draw_pipe_passthrough_tri;
 514    stage->tri(stage, header);
 515 }
 516
 517
 518 static void
 519 pstip_flush(struct draw_stage *stage, unsigned flags)
 520 {
 521    struct draw_context *draw = stage->draw;
 522    struct pstip_stage *pstip = pstip_stage(stage);
 523    struct pipe_context *pipe = pstip->pipe;
 524
 525    stage->tri = pstip_first_tri;
 526    stage->next->flush( stage->next, flags );
 527
 528    /* restore original frag shader, texture, sampler state */
 529    draw->suspend_flushing = TRUE;
 530    pstip->driver_bind_fs_state(pipe, pstip->fs ? pstip->fs->driver_fs : NULL);
 531
 532    pstip->driver_bind_sampler_states(pipe, PIPE_SHADER_FRAGMENT, 0,
 533                                      pstip->num_samplers,
 534                                      pstip->state.samplers);
 535
 536    pstip->driver_set_sampler_views(pipe, PIPE_SHADER_FRAGMENT, 0,
 537                                    pstip->num_sampler_views,
 538                                    pstip->state.sampler_views);
 539
 540    draw->suspend_flushing = FALSE;
 541 }
 542
 543
 544 static void
 545 pstip_reset_stipple_counter(struct draw_stage *stage)
 546 {
 547    stage->next->reset_stipple_counter( stage->next );
 548 }
 549
 550
 551 static void
 552 pstip_destroy(struct draw_stage *stage)
 553 {
 554    struct pstip_stage *pstip = pstip_stage(stage);
 555    uint i;
 556
 557    for (i = 0; i < PIPE_MAX_SHADER_SAMPLER_VIEWS; i++) {
 558       pipe_sampler_view_reference(&pstip->state.sampler_views[i], NULL);
 559    }
 560
 561    pstip->pipe->delete_sampler_state(pstip->pipe, pstip->sampler_cso);
 562
 563    pipe_resource_reference(&pstip->texture, NULL);
 564
 565    if (pstip->sampler_view) {
 566       pipe_sampler_view_reference(&pstip->sampler_view, NULL);
 567    }
 568
 569    draw_free_temp_verts( stage );
 570    FREE( stage );
 571 }
 572
 573
 574 /** Create a new polygon stipple drawing stage object */
 575 static struct pstip_stage *
 576 draw_pstip_stage(struct draw_context *draw, struct pipe_context *pipe)
 577 {
 578    struct pstip_stage *pstip = CALLOC_STRUCT(pstip_stage);
 579    if (pstip == NULL)
 580       goto fail;
 581
 582    pstip->pipe = pipe;
 583
 584    pstip->stage.draw = draw;
 585    pstip->stage.name = "pstip";
 586    pstip->stage.next = NULL;
 587    pstip->stage.point = draw_pipe_passthrough_point;
 588    pstip->stage.line = draw_pipe_passthrough_line;
 589    pstip->stage.tri = pstip_first_tri;
 590    pstip->stage.flush = pstip_flush;
 591    pstip->stage.reset_stipple_counter = pstip_reset_stipple_counter;
 592    pstip->stage.destroy = pstip_destroy;
 593
 594    if (!draw_alloc_temp_verts( &pstip->stage, 8 ))
 595       goto fail;
 596
 597    return pstip;
 598
 599 fail:
 600    if (pstip)
 601       pstip->stage.destroy( &pstip->stage );
 602
 603    return NULL;
 604 }
 605
 606
 607 static struct pstip_stage *
 608 pstip_stage_from_pipe(struct pipe_context *pipe)
 609 {
 610    struct draw_context *draw = (struct draw_context *) pipe->draw;
 611    return pstip_stage(draw->pipeline.pstipple);
 612 }
 613
 614
 615 /**
 616  * This function overrides the driver's create_fs_state() function and
 617  * will typically be called by the state tracker.
 618  */
 619 static void *
 620 pstip_create_fs_state(struct pipe_context *pipe,
 621                        const struct pipe_shader_state *fs)
 622 {
 623    struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
 624    struct pstip_fragment_shader *pstipfs = CALLOC_STRUCT(pstip_fragment_shader);
 625
 626    if (pstipfs) {
 627       pstipfs->state.tokens = tgsi_dup_tokens(fs->tokens);
 628
 629       /* pass-through */
 630       pstipfs->driver_fs = pstip->driver_create_fs_state(pstip->pipe, fs);
 631    }
 632
 633    return pstipfs;
 634 }
 635
 636
 637 static void
 638 pstip_bind_fs_state(struct pipe_context *pipe, void *fs)
 639 {
 640    struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
 641    struct pstip_fragment_shader *pstipfs = (struct pstip_fragment_shader *) fs;
 642    /* save current */
 643    pstip->fs = pstipfs;
 644    /* pass-through */
 645    pstip->driver_bind_fs_state(pstip->pipe,
 646                                (pstipfs ? pstipfs->driver_fs : NULL));
 647 }
 648
 649
 650 static void
 651 pstip_delete_fs_state(struct pipe_context *pipe, void *fs)
 652 {
 653    struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
 654    struct pstip_fragment_shader *pstipfs = (struct pstip_fragment_shader *) fs;
 655    /* pass-through */
 656    pstip->driver_delete_fs_state(pstip->pipe, pstipfs->driver_fs);
 657
 658    if (pstipfs->pstip_fs)
 659       pstip->driver_delete_fs_state(pstip->pipe, pstipfs->pstip_fs);
 660
 661    FREE((void*)pstipfs->state.tokens);
 662    FREE(pstipfs);
 663 }
 664
 665
 666 static void
 667 pstip_bind_sampler_states(struct pipe_context *pipe, unsigned shader,
 668                           unsigned start, unsigned num, void **sampler)
 669 {
 670    struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
 671    uint i;
 672
 673    assert(start == 0);
 674
 675    if (shader == PIPE_SHADER_FRAGMENT) {
 676       /* save current */
 677       memcpy(pstip->state.samplers, sampler, num * sizeof(void *));
 678       for (i = num; i < PIPE_MAX_SAMPLERS; i++) {
 679          pstip->state.samplers[i] = NULL;
 680       }
 681       pstip->num_samplers = num;
 682    }
 683
 684    /* pass-through */
 685    pstip->driver_bind_sampler_states(pstip->pipe, shader, start, num, sampler);
 686 }
 687
 688
 689 static void
 690 pstip_set_sampler_views(struct pipe_context *pipe,
 691                         unsigned shader, unsigned start, unsigned num,
 692                         struct pipe_sampler_view **views)
 693 {
 694    struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
 695    uint i;
 696
 697    if (shader == PIPE_SHADER_FRAGMENT) {
 698       /* save current */
 699       for (i = 0; i < num; i++) {
 700          pipe_sampler_view_reference(&pstip->state.sampler_views[start + i],
 701                                      views[i]);
 702       }
 703       pstip->num_sampler_views = num;
 704    }
 705
 706    /* pass-through */
 707    pstip->driver_set_sampler_views(pstip->pipe, shader, start, num, views);
 708 }
 709
 710
 711 static void
 712 pstip_set_polygon_stipple(struct pipe_context *pipe,
 713                           const struct pipe_poly_stipple *stipple)
 714 {
 715    struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
 716
 717    /* save current */
 718    pstip->state.stipple = stipple;
 719
 720    /* pass-through */
 721    pstip->driver_set_polygon_stipple(pstip->pipe, stipple);
 722
 723    pstip_update_texture(pstip);
 724 }
 725
 726
 727 /**
 728  * Called by drivers that want to install this polygon stipple stage
 729  * into the draw module's pipeline.  This will not be used if the
 730  * hardware has native support for polygon stipple.
 731  */
 732 boolean
 733 draw_install_pstipple_stage(struct draw_context *draw,
 734                             struct pipe_context *pipe)
 735 {
 736    struct pstip_stage *pstip;
 737
 738    pipe->draw = (void *) draw;
 739
 740    /*
 741     * Create / install pgon stipple drawing / prim stage
 742     */
 743    pstip = draw_pstip_stage( draw, pipe );
 744    if (pstip == NULL)
 745       goto fail;
 746
 747    draw->pipeline.pstipple = &pstip->stage;
 748
 749    /* save original driver functions */
 750    pstip->driver_create_fs_state = pipe->create_fs_state;
 751    pstip->driver_bind_fs_state = pipe->bind_fs_state;
 752    pstip->driver_delete_fs_state = pipe->delete_fs_state;
 753
 754    pstip->driver_bind_sampler_states = pipe->bind_sampler_states;
 755    pstip->driver_set_sampler_views = pipe->set_sampler_views;
 756    pstip->driver_set_polygon_stipple = pipe->set_polygon_stipple;
 757
 758    /* create special texture, sampler state */
 759    if (!pstip_create_texture(pstip))
 760       goto fail;
 761
 762    if (!pstip_create_sampler(pstip))
 763       goto fail;
 764
 765    /* override the driver's functions */
 766    pipe->create_fs_state = pstip_create_fs_state;
 767    pipe->bind_fs_state = pstip_bind_fs_state;
 768    pipe->delete_fs_state = pstip_delete_fs_state;
 769
 770    pipe->bind_sampler_states = pstip_bind_sampler_states;
 771    pipe->set_sampler_views = pstip_set_sampler_views;
 772    pipe->set_polygon_stipple = pstip_set_polygon_stipple;
 773
 774    return TRUE;
 775
 776  fail:
 777    if (pstip)
 778       pstip->stage.destroy( &pstip->stage );
 779
 780    return FALSE;
 781 }