src/gallium/auxiliary/draw/draw_pipe_pstipple.c

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