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