1 /**************************************************************************
3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
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.
37 #include "pipe/p_util.h"
38 #include "pipe/p_inlines.h"
39 #include "pipe/p_context.h"
40 #include "pipe/p_defines.h"
41 #include "pipe/p_shader_tokens.h"
43 #include "tgsi/util/tgsi_transform.h"
44 #include "tgsi/util/tgsi_dump.h"
46 #include "draw_context.h"
47 #include "draw_pipe.h"
52 * Subclass of pipe_shader_state to carry extra fragment shader info.
54 struct pstip_fragment_shader
56 struct pipe_shader_state state
;
64 * Subclass of draw_stage
68 struct draw_stage stage
;
71 struct pipe_texture
*texture
;
76 * Currently bound state
78 struct pstip_fragment_shader
*fs
;
80 void *samplers
[PIPE_MAX_SAMPLERS
];
81 struct pipe_texture
*textures
[PIPE_MAX_SAMPLERS
];
82 const struct pipe_poly_stipple
*stipple
;
86 * Driver interface/override functions
88 void * (*driver_create_fs_state
)(struct pipe_context
*,
89 const struct pipe_shader_state
*);
90 void (*driver_bind_fs_state
)(struct pipe_context
*, void *);
91 void (*driver_delete_fs_state
)(struct pipe_context
*, void *);
93 void (*driver_bind_sampler_states
)(struct pipe_context
*, unsigned, void **);
95 void (*driver_set_sampler_textures
)(struct pipe_context
*, unsigned,
96 struct pipe_texture
**);
98 void (*driver_set_polygon_stipple
)(struct pipe_context
*,
99 const struct pipe_poly_stipple
*);
101 struct pipe_context
*pipe
;
107 * Subclass of tgsi_transform_context, used for transforming the
108 * user's fragment shader to add the special AA instructions.
110 struct pstip_transform_context
{
111 struct tgsi_transform_context base
;
112 uint tempsUsed
; /**< bitmask */
115 uint samplersUsed
; /**< bitfield of samplers used */
116 int freeSampler
; /** an available sampler for the pstipple */
117 int texTemp
; /**< temp registers */
119 boolean firstInstruction
;
124 * TGSI declaration transform callback.
125 * Look for a free sampler, a free input attrib, and two free temp regs.
128 pstip_transform_decl(struct tgsi_transform_context
*ctx
,
129 struct tgsi_full_declaration
*decl
)
131 struct pstip_transform_context
*pctx
= (struct pstip_transform_context
*) ctx
;
133 if (decl
->Declaration
.File
== TGSI_FILE_SAMPLER
) {
135 for (i
= decl
->u
.DeclarationRange
.First
;
136 i
<= decl
->u
.DeclarationRange
.Last
; i
++) {
137 pctx
->samplersUsed
|= 1 << i
;
140 else if (decl
->Declaration
.File
== TGSI_FILE_INPUT
) {
141 pctx
->maxInput
= MAX2(pctx
->maxInput
, (int) decl
->u
.DeclarationRange
.Last
);
142 if (decl
->Semantic
.SemanticName
== TGSI_SEMANTIC_POSITION
)
143 pctx
->wincoordInput
= (int) decl
->u
.DeclarationRange
.First
;
145 else if (decl
->Declaration
.File
== TGSI_FILE_TEMPORARY
) {
147 for (i
= decl
->u
.DeclarationRange
.First
;
148 i
<= decl
->u
.DeclarationRange
.Last
; i
++) {
149 pctx
->tempsUsed
|= (1 << i
);
153 ctx
->emit_declaration(ctx
, decl
);
158 pstip_transform_immed(struct tgsi_transform_context
*ctx
,
159 struct tgsi_full_immediate
*immed
)
161 struct pstip_transform_context
*pctx
= (struct pstip_transform_context
*) ctx
;
167 * Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
170 free_bit(uint bitfield
)
173 for (i
= 0; i
< 32; i
++) {
174 if ((bitfield
& (1 << i
)) == 0)
182 * TGSI instruction transform callback.
183 * Replace writes to result.color w/ a temp reg.
184 * Upon END instruction, insert texture sampling code for antialiasing.
187 pstip_transform_inst(struct tgsi_transform_context
*ctx
,
188 struct tgsi_full_instruction
*inst
)
190 struct pstip_transform_context
*pctx
= (struct pstip_transform_context
*) ctx
;
192 if (pctx
->firstInstruction
) {
193 /* emit our new declarations before the first instruction */
195 struct tgsi_full_declaration decl
;
196 struct tgsi_full_instruction newInst
;
200 /* find free sampler */
201 pctx
->freeSampler
= free_bit(pctx
->samplersUsed
);
202 if (pctx
->freeSampler
>= PIPE_MAX_SAMPLERS
)
203 pctx
->freeSampler
= PIPE_MAX_SAMPLERS
- 1;
205 if (pctx
->wincoordInput
< 0)
206 wincoordInput
= pctx
->maxInput
+ 1;
208 wincoordInput
= pctx
->wincoordInput
;
210 /* find one free temp reg */
211 for (i
= 0; i
< 32; i
++) {
212 if ((pctx
->tempsUsed
& (1 << i
)) == 0) {
213 /* found a free temp */
214 if (pctx
->texTemp
< 0)
220 assert(pctx
->texTemp
>= 0);
222 if (pctx
->wincoordInput
< 0) {
223 /* declare new position input reg */
224 decl
= tgsi_default_full_declaration();
225 decl
.Declaration
.File
= TGSI_FILE_INPUT
;
226 decl
.Declaration
.Semantic
= 1;
227 decl
.Semantic
.SemanticName
= TGSI_SEMANTIC_POSITION
;
228 decl
.Semantic
.SemanticIndex
= 0;
229 decl
.Declaration
.Interpolate
= 1;
230 decl
.Interpolation
.Interpolate
= TGSI_INTERPOLATE_LINEAR
; /* XXX? */
231 decl
.u
.DeclarationRange
.First
=
232 decl
.u
.DeclarationRange
.Last
= wincoordInput
;
233 ctx
->emit_declaration(ctx
, &decl
);
236 /* declare new sampler */
237 decl
= tgsi_default_full_declaration();
238 decl
.Declaration
.File
= TGSI_FILE_SAMPLER
;
239 decl
.u
.DeclarationRange
.First
=
240 decl
.u
.DeclarationRange
.Last
= pctx
->freeSampler
;
241 ctx
->emit_declaration(ctx
, &decl
);
243 /* declare new temp regs */
244 decl
= tgsi_default_full_declaration();
245 decl
.Declaration
.File
= TGSI_FILE_TEMPORARY
;
246 decl
.u
.DeclarationRange
.First
=
247 decl
.u
.DeclarationRange
.Last
= pctx
->texTemp
;
248 ctx
->emit_declaration(ctx
, &decl
);
250 /* emit immediate = {1/32, 1/32, 1, 1}
251 * The index/position of this immediate will be pctx->numImmed
254 static const float value
[4] = { 1.0/32, 1.0/32, 1.0, 1.0 };
255 struct tgsi_full_immediate immed
;
257 immed
= tgsi_default_full_immediate();
258 immed
.Immediate
.Size
= 1 + size
; /* one for the token itself */
259 immed
.u
.Pointer
= (void *) value
;
260 ctx
->emit_immediate(ctx
, &immed
);
263 pctx
->firstInstruction
= FALSE
;
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.
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
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
);
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
);
303 /* KILP texTemp; # if texTemp < 0, KILL fragment */
304 newInst
= tgsi_default_full_instruction();
305 newInst
.Instruction
.Opcode
= TGSI_OPCODE_KILP
;
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
);
314 /* emit this instruction */
315 ctx
->emit_instruction(ctx
, inst
);
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.
324 generate_pstip_fs(struct pstip_stage
*pstip
)
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
;
333 pstip_fs
= *orig_fs
; /* copy to init */
334 pstip_fs
.tokens
= MALLOC(sizeof(struct tgsi_token
) * MAX
);
335 if (pstip_fs
.tokens
== NULL
)
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
;
347 tgsi_transform_shader(orig_fs
->tokens
,
348 (struct tgsi_token
*) pstip_fs
.tokens
,
349 MAX
, &transform
.base
);
352 tgsi_dump(orig_fs
->tokens
, 0);
353 tgsi_dump(pstip_fs
.tokens
, 0);
356 pstip
->fs
->sampler_unit
= transform
.freeSampler
;
357 assert(pstip
->fs
->sampler_unit
< PIPE_MAX_SAMPLERS
);
359 pstip
->fs
->pstip_fs
= pstip
->driver_create_fs_state(pstip
->pipe
, &pstip_fs
);
366 * Load texture image with current stipple pattern.
369 pstip_update_texture(struct pstip_stage
*pstip
)
371 static const uint bit31
= 1 << 31;
372 struct pipe_context
*pipe
= pstip
->pipe
;
373 struct pipe_screen
*screen
= pipe
->screen
;
374 struct pipe_surface
*surface
;
375 const uint
*stipple
= pstip
->state
.stipple
->stipple
;
379 /* XXX: want to avoid flushing just because we use stipple:
381 pipe
->flush( pipe
, PIPE_FLUSH_TEXTURE_CACHE
, NULL
);
383 surface
= screen
->get_tex_surface(screen
, pstip
->texture
, 0, 0, 0,
384 PIPE_BUFFER_USAGE_CPU_WRITE
);
385 data
= screen
->surface_map(screen
, surface
,
386 PIPE_BUFFER_USAGE_CPU_WRITE
);
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
394 for (i
= 0; i
< 32; i
++) {
395 for (j
= 0; j
< 32; j
++) {
396 if (stipple
[i
] & (bit31
>> j
)) {
398 data
[i
* surface
->pitch
+ j
] = 0;
402 data
[i
* surface
->pitch
+ j
] = 255;
408 screen
->surface_unmap(screen
, surface
);
409 screen
->tex_surface_release(screen
, &surface
);
414 * Create the texture map we'll use for stippling.
417 pstip_create_texture(struct pstip_stage
*pstip
)
419 struct pipe_context
*pipe
= pstip
->pipe
;
420 struct pipe_screen
*screen
= pipe
->screen
;
421 struct pipe_texture texTemp
;
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;
432 pstip
->texture
= screen
->texture_create(screen
, &texTemp
);
433 if (pstip
->texture
== NULL
)
441 * Create the sampler CSO that'll be used for stippling.
444 pstip_create_sampler(struct pstip_stage
*pstip
)
446 struct pipe_sampler_state sampler
;
447 struct pipe_context
*pipe
= pstip
->pipe
;
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
;
460 pstip
->sampler_cso
= pipe
->create_sampler_state(pipe
, &sampler
);
461 if (pstip
->sampler_cso
== NULL
)
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.
473 bind_pstip_fragment_shader(struct pstip_stage
*pstip
)
475 struct draw_context
*draw
= pstip
->stage
.draw
;
476 if (!pstip
->fs
->pstip_fs
&&
477 !generate_pstip_fs(pstip
))
480 draw
->suspend_flushing
= TRUE
;
481 pstip
->driver_bind_fs_state(pstip
->pipe
, pstip
->fs
->pstip_fs
);
482 draw
->suspend_flushing
= FALSE
;
487 static INLINE
struct pstip_stage
*
488 pstip_stage( struct draw_stage
*stage
)
490 return (struct pstip_stage
*) stage
;
495 pstip_first_tri(struct draw_stage
*stage
, struct prim_header
*header
)
497 struct pstip_stage
*pstip
= pstip_stage(stage
);
498 struct pipe_context
*pipe
= pstip
->pipe
;
499 struct draw_context
*draw
= stage
->draw
;
502 assert(stage
->draw
->rasterizer
->poly_stipple_enable
);
504 /* bind our fragprog */
505 if (!bind_pstip_fragment_shader(pstip
)) {
506 stage
->tri
= draw_pipe_passthrough_tri
;
507 stage
->tri(stage
, header
);
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);
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
],
522 assert(num_samplers
<= PIPE_MAX_SAMPLERS
);
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
;
529 /* now really draw first triangle */
530 stage
->tri
= draw_pipe_passthrough_tri
;
531 stage
->tri(stage
, header
);
536 pstip_flush(struct draw_stage
*stage
, unsigned flags
)
538 struct draw_context
*draw
= stage
->draw
;
539 struct pstip_stage
*pstip
= pstip_stage(stage
);
540 struct pipe_context
*pipe
= pstip
->pipe
;
542 stage
->tri
= pstip_first_tri
;
543 stage
->next
->flush( stage
->next
, flags
);
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
;
557 pstip_reset_stipple_counter(struct draw_stage
*stage
)
559 stage
->next
->reset_stipple_counter( stage
->next
);
564 pstip_destroy(struct draw_stage
*stage
)
566 struct pstip_stage
*pstip
= pstip_stage(stage
);
569 for (i
= 0; i
< PIPE_MAX_SAMPLERS
; i
++) {
570 pipe_texture_reference(&pstip
->state
.textures
[i
], NULL
);
573 pstip
->pipe
->delete_sampler_state(pstip
->pipe
, pstip
->sampler_cso
);
575 pipe_texture_release(&pstip
->texture
);
577 draw_free_temp_verts( stage
);
582 static struct pstip_stage
*
583 draw_pstip_stage(struct draw_context
*draw
)
585 struct pstip_stage
*pstip
= CALLOC_STRUCT(pstip_stage
);
587 draw_alloc_temp_verts( &pstip
->stage
, 8 );
589 pstip
->stage
.draw
= draw
;
590 pstip
->stage
.next
= NULL
;
591 pstip
->stage
.point
= draw_pipe_passthrough_point
;
592 pstip
->stage
.line
= draw_pipe_passthrough_line
;
593 pstip
->stage
.tri
= pstip_first_tri
;
594 pstip
->stage
.flush
= pstip_flush
;
595 pstip
->stage
.reset_stipple_counter
= pstip_reset_stipple_counter
;
596 pstip
->stage
.destroy
= pstip_destroy
;
602 static struct pstip_stage
*
603 pstip_stage_from_pipe(struct pipe_context
*pipe
)
605 struct draw_context
*draw
= (struct draw_context
*) pipe
->draw
;
606 return pstip_stage(draw
->pipeline
.pstipple
);
611 * This function overrides the driver's create_fs_state() function and
612 * will typically be called by the state tracker.
615 pstip_create_fs_state(struct pipe_context
*pipe
,
616 const struct pipe_shader_state
*fs
)
618 struct pstip_stage
*pstip
= pstip_stage_from_pipe(pipe
);
619 struct pstip_fragment_shader
*aafs
= CALLOC_STRUCT(pstip_fragment_shader
);
625 aafs
->driver_fs
= pstip
->driver_create_fs_state(pstip
->pipe
, fs
);
633 pstip_bind_fs_state(struct pipe_context
*pipe
, void *fs
)
635 struct pstip_stage
*pstip
= pstip_stage_from_pipe(pipe
);
636 struct pstip_fragment_shader
*aafs
= (struct pstip_fragment_shader
*) fs
;
640 pstip
->driver_bind_fs_state(pstip
->pipe
,
641 (aafs
? aafs
->driver_fs
: NULL
));
646 pstip_delete_fs_state(struct pipe_context
*pipe
, void *fs
)
648 struct pstip_stage
*pstip
= pstip_stage_from_pipe(pipe
);
649 struct pstip_fragment_shader
*aafs
= (struct pstip_fragment_shader
*) fs
;
651 pstip
->driver_delete_fs_state(pstip
->pipe
, aafs
->driver_fs
);
657 pstip_bind_sampler_states(struct pipe_context
*pipe
,
658 unsigned num
, void **sampler
)
660 struct pstip_stage
*pstip
= pstip_stage_from_pipe(pipe
);
664 memcpy(pstip
->state
.samplers
, sampler
, num
* sizeof(void *));
665 for (i
= num
; i
< PIPE_MAX_SAMPLERS
; i
++) {
666 pstip
->state
.samplers
[i
] = NULL
;
669 pstip
->num_samplers
= num
;
671 pstip
->driver_bind_sampler_states(pstip
->pipe
, num
, sampler
);
676 pstip_set_sampler_textures(struct pipe_context
*pipe
,
677 unsigned num
, struct pipe_texture
**texture
)
679 struct pstip_stage
*pstip
= pstip_stage_from_pipe(pipe
);
683 for (i
= 0; i
< num
; i
++) {
684 pipe_texture_reference(&pstip
->state
.textures
[i
], texture
[i
]);
686 for (; i
< PIPE_MAX_SAMPLERS
; i
++) {
687 pipe_texture_reference(&pstip
->state
.textures
[i
], NULL
);
690 pstip
->num_textures
= num
;
693 pstip
->driver_set_sampler_textures(pstip
->pipe
, num
, texture
);
698 pstip_set_polygon_stipple(struct pipe_context
*pipe
,
699 const struct pipe_poly_stipple
*stipple
)
701 struct pstip_stage
*pstip
= pstip_stage_from_pipe(pipe
);
704 pstip
->state
.stipple
= stipple
;
707 pstip
->driver_set_polygon_stipple(pstip
->pipe
, stipple
);
709 pstip_update_texture(pstip
);
714 * Called by drivers that want to install this polygon stipple stage
715 * into the draw module's pipeline. This will not be used if the
716 * hardware has native support for polygon stipple.
719 draw_install_pstipple_stage(struct draw_context
*draw
,
720 struct pipe_context
*pipe
)
722 struct pstip_stage
*pstip
;
724 pipe
->draw
= (void *) draw
;
727 * Create / install pgon stipple drawing / prim stage
729 pstip
= draw_pstip_stage( draw
);
733 draw
->pipeline
.pstipple
= &pstip
->stage
;
737 /* create special texture, sampler state */
738 if (!pstip_create_texture(pstip
))
741 if (!pstip_create_sampler(pstip
))
744 /* save original driver functions */
745 pstip
->driver_create_fs_state
= pipe
->create_fs_state
;
746 pstip
->driver_bind_fs_state
= pipe
->bind_fs_state
;
747 pstip
->driver_delete_fs_state
= pipe
->delete_fs_state
;
749 pstip
->driver_bind_sampler_states
= pipe
->bind_sampler_states
;
750 pstip
->driver_set_sampler_textures
= pipe
->set_sampler_textures
;
751 pstip
->driver_set_polygon_stipple
= pipe
->set_polygon_stipple
;
753 /* override the driver's functions */
754 pipe
->create_fs_state
= pstip_create_fs_state
;
755 pipe
->bind_fs_state
= pstip_bind_fs_state
;
756 pipe
->delete_fs_state
= pstip_delete_fs_state
;
758 pipe
->bind_sampler_states
= pstip_bind_sampler_states
;
759 pipe
->set_sampler_textures
= pstip_set_sampler_textures
;
760 pipe
->set_polygon_stipple
= pstip_set_polygon_stipple
;
766 pstip
->stage
.destroy( &pstip
->stage
);