457 lines
14 KiB
C
457 lines
14 KiB
C
/**************************************************************************
|
|
*
|
|
* Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
|
* Copyright 2010 VMware, Inc.
|
|
* 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 helper module. Drivers/GPUs which don't support polygon
|
|
* stipple natively can use this module to simulate it.
|
|
*
|
|
* Basically, modify fragment shader to sample the 32x32 stipple pattern
|
|
* texture and do a fragment kill for the 'off' bits.
|
|
*
|
|
* This was originally a 'draw' module stage, but since we don't need
|
|
* vertex window coords or anything, it can be a stand-alone utility module.
|
|
*
|
|
* 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_memory.h"
|
|
#include "util/u_pstipple.h"
|
|
#include "util/u_sampler.h"
|
|
|
|
#include "tgsi/tgsi_transform.h"
|
|
#include "tgsi/tgsi_dump.h"
|
|
#include "tgsi/tgsi_scan.h"
|
|
|
|
/** Approx number of new tokens for instructions in pstip_transform_inst() */
|
|
#define NUM_NEW_TOKENS 50
|
|
|
|
|
|
static void
|
|
util_pstipple_update_stipple_texture(struct pipe_context *pipe,
|
|
struct pipe_resource *tex,
|
|
const uint32_t pattern[32])
|
|
{
|
|
static const uint bit31 = 1 << 31;
|
|
struct pipe_transfer *transfer;
|
|
ubyte *data;
|
|
int i, j;
|
|
|
|
/* map texture memory */
|
|
data = pipe_transfer_map(pipe, tex, 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 (pattern[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 a 32x32 alpha8 texture that encodes the given stipple pattern.
|
|
*/
|
|
struct pipe_resource *
|
|
util_pstipple_create_stipple_texture(struct pipe_context *pipe,
|
|
const uint32_t pattern[32])
|
|
{
|
|
struct pipe_screen *screen = pipe->screen;
|
|
struct pipe_resource templat, *tex;
|
|
|
|
memset(&templat, 0, sizeof(templat));
|
|
templat.target = PIPE_TEXTURE_2D;
|
|
templat.format = PIPE_FORMAT_A8_UNORM;
|
|
templat.last_level = 0;
|
|
templat.width0 = 32;
|
|
templat.height0 = 32;
|
|
templat.depth0 = 1;
|
|
templat.array_size = 1;
|
|
templat.bind = PIPE_BIND_SAMPLER_VIEW;
|
|
|
|
tex = screen->resource_create(screen, &templat);
|
|
|
|
if (tex)
|
|
util_pstipple_update_stipple_texture(pipe, tex, pattern);
|
|
|
|
return tex;
|
|
}
|
|
|
|
|
|
/**
|
|
* Create sampler view to sample the stipple texture.
|
|
*/
|
|
struct pipe_sampler_view *
|
|
util_pstipple_create_sampler_view(struct pipe_context *pipe,
|
|
struct pipe_resource *tex)
|
|
{
|
|
struct pipe_sampler_view templat, *sv;
|
|
|
|
u_sampler_view_default_template(&templat, tex, tex->format);
|
|
sv = pipe->create_sampler_view(pipe, tex, &templat);
|
|
|
|
return sv;
|
|
}
|
|
|
|
|
|
/**
|
|
* Create the sampler CSO that'll be used for stippling.
|
|
*/
|
|
void *
|
|
util_pstipple_create_sampler(struct pipe_context *pipe)
|
|
{
|
|
struct pipe_sampler_state templat;
|
|
void *s;
|
|
|
|
memset(&templat, 0, sizeof(templat));
|
|
templat.wrap_s = PIPE_TEX_WRAP_REPEAT;
|
|
templat.wrap_t = PIPE_TEX_WRAP_REPEAT;
|
|
templat.wrap_r = PIPE_TEX_WRAP_REPEAT;
|
|
templat.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
|
|
templat.min_img_filter = PIPE_TEX_FILTER_NEAREST;
|
|
templat.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
|
|
templat.normalized_coords = 1;
|
|
templat.min_lod = 0.0f;
|
|
templat.max_lod = 0.0f;
|
|
|
|
s = pipe->create_sampler_state(pipe, &templat);
|
|
return s;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* 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;
|
|
struct tgsi_shader_info info;
|
|
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;
|
|
uint coordOrigin;
|
|
};
|
|
|
|
|
|
/**
|
|
* TGSI declaration transform callback.
|
|
* Track samplers used, temps used, inputs used.
|
|
*/
|
|
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;
|
|
|
|
/* XXX we can use tgsi_shader_info instead of some of this */
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
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;
|
|
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.
|
|
* Before the first instruction, insert our new code to sample the
|
|
* stipple texture (using the fragment coord register) then kill the
|
|
* fragment if the stipple texture bit is off.
|
|
*
|
|
* Insert:
|
|
* declare new registers
|
|
* MUL texTemp, INPUT[wincoord], 1/32;
|
|
* TEX texTemp, texTemp, sampler;
|
|
* KIL -texTemp; # if -texTemp < 0, KILL fragment
|
|
* [...original code...]
|
|
*/
|
|
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 texture 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 register */
|
|
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;
|
|
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 REPEAT wrap mode with normalized
|
|
* texcoords. Darn.
|
|
*/
|
|
|
|
/* XXX invert wincoord if origin isn't lower-left... */
|
|
|
|
/* 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);
|
|
}
|
|
|
|
|
|
/**
|
|
* Given a fragment shader, return a new fragment shader which
|
|
* samples a stipple texture and executes KILL.
|
|
*/
|
|
struct pipe_shader_state *
|
|
util_pstipple_create_fragment_shader(struct pipe_context *pipe,
|
|
struct pipe_shader_state *fs,
|
|
unsigned *samplerUnitOut)
|
|
{
|
|
struct pipe_shader_state *new_fs;
|
|
struct pstip_transform_context transform;
|
|
const uint newLen = tgsi_num_tokens(fs->tokens) + NUM_NEW_TOKENS;
|
|
unsigned i;
|
|
|
|
new_fs = MALLOC(sizeof(*new_fs));
|
|
if (!new_fs)
|
|
return NULL;
|
|
|
|
new_fs->tokens = tgsi_alloc_tokens(newLen);
|
|
if (!new_fs->tokens) {
|
|
FREE(new_fs);
|
|
return NULL;
|
|
}
|
|
|
|
/* Setup shader transformation info/context.
|
|
*/
|
|
memset(&transform, 0, sizeof(transform));
|
|
transform.wincoordInput = -1;
|
|
transform.maxInput = -1;
|
|
transform.texTemp = -1;
|
|
transform.firstInstruction = TRUE;
|
|
transform.coordOrigin = TGSI_FS_COORD_ORIGIN_UPPER_LEFT;
|
|
transform.base.transform_instruction = pstip_transform_inst;
|
|
transform.base.transform_declaration = pstip_transform_decl;
|
|
transform.base.transform_immediate = pstip_transform_immed;
|
|
|
|
tgsi_scan_shader(fs->tokens, &transform.info);
|
|
|
|
/* find fragment coordinate origin property */
|
|
for (i = 0; i < transform.info.num_properties; i++) {
|
|
if (transform.info.properties[i].name == TGSI_PROPERTY_FS_COORD_ORIGIN)
|
|
transform.coordOrigin = transform.info.properties[i].data[0];
|
|
}
|
|
|
|
tgsi_transform_shader(fs->tokens,
|
|
(struct tgsi_token *) new_fs->tokens,
|
|
newLen, &transform.base);
|
|
|
|
#if 0 /* DEBUG */
|
|
tgsi_dump(fs->tokens, 0);
|
|
tgsi_dump(new_fs->tokens, 0);
|
|
#endif
|
|
|
|
assert(transform.freeSampler < PIPE_MAX_SAMPLERS);
|
|
*samplerUnitOut = transform.freeSampler;
|
|
|
|
return new_fs;
|
|
}
|
|
|