git.oblomov.eu Git - wine/blob - dlls/wined3d/baseshader.c

   1 /*
   2  * shaders implementation
   3  *
   4  * Copyright 2002-2003 Jason Edmeades
   5  * Copyright 2002-2003 Raphael Junqueira
   6  * Copyright 2004 Christian Costa
   7  * Copyright 2005 Oliver Stieber
   8  * Copyright 2006 Ivan Gyurdiev
   9  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
  10  * Copyright 2009 Henri Verbeet for CodeWeavers
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #include "config.h"
  28 #include <string.h>
  29 #include <stdio.h>
  30 #include "wined3d_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  33 WINE_DECLARE_DEBUG_CHANNEL(d3d);
  34
  35 static const char *shader_opcode_names[] =
  36 {
  37     /* WINED3DSIH_ABS           */ "abs",
  38     /* WINED3DSIH_ADD           */ "add",
  39     /* WINED3DSIH_BEM           */ "bem",
  40     /* WINED3DSIH_BREAK         */ "break",
  41     /* WINED3DSIH_BREAKC        */ "breakc",
  42     /* WINED3DSIH_BREAKP        */ "breakp",
  43     /* WINED3DSIH_CALL          */ "call",
  44     /* WINED3DSIH_CALLNZ        */ "callnz",
  45     /* WINED3DSIH_CMP           */ "cmp",
  46     /* WINED3DSIH_CND           */ "cnd",
  47     /* WINED3DSIH_CRS           */ "crs",
  48     /* WINED3DSIH_DCL           */ "dcl",
  49     /* WINED3DSIH_DEF           */ "def",
  50     /* WINED3DSIH_DEFB          */ "defb",
  51     /* WINED3DSIH_DEFI          */ "defi",
  52     /* WINED3DSIH_DP2ADD        */ "dp2add",
  53     /* WINED3DSIH_DP3           */ "dp3",
  54     /* WINED3DSIH_DP4           */ "dp4",
  55     /* WINED3DSIH_DST           */ "dst",
  56     /* WINED3DSIH_DSX           */ "dsx",
  57     /* WINED3DSIH_DSY           */ "dsy",
  58     /* WINED3DSIH_ELSE          */ "else",
  59     /* WINED3DSIH_ENDIF         */ "endif",
  60     /* WINED3DSIH_ENDLOOP       */ "endloop",
  61     /* WINED3DSIH_ENDREP        */ "endrep",
  62     /* WINED3DSIH_EXP           */ "exp",
  63     /* WINED3DSIH_EXPP          */ "expp",
  64     /* WINED3DSIH_FRC           */ "frc",
  65     /* WINED3DSIH_IF            */ "if",
  66     /* WINED3DSIH_IFC           */ "ifc",
  67     /* WINED3DSIH_LABEL         */ "label",
  68     /* WINED3DSIH_LIT           */ "lit",
  69     /* WINED3DSIH_LOG           */ "log",
  70     /* WINED3DSIH_LOGP          */ "logp",
  71     /* WINED3DSIH_LOOP          */ "loop",
  72     /* WINED3DSIH_LRP           */ "lrp",
  73     /* WINED3DSIH_M3x2          */ "m3x2",
  74     /* WINED3DSIH_M3x3          */ "m3x3",
  75     /* WINED3DSIH_M3x4          */ "m3x4",
  76     /* WINED3DSIH_M4x3          */ "m4x3",
  77     /* WINED3DSIH_M4x4          */ "m4x4",
  78     /* WINED3DSIH_MAD           */ "mad",
  79     /* WINED3DSIH_MAX           */ "max",
  80     /* WINED3DSIH_MIN           */ "min",
  81     /* WINED3DSIH_MOV           */ "mov",
  82     /* WINED3DSIH_MOVA          */ "mova",
  83     /* WINED3DSIH_MUL           */ "mul",
  84     /* WINED3DSIH_NOP           */ "nop",
  85     /* WINED3DSIH_NRM           */ "nrm",
  86     /* WINED3DSIH_PHASE         */ "phase",
  87     /* WINED3DSIH_POW           */ "pow",
  88     /* WINED3DSIH_RCP           */ "rcp",
  89     /* WINED3DSIH_REP           */ "rep",
  90     /* WINED3DSIH_RET           */ "ret",
  91     /* WINED3DSIH_RSQ           */ "rsq",
  92     /* WINED3DSIH_SETP          */ "setp",
  93     /* WINED3DSIH_SGE           */ "sge",
  94     /* WINED3DSIH_SGN           */ "sgn",
  95     /* WINED3DSIH_SINCOS        */ "sincos",
  96     /* WINED3DSIH_SLT           */ "slt",
  97     /* WINED3DSIH_SUB           */ "sub",
  98     /* WINED3DSIH_TEX           */ "texld",
  99     /* WINED3DSIH_TEXBEM        */ "texbem",
 100     /* WINED3DSIH_TEXBEML       */ "texbeml",
 101     /* WINED3DSIH_TEXCOORD      */ "texcrd",
 102     /* WINED3DSIH_TEXDEPTH      */ "texdepth",
 103     /* WINED3DSIH_TEXDP3        */ "texdp3",
 104     /* WINED3DSIH_TEXDP3TEX     */ "texdp3tex",
 105     /* WINED3DSIH_TEXKILL       */ "texkill",
 106     /* WINED3DSIH_TEXLDD        */ "texldd",
 107     /* WINED3DSIH_TEXLDL        */ "texldl",
 108     /* WINED3DSIH_TEXM3x2DEPTH  */ "texm3x2depth",
 109     /* WINED3DSIH_TEXM3x2PAD    */ "texm3x2pad",
 110     /* WINED3DSIH_TEXM3x2TEX    */ "texm3x2tex",
 111     /* WINED3DSIH_TEXM3x3       */ "texm3x3",
 112     /* WINED3DSIH_TEXM3x3DIFF   */ "texm3x3diff",
 113     /* WINED3DSIH_TEXM3x3PAD    */ "texm3x3pad",
 114     /* WINED3DSIH_TEXM3x3SPEC   */ "texm3x3spec",
 115     /* WINED3DSIH_TEXM3x3TEX    */ "texm3x3tex",
 116     /* WINED3DSIH_TEXM3x3VSPEC  */ "texm3x3vspec",
 117     /* WINED3DSIH_TEXREG2AR     */ "texreg2ar",
 118     /* WINED3DSIH_TEXREG2GB     */ "texreg2gb",
 119     /* WINED3DSIH_TEXREG2RGB    */ "texreg2rgb",
 120 };
 121
 122 #define WINED3D_SM1_VS  0xfffe
 123 #define WINED3D_SM1_PS  0xffff
 124
 125 const struct wined3d_shader_frontend *shader_select_frontend(DWORD version_token)
 126 {
 127     switch (version_token >> 16)
 128     {
 129         case WINED3D_SM1_VS:
 130         case WINED3D_SM1_PS:
 131             return &sm1_shader_frontend;
 132
 133         default:
 134             FIXME("Unrecognised version token %#x\n", version_token);
 135             return NULL;
 136     }
 137 }
 138
 139 static inline BOOL shader_is_version_token(DWORD token) {
 140     return shader_is_pshader_version(token) ||
 141            shader_is_vshader_version(token);
 142 }
 143
 144 void shader_buffer_init(struct SHADER_BUFFER *buffer)
 145 {
 146     buffer->buffer = HeapAlloc(GetProcessHeap(), 0, SHADER_PGMSIZE);
 147     buffer->buffer[0] = '\0';
 148     buffer->bsize = 0;
 149     buffer->lineNo = 0;
 150     buffer->newline = TRUE;
 151 }
 152
 153 void shader_buffer_free(struct SHADER_BUFFER *buffer)
 154 {
 155     HeapFree(GetProcessHeap(), 0, buffer->buffer);
 156 }
 157
 158 int shader_vaddline(SHADER_BUFFER* buffer, const char *format, va_list args)
 159 {
 160     char* base = buffer->buffer + buffer->bsize;
 161     int rc;
 162
 163     rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
 164
 165     if (rc < 0 ||                                   /* C89 */
 166         rc > SHADER_PGMSIZE - 1 - buffer->bsize) {  /* C99 */
 167
 168         ERR("The buffer allocated for the shader program string "
 169             "is too small at %d bytes.\n", SHADER_PGMSIZE);
 170         buffer->bsize = SHADER_PGMSIZE - 1;
 171         return -1;
 172     }
 173
 174     if (buffer->newline) {
 175         TRACE("GL HW (%u, %u) : %s", buffer->lineNo + 1, buffer->bsize, base);
 176         buffer->newline = FALSE;
 177     } else {
 178         TRACE("%s", base);
 179     }
 180
 181     buffer->bsize += rc;
 182     if (buffer->buffer[buffer->bsize-1] == '\n') {
 183         buffer->lineNo++;
 184         buffer->newline = TRUE;
 185     }
 186     return 0;
 187 }
 188
 189 int shader_addline(SHADER_BUFFER* buffer, const char *format, ...)
 190 {
 191     int ret;
 192     va_list args;
 193
 194     va_start(args, format);
 195     ret = shader_vaddline(buffer, format, args);
 196     va_end(args);
 197
 198     return ret;
 199 }
 200
 201 void shader_init(struct IWineD3DBaseShaderClass *shader,
 202         IWineD3DDevice *device, const SHADER_OPCODE *instruction_table)
 203 {
 204     shader->ref = 1;
 205     shader->device = device;
 206     shader->shader_ins = instruction_table;
 207     list_init(&shader->linked_programs);
 208 }
 209
 210 /* Convert floating point offset relative
 211  * to a register file to an absolute offset for float constants */
 212 static unsigned int shader_get_float_offset(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx)
 213 {
 214     switch (register_type)
 215     {
 216         case WINED3DSPR_CONST: return register_idx;
 217         case WINED3DSPR_CONST2: return 2048 + register_idx;
 218         case WINED3DSPR_CONST3: return 4096 + register_idx;
 219         case WINED3DSPR_CONST4: return 6144 + register_idx;
 220         default:
 221             FIXME("Unsupported register type: %d\n", register_type);
 222             return register_idx;
 223     }
 224 }
 225
 226 static void shader_delete_constant_list(struct list* clist) {
 227
 228     struct list *ptr;
 229     struct local_constant* constant;
 230
 231     ptr = list_head(clist);
 232     while (ptr) {
 233         constant = LIST_ENTRY(ptr, struct local_constant, entry);
 234         ptr = list_next(clist, ptr);
 235         HeapFree(GetProcessHeap(), 0, constant);
 236     }
 237     list_init(clist);
 238 }
 239
 240 static void shader_record_register_usage(IWineD3DBaseShaderImpl *This, struct shader_reg_maps *reg_maps,
 241         DWORD register_type, UINT register_idx, BOOL has_rel_addr, BOOL pshader)
 242 {
 243     switch (register_type)
 244     {
 245         case WINED3DSPR_TEXTURE: /* WINED3DSPR_ADDR */
 246             if (pshader) reg_maps->texcoord[register_idx] = 1;
 247             else reg_maps->address[register_idx] = 1;
 248             break;
 249
 250         case WINED3DSPR_TEMP:
 251             reg_maps->temporary[register_idx] = 1;
 252             break;
 253
 254         case WINED3DSPR_INPUT:
 255             if (!pshader) reg_maps->attributes[register_idx] = 1;
 256             else
 257             {
 258                 if (has_rel_addr)
 259                 {
 260                     /* If relative addressing is used, we must assume that all registers
 261                      * are used. Even if it is a construct like v3[aL], we can't assume
 262                      * that v0, v1 and v2 aren't read because aL can be negative */
 263                     unsigned int i;
 264                     for (i = 0; i < MAX_REG_INPUT; ++i)
 265                     {
 266                         ((IWineD3DPixelShaderImpl *)This)->input_reg_used[i] = TRUE;
 267                     }
 268                 }
 269                 else
 270                 {
 271                     ((IWineD3DPixelShaderImpl *)This)->input_reg_used[register_idx] = TRUE;
 272                 }
 273             }
 274             break;
 275
 276         case WINED3DSPR_RASTOUT:
 277             if (register_idx == 1) reg_maps->fog = 1;
 278             break;
 279
 280         case WINED3DSPR_MISCTYPE:
 281             if (pshader && register_idx == 0) reg_maps->vpos = 1;
 282             break;
 283
 284         case WINED3DSPR_CONST:
 285             if (has_rel_addr)
 286             {
 287                 if (!pshader)
 288                 {
 289                     if (register_idx <= ((IWineD3DVertexShaderImpl *)This)->min_rel_offset)
 290                         ((IWineD3DVertexShaderImpl *)This)->min_rel_offset = register_idx;
 291                     else if (register_idx >= ((IWineD3DVertexShaderImpl *)This)->max_rel_offset)
 292                         ((IWineD3DVertexShaderImpl *)This)->max_rel_offset = register_idx;
 293                 }
 294                 reg_maps->usesrelconstF = TRUE;
 295             }
 296             break;
 297
 298         case WINED3DSPR_CONSTINT:
 299             reg_maps->integer_constants |= (1 << register_idx);
 300             break;
 301
 302         case WINED3DSPR_CONSTBOOL:
 303             reg_maps->boolean_constants |= (1 << register_idx);
 304             break;
 305
 306         default:
 307             TRACE("Not recording register of type %#x and idx %u\n", register_type, register_idx);
 308             break;
 309     }
 310 }
 311
 312 /* Note that this does not count the loop register
 313  * as an address register. */
 314
 315 HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3d_shader_frontend *fe,
 316         struct shader_reg_maps *reg_maps, struct wined3d_shader_semantic *semantics_in,
 317         struct wined3d_shader_semantic *semantics_out, const DWORD *byte_code)
 318 {
 319     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 320     const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;
 321     DWORD shader_version;
 322     unsigned int cur_loop_depth = 0, max_loop_depth = 0;
 323     const DWORD* pToken = byte_code;
 324     char pshader;
 325
 326     /* There are some minor differences between pixel and vertex shaders */
 327
 328     memset(reg_maps, 0, sizeof(*reg_maps));
 329
 330     /* get_registers_used is called on every compile on some 1.x shaders, which can result
 331      * in stacking up a collection of local constants. Delete the old constants if existing
 332      */
 333     shader_delete_constant_list(&This->baseShader.constantsF);
 334     shader_delete_constant_list(&This->baseShader.constantsB);
 335     shader_delete_constant_list(&This->baseShader.constantsI);
 336
 337     /* The version token is supposed to be the first token */
 338     if (!shader_is_version_token(*pToken))
 339     {
 340         FIXME("First token is not a version token, invalid shader.\n");
 341         return WINED3DERR_INVALIDCALL;
 342     }
 343     reg_maps->shader_version = shader_version = *pToken++;
 344     pshader = shader_is_pshader_version(shader_version);
 345
 346     while (!fe->shader_is_end(&pToken))
 347     {
 348         struct wined3d_shader_instruction ins;
 349         const char *comment;
 350         UINT param_size;
 351
 352         /* Skip comments */
 353         fe->shader_read_comment(&pToken, &comment);
 354         if (comment) continue;
 355
 356         /* Fetch opcode */
 357         fe->shader_read_opcode(&pToken, &ins, &param_size, shader_ins, shader_version);
 358
 359         /* Unhandled opcode, and its parameters */
 360         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
 361         {
 362             TRACE("Skipping unrecognized instruction.\n");
 363             pToken += param_size;
 364             continue;
 365         }
 366
 367         /* Handle declarations */
 368         if (ins.handler_idx == WINED3DSIH_DCL)
 369         {
 370             struct wined3d_shader_semantic semantic;
 371
 372             fe->shader_read_semantic(&pToken, &semantic);
 373
 374             switch (semantic.reg.register_type)
 375             {
 376                 /* Vshader: mark attributes used
 377                  * Pshader: mark 3.0 input registers used, save token */
 378                 case WINED3DSPR_INPUT:
 379                     if (!pshader) reg_maps->attributes[semantic.reg.register_idx] = 1;
 380                     else reg_maps->packed_input[semantic.reg.register_idx] = 1;
 381                     semantics_in[semantic.reg.register_idx] = semantic;
 382                     break;
 383
 384                 /* Vshader: mark 3.0 output registers used, save token */
 385                 case WINED3DSPR_OUTPUT:
 386                     reg_maps->packed_output[semantic.reg.register_idx] = 1;
 387                     semantics_out[semantic.reg.register_idx] = semantic;
 388                     if (semantic.usage == WINED3DDECLUSAGE_FOG) reg_maps->fog = 1;
 389                     break;
 390
 391                 /* Save sampler usage token */
 392                 case WINED3DSPR_SAMPLER:
 393                     reg_maps->sampler_type[semantic.reg.register_idx] = semantic.sampler_type;
 394                     break;
 395
 396                 default:
 397                     TRACE("Not recording DCL register type %#x.\n", semantic.reg.register_type);
 398                     break;
 399             }
 400         }
 401         else if (ins.handler_idx == WINED3DSIH_DEF)
 402         {
 403             struct wined3d_shader_dst_param dst;
 404             struct wined3d_shader_src_param rel_addr;
 405
 406             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 407             if (!lconst) return E_OUTOFMEMORY;
 408
 409             fe->shader_read_dst_param(&pToken, &dst, &rel_addr, shader_version);
 410             lconst->idx = dst.register_idx;
 411
 412             memcpy(lconst->value, pToken, 4 * sizeof(DWORD));
 413             pToken += 4;
 414
 415             /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
 416             if (WINED3DSHADER_VERSION_MAJOR(shader_version) == 1 && pshader)
 417             {
 418                 float *value = (float *) lconst->value;
 419                 if(value[0] < -1.0) value[0] = -1.0;
 420                 else if(value[0] >  1.0) value[0] =  1.0;
 421                 if(value[1] < -1.0) value[1] = -1.0;
 422                 else if(value[1] >  1.0) value[1] =  1.0;
 423                 if(value[2] < -1.0) value[2] = -1.0;
 424                 else if(value[2] >  1.0) value[2] =  1.0;
 425                 if(value[3] < -1.0) value[3] = -1.0;
 426                 else if(value[3] >  1.0) value[3] =  1.0;
 427             }
 428
 429             list_add_head(&This->baseShader.constantsF, &lconst->entry);
 430         }
 431         else if (ins.handler_idx == WINED3DSIH_DEFI)
 432         {
 433             struct wined3d_shader_dst_param dst;
 434             struct wined3d_shader_src_param rel_addr;
 435
 436             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 437             if (!lconst) return E_OUTOFMEMORY;
 438
 439             fe->shader_read_dst_param(&pToken, &dst, &rel_addr, shader_version);
 440             lconst->idx = dst.register_idx;
 441
 442             memcpy(lconst->value, pToken, 4 * sizeof(DWORD));
 443             pToken += 4;
 444
 445             list_add_head(&This->baseShader.constantsI, &lconst->entry);
 446         }
 447         else if (ins.handler_idx == WINED3DSIH_DEFB)
 448         {
 449             struct wined3d_shader_dst_param dst;
 450             struct wined3d_shader_src_param rel_addr;
 451
 452             local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 453             if (!lconst) return E_OUTOFMEMORY;
 454
 455             fe->shader_read_dst_param(&pToken, &dst, &rel_addr, shader_version);
 456             lconst->idx = dst.register_idx;
 457
 458             memcpy(lconst->value, pToken, sizeof(DWORD));
 459             ++pToken;
 460
 461             list_add_head(&This->baseShader.constantsB, &lconst->entry);
 462         }
 463         /* If there's a loop in the shader */
 464         else if (ins.handler_idx == WINED3DSIH_LOOP
 465                 || ins.handler_idx == WINED3DSIH_REP)
 466         {
 467             struct wined3d_shader_src_param src, rel_addr;
 468
 469             fe->shader_read_src_param(&pToken, &src, &rel_addr, shader_version);
 470
 471             /* Rep and Loop always use an integer constant for the control parameters */
 472             if (ins.handler_idx == WINED3DSIH_REP)
 473             {
 474                 reg_maps->integer_constants |= 1 << src.register_idx;
 475             }
 476             else
 477             {
 478                 fe->shader_read_src_param(&pToken, &src, &rel_addr, shader_version);
 479                 reg_maps->integer_constants |= 1 << src.register_idx;
 480             }
 481
 482             cur_loop_depth++;
 483             if(cur_loop_depth > max_loop_depth)
 484                 max_loop_depth = cur_loop_depth;
 485         }
 486         else if (ins.handler_idx == WINED3DSIH_ENDLOOP
 487                 || ins.handler_idx == WINED3DSIH_ENDREP)
 488         {
 489             cur_loop_depth--;
 490         }
 491         /* For subroutine prototypes */
 492         else if (ins.handler_idx == WINED3DSIH_LABEL)
 493         {
 494             struct wined3d_shader_src_param src, rel_addr;
 495
 496             fe->shader_read_src_param(&pToken, &src, &rel_addr, shader_version);
 497             reg_maps->labels[src.register_idx] = 1;
 498         }
 499         /* Set texture, address, temporary registers */
 500         else
 501         {
 502             int i, limit;
 503
 504             /* This will loop over all the registers and try to
 505              * make a bitmask of the ones we're interested in.
 506              *
 507              * Relative addressing tokens are ignored, but that's
 508              * okay, since we'll catch any address registers when
 509              * they are initialized (required by spec) */
 510
 511             if (ins.dst_count)
 512             {
 513                 struct wined3d_shader_dst_param dst_param;
 514                 struct wined3d_shader_src_param dst_rel_addr;
 515
 516                 fe->shader_read_dst_param(&pToken, &dst_param, &dst_rel_addr, shader_version);
 517
 518                 /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and
 519                  * is used in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel
 520                  * shaders because TECRDOUT isn't used in them, but future register types might cause issues */
 521                 if (!pshader && WINED3DSHADER_VERSION_MAJOR(shader_version) < 3
 522                         && dst_param.register_type == WINED3DSPR_TEXCRDOUT)
 523                 {
 524                     reg_maps->texcoord_mask[dst_param.register_type] |= dst_param.write_mask;
 525                 }
 526                 else
 527                 {
 528                     shader_record_register_usage(This, reg_maps, dst_param.register_type,
 529                             dst_param.register_idx, !!dst_param.rel_addr, pshader);
 530                 }
 531
 532                 /* Declare 1.X samplers implicitly, based on the destination reg. number */
 533                 if (WINED3DSHADER_VERSION_MAJOR(shader_version) == 1
 534                         && pshader /* Filter different instructions with the same enum values in VS */
 535                         && (ins.handler_idx == WINED3DSIH_TEX
 536                             || ins.handler_idx == WINED3DSIH_TEXBEM
 537                             || ins.handler_idx == WINED3DSIH_TEXBEML
 538                             || ins.handler_idx == WINED3DSIH_TEXDP3TEX
 539                             || ins.handler_idx == WINED3DSIH_TEXM3x2TEX
 540                             || ins.handler_idx == WINED3DSIH_TEXM3x3SPEC
 541                             || ins.handler_idx == WINED3DSIH_TEXM3x3TEX
 542                             || ins.handler_idx == WINED3DSIH_TEXM3x3VSPEC
 543                             || ins.handler_idx == WINED3DSIH_TEXREG2AR
 544                             || ins.handler_idx == WINED3DSIH_TEXREG2GB
 545                             || ins.handler_idx == WINED3DSIH_TEXREG2RGB))
 546                 {
 547                     /* Fake sampler usage, only set reserved bit and ttype */
 548                     DWORD sampler_code = dst_param.register_idx;
 549
 550                     TRACE("Setting fake 2D sampler for 1.x pixelshader\n");
 551                     reg_maps->sampler_type[sampler_code] = WINED3DSTT_2D;
 552
 553                     /* texbem is only valid with < 1.4 pixel shaders */
 554                     if (ins.handler_idx == WINED3DSIH_TEXBEM
 555                             || ins.handler_idx == WINED3DSIH_TEXBEML)
 556                     {
 557                         reg_maps->bumpmat[sampler_code] = TRUE;
 558                         if (ins.handler_idx == WINED3DSIH_TEXBEML)
 559                         {
 560                             reg_maps->luminanceparams[sampler_code] = TRUE;
 561                         }
 562                     }
 563                 }
 564                 else if (pshader && ins.handler_idx == WINED3DSIH_BEM)
 565                 {
 566                     reg_maps->bumpmat[dst_param.register_idx] = TRUE;
 567                 }
 568             }
 569
 570             if (ins.handler_idx == WINED3DSIH_NRM)
 571             {
 572                 reg_maps->usesnrm = 1;
 573             }
 574             else if (ins.handler_idx == WINED3DSIH_DSY)
 575             {
 576                 reg_maps->usesdsy = 1;
 577             }
 578
 579             limit = ins.src_count + (ins.predicate ? 1 : 0);
 580             for (i = 0; i < limit; ++i)
 581             {
 582                 struct wined3d_shader_src_param src_param, src_rel_addr;
 583
 584                 fe->shader_read_src_param(&pToken, &src_param, &src_rel_addr, shader_version);
 585                 shader_record_register_usage(This, reg_maps, src_param.register_type,
 586                         src_param.register_idx, !!src_param.rel_addr, pshader);
 587             }
 588         }
 589     }
 590     reg_maps->loop_depth = max_loop_depth;
 591
 592     This->baseShader.functionLength = ((char *)pToken - (char *)byte_code);
 593
 594     return WINED3D_OK;
 595 }
 596
 597 static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semantic, DWORD shader_version)
 598 {
 599     TRACE("dcl");
 600
 601     if (semantic->reg.register_type == WINED3DSPR_SAMPLER)
 602     {
 603         switch (semantic->sampler_type)
 604         {
 605             case WINED3DSTT_2D: TRACE("_2d"); break;
 606             case WINED3DSTT_CUBE: TRACE("_cube"); break;
 607             case WINED3DSTT_VOLUME: TRACE("_volume"); break;
 608             default: TRACE("_unknown_ttype(0x%08x)", semantic->sampler_type);
 609         }
 610     }
 611     else
 612     {
 613         /* Pixel shaders 3.0 don't have usage semantics */
 614         if (shader_is_pshader_version(shader_version) && shader_version < WINED3DPS_VERSION(3,0))
 615             return;
 616         else
 617             TRACE("_");
 618
 619         switch (semantic->usage)
 620         {
 621             case WINED3DDECLUSAGE_POSITION:
 622                 TRACE("position%d", semantic->usage_idx);
 623                 break;
 624             case WINED3DDECLUSAGE_BLENDINDICES:
 625                 TRACE("blend");
 626                 break;
 627             case WINED3DDECLUSAGE_BLENDWEIGHT:
 628                 TRACE("weight");
 629                 break;
 630             case WINED3DDECLUSAGE_NORMAL:
 631                 TRACE("normal%d", semantic->usage_idx);
 632                 break;
 633             case WINED3DDECLUSAGE_PSIZE:
 634                 TRACE("psize");
 635                 break;
 636             case WINED3DDECLUSAGE_COLOR:
 637                 if (semantic->usage_idx == 0) TRACE("color");
 638                 else TRACE("specular%d", (semantic->usage_idx - 1));
 639                 break;
 640             case WINED3DDECLUSAGE_TEXCOORD:
 641                 TRACE("texture%d", semantic->usage_idx);
 642                 break;
 643             case WINED3DDECLUSAGE_TANGENT:
 644                 TRACE("tangent");
 645                 break;
 646             case WINED3DDECLUSAGE_BINORMAL:
 647                 TRACE("binormal");
 648                 break;
 649             case WINED3DDECLUSAGE_TESSFACTOR:
 650                 TRACE("tessfactor");
 651                 break;
 652             case WINED3DDECLUSAGE_POSITIONT:
 653                 TRACE("positionT%d", semantic->usage_idx);
 654                 break;
 655             case WINED3DDECLUSAGE_FOG:
 656                 TRACE("fog");
 657                 break;
 658             case WINED3DDECLUSAGE_DEPTH:
 659                 TRACE("depth");
 660                 break;
 661             case WINED3DDECLUSAGE_SAMPLE:
 662                 TRACE("sample");
 663                 break;
 664             default:
 665                 FIXME("unknown_semantics(0x%08x)", semantic->usage);
 666         }
 667     }
 668 }
 669
 670 static void shader_dump_register(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx,
 671         const struct wined3d_shader_src_param *rel_addr, DWORD shader_version)
 672 {
 673     static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
 674     static const char * const misctype_reg_names[] = {"vPos", "vFace"};
 675     UINT offset = register_idx;
 676
 677     switch (register_type)
 678     {
 679         case WINED3DSPR_TEMP:
 680             TRACE("r");
 681             break;
 682
 683         case WINED3DSPR_INPUT:
 684             TRACE("v");
 685             break;
 686
 687         case WINED3DSPR_CONST:
 688         case WINED3DSPR_CONST2:
 689         case WINED3DSPR_CONST3:
 690         case WINED3DSPR_CONST4:
 691             TRACE("c");
 692             offset = shader_get_float_offset(register_type, register_idx);
 693             break;
 694
 695         case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
 696             TRACE("%c", shader_is_pshader_version(shader_version) ? 't' : 'a');
 697             break;
 698
 699         case WINED3DSPR_RASTOUT:
 700             TRACE("%s", rastout_reg_names[register_idx]);
 701             break;
 702
 703         case WINED3DSPR_COLOROUT:
 704             TRACE("oC");
 705             break;
 706
 707         case WINED3DSPR_DEPTHOUT:
 708             TRACE("oDepth");
 709             break;
 710
 711         case WINED3DSPR_ATTROUT:
 712             TRACE("oD");
 713             break;
 714
 715         case WINED3DSPR_TEXCRDOUT:
 716             /* Vertex shaders >= 3.0 use general purpose output registers
 717              * (WINED3DSPR_OUTPUT), which can include an address token */
 718             if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 3) TRACE("o");
 719             else TRACE("oT");
 720             break;
 721
 722         case WINED3DSPR_CONSTINT:
 723             TRACE("i");
 724             break;
 725
 726         case WINED3DSPR_CONSTBOOL:
 727             TRACE("b");
 728             break;
 729
 730         case WINED3DSPR_LABEL:
 731             TRACE("l");
 732             break;
 733
 734         case WINED3DSPR_LOOP:
 735             TRACE("aL");
 736             break;
 737
 738         case WINED3DSPR_SAMPLER:
 739             TRACE("s");
 740             break;
 741
 742         case WINED3DSPR_MISCTYPE:
 743             if (register_idx > 1) FIXME("Unhandled misctype register %d\n", register_idx);
 744             else TRACE("%s", misctype_reg_names[register_idx]);
 745             break;
 746
 747         case WINED3DSPR_PREDICATE:
 748             TRACE("p");
 749             break;
 750
 751         default:
 752             TRACE("unhandled_rtype(%#x)", register_type);
 753             break;
 754     }
 755
 756     if (register_type != WINED3DSPR_RASTOUT && register_type != WINED3DSPR_MISCTYPE)
 757     {
 758         if (rel_addr)
 759         {
 760             TRACE("[");
 761             shader_dump_src_param(rel_addr, shader_version);
 762             TRACE(" + ");
 763         }
 764         TRACE("%u", offset);
 765         if (rel_addr) TRACE("]");
 766     }
 767 }
 768
 769 void shader_dump_dst_param(const struct wined3d_shader_dst_param *param, DWORD shader_version)
 770 {
 771     DWORD write_mask = param->write_mask;
 772
 773     shader_dump_register(param->register_type, param->register_idx, param->rel_addr, shader_version);
 774
 775     if (write_mask != WINED3DSP_WRITEMASK_ALL)
 776     {
 777         static const char *write_mask_chars = "xyzw";
 778
 779         TRACE(".");
 780         if (write_mask & WINED3DSP_WRITEMASK_0) TRACE("%c", write_mask_chars[0]);
 781         if (write_mask & WINED3DSP_WRITEMASK_1) TRACE("%c", write_mask_chars[1]);
 782         if (write_mask & WINED3DSP_WRITEMASK_2) TRACE("%c", write_mask_chars[2]);
 783         if (write_mask & WINED3DSP_WRITEMASK_3) TRACE("%c", write_mask_chars[3]);
 784     }
 785 }
 786
 787 void shader_dump_src_param(const struct wined3d_shader_src_param *param, DWORD shader_version)
 788 {
 789     DWORD src_modifier = param->modifiers;
 790     DWORD swizzle = param->swizzle;
 791
 792     if (src_modifier == WINED3DSPSM_NEG
 793             || src_modifier == WINED3DSPSM_BIASNEG
 794             || src_modifier == WINED3DSPSM_SIGNNEG
 795             || src_modifier == WINED3DSPSM_X2NEG
 796             || src_modifier == WINED3DSPSM_ABSNEG)
 797         TRACE("-");
 798     else if (src_modifier == WINED3DSPSM_COMP)
 799         TRACE("1-");
 800     else if (src_modifier == WINED3DSPSM_NOT)
 801         TRACE("!");
 802
 803     if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG)
 804         TRACE("abs(");
 805
 806     shader_dump_register(param->register_type, param->register_idx, param->rel_addr, shader_version);
 807
 808     if (src_modifier)
 809     {
 810         switch (src_modifier)
 811         {
 812             case WINED3DSPSM_NONE:    break;
 813             case WINED3DSPSM_NEG:     break;
 814             case WINED3DSPSM_NOT:     break;
 815             case WINED3DSPSM_BIAS:    TRACE("_bias"); break;
 816             case WINED3DSPSM_BIASNEG: TRACE("_bias"); break;
 817             case WINED3DSPSM_SIGN:    TRACE("_bx2"); break;
 818             case WINED3DSPSM_SIGNNEG: TRACE("_bx2"); break;
 819             case WINED3DSPSM_COMP:    break;
 820             case WINED3DSPSM_X2:      TRACE("_x2"); break;
 821             case WINED3DSPSM_X2NEG:   TRACE("_x2"); break;
 822             case WINED3DSPSM_DZ:      TRACE("_dz"); break;
 823             case WINED3DSPSM_DW:      TRACE("_dw"); break;
 824             case WINED3DSPSM_ABSNEG:  TRACE(")"); break;
 825             case WINED3DSPSM_ABS:     TRACE(")"); break;
 826             default:
 827                                       TRACE("_unknown_modifier(%#x)", src_modifier);
 828         }
 829     }
 830
 831     if (swizzle != WINED3DSP_NOSWIZZLE)
 832     {
 833         static const char *swizzle_chars = "xyzw";
 834         DWORD swizzle_x = swizzle & 0x03;
 835         DWORD swizzle_y = (swizzle >> 2) & 0x03;
 836         DWORD swizzle_z = (swizzle >> 4) & 0x03;
 837         DWORD swizzle_w = (swizzle >> 6) & 0x03;
 838
 839         if (swizzle_x == swizzle_y
 840                 && swizzle_x == swizzle_z
 841                 && swizzle_x == swizzle_w)
 842         {
 843             TRACE(".%c", swizzle_chars[swizzle_x]);
 844         }
 845         else
 846         {
 847             TRACE(".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
 848                     swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]);
 849         }
 850     }
 851 }
 852
 853 /* Shared code in order to generate the bulk of the shader string.
 854  * NOTE: A description of how to parse tokens can be found on msdn */
 855 void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER *buffer,
 856         const struct wined3d_shader_frontend *fe, const shader_reg_maps *reg_maps,
 857         const DWORD *pFunction)
 858 {
 859     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 860     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device; /* To access shader backend callbacks */
 861     const SHADER_OPCODE *opcode_table = This->baseShader.shader_ins;
 862     const SHADER_HANDLER *handler_table = device->shader_backend->shader_instruction_handler_table;
 863     DWORD shader_version = reg_maps->shader_version;
 864     struct wined3d_shader_src_param src_rel_addr[4];
 865     struct wined3d_shader_src_param src_param[4];
 866     struct wined3d_shader_src_param dst_rel_addr;
 867     struct wined3d_shader_dst_param dst_param;
 868     struct wined3d_shader_instruction ins;
 869     struct wined3d_shader_context ctx;
 870     const DWORD *pToken = pFunction;
 871     SHADER_HANDLER hw_fct;
 872     DWORD i;
 873
 874     /* Initialize current parsing state */
 875     ctx.shader = iface;
 876     ctx.reg_maps = reg_maps;
 877     ctx.buffer = buffer;
 878
 879     ins.ctx = &ctx;
 880     ins.dst = &dst_param;
 881     ins.src = src_param;
 882     This->baseShader.parse_state.current_row = 0;
 883
 884     if (!shader_is_version_token(*pToken++))
 885     {
 886         ERR("First token is not a version token, invalid shader.\n");
 887         return;
 888     }
 889
 890     while (!fe->shader_is_end(&pToken))
 891     {
 892         const char *comment;
 893         UINT param_size;
 894
 895         /* Skip comment tokens */
 896         fe->shader_read_comment(&pToken, &comment);
 897         if (comment) continue;
 898
 899         /* Read opcode */
 900         fe->shader_read_opcode(&pToken, &ins, &param_size, opcode_table, shader_version);
 901
 902         /* Unknown opcode and its parameters */
 903         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
 904         {
 905             TRACE("Skipping unrecognized instruction.\n");
 906             pToken += param_size;
 907             continue;
 908         }
 909
 910         /* Nothing to do */
 911         if (ins.handler_idx == WINED3DSIH_DCL
 912                 || ins.handler_idx == WINED3DSIH_NOP
 913                 || ins.handler_idx == WINED3DSIH_DEF
 914                 || ins.handler_idx == WINED3DSIH_DEFI
 915                 || ins.handler_idx == WINED3DSIH_DEFB
 916                 || ins.handler_idx == WINED3DSIH_PHASE
 917                 || ins.handler_idx == WINED3DSIH_RET)
 918         {
 919             pToken += param_size;
 920             continue;
 921         }
 922
 923         /* Select handler */
 924         hw_fct = handler_table[ins.handler_idx];
 925
 926         /* Unhandled opcode */
 927         if (!hw_fct)
 928         {
 929             FIXME("Backend can't handle opcode %#x\n", ins.handler_idx);
 930             pToken += param_size;
 931             continue;
 932         }
 933
 934         /* Destination token */
 935         if (ins.dst_count) fe->shader_read_dst_param(&pToken, &dst_param, &dst_rel_addr, shader_version);
 936
 937         /* Predication token */
 938         if (ins.predicate) ins.predicate = *pToken++;
 939
 940         /* Other source tokens */
 941         for (i = 0; i < ins.src_count; ++i)
 942         {
 943             fe->shader_read_src_param(&pToken, &src_param[i], &src_rel_addr[i], shader_version);
 944         }
 945
 946         /* Call appropriate function for output target */
 947         hw_fct(&ins);
 948
 949         /* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
 950         /* FIXME: This should be internal to the shader backend.
 951          * Also, right now this is the only reason "shader_mode" exists. */
 952         if (This->baseShader.shader_mode == SHADER_GLSL) shader_glsl_add_instruction_modifiers(&ins);
 953     }
 954 }
 955
 956 static void shader_dump_ins_modifiers(const struct wined3d_shader_dst_param *dst)
 957 {
 958     DWORD mmask = dst->modifiers;
 959
 960     switch (dst->shift)
 961     {
 962         case 0: break;
 963         case 13: TRACE("_d8"); break;
 964         case 14: TRACE("_d4"); break;
 965         case 15: TRACE("_d2"); break;
 966         case 1: TRACE("_x2"); break;
 967         case 2: TRACE("_x4"); break;
 968         case 3: TRACE("_x8"); break;
 969         default: TRACE("_unhandled_shift(%d)", dst->shift); break;
 970     }
 971
 972     if (mmask & WINED3DSPDM_SATURATE)         TRACE("_sat");
 973     if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
 974     if (mmask & WINED3DSPDM_MSAMPCENTROID)    TRACE("_centroid");
 975
 976     mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
 977     if (mmask)
 978         FIXME("_unrecognized_modifier(%#x)", mmask);
 979 }
 980
 981 void shader_trace_init(const struct wined3d_shader_frontend *fe,
 982         const DWORD *pFunction, const SHADER_OPCODE *opcode_table)
 983 {
 984     const DWORD* pToken = pFunction;
 985     DWORD shader_version;
 986     DWORD i;
 987
 988     TRACE("Parsing %p\n", pFunction);
 989
 990     /* The version token is supposed to be the first token */
 991     if (!shader_is_version_token(*pToken))
 992     {
 993         FIXME("First token is not a version token, invalid shader.\n");
 994         return;
 995     }
 996     shader_version = *pToken++;
 997     TRACE("%s_%u_%u\n", shader_is_pshader_version(shader_version) ? "ps": "vs",
 998             WINED3DSHADER_VERSION_MAJOR(shader_version), WINED3DSHADER_VERSION_MINOR(shader_version));
 999
1000     while (!fe->shader_is_end(&pToken))
1001     {
1002         struct wined3d_shader_instruction ins;
1003         const char *comment;
1004         UINT param_size;
1005
1006         /* comment */
1007         fe->shader_read_comment(&pToken, &comment);
1008         if (comment)
1009         {
1010             TRACE("//%s\n", comment);
1011             continue;
1012         }
1013
1014         fe->shader_read_opcode(&pToken, &ins, &param_size, opcode_table, shader_version);
1015         if (ins.handler_idx == WINED3DSIH_TABLE_SIZE)
1016         {
1017             TRACE("Skipping unrecognized instruction.\n");
1018             pToken += param_size;
1019             continue;
1020         }
1021
1022         if (ins.handler_idx == WINED3DSIH_DCL)
1023         {
1024             struct wined3d_shader_semantic semantic;
1025
1026             fe->shader_read_semantic(&pToken, &semantic);
1027
1028             shader_dump_decl_usage(&semantic, shader_version);
1029             shader_dump_ins_modifiers(&semantic.reg);
1030             TRACE(" ");
1031             shader_dump_dst_param(&semantic.reg, shader_version);
1032         }
1033         else if (ins.handler_idx == WINED3DSIH_DEF)
1034         {
1035             struct wined3d_shader_dst_param dst;
1036             struct wined3d_shader_src_param rel_addr;
1037
1038             fe->shader_read_dst_param(&pToken, &dst, &rel_addr, shader_version);
1039
1040             TRACE("def c%u = %f, %f, %f, %f", shader_get_float_offset(dst.register_type, dst.register_idx),
1041                     *(const float *)(pToken),
1042                     *(const float *)(pToken + 1),
1043                     *(const float *)(pToken + 2),
1044                     *(const float *)(pToken + 3));
1045             pToken += 4;
1046         }
1047         else if (ins.handler_idx == WINED3DSIH_DEFI)
1048         {
1049             struct wined3d_shader_dst_param dst;
1050             struct wined3d_shader_src_param rel_addr;
1051
1052             fe->shader_read_dst_param(&pToken, &dst, &rel_addr, shader_version);
1053
1054             TRACE("defi i%u = %d, %d, %d, %d", dst.register_idx,
1055                     *(pToken),
1056                     *(pToken + 1),
1057                     *(pToken + 2),
1058                     *(pToken + 3));
1059             pToken += 4;
1060         }
1061         else if (ins.handler_idx == WINED3DSIH_DEFB)
1062         {
1063             struct wined3d_shader_dst_param dst;
1064             struct wined3d_shader_src_param rel_addr;
1065
1066             fe->shader_read_dst_param(&pToken, &dst, &rel_addr, shader_version);
1067
1068             TRACE("defb b%u = %s", dst.register_idx, *pToken ? "true" : "false");
1069             ++pToken;
1070         }
1071         else
1072         {
1073             struct wined3d_shader_src_param dst_rel_addr, src_rel_addr;
1074             struct wined3d_shader_dst_param dst_param;
1075             struct wined3d_shader_src_param src_param;
1076
1077             if (ins.dst_count)
1078             {
1079                 fe->shader_read_dst_param(&pToken, &dst_param, &dst_rel_addr, shader_version);
1080             }
1081
1082             /* Print out predication source token first - it follows
1083              * the destination token. */
1084             if (ins.predicate)
1085             {
1086                 fe->shader_read_src_param(&pToken, &src_param, &src_rel_addr, shader_version);
1087                 TRACE("(");
1088                 shader_dump_src_param(&src_param, shader_version);
1089                 TRACE(") ");
1090             }
1091
1092             /* PixWin marks instructions with the coissue flag with a '+' */
1093             if (ins.coissue) TRACE("+");
1094
1095             TRACE("%s", shader_opcode_names[ins.handler_idx]);
1096
1097             if (ins.handler_idx == WINED3DSIH_IFC
1098                     || ins.handler_idx == WINED3DSIH_BREAKC)
1099             {
1100                 switch (ins.flags)
1101                 {
1102                     case COMPARISON_GT: TRACE("_gt"); break;
1103                     case COMPARISON_EQ: TRACE("_eq"); break;
1104                     case COMPARISON_GE: TRACE("_ge"); break;
1105                     case COMPARISON_LT: TRACE("_lt"); break;
1106                     case COMPARISON_NE: TRACE("_ne"); break;
1107                     case COMPARISON_LE: TRACE("_le"); break;
1108                     default: TRACE("_(%u)", ins.flags);
1109                 }
1110             }
1111             else if (ins.handler_idx == WINED3DSIH_TEX
1112                     && shader_version >= WINED3DPS_VERSION(2,0)
1113                     && (ins.flags & WINED3DSI_TEXLD_PROJECT))
1114             {
1115                 TRACE("p");
1116             }
1117
1118             /* We already read the destination token, print it. */
1119             if (ins.dst_count)
1120             {
1121                 shader_dump_ins_modifiers(&dst_param);
1122                 TRACE(" ");
1123                 shader_dump_dst_param(&dst_param, shader_version);
1124             }
1125
1126             /* Other source tokens */
1127             for (i = ins.dst_count; i < (ins.dst_count + ins.src_count); ++i)
1128             {
1129                 fe->shader_read_src_param(&pToken, &src_param, &src_rel_addr, shader_version);
1130                 TRACE(!i ? " " : ", ");
1131                 shader_dump_src_param(&src_param, shader_version);
1132             }
1133         }
1134         TRACE("\n");
1135     }
1136 }
1137
1138 void shader_cleanup(IWineD3DBaseShader *iface)
1139 {
1140     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
1141
1142     ((IWineD3DDeviceImpl *)This->baseShader.device)->shader_backend->shader_destroy(iface);
1143     HeapFree(GetProcessHeap(), 0, This->baseShader.function);
1144     shader_delete_constant_list(&This->baseShader.constantsF);
1145     shader_delete_constant_list(&This->baseShader.constantsB);
1146     shader_delete_constant_list(&This->baseShader.constantsI);
1147     list_remove(&This->baseShader.shader_list_entry);
1148 }
1149
1150 static const SHADER_HANDLER shader_none_instruction_handler_table[WINED3DSIH_TABLE_SIZE] = {0};
1151 static void shader_none_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {}
1152 static void shader_none_select_depth_blt(IWineD3DDevice *iface, enum tex_types tex_type) {}
1153 static void shader_none_deselect_depth_blt(IWineD3DDevice *iface) {}
1154 static void shader_none_update_float_vertex_constants(IWineD3DDevice *iface, UINT start, UINT count) {}
1155 static void shader_none_update_float_pixel_constants(IWineD3DDevice *iface, UINT start, UINT count) {}
1156 static void shader_none_load_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1157 static void shader_none_load_np2fixup_constants(IWineD3DDevice *iface, char usePS, char useVS) {}
1158 static void shader_none_destroy(IWineD3DBaseShader *iface) {}
1159 static HRESULT shader_none_alloc(IWineD3DDevice *iface) {return WINED3D_OK;}
1160 static void shader_none_free(IWineD3DDevice *iface) {}
1161 static BOOL shader_none_dirty_const(IWineD3DDevice *iface) {return FALSE;}
1162 static GLuint shader_none_generate_pshader(IWineD3DPixelShader *iface, const struct wined3d_shader_frontend *fe,
1163         SHADER_BUFFER *buffer, const struct ps_compile_args *args)
1164 {
1165     FIXME("NONE shader backend asked to generate a pixel shader\n");
1166     return 0;
1167 }
1168 static GLuint shader_none_generate_vshader(IWineD3DVertexShader *iface, const struct wined3d_shader_frontend *fe,
1169         SHADER_BUFFER *buffer, const struct vs_compile_args *args)
1170 {
1171     FIXME("NONE shader backend asked to generate a vertex shader\n");
1172     return 0;
1173 }
1174
1175 #define GLINFO_LOCATION      (*gl_info)
1176 static void shader_none_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *pCaps)
1177 {
1178     /* Set the shader caps to 0 for the none shader backend */
1179     pCaps->VertexShaderVersion  = 0;
1180     pCaps->PixelShaderVersion    = 0;
1181     pCaps->PixelShader1xMaxValue = 0.0;
1182 }
1183 #undef GLINFO_LOCATION
1184 static BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup)
1185 {
1186     if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
1187     {
1188         TRACE("Checking support for fixup:\n");
1189         dump_color_fixup_desc(fixup);
1190     }
1191
1192     /* Faked to make some apps happy. */
1193     if (!is_yuv_fixup(fixup))
1194     {
1195         TRACE("[OK]\n");
1196         return TRUE;
1197     }
1198
1199     TRACE("[FAILED]\n");
1200     return FALSE;
1201 }
1202
1203 const shader_backend_t none_shader_backend = {
1204     shader_none_instruction_handler_table,
1205     shader_none_select,
1206     shader_none_select_depth_blt,
1207     shader_none_deselect_depth_blt,
1208     shader_none_update_float_vertex_constants,
1209     shader_none_update_float_pixel_constants,
1210     shader_none_load_constants,
1211     shader_none_load_np2fixup_constants,
1212     shader_none_destroy,
1213     shader_none_alloc,
1214     shader_none_free,
1215     shader_none_dirty_const,
1216     shader_none_generate_pshader,
1217     shader_none_generate_vshader,
1218     shader_none_get_caps,
1219     shader_none_color_fixup_supported,
1220 };