1 /**************************************************************************
3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
29 * Polygon stipple stage: implement polygon stipple with texture map and
30 * fragment program. The fragment program samples the texture and does
31 * a fragment kill for the stipple-failing fragments.
37 #include "pipe/p_context.h"
38 #include "pipe/p_defines.h"
39 #include "pipe/p_shader_tokens.h"
40 #include "util/u_inlines.h"
42 #include "util/u_format.h"
43 #include "util/u_math.h"
44 #include "util/u_memory.h"
45 #include "util/u_sampler.h"
47 #include "tgsi/tgsi_transform.h"
48 #include "tgsi/tgsi_dump.h"
50 #include "draw_context.h"
51 #include "draw_pipe.h"
54 /** Approx number of new tokens for instructions in pstip_transform_inst() */
55 #define NUM_NEW_TOKENS 50
59 * Subclass of pipe_shader_state to carry extra fragment shader info.
61 struct pstip_fragment_shader
63 struct pipe_shader_state state;
71 * Subclass of draw_stage
75 struct draw_stage stage;
78 struct pipe_resource *texture;
79 struct pipe_sampler_view *sampler_view;
81 uint num_sampler_views;
84 * Currently bound state
86 struct pstip_fragment_shader *fs;
88 void *samplers[PIPE_MAX_SAMPLERS];
89 struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
90 const struct pipe_poly_stipple *stipple;
94 * Driver interface/override functions
96 void * (*driver_create_fs_state)(struct pipe_context *,
97 const struct pipe_shader_state *);
98 void (*driver_bind_fs_state)(struct pipe_context *, void *);
99 void (*driver_delete_fs_state)(struct pipe_context *, void *);
101 void (*driver_bind_sampler_states)(struct pipe_context *, unsigned, void **);
103 void (*driver_set_sampler_views)(struct pipe_context *,
105 struct pipe_sampler_view **);
107 void (*driver_set_polygon_stipple)(struct pipe_context *,
108 const struct pipe_poly_stipple *);
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 pstip_transform_context {
120 struct tgsi_transform_context base;
121 uint tempsUsed; /**< bitmask */
124 uint samplersUsed; /**< bitfield of samplers used */
125 int freeSampler; /** an available sampler for the pstipple */
126 int texTemp; /**< temp registers */
128 boolean firstInstruction;
133 * TGSI declaration transform callback.
134 * Look for a free sampler, a free input attrib, and two free temp regs.
137 pstip_transform_decl(struct tgsi_transform_context *ctx,
138 struct tgsi_full_declaration *decl)
140 struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
142 if (decl->Declaration.File == TGSI_FILE_SAMPLER) {
144 for (i = decl->Range.First;
145 i <= decl->Range.Last; i++) {
146 pctx->samplersUsed |= 1 << i;
149 else if (decl->Declaration.File == TGSI_FILE_INPUT) {
150 pctx->maxInput = MAX2(pctx->maxInput, (int) decl->Range.Last);
151 if (decl->Semantic.Name == TGSI_SEMANTIC_POSITION)
152 pctx->wincoordInput = (int) decl->Range.First;
154 else if (decl->Declaration.File == TGSI_FILE_TEMPORARY) {
156 for (i = decl->Range.First;
157 i <= decl->Range.Last; i++) {
158 pctx->tempsUsed |= (1 << i);
162 ctx->emit_declaration(ctx, decl);
167 pstip_transform_immed(struct tgsi_transform_context *ctx,
168 struct tgsi_full_immediate *immed)
170 struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
176 * Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
179 free_bit(uint bitfield)
181 return ffs(~bitfield) - 1;
186 * TGSI instruction transform callback.
187 * Replace writes to result.color w/ a temp reg.
188 * Upon END instruction, insert texture sampling code for antialiasing.
191 pstip_transform_inst(struct tgsi_transform_context *ctx,
192 struct tgsi_full_instruction *inst)
194 struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
196 if (pctx->firstInstruction) {
197 /* emit our new declarations before the first instruction */
199 struct tgsi_full_declaration decl;
200 struct tgsi_full_instruction newInst;
204 /* find free sampler */
205 pctx->freeSampler = free_bit(pctx->samplersUsed);
206 if (pctx->freeSampler >= PIPE_MAX_SAMPLERS)
207 pctx->freeSampler = PIPE_MAX_SAMPLERS - 1;
209 if (pctx->wincoordInput < 0)
210 wincoordInput = pctx->maxInput + 1;
212 wincoordInput = pctx->wincoordInput;
214 /* find one free temp reg */
215 for (i = 0; i < 32; i++) {
216 if ((pctx->tempsUsed & (1 << i)) == 0) {
217 /* found a free temp */
218 if (pctx->texTemp < 0)
224 assert(pctx->texTemp >= 0);
226 if (pctx->wincoordInput < 0) {
227 /* declare new position input reg */
228 decl = tgsi_default_full_declaration();
229 decl.Declaration.File = TGSI_FILE_INPUT;
230 decl.Declaration.Interpolate = TGSI_INTERPOLATE_LINEAR; /* XXX? */
231 decl.Declaration.Semantic = 1;
232 decl.Semantic.Name = TGSI_SEMANTIC_POSITION;
233 decl.Semantic.Index = 0;
235 decl.Range.Last = wincoordInput;
236 ctx->emit_declaration(ctx, &decl);
239 /* declare new sampler */
240 decl = tgsi_default_full_declaration();
241 decl.Declaration.File = TGSI_FILE_SAMPLER;
243 decl.Range.Last = pctx->freeSampler;
244 ctx->emit_declaration(ctx, &decl);
246 /* declare new temp regs */
247 decl = tgsi_default_full_declaration();
248 decl.Declaration.File = TGSI_FILE_TEMPORARY;
250 decl.Range.Last = pctx->texTemp;
251 ctx->emit_declaration(ctx, &decl);
253 /* emit immediate = {1/32, 1/32, 1, 1}
254 * The index/position of this immediate will be pctx->numImmed
257 static const float value[4] = { 1.0/32, 1.0/32, 1.0, 1.0 };
258 struct tgsi_full_immediate immed;
260 immed = tgsi_default_full_immediate();
261 immed.Immediate.NrTokens = 1 + size; /* one for the token itself */
262 immed.u[0].Float = value[0];
263 immed.u[1].Float = value[1];
264 immed.u[2].Float = value[2];
265 immed.u[3].Float = value[3];
266 ctx->emit_immediate(ctx, &immed);
269 pctx->firstInstruction = FALSE;
273 * Insert new MUL/TEX/KILP instructions at start of program
274 * Take gl_FragCoord, divide by 32 (stipple size), sample the
275 * texture and kill fragment if needed.
277 * We'd like to use non-normalized texcoords to index into a RECT
278 * texture, but we can only use GL_REPEAT wrap mode with normalized
282 /* MUL texTemp, INPUT[wincoord], 1/32; */
283 newInst = tgsi_default_full_instruction();
284 newInst.Instruction.Opcode = TGSI_OPCODE_MUL;
285 newInst.Instruction.NumDstRegs = 1;
286 newInst.Dst[0].Register.File = TGSI_FILE_TEMPORARY;
287 newInst.Dst[0].Register.Index = pctx->texTemp;
288 newInst.Instruction.NumSrcRegs = 2;
289 newInst.Src[0].Register.File = TGSI_FILE_INPUT;
290 newInst.Src[0].Register.Index = wincoordInput;
291 newInst.Src[1].Register.File = TGSI_FILE_IMMEDIATE;
292 newInst.Src[1].Register.Index = pctx->numImmed;
293 ctx->emit_instruction(ctx, &newInst);
295 /* TEX texTemp, texTemp, sampler; */
296 newInst = tgsi_default_full_instruction();
297 newInst.Instruction.Opcode = TGSI_OPCODE_TEX;
298 newInst.Instruction.NumDstRegs = 1;
299 newInst.Dst[0].Register.File = TGSI_FILE_TEMPORARY;
300 newInst.Dst[0].Register.Index = pctx->texTemp;
301 newInst.Instruction.NumSrcRegs = 2;
302 newInst.Instruction.Texture = TRUE;
303 newInst.Texture.Texture = TGSI_TEXTURE_2D;
304 newInst.Src[0].Register.File = TGSI_FILE_TEMPORARY;
305 newInst.Src[0].Register.Index = pctx->texTemp;
306 newInst.Src[1].Register.File = TGSI_FILE_SAMPLER;
307 newInst.Src[1].Register.Index = pctx->freeSampler;
308 ctx->emit_instruction(ctx, &newInst);
310 /* KIL -texTemp; # if -texTemp < 0, KILL fragment */
311 newInst = tgsi_default_full_instruction();
312 newInst.Instruction.Opcode = TGSI_OPCODE_KIL;
313 newInst.Instruction.NumDstRegs = 0;
314 newInst.Instruction.NumSrcRegs = 1;
315 newInst.Src[0].Register.File = TGSI_FILE_TEMPORARY;
316 newInst.Src[0].Register.Index = pctx->texTemp;
317 newInst.Src[0].Register.Negate = 1;
318 ctx->emit_instruction(ctx, &newInst);
321 /* emit this instruction */
322 ctx->emit_instruction(ctx, inst);
327 * Generate the frag shader we'll use for doing polygon stipple.
328 * This will be the user's shader prefixed with a TEX and KIL instruction.
331 generate_pstip_fs(struct pstip_stage *pstip)
333 const struct pipe_shader_state *orig_fs = &pstip->fs->state;
334 /*struct draw_context *draw = pstip->stage.draw;*/
335 struct pipe_shader_state pstip_fs;
336 struct pstip_transform_context transform;
337 const uint newLen = tgsi_num_tokens(orig_fs->tokens) + NUM_NEW_TOKENS;
339 pstip_fs = *orig_fs; /* copy to init */
340 pstip_fs.tokens = tgsi_alloc_tokens(newLen);
341 if (pstip_fs.tokens == NULL)
344 memset(&transform, 0, sizeof(transform));
345 transform.wincoordInput = -1;
346 transform.maxInput = -1;
347 transform.texTemp = -1;
348 transform.firstInstruction = TRUE;
349 transform.base.transform_instruction = pstip_transform_inst;
350 transform.base.transform_declaration = pstip_transform_decl;
351 transform.base.transform_immediate = pstip_transform_immed;
353 tgsi_transform_shader(orig_fs->tokens,
354 (struct tgsi_token *) pstip_fs.tokens,
355 newLen, &transform.base);
358 tgsi_dump(orig_fs->tokens, 0);
359 tgsi_dump(pstip_fs.tokens, 0);
362 pstip->fs->sampler_unit = transform.freeSampler;
363 assert(pstip->fs->sampler_unit < PIPE_MAX_SAMPLERS);
365 pstip->fs->pstip_fs = pstip->driver_create_fs_state(pstip->pipe, &pstip_fs);
367 FREE((void *)pstip_fs.tokens);
373 * Load texture image with current stipple pattern.
376 pstip_update_texture(struct pstip_stage *pstip)
378 static const uint bit31 = 1 << 31;
379 struct pipe_context *pipe = pstip->pipe;
380 struct pipe_transfer *transfer;
381 const uint *stipple = pstip->state.stipple->stipple;
385 /* XXX: want to avoid flushing just because we use stipple:
387 * Flush should no longer be necessary if driver is properly
388 * interleaving drawing and transfers on a given context:
390 pipe->flush( pipe, PIPE_FLUSH_TEXTURE_CACHE, NULL );
392 transfer = pipe_get_transfer(pipe, pstip->texture, 0, 0, 0,
393 PIPE_TRANSFER_WRITE, 0, 0, 32, 32);
394 data = pipe->transfer_map(pipe, transfer);
397 * Load alpha texture.
398 * Note: 0 means keep the fragment, 255 means kill it.
399 * We'll negate the texel value and use KILP which kills if value
402 for (i = 0; i < 32; i++) {
403 for (j = 0; j < 32; j++) {
404 if (stipple[i] & (bit31 >> j)) {
406 data[i * transfer->stride + j] = 0;
410 data[i * transfer->stride + j] = 255;
416 pipe->transfer_unmap(pipe, transfer);
417 pipe->transfer_destroy(pipe, transfer);
422 * Create the texture map we'll use for stippling.
425 pstip_create_texture(struct pstip_stage *pstip)
427 struct pipe_context *pipe = pstip->pipe;
428 struct pipe_screen *screen = pipe->screen;
429 struct pipe_resource texTemp;
430 struct pipe_sampler_view viewTempl;
432 memset(&texTemp, 0, sizeof(texTemp));
433 texTemp.target = PIPE_TEXTURE_2D;
434 texTemp.format = PIPE_FORMAT_A8_UNORM; /* XXX verify supported by driver! */
435 texTemp.last_level = 0;
437 texTemp.height0 = 32;
440 pstip->texture = screen->resource_create(screen, &texTemp);
441 if (pstip->texture == NULL)
444 u_sampler_view_default_template(&viewTempl,
446 pstip->texture->format);
447 pstip->sampler_view = pipe->create_sampler_view(pipe,
450 if (!pstip->sampler_view) {
459 * Create the sampler CSO that'll be used for stippling.
462 pstip_create_sampler(struct pstip_stage *pstip)
464 struct pipe_sampler_state sampler;
465 struct pipe_context *pipe = pstip->pipe;
467 memset(&sampler, 0, sizeof(sampler));
468 sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
469 sampler.wrap_t = PIPE_TEX_WRAP_REPEAT;
470 sampler.wrap_r = PIPE_TEX_WRAP_REPEAT;
471 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
472 sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
473 sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
474 sampler.normalized_coords = 1;
475 sampler.min_lod = 0.0f;
476 sampler.max_lod = 0.0f;
478 pstip->sampler_cso = pipe->create_sampler_state(pipe, &sampler);
479 if (pstip->sampler_cso == NULL)
487 * When we're about to draw our first stipple polygon in a batch, this function
488 * is called to tell the driver to bind our modified fragment shader.
491 bind_pstip_fragment_shader(struct pstip_stage *pstip)
493 struct draw_context *draw = pstip->stage.draw;
494 if (!pstip->fs->pstip_fs &&
495 !generate_pstip_fs(pstip))
498 draw->suspend_flushing = TRUE;
499 pstip->driver_bind_fs_state(pstip->pipe, pstip->fs->pstip_fs);
500 draw->suspend_flushing = FALSE;
505 static INLINE struct pstip_stage *
506 pstip_stage( struct draw_stage *stage )
508 return (struct pstip_stage *) stage;
513 pstip_first_tri(struct draw_stage *stage, struct prim_header *header)
515 struct pstip_stage *pstip = pstip_stage(stage);
516 struct pipe_context *pipe = pstip->pipe;
517 struct draw_context *draw = stage->draw;
520 assert(stage->draw->rasterizer->poly_stipple_enable);
522 /* bind our fragprog */
523 if (!bind_pstip_fragment_shader(pstip)) {
524 stage->tri = draw_pipe_passthrough_tri;
525 stage->tri(stage, header);
530 /* how many samplers? */
531 /* we'll use sampler/texture[pstip->sampler_unit] for the stipple */
532 num_samplers = MAX2(pstip->num_sampler_views, pstip->num_samplers);
533 num_samplers = MAX2(num_samplers, pstip->fs->sampler_unit + 1);
535 /* plug in our sampler, texture */
536 pstip->state.samplers[pstip->fs->sampler_unit] = pstip->sampler_cso;
537 pipe_sampler_view_reference(&pstip->state.sampler_views[pstip->fs->sampler_unit],
538 pstip->sampler_view);
540 assert(num_samplers <= PIPE_MAX_SAMPLERS);
542 draw->suspend_flushing = TRUE;
543 pstip->driver_bind_sampler_states(pipe, num_samplers, pstip->state.samplers);
544 pstip->driver_set_sampler_views(pipe, num_samplers, pstip->state.sampler_views);
545 draw->suspend_flushing = FALSE;
547 /* now really draw first triangle */
548 stage->tri = draw_pipe_passthrough_tri;
549 stage->tri(stage, header);
554 pstip_flush(struct draw_stage *stage, unsigned flags)
556 struct draw_context *draw = stage->draw;
557 struct pstip_stage *pstip = pstip_stage(stage);
558 struct pipe_context *pipe = pstip->pipe;
560 stage->tri = pstip_first_tri;
561 stage->next->flush( stage->next, flags );
563 /* restore original frag shader, texture, sampler state */
564 draw->suspend_flushing = TRUE;
565 pstip->driver_bind_fs_state(pipe, pstip->fs->driver_fs);
566 pstip->driver_bind_sampler_states(pipe, pstip->num_samplers,
567 pstip->state.samplers);
568 pstip->driver_set_sampler_views(pipe,
569 pstip->num_sampler_views,
570 pstip->state.sampler_views);
571 draw->suspend_flushing = FALSE;
576 pstip_reset_stipple_counter(struct draw_stage *stage)
578 stage->next->reset_stipple_counter( stage->next );
583 pstip_destroy(struct draw_stage *stage)
585 struct pstip_stage *pstip = pstip_stage(stage);
588 for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
589 pipe_sampler_view_reference(&pstip->state.sampler_views[i], NULL);
592 pstip->pipe->delete_sampler_state(pstip->pipe, pstip->sampler_cso);
594 pipe_resource_reference(&pstip->texture, NULL);
596 if (pstip->sampler_view) {
597 pipe_sampler_view_reference(&pstip->sampler_view, NULL);
600 draw_free_temp_verts( stage );
605 static struct pstip_stage *
606 draw_pstip_stage(struct draw_context *draw)
608 struct pstip_stage *pstip = CALLOC_STRUCT(pstip_stage);
610 draw_alloc_temp_verts( &pstip->stage, 8 );
612 pstip->stage.draw = draw;
613 pstip->stage.name = "pstip";
614 pstip->stage.next = NULL;
615 pstip->stage.point = draw_pipe_passthrough_point;
616 pstip->stage.line = draw_pipe_passthrough_line;
617 pstip->stage.tri = pstip_first_tri;
618 pstip->stage.flush = pstip_flush;
619 pstip->stage.reset_stipple_counter = pstip_reset_stipple_counter;
620 pstip->stage.destroy = pstip_destroy;
626 static struct pstip_stage *
627 pstip_stage_from_pipe(struct pipe_context *pipe)
629 struct draw_context *draw = (struct draw_context *) pipe->draw;
630 return pstip_stage(draw->pipeline.pstipple);
635 * This function overrides the driver's create_fs_state() function and
636 * will typically be called by the state tracker.
639 pstip_create_fs_state(struct pipe_context *pipe,
640 const struct pipe_shader_state *fs)
642 struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
643 struct pstip_fragment_shader *aafs = CALLOC_STRUCT(pstip_fragment_shader);
649 aafs->driver_fs = pstip->driver_create_fs_state(pstip->pipe, fs);
657 pstip_bind_fs_state(struct pipe_context *pipe, void *fs)
659 struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
660 struct pstip_fragment_shader *aafs = (struct pstip_fragment_shader *) fs;
664 pstip->driver_bind_fs_state(pstip->pipe,
665 (aafs ? aafs->driver_fs : NULL));
670 pstip_delete_fs_state(struct pipe_context *pipe, void *fs)
672 struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
673 struct pstip_fragment_shader *aafs = (struct pstip_fragment_shader *) fs;
675 pstip->driver_delete_fs_state(pstip->pipe, aafs->driver_fs);
678 pstip->driver_delete_fs_state(pstip->pipe, aafs->pstip_fs);
685 pstip_bind_sampler_states(struct pipe_context *pipe,
686 unsigned num, void **sampler)
688 struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
692 memcpy(pstip->state.samplers, sampler, num * sizeof(void *));
693 for (i = num; i < PIPE_MAX_SAMPLERS; i++) {
694 pstip->state.samplers[i] = NULL;
697 pstip->num_samplers = num;
699 pstip->driver_bind_sampler_states(pstip->pipe, num, sampler);
704 pstip_set_sampler_views(struct pipe_context *pipe,
706 struct pipe_sampler_view **views)
708 struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
712 for (i = 0; i < num; i++) {
713 pipe_sampler_view_reference(&pstip->state.sampler_views[i], views[i]);
715 for (; i < PIPE_MAX_SAMPLERS; i++) {
716 pipe_sampler_view_reference(&pstip->state.sampler_views[i], NULL);
719 pstip->num_sampler_views = num;
722 pstip->driver_set_sampler_views(pstip->pipe, num, views);
727 pstip_set_polygon_stipple(struct pipe_context *pipe,
728 const struct pipe_poly_stipple *stipple)
730 struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
733 pstip->state.stipple = stipple;
736 pstip->driver_set_polygon_stipple(pstip->pipe, stipple);
738 pstip_update_texture(pstip);
743 * Called by drivers that want to install this polygon stipple stage
744 * into the draw module's pipeline. This will not be used if the
745 * hardware has native support for polygon stipple.
748 draw_install_pstipple_stage(struct draw_context *draw,
749 struct pipe_context *pipe)
751 struct pstip_stage *pstip;
753 pipe->draw = (void *) draw;
756 * Create / install pgon stipple drawing / prim stage
758 pstip = draw_pstip_stage( draw );
762 draw->pipeline.pstipple = &pstip->stage;
766 /* create special texture, sampler state */
767 if (!pstip_create_texture(pstip))
770 if (!pstip_create_sampler(pstip))
773 /* save original driver functions */
774 pstip->driver_create_fs_state = pipe->create_fs_state;
775 pstip->driver_bind_fs_state = pipe->bind_fs_state;
776 pstip->driver_delete_fs_state = pipe->delete_fs_state;
778 pstip->driver_bind_sampler_states = pipe->bind_fragment_sampler_states;
779 pstip->driver_set_sampler_views = pipe->set_fragment_sampler_views;
780 pstip->driver_set_polygon_stipple = pipe->set_polygon_stipple;
782 /* override the driver's functions */
783 pipe->create_fs_state = pstip_create_fs_state;
784 pipe->bind_fs_state = pstip_bind_fs_state;
785 pipe->delete_fs_state = pstip_delete_fs_state;
787 pipe->bind_fragment_sampler_states = pstip_bind_sampler_states;
788 pipe->set_fragment_sampler_views = pstip_set_sampler_views;
789 pipe->set_polygon_stipple = pstip_set_polygon_stipple;
795 pstip->stage.destroy( &pstip->stage );