u_pstipple.c revision 0c4bc1e29223ffec4617999c0c03d722bdcc170a
1/************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 4 * Copyright 2010 VMware, Inc. 5 * All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the 9 * "Software"), to deal in the Software without restriction, including 10 * without limitation the rights to use, copy, modify, merge, publish, 11 * distribute, sub license, and/or sell copies of the Software, and to 12 * permit persons to whom the Software is furnished to do so, subject to 13 * the following conditions: 14 * 15 * The above copyright notice and this permission notice (including the 16 * next paragraph) shall be included in all copies or substantial portions 17 * of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 22 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 24 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 25 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 26 * 27 **************************************************************************/ 28 29/** 30 * Polygon stipple helper module. Drivers/GPUs which don't support polygon 31 * stipple natively can use this module to simulate it. 32 * 33 * Basically, modify fragment shader to sample the 32x32 stipple pattern 34 * texture and do a fragment kill for the 'off' bits. 35 * 36 * This was originally a 'draw' module stage, but since we don't need 37 * vertex window coords or anything, it can be a stand-alone utility module. 38 * 39 * Authors: Brian Paul 40 */ 41 42 43#include "pipe/p_context.h" 44#include "pipe/p_defines.h" 45#include "pipe/p_shader_tokens.h" 46#include "util/u_inlines.h" 47 48#include "util/u_format.h" 49#include "util/u_memory.h" 50#include "util/u_pstipple.h" 51#include "util/u_sampler.h" 52 53#include "tgsi/tgsi_transform.h" 54#include "tgsi/tgsi_dump.h" 55#include "tgsi/tgsi_scan.h" 56 57/** Approx number of new tokens for instructions in pstip_transform_inst() */ 58#define NUM_NEW_TOKENS 50 59 60 61static void 62util_pstipple_update_stipple_texture(struct pipe_context *pipe, 63 struct pipe_resource *tex, 64 const uint32_t pattern[32]) 65{ 66 static const uint bit31 = 1 << 31; 67 struct pipe_transfer *transfer; 68 ubyte *data; 69 int i, j; 70 71 /* map texture memory */ 72 data = pipe_transfer_map(pipe, tex, 0, 0, 73 PIPE_TRANSFER_WRITE, 0, 0, 32, 32, &transfer); 74 75 /* 76 * Load alpha texture. 77 * Note: 0 means keep the fragment, 255 means kill it. 78 * We'll negate the texel value and use KILL_IF which kills if value 79 * is negative. 80 */ 81 for (i = 0; i < 32; i++) { 82 for (j = 0; j < 32; j++) { 83 if (pattern[i] & (bit31 >> j)) { 84 /* fragment "on" */ 85 data[i * transfer->stride + j] = 0; 86 } 87 else { 88 /* fragment "off" */ 89 data[i * transfer->stride + j] = 255; 90 } 91 } 92 } 93 94 /* unmap */ 95 pipe->transfer_unmap(pipe, transfer); 96} 97 98 99/** 100 * Create a 32x32 alpha8 texture that encodes the given stipple pattern. 101 */ 102struct pipe_resource * 103util_pstipple_create_stipple_texture(struct pipe_context *pipe, 104 const uint32_t pattern[32]) 105{ 106 struct pipe_screen *screen = pipe->screen; 107 struct pipe_resource templat, *tex; 108 109 memset(&templat, 0, sizeof(templat)); 110 templat.target = PIPE_TEXTURE_2D; 111 templat.format = PIPE_FORMAT_A8_UNORM; 112 templat.last_level = 0; 113 templat.width0 = 32; 114 templat.height0 = 32; 115 templat.depth0 = 1; 116 templat.array_size = 1; 117 templat.bind = PIPE_BIND_SAMPLER_VIEW; 118 119 tex = screen->resource_create(screen, &templat); 120 121 if (tex) 122 util_pstipple_update_stipple_texture(pipe, tex, pattern); 123 124 return tex; 125} 126 127 128/** 129 * Create sampler view to sample the stipple texture. 130 */ 131struct pipe_sampler_view * 132util_pstipple_create_sampler_view(struct pipe_context *pipe, 133 struct pipe_resource *tex) 134{ 135 struct pipe_sampler_view templat, *sv; 136 137 u_sampler_view_default_template(&templat, tex, tex->format); 138 sv = pipe->create_sampler_view(pipe, tex, &templat); 139 140 return sv; 141} 142 143 144/** 145 * Create the sampler CSO that'll be used for stippling. 146 */ 147void * 148util_pstipple_create_sampler(struct pipe_context *pipe) 149{ 150 struct pipe_sampler_state templat; 151 void *s; 152 153 memset(&templat, 0, sizeof(templat)); 154 templat.wrap_s = PIPE_TEX_WRAP_REPEAT; 155 templat.wrap_t = PIPE_TEX_WRAP_REPEAT; 156 templat.wrap_r = PIPE_TEX_WRAP_REPEAT; 157 templat.min_mip_filter = PIPE_TEX_MIPFILTER_NONE; 158 templat.min_img_filter = PIPE_TEX_FILTER_NEAREST; 159 templat.mag_img_filter = PIPE_TEX_FILTER_NEAREST; 160 templat.normalized_coords = 1; 161 templat.min_lod = 0.0f; 162 templat.max_lod = 0.0f; 163 164 s = pipe->create_sampler_state(pipe, &templat); 165 return s; 166} 167 168 169 170/** 171 * Subclass of tgsi_transform_context, used for transforming the 172 * user's fragment shader to add the extra texture sample and fragment kill 173 * instructions. 174 */ 175struct pstip_transform_context { 176 struct tgsi_transform_context base; 177 struct tgsi_shader_info info; 178 uint tempsUsed; /**< bitmask */ 179 int wincoordInput; 180 int maxInput; 181 uint samplersUsed; /**< bitfield of samplers used */ 182 int freeSampler; /** an available sampler for the pstipple */ 183 int texTemp; /**< temp registers */ 184 int numImmed; 185 boolean firstInstruction; 186 uint coordOrigin; 187}; 188 189 190/** 191 * TGSI declaration transform callback. 192 * Track samplers used, temps used, inputs used. 193 */ 194static void 195pstip_transform_decl(struct tgsi_transform_context *ctx, 196 struct tgsi_full_declaration *decl) 197{ 198 struct pstip_transform_context *pctx = 199 (struct pstip_transform_context *) ctx; 200 201 /* XXX we can use tgsi_shader_info instead of some of this */ 202 203 if (decl->Declaration.File == TGSI_FILE_SAMPLER) { 204 uint i; 205 for (i = decl->Range.First; i <= decl->Range.Last; i++) { 206 pctx->samplersUsed |= 1 << i; 207 } 208 } 209 else if (decl->Declaration.File == TGSI_FILE_INPUT) { 210 pctx->maxInput = MAX2(pctx->maxInput, (int) decl->Range.Last); 211 if (decl->Semantic.Name == TGSI_SEMANTIC_POSITION) 212 pctx->wincoordInput = (int) decl->Range.First; 213 } 214 else if (decl->Declaration.File == TGSI_FILE_TEMPORARY) { 215 uint i; 216 for (i = decl->Range.First; i <= decl->Range.Last; i++) { 217 pctx->tempsUsed |= (1 << i); 218 } 219 } 220 221 ctx->emit_declaration(ctx, decl); 222} 223 224 225static void 226pstip_transform_immed(struct tgsi_transform_context *ctx, 227 struct tgsi_full_immediate *immed) 228{ 229 struct pstip_transform_context *pctx = 230 (struct pstip_transform_context *) ctx; 231 pctx->numImmed++; 232} 233 234 235/** 236 * Find the lowest zero bit in the given word, or -1 if bitfield is all ones. 237 */ 238static int 239free_bit(uint bitfield) 240{ 241 return ffs(~bitfield) - 1; 242} 243 244 245/** 246 * TGSI instruction transform callback. 247 * Before the first instruction, insert our new code to sample the 248 * stipple texture (using the fragment coord register) then kill the 249 * fragment if the stipple texture bit is off. 250 * 251 * Insert: 252 * declare new registers 253 * MUL texTemp, INPUT[wincoord], 1/32; 254 * TEX texTemp, texTemp, sampler; 255 * KILL_IF -texTemp; # if -texTemp < 0, kill fragment 256 * [...original code...] 257 */ 258static void 259pstip_transform_inst(struct tgsi_transform_context *ctx, 260 struct tgsi_full_instruction *inst) 261{ 262 struct pstip_transform_context *pctx = 263 (struct pstip_transform_context *) ctx; 264 265 if (pctx->firstInstruction) { 266 /* emit our new declarations before the first instruction */ 267 268 struct tgsi_full_declaration decl; 269 struct tgsi_full_instruction newInst; 270 uint i; 271 int wincoordInput; 272 273 /* find free texture sampler */ 274 pctx->freeSampler = free_bit(pctx->samplersUsed); 275 if (pctx->freeSampler >= PIPE_MAX_SAMPLERS) 276 pctx->freeSampler = PIPE_MAX_SAMPLERS - 1; 277 278 if (pctx->wincoordInput < 0) 279 wincoordInput = pctx->maxInput + 1; 280 else 281 wincoordInput = pctx->wincoordInput; 282 283 /* find one free temp register */ 284 for (i = 0; i < 32; i++) { 285 if ((pctx->tempsUsed & (1 << i)) == 0) { 286 /* found a free temp */ 287 if (pctx->texTemp < 0) 288 pctx->texTemp = i; 289 else 290 break; 291 } 292 } 293 assert(pctx->texTemp >= 0); 294 295 if (pctx->wincoordInput < 0) { 296 /* declare new position input reg */ 297 decl = tgsi_default_full_declaration(); 298 decl.Declaration.File = TGSI_FILE_INPUT; 299 decl.Declaration.Interpolate = 1; 300 decl.Declaration.Semantic = 1; 301 decl.Semantic.Name = TGSI_SEMANTIC_POSITION; 302 decl.Semantic.Index = 0; 303 decl.Range.First = 304 decl.Range.Last = wincoordInput; 305 decl.Interp.Interpolate = TGSI_INTERPOLATE_LINEAR; 306 ctx->emit_declaration(ctx, &decl); 307 } 308 309 /* declare new sampler */ 310 decl = tgsi_default_full_declaration(); 311 decl.Declaration.File = TGSI_FILE_SAMPLER; 312 decl.Range.First = 313 decl.Range.Last = pctx->freeSampler; 314 ctx->emit_declaration(ctx, &decl); 315 316 /* declare new temp regs */ 317 decl = tgsi_default_full_declaration(); 318 decl.Declaration.File = TGSI_FILE_TEMPORARY; 319 decl.Range.First = 320 decl.Range.Last = pctx->texTemp; 321 ctx->emit_declaration(ctx, &decl); 322 323 /* emit immediate = {1/32, 1/32, 1, 1} 324 * The index/position of this immediate will be pctx->numImmed 325 */ 326 { 327 static const float value[4] = { 1.0/32, 1.0/32, 1.0, 1.0 }; 328 struct tgsi_full_immediate immed; 329 uint size = 4; 330 immed = tgsi_default_full_immediate(); 331 immed.Immediate.NrTokens = 1 + size; /* one for the token itself */ 332 immed.u[0].Float = value[0]; 333 immed.u[1].Float = value[1]; 334 immed.u[2].Float = value[2]; 335 immed.u[3].Float = value[3]; 336 ctx->emit_immediate(ctx, &immed); 337 } 338 339 pctx->firstInstruction = FALSE; 340 341 342 /* 343 * Insert new MUL/TEX/KILL_IF instructions at start of program 344 * Take gl_FragCoord, divide by 32 (stipple size), sample the 345 * texture and kill fragment if needed. 346 * 347 * We'd like to use non-normalized texcoords to index into a RECT 348 * texture, but we can only use REPEAT wrap mode with normalized 349 * texcoords. Darn. 350 */ 351 352 /* XXX invert wincoord if origin isn't lower-left... */ 353 354 /* MUL texTemp, INPUT[wincoord], 1/32; */ 355 newInst = tgsi_default_full_instruction(); 356 newInst.Instruction.Opcode = TGSI_OPCODE_MUL; 357 newInst.Instruction.NumDstRegs = 1; 358 newInst.Dst[0].Register.File = TGSI_FILE_TEMPORARY; 359 newInst.Dst[0].Register.Index = pctx->texTemp; 360 newInst.Instruction.NumSrcRegs = 2; 361 newInst.Src[0].Register.File = TGSI_FILE_INPUT; 362 newInst.Src[0].Register.Index = wincoordInput; 363 newInst.Src[1].Register.File = TGSI_FILE_IMMEDIATE; 364 newInst.Src[1].Register.Index = pctx->numImmed; 365 ctx->emit_instruction(ctx, &newInst); 366 367 /* TEX texTemp, texTemp, sampler; */ 368 newInst = tgsi_default_full_instruction(); 369 newInst.Instruction.Opcode = TGSI_OPCODE_TEX; 370 newInst.Instruction.NumDstRegs = 1; 371 newInst.Dst[0].Register.File = TGSI_FILE_TEMPORARY; 372 newInst.Dst[0].Register.Index = pctx->texTemp; 373 newInst.Instruction.NumSrcRegs = 2; 374 newInst.Instruction.Texture = TRUE; 375 newInst.Texture.Texture = TGSI_TEXTURE_2D; 376 newInst.Src[0].Register.File = TGSI_FILE_TEMPORARY; 377 newInst.Src[0].Register.Index = pctx->texTemp; 378 newInst.Src[1].Register.File = TGSI_FILE_SAMPLER; 379 newInst.Src[1].Register.Index = pctx->freeSampler; 380 ctx->emit_instruction(ctx, &newInst); 381 382 /* KILL_IF -texTemp; # if -texTemp < 0, kill fragment */ 383 newInst = tgsi_default_full_instruction(); 384 newInst.Instruction.Opcode = TGSI_OPCODE_KILL_IF; 385 newInst.Instruction.NumDstRegs = 0; 386 newInst.Instruction.NumSrcRegs = 1; 387 newInst.Src[0].Register.File = TGSI_FILE_TEMPORARY; 388 newInst.Src[0].Register.Index = pctx->texTemp; 389 newInst.Src[0].Register.Negate = 1; 390 ctx->emit_instruction(ctx, &newInst); 391 } 392 393 /* emit this instruction */ 394 ctx->emit_instruction(ctx, inst); 395} 396 397 398/** 399 * Given a fragment shader, return a new fragment shader which 400 * samples a stipple texture and executes KILL. 401 */ 402struct pipe_shader_state * 403util_pstipple_create_fragment_shader(struct pipe_context *pipe, 404 struct pipe_shader_state *fs, 405 unsigned *samplerUnitOut) 406{ 407 struct pipe_shader_state *new_fs; 408 struct pstip_transform_context transform; 409 const uint newLen = tgsi_num_tokens(fs->tokens) + NUM_NEW_TOKENS; 410 411 new_fs = MALLOC(sizeof(*new_fs)); 412 if (!new_fs) 413 return NULL; 414 415 new_fs->tokens = tgsi_alloc_tokens(newLen); 416 if (!new_fs->tokens) { 417 FREE(new_fs); 418 return NULL; 419 } 420 421 /* Setup shader transformation info/context. 422 */ 423 memset(&transform, 0, sizeof(transform)); 424 transform.wincoordInput = -1; 425 transform.maxInput = -1; 426 transform.texTemp = -1; 427 transform.firstInstruction = TRUE; 428 transform.coordOrigin = TGSI_FS_COORD_ORIGIN_UPPER_LEFT; 429 transform.base.transform_instruction = pstip_transform_inst; 430 transform.base.transform_declaration = pstip_transform_decl; 431 transform.base.transform_immediate = pstip_transform_immed; 432 433 tgsi_scan_shader(fs->tokens, &transform.info); 434 435 transform.coordOrigin = 436 transform.info.properties[TGSI_PROPERTY_FS_COORD_ORIGIN]; 437 438 tgsi_transform_shader(fs->tokens, 439 (struct tgsi_token *) new_fs->tokens, 440 newLen, &transform.base); 441 442#if 0 /* DEBUG */ 443 tgsi_dump(fs->tokens, 0); 444 tgsi_dump(new_fs->tokens, 0); 445#endif 446 447 assert(transform.freeSampler < PIPE_MAX_SAMPLERS); 448 *samplerUnitOut = transform.freeSampler; 449 450 return new_fs; 451} 452 453