1 /**************************************************************************
2 *
3 * Copyright 2008 VMware, Inc.
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 VMWARE 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 * AA point stage: AA points are converted to quads and rendered with a
30 * special fragment shader. Another approach would be to use a texture
31 * map image of a point, but experiments indicate the quality isn't nearly
32 * as good as this approach.
33 *
34 * Note: this looks a lot like draw_aaline.c but there's actually little
35 * if any code that can be shared.
36 *
37 * Authors: Brian Paul
38 */
39
40
41 #include "pipe/p_context.h"
42 #include "pipe/p_defines.h"
43 #include "pipe/p_shader_tokens.h"
44
45 #include "tgsi/tgsi_transform.h"
46 #include "tgsi/tgsi_dump.h"
47
48 #include "util/u_math.h"
49 #include "util/u_memory.h"
50
51 #include "draw_context.h"
52 #include "draw_vs.h"
53 #include "draw_pipe.h"
54
55
56 /** Approx number of new tokens for instructions in aa_transform_inst() */
57 #define NUM_NEW_TOKENS 200
58
59
60 /*
61 * Enabling NORMALIZE might give _slightly_ better results.
62 * Basically, it controls whether we compute distance as d=sqrt(x*x+y*y) or
63 * d=x*x+y*y. Since we're working with a unit circle, the later seems
64 * close enough and saves some costly instructions.
65 */
66 #define NORMALIZE 0
67
68
69 /**
70 * Subclass of pipe_shader_state to carry extra fragment shader info.
71 */
72 struct aapoint_fragment_shader
73 {
74 struct pipe_shader_state state;
75 void *driver_fs; /**< the regular shader */
76 void *aapoint_fs; /**< the aa point-augmented shader */
77 int generic_attrib; /**< The generic input attrib/texcoord we'll use */
78 };
79
80
81 /**
82 * Subclass of draw_stage
83 */
84 struct aapoint_stage
85 {
86 struct draw_stage stage;
87
88 /** half of pipe_rasterizer_state::point_size */
89 float radius;
90
91 /** vertex attrib slot containing point size */
92 int psize_slot;
93
94 /** this is the vertex attrib slot for the new texcoords */
95 uint tex_slot;
96
97 /** vertex attrib slot containing position */
98 uint pos_slot;
99
100 /** Currently bound fragment shader */
101 struct aapoint_fragment_shader *fs;
102
103 /*
104 * Driver interface/override functions
105 */
106 void * (*driver_create_fs_state)(struct pipe_context *,
107 const struct pipe_shader_state *);
108 void (*driver_bind_fs_state)(struct pipe_context *, void *);
109 void (*driver_delete_fs_state)(struct pipe_context *, void *);
110 };
111
112
113
114 /**
115 * Subclass of tgsi_transform_context, used for transforming the
116 * user's fragment shader to add the special AA instructions.
117 */
118 struct aa_transform_context {
119 struct tgsi_transform_context base;
120 uint tempsUsed; /**< bitmask */
121 int colorOutput; /**< which output is the primary color */
122 int maxInput, maxGeneric; /**< max input index found */
123 int tmp0, colorTemp; /**< temp registers */
124 };
125
126
127 /**
128 * TGSI declaration transform callback.
129 * Look for two free temp regs and available input reg for new texcoords.
130 */
131 static void
aa_transform_decl(struct tgsi_transform_context * ctx,struct tgsi_full_declaration * decl)132 aa_transform_decl(struct tgsi_transform_context *ctx,
133 struct tgsi_full_declaration *decl)
134 {
135 struct aa_transform_context *aactx = (struct aa_transform_context *) ctx;
136
137 if (decl->Declaration.File == TGSI_FILE_OUTPUT &&
138 decl->Semantic.Name == TGSI_SEMANTIC_COLOR &&
139 decl->Semantic.Index == 0) {
140 aactx->colorOutput = decl->Range.First;
141 }
142 else if (decl->Declaration.File == TGSI_FILE_INPUT) {
143 if ((int) decl->Range.Last > aactx->maxInput)
144 aactx->maxInput = decl->Range.Last;
145 if (decl->Semantic.Name == TGSI_SEMANTIC_GENERIC &&
146 (int) decl->Semantic.Index > aactx->maxGeneric) {
147 aactx->maxGeneric = decl->Semantic.Index;
148 }
149 }
150 else if (decl->Declaration.File == TGSI_FILE_TEMPORARY) {
151 uint i;
152 for (i = decl->Range.First;
153 i <= decl->Range.Last; i++) {
154 aactx->tempsUsed |= (1 << i);
155 }
156 }
157
158 ctx->emit_declaration(ctx, decl);
159 }
160
161
162 /**
163 * TGSI transform callback.
164 * Insert new declarations and instructions before first instruction.
165 */
166 static void
aa_transform_prolog(struct tgsi_transform_context * ctx)167 aa_transform_prolog(struct tgsi_transform_context *ctx)
168 {
169 /* emit our new declarations before the first instruction */
170 struct aa_transform_context *aactx = (struct aa_transform_context *) ctx;
171 struct tgsi_full_instruction newInst;
172 const int texInput = aactx->maxInput + 1;
173 int tmp0;
174 uint i;
175
176 /* find two free temp regs */
177 for (i = 0; i < 32; i++) {
178 if ((aactx->tempsUsed & (1 << i)) == 0) {
179 /* found a free temp */
180 if (aactx->tmp0 < 0)
181 aactx->tmp0 = i;
182 else if (aactx->colorTemp < 0)
183 aactx->colorTemp = i;
184 else
185 break;
186 }
187 }
188
189 assert(aactx->colorTemp != aactx->tmp0);
190
191 tmp0 = aactx->tmp0;
192
193 /* declare new generic input/texcoord */
194 tgsi_transform_input_decl(ctx, texInput,
195 TGSI_SEMANTIC_GENERIC, aactx->maxGeneric + 1,
196 TGSI_INTERPOLATE_LINEAR);
197
198 /* declare new temp regs */
199 tgsi_transform_temp_decl(ctx, tmp0);
200 tgsi_transform_temp_decl(ctx, aactx->colorTemp);
201
202 /*
203 * Emit code to compute fragment coverage, kill if outside point radius
204 *
205 * Temp reg0 usage:
206 * t0.x = distance of fragment from center point
207 * t0.y = boolean, is t0.x > 1.0, also misc temp usage
208 * t0.z = temporary for computing 1/(1-k) value
209 * t0.w = final coverage value
210 */
211
212 /* MUL t0.xy, tex, tex; # compute x^2, y^2 */
213 tgsi_transform_op2_inst(ctx, TGSI_OPCODE_MUL,
214 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_XY,
215 TGSI_FILE_INPUT, texInput,
216 TGSI_FILE_INPUT, texInput, false);
217
218 /* ADD t0.x, t0.x, t0.y; # x^2 + y^2 */
219 tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_ADD,
220 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_X,
221 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_X,
222 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_Y, false);
223
224 #if NORMALIZE /* OPTIONAL normalization of length */
225 /* RSQ t0.x, t0.x; */
226 tgsi_transform_op1_inst(ctx, TGSI_OPCODE_RSQ,
227 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_X,
228 TGSI_FILE_TEMPORARY, tmp0);
229
230 /* RCP t0.x, t0.x; */
231 tgsi_transform_op1_inst(ctx, TGSI_OPCODE_RCP,
232 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_X,
233 TGSI_FILE_TEMPORARY, tmp0);
234 #endif
235
236 /* SGT t0.y, t0.xxxx, tex.wwww; # bool b = d > 1 (NOTE tex.w == 1) */
237 tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_SGT,
238 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_Y,
239 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_X,
240 TGSI_FILE_INPUT, texInput, TGSI_SWIZZLE_W, false);
241
242 /* KILL_IF -tmp0.yyyy; # if -tmp0.y < 0, KILL */
243 tgsi_transform_kill_inst(ctx, TGSI_FILE_TEMPORARY, tmp0,
244 TGSI_SWIZZLE_Y, TRUE);
245
246 /* compute coverage factor = (1-d)/(1-k) */
247
248 /* SUB t0.z, tex.w, tex.z; # m = 1 - k */
249 tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_ADD,
250 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_Z,
251 TGSI_FILE_INPUT, texInput, TGSI_SWIZZLE_W,
252 TGSI_FILE_INPUT, texInput, TGSI_SWIZZLE_Z, true);
253
254 /* RCP t0.z, t0.z; # t0.z = 1 / m */
255 newInst = tgsi_default_full_instruction();
256 newInst.Instruction.Opcode = TGSI_OPCODE_RCP;
257 newInst.Instruction.NumDstRegs = 1;
258 newInst.Dst[0].Register.File = TGSI_FILE_TEMPORARY;
259 newInst.Dst[0].Register.Index = tmp0;
260 newInst.Dst[0].Register.WriteMask = TGSI_WRITEMASK_Z;
261 newInst.Instruction.NumSrcRegs = 1;
262 newInst.Src[0].Register.File = TGSI_FILE_TEMPORARY;
263 newInst.Src[0].Register.Index = tmp0;
264 newInst.Src[0].Register.SwizzleX = TGSI_SWIZZLE_Z;
265 ctx->emit_instruction(ctx, &newInst);
266
267 /* SUB t0.y, 1, t0.x; # d = 1 - d */
268 tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_ADD,
269 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_Y,
270 TGSI_FILE_INPUT, texInput, TGSI_SWIZZLE_W,
271 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_X, true);
272
273 /* MUL t0.w, t0.y, t0.z; # coverage = d * m */
274 tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_MUL,
275 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_W,
276 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_Y,
277 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_Z, false);
278
279 /* SLE t0.y, t0.x, tex.z; # bool b = distance <= k */
280 tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_SLE,
281 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_Y,
282 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_X,
283 TGSI_FILE_INPUT, texInput, TGSI_SWIZZLE_Z, false);
284
285 /* CMP t0.w, -t0.y, tex.w, t0.w;
286 * # if -t0.y < 0 then
287 * t0.w = 1
288 * else
289 * t0.w = t0.w
290 */
291 tgsi_transform_op3_swz_inst(ctx, TGSI_OPCODE_CMP,
292 TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_W,
293 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_Y, 1,
294 TGSI_FILE_INPUT, texInput, TGSI_SWIZZLE_W,
295 TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_W);
296 }
297
298
299 /**
300 * TGSI transform callback.
301 * Insert new instructions before the END instruction.
302 */
303 static void
aa_transform_epilog(struct tgsi_transform_context * ctx)304 aa_transform_epilog(struct tgsi_transform_context *ctx)
305 {
306 struct aa_transform_context *aactx = (struct aa_transform_context *) ctx;
307
308 /* add alpha modulation code at tail of program */
309
310 /* MOV result.color.xyz, colorTemp; */
311 tgsi_transform_op1_inst(ctx, TGSI_OPCODE_MOV,
312 TGSI_FILE_OUTPUT, aactx->colorOutput,
313 TGSI_WRITEMASK_XYZ,
314 TGSI_FILE_TEMPORARY, aactx->colorTemp);
315
316 /* MUL result.color.w, colorTemp, tmp0.w; */
317 tgsi_transform_op2_inst(ctx, TGSI_OPCODE_MUL,
318 TGSI_FILE_OUTPUT, aactx->colorOutput,
319 TGSI_WRITEMASK_W,
320 TGSI_FILE_TEMPORARY, aactx->colorTemp,
321 TGSI_FILE_TEMPORARY, aactx->tmp0, false);
322 }
323
324
325 /**
326 * TGSI transform callback.
327 * Called per instruction.
328 * Replace writes to result.color w/ a temp reg.
329 */
330 static void
aa_transform_inst(struct tgsi_transform_context * ctx,struct tgsi_full_instruction * inst)331 aa_transform_inst(struct tgsi_transform_context *ctx,
332 struct tgsi_full_instruction *inst)
333 {
334 struct aa_transform_context *aactx = (struct aa_transform_context *) ctx;
335 unsigned i;
336
337 /* Not an END instruction.
338 * Look for writes to result.color and replace with colorTemp reg.
339 */
340 for (i = 0; i < inst->Instruction.NumDstRegs; i++) {
341 struct tgsi_full_dst_register *dst = &inst->Dst[i];
342 if (dst->Register.File == TGSI_FILE_OUTPUT &&
343 dst->Register.Index == aactx->colorOutput) {
344 dst->Register.File = TGSI_FILE_TEMPORARY;
345 dst->Register.Index = aactx->colorTemp;
346 }
347 }
348
349 ctx->emit_instruction(ctx, inst);
350 }
351
352
353 /**
354 * Generate the frag shader we'll use for drawing AA points.
355 * This will be the user's shader plus some texture/modulate instructions.
356 */
357 static boolean
generate_aapoint_fs(struct aapoint_stage * aapoint)358 generate_aapoint_fs(struct aapoint_stage *aapoint)
359 {
360 const struct pipe_shader_state *orig_fs = &aapoint->fs->state;
361 struct pipe_shader_state aapoint_fs;
362 struct aa_transform_context transform;
363 const uint newLen = tgsi_num_tokens(orig_fs->tokens) + NUM_NEW_TOKENS;
364 struct pipe_context *pipe = aapoint->stage.draw->pipe;
365
366 aapoint_fs = *orig_fs; /* copy to init */
367 aapoint_fs.tokens = tgsi_alloc_tokens(newLen);
368 if (aapoint_fs.tokens == NULL)
369 return FALSE;
370
371 memset(&transform, 0, sizeof(transform));
372 transform.colorOutput = -1;
373 transform.maxInput = -1;
374 transform.maxGeneric = -1;
375 transform.colorTemp = -1;
376 transform.tmp0 = -1;
377 transform.base.prolog = aa_transform_prolog;
378 transform.base.epilog = aa_transform_epilog;
379 transform.base.transform_instruction = aa_transform_inst;
380 transform.base.transform_declaration = aa_transform_decl;
381
382 tgsi_transform_shader(orig_fs->tokens,
383 (struct tgsi_token *) aapoint_fs.tokens,
384 newLen, &transform.base);
385
386 #if 0 /* DEBUG */
387 debug_printf("draw_aapoint, orig shader:\n");
388 tgsi_dump(orig_fs->tokens, 0);
389 debug_printf("draw_aapoint, new shader:\n");
390 tgsi_dump(aapoint_fs.tokens, 0);
391 #endif
392
393 aapoint->fs->aapoint_fs
394 = aapoint->driver_create_fs_state(pipe, &aapoint_fs);
395 if (aapoint->fs->aapoint_fs == NULL)
396 goto fail;
397
398 aapoint->fs->generic_attrib = transform.maxGeneric + 1;
399 FREE((void *)aapoint_fs.tokens);
400 return TRUE;
401
402 fail:
403 FREE((void *)aapoint_fs.tokens);
404 return FALSE;
405 }
406
407
408 /**
409 * When we're about to draw our first AA point in a batch, this function is
410 * called to tell the driver to bind our modified fragment shader.
411 */
412 static boolean
bind_aapoint_fragment_shader(struct aapoint_stage * aapoint)413 bind_aapoint_fragment_shader(struct aapoint_stage *aapoint)
414 {
415 struct draw_context *draw = aapoint->stage.draw;
416 struct pipe_context *pipe = draw->pipe;
417
418 if (!aapoint->fs->aapoint_fs &&
419 !generate_aapoint_fs(aapoint))
420 return FALSE;
421
422 draw->suspend_flushing = TRUE;
423 aapoint->driver_bind_fs_state(pipe, aapoint->fs->aapoint_fs);
424 draw->suspend_flushing = FALSE;
425
426 return TRUE;
427 }
428
429
430
431 static inline struct aapoint_stage *
aapoint_stage(struct draw_stage * stage)432 aapoint_stage( struct draw_stage *stage )
433 {
434 return (struct aapoint_stage *) stage;
435 }
436
437
438
439
440 /**
441 * Draw an AA point by drawing a quad.
442 */
443 static void
aapoint_point(struct draw_stage * stage,struct prim_header * header)444 aapoint_point(struct draw_stage *stage, struct prim_header *header)
445 {
446 const struct aapoint_stage *aapoint = aapoint_stage(stage);
447 struct prim_header tri;
448 struct vertex_header *v[4];
449 const uint tex_slot = aapoint->tex_slot;
450 const uint pos_slot = aapoint->pos_slot;
451 float radius, *pos, *tex;
452 uint i;
453 float k;
454
455 if (aapoint->psize_slot >= 0) {
456 radius = 0.5f * header->v[0]->data[aapoint->psize_slot][0];
457 }
458 else {
459 radius = aapoint->radius;
460 }
461
462 /*
463 * Note: the texcoords (generic attrib, really) we use are special:
464 * The S and T components simply vary from -1 to +1.
465 * The R component is k, below.
466 * The Q component is 1.0 and will used as a handy constant in the
467 * fragment shader.
468 */
469
470 /*
471 * k is the threshold distance from the point's center at which
472 * we begin alpha attenuation (the coverage value).
473 * Operating within a unit circle, we'll compute the fragment's
474 * distance 'd' from the center point using the texcoords.
475 * IF d > 1.0 THEN
476 * KILL fragment
477 * ELSE IF d > k THEN
478 * compute coverage in [0,1] proportional to d in [k, 1].
479 * ELSE
480 * coverage = 1.0; // full coverage
481 * ENDIF
482 *
483 * Note: the ELSEIF and ELSE clauses are actually implemented with CMP to
484 * avoid using IF/ELSE/ENDIF TGSI opcodes.
485 */
486
487 #if !NORMALIZE
488 k = 1.0f / radius;
489 k = 1.0f - 2.0f * k + k * k;
490 #else
491 k = 1.0f - 1.0f / radius;
492 #endif
493
494 /* allocate/dup new verts */
495 for (i = 0; i < 4; i++) {
496 v[i] = dup_vert(stage, header->v[0], i);
497 }
498
499 /* new verts */
500 pos = v[0]->data[pos_slot];
501 pos[0] -= radius;
502 pos[1] -= radius;
503
504 pos = v[1]->data[pos_slot];
505 pos[0] += radius;
506 pos[1] -= radius;
507
508 pos = v[2]->data[pos_slot];
509 pos[0] += radius;
510 pos[1] += radius;
511
512 pos = v[3]->data[pos_slot];
513 pos[0] -= radius;
514 pos[1] += radius;
515
516 /* new texcoords */
517 tex = v[0]->data[tex_slot];
518 ASSIGN_4V(tex, -1, -1, k, 1);
519
520 tex = v[1]->data[tex_slot];
521 ASSIGN_4V(tex, 1, -1, k, 1);
522
523 tex = v[2]->data[tex_slot];
524 ASSIGN_4V(tex, 1, 1, k, 1);
525
526 tex = v[3]->data[tex_slot];
527 ASSIGN_4V(tex, -1, 1, k, 1);
528
529 /* emit 2 tris for the quad strip */
530 tri.v[0] = v[0];
531 tri.v[1] = v[1];
532 tri.v[2] = v[2];
533 stage->next->tri( stage->next, &tri );
534
535 tri.v[0] = v[0];
536 tri.v[1] = v[2];
537 tri.v[2] = v[3];
538 stage->next->tri( stage->next, &tri );
539 }
540
541
542 static void
aapoint_first_point(struct draw_stage * stage,struct prim_header * header)543 aapoint_first_point(struct draw_stage *stage, struct prim_header *header)
544 {
545 auto struct aapoint_stage *aapoint = aapoint_stage(stage);
546 struct draw_context *draw = stage->draw;
547 struct pipe_context *pipe = draw->pipe;
548 const struct pipe_rasterizer_state *rast = draw->rasterizer;
549 void *r;
550
551 assert(draw->rasterizer->point_smooth);
552
553 if (draw->rasterizer->point_size <= 2.0)
554 aapoint->radius = 1.0;
555 else
556 aapoint->radius = 0.5f * draw->rasterizer->point_size;
557
558 /*
559 * Bind (generate) our fragprog.
560 */
561 bind_aapoint_fragment_shader(aapoint);
562
563 draw_aapoint_prepare_outputs(draw, draw->pipeline.aapoint);
564
565 draw->suspend_flushing = TRUE;
566
567 /* Disable triangle culling, stippling, unfilled mode etc. */
568 r = draw_get_rasterizer_no_cull(draw, rast->scissor, rast->flatshade);
569 pipe->bind_rasterizer_state(pipe, r);
570
571 draw->suspend_flushing = FALSE;
572
573 /* now really draw first point */
574 stage->point = aapoint_point;
575 stage->point(stage, header);
576 }
577
578
579 static void
aapoint_flush(struct draw_stage * stage,unsigned flags)580 aapoint_flush(struct draw_stage *stage, unsigned flags)
581 {
582 struct draw_context *draw = stage->draw;
583 struct aapoint_stage *aapoint = aapoint_stage(stage);
584 struct pipe_context *pipe = draw->pipe;
585
586 stage->point = aapoint_first_point;
587 stage->next->flush( stage->next, flags );
588
589 /* restore original frag shader */
590 draw->suspend_flushing = TRUE;
591 aapoint->driver_bind_fs_state(pipe, aapoint->fs ? aapoint->fs->driver_fs : NULL);
592
593 /* restore original rasterizer state */
594 if (draw->rast_handle) {
595 pipe->bind_rasterizer_state(pipe, draw->rast_handle);
596 }
597
598 draw->suspend_flushing = FALSE;
599
600 draw_remove_extra_vertex_attribs(draw);
601 }
602
603
604 static void
aapoint_reset_stipple_counter(struct draw_stage * stage)605 aapoint_reset_stipple_counter(struct draw_stage *stage)
606 {
607 stage->next->reset_stipple_counter( stage->next );
608 }
609
610
611 static void
aapoint_destroy(struct draw_stage * stage)612 aapoint_destroy(struct draw_stage *stage)
613 {
614 struct aapoint_stage* aapoint = aapoint_stage(stage);
615 struct pipe_context *pipe = stage->draw->pipe;
616
617 draw_free_temp_verts( stage );
618
619 /* restore the old entry points */
620 pipe->create_fs_state = aapoint->driver_create_fs_state;
621 pipe->bind_fs_state = aapoint->driver_bind_fs_state;
622 pipe->delete_fs_state = aapoint->driver_delete_fs_state;
623
624 FREE( stage );
625 }
626
627 void
draw_aapoint_prepare_outputs(struct draw_context * draw,struct draw_stage * stage)628 draw_aapoint_prepare_outputs(struct draw_context *draw,
629 struct draw_stage *stage)
630 {
631 struct aapoint_stage *aapoint = aapoint_stage(stage);
632 const struct pipe_rasterizer_state *rast = draw->rasterizer;
633
634 /* update vertex attrib info */
635 aapoint->pos_slot = draw_current_shader_position_output(draw);
636
637 if (!rast->point_smooth)
638 return;
639
640 /* allocate the extra post-transformed vertex attribute */
641 aapoint->tex_slot = draw_alloc_extra_vertex_attrib(draw,
642 TGSI_SEMANTIC_GENERIC,
643 aapoint->fs->generic_attrib);
644 assert(aapoint->tex_slot > 0); /* output[0] is vertex pos */
645
646 /* find psize slot in post-transform vertex */
647 aapoint->psize_slot = -1;
648 if (draw->rasterizer->point_size_per_vertex) {
649 const struct tgsi_shader_info *info = draw_get_shader_info(draw);
650 uint i;
651 /* find PSIZ vertex output */
652 for (i = 0; i < info->num_outputs; i++) {
653 if (info->output_semantic_name[i] == TGSI_SEMANTIC_PSIZE) {
654 aapoint->psize_slot = i;
655 break;
656 }
657 }
658 }
659 }
660
661 static struct aapoint_stage *
draw_aapoint_stage(struct draw_context * draw)662 draw_aapoint_stage(struct draw_context *draw)
663 {
664 struct aapoint_stage *aapoint = CALLOC_STRUCT(aapoint_stage);
665 if (!aapoint)
666 goto fail;
667
668 aapoint->stage.draw = draw;
669 aapoint->stage.name = "aapoint";
670 aapoint->stage.next = NULL;
671 aapoint->stage.point = aapoint_first_point;
672 aapoint->stage.line = draw_pipe_passthrough_line;
673 aapoint->stage.tri = draw_pipe_passthrough_tri;
674 aapoint->stage.flush = aapoint_flush;
675 aapoint->stage.reset_stipple_counter = aapoint_reset_stipple_counter;
676 aapoint->stage.destroy = aapoint_destroy;
677
678 if (!draw_alloc_temp_verts( &aapoint->stage, 4 ))
679 goto fail;
680
681 return aapoint;
682
683 fail:
684 if (aapoint)
685 aapoint->stage.destroy(&aapoint->stage);
686
687 return NULL;
688
689 }
690
691
692 static struct aapoint_stage *
aapoint_stage_from_pipe(struct pipe_context * pipe)693 aapoint_stage_from_pipe(struct pipe_context *pipe)
694 {
695 struct draw_context *draw = (struct draw_context *) pipe->draw;
696 return aapoint_stage(draw->pipeline.aapoint);
697 }
698
699
700 /**
701 * This function overrides the driver's create_fs_state() function and
702 * will typically be called by the state tracker.
703 */
704 static void *
aapoint_create_fs_state(struct pipe_context * pipe,const struct pipe_shader_state * fs)705 aapoint_create_fs_state(struct pipe_context *pipe,
706 const struct pipe_shader_state *fs)
707 {
708 struct aapoint_stage *aapoint = aapoint_stage_from_pipe(pipe);
709 struct aapoint_fragment_shader *aafs = CALLOC_STRUCT(aapoint_fragment_shader);
710 if (!aafs)
711 return NULL;
712
713 aafs->state.tokens = tgsi_dup_tokens(fs->tokens);
714
715 /* pass-through */
716 aafs->driver_fs = aapoint->driver_create_fs_state(pipe, fs);
717
718 return aafs;
719 }
720
721
722 static void
aapoint_bind_fs_state(struct pipe_context * pipe,void * fs)723 aapoint_bind_fs_state(struct pipe_context *pipe, void *fs)
724 {
725 struct aapoint_stage *aapoint = aapoint_stage_from_pipe(pipe);
726 struct aapoint_fragment_shader *aafs = (struct aapoint_fragment_shader *) fs;
727 /* save current */
728 aapoint->fs = aafs;
729 /* pass-through */
730 aapoint->driver_bind_fs_state(pipe,
731 (aafs ? aafs->driver_fs : NULL));
732 }
733
734
735 static void
aapoint_delete_fs_state(struct pipe_context * pipe,void * fs)736 aapoint_delete_fs_state(struct pipe_context *pipe, void *fs)
737 {
738 struct aapoint_stage *aapoint = aapoint_stage_from_pipe(pipe);
739 struct aapoint_fragment_shader *aafs = (struct aapoint_fragment_shader *) fs;
740
741 /* pass-through */
742 aapoint->driver_delete_fs_state(pipe, aafs->driver_fs);
743
744 if (aafs->aapoint_fs)
745 aapoint->driver_delete_fs_state(pipe, aafs->aapoint_fs);
746
747 FREE((void*)aafs->state.tokens);
748
749 FREE(aafs);
750 }
751
752
753 /**
754 * Called by drivers that want to install this AA point prim stage
755 * into the draw module's pipeline. This will not be used if the
756 * hardware has native support for AA points.
757 */
758 boolean
draw_install_aapoint_stage(struct draw_context * draw,struct pipe_context * pipe)759 draw_install_aapoint_stage(struct draw_context *draw,
760 struct pipe_context *pipe)
761 {
762 struct aapoint_stage *aapoint;
763
764 pipe->draw = (void *) draw;
765
766 /*
767 * Create / install AA point drawing / prim stage
768 */
769 aapoint = draw_aapoint_stage( draw );
770 if (!aapoint)
771 return FALSE;
772
773 /* save original driver functions */
774 aapoint->driver_create_fs_state = pipe->create_fs_state;
775 aapoint->driver_bind_fs_state = pipe->bind_fs_state;
776 aapoint->driver_delete_fs_state = pipe->delete_fs_state;
777
778 /* override the driver's functions */
779 pipe->create_fs_state = aapoint_create_fs_state;
780 pipe->bind_fs_state = aapoint_bind_fs_state;
781 pipe->delete_fs_state = aapoint_delete_fs_state;
782
783 draw->pipeline.aapoint = &aapoint->stage;
784
785 return TRUE;
786 }
787