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