dlls/wined3d/arb_program_shader.c

   1 /*
   2  * Pixel and vertex shaders implementation using ARB_vertex_program
   3  * and ARB_fragment_program GL extensions.
   4  *
   5  * Copyright 2002-2003 Jason Edmeades
   6  * Copyright 2002-2003 Raphael Junqueira
   7  * Copyright 2004 Christian Costa
   8  * Copyright 2005 Oliver Stieber
   9  * Copyright 2006 Ivan Gyurdiev
  10  * Copyright 2006 Jason Green
  11  * Copyright 2006 Henri Verbeet
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2.1 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with this library; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  26  */
  27
  28 #include "config.h"
  29
  30 #include <math.h>
  31 #include <stdio.h>
  32
  33 #include "wined3d_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  36 WINE_DECLARE_DEBUG_CHANNEL(d3d_constants);
  37
  38 #define GLINFO_LOCATION      (*gl_info)
  39
  40 /********************************************************
  41  * ARB_[vertex/fragment]_program helper functions follow
  42  ********************************************************/
  43
  44 /**
  45  * Loads floating point constants into the currently set ARB_vertex/fragment_program.
  46  * When constant_list == NULL, it will load all the constants.
  47  *
  48  * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders)
  49  *  or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
  50  */
  51 static void shader_arb_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL_Info *gl_info, GLuint target_type,
  52         unsigned int max_constants, float* constants, struct list *constant_list) {
  53     constant_entry *constant;
  54     local_constant* lconst;
  55     int i;
  56
  57     if (TRACE_ON(d3d_shader)) {
  58         LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) {
  59             i = constant->idx;
  60             TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i,
  61                     constants[i * 4 + 0], constants[i * 4 + 1],
  62                     constants[i * 4 + 2], constants[i * 4 + 3]);
  63         }
  64     }
  65     LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) {
  66         i = constant->idx;
  67         GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, constants + (i * 4)));
  68     }
  69     checkGLcall("glProgramEnvParameter4fvARB()");
  70
  71     /* Load immediate constants */
  72     if (TRACE_ON(d3d_shader)) {
  73         LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
  74             GLfloat* values = (GLfloat*)lconst->value;
  75             TRACE_(d3d_constants)("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
  76                     values[0], values[1], values[2], values[3]);
  77         }
  78     }
  79     LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
  80         GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, lconst->idx, (GLfloat*)lconst->value));
  81     }
  82     checkGLcall("glProgramEnvParameter4fvARB()");
  83 }
  84
  85 /**
  86  * Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs.
  87  *
  88  * We only support float constants in ARB at the moment, so don't
  89  * worry about the Integers or Booleans
  90  */
  91 void shader_arb_load_constants(
  92     IWineD3DDevice* device,
  93     char usePixelShader,
  94     char useVertexShader) {
  95
  96     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device;
  97     IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
  98     WineD3D_GL_Info *gl_info = &((IWineD3DImpl*)deviceImpl->wineD3D)->gl_info;
  99
 100     if (useVertexShader) {
 101         IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
 102
 103         /* Load DirectX 9 float constants for vertex shader */
 104         shader_arb_load_constantsF(vshader, gl_info, GL_VERTEX_PROGRAM_ARB,
 105                                    GL_LIMITS(vshader_constantsF),
 106                                    stateBlock->vertexShaderConstantF,
 107                                    &stateBlock->set_vconstantsF);
 108
 109         /* Upload the position fixup */
 110         GL_EXTCALL(glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, ARB_SHADER_PRIVCONST_POS, deviceImpl->posFixup));
 111     }
 112
 113     if (usePixelShader) {
 114
 115         IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
 116
 117         /* Load DirectX 9 float constants for pixel shader */
 118         shader_arb_load_constantsF(pshader, gl_info, GL_FRAGMENT_PROGRAM_ARB,
 119                                    GL_LIMITS(pshader_constantsF),
 120                                    stateBlock->pixelShaderConstantF,
 121                                    &stateBlock->set_pconstantsF);
 122         if(((IWineD3DPixelShaderImpl *) pshader)->bumpenvmatconst) {
 123             /* needsbumpmat stores the stage number from where to load the matrix. bumpenvmatconst stores the
 124              * number of the constant to load the matrix into.
 125              * The state manager takes care that this function is always called if the bump env matrix changes
 126              */
 127             IWineD3DPixelShaderImpl *psi = (IWineD3DPixelShaderImpl *) pshader;
 128             float *data = (float *) &stateBlock->textureState[(int) psi->needsbumpmat][WINED3DTSS_BUMPENVMAT00];
 129             GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, psi->bumpenvmatconst, data));
 130         }
 131     }
 132 }
 133
 134 /* Generate the variable & register declarations for the ARB_vertex_program output target */
 135 void shader_generate_arb_declarations(
 136     IWineD3DBaseShader *iface,
 137     shader_reg_maps* reg_maps,
 138     SHADER_BUFFER* buffer,
 139     WineD3D_GL_Info* gl_info) {
 140
 141     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 142     DWORD i;
 143     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 144     unsigned max_constantsF = min(This->baseShader.limits.constant_float,
 145             (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
 146
 147     /* Temporary Output register */
 148     shader_addline(buffer, "TEMP TMP_OUT;\n");
 149
 150     for(i = 0; i < This->baseShader.limits.temporary; i++) {
 151         if (reg_maps->temporary[i])
 152             shader_addline(buffer, "TEMP R%u;\n", i);
 153     }
 154
 155     for (i = 0; i < This->baseShader.limits.address; i++) {
 156         if (reg_maps->address[i])
 157             shader_addline(buffer, "ADDRESS A%d;\n", i);
 158     }
 159
 160     for(i = 0; i < This->baseShader.limits.texcoord; i++) {
 161         if (reg_maps->texcoord[i])
 162             shader_addline(buffer,"TEMP T%u;\n", i);
 163     }
 164
 165     /* Texture coordinate registers must be pre-loaded */
 166     for (i = 0; i < This->baseShader.limits.texcoord; i++) {
 167         if (reg_maps->texcoord[i])
 168             shader_addline(buffer, "MOV T%u, fragment.texcoord[%u];\n", i, i);
 169     }
 170
 171     if(reg_maps->bumpmat /* Only  a pshader can use texbem */) {
 172         /* If the shader does not use all available constants, use the next free constant to load the bump mapping environment matrix from
 173          * the stateblock into the shader. If no constant is available don't load, texbem will then just sample the texture without applying
 174          * bump mapping.
 175          */
 176         if(max_constantsF < GL_LIMITS(pshader_constantsF)) {
 177             ((IWineD3DPixelShaderImpl *)This)->bumpenvmatconst = max_constantsF;
 178             shader_addline(buffer, "PARAM bumpenvmat = program.env[%d];\n", ((IWineD3DPixelShaderImpl *)This)->bumpenvmatconst);
 179         } else {
 180             FIXME("No free constant found to load environemnt bump mapping matrix into the shader. texbem instruction will not apply bump mapping\n");
 181         }
 182     }
 183
 184     /* Need to PARAM the environment parameters (constants) so we can use relative addressing */
 185     shader_addline(buffer, "PARAM C[%d] = { program.env[0..%d] };\n",
 186                    max_constantsF, max_constantsF - 1);
 187 }
 188
 189 static const char * const shift_tab[] = {
 190     "dummy",     /*  0 (none) */
 191     "coefmul.x", /*  1 (x2)   */
 192     "coefmul.y", /*  2 (x4)   */
 193     "coefmul.z", /*  3 (x8)   */
 194     "coefmul.w", /*  4 (x16)  */
 195     "dummy",     /*  5 (x32)  */
 196     "dummy",     /*  6 (x64)  */
 197     "dummy",     /*  7 (x128) */
 198     "dummy",     /*  8 (d256) */
 199     "dummy",     /*  9 (d128) */
 200     "dummy",     /* 10 (d64)  */
 201     "dummy",     /* 11 (d32)  */
 202     "coefdiv.w", /* 12 (d16)  */
 203     "coefdiv.z", /* 13 (d8)   */
 204     "coefdiv.y", /* 14 (d4)   */
 205     "coefdiv.x"  /* 15 (d2)   */
 206 };
 207
 208 static void shader_arb_get_write_mask(const DWORD param, char *write_mask) {
 209     char *ptr = write_mask;
 210
 211     if ((param & WINED3DSP_WRITEMASK_ALL) != WINED3DSP_WRITEMASK_ALL) {
 212         *ptr++ = '.';
 213         if (param & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
 214         if (param & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
 215         if (param & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
 216         if (param & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
 217     }
 218
 219     *ptr = '\0';
 220 }
 221
 222 static void shader_arb_get_swizzle(const DWORD param, BOOL fixup, char *swizzle_str) {
 223     /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
 224      * but addressed as "rgba". To fix this we need to swap the register's x
 225      * and z components. */
 226     const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
 227     char *ptr = swizzle_str;
 228
 229     /* swizzle bits fields: wwzzyyxx */
 230     DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
 231     DWORD swizzle_x = swizzle & 0x03;
 232     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 233     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 234     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 235
 236     /* If the swizzle is the default swizzle (ie, "xyzw"), we don't need to
 237      * generate a swizzle string. Unless we need to our own swizzling. */
 238     if ((WINED3DSP_NOSWIZZLE >> WINED3DSP_SWIZZLE_SHIFT) != swizzle || fixup) {
 239         *ptr++ = '.';
 240         if (swizzle_x == swizzle_y && swizzle_x == swizzle_z && swizzle_x == swizzle_w) {
 241             *ptr++ = swizzle_chars[swizzle_x];
 242         } else {
 243             *ptr++ = swizzle_chars[swizzle_x];
 244             *ptr++ = swizzle_chars[swizzle_y];
 245             *ptr++ = swizzle_chars[swizzle_z];
 246             *ptr++ = swizzle_chars[swizzle_w];
 247         }
 248     }
 249
 250     *ptr = '\0';
 251 }
 252
 253 static void pshader_get_register_name(
 254     const DWORD param, char* regstr) {
 255
 256     DWORD reg = param & WINED3DSP_REGNUM_MASK;
 257     DWORD regtype = shader_get_regtype(param);
 258
 259     switch (regtype) {
 260     case WINED3DSPR_TEMP:
 261         sprintf(regstr, "R%u", reg);
 262     break;
 263     case WINED3DSPR_INPUT:
 264         if (reg==0) {
 265             strcpy(regstr, "fragment.color.primary");
 266         } else {
 267             strcpy(regstr, "fragment.color.secondary");
 268         }
 269     break;
 270     case WINED3DSPR_CONST:
 271         sprintf(regstr, "C[%u]", reg);
 272     break;
 273     case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
 274         sprintf(regstr,"T%u", reg);
 275     break;
 276     case WINED3DSPR_COLOROUT:
 277         if (reg == 0)
 278             sprintf(regstr, "result.color");
 279         else {
 280             /* TODO: See GL_ARB_draw_buffers */
 281             FIXME("Unsupported write to render target %u\n", reg);
 282             sprintf(regstr, "unsupported_register");
 283         }
 284     break;
 285     case WINED3DSPR_DEPTHOUT:
 286         sprintf(regstr, "result.depth");
 287     break;
 288     case WINED3DSPR_ATTROUT:
 289         sprintf(regstr, "oD[%u]", reg);
 290     break;
 291     case WINED3DSPR_TEXCRDOUT:
 292         sprintf(regstr, "oT[%u]", reg);
 293     break;
 294     default:
 295         FIXME("Unhandled register name Type(%d)\n", regtype);
 296         sprintf(regstr, "unrecognized_register");
 297     break;
 298     }
 299 }
 300
 301 /* TODO: merge with pixel shader */
 302 static void vshader_program_add_param(SHADER_OPCODE_ARG *arg, const DWORD param, BOOL is_input, char *hwLine) {
 303
 304   IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) arg->shader;
 305
 306   /* oPos, oFog and oPts in D3D */
 307   static const char * const hwrastout_reg_names[] = { "TMP_OUT", "TMP_FOG", "result.pointsize" };
 308
 309   DWORD reg = param & WINED3DSP_REGNUM_MASK;
 310   DWORD regtype = shader_get_regtype(param);
 311   char  tmpReg[255];
 312   BOOL is_color = FALSE;
 313
 314   if ((param & WINED3DSP_SRCMOD_MASK) == WINED3DSPSM_NEG) {
 315       strcat(hwLine, " -");
 316   } else {
 317       strcat(hwLine, " ");
 318   }
 319
 320   switch (regtype) {
 321   case WINED3DSPR_TEMP:
 322     sprintf(tmpReg, "R%u", reg);
 323     strcat(hwLine, tmpReg);
 324     break;
 325   case WINED3DSPR_INPUT:
 326
 327     if (vshader_input_is_color((IWineD3DVertexShader*) This, reg))
 328         is_color = TRUE;
 329
 330     sprintf(tmpReg, "vertex.attrib[%u]", reg);
 331     strcat(hwLine, tmpReg);
 332     break;
 333   case WINED3DSPR_CONST:
 334     sprintf(tmpReg, "C[%s%u]", (param & WINED3DSHADER_ADDRMODE_RELATIVE) ? "A0.x + " : "", reg);
 335     strcat(hwLine, tmpReg);
 336     break;
 337   case WINED3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 338     sprintf(tmpReg, "A%u", reg);
 339     strcat(hwLine, tmpReg);
 340     break;
 341   case WINED3DSPR_RASTOUT:
 342     sprintf(tmpReg, "%s", hwrastout_reg_names[reg]);
 343     strcat(hwLine, tmpReg);
 344     break;
 345   case WINED3DSPR_ATTROUT:
 346     if (reg==0) {
 347        strcat(hwLine, "result.color.primary");
 348     } else {
 349        strcat(hwLine, "result.color.secondary");
 350     }
 351     break;
 352   case WINED3DSPR_TEXCRDOUT:
 353     sprintf(tmpReg, "result.texcoord[%u]", reg);
 354     strcat(hwLine, tmpReg);
 355     break;
 356   default:
 357     FIXME("Unknown reg type %d %d\n", regtype, reg);
 358     strcat(hwLine, "unrecognized_register");
 359     break;
 360   }
 361
 362   if (!is_input) {
 363     char write_mask[6];
 364     shader_arb_get_write_mask(param, write_mask);
 365     strcat(hwLine, write_mask);
 366   } else {
 367     char swizzle[6];
 368     shader_arb_get_swizzle(param, is_color, swizzle);
 369     strcat(hwLine, swizzle);
 370   }
 371 }
 372
 373 static void shader_hw_sample(SHADER_OPCODE_ARG* arg, DWORD sampler_idx, const char *dst_str, const char *coord_reg) {
 374     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 375     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
 376
 377     SHADER_BUFFER* buffer = arg->buffer;
 378     DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
 379     const char *tex_type;
 380
 381     switch(sampler_type) {
 382         case WINED3DSTT_1D:
 383             tex_type = "1D";
 384             break;
 385
 386         case WINED3DSTT_2D:
 387             tex_type = "2D";
 388             break;
 389
 390         case WINED3DSTT_VOLUME:
 391             tex_type = "3D";
 392             break;
 393
 394         case WINED3DSTT_CUBE:
 395             tex_type = "CUBE";
 396             break;
 397
 398         default:
 399             ERR("Unexpected texture type %d\n", sampler_type);
 400             tex_type = "";
 401     }
 402
 403     if (deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS] & WINED3DTTFF_PROJECTED) {
 404         shader_addline(buffer, "TXP %s, %s, texture[%u], %s;\n", dst_str, coord_reg, sampler_idx, tex_type);
 405     } else {
 406         shader_addline(buffer, "TEX %s, %s, texture[%u], %s;\n", dst_str, coord_reg, sampler_idx, tex_type);
 407     }
 408 }
 409
 410
 411 static void pshader_gen_input_modifier_line (
 412     SHADER_BUFFER* buffer,
 413     const DWORD instr,
 414     int tmpreg,
 415     char *outregstr) {
 416
 417     /* Generate a line that does the input modifier computation and return the input register to use */
 418     char regstr[256];
 419     char swzstr[20];
 420     int insert_line;
 421
 422     /* Assume a new line will be added */
 423     insert_line = 1;
 424
 425     /* Get register name */
 426     pshader_get_register_name(instr, regstr);
 427     shader_arb_get_swizzle(instr, FALSE, swzstr);
 428
 429     switch (instr & WINED3DSP_SRCMOD_MASK) {
 430     case WINED3DSPSM_NONE:
 431         sprintf(outregstr, "%s%s", regstr, swzstr);
 432         insert_line = 0;
 433         break;
 434     case WINED3DSPSM_NEG:
 435         sprintf(outregstr, "-%s%s", regstr, swzstr);
 436         insert_line = 0;
 437         break;
 438     case WINED3DSPSM_BIAS:
 439         shader_addline(buffer, "ADD T%c, %s, -coefdiv.x;\n", 'A' + tmpreg, regstr);
 440         break;
 441     case WINED3DSPSM_BIASNEG:
 442         shader_addline(buffer, "ADD T%c, -%s, coefdiv.x;\n", 'A' + tmpreg, regstr);
 443         break;
 444     case WINED3DSPSM_SIGN:
 445         shader_addline(buffer, "MAD T%c, %s, coefmul.x, -one.x;\n", 'A' + tmpreg, regstr);
 446         break;
 447     case WINED3DSPSM_SIGNNEG:
 448         shader_addline(buffer, "MAD T%c, %s, -coefmul.x, one.x;\n", 'A' + tmpreg, regstr);
 449         break;
 450     case WINED3DSPSM_COMP:
 451         shader_addline(buffer, "SUB T%c, one.x, %s;\n", 'A' + tmpreg, regstr);
 452         break;
 453     case WINED3DSPSM_X2:
 454         shader_addline(buffer, "ADD T%c, %s, %s;\n", 'A' + tmpreg, regstr, regstr);
 455         break;
 456     case WINED3DSPSM_X2NEG:
 457         shader_addline(buffer, "ADD T%c, -%s, -%s;\n", 'A' + tmpreg, regstr, regstr);
 458         break;
 459     case WINED3DSPSM_DZ:
 460         shader_addline(buffer, "RCP T%c, %s.z;\n", 'A' + tmpreg, regstr);
 461         shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
 462         break;
 463     case WINED3DSPSM_DW:
 464         shader_addline(buffer, "RCP T%c, %s.w;\n", 'A' + tmpreg, regstr);
 465         shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
 466         break;
 467     default:
 468         sprintf(outregstr, "%s%s", regstr, swzstr);
 469         insert_line = 0;
 470     }
 471
 472     /* Return modified or original register, with swizzle */
 473     if (insert_line)
 474         sprintf(outregstr, "T%c%s", 'A' + tmpreg, swzstr);
 475 }
 476
 477 inline static void pshader_gen_output_modifier_line(
 478     SHADER_BUFFER* buffer,
 479     int saturate,
 480     char *write_mask,
 481     int shift,
 482     char *regstr) {
 483
 484     /* Generate a line that does the output modifier computation */
 485     shader_addline(buffer, "MUL%s %s%s, %s, %s;\n", saturate ? "_SAT" : "",
 486         regstr, write_mask, regstr, shift_tab[shift]);
 487 }
 488
 489 void pshader_hw_cnd(SHADER_OPCODE_ARG* arg) {
 490
 491     SHADER_BUFFER* buffer = arg->buffer;
 492     char dst_wmask[20];
 493     char dst_name[50];
 494     char src_name[3][50];
 495
 496     /* FIXME: support output modifiers */
 497
 498     /* Handle output register */
 499     pshader_get_register_name(arg->dst, dst_name);
 500     shader_arb_get_write_mask(arg->dst, dst_wmask);
 501     strcat(dst_name, dst_wmask);
 502
 503     /* Generate input register names (with modifiers) */
 504     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src_name[0]);
 505     pshader_gen_input_modifier_line(buffer, arg->src[1], 1, src_name[1]);
 506     pshader_gen_input_modifier_line(buffer, arg->src[2], 2, src_name[2]);
 507
 508     shader_addline(buffer, "ADD TMP, -%s, coefdiv.x;\n", src_name[0]);
 509     shader_addline(buffer, "CMP %s, TMP, %s, %s;\n", dst_name, src_name[1], src_name[2]);
 510 }
 511
 512 void pshader_hw_cmp(SHADER_OPCODE_ARG* arg) {
 513
 514     SHADER_BUFFER* buffer = arg->buffer;
 515     char dst_wmask[20];
 516     char dst_name[50];
 517     char src_name[3][50];
 518
 519     /* FIXME: support output modifiers */
 520
 521     /* Handle output register */
 522     pshader_get_register_name(arg->dst, dst_name);
 523     shader_arb_get_write_mask(arg->dst, dst_wmask);
 524     strcat(dst_name, dst_wmask);
 525
 526     /* Generate input register names (with modifiers) */
 527     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src_name[0]);
 528     pshader_gen_input_modifier_line(buffer, arg->src[1], 1, src_name[1]);
 529     pshader_gen_input_modifier_line(buffer, arg->src[2], 2, src_name[2]);
 530
 531     shader_addline(buffer, "CMP %s, %s, %s, %s;\n", dst_name,
 532         src_name[0], src_name[2], src_name[1]);
 533 }
 534
 535 /* Map the opcode 1-to-1 to the GL code */
 536 void pshader_hw_map2gl(SHADER_OPCODE_ARG* arg) {
 537
 538      CONST SHADER_OPCODE* curOpcode = arg->opcode;
 539      SHADER_BUFFER* buffer = arg->buffer;
 540      DWORD dst = arg->dst;
 541      DWORD* src = arg->src;
 542
 543      unsigned int i;
 544      char tmpLine[256];
 545
 546      /* Output token related */
 547      char output_rname[256];
 548      char output_wmask[20];
 549      BOOL saturate = FALSE;
 550      BOOL centroid = FALSE;
 551      BOOL partialprecision = FALSE;
 552      DWORD shift;
 553
 554      strcpy(tmpLine, curOpcode->glname);
 555
 556      /* Process modifiers */
 557      if (0 != (dst & WINED3DSP_DSTMOD_MASK)) {
 558          DWORD mask = dst & WINED3DSP_DSTMOD_MASK;
 559
 560          saturate = mask & WINED3DSPDM_SATURATE;
 561          centroid = mask & WINED3DSPDM_MSAMPCENTROID;
 562          partialprecision = mask & WINED3DSPDM_PARTIALPRECISION;
 563          mask &= ~(WINED3DSPDM_MSAMPCENTROID | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_SATURATE);
 564          if (mask)
 565             FIXME("Unrecognized modifier(0x%#x)\n", mask >> WINED3DSP_DSTMOD_SHIFT);
 566
 567          if (centroid)
 568              FIXME("Unhandled modifier(0x%#x)\n", mask >> WINED3DSP_DSTMOD_SHIFT);
 569      }
 570      shift = (dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
 571
 572       /* Generate input and output registers */
 573       if (curOpcode->num_params > 0) {
 574           char operands[4][100];
 575
 576           /* Generate input register names (with modifiers) */
 577           for (i = 1; i < curOpcode->num_params; ++i)
 578               pshader_gen_input_modifier_line(buffer, src[i-1], i-1, operands[i]);
 579
 580           /* Handle output register */
 581           pshader_get_register_name(dst, output_rname);
 582           strcpy(operands[0], output_rname);
 583           shader_arb_get_write_mask(dst, output_wmask);
 584           strcat(operands[0], output_wmask);
 585
 586           if (saturate && (shift == 0))
 587              strcat(tmpLine, "_SAT");
 588           strcat(tmpLine, " ");
 589           strcat(tmpLine, operands[0]);
 590           for (i = 1; i < curOpcode->num_params; i++) {
 591               strcat(tmpLine, ", ");
 592               strcat(tmpLine, operands[i]);
 593           }
 594           strcat(tmpLine,";\n");
 595           shader_addline(buffer, tmpLine);
 596
 597           /* A shift requires another line. */
 598           if (shift != 0)
 599               pshader_gen_output_modifier_line(buffer, saturate, output_wmask, shift, output_rname);
 600       }
 601 }
 602
 603 void pshader_hw_tex(SHADER_OPCODE_ARG* arg) {
 604
 605     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 606
 607     DWORD dst = arg->dst;
 608     DWORD* src = arg->src;
 609     SHADER_BUFFER* buffer = arg->buffer;
 610     DWORD hex_version = This->baseShader.hex_version;
 611
 612     char reg_dest[40];
 613     char reg_coord[40];
 614     DWORD reg_dest_code;
 615     DWORD reg_sampler_code;
 616
 617     /* All versions have a destination register */
 618     reg_dest_code = dst & WINED3DSP_REGNUM_MASK;
 619     pshader_get_register_name(dst, reg_dest);
 620
 621     /* 1.0-1.3: Use destination register as coordinate source.
 622        1.4+: Use provided coordinate source register. */
 623    if (hex_version < WINED3DPS_VERSION(1,4))
 624       strcpy(reg_coord, reg_dest);
 625    else
 626       pshader_gen_input_modifier_line(buffer, src[0], 0, reg_coord);
 627
 628   /* 1.0-1.4: Use destination register number as texture code.
 629      2.0+: Use provided sampler number as texure code. */
 630   if (hex_version < WINED3DPS_VERSION(2,0))
 631      reg_sampler_code = reg_dest_code;
 632   else
 633      reg_sampler_code = src[1] & WINED3DSP_REGNUM_MASK;
 634
 635   shader_hw_sample(arg, reg_sampler_code, reg_dest, reg_coord);
 636 }
 637
 638 void pshader_hw_texcoord(SHADER_OPCODE_ARG* arg) {
 639
 640     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 641     DWORD dst = arg->dst;
 642     DWORD* src = arg->src;
 643     SHADER_BUFFER* buffer = arg->buffer;
 644     DWORD hex_version = This->baseShader.hex_version;
 645
 646     char tmp[20];
 647     shader_arb_get_write_mask(dst, tmp);
 648     if (hex_version != WINED3DPS_VERSION(1,4)) {
 649         DWORD reg = dst & WINED3DSP_REGNUM_MASK;
 650         shader_addline(buffer, "MOV_SAT T%u%s, fragment.texcoord[%u];\n", reg, tmp, reg);
 651     } else {
 652         DWORD reg1 = dst & WINED3DSP_REGNUM_MASK;
 653         DWORD reg2 = src[0] & WINED3DSP_REGNUM_MASK;
 654         shader_addline(buffer, "MOV R%u%s, fragment.texcoord[%u];\n", reg1, tmp, reg2);
 655    }
 656 }
 657
 658 void pshader_hw_texreg2ar(SHADER_OPCODE_ARG* arg) {
 659
 660      SHADER_BUFFER* buffer = arg->buffer;
 661
 662      DWORD reg1 = arg->dst & WINED3DSP_REGNUM_MASK;
 663      DWORD reg2 = arg->src[0] & WINED3DSP_REGNUM_MASK;
 664      char dst_str[8];
 665
 666      sprintf(dst_str, "T%u", reg1);
 667      shader_addline(buffer, "MOV TMP.r, T%u.a;\n", reg2);
 668      shader_addline(buffer, "MOV TMP.g, T%u.r;\n", reg2);
 669      shader_hw_sample(arg, reg1, dst_str, "TMP");
 670 }
 671
 672 void pshader_hw_texreg2gb(SHADER_OPCODE_ARG* arg) {
 673
 674      SHADER_BUFFER* buffer = arg->buffer;
 675
 676      DWORD reg1 = arg->dst & WINED3DSP_REGNUM_MASK;
 677      DWORD reg2 = arg->src[0] & WINED3DSP_REGNUM_MASK;
 678      char dst_str[8];
 679
 680      sprintf(dst_str, "T%u", reg1);
 681      shader_addline(buffer, "MOV TMP.r, T%u.g;\n", reg2);
 682      shader_addline(buffer, "MOV TMP.g, T%u.b;\n", reg2);
 683      shader_hw_sample(arg, reg1, dst_str, "TMP");
 684 }
 685
 686 void pshader_hw_texbem(SHADER_OPCODE_ARG* arg) {
 687 #if 0
 688      SHADER_BUFFER* buffer = arg->buffer;
 689      DWORD reg1 = arg->dst  & WINED3DSP_REGNUM_MASK;
 690      DWORD reg2 = arg->src[0] & WINED3DSP_REGNUM_MASK;
 691      char dst_str[8];
 692
 693      /* FIXME: Should apply the BUMPMAPENV matrix */
 694      sprintf(dst_str, "T%u", reg1);
 695      shader_addline(buffer, "ADD TMP.rg, fragment.texcoord[%u], T%u;\n", reg1, reg2);
 696      shader_hw_sample(arg, reg1, dst_str, "TMP");
 697 #endif
 698     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 699
 700     DWORD dst = arg->dst;
 701     DWORD src = arg->src[0] & WINED3DSP_REGNUM_MASK;
 702     SHADER_BUFFER* buffer = arg->buffer;
 703
 704     char reg_coord[40];
 705     DWORD reg_dest_code;
 706
 707     /* All versions have a destination register */
 708     reg_dest_code = dst & WINED3DSP_REGNUM_MASK;
 709     /* Can directly use the name because texbem is only valid for <= 1.3 shaders */
 710     pshader_get_register_name(dst, reg_coord);
 711
 712     if(This->bumpenvmatconst) {
 713         /*shader_addline(buffer, "MOV T%u, fragment.texcoord[%u];\n", 1, 1); Not needed - done already */
 714         shader_addline(buffer, "SWZ TMP2, bumpenvmat, x, z, 0, 0;\n");
 715         shader_addline(buffer, "DP3 TMP.r, TMP2, T%u;\n", src);
 716         shader_addline(buffer, "SWZ TMP2, bumpenvmat, y, w, 0, 0;\n");
 717         shader_addline(buffer, "DP3 TMP.g, TMP2, T%u;\n", src);
 718         shader_addline(buffer, "ADD TMP.rg, TMP, %s;\n", reg_coord);
 719         /* Not sure about this, but hl2 needs it. It uses a projected texture with texbem and depends on the 4th coordinate */
 720         shader_addline(buffer, "MOV TMP.a, %s;\n", reg_coord);
 721         shader_hw_sample(arg, reg_dest_code, reg_coord, "TMP");
 722     } else {
 723         /* Without a bump matrix loaded, just sample with the unmodified coordinates */
 724         shader_hw_sample(arg, reg_dest_code, reg_coord, reg_coord);
 725     }
 726 }
 727
 728 void pshader_hw_texm3x2pad(SHADER_OPCODE_ARG* arg) {
 729
 730     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 731     SHADER_BUFFER* buffer = arg->buffer;
 732     char src0_name[50];
 733
 734     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 735     shader_addline(buffer, "DP3 TMP.x, T%u, %s;\n", reg, src0_name);
 736 }
 737
 738 void pshader_hw_texm3x2tex(SHADER_OPCODE_ARG* arg) {
 739
 740     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 741     SHADER_BUFFER* buffer = arg->buffer;
 742     char dst_str[8];
 743     char src0_name[50];
 744
 745     sprintf(dst_str, "T%u", reg);
 746     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 747     shader_addline(buffer, "DP3 TMP.y, T%u, %s;\n", reg, src0_name);
 748     shader_hw_sample(arg, reg, dst_str, "TMP");
 749 }
 750
 751 void pshader_hw_texm3x3pad(SHADER_OPCODE_ARG* arg) {
 752
 753     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 754     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 755     SHADER_BUFFER* buffer = arg->buffer;
 756     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 757     char src0_name[50];
 758
 759     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 760     shader_addline(buffer, "DP3 TMP.%c, T%u, %s;\n", 'x' + current_state->current_row, reg, src0_name);
 761     current_state->texcoord_w[current_state->current_row++] = reg;
 762 }
 763
 764 void pshader_hw_texm3x3tex(SHADER_OPCODE_ARG* arg) {
 765
 766     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 767     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 768     SHADER_BUFFER* buffer = arg->buffer;
 769     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 770     char dst_str[8];
 771     char src0_name[50];
 772
 773     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 774     shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
 775
 776     /* Sample the texture using the calculated coordinates */
 777     sprintf(dst_str, "T%u", reg);
 778     shader_hw_sample(arg, reg, dst_str, "TMP");
 779     current_state->current_row = 0;
 780 }
 781
 782 void pshader_hw_texm3x3vspec(SHADER_OPCODE_ARG* arg) {
 783
 784     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 785     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 786     SHADER_BUFFER* buffer = arg->buffer;
 787     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 788     char dst_str[8];
 789     char src0_name[50];
 790
 791     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 792     shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
 793
 794     /* Construct the eye-ray vector from w coordinates */
 795     shader_addline(buffer, "MOV TMP2.x, fragment.texcoord[%u].w;\n", current_state->texcoord_w[0]);
 796     shader_addline(buffer, "MOV TMP2.y, fragment.texcoord[%u].w;\n", current_state->texcoord_w[1]);
 797     shader_addline(buffer, "MOV TMP2.z, fragment.texcoord[%u].w;\n", reg);
 798
 799     /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
 800     shader_addline(buffer, "DP3 TMP.w, TMP, TMP2;\n");
 801     shader_addline(buffer, "MUL TMP, TMP.w, TMP;\n");
 802     shader_addline(buffer, "MAD TMP, coefmul.x, TMP, -TMP2;\n");
 803
 804     /* Sample the texture using the calculated coordinates */
 805     sprintf(dst_str, "T%u", reg);
 806     shader_hw_sample(arg, reg, dst_str, "TMP");
 807     current_state->current_row = 0;
 808 }
 809
 810 void pshader_hw_texm3x3spec(SHADER_OPCODE_ARG* arg) {
 811
 812     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 813     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 814     DWORD reg3 = arg->src[1] & WINED3DSP_REGNUM_MASK;
 815     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 816     SHADER_BUFFER* buffer = arg->buffer;
 817     char dst_str[8];
 818     char src0_name[50];
 819
 820     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 821     shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
 822
 823     /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
 824     shader_addline(buffer, "DP3 TMP.w, TMP, C[%u];\n", reg3);
 825     shader_addline(buffer, "MUL TMP, TMP.w, TMP;\n");
 826     shader_addline(buffer, "MAD TMP, coefmul.x, TMP, -C[%u];\n", reg3);
 827
 828     /* Sample the texture using the calculated coordinates */
 829     sprintf(dst_str, "T%u", reg);
 830     shader_hw_sample(arg, reg, dst_str, "TMP");
 831     current_state->current_row = 0;
 832 }
 833
 834 /** Handles transforming all WINED3DSIO_M?x? opcodes for
 835     Vertex shaders to ARB_vertex_program codes */
 836 void vshader_hw_mnxn(SHADER_OPCODE_ARG* arg) {
 837
 838     int i;
 839     int nComponents = 0;
 840     SHADER_OPCODE_ARG tmpArg;
 841
 842     memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
 843
 844     /* Set constants for the temporary argument */
 845     tmpArg.shader      = arg->shader;
 846     tmpArg.buffer      = arg->buffer;
 847     tmpArg.src[0]      = arg->src[0];
 848     tmpArg.src_addr[0] = arg->src_addr[0];
 849     tmpArg.src_addr[1] = arg->src_addr[1];
 850     tmpArg.reg_maps = arg->reg_maps;
 851
 852     switch(arg->opcode->opcode) {
 853     case WINED3DSIO_M4x4:
 854         nComponents = 4;
 855         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
 856         break;
 857     case WINED3DSIO_M4x3:
 858         nComponents = 3;
 859         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
 860         break;
 861     case WINED3DSIO_M3x4:
 862         nComponents = 4;
 863         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
 864         break;
 865     case WINED3DSIO_M3x3:
 866         nComponents = 3;
 867         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
 868         break;
 869     case WINED3DSIO_M3x2:
 870         nComponents = 2;
 871         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
 872         break;
 873     default:
 874         break;
 875     }
 876
 877     for (i = 0; i < nComponents; i++) {
 878         tmpArg.dst = ((arg->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
 879         tmpArg.src[1] = arg->src[1]+i;
 880         vshader_hw_map2gl(&tmpArg);
 881     }
 882 }
 883
 884 void vshader_hw_rsq_rcp(SHADER_OPCODE_ARG* arg) {
 885     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 886     SHADER_BUFFER* buffer = arg->buffer;
 887     DWORD dst = arg->dst;
 888     DWORD src = arg->src[0];
 889     DWORD swizzle = (src & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
 890
 891     char tmpLine[256];
 892
 893     strcpy(tmpLine, curOpcode->glname); /* Opcode */
 894     vshader_program_add_param(arg, dst, FALSE, tmpLine); /* Destination */
 895     strcat(tmpLine, ",");
 896     vshader_program_add_param(arg, src, TRUE, tmpLine);
 897     if ((WINED3DSP_NOSWIZZLE >> WINED3DSP_SWIZZLE_SHIFT) == swizzle) {
 898         /* Dx sdk says .x is used if no swizzle is given */
 899         strcat(tmpLine, ".x");
 900     }
 901
 902     shader_addline(buffer, "%s;\n", tmpLine);
 903 }
 904
 905 /* TODO: merge with pixel shader */
 906 /* Map the opcode 1-to-1 to the GL code */
 907 void vshader_hw_map2gl(SHADER_OPCODE_ARG* arg) {
 908
 909     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 910     SHADER_BUFFER* buffer = arg->buffer;
 911     DWORD dst = arg->dst;
 912     DWORD* src = arg->src;
 913
 914     DWORD dst_regtype = shader_get_regtype(dst);
 915     char tmpLine[256];
 916     unsigned int i;
 917
 918     if ((curOpcode->opcode == WINED3DSIO_MOV && dst_regtype == WINED3DSPR_ADDR) || curOpcode->opcode == WINED3DSIO_MOVA)
 919         strcpy(tmpLine, "ARL");
 920     else
 921         strcpy(tmpLine, curOpcode->glname);
 922
 923     if (curOpcode->num_params > 0) {
 924         vshader_program_add_param(arg, dst, FALSE, tmpLine);
 925         for (i = 1; i < curOpcode->num_params; ++i) {
 926            strcat(tmpLine, ",");
 927            vshader_program_add_param(arg, src[i-1], TRUE, tmpLine);
 928         }
 929     }
 930    shader_addline(buffer, "%s;\n", tmpLine);
 931 }
 932
 933 static GLuint create_arb_blt_vertex_program(WineD3D_GL_Info *gl_info) {
 934     GLuint program_id = 0;
 935     const char *blt_vprogram =
 936         "!!ARBvp1.0\n"
 937         "PARAM c[1] = { { 1, 0.5 } };\n"
 938         "MOV result.position, vertex.position;\n"
 939         "MOV result.color, c[0].x;\n"
 940         "MAD result.texcoord[0].y, -vertex.position, c[0], c[0];\n"
 941         "MAD result.texcoord[0].x, vertex.position, c[0].y, c[0].y;\n"
 942         "END\n";
 943
 944     GL_EXTCALL(glGenProgramsARB(1, &program_id));
 945     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, program_id));
 946     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_vprogram), blt_vprogram));
 947
 948     if (glGetError() == GL_INVALID_OPERATION) {
 949         GLint pos;
 950         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
 951         FIXME("Vertex program error at position %d: %s\n", pos,
 952             debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
 953     }
 954
 955     return program_id;
 956 }
 957
 958 static GLuint create_arb_blt_fragment_program(WineD3D_GL_Info *gl_info) {
 959     GLuint program_id = 0;
 960     const char *blt_fprogram =
 961         "!!ARBfp1.0\n"
 962         "TEMP R0;\n"
 963         "TEX R0.x, fragment.texcoord[0], texture[0], 2D;\n"
 964         "MOV result.depth.z, R0.x;\n"
 965         "END\n";
 966
 967     GL_EXTCALL(glGenProgramsARB(1, &program_id));
 968     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program_id));
 969     GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_fprogram), blt_fprogram));
 970
 971     if (glGetError() == GL_INVALID_OPERATION) {
 972         GLint pos;
 973         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
 974         FIXME("Fragment program error at position %d: %s\n", pos,
 975             debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
 976     }
 977
 978     return program_id;
 979 }
 980
 981 static void shader_arb_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {
 982     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 983     WineD3D_GL_Info *gl_info = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
 984
 985     if (useVS) {
 986         TRACE("Using vertex shader\n");
 987
 988         /* Bind the vertex program */
 989         GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB,
 990             ((IWineD3DVertexShaderImpl *)This->stateBlock->vertexShader)->baseShader.prgId));
 991         checkGLcall("glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertexShader->prgId);");
 992
 993         /* Enable OpenGL vertex programs */
 994         glEnable(GL_VERTEX_PROGRAM_ARB);
 995         checkGLcall("glEnable(GL_VERTEX_PROGRAM_ARB);");
 996         TRACE("(%p) : Bound vertex program %u and enabled GL_VERTEX_PROGRAM_ARB\n",
 997             This, ((IWineD3DVertexShaderImpl *)This->stateBlock->vertexShader)->baseShader.prgId);
 998     } else if(GL_SUPPORT(ARB_VERTEX_PROGRAM)) {
 999         glDisable(GL_VERTEX_PROGRAM_ARB);
1000         checkGLcall("glDisable(GL_VERTEX_PROGRAM_ARB)");
1001     }
1002
1003     if (usePS) {
1004         TRACE("Using pixel shader\n");
1005
1006         /* Bind the fragment program */
1007         GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,
1008             ((IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader)->baseShader.prgId));
1009         checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, pixelShader->prgId);");
1010
1011         /* Enable OpenGL fragment programs */
1012         glEnable(GL_FRAGMENT_PROGRAM_ARB);
1013         checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB);");
1014         TRACE("(%p) : Bound fragment program %u and enabled GL_FRAGMENT_PROGRAM_ARB\n",
1015             This, ((IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader)->baseShader.prgId);
1016     } else if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
1017         glDisable(GL_FRAGMENT_PROGRAM_ARB);
1018         checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
1019     }
1020 }
1021
1022 static void shader_arb_select_depth_blt(IWineD3DDevice *iface) {
1023     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1024     WineD3D_GL_Info *gl_info = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
1025     static GLuint vprogram_id = 0;
1026     static GLuint fprogram_id = 0;
1027
1028     if (!vprogram_id) vprogram_id = create_arb_blt_vertex_program(gl_info);
1029     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vprogram_id));
1030     glEnable(GL_VERTEX_PROGRAM_ARB);
1031
1032     if (!fprogram_id) fprogram_id = create_arb_blt_fragment_program(gl_info);
1033     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fprogram_id));
1034     glEnable(GL_FRAGMENT_PROGRAM_ARB);
1035 }
1036
1037 static void shader_arb_cleanup(IWineD3DDevice *iface) {
1038     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1039     WineD3D_GL_Info *gl_info = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
1040     if (GL_SUPPORT(ARB_VERTEX_PROGRAM)) glDisable(GL_VERTEX_PROGRAM_ARB);
1041     if (GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) glDisable(GL_FRAGMENT_PROGRAM_ARB);
1042 }
1043
1044 const shader_backend_t arb_program_shader_backend = {
1045     &shader_arb_select,
1046     &shader_arb_select_depth_blt,
1047     &shader_arb_load_constants,
1048     &shader_arb_cleanup
1049 };