forked from KolibriOS/kolibrios
816 lines
24 KiB
C
816 lines
24 KiB
C
/**************************************************************************
|
|
*
|
|
* Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
**************************************************************************/
|
|
|
|
/**
|
|
* Polygon stipple stage: implement polygon stipple with texture map and
|
|
* fragment program. The fragment program samples the texture using the
|
|
* fragment window coordinate register and does a fragment kill for the
|
|
* stipple-failing fragments.
|
|
*
|
|
* Authors: Brian Paul
|
|
*/
|
|
|
|
|
|
#include "pipe/p_context.h"
|
|
#include "pipe/p_defines.h"
|
|
#include "pipe/p_shader_tokens.h"
|
|
#include "util/u_inlines.h"
|
|
|
|
#include "util/u_format.h"
|
|
#include "util/u_math.h"
|
|
#include "util/u_memory.h"
|
|
#include "util/u_sampler.h"
|
|
|
|
#include "tgsi/tgsi_transform.h"
|
|
#include "tgsi/tgsi_dump.h"
|
|
|
|
#include "draw_context.h"
|
|
#include "draw_pipe.h"
|
|
|
|
|
|
/** Approx number of new tokens for instructions in pstip_transform_inst() */
|
|
#define NUM_NEW_TOKENS 50
|
|
|
|
|
|
/**
|
|
* Subclass of pipe_shader_state to carry extra fragment shader info.
|
|
*/
|
|
struct pstip_fragment_shader
|
|
{
|
|
struct pipe_shader_state state;
|
|
void *driver_fs;
|
|
void *pstip_fs;
|
|
uint sampler_unit;
|
|
};
|
|
|
|
|
|
/**
|
|
* Subclass of draw_stage
|
|
*/
|
|
struct pstip_stage
|
|
{
|
|
struct draw_stage stage;
|
|
|
|
void *sampler_cso;
|
|
struct pipe_resource *texture;
|
|
struct pipe_sampler_view *sampler_view;
|
|
uint num_samplers;
|
|
uint num_sampler_views;
|
|
|
|
/*
|
|
* Currently bound state
|
|
*/
|
|
struct pstip_fragment_shader *fs;
|
|
struct {
|
|
void *samplers[PIPE_MAX_SAMPLERS];
|
|
struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
|
|
const struct pipe_poly_stipple *stipple;
|
|
} state;
|
|
|
|
/*
|
|
* Driver interface/override functions
|
|
*/
|
|
void * (*driver_create_fs_state)(struct pipe_context *,
|
|
const struct pipe_shader_state *);
|
|
void (*driver_bind_fs_state)(struct pipe_context *, void *);
|
|
void (*driver_delete_fs_state)(struct pipe_context *, void *);
|
|
|
|
void (*driver_bind_sampler_states)(struct pipe_context *, unsigned, void **);
|
|
|
|
void (*driver_set_sampler_views)(struct pipe_context *,
|
|
unsigned,
|
|
struct pipe_sampler_view **);
|
|
|
|
void (*driver_set_polygon_stipple)(struct pipe_context *,
|
|
const struct pipe_poly_stipple *);
|
|
|
|
struct pipe_context *pipe;
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Subclass of tgsi_transform_context, used for transforming the
|
|
* user's fragment shader to add the extra texture sample and fragment kill
|
|
* instructions.
|
|
*/
|
|
struct pstip_transform_context {
|
|
struct tgsi_transform_context base;
|
|
uint tempsUsed; /**< bitmask */
|
|
int wincoordInput;
|
|
int maxInput;
|
|
uint samplersUsed; /**< bitfield of samplers used */
|
|
int freeSampler; /** an available sampler for the pstipple */
|
|
int texTemp; /**< temp registers */
|
|
int numImmed;
|
|
boolean firstInstruction;
|
|
};
|
|
|
|
|
|
/**
|
|
* TGSI declaration transform callback.
|
|
* Look for a free sampler, a free input attrib, and two free temp regs.
|
|
*/
|
|
static void
|
|
pstip_transform_decl(struct tgsi_transform_context *ctx,
|
|
struct tgsi_full_declaration *decl)
|
|
{
|
|
struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
|
|
|
|
if (decl->Declaration.File == TGSI_FILE_SAMPLER) {
|
|
uint i;
|
|
for (i = decl->Range.First;
|
|
i <= decl->Range.Last; i++) {
|
|
pctx->samplersUsed |= 1 << i;
|
|
}
|
|
}
|
|
else if (decl->Declaration.File == TGSI_FILE_INPUT) {
|
|
pctx->maxInput = MAX2(pctx->maxInput, (int) decl->Range.Last);
|
|
if (decl->Semantic.Name == TGSI_SEMANTIC_POSITION)
|
|
pctx->wincoordInput = (int) decl->Range.First;
|
|
}
|
|
else if (decl->Declaration.File == TGSI_FILE_TEMPORARY) {
|
|
uint i;
|
|
for (i = decl->Range.First;
|
|
i <= decl->Range.Last; i++) {
|
|
pctx->tempsUsed |= (1 << i);
|
|
}
|
|
}
|
|
|
|
ctx->emit_declaration(ctx, decl);
|
|
}
|
|
|
|
|
|
/**
|
|
* TGSI immediate declaration transform callback.
|
|
* We're just counting the number of immediates here.
|
|
*/
|
|
static void
|
|
pstip_transform_immed(struct tgsi_transform_context *ctx,
|
|
struct tgsi_full_immediate *immed)
|
|
{
|
|
struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
|
|
ctx->emit_immediate(ctx, immed); /* emit to output shader */
|
|
pctx->numImmed++;
|
|
}
|
|
|
|
|
|
/**
|
|
* Find the lowest zero bit in the given word, or -1 if bitfield is all ones.
|
|
*/
|
|
static int
|
|
free_bit(uint bitfield)
|
|
{
|
|
return ffs(~bitfield) - 1;
|
|
}
|
|
|
|
|
|
/**
|
|
* TGSI instruction transform callback.
|
|
* Replace writes to result.color w/ a temp reg.
|
|
* Upon END instruction, insert texture sampling code for antialiasing.
|
|
*/
|
|
static void
|
|
pstip_transform_inst(struct tgsi_transform_context *ctx,
|
|
struct tgsi_full_instruction *inst)
|
|
{
|
|
struct pstip_transform_context *pctx = (struct pstip_transform_context *) ctx;
|
|
|
|
if (pctx->firstInstruction) {
|
|
/* emit our new declarations before the first instruction */
|
|
|
|
struct tgsi_full_declaration decl;
|
|
struct tgsi_full_instruction newInst;
|
|
uint i;
|
|
int wincoordInput;
|
|
|
|
/* find free sampler */
|
|
pctx->freeSampler = free_bit(pctx->samplersUsed);
|
|
if (pctx->freeSampler >= PIPE_MAX_SAMPLERS)
|
|
pctx->freeSampler = PIPE_MAX_SAMPLERS - 1;
|
|
|
|
if (pctx->wincoordInput < 0)
|
|
wincoordInput = pctx->maxInput + 1;
|
|
else
|
|
wincoordInput = pctx->wincoordInput;
|
|
|
|
/* find one free temp reg */
|
|
for (i = 0; i < 32; i++) {
|
|
if ((pctx->tempsUsed & (1 << i)) == 0) {
|
|
/* found a free temp */
|
|
if (pctx->texTemp < 0)
|
|
pctx->texTemp = i;
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
assert(pctx->texTemp >= 0);
|
|
|
|
if (pctx->wincoordInput < 0) {
|
|
/* declare new position input reg */
|
|
decl = tgsi_default_full_declaration();
|
|
decl.Declaration.File = TGSI_FILE_INPUT;
|
|
decl.Declaration.Interpolate = 1;
|
|
decl.Declaration.Semantic = 1;
|
|
decl.Semantic.Name = TGSI_SEMANTIC_POSITION;
|
|
decl.Semantic.Index = 0;
|
|
decl.Range.First =
|
|
decl.Range.Last = wincoordInput;
|
|
decl.Interp.Interpolate = TGSI_INTERPOLATE_LINEAR; /* XXX? */
|
|
ctx->emit_declaration(ctx, &decl);
|
|
}
|
|
|
|
/* declare new sampler */
|
|
decl = tgsi_default_full_declaration();
|
|
decl.Declaration.File = TGSI_FILE_SAMPLER;
|
|
decl.Range.First =
|
|
decl.Range.Last = pctx->freeSampler;
|
|
ctx->emit_declaration(ctx, &decl);
|
|
|
|
/* declare new temp regs */
|
|
decl = tgsi_default_full_declaration();
|
|
decl.Declaration.File = TGSI_FILE_TEMPORARY;
|
|
decl.Range.First =
|
|
decl.Range.Last = pctx->texTemp;
|
|
ctx->emit_declaration(ctx, &decl);
|
|
|
|
/* emit immediate = {1/32, 1/32, 1, 1}
|
|
* The index/position of this immediate will be pctx->numImmed
|
|
*/
|
|
{
|
|
static const float value[4] = { 1.0/32, 1.0/32, 1.0, 1.0 };
|
|
struct tgsi_full_immediate immed;
|
|
uint size = 4;
|
|
immed = tgsi_default_full_immediate();
|
|
immed.Immediate.NrTokens = 1 + size; /* one for the token itself */
|
|
immed.u[0].Float = value[0];
|
|
immed.u[1].Float = value[1];
|
|
immed.u[2].Float = value[2];
|
|
immed.u[3].Float = value[3];
|
|
ctx->emit_immediate(ctx, &immed);
|
|
}
|
|
|
|
pctx->firstInstruction = FALSE;
|
|
|
|
|
|
/*
|
|
* Insert new MUL/TEX/KILP instructions at start of program
|
|
* Take gl_FragCoord, divide by 32 (stipple size), sample the
|
|
* texture and kill fragment if needed.
|
|
*
|
|
* We'd like to use non-normalized texcoords to index into a RECT
|
|
* texture, but we can only use GL_REPEAT wrap mode with normalized
|
|
* texcoords. Darn.
|
|
*/
|
|
|
|
/* MUL texTemp, INPUT[wincoord], 1/32; */
|
|
newInst = tgsi_default_full_instruction();
|
|
newInst.Instruction.Opcode = TGSI_OPCODE_MUL;
|
|
newInst.Instruction.NumDstRegs = 1;
|
|
newInst.Dst[0].Register.File = TGSI_FILE_TEMPORARY;
|
|
newInst.Dst[0].Register.Index = pctx->texTemp;
|
|
newInst.Instruction.NumSrcRegs = 2;
|
|
newInst.Src[0].Register.File = TGSI_FILE_INPUT;
|
|
newInst.Src[0].Register.Index = wincoordInput;
|
|
newInst.Src[1].Register.File = TGSI_FILE_IMMEDIATE;
|
|
newInst.Src[1].Register.Index = pctx->numImmed;
|
|
ctx->emit_instruction(ctx, &newInst);
|
|
|
|
/* TEX texTemp, texTemp, sampler; */
|
|
newInst = tgsi_default_full_instruction();
|
|
newInst.Instruction.Opcode = TGSI_OPCODE_TEX;
|
|
newInst.Instruction.NumDstRegs = 1;
|
|
newInst.Dst[0].Register.File = TGSI_FILE_TEMPORARY;
|
|
newInst.Dst[0].Register.Index = pctx->texTemp;
|
|
newInst.Instruction.NumSrcRegs = 2;
|
|
newInst.Instruction.Texture = TRUE;
|
|
newInst.Texture.Texture = TGSI_TEXTURE_2D;
|
|
newInst.Src[0].Register.File = TGSI_FILE_TEMPORARY;
|
|
newInst.Src[0].Register.Index = pctx->texTemp;
|
|
newInst.Src[1].Register.File = TGSI_FILE_SAMPLER;
|
|
newInst.Src[1].Register.Index = pctx->freeSampler;
|
|
ctx->emit_instruction(ctx, &newInst);
|
|
|
|
/* KIL -texTemp; # if -texTemp < 0, KILL fragment */
|
|
newInst = tgsi_default_full_instruction();
|
|
newInst.Instruction.Opcode = TGSI_OPCODE_KIL;
|
|
newInst.Instruction.NumDstRegs = 0;
|
|
newInst.Instruction.NumSrcRegs = 1;
|
|
newInst.Src[0].Register.File = TGSI_FILE_TEMPORARY;
|
|
newInst.Src[0].Register.Index = pctx->texTemp;
|
|
newInst.Src[0].Register.Negate = 1;
|
|
ctx->emit_instruction(ctx, &newInst);
|
|
}
|
|
|
|
/* emit this instruction */
|
|
ctx->emit_instruction(ctx, inst);
|
|
}
|
|
|
|
|
|
/**
|
|
* Generate the frag shader we'll use for doing polygon stipple.
|
|
* This will be the user's shader prefixed with a TEX and KIL instruction.
|
|
*/
|
|
static boolean
|
|
generate_pstip_fs(struct pstip_stage *pstip)
|
|
{
|
|
const struct pipe_shader_state *orig_fs = &pstip->fs->state;
|
|
/*struct draw_context *draw = pstip->stage.draw;*/
|
|
struct pipe_shader_state pstip_fs;
|
|
struct pstip_transform_context transform;
|
|
const uint newLen = tgsi_num_tokens(orig_fs->tokens) + NUM_NEW_TOKENS;
|
|
|
|
pstip_fs = *orig_fs; /* copy to init */
|
|
pstip_fs.tokens = tgsi_alloc_tokens(newLen);
|
|
if (pstip_fs.tokens == NULL)
|
|
return FALSE;
|
|
|
|
memset(&transform, 0, sizeof(transform));
|
|
transform.wincoordInput = -1;
|
|
transform.maxInput = -1;
|
|
transform.texTemp = -1;
|
|
transform.firstInstruction = TRUE;
|
|
transform.base.transform_instruction = pstip_transform_inst;
|
|
transform.base.transform_declaration = pstip_transform_decl;
|
|
transform.base.transform_immediate = pstip_transform_immed;
|
|
|
|
tgsi_transform_shader(orig_fs->tokens,
|
|
(struct tgsi_token *) pstip_fs.tokens,
|
|
newLen, &transform.base);
|
|
|
|
#if 0 /* DEBUG */
|
|
tgsi_dump(orig_fs->tokens, 0);
|
|
tgsi_dump(pstip_fs.tokens, 0);
|
|
#endif
|
|
|
|
assert(pstip->fs);
|
|
|
|
pstip->fs->sampler_unit = transform.freeSampler;
|
|
assert(pstip->fs->sampler_unit < PIPE_MAX_SAMPLERS);
|
|
|
|
pstip->fs->pstip_fs = pstip->driver_create_fs_state(pstip->pipe, &pstip_fs);
|
|
|
|
FREE((void *)pstip_fs.tokens);
|
|
|
|
if (!pstip->fs->pstip_fs)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
* Load texture image with current stipple pattern.
|
|
*/
|
|
static void
|
|
pstip_update_texture(struct pstip_stage *pstip)
|
|
{
|
|
static const uint bit31 = 1 << 31;
|
|
struct pipe_context *pipe = pstip->pipe;
|
|
struct pipe_transfer *transfer;
|
|
const uint *stipple = pstip->state.stipple->stipple;
|
|
uint i, j;
|
|
ubyte *data;
|
|
|
|
data = pipe_transfer_map(pipe, pstip->texture, 0, 0,
|
|
PIPE_TRANSFER_WRITE, 0, 0, 32, 32, &transfer);
|
|
|
|
/*
|
|
* Load alpha texture.
|
|
* Note: 0 means keep the fragment, 255 means kill it.
|
|
* We'll negate the texel value and use KILP which kills if value
|
|
* is negative.
|
|
*/
|
|
for (i = 0; i < 32; i++) {
|
|
for (j = 0; j < 32; j++) {
|
|
if (stipple[i] & (bit31 >> j)) {
|
|
/* fragment "on" */
|
|
data[i * transfer->stride + j] = 0;
|
|
}
|
|
else {
|
|
/* fragment "off" */
|
|
data[i * transfer->stride + j] = 255;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* unmap */
|
|
pipe_transfer_unmap(pipe, transfer);
|
|
}
|
|
|
|
|
|
/**
|
|
* Create the texture map we'll use for stippling.
|
|
*/
|
|
static boolean
|
|
pstip_create_texture(struct pstip_stage *pstip)
|
|
{
|
|
struct pipe_context *pipe = pstip->pipe;
|
|
struct pipe_screen *screen = pipe->screen;
|
|
struct pipe_resource texTemp;
|
|
struct pipe_sampler_view viewTempl;
|
|
|
|
memset(&texTemp, 0, sizeof(texTemp));
|
|
texTemp.target = PIPE_TEXTURE_2D;
|
|
texTemp.format = PIPE_FORMAT_A8_UNORM; /* XXX verify supported by driver! */
|
|
texTemp.last_level = 0;
|
|
texTemp.width0 = 32;
|
|
texTemp.height0 = 32;
|
|
texTemp.depth0 = 1;
|
|
texTemp.array_size = 1;
|
|
texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
|
|
|
|
pstip->texture = screen->resource_create(screen, &texTemp);
|
|
if (pstip->texture == NULL)
|
|
return FALSE;
|
|
|
|
u_sampler_view_default_template(&viewTempl,
|
|
pstip->texture,
|
|
pstip->texture->format);
|
|
pstip->sampler_view = pipe->create_sampler_view(pipe,
|
|
pstip->texture,
|
|
&viewTempl);
|
|
if (!pstip->sampler_view) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
* Create the sampler CSO that'll be used for stippling.
|
|
*/
|
|
static boolean
|
|
pstip_create_sampler(struct pstip_stage *pstip)
|
|
{
|
|
struct pipe_sampler_state sampler;
|
|
struct pipe_context *pipe = pstip->pipe;
|
|
|
|
memset(&sampler, 0, sizeof(sampler));
|
|
sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
|
|
sampler.wrap_t = PIPE_TEX_WRAP_REPEAT;
|
|
sampler.wrap_r = PIPE_TEX_WRAP_REPEAT;
|
|
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
|
|
sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
|
|
sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
|
|
sampler.normalized_coords = 1;
|
|
sampler.min_lod = 0.0f;
|
|
sampler.max_lod = 0.0f;
|
|
|
|
pstip->sampler_cso = pipe->create_sampler_state(pipe, &sampler);
|
|
if (pstip->sampler_cso == NULL)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
* When we're about to draw our first stipple polygon in a batch, this function
|
|
* is called to tell the driver to bind our modified fragment shader.
|
|
*/
|
|
static boolean
|
|
bind_pstip_fragment_shader(struct pstip_stage *pstip)
|
|
{
|
|
struct draw_context *draw = pstip->stage.draw;
|
|
if (!pstip->fs->pstip_fs &&
|
|
!generate_pstip_fs(pstip))
|
|
return FALSE;
|
|
|
|
draw->suspend_flushing = TRUE;
|
|
pstip->driver_bind_fs_state(pstip->pipe, pstip->fs->pstip_fs);
|
|
draw->suspend_flushing = FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static INLINE struct pstip_stage *
|
|
pstip_stage( struct draw_stage *stage )
|
|
{
|
|
return (struct pstip_stage *) stage;
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_first_tri(struct draw_stage *stage, struct prim_header *header)
|
|
{
|
|
struct pstip_stage *pstip = pstip_stage(stage);
|
|
struct pipe_context *pipe = pstip->pipe;
|
|
struct draw_context *draw = stage->draw;
|
|
uint num_samplers;
|
|
|
|
assert(stage->draw->rasterizer->poly_stipple_enable);
|
|
|
|
/* bind our fragprog */
|
|
if (!bind_pstip_fragment_shader(pstip)) {
|
|
stage->tri = draw_pipe_passthrough_tri;
|
|
stage->tri(stage, header);
|
|
return;
|
|
}
|
|
|
|
|
|
/* how many samplers? */
|
|
/* we'll use sampler/texture[pstip->sampler_unit] for the stipple */
|
|
num_samplers = MAX2(pstip->num_sampler_views, pstip->num_samplers);
|
|
num_samplers = MAX2(num_samplers, pstip->fs->sampler_unit + 1);
|
|
|
|
/* plug in our sampler, texture */
|
|
pstip->state.samplers[pstip->fs->sampler_unit] = pstip->sampler_cso;
|
|
pipe_sampler_view_reference(&pstip->state.sampler_views[pstip->fs->sampler_unit],
|
|
pstip->sampler_view);
|
|
|
|
assert(num_samplers <= PIPE_MAX_SAMPLERS);
|
|
|
|
draw->suspend_flushing = TRUE;
|
|
pstip->driver_bind_sampler_states(pipe, num_samplers, pstip->state.samplers);
|
|
pstip->driver_set_sampler_views(pipe, num_samplers, pstip->state.sampler_views);
|
|
draw->suspend_flushing = FALSE;
|
|
|
|
/* now really draw first triangle */
|
|
stage->tri = draw_pipe_passthrough_tri;
|
|
stage->tri(stage, header);
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_flush(struct draw_stage *stage, unsigned flags)
|
|
{
|
|
struct draw_context *draw = stage->draw;
|
|
struct pstip_stage *pstip = pstip_stage(stage);
|
|
struct pipe_context *pipe = pstip->pipe;
|
|
|
|
stage->tri = pstip_first_tri;
|
|
stage->next->flush( stage->next, flags );
|
|
|
|
/* restore original frag shader, texture, sampler state */
|
|
draw->suspend_flushing = TRUE;
|
|
pstip->driver_bind_fs_state(pipe, pstip->fs ? pstip->fs->driver_fs : NULL);
|
|
pstip->driver_bind_sampler_states(pipe, pstip->num_samplers,
|
|
pstip->state.samplers);
|
|
pstip->driver_set_sampler_views(pipe,
|
|
pstip->num_sampler_views,
|
|
pstip->state.sampler_views);
|
|
draw->suspend_flushing = FALSE;
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_reset_stipple_counter(struct draw_stage *stage)
|
|
{
|
|
stage->next->reset_stipple_counter( stage->next );
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_destroy(struct draw_stage *stage)
|
|
{
|
|
struct pstip_stage *pstip = pstip_stage(stage);
|
|
uint i;
|
|
|
|
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
|
|
pipe_sampler_view_reference(&pstip->state.sampler_views[i], NULL);
|
|
}
|
|
|
|
pstip->pipe->delete_sampler_state(pstip->pipe, pstip->sampler_cso);
|
|
|
|
pipe_resource_reference(&pstip->texture, NULL);
|
|
|
|
if (pstip->sampler_view) {
|
|
pipe_sampler_view_reference(&pstip->sampler_view, NULL);
|
|
}
|
|
|
|
draw_free_temp_verts( stage );
|
|
FREE( stage );
|
|
}
|
|
|
|
|
|
/** Create a new polygon stipple drawing stage object */
|
|
static struct pstip_stage *
|
|
draw_pstip_stage(struct draw_context *draw, struct pipe_context *pipe)
|
|
{
|
|
struct pstip_stage *pstip = CALLOC_STRUCT(pstip_stage);
|
|
if (pstip == NULL)
|
|
goto fail;
|
|
|
|
pstip->pipe = pipe;
|
|
|
|
pstip->stage.draw = draw;
|
|
pstip->stage.name = "pstip";
|
|
pstip->stage.next = NULL;
|
|
pstip->stage.point = draw_pipe_passthrough_point;
|
|
pstip->stage.line = draw_pipe_passthrough_line;
|
|
pstip->stage.tri = pstip_first_tri;
|
|
pstip->stage.flush = pstip_flush;
|
|
pstip->stage.reset_stipple_counter = pstip_reset_stipple_counter;
|
|
pstip->stage.destroy = pstip_destroy;
|
|
|
|
if (!draw_alloc_temp_verts( &pstip->stage, 8 ))
|
|
goto fail;
|
|
|
|
return pstip;
|
|
|
|
fail:
|
|
if (pstip)
|
|
pstip->stage.destroy( &pstip->stage );
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static struct pstip_stage *
|
|
pstip_stage_from_pipe(struct pipe_context *pipe)
|
|
{
|
|
struct draw_context *draw = (struct draw_context *) pipe->draw;
|
|
return pstip_stage(draw->pipeline.pstipple);
|
|
}
|
|
|
|
|
|
/**
|
|
* This function overrides the driver's create_fs_state() function and
|
|
* will typically be called by the state tracker.
|
|
*/
|
|
static void *
|
|
pstip_create_fs_state(struct pipe_context *pipe,
|
|
const struct pipe_shader_state *fs)
|
|
{
|
|
struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
|
|
struct pstip_fragment_shader *pstipfs = CALLOC_STRUCT(pstip_fragment_shader);
|
|
|
|
if (pstipfs) {
|
|
pstipfs->state = *fs;
|
|
|
|
/* pass-through */
|
|
pstipfs->driver_fs = pstip->driver_create_fs_state(pstip->pipe, fs);
|
|
}
|
|
|
|
return pstipfs;
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_bind_fs_state(struct pipe_context *pipe, void *fs)
|
|
{
|
|
struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
|
|
struct pstip_fragment_shader *pstipfs = (struct pstip_fragment_shader *) fs;
|
|
/* save current */
|
|
pstip->fs = pstipfs;
|
|
/* pass-through */
|
|
pstip->driver_bind_fs_state(pstip->pipe,
|
|
(pstipfs ? pstipfs->driver_fs : NULL));
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_delete_fs_state(struct pipe_context *pipe, void *fs)
|
|
{
|
|
struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
|
|
struct pstip_fragment_shader *pstipfs = (struct pstip_fragment_shader *) fs;
|
|
/* pass-through */
|
|
pstip->driver_delete_fs_state(pstip->pipe, pstipfs->driver_fs);
|
|
|
|
if (pstipfs->pstip_fs)
|
|
pstip->driver_delete_fs_state(pstip->pipe, pstipfs->pstip_fs);
|
|
|
|
FREE(pstipfs);
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_bind_sampler_states(struct pipe_context *pipe,
|
|
unsigned num, void **sampler)
|
|
{
|
|
struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
|
|
uint i;
|
|
|
|
/* save current */
|
|
memcpy(pstip->state.samplers, sampler, num * sizeof(void *));
|
|
for (i = num; i < PIPE_MAX_SAMPLERS; i++) {
|
|
pstip->state.samplers[i] = NULL;
|
|
}
|
|
|
|
pstip->num_samplers = num;
|
|
/* pass-through */
|
|
pstip->driver_bind_sampler_states(pstip->pipe, num, sampler);
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_set_sampler_views(struct pipe_context *pipe,
|
|
unsigned num,
|
|
struct pipe_sampler_view **views)
|
|
{
|
|
struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
|
|
uint i;
|
|
|
|
/* save current */
|
|
for (i = 0; i < num; i++) {
|
|
pipe_sampler_view_reference(&pstip->state.sampler_views[i], views[i]);
|
|
}
|
|
for (; i < PIPE_MAX_SAMPLERS; i++) {
|
|
pipe_sampler_view_reference(&pstip->state.sampler_views[i], NULL);
|
|
}
|
|
|
|
pstip->num_sampler_views = num;
|
|
|
|
/* pass-through */
|
|
pstip->driver_set_sampler_views(pstip->pipe, num, views);
|
|
}
|
|
|
|
|
|
static void
|
|
pstip_set_polygon_stipple(struct pipe_context *pipe,
|
|
const struct pipe_poly_stipple *stipple)
|
|
{
|
|
struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
|
|
|
|
/* save current */
|
|
pstip->state.stipple = stipple;
|
|
|
|
/* pass-through */
|
|
pstip->driver_set_polygon_stipple(pstip->pipe, stipple);
|
|
|
|
pstip_update_texture(pstip);
|
|
}
|
|
|
|
|
|
/**
|
|
* Called by drivers that want to install this polygon stipple stage
|
|
* into the draw module's pipeline. This will not be used if the
|
|
* hardware has native support for polygon stipple.
|
|
*/
|
|
boolean
|
|
draw_install_pstipple_stage(struct draw_context *draw,
|
|
struct pipe_context *pipe)
|
|
{
|
|
struct pstip_stage *pstip;
|
|
|
|
pipe->draw = (void *) draw;
|
|
|
|
/*
|
|
* Create / install pgon stipple drawing / prim stage
|
|
*/
|
|
pstip = draw_pstip_stage( draw, pipe );
|
|
if (pstip == NULL)
|
|
goto fail;
|
|
|
|
draw->pipeline.pstipple = &pstip->stage;
|
|
|
|
/* create special texture, sampler state */
|
|
if (!pstip_create_texture(pstip))
|
|
goto fail;
|
|
|
|
if (!pstip_create_sampler(pstip))
|
|
goto fail;
|
|
|
|
/* save original driver functions */
|
|
pstip->driver_create_fs_state = pipe->create_fs_state;
|
|
pstip->driver_bind_fs_state = pipe->bind_fs_state;
|
|
pstip->driver_delete_fs_state = pipe->delete_fs_state;
|
|
|
|
pstip->driver_bind_sampler_states = pipe->bind_fragment_sampler_states;
|
|
pstip->driver_set_sampler_views = pipe->set_fragment_sampler_views;
|
|
pstip->driver_set_polygon_stipple = pipe->set_polygon_stipple;
|
|
|
|
/* override the driver's functions */
|
|
pipe->create_fs_state = pstip_create_fs_state;
|
|
pipe->bind_fs_state = pstip_bind_fs_state;
|
|
pipe->delete_fs_state = pstip_delete_fs_state;
|
|
|
|
pipe->bind_fragment_sampler_states = pstip_bind_sampler_states;
|
|
pipe->set_fragment_sampler_views = pstip_set_sampler_views;
|
|
pipe->set_polygon_stipple = pstip_set_polygon_stipple;
|
|
|
|
return TRUE;
|
|
|
|
fail:
|
|
if (pstip)
|
|
pstip->stage.destroy( &pstip->stage );
|
|
|
|
return FALSE;
|
|
}
|