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_context.h"
36 #include "pipe/p_defines.h"
37 #include "pipe/p_shader_tokens.h"
38 #include "util/u_inlines.h"
40 #include "util/u_format.h"
41 #include "util/u_math.h"
42 #include "util/u_memory.h"
43 #include "util/u_sampler.h"
45 #include "tgsi/tgsi_transform.h"
46 #include "tgsi/tgsi_dump.h"
48 #include "draw_context.h"
49 #include "draw_private.h"
50 #include "draw_pipe.h"
53 /** Approx number of new tokens for instructions in aa_transform_inst() */
54 #define NUM_NEW_TOKENS 50
58 * Max texture level for the alpha texture used for antialiasing
60 #define MAX_TEXTURE_LEVEL 5 /* 32 x 32 */
64 * Subclass of pipe_shader_state to carry extra fragment shader info.
66 struct aaline_fragment_shader
68 struct pipe_shader_state state
;
72 int generic_attrib
; /**< texcoord/generic used for texture */
77 * Subclass of draw_stage
81 struct draw_stage stage
;
83 float half_line_width
;
85 /** For AA lines, this is the vertex attrib slot for the new texcoords */
87 /** position, not necessarily output zero */
91 struct pipe_resource
*texture
;
92 struct pipe_sampler_view
*sampler_view
;
94 uint num_sampler_views
;
98 * Currently bound state
100 struct aaline_fragment_shader
*fs
;
102 void *sampler
[PIPE_MAX_SAMPLERS
];
103 struct pipe_sampler_view
*sampler_views
[PIPE_MAX_SAMPLERS
];
107 * Driver interface/override functions
109 void * (*driver_create_fs_state
)(struct pipe_context
*,
110 const struct pipe_shader_state
*);
111 void (*driver_bind_fs_state
)(struct pipe_context
*, void *);
112 void (*driver_delete_fs_state
)(struct pipe_context
*, void *);
114 void (*driver_bind_sampler_states
)(struct pipe_context
*, unsigned,
117 void (*driver_set_sampler_views
)(struct pipe_context
*,
119 struct pipe_sampler_view
**);
125 * Subclass of tgsi_transform_context, used for transforming the
126 * user's fragment shader to add the special AA instructions.
128 struct aa_transform_context
{
129 struct tgsi_transform_context base
;
130 uint tempsUsed
; /**< bitmask */
131 int colorOutput
; /**< which output is the primary color */
132 uint samplersUsed
; /**< bitfield of samplers used */
133 int freeSampler
; /** an available sampler for the pstipple */
134 int maxInput
, maxGeneric
; /**< max input index found */
135 int colorTemp
, texTemp
; /**< temp registers */
136 boolean firstInstruction
;
141 * TGSI declaration transform callback.
142 * Look for a free sampler, a free input attrib, and two free temp regs.
145 aa_transform_decl(struct tgsi_transform_context
*ctx
,
146 struct tgsi_full_declaration
*decl
)
148 struct aa_transform_context
*aactx
= (struct aa_transform_context
*) ctx
;
150 if (decl
->Declaration
.File
== TGSI_FILE_OUTPUT
&&
151 decl
->Semantic
.Name
== TGSI_SEMANTIC_COLOR
&&
152 decl
->Semantic
.Index
== 0) {
153 aactx
->colorOutput
= decl
->Range
.First
;
155 else if (decl
->Declaration
.File
== TGSI_FILE_SAMPLER
) {
157 for (i
= decl
->Range
.First
;
158 i
<= decl
->Range
.Last
; i
++) {
159 aactx
->samplersUsed
|= 1 << i
;
162 else if (decl
->Declaration
.File
== TGSI_FILE_INPUT
) {
163 if ((int) decl
->Range
.Last
> aactx
->maxInput
)
164 aactx
->maxInput
= decl
->Range
.Last
;
165 if (decl
->Semantic
.Name
== TGSI_SEMANTIC_GENERIC
&&
166 (int) decl
->Semantic
.Index
> aactx
->maxGeneric
) {
167 aactx
->maxGeneric
= decl
->Semantic
.Index
;
170 else if (decl
->Declaration
.File
== TGSI_FILE_TEMPORARY
) {
172 for (i
= decl
->Range
.First
;
173 i
<= decl
->Range
.Last
; i
++) {
174 aactx
->tempsUsed
|= (1 << i
);
178 ctx
->emit_declaration(ctx
, decl
);
183 * Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
186 free_bit(uint bitfield
)
188 return ffs(~bitfield
) - 1;
193 * TGSI instruction transform callback.
194 * Replace writes to result.color w/ a temp reg.
195 * Upon END instruction, insert texture sampling code for antialiasing.
198 aa_transform_inst(struct tgsi_transform_context
*ctx
,
199 struct tgsi_full_instruction
*inst
)
201 struct aa_transform_context
*aactx
= (struct aa_transform_context
*) ctx
;
203 if (aactx
->firstInstruction
) {
204 /* emit our new declarations before the first instruction */
206 struct tgsi_full_declaration decl
;
209 /* find free sampler */
210 aactx
->freeSampler
= free_bit(aactx
->samplersUsed
);
211 if (aactx
->freeSampler
>= PIPE_MAX_SAMPLERS
)
212 aactx
->freeSampler
= PIPE_MAX_SAMPLERS
- 1;
214 /* find two free temp regs */
215 for (i
= 0; i
< 32; i
++) {
216 if ((aactx
->tempsUsed
& (1 << i
)) == 0) {
217 /* found a free temp */
218 if (aactx
->colorTemp
< 0)
219 aactx
->colorTemp
= i
;
220 else if (aactx
->texTemp
< 0)
226 assert(aactx
->colorTemp
>= 0);
227 assert(aactx
->texTemp
>= 0);
229 /* declare new generic input/texcoord */
230 decl
= tgsi_default_full_declaration();
231 decl
.Declaration
.File
= TGSI_FILE_INPUT
;
232 /* XXX this could be linear... */
233 decl
.Declaration
.Interpolate
= TGSI_INTERPOLATE_PERSPECTIVE
;
234 decl
.Declaration
.Semantic
= 1;
235 decl
.Semantic
.Name
= TGSI_SEMANTIC_GENERIC
;
236 decl
.Semantic
.Index
= aactx
->maxGeneric
+ 1;
238 decl
.Range
.Last
= aactx
->maxInput
+ 1;
239 ctx
->emit_declaration(ctx
, &decl
);
241 /* declare new sampler */
242 decl
= tgsi_default_full_declaration();
243 decl
.Declaration
.File
= TGSI_FILE_SAMPLER
;
245 decl
.Range
.Last
= aactx
->freeSampler
;
246 ctx
->emit_declaration(ctx
, &decl
);
248 /* declare new temp regs */
249 decl
= tgsi_default_full_declaration();
250 decl
.Declaration
.File
= TGSI_FILE_TEMPORARY
;
252 decl
.Range
.Last
= aactx
->texTemp
;
253 ctx
->emit_declaration(ctx
, &decl
);
255 decl
= tgsi_default_full_declaration();
256 decl
.Declaration
.File
= TGSI_FILE_TEMPORARY
;
258 decl
.Range
.Last
= aactx
->colorTemp
;
259 ctx
->emit_declaration(ctx
, &decl
);
261 aactx
->firstInstruction
= FALSE
;
264 if (inst
->Instruction
.Opcode
== TGSI_OPCODE_END
&&
265 aactx
->colorOutput
!= -1) {
266 struct tgsi_full_instruction newInst
;
269 newInst
= tgsi_default_full_instruction();
270 newInst
.Instruction
.Opcode
= TGSI_OPCODE_TEX
;
271 newInst
.Instruction
.NumDstRegs
= 1;
272 newInst
.Dst
[0].Register
.File
= TGSI_FILE_TEMPORARY
;
273 newInst
.Dst
[0].Register
.Index
= aactx
->texTemp
;
274 newInst
.Instruction
.NumSrcRegs
= 2;
275 newInst
.Instruction
.Texture
= TRUE
;
276 newInst
.Texture
.Texture
= TGSI_TEXTURE_2D
;
277 newInst
.Src
[0].Register
.File
= TGSI_FILE_INPUT
;
278 newInst
.Src
[0].Register
.Index
= aactx
->maxInput
+ 1;
279 newInst
.Src
[1].Register
.File
= TGSI_FILE_SAMPLER
;
280 newInst
.Src
[1].Register
.Index
= aactx
->freeSampler
;
282 ctx
->emit_instruction(ctx
, &newInst
);
285 newInst
= tgsi_default_full_instruction();
286 newInst
.Instruction
.Opcode
= TGSI_OPCODE_MOV
;
287 newInst
.Instruction
.NumDstRegs
= 1;
288 newInst
.Dst
[0].Register
.File
= TGSI_FILE_OUTPUT
;
289 newInst
.Dst
[0].Register
.Index
= aactx
->colorOutput
;
290 newInst
.Dst
[0].Register
.WriteMask
= TGSI_WRITEMASK_XYZ
;
291 newInst
.Instruction
.NumSrcRegs
= 1;
292 newInst
.Src
[0].Register
.File
= TGSI_FILE_TEMPORARY
;
293 newInst
.Src
[0].Register
.Index
= aactx
->colorTemp
;
294 ctx
->emit_instruction(ctx
, &newInst
);
297 newInst
= tgsi_default_full_instruction();
298 newInst
.Instruction
.Opcode
= TGSI_OPCODE_MUL
;
299 newInst
.Instruction
.NumDstRegs
= 1;
300 newInst
.Dst
[0].Register
.File
= TGSI_FILE_OUTPUT
;
301 newInst
.Dst
[0].Register
.Index
= aactx
->colorOutput
;
302 newInst
.Dst
[0].Register
.WriteMask
= TGSI_WRITEMASK_W
;
303 newInst
.Instruction
.NumSrcRegs
= 2;
304 newInst
.Src
[0].Register
.File
= TGSI_FILE_TEMPORARY
;
305 newInst
.Src
[0].Register
.Index
= aactx
->colorTemp
;
306 newInst
.Src
[1].Register
.File
= TGSI_FILE_TEMPORARY
;
307 newInst
.Src
[1].Register
.Index
= aactx
->texTemp
;
308 ctx
->emit_instruction(ctx
, &newInst
);
311 newInst
= tgsi_default_full_instruction();
312 newInst
.Instruction
.Opcode
= TGSI_OPCODE_END
;
313 newInst
.Instruction
.NumDstRegs
= 0;
314 newInst
.Instruction
.NumSrcRegs
= 0;
315 ctx
->emit_instruction(ctx
, &newInst
);
318 /* Not an END instruction.
319 * Look for writes to result.color and replace with colorTemp reg.
323 for (i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++) {
324 struct tgsi_full_dst_register
*dst
= &inst
->Dst
[i
];
325 if (dst
->Register
.File
== TGSI_FILE_OUTPUT
&&
326 dst
->Register
.Index
== aactx
->colorOutput
) {
327 dst
->Register
.File
= TGSI_FILE_TEMPORARY
;
328 dst
->Register
.Index
= aactx
->colorTemp
;
332 ctx
->emit_instruction(ctx
, inst
);
338 * Generate the frag shader we'll use for drawing AA lines.
339 * This will be the user's shader plus some texture/modulate instructions.
342 generate_aaline_fs(struct aaline_stage
*aaline
)
344 struct pipe_context
*pipe
= aaline
->stage
.draw
->pipe
;
345 const struct pipe_shader_state
*orig_fs
= &aaline
->fs
->state
;
346 struct pipe_shader_state aaline_fs
;
347 struct aa_transform_context transform
;
348 const uint newLen
= tgsi_num_tokens(orig_fs
->tokens
) + NUM_NEW_TOKENS
;
350 aaline_fs
= *orig_fs
; /* copy to init */
351 aaline_fs
.tokens
= tgsi_alloc_tokens(newLen
);
352 if (aaline_fs
.tokens
== NULL
)
355 memset(&transform
, 0, sizeof(transform
));
356 transform
.colorOutput
= -1;
357 transform
.maxInput
= -1;
358 transform
.maxGeneric
= -1;
359 transform
.colorTemp
= -1;
360 transform
.texTemp
= -1;
361 transform
.firstInstruction
= TRUE
;
362 transform
.base
.transform_instruction
= aa_transform_inst
;
363 transform
.base
.transform_declaration
= aa_transform_decl
;
365 tgsi_transform_shader(orig_fs
->tokens
,
366 (struct tgsi_token
*) aaline_fs
.tokens
,
367 newLen
, &transform
.base
);
370 tgsi_dump(orig_fs
->tokens
, 0);
371 tgsi_dump(aaline_fs
.tokens
, 0);
374 aaline
->fs
->sampler_unit
= transform
.freeSampler
;
376 aaline
->fs
->aaline_fs
377 = aaline
->driver_create_fs_state(pipe
, &aaline_fs
);
378 if (aaline
->fs
->aaline_fs
== NULL
)
381 aaline
->fs
->generic_attrib
= transform
.maxGeneric
+ 1;
382 FREE((void *)aaline_fs
.tokens
);
386 FREE((void *)aaline_fs
.tokens
);
392 * Create the texture map we'll use for antialiasing the lines.
395 aaline_create_texture(struct aaline_stage
*aaline
)
397 struct pipe_context
*pipe
= aaline
->stage
.draw
->pipe
;
398 struct pipe_screen
*screen
= pipe
->screen
;
399 struct pipe_resource texTemp
;
400 struct pipe_sampler_view viewTempl
;
403 memset(&texTemp
, 0, sizeof(texTemp
));
404 texTemp
.target
= PIPE_TEXTURE_2D
;
405 texTemp
.format
= PIPE_FORMAT_A8_UNORM
; /* XXX verify supported by driver! */
406 texTemp
.last_level
= MAX_TEXTURE_LEVEL
;
407 texTemp
.width0
= 1 << MAX_TEXTURE_LEVEL
;
408 texTemp
.height0
= 1 << MAX_TEXTURE_LEVEL
;
410 texTemp
.bind
= PIPE_BIND_SAMPLER_VIEW
;
412 aaline
->texture
= screen
->resource_create(screen
, &texTemp
);
413 if (!aaline
->texture
)
416 u_sampler_view_default_template(&viewTempl
,
418 aaline
->texture
->format
);
419 aaline
->sampler_view
= pipe
->create_sampler_view(pipe
,
422 if (!aaline
->sampler_view
) {
426 /* Fill in mipmap images.
427 * Basically each level is solid opaque, except for the outermost
428 * texels which are zero. Special case the 1x1 and 2x2 levels
429 * (though, those levels shouldn't be used - see the max_lod setting).
431 for (level
= 0; level
<= MAX_TEXTURE_LEVEL
; level
++) {
432 struct pipe_transfer
*transfer
;
434 const uint size
= u_minify(aaline
->texture
->width0
, level
);
438 assert(aaline
->texture
->width0
== aaline
->texture
->height0
);
440 u_box_origin_2d( size
, size
, &box
);
442 /* This texture is new, no need to flush.
444 transfer
= pipe
->get_transfer(pipe
,
446 u_subresource(0, level
),
450 data
= pipe
->transfer_map(pipe
, transfer
);
454 for (i
= 0; i
< size
; i
++) {
455 for (j
= 0; j
< size
; j
++) {
460 else if (size
== 2) {
461 d
= 200; /* tuneable */
463 else if (i
== 0 || j
== 0 || i
== size
- 1 || j
== size
- 1) {
469 data
[i
* transfer
->stride
+ j
] = d
;
474 pipe
->transfer_unmap(pipe
, transfer
);
475 pipe
->transfer_destroy(pipe
, transfer
);
482 * Create the sampler CSO that'll be used for antialiasing.
483 * By using a mipmapped texture, we don't have to generate a different
484 * texture image for each line size.
487 aaline_create_sampler(struct aaline_stage
*aaline
)
489 struct pipe_sampler_state sampler
;
490 struct pipe_context
*pipe
= aaline
->stage
.draw
->pipe
;
492 memset(&sampler
, 0, sizeof(sampler
));
493 sampler
.wrap_s
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
494 sampler
.wrap_t
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
495 sampler
.wrap_r
= PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
496 sampler
.min_mip_filter
= PIPE_TEX_MIPFILTER_LINEAR
;
497 sampler
.min_img_filter
= PIPE_TEX_FILTER_LINEAR
;
498 sampler
.mag_img_filter
= PIPE_TEX_FILTER_LINEAR
;
499 sampler
.normalized_coords
= 1;
500 sampler
.min_lod
= 0.0f
;
501 /* avoid using the 1x1 and 2x2 mipmap levels */
502 sampler
.max_lod
= MAX_TEXTURE_LEVEL
- 2;
504 aaline
->sampler_cso
= pipe
->create_sampler_state(pipe
, &sampler
);
505 if (aaline
->sampler_cso
== NULL
)
513 * When we're about to draw our first AA line in a batch, this function is
514 * called to tell the driver to bind our modified fragment shader.
517 bind_aaline_fragment_shader(struct aaline_stage
*aaline
)
519 struct draw_context
*draw
= aaline
->stage
.draw
;
520 struct pipe_context
*pipe
= draw
->pipe
;
522 if (!aaline
->fs
->aaline_fs
&&
523 !generate_aaline_fs(aaline
))
526 draw
->suspend_flushing
= TRUE
;
527 aaline
->driver_bind_fs_state(pipe
, aaline
->fs
->aaline_fs
);
528 draw
->suspend_flushing
= FALSE
;
535 static INLINE
struct aaline_stage
*
536 aaline_stage( struct draw_stage
*stage
)
538 return (struct aaline_stage
*) stage
;
543 * Draw a wide line by drawing a quad, using geometry which will
544 * fullfill GL's antialiased line requirements.
547 aaline_line(struct draw_stage
*stage
, struct prim_header
*header
)
549 const struct aaline_stage
*aaline
= aaline_stage(stage
);
550 const float half_width
= aaline
->half_line_width
;
551 struct prim_header tri
;
552 struct vertex_header
*v
[8];
553 uint texPos
= aaline
->tex_slot
;
554 uint posPos
= aaline
->pos_slot
;
556 float dx
= header
->v
[1]->data
[posPos
][0] - header
->v
[0]->data
[posPos
][0];
557 float dy
= header
->v
[1]->data
[posPos
][1] - header
->v
[0]->data
[posPos
][1];
558 double a
= atan2(dy
, dx
);
559 float c_a
= (float) cos(a
), s_a
= (float) sin(a
);
562 /* XXX the ends of lines aren't quite perfect yet, but probably passable */
563 dx
= 0.5F
* half_width
;
566 /* allocate/dup new verts */
567 for (i
= 0; i
< 8; i
++) {
568 v
[i
] = dup_vert(stage
, header
->v
[i
/4], i
);
572 * Quad strip for line from v0 to v1 (*=endpoints):
575 * +---+---------------------+---+
579 * +---+---------------------+---+
584 pos
= v
[0]->data
[posPos
];
585 pos
[0] += (-dx
* c_a
- dy
* s_a
);
586 pos
[1] += (-dx
* s_a
+ dy
* c_a
);
588 pos
= v
[1]->data
[posPos
];
589 pos
[0] += (-dx
* c_a
- -dy
* s_a
);
590 pos
[1] += (-dx
* s_a
+ -dy
* c_a
);
592 pos
= v
[2]->data
[posPos
];
593 pos
[0] += ( dx
* c_a
- dy
* s_a
);
594 pos
[1] += ( dx
* s_a
+ dy
* c_a
);
596 pos
= v
[3]->data
[posPos
];
597 pos
[0] += ( dx
* c_a
- -dy
* s_a
);
598 pos
[1] += ( dx
* s_a
+ -dy
* c_a
);
600 pos
= v
[4]->data
[posPos
];
601 pos
[0] += (-dx
* c_a
- dy
* s_a
);
602 pos
[1] += (-dx
* s_a
+ dy
* c_a
);
604 pos
= v
[5]->data
[posPos
];
605 pos
[0] += (-dx
* c_a
- -dy
* s_a
);
606 pos
[1] += (-dx
* s_a
+ -dy
* c_a
);
608 pos
= v
[6]->data
[posPos
];
609 pos
[0] += ( dx
* c_a
- dy
* s_a
);
610 pos
[1] += ( dx
* s_a
+ dy
* c_a
);
612 pos
= v
[7]->data
[posPos
];
613 pos
[0] += ( dx
* c_a
- -dy
* s_a
);
614 pos
[1] += ( dx
* s_a
+ -dy
* c_a
);
617 tex
= v
[0]->data
[texPos
];
618 ASSIGN_4V(tex
, 0, 0, 0, 1);
620 tex
= v
[1]->data
[texPos
];
621 ASSIGN_4V(tex
, 0, 1, 0, 1);
623 tex
= v
[2]->data
[texPos
];
624 ASSIGN_4V(tex
, .5, 0, 0, 1);
626 tex
= v
[3]->data
[texPos
];
627 ASSIGN_4V(tex
, .5, 1, 0, 1);
629 tex
= v
[4]->data
[texPos
];
630 ASSIGN_4V(tex
, .5, 0, 0, 1);
632 tex
= v
[5]->data
[texPos
];
633 ASSIGN_4V(tex
, .5, 1, 0, 1);
635 tex
= v
[6]->data
[texPos
];
636 ASSIGN_4V(tex
, 1, 0, 0, 1);
638 tex
= v
[7]->data
[texPos
];
639 ASSIGN_4V(tex
, 1, 1, 0, 1);
641 /* emit 6 tris for the quad strip */
642 tri
.v
[0] = v
[2]; tri
.v
[1] = v
[1]; tri
.v
[2] = v
[0];
643 stage
->next
->tri( stage
->next
, &tri
);
645 tri
.v
[0] = v
[3]; tri
.v
[1] = v
[1]; tri
.v
[2] = v
[2];
646 stage
->next
->tri( stage
->next
, &tri
);
648 tri
.v
[0] = v
[4]; tri
.v
[1] = v
[3]; tri
.v
[2] = v
[2];
649 stage
->next
->tri( stage
->next
, &tri
);
651 tri
.v
[0] = v
[5]; tri
.v
[1] = v
[3]; tri
.v
[2] = v
[4];
652 stage
->next
->tri( stage
->next
, &tri
);
654 tri
.v
[0] = v
[6]; tri
.v
[1] = v
[5]; tri
.v
[2] = v
[4];
655 stage
->next
->tri( stage
->next
, &tri
);
657 tri
.v
[0] = v
[7]; tri
.v
[1] = v
[5]; tri
.v
[2] = v
[6];
658 stage
->next
->tri( stage
->next
, &tri
);
663 aaline_first_line(struct draw_stage
*stage
, struct prim_header
*header
)
665 auto struct aaline_stage
*aaline
= aaline_stage(stage
);
666 struct draw_context
*draw
= stage
->draw
;
667 struct pipe_context
*pipe
= draw
->pipe
;
668 const struct pipe_rasterizer_state
*rast
= draw
->rasterizer
;
672 assert(draw
->rasterizer
->line_smooth
);
674 if (draw
->rasterizer
->line_width
<= 2.2)
675 aaline
->half_line_width
= 1.1f
;
677 aaline
->half_line_width
= 0.5f
* draw
->rasterizer
->line_width
;
680 * Bind (generate) our fragprog, sampler and texture
682 if (!bind_aaline_fragment_shader(aaline
)) {
683 stage
->line
= draw_pipe_passthrough_line
;
684 stage
->line(stage
, header
);
688 /* update vertex attrib info */
689 aaline
->tex_slot
= draw_current_shader_outputs(draw
);
690 aaline
->pos_slot
= draw_current_shader_position_output(draw
);;
692 /* advertise the extra post-transformed vertex attribute */
693 draw
->extra_shader_outputs
.semantic_name
= TGSI_SEMANTIC_GENERIC
;
694 draw
->extra_shader_outputs
.semantic_index
= aaline
->fs
->generic_attrib
;
695 draw
->extra_shader_outputs
.slot
= aaline
->tex_slot
;
697 /* how many samplers? */
698 /* we'll use sampler/texture[pstip->sampler_unit] for the stipple */
699 num_samplers
= MAX2(aaline
->num_sampler_views
, aaline
->num_samplers
);
700 num_samplers
= MAX2(num_samplers
, aaline
->fs
->sampler_unit
+ 1);
702 aaline
->state
.sampler
[aaline
->fs
->sampler_unit
] = aaline
->sampler_cso
;
703 pipe_sampler_view_reference(&aaline
->state
.sampler_views
[aaline
->fs
->sampler_unit
],
704 aaline
->sampler_view
);
706 draw
->suspend_flushing
= TRUE
;
707 aaline
->driver_bind_sampler_states(pipe
, num_samplers
, aaline
->state
.sampler
);
708 aaline
->driver_set_sampler_views(pipe
, num_samplers
, aaline
->state
.sampler_views
);
710 /* Disable triangle culling, stippling, unfilled mode etc. */
711 r
= draw_get_rasterizer_no_cull(draw
, rast
->scissor
, rast
->flatshade
);
712 pipe
->bind_rasterizer_state(pipe
, r
);
714 draw
->suspend_flushing
= FALSE
;
716 /* now really draw first line */
717 stage
->line
= aaline_line
;
718 stage
->line(stage
, header
);
723 aaline_flush(struct draw_stage
*stage
, unsigned flags
)
725 struct draw_context
*draw
= stage
->draw
;
726 struct aaline_stage
*aaline
= aaline_stage(stage
);
727 struct pipe_context
*pipe
= draw
->pipe
;
729 stage
->line
= aaline_first_line
;
730 stage
->next
->flush( stage
->next
, flags
);
732 /* restore original frag shader, texture, sampler state */
733 draw
->suspend_flushing
= TRUE
;
734 aaline
->driver_bind_fs_state(pipe
, aaline
->fs
->driver_fs
);
735 aaline
->driver_bind_sampler_states(pipe
, aaline
->num_samplers
,
736 aaline
->state
.sampler
);
737 aaline
->driver_set_sampler_views(pipe
,
738 aaline
->num_sampler_views
,
739 aaline
->state
.sampler_views
);
741 /* restore original rasterizer state */
742 if (draw
->rast_handle
) {
743 pipe
->bind_rasterizer_state(pipe
, draw
->rast_handle
);
746 draw
->suspend_flushing
= FALSE
;
748 draw
->extra_shader_outputs
.slot
= 0;
753 aaline_reset_stipple_counter(struct draw_stage
*stage
)
755 stage
->next
->reset_stipple_counter( stage
->next
);
760 aaline_destroy(struct draw_stage
*stage
)
762 struct aaline_stage
*aaline
= aaline_stage(stage
);
763 struct pipe_context
*pipe
= stage
->draw
->pipe
;
766 for (i
= 0; i
< PIPE_MAX_SAMPLERS
; i
++) {
767 pipe_sampler_view_reference(&aaline
->state
.sampler_views
[i
], NULL
);
770 if (aaline
->sampler_cso
)
771 pipe
->delete_sampler_state(pipe
, aaline
->sampler_cso
);
774 pipe_resource_reference(&aaline
->texture
, NULL
);
776 if (aaline
->sampler_view
) {
777 pipe_sampler_view_reference(&aaline
->sampler_view
, NULL
);
780 draw_free_temp_verts( stage
);
786 static struct aaline_stage
*
787 draw_aaline_stage(struct draw_context
*draw
)
789 struct aaline_stage
*aaline
= CALLOC_STRUCT(aaline_stage
);
793 aaline
->stage
.draw
= draw
;
794 aaline
->stage
.name
= "aaline";
795 aaline
->stage
.next
= NULL
;
796 aaline
->stage
.point
= draw_pipe_passthrough_point
;
797 aaline
->stage
.line
= aaline_first_line
;
798 aaline
->stage
.tri
= draw_pipe_passthrough_tri
;
799 aaline
->stage
.flush
= aaline_flush
;
800 aaline
->stage
.reset_stipple_counter
= aaline_reset_stipple_counter
;
801 aaline
->stage
.destroy
= aaline_destroy
;
803 if (!draw_alloc_temp_verts( &aaline
->stage
, 8 ))
810 aaline
->stage
.destroy(&aaline
->stage
);
816 static struct aaline_stage
*
817 aaline_stage_from_pipe(struct pipe_context
*pipe
)
819 struct draw_context
*draw
= (struct draw_context
*) pipe
->draw
;
820 return aaline_stage(draw
->pipeline
.aaline
);
825 * This function overrides the driver's create_fs_state() function and
826 * will typically be called by the state tracker.
829 aaline_create_fs_state(struct pipe_context
*pipe
,
830 const struct pipe_shader_state
*fs
)
832 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
833 struct aaline_fragment_shader
*aafs
= CALLOC_STRUCT(aaline_fragment_shader
);
841 aafs
->driver_fs
= aaline
->driver_create_fs_state(pipe
, fs
);
848 aaline_bind_fs_state(struct pipe_context
*pipe
, void *fs
)
850 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
851 struct aaline_fragment_shader
*aafs
= (struct aaline_fragment_shader
*) fs
;
856 aaline
->driver_bind_fs_state(pipe
, (aafs
? aafs
->driver_fs
: NULL
));
861 aaline_delete_fs_state(struct pipe_context
*pipe
, void *fs
)
863 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
864 struct aaline_fragment_shader
*aafs
= (struct aaline_fragment_shader
*) fs
;
867 aaline
->driver_delete_fs_state(pipe
, aafs
->driver_fs
);
870 aaline
->driver_delete_fs_state(pipe
, aafs
->aaline_fs
);
877 aaline_bind_sampler_states(struct pipe_context
*pipe
,
878 unsigned num
, void **sampler
)
880 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
883 memcpy(aaline
->state
.sampler
, sampler
, num
* sizeof(void *));
884 aaline
->num_samplers
= num
;
887 aaline
->driver_bind_sampler_states(pipe
, num
, sampler
);
892 aaline_set_sampler_views(struct pipe_context
*pipe
,
894 struct pipe_sampler_view
**views
)
896 struct aaline_stage
*aaline
= aaline_stage_from_pipe(pipe
);
900 for (i
= 0; i
< num
; i
++) {
901 pipe_sampler_view_reference(&aaline
->state
.sampler_views
[i
], views
[i
]);
903 for ( ; i
< PIPE_MAX_SAMPLERS
; i
++) {
904 pipe_sampler_view_reference(&aaline
->state
.sampler_views
[i
], NULL
);
906 aaline
->num_sampler_views
= num
;
909 aaline
->driver_set_sampler_views(pipe
, num
, views
);
914 * Called by drivers that want to install this AA line prim stage
915 * into the draw module's pipeline. This will not be used if the
916 * hardware has native support for AA lines.
919 draw_install_aaline_stage(struct draw_context
*draw
, struct pipe_context
*pipe
)
921 struct aaline_stage
*aaline
;
923 pipe
->draw
= (void *) draw
;
926 * Create / install AA line drawing / prim stage
928 aaline
= draw_aaline_stage( draw
);
932 /* create special texture, sampler state */
933 if (!aaline_create_texture(aaline
))
936 if (!aaline_create_sampler(aaline
))
939 /* save original driver functions */
940 aaline
->driver_create_fs_state
= pipe
->create_fs_state
;
941 aaline
->driver_bind_fs_state
= pipe
->bind_fs_state
;
942 aaline
->driver_delete_fs_state
= pipe
->delete_fs_state
;
944 aaline
->driver_bind_sampler_states
= pipe
->bind_fragment_sampler_states
;
945 aaline
->driver_set_sampler_views
= pipe
->set_fragment_sampler_views
;
947 /* override the driver's functions */
948 pipe
->create_fs_state
= aaline_create_fs_state
;
949 pipe
->bind_fs_state
= aaline_bind_fs_state
;
950 pipe
->delete_fs_state
= aaline_delete_fs_state
;
952 pipe
->bind_fragment_sampler_states
= aaline_bind_sampler_states
;
953 pipe
->set_fragment_sampler_views
= aaline_set_sampler_views
;
955 /* Install once everything is known to be OK:
957 draw
->pipeline
.aaline
= &aaline
->stage
;
963 aaline
->stage
.destroy( &aaline
->stage
);