1 /**************************************************************************
3 * Copyright 2007 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 * AA line stage: AA lines are converted to texture mapped triangles.
35 #include "pipe/p_util.h"
36 #include "pipe/p_inlines.h"
37 #include "pipe/p_context.h"
38 #include "pipe/p_defines.h"
39 #include "pipe/p_shader_tokens.h"
41 #include "tgsi/util/tgsi_transform.h"
42 #include "tgsi/util/tgsi_dump.h"
44 #include "draw_context.h"
45 #include "draw_private.h"
46 #include "draw_pipe.h"
50 * Max texture level for the alpha texture used for antialiasing
52 #define MAX_TEXTURE_LEVEL 5 /* 32 x 32 */
56 * Subclass of pipe_shader_state to carry extra fragment shader info.
58 struct aaline_fragment_shader
60 struct pipe_shader_state state
;
63 void *aapoint_fs
; /* not yet */
64 void *sprite_fs
; /* not yet */
66 int generic_attrib
; /**< texcoord/generic used for texture */
71 * Subclass of draw_stage
75 struct draw_stage stage
;
77 float half_line_width
;
79 /** For AA lines, this is the vertex attrib slot for the new texcoords */
83 struct pipe_texture
*texture
;
89 * Currently bound state
91 struct aaline_fragment_shader
*fs
;
93 void *sampler
[PIPE_MAX_SAMPLERS
];
94 struct pipe_texture
*texture
[PIPE_MAX_SAMPLERS
];
98 * Driver interface/override functions
100 void * (*driver_create_fs_state
)(struct pipe_context
*,
101 const struct pipe_shader_state
*);
102 void (*driver_bind_fs_state
)(struct pipe_context
*, void *);
103 void (*driver_delete_fs_state
)(struct pipe_context
*, void *);
105 void (*driver_bind_sampler_states
)(struct pipe_context
*, unsigned,
107 void (*driver_set_sampler_textures
)(struct pipe_context
*, unsigned,
108 struct pipe_texture
**);
110 struct pipe_context
*pipe
;
116 * Subclass of tgsi_transform_context, used for transforming the
117 * user's fragment shader to add the special AA instructions.
119 struct aa_transform_context
{
120 struct tgsi_transform_context base
;
121 uint tempsUsed
; /**< bitmask */
122 int colorOutput
; /**< which output is the primary color */
123 uint samplersUsed
; /**< bitfield of samplers used */
124 int freeSampler
; /** an available sampler for the pstipple */
125 int maxInput
, maxGeneric
; /**< max input index found */
126 int colorTemp
, texTemp
; /**< temp registers */
127 boolean firstInstruction
;
132 * TGSI declaration transform callback.
133 * Look for a free sampler, a free input attrib, and two free temp regs.
136 aa_transform_decl(struct tgsi_transform_context
*ctx
,
137 struct tgsi_full_declaration
*decl
)
139 struct aa_transform_context
*aactx
= (struct aa_transform_context
*) ctx
;
141 if (decl
->Declaration
.File
== TGSI_FILE_OUTPUT
&&
142 decl
->Semantic
.SemanticName
== TGSI_SEMANTIC_COLOR
&&
143 decl
->Semantic
.SemanticIndex
== 0) {
144 aactx
->colorOutput
= decl
->u
.DeclarationRange
.First
;
146 else if (decl
->Declaration
.File
== TGSI_FILE_SAMPLER
) {
148 for (i
= decl
->u
.DeclarationRange
.First
;
149 i
<= decl
->u
.DeclarationRange
.Last
; i
++) {
150 aactx
->samplersUsed
|= 1 << i
;
153 else if (decl
->Declaration
.File
== TGSI_FILE_INPUT
) {
154 if ((int) decl
->u
.DeclarationRange
.Last
> aactx
->maxInput
)
155 aactx
->maxInput
= decl
->u
.DeclarationRange
.Last
;
156 if (decl
->Semantic
.SemanticName
== TGSI_SEMANTIC_GENERIC
&&
157 (int) decl
->Semantic
.SemanticIndex
> aactx
->maxGeneric
) {
158 aactx
->maxGeneric
= decl
->Semantic
.SemanticIndex
;
161 else if (decl
->Declaration
.File
== TGSI_FILE_TEMPORARY
) {
163 for (i
= decl
->u
.DeclarationRange
.First
;
164 i
<= decl
->u
.DeclarationRange
.Last
; i
++) {
165 aactx
->tempsUsed
|= (1 << i
);
169 ctx
->emit_declaration(ctx
, decl
);
174 * Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
177 free_bit(uint bitfield
)
180 for (i
= 0; i
< 32; i
++) {
181 if ((bitfield
& (1 << i
)) == 0)
189 * TGSI instruction transform callback.
190 * Replace writes to result.color w/ a temp reg.
191 * Upon END instruction, insert texture sampling code for antialiasing.
194 aa_transform_inst(struct tgsi_transform_context
*ctx
,
195 struct tgsi_full_instruction
*inst
)
197 struct aa_transform_context
*aactx
= (struct aa_transform_context
*) ctx
;
199 if (aactx
->firstInstruction
) {
200 /* emit our new declarations before the first instruction */
202 struct tgsi_full_declaration decl
;
205 /* find free sampler */
206 aactx
->freeSampler
= free_bit(aactx
->samplersUsed
);
207 if (aactx
->freeSampler
>= PIPE_MAX_SAMPLERS
)
208 aactx
->freeSampler
= PIPE_MAX_SAMPLERS
- 1;
210 /* find two free temp regs */
211 for (i
= 0; i
< 32; i
++) {
212 if ((aactx
->tempsUsed
& (1 << i
)) == 0) {
213 /* found a free temp */
214 if (aactx
->colorTemp
< 0)
215 aactx
->colorTemp
= i
;
216 else if (aactx
->texTemp
< 0)
222 assert(aactx
->colorTemp
>= 0);
223 assert(aactx
->texTemp
>= 0);
225 /* declare new generic input/texcoord */
226 decl
= tgsi_default_full_declaration();
227 decl
.Declaration
.File
= TGSI_FILE_INPUT
;
228 decl
.Declaration
.Semantic
= 1;
229 decl
.Semantic
.SemanticName
= TGSI_SEMANTIC_GENERIC
;
230 decl
.Semantic
.SemanticIndex
= aactx
->maxGeneric
+ 1;
231 decl
.Declaration
.Interpolate
= 1;
232 /* XXX this could be linear... */
233 decl
.Interpolation
.Interpolate
= TGSI_INTERPOLATE_PERSPECTIVE
;
234 decl
.u
.DeclarationRange
.First
=
235 decl
.u
.DeclarationRange
.Last
= aactx
->maxInput
+ 1;
236 ctx
->emit_declaration(ctx
, &decl
);
238 /* declare new sampler */
239 decl
= tgsi_default_full_declaration();
240 decl
.Declaration
.File
= TGSI_FILE_SAMPLER
;
241 decl
.u
.DeclarationRange
.First
=
242 decl
.u
.DeclarationRange
.Last
= aactx
->freeSampler
;
243 ctx
->emit_declaration(ctx
, &decl
);
245 /* declare new temp regs */
246 decl
= tgsi_default_full_declaration();
247 decl
.Declaration
.File
= TGSI_FILE_TEMPORARY
;
248 decl
.u
.DeclarationRange
.First
=
249 decl
.u
.DeclarationRange
.Last
= aactx
->texTemp
;
250 ctx
->emit_declaration(ctx
, &decl
);
252 decl
= tgsi_default_full_declaration();
253 decl
.Declaration
.File
= TGSI_FILE_TEMPORARY
;
254 decl
.u
.DeclarationRange
.First
=
255 decl
.u
.DeclarationRange
.Last
= aactx
->colorTemp
;
256 ctx
->emit_declaration(ctx
, &decl
);
258 aactx
->firstInstruction
= FALSE
;
261 if (inst
->Instruction
.Opcode
== TGSI_OPCODE_END
&&
262 aactx
->colorOutput
!= -1) {
263 struct tgsi_full_instruction newInst
;
266 newInst
= tgsi_default_full_instruction();
267 newInst
.Instruction
.Opcode
= TGSI_OPCODE_TEX
;
268 newInst
.Instruction
.NumDstRegs
= 1;
269 newInst
.FullDstRegisters
[0].DstRegister
.File
= TGSI_FILE_TEMPORARY
;
270 newInst
.FullDstRegisters
[0].DstRegister
.Index
= aactx
->texTemp
;
271 newInst
.Instruction
.NumSrcRegs
= 2;
272 newInst
.InstructionExtTexture
.Texture
= TGSI_TEXTURE_2D
;
273 newInst
.FullSrcRegisters
[0].SrcRegister
.File
= TGSI_FILE_INPUT
;
274 newInst
.FullSrcRegisters
[0].SrcRegister
.Index
= aactx
->maxInput
+ 1;
275 newInst
.FullSrcRegisters
[1].SrcRegister
.File
= TGSI_FILE_SAMPLER
;
276 newInst
.FullSrcRegisters
[1].SrcRegister
.Index
= aactx
->freeSampler
;
278 ctx
->emit_instruction(ctx
, &newInst
);
281 newInst
= tgsi_default_full_instruction();
282 newInst
.Instruction
.Opcode
= TGSI_OPCODE_MOV
;
283 newInst
.Instruction
.NumDstRegs
= 1;
284 newInst
.FullDstRegisters
[0].DstRegister
.File
= TGSI_FILE_OUTPUT
;
285 newInst
.FullDstRegisters
[0].DstRegister
.Index
= aactx
->colorOutput
;
286 newInst
.FullDstRegisters
[0].DstRegister
.WriteMask
= TGSI_WRITEMASK_XYZ
;
287 newInst
.Instruction
.NumSrcRegs
= 1;
288 newInst
.FullSrcRegisters
[0].SrcRegister
.File
= TGSI_FILE_TEMPORARY
;
289 newInst
.FullSrcRegisters
[0].SrcRegister
.Index
= aactx
->colorTemp
;
290 ctx
->emit_instruction(ctx
, &newInst
);
293 newInst
= tgsi_default_full_instruction();
294 newInst
.Instruction
.Opcode
= TGSI_OPCODE_MUL
;
295 newInst
.Instruction
.NumDstRegs
= 1;
296 newInst
.FullDstRegisters
[0].DstRegister
.File
= TGSI_FILE_OUTPUT
;
297 newInst
.FullDstRegisters
[0].DstRegister
.Index
= aactx
->colorOutput
;
298 newInst
.FullDstRegisters
[0].DstRegister
.WriteMask
= TGSI_WRITEMASK_W
;
299 newInst
.Instruction
.NumSrcRegs
= 2;
300 newInst
.FullSrcRegisters
[0].SrcRegister
.File
= TGSI_FILE_TEMPORARY
;
301 newInst
.FullSrcRegisters
[0].SrcRegister
.Index
= aactx
->colorTemp
;
302 newInst
.FullSrcRegisters
[1].SrcRegister
.File
= TGSI_FILE_TEMPORARY
;
303 newInst
.FullSrcRegisters
[1].SrcRegister
.Index
= aactx
->texTemp
;
304 ctx
->emit_instruction(ctx
, &newInst
);
307 newInst
= tgsi_default_full_instruction();
308 newInst
.Instruction
.Opcode
= TGSI_OPCODE_END
;
309 newInst
.Instruction
.NumDstRegs
= 0;
310 newInst
.Instruction
.NumSrcRegs
= 0;
311 ctx
->emit_instruction(ctx
, &newInst
);
314 /* Not an END instruction.
315 * Look for writes to result.color and replace with colorTemp reg.
319 for (i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++) {
320 struct tgsi_full_dst_register
*dst
= &inst
->FullDstRegisters
[i
];
321 if (dst
->DstRegister
.File
== TGSI_FILE_OUTPUT
&&
322 dst
->DstRegister
.Index
== aactx
->colorOutput
) {
323 dst
->DstRegister
.File
= TGSI_FILE_TEMPORARY
;
324 dst
->DstRegister
.Index
= aactx
->colorTemp
;
328 ctx
->emit_instruction(ctx
, inst
);
334 * Generate the frag shader we'll use for drawing AA lines.
335 * This will be the user's shader plus some texture/modulate instructions.
338 generate_aaline_fs(struct aaline_stage
*aaline
)
340 const struct pipe_shader_state
*orig_fs
= &aaline
->fs
->state
;
341 struct pipe_shader_state aaline_fs
;
342 struct aa_transform_context transform
;
346 aaline_fs
= *orig_fs
; /* copy to init */
347 aaline_fs
.tokens
= MALLOC(sizeof(struct tgsi_token
) * MAX
);
348 if (aaline_fs
.tokens
== NULL
)
351 memset(&transform
, 0, sizeof(transform
));
352 transform
.colorOutput
= -1;
353 transform
.maxInput
= -1;
354 transform
.maxGeneric
= -1;
355 transform
.colorTemp
= -1;
356 transform
.texTemp
= -1;
357 transform
.firstInstruction
= TRUE
;
358 transform
.base
.transform_instruction
= aa_transform_inst
;
359 transform
.base
.transform_declaration
= aa_transform_decl
;
361 tgsi_transform_shader(orig_fs
->tokens
,
362 (struct tgsi_token
*) aaline_fs
.tokens
,
363 MAX
, &transform
.base
);
366 tgsi_dump(orig_fs
->tokens
, 0);
367 tgsi_dump(aaline_fs
.tokens
, 0);
370 aaline
->fs
->sampler_unit
= transform
.freeSampler
;
372 aaline
->fs
->aaline_fs
373 = aaline
->driver_create_fs_state(aaline
->pipe
, &aaline_fs
);
374 if (aaline
->fs
->aaline_fs
== NULL
)
377 aaline
->fs
->generic_attrib
= transform
.maxGeneric
+ 1;
383 * Create the texture map we'll use for antialiasing the lines.
386 aaline_create_texture(struct aaline_stage
*aaline
)
388 struct pipe_context
*pipe
= aaline
->pipe
;
389 struct pipe_screen
*screen
= pipe
->screen
;
390 struct pipe_texture texTemp
;
393 memset(&texTemp
, 0, sizeof(texTemp
));
394 texTemp
.target
= PIPE_TEXTURE_2D
;
395 texTemp
.format
= PIPE_FORMAT_A8_UNORM
; /* XXX verify supported by driver! */
396 texTemp
.last_level
= MAX_TEXTURE_LEVEL
;
397 texTemp
.width
[0] = 1 << MAX_TEXTURE_LEVEL
;
398 texTemp
.height
[0] = 1 << MAX_TEXTURE_LEVEL
;
399 texTemp
.depth
[0] = 1;
402 aaline
->texture
= screen
->texture_create(screen
, &texTemp
);
403 if (!aaline
->texture
)
406 /* Fill in mipmap images.
407 * Basically each level is solid opaque, except for the outermost
408 * texels which are zero. Special case the 1x1 and 2x2 levels.
410 for (level
= 0; level
<= MAX_TEXTURE_LEVEL
; level
++) {
411 struct pipe_surface
*surface
;
412 const uint size
= aaline
->texture
->width
[level
];
416 assert(aaline
->texture
->width
[level
] == aaline
->texture
->height
[level
]);
418 /* This texture is new, no need to flush.
420 surface
= screen
->get_tex_surface(screen
, aaline
->texture
, 0, level
, 0,
421 PIPE_BUFFER_USAGE_CPU_WRITE
);
422 data
= screen
->surface_map(screen
, surface
, PIPE_BUFFER_USAGE_CPU_WRITE
);
426 for (i
= 0; i
< size
; i
++) {
427 for (j
= 0; j
< size
; j
++) {
432 else if (size
== 2) {
433 d
= 200; /* tuneable */
435 else if (i
== 0 || j
== 0 || i
== size
- 1 || j
== size
- 1) {
441 data
[i
* surface
->pitch
+ j
] = d
;
446 screen
->surface_unmap(screen
, surface
);
447 screen
->tex_surface_release(screen
, &surface
);
454 * Create the sampler CSO that'll be used for antialiasing.
455 * By using a mipmapped texture, we don't have to generate a different
456 * texture image for each line size.
459 aaline_create_sampler(struct aaline_stage
*aaline
)
461 struct pipe_sampler_state sampler
;
462 struct pipe_context
*pipe
= aaline
->pipe
;
464 memset(&sampler
, 0, sizeof(sampler
));
465 sampler
.wrap_s
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
466 sampler
.wrap_t
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
467 sampler
.wrap_r
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
468 sampler
.min_mip_filter
= PIPE_TEX_MIPFILTER_LINEAR
;
469 sampler
.min_img_filter
= PIPE_TEX_FILTER_LINEAR
;
470 sampler
.mag_img_filter
= PIPE_TEX_FILTER_LINEAR
;
471 sampler
.normalized_coords
= 1;
472 sampler
.min_lod
= 0.0f
;
473 sampler
.max_lod
= MAX_TEXTURE_LEVEL
;
475 aaline
->sampler_cso
= pipe
->create_sampler_state(pipe
, &sampler
);
476 if (aaline
->sampler_cso
== NULL
)
484 * When we're about to draw our first AA line in a batch, this function is
485 * called to tell the driver to bind our modified fragment shader.
488 bind_aaline_fragment_shader(struct aaline_stage
*aaline
)
490 struct draw_context
*draw
= aaline
->stage
.draw
;
492 if (!aaline
->fs
->aaline_fs
&&
493 !generate_aaline_fs(aaline
))
496 draw
->suspend_flushing
= TRUE
;
497 aaline
->driver_bind_fs_state(aaline
->pipe
, aaline
->fs
->aaline_fs
);
498 draw
->suspend_flushing
= FALSE
;
505 static INLINE
struct aaline_stage
*
506 aaline_stage( struct draw_stage
*stage
)
508 return (struct aaline_stage
*) stage
;
513 * Draw a wide line by drawing a quad, using geometry which will
514 * fullfill GL's antialiased line requirements.
517 aaline_line(struct draw_stage
*stage
, struct prim_header
*header
)
519 const struct aaline_stage
*aaline
= aaline_stage(stage
);
520 const float half_width
= aaline
->half_line_width
;
521 struct prim_header tri
;
522 struct vertex_header
*v
[8];
523 uint texPos
= aaline
->tex_slot
;
525 float dx
= header
->v
[1]->data
[0][0] - header
->v
[0]->data
[0][0];
526 float dy
= header
->v
[1]->data
[0][1] - header
->v
[0]->data
[0][1];
527 double a
= atan2(dy
, dx
);
528 float c_a
= (float) cos(a
), s_a
= (float) sin(a
);
531 /* XXX the ends of lines aren't quite perfect yet, but probably passable */
532 dx
= 0.5F
* half_width
;
535 /* allocate/dup new verts */
536 for (i
= 0; i
< 8; i
++) {
537 v
[i
] = dup_vert(stage
, header
->v
[i
/4], i
);
541 * Quad strip for line from v0 to v1 (*=endpoints):
544 * +---+---------------------+---+
548 * +---+---------------------+---+
554 pos
[0] += (-dx
* c_a
- dy
* s_a
);
555 pos
[1] += (-dx
* s_a
+ dy
* c_a
);
558 pos
[0] += (-dx
* c_a
- -dy
* s_a
);
559 pos
[1] += (-dx
* s_a
+ -dy
* c_a
);
562 pos
[0] += ( dx
* c_a
- dy
* s_a
);
563 pos
[1] += ( dx
* s_a
+ dy
* c_a
);
566 pos
[0] += ( dx
* c_a
- -dy
* s_a
);
567 pos
[1] += ( dx
* s_a
+ -dy
* c_a
);
570 pos
[0] += (-dx
* c_a
- dy
* s_a
);
571 pos
[1] += (-dx
* s_a
+ dy
* c_a
);
574 pos
[0] += (-dx
* c_a
- -dy
* s_a
);
575 pos
[1] += (-dx
* s_a
+ -dy
* c_a
);
578 pos
[0] += ( dx
* c_a
- dy
* s_a
);
579 pos
[1] += ( dx
* s_a
+ dy
* c_a
);
582 pos
[0] += ( dx
* c_a
- -dy
* s_a
);
583 pos
[1] += ( dx
* s_a
+ -dy
* c_a
);
586 tex
= v
[0]->data
[texPos
];
587 ASSIGN_4V(tex
, 0, 0, 0, 1);
589 tex
= v
[1]->data
[texPos
];
590 ASSIGN_4V(tex
, 0, 1, 0, 1);
592 tex
= v
[2]->data
[texPos
];
593 ASSIGN_4V(tex
, .5, 0, 0, 1);
595 tex
= v
[3]->data
[texPos
];
596 ASSIGN_4V(tex
, .5, 1, 0, 1);
598 tex
= v
[4]->data
[texPos
];
599 ASSIGN_4V(tex
, .5, 0, 0, 1);
601 tex
= v
[5]->data
[texPos
];
602 ASSIGN_4V(tex
, .5, 1, 0, 1);
604 tex
= v
[6]->data
[texPos
];
605 ASSIGN_4V(tex
, 1, 0, 0, 1);
607 tex
= v
[7]->data
[texPos
];
608 ASSIGN_4V(tex
, 1, 1, 0, 1);
610 /* emit 6 tris for the quad strip */
611 tri
.v
[0] = v
[2]; tri
.v
[1] = v
[1]; tri
.v
[2] = v
[0];
612 stage
->next
->tri( stage
->next
, &tri
);
614 tri
.v
[0] = v
[3]; tri
.v
[1] = v
[1]; tri
.v
[2] = v
[2];
615 stage
->next
->tri( stage
->next
, &tri
);
617 tri
.v
[0] = v
[4]; tri
.v
[1] = v
[3]; tri
.v
[2] = v
[2];
618 stage
->next
->tri( stage
->next
, &tri
);
620 tri
.v
[0] = v
[5]; tri
.v
[1] = v
[3]; tri
.v
[2] = v
[4];
621 stage
->next
->tri( stage
->next
, &tri
);
623 tri
.v
[0] = v
[6]; tri
.v
[1] = v
[5]; tri
.v
[2] = v
[4];
624 stage
->next
->tri( stage
->next
, &tri
);
626 tri
.v
[0] = v
[7]; tri
.v
[1] = v
[5]; tri
.v
[2] = v
[6];
627 stage
->next
->tri( stage
->next
, &tri
);
632 aaline_first_line(struct draw_stage
*stage
, struct prim_header
*header
)
634 auto struct aaline_stage
*aaline
= aaline_stage(stage
);
635 struct draw_context
*draw
= stage
->draw
;
636 struct pipe_context
*pipe
= aaline
->pipe
;
639 assert(draw
->rasterizer
->line_smooth
);
641 if (draw
->rasterizer
->line_width
<= 3.0)
642 aaline
->half_line_width
= 1.5f
;
644 aaline
->half_line_width
= 0.5f
* draw
->rasterizer
->line_width
;
647 * Bind (generate) our fragprog, sampler and texture
649 if (!bind_aaline_fragment_shader(aaline
)) {
650 stage
->line
= draw_pipe_passthrough_line
;
651 stage
->line(stage
, header
);
655 /* update vertex attrib info */
656 aaline
->tex_slot
= draw
->vs
.num_vs_outputs
;
657 assert(aaline
->tex_slot
> 0); /* output[0] is vertex pos */
659 /* advertise the extra post-transformed vertex attribute */
660 draw
->extra_vp_outputs
.semantic_name
= TGSI_SEMANTIC_GENERIC
;
661 draw
->extra_vp_outputs
.semantic_index
= aaline
->fs
->generic_attrib
;
662 draw
->extra_vp_outputs
.slot
= aaline
->tex_slot
;
664 /* how many samplers? */
665 /* we'll use sampler/texture[pstip->sampler_unit] for the stipple */
666 num_samplers
= MAX2(aaline
->num_textures
, aaline
->num_samplers
);
667 num_samplers
= MAX2(num_samplers
, aaline
->fs
->sampler_unit
+ 1);
669 aaline
->state
.sampler
[aaline
->fs
->sampler_unit
] = aaline
->sampler_cso
;
670 pipe_texture_reference(&aaline
->state
.texture
[aaline
->fs
->sampler_unit
],
673 draw
->suspend_flushing
= TRUE
;
674 aaline
->driver_bind_sampler_states(pipe
, num_samplers
, aaline
->state
.sampler
);
675 aaline
->driver_set_sampler_textures(pipe
, num_samplers
, aaline
->state
.texture
);
676 draw
->suspend_flushing
= FALSE
;
678 /* now really draw first line */
679 stage
->line
= aaline_line
;
680 stage
->line(stage
, header
);
685 aaline_flush(struct draw_stage
*stage
, unsigned flags
)
687 struct draw_context
*draw
= stage
->draw
;
688 struct aaline_stage
*aaline
= aaline_stage(stage
);
689 struct pipe_context
*pipe
= aaline
->pipe
;
691 stage
->line
= aaline_first_line
;
692 stage
->next
->flush( stage
->next
, flags
);
694 /* restore original frag shader, texture, sampler state */
695 draw
->suspend_flushing
= TRUE
;
696 aaline
->driver_bind_fs_state(pipe
, aaline
->fs
->driver_fs
);
697 aaline
->driver_bind_sampler_states(pipe
, aaline
->num_samplers
,
698 aaline
->state
.sampler
);
699 aaline
->driver_set_sampler_textures(pipe
, aaline
->num_textures
,
700 aaline
->state
.texture
);
701 draw
->suspend_flushing
= FALSE
;
703 draw
->extra_vp_outputs
.slot
= 0;
708 aaline_reset_stipple_counter(struct draw_stage
*stage
)
710 stage
->next
->reset_stipple_counter( stage
->next
);
715 aaline_destroy(struct draw_stage
*stage
)
717 struct aaline_stage
*aaline
= aaline_stage(stage
);
720 for (i
= 0; i
< PIPE_MAX_SAMPLERS
; i
++) {
721 pipe_texture_reference(&aaline
->state
.texture
[i
], NULL
);
724 if (aaline
->sampler_cso
)
725 aaline
->pipe
->delete_sampler_state(aaline
->pipe
, aaline
->sampler_cso
);
728 pipe_texture_release(&aaline
->texture
);
730 draw_free_temp_verts( stage
);
736 static struct aaline_stage
*
737 draw_aaline_stage(struct draw_context
*draw
)
739 struct aaline_stage
*aaline
= CALLOC_STRUCT(aaline_stage
);
743 if (!draw_alloc_temp_verts( &aaline
->stage
, 8 ))
746 aaline
->stage
.draw
= draw
;
747 aaline
->stage
.next
= NULL
;
748 aaline
->stage
.point
= draw_pipe_passthrough_point
;
749 aaline
->stage
.line
= aaline_first_line
;
750 aaline
->stage
.tri
= draw_pipe_passthrough_tri
;
751 aaline
->stage
.flush
= aaline_flush
;
752 aaline
->stage
.reset_stipple_counter
= aaline_reset_stipple_counter
;
753 aaline
->stage
.destroy
= aaline_destroy
;
759 aaline_destroy(&aaline
->stage
);
765 static struct aaline_stage
*
766 aaline_stage_from_pipe(struct pipe_context
*pipe
)
768 struct draw_context
*draw
= (struct draw_context
*) pipe
->draw
;
769 return aaline_stage(draw
->pipeline
.aaline
);
774 * This function overrides the driver's create_fs_state() function and
775 * will typically be called by the state tracker.
778 aaline_create_fs_state(struct pipe_context
*pipe
,
779 const struct pipe_shader_state
*fs
)
781 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
782 struct aaline_fragment_shader
*aafs
= CALLOC_STRUCT(aaline_fragment_shader
);
789 aafs
->driver_fs
= aaline
->driver_create_fs_state(aaline
->pipe
, fs
);
796 aaline_bind_fs_state(struct pipe_context
*pipe
, void *fs
)
798 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
799 struct aaline_fragment_shader
*aafs
= (struct aaline_fragment_shader
*) fs
;
804 aaline
->driver_bind_fs_state(aaline
->pipe
,
805 (aafs
? aafs
->driver_fs
: NULL
));
810 aaline_delete_fs_state(struct pipe_context
*pipe
, void *fs
)
812 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
813 struct aaline_fragment_shader
*aafs
= (struct aaline_fragment_shader
*) fs
;
815 aaline
->driver_delete_fs_state(aaline
->pipe
, aafs
->driver_fs
);
821 aaline_bind_sampler_states(struct pipe_context
*pipe
,
822 unsigned num
, void **sampler
)
824 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
827 memcpy(aaline
->state
.sampler
, sampler
, num
* sizeof(void *));
828 aaline
->num_samplers
= num
;
831 aaline
->driver_bind_sampler_states(aaline
->pipe
, num
, sampler
);
836 aaline_set_sampler_textures(struct pipe_context
*pipe
,
837 unsigned num
, struct pipe_texture
**texture
)
839 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
843 for (i
= 0; i
< num
; i
++) {
844 pipe_texture_reference(&aaline
->state
.texture
[i
], texture
[i
]);
846 for ( ; i
< PIPE_MAX_SAMPLERS
; i
++) {
847 pipe_texture_reference(&aaline
->state
.texture
[i
], NULL
);
849 aaline
->num_textures
= num
;
852 aaline
->driver_set_sampler_textures(aaline
->pipe
, num
, texture
);
857 * Called by drivers that want to install this AA line prim stage
858 * into the draw module's pipeline. This will not be used if the
859 * hardware has native support for AA lines.
862 draw_install_aaline_stage(struct draw_context
*draw
, struct pipe_context
*pipe
)
864 struct aaline_stage
*aaline
;
866 pipe
->draw
= (void *) draw
;
869 * Create / install AA line drawing / prim stage
871 aaline
= draw_aaline_stage( draw
);
877 /* create special texture, sampler state */
878 if (!aaline_create_texture(aaline
))
881 if (!aaline_create_sampler(aaline
))
884 /* save original driver functions */
885 aaline
->driver_create_fs_state
= pipe
->create_fs_state
;
886 aaline
->driver_bind_fs_state
= pipe
->bind_fs_state
;
887 aaline
->driver_delete_fs_state
= pipe
->delete_fs_state
;
889 aaline
->driver_bind_sampler_states
= pipe
->bind_sampler_states
;
890 aaline
->driver_set_sampler_textures
= pipe
->set_sampler_textures
;
892 /* override the driver's functions */
893 pipe
->create_fs_state
= aaline_create_fs_state
;
894 pipe
->bind_fs_state
= aaline_bind_fs_state
;
895 pipe
->delete_fs_state
= aaline_delete_fs_state
;
897 pipe
->bind_sampler_states
= aaline_bind_sampler_states
;
898 pipe
->set_sampler_textures
= aaline_set_sampler_textures
;
900 /* Install once everything is known to be OK:
902 draw
->pipeline
.aaline
= &aaline
->stage
;
908 aaline
->stage
.destroy( &aaline
->stage
);