git.oblomov.eu Git - wine/blob - 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  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
  13  * Copyright 2009 Henri Verbeet for CodeWeavers
  14  *
  15  * This library is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU Lesser General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2.1 of the License, or (at your option) any later version.
  19  *
  20  * This library is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * Lesser General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Lesser General Public
  26  * License along with this library; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  28  */
  29
  30 #include "config.h"
  31
  32 #include <math.h>
  33 #include <stdio.h>
  34
  35 #include "wined3d_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  38 WINE_DECLARE_DEBUG_CHANNEL(d3d_constants);
  39 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
  40 WINE_DECLARE_DEBUG_CHANNEL(d3d);
  41
  42 #define GLINFO_LOCATION      (*gl_info)
  43
  44 /* GL locking for state handlers is done by the caller. */
  45 static BOOL need_mova_const(IWineD3DBaseShader *shader, const WineD3D_GL_Info *gl_info) {
  46     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) shader;
  47     if(!This->baseShader.reg_maps.usesmova) return FALSE;
  48     return !GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION);
  49 }
  50
  51 static BOOL need_helper_const(const WineD3D_GL_Info *gl_info) {
  52     if(!GL_SUPPORT(NV_VERTEX_PROGRAM)   || /* Need to init colors */
  53        gl_info->arb_vs_offset_limit     || /* Have to init texcoords */
  54        gl_info->set_texcoord_w) {          /* Load the immval offset */
  55         return TRUE;
  56     }
  57     return FALSE;
  58 }
  59
  60 static unsigned int reserved_vs_const(IWineD3DBaseShader *shader, const WineD3D_GL_Info *gl_info) {
  61     unsigned int ret = 1;
  62     /* We use one PARAM for the pos fixup, and in some cases one to load
  63      * some immediate values into the shader
  64      */
  65     if(need_helper_const(gl_info)) ret++;
  66     if(need_mova_const(shader, gl_info)) ret++;
  67     return ret;
  68 }
  69
  70 /* Internally used shader constants. Applications can use constants 0 to GL_LIMITS(vshader_constantsF) - 1,
  71  * so upload them above that
  72  */
  73 #define ARB_SHADER_PRIVCONST_BASE (GL_LIMITS(vshader_constantsF) - 1)
  74 #define ARB_SHADER_PRIVCONST_POS ARB_SHADER_PRIVCONST_BASE + 0
  75
  76 /* ARB_program_shader private data */
  77 struct control_frame
  78 {
  79     struct                          list entry;
  80     enum
  81     {
  82         IF,
  83         IFC,
  84         LOOP,
  85         REP
  86     } type;
  87     BOOL                            muting;
  88     BOOL                            outer_loop;
  89     union
  90     {
  91         unsigned int                loop_no;
  92         unsigned int                ifc_no;
  93     };
  94     DWORD                           loop_control[3];
  95     BOOL                            had_else;
  96 };
  97
  98 struct arb_ps_compile_args
  99 {
 100     struct ps_compile_args          super;
 101     DWORD                           bools; /* WORD is enough, use DWORD for alignment */
 102     unsigned char                   loop_ctrl[MAX_CONST_I][3];
 103 };
 104
 105 struct stb_const_desc
 106 {
 107     unsigned char           texunit;
 108     UINT                    const_num;
 109 };
 110
 111 struct arb_ps_compiled_shader
 112 {
 113     struct arb_ps_compile_args      args;
 114     GLuint                          prgId;
 115     struct stb_const_desc           bumpenvmatconst[MAX_TEXTURES];
 116     unsigned char                   numbumpenvmatconsts;
 117     struct stb_const_desc           luminanceconst[MAX_TEXTURES];
 118     UINT                            int_consts[MAX_CONST_I];
 119     char                            num_int_consts;
 120     UINT                            ycorrection;
 121 };
 122
 123 struct arb_vs_compile_args
 124 {
 125     struct vs_compile_args          super;
 126     DWORD                           bools; /* WORD is enough, use DWORD for alignment */
 127     unsigned char                   loop_ctrl[MAX_CONST_I][3];
 128 };
 129
 130 struct arb_vs_compiled_shader
 131 {
 132     struct arb_vs_compile_args      args;
 133     GLuint                          prgId;
 134     UINT                            int_consts[MAX_CONST_I];
 135     char                            num_int_consts;
 136 };
 137
 138 struct recorded_instruction
 139 {
 140     struct wined3d_shader_instruction ins;
 141     struct list entry;
 142 };
 143
 144 struct shader_arb_ctx_priv
 145 {
 146     char addr_reg[20];
 147     enum
 148     {
 149         /* plain GL_ARB_vertex_program or GL_ARB_fragment_program */
 150         ARB,
 151         /* GL_NV_vertex_progam2_option or GL_NV_fragment_program_option */
 152         NV2,
 153         /* GL_NV_vertex_program3 or GL_NV_fragment_program2 */
 154         NV3
 155     } target_version;
 156
 157     const struct arb_vs_compile_args    *cur_vs_args;
 158     const struct arb_ps_compile_args    *cur_ps_args;
 159     const struct arb_ps_compiled_shader *compiled_fprog;
 160     const struct arb_vs_compiled_shader *compiled_vprog;
 161     struct list                         control_frames;
 162     struct list                         record;
 163     BOOL                                recording;
 164     BOOL                                muted;
 165     unsigned int                        num_loops, loop_depth, num_ifcs;
 166     int                                 aL;
 167 };
 168
 169 struct arb_pshader_private {
 170     struct arb_ps_compiled_shader   *gl_shaders;
 171     UINT                            num_gl_shaders, shader_array_size;
 172 };
 173
 174 struct arb_vshader_private {
 175     struct arb_vs_compiled_shader   *gl_shaders;
 176     UINT                            num_gl_shaders, shader_array_size;
 177 };
 178
 179 struct shader_arb_priv
 180 {
 181     GLuint                  current_vprogram_id;
 182     GLuint                  current_fprogram_id;
 183     const struct arb_ps_compiled_shader *compiled_fprog;
 184     const struct arb_vs_compiled_shader *compiled_vprog;
 185     GLuint                  depth_blt_vprogram_id;
 186     GLuint                  depth_blt_fprogram_id[tex_type_count];
 187     BOOL                    use_arbfp_fixed_func;
 188     struct wine_rb_tree     fragment_shaders;
 189 };
 190
 191 /********************************************************
 192  * ARB_[vertex/fragment]_program helper functions follow
 193  ********************************************************/
 194
 195 /**
 196  * Loads floating point constants into the currently set ARB_vertex/fragment_program.
 197  * When constant_list == NULL, it will load all the constants.
 198  *
 199  * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders)
 200  *  or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
 201  */
 202 /* GL locking is done by the caller */
 203 static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl* This, const WineD3D_GL_Info *gl_info,
 204         GLuint target_type, unsigned int max_constants, const float *constants, char *dirty_consts)
 205 {
 206     local_constant* lconst;
 207     DWORD i, j;
 208     unsigned int ret;
 209
 210     if (TRACE_ON(d3d_shader)) {
 211         for(i = 0; i < max_constants; i++) {
 212             if(!dirty_consts[i]) continue;
 213             TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i,
 214                         constants[i * 4 + 0], constants[i * 4 + 1],
 215                         constants[i * 4 + 2], constants[i * 4 + 3]);
 216         }
 217     }
 218     /* In 1.X pixel shaders constants are implicitly clamped in the range [-1;1] */
 219     if (target_type == GL_FRAGMENT_PROGRAM_ARB && This->baseShader.reg_maps.shader_version.major == 1)
 220     {
 221         float lcl_const[4];
 222         for(i = 0; i < max_constants; i++) {
 223             if(!dirty_consts[i]) continue;
 224             dirty_consts[i] = 0;
 225
 226             j = 4 * i;
 227             if(constants[j + 0] > 1.0) lcl_const[0] = 1.0;
 228             else if(constants[j + 0] < -1.0) lcl_const[0] = -1.0;
 229             else lcl_const[0] = constants[j + 0];
 230
 231             if(constants[j + 1] > 1.0) lcl_const[1] = 1.0;
 232             else if(constants[j + 1] < -1.0) lcl_const[1] = -1.0;
 233             else lcl_const[1] = constants[j + 1];
 234
 235             if(constants[j + 2] > 1.0) lcl_const[2] = 1.0;
 236             else if(constants[j + 2] < -1.0) lcl_const[2] = -1.0;
 237             else lcl_const[2] = constants[j + 2];
 238
 239             if(constants[j + 3] > 1.0) lcl_const[3] = 1.0;
 240             else if(constants[j + 3] < -1.0) lcl_const[3] = -1.0;
 241             else lcl_const[3] = constants[j + 3];
 242
 243             GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, lcl_const));
 244         }
 245     } else {
 246         if(GL_SUPPORT(EXT_GPU_PROGRAM_PARAMETERS)) {
 247             /* TODO: Benchmark if we're better of with finding the dirty constants ourselves,
 248              * or just reloading *all* constants at once
 249              *
 250             GL_EXTCALL(glProgramEnvParameters4fvEXT(target_type, 0, max_constants, constants));
 251              */
 252             for(i = 0; i < max_constants; i++) {
 253                 if(!dirty_consts[i]) continue;
 254
 255                 /* Find the next block of dirty constants */
 256                 dirty_consts[i] = 0;
 257                 j = i;
 258                 for(i++; (i < max_constants) && dirty_consts[i]; i++) {
 259                     dirty_consts[i] = 0;
 260                 }
 261
 262                 GL_EXTCALL(glProgramEnvParameters4fvEXT(target_type, j, i - j, constants + (j * 4)));
 263             }
 264         } else {
 265             for(i = 0; i < max_constants; i++) {
 266                 if(dirty_consts[i]) {
 267                     dirty_consts[i] = 0;
 268                     GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, constants + (i * 4)));
 269                 }
 270             }
 271         }
 272     }
 273     checkGLcall("glProgramEnvParameter4fvARB()");
 274
 275     /* Load immediate constants */
 276     if(This->baseShader.load_local_constsF) {
 277         if (TRACE_ON(d3d_shader)) {
 278             LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 279                 GLfloat* values = (GLfloat*)lconst->value;
 280                 TRACE_(d3d_constants)("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
 281                         values[0], values[1], values[2], values[3]);
 282             }
 283         }
 284         /* Immediate constants are clamped for 1.X shaders at loading times */
 285         ret = 0;
 286         LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 287             dirty_consts[lconst->idx] = 1; /* Dirtify so the non-immediate constant overwrites it next time */
 288             ret = max(ret, lconst->idx + 1);
 289             GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, lconst->idx, (GLfloat*)lconst->value));
 290         }
 291         checkGLcall("glProgramEnvParameter4fvARB()");
 292         return ret; /* The loaded immediate constants need reloading for the next shader */
 293     } else {
 294         return 0; /* No constants are dirty now */
 295     }
 296 }
 297
 298 /**
 299  * Loads the texture dimensions for NP2 fixup into the currently set ARB_[vertex/fragment]_programs.
 300  */
 301 static void shader_arb_load_np2fixup_constants(
 302     IWineD3DDevice* device,
 303     char usePixelShader,
 304     char useVertexShader) {
 305     /* not implemented */
 306 }
 307
 308 static inline void shader_arb_ps_local_constants(IWineD3DDeviceImpl* deviceImpl)
 309 {
 310     IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
 311     const WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
 312     unsigned char i;
 313     struct shader_arb_priv *priv = deviceImpl->shader_priv;
 314     const struct arb_ps_compiled_shader *gl_shader = priv->compiled_fprog;
 315
 316     for(i = 0; i < gl_shader->numbumpenvmatconsts; i++)
 317     {
 318         int texunit = gl_shader->bumpenvmatconst[i].texunit;
 319
 320         /* The state manager takes care that this function is always called if the bump env matrix changes */
 321         const float *data = (const float *)&stateBlock->textureState[texunit][WINED3DTSS_BUMPENVMAT00];
 322         GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->bumpenvmatconst[i].const_num, data));
 323
 324         if (gl_shader->luminanceconst[i].const_num != WINED3D_CONST_NUM_UNUSED)
 325         {
 326             /* WINED3DTSS_BUMPENVLSCALE and WINED3DTSS_BUMPENVLOFFSET are next to each other.
 327              * point gl to the scale, and load 4 floats. x = scale, y = offset, z and w are junk, we
 328              * don't care about them. The pointers are valid for sure because the stateblock is bigger.
 329              * (they're WINED3DTSS_TEXTURETRANSFORMFLAGS and WINED3DTSS_ADDRESSW, so most likely 0 or NaN
 330             */
 331             const float *scale = (const float *)&stateBlock->textureState[texunit][WINED3DTSS_BUMPENVLSCALE];
 332             GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->luminanceconst[i].const_num, scale));
 333         }
 334     }
 335     checkGLcall("Load bumpmap consts\n");
 336
 337     if(gl_shader->num_int_consts == 0) return;
 338
 339     for(i = 0; i < MAX_CONST_I; i++)
 340     {
 341         if(gl_shader->int_consts[i] != WINED3D_CONST_NUM_UNUSED)
 342         {
 343             float val[4];
 344             val[0] = stateBlock->pixelShaderConstantI[4 * i];
 345             val[1] = stateBlock->pixelShaderConstantI[4 * i + 1];
 346             val[2] = stateBlock->pixelShaderConstantI[4 * i + 2];
 347             val[3] = -1.0;
 348
 349             GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->int_consts[i], val));
 350         }
 351     }
 352     checkGLcall("Load ps int consts\n");
 353
 354     if(gl_shader->ycorrection != WINED3D_CONST_NUM_UNUSED)
 355     {
 356         /* ycorrection.x: Backbuffer height(onscreen) or 0(offscreen).
 357          * ycorrection.y: -1.0(onscreen), 1.0(offscreen)
 358          * ycorrection.z: 1.0
 359          * ycorrection.w: 0.0
 360          */
 361         float val[4];
 362         val[0] = deviceImpl->render_offscreen ? 0.0 : ((IWineD3DSurfaceImpl *) deviceImpl->render_targets[0])->currentDesc.Height;
 363         val[1] = deviceImpl->render_offscreen ? 1.0 : -1.0;
 364         val[2] = 1.0;
 365         val[3] = 0.0;
 366         GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->ycorrection, val));
 367         checkGLcall("y correction loading\n");
 368     }
 369 }
 370
 371 static inline void shader_arb_vs_local_constants(IWineD3DDeviceImpl* deviceImpl)
 372 {
 373     IWineD3DStateBlockImpl* stateBlock;
 374     const WineD3D_GL_Info *gl_info;
 375     unsigned char i;
 376     struct shader_arb_priv *priv = deviceImpl->shader_priv;
 377     const struct arb_vs_compiled_shader *gl_shader = priv->compiled_vprog;
 378
 379     if(gl_shader->num_int_consts == 0) return;
 380
 381     gl_info = &deviceImpl->adapter->gl_info;
 382     stateBlock = deviceImpl->stateBlock;
 383
 384     for(i = 0; i < MAX_CONST_I; i++)
 385     {
 386         if(gl_shader->int_consts[i] != WINED3D_CONST_NUM_UNUSED)
 387         {
 388             float val[4];
 389             val[0] = stateBlock->vertexShaderConstantI[4 * i];
 390             val[1] = stateBlock->vertexShaderConstantI[4 * i + 1];
 391             val[2] = stateBlock->vertexShaderConstantI[4 * i + 2];
 392             val[3] = -1.0;
 393
 394             GL_EXTCALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, gl_shader->int_consts[i], val));
 395         }
 396     }
 397     checkGLcall("Load vs int consts\n");
 398 }
 399
 400 /**
 401  * Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs.
 402  *
 403  * We only support float constants in ARB at the moment, so don't
 404  * worry about the Integers or Booleans
 405  */
 406 /* GL locking is done by the caller (state handler) */
 407 static void shader_arb_load_constants(
 408     IWineD3DDevice* device,
 409     char usePixelShader,
 410     char useVertexShader) {
 411
 412     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device;
 413     IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
 414     const WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
 415
 416     if (useVertexShader) {
 417         IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
 418
 419         /* Load DirectX 9 float constants for vertex shader */
 420         deviceImpl->highest_dirty_vs_const = shader_arb_load_constantsF(
 421                 vshader, gl_info, GL_VERTEX_PROGRAM_ARB,
 422                 deviceImpl->highest_dirty_vs_const,
 423                 stateBlock->vertexShaderConstantF,
 424                 deviceImpl->activeContext->vshader_const_dirty);
 425
 426         /* Upload the position fixup */
 427         GL_EXTCALL(glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, ARB_SHADER_PRIVCONST_POS, deviceImpl->posFixup));
 428
 429         shader_arb_vs_local_constants(deviceImpl);
 430     }
 431
 432     if (usePixelShader) {
 433         IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
 434
 435         /* Load DirectX 9 float constants for pixel shader */
 436         deviceImpl->highest_dirty_ps_const = shader_arb_load_constantsF(
 437                 pshader, gl_info, GL_FRAGMENT_PROGRAM_ARB,
 438                 deviceImpl->highest_dirty_ps_const,
 439                 stateBlock->pixelShaderConstantF,
 440                 deviceImpl->activeContext->pshader_const_dirty);
 441         shader_arb_ps_local_constants(deviceImpl);
 442     }
 443 }
 444
 445 static void shader_arb_update_float_vertex_constants(IWineD3DDevice *iface, UINT start, UINT count)
 446 {
 447     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 448
 449     /* We don't want shader constant dirtification to be an O(contexts), so just dirtify the active
 450      * context. On a context switch the old context will be fully dirtified */
 451     memset(This->activeContext->vshader_const_dirty + start, 1,
 452             sizeof(*This->activeContext->vshader_const_dirty) * count);
 453     This->highest_dirty_vs_const = max(This->highest_dirty_vs_const, start + count + 1);
 454 }
 455
 456 static void shader_arb_update_float_pixel_constants(IWineD3DDevice *iface, UINT start, UINT count)
 457 {
 458     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 459
 460     /* We don't want shader constant dirtification to be an O(contexts), so just dirtify the active
 461      * context. On a context switch the old context will be fully dirtified */
 462     memset(This->activeContext->pshader_const_dirty + start, 1,
 463             sizeof(*This->activeContext->pshader_const_dirty) * count);
 464     This->highest_dirty_ps_const = max(This->highest_dirty_ps_const, start + count + 1);
 465 }
 466
 467 static DWORD *local_const_mapping(IWineD3DBaseShaderImpl *This)
 468 {
 469     DWORD *ret;
 470     DWORD idx = 0;
 471     const local_constant *lconst;
 472
 473     if(This->baseShader.load_local_constsF || list_empty(&This->baseShader.constantsF)) return NULL;
 474
 475     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) * This->baseShader.limits.constant_float);
 476     if(!ret) {
 477         ERR("Out of memory\n");
 478         return NULL;
 479     }
 480
 481     LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 482         ret[lconst->idx] = idx++;
 483     }
 484     return ret;
 485 }
 486
 487 /* Generate the variable & register declarations for the ARB_vertex_program output target */
 488 static DWORD shader_generate_arb_declarations(IWineD3DBaseShader *iface, const shader_reg_maps *reg_maps,
 489         SHADER_BUFFER *buffer, const WineD3D_GL_Info *gl_info, DWORD *lconst_map)
 490 {
 491     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 492     DWORD i, next_local = 0;
 493     char pshader = shader_is_pshader_version(reg_maps->shader_version.type);
 494     unsigned max_constantsF;
 495     const local_constant *lconst;
 496
 497     /* In pixel shaders, all private constants are program local, we don't need anything
 498      * from program.env. Thus we can advertise the full set of constants in pixel shaders.
 499      * If we need a private constant the GL implementation will squeeze it in somewhere
 500      *
 501      * With vertex shaders we need the posFixup and on some GL implementations 4 helper
 502      * immediate values. The posFixup is loaded using program.env for now, so always
 503      * subtract one from the number of constants. If the shader uses indirect addressing,
 504      * account for the helper const too because we have to declare all availabke d3d constants
 505      * and don't know which are actually used.
 506      */
 507     if(pshader) {
 508         max_constantsF = GL_LIMITS(pshader_constantsF);
 509     } else {
 510         if(This->baseShader.reg_maps.usesrelconstF) {
 511             max_constantsF = GL_LIMITS(vshader_constantsF) - reserved_vs_const(iface, gl_info);
 512             if(GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION)) max_constantsF -= GL_LIMITS(clipplanes);
 513             max_constantsF -= count_bits(This->baseShader.reg_maps.integer_constants);
 514         } else {
 515             max_constantsF = GL_LIMITS(vshader_constantsF) - 1;
 516         }
 517     }
 518
 519     for(i = 0; i < This->baseShader.limits.temporary; i++) {
 520         if (reg_maps->temporary[i])
 521             shader_addline(buffer, "TEMP R%u;\n", i);
 522     }
 523
 524     for (i = 0; i < This->baseShader.limits.address; i++) {
 525         if (reg_maps->address[i])
 526             shader_addline(buffer, "ADDRESS A%d;\n", i);
 527     }
 528
 529     if(pshader && reg_maps->shader_version.major == 1 && reg_maps->shader_version.minor <= 3) {
 530         for(i = 0; i < This->baseShader.limits.texcoord; i++) {
 531             if (reg_maps->texcoord[i] && pshader)
 532                 shader_addline(buffer,"TEMP T%u;\n", i);
 533         }
 534     }
 535
 536     /* Load local constants using the program-local space,
 537      * this avoids reloading them each time the shader is used
 538      */
 539     if(lconst_map) {
 540         LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 541             shader_addline(buffer, "PARAM C%u = program.local[%u];\n", lconst->idx,
 542                            lconst_map[lconst->idx]);
 543             next_local = max(next_local, lconst_map[lconst->idx] + 1);
 544         }
 545     }
 546
 547     /* we use the array-based constants array if the local constants are marked for loading,
 548      * because then we use indirect addressing, or when the local constant list is empty,
 549      * because then we don't know if we're using indirect addressing or not. If we're hardcoding
 550      * local constants do not declare the loaded constants as an array because ARB compilers usually
 551      * do not optimize unused constants away
 552      */
 553     if(This->baseShader.reg_maps.usesrelconstF) {
 554         /* Need to PARAM the environment parameters (constants) so we can use relative addressing */
 555         shader_addline(buffer, "PARAM C[%d] = { program.env[0..%d] };\n",
 556                     max_constantsF, max_constantsF - 1);
 557     } else {
 558         for(i = 0; i < max_constantsF; i++) {
 559             DWORD idx, mask;
 560             idx = i >> 5;
 561             mask = 1 << (i & 0x1f);
 562             if(!shader_constant_is_local(This, i) && (This->baseShader.reg_maps.constf[idx] & mask)) {
 563                 shader_addline(buffer, "PARAM C%d = program.env[%d];\n",i, i);
 564             }
 565         }
 566     }
 567
 568     return next_local;
 569 }
 570
 571 static const char * const shift_tab[] = {
 572     "dummy",     /*  0 (none) */
 573     "coefmul.x", /*  1 (x2)   */
 574     "coefmul.y", /*  2 (x4)   */
 575     "coefmul.z", /*  3 (x8)   */
 576     "coefmul.w", /*  4 (x16)  */
 577     "dummy",     /*  5 (x32)  */
 578     "dummy",     /*  6 (x64)  */
 579     "dummy",     /*  7 (x128) */
 580     "dummy",     /*  8 (d256) */
 581     "dummy",     /*  9 (d128) */
 582     "dummy",     /* 10 (d64)  */
 583     "dummy",     /* 11 (d32)  */
 584     "coefdiv.w", /* 12 (d16)  */
 585     "coefdiv.z", /* 13 (d8)   */
 586     "coefdiv.y", /* 14 (d4)   */
 587     "coefdiv.x"  /* 15 (d2)   */
 588 };
 589
 590 static void shader_arb_get_write_mask(const struct wined3d_shader_instruction *ins,
 591         const struct wined3d_shader_dst_param *dst, char *write_mask)
 592 {
 593     char *ptr = write_mask;
 594
 595     if (dst->write_mask != WINED3DSP_WRITEMASK_ALL)
 596     {
 597         *ptr++ = '.';
 598         if (dst->write_mask & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
 599         if (dst->write_mask & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
 600         if (dst->write_mask & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
 601         if (dst->write_mask & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
 602     }
 603
 604     *ptr = '\0';
 605 }
 606
 607 static void shader_arb_get_swizzle(const struct wined3d_shader_src_param *param, BOOL fixup, char *swizzle_str)
 608 {
 609     /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
 610      * but addressed as "rgba". To fix this we need to swap the register's x
 611      * and z components. */
 612     const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
 613     char *ptr = swizzle_str;
 614
 615     /* swizzle bits fields: wwzzyyxx */
 616     DWORD swizzle = param->swizzle;
 617     DWORD swizzle_x = swizzle & 0x03;
 618     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 619     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 620     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 621
 622     /* If the swizzle is the default swizzle (ie, "xyzw"), we don't need to
 623      * generate a swizzle string. Unless we need to our own swizzling. */
 624     if (swizzle != WINED3DSP_NOSWIZZLE || fixup)
 625     {
 626         *ptr++ = '.';
 627         if (swizzle_x == swizzle_y && swizzle_x == swizzle_z && swizzle_x == swizzle_w) {
 628             *ptr++ = swizzle_chars[swizzle_x];
 629         } else {
 630             *ptr++ = swizzle_chars[swizzle_x];
 631             *ptr++ = swizzle_chars[swizzle_y];
 632             *ptr++ = swizzle_chars[swizzle_z];
 633             *ptr++ = swizzle_chars[swizzle_w];
 634         }
 635     }
 636
 637     *ptr = '\0';
 638 }
 639
 640 static void shader_arb_request_a0(const struct wined3d_shader_instruction *ins, const char *src)
 641 {
 642     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
 643     SHADER_BUFFER *buffer = ins->ctx->buffer;
 644
 645     if(strcmp(priv->addr_reg, src) == 0) return;
 646
 647     strcpy(priv->addr_reg, src);
 648     shader_addline(buffer, "ARL A0.x, %s;\n", src);
 649 }
 650
 651 static void shader_arb_get_src_param(const struct wined3d_shader_instruction *ins,
 652         const struct wined3d_shader_src_param *src, unsigned int tmpreg, char *outregstr);
 653
 654 static void shader_arb_get_register_name(const struct wined3d_shader_instruction *ins,
 655         const struct wined3d_shader_register *reg, char *register_name, BOOL *is_color)
 656 {
 657     /* oPos, oFog and oPts in D3D */
 658     static const char * const rastout_reg_names[] = {"TMP_OUT", "result.fogcoord", "result.pointsize"};
 659     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
 660     BOOL pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type);
 661     struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
 662
 663     *is_color = FALSE;
 664
 665     switch (reg->type)
 666     {
 667         case WINED3DSPR_TEMP:
 668             sprintf(register_name, "R%u", reg->idx);
 669             break;
 670
 671         case WINED3DSPR_INPUT:
 672             if (pshader)
 673             {
 674                 if (reg->idx == 0) strcpy(register_name, "fragment.color.primary");
 675                 else strcpy(register_name, "fragment.color.secondary");
 676             }
 677             else
 678             {
 679                 if (ctx->cur_vs_args->super.swizzle_map & (1 << reg->idx)) *is_color = TRUE;
 680                 sprintf(register_name, "vertex.attrib[%u]", reg->idx);
 681             }
 682             break;
 683
 684         case WINED3DSPR_CONST:
 685             if (!pshader && reg->rel_addr)
 686             {
 687                 BOOL aL = FALSE;
 688                 char rel_reg[50];
 689                 UINT rel_offset = ((IWineD3DVertexShaderImpl *)This)->rel_offset;
 690                 if(This->baseShader.reg_maps.shader_version.major < 2) {
 691                     sprintf(rel_reg, "A0.x");
 692                 } else {
 693                     shader_arb_get_src_param(ins, reg->rel_addr, 0, rel_reg);
 694                     if(ctx->target_version == ARB) {
 695                         if(strcmp(rel_reg, "**aL_emul**") == 0) {
 696                             aL = TRUE;
 697                         } else {
 698                             shader_arb_request_a0(ins, rel_reg);
 699                             sprintf(rel_reg, "A0.x");
 700                         }
 701                     }
 702                 }
 703                 if(aL)
 704                     sprintf(register_name, "C[%u]", ctx->aL + reg->idx);
 705                 else if (reg->idx >= rel_offset)
 706                     sprintf(register_name, "C[%s + %u]", rel_reg, reg->idx - rel_offset);
 707                 else
 708                     sprintf(register_name, "C[%s - %u]", rel_reg, -reg->idx + rel_offset);
 709             }
 710             else
 711             {
 712                 if (This->baseShader.reg_maps.usesrelconstF)
 713                     sprintf(register_name, "C[%u]", reg->idx);
 714                 else
 715                     sprintf(register_name, "C%u", reg->idx);
 716             }
 717             break;
 718
 719         case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
 720             if (pshader) {
 721                 if(This->baseShader.reg_maps.shader_version.major == 1 &&
 722                    This->baseShader.reg_maps.shader_version.minor <= 3) {
 723                     /* In ps <= 1.3, Tx is a temporary register as destination to all instructions,
 724                      * and as source to most instructions. For some instructions it is the texcoord
 725                      * input. Those instructions know about the special use
 726                      */
 727                     sprintf(register_name, "T%u", reg->idx);
 728                 } else {
 729                     /* in ps 1.4 and 2.x Tx is always a (read-only) varying */
 730                     sprintf(register_name, "fragment.texcoord[%u]", reg->idx);
 731                 }
 732             }
 733             else
 734             {
 735                 if(This->baseShader.reg_maps.shader_version.major == 1 || ctx->target_version >= NV2)
 736                 {
 737                     sprintf(register_name, "A%u", reg->idx);
 738                 }
 739                 else
 740                 {
 741                     sprintf(register_name, "A%u_SHADOW", reg->idx);
 742                 }
 743             }
 744             break;
 745
 746         case WINED3DSPR_COLOROUT:
 747             if (reg->idx == 0)
 748             {
 749                 if(ctx->cur_ps_args->super.srgb_correction)
 750                 {
 751                     strcpy(register_name, "TMP_COLOR");
 752                 }
 753                 else
 754                 {
 755                     strcpy(register_name, "result.color");
 756                 }
 757             }
 758             else
 759             {
 760                 /* TODO: See GL_ARB_draw_buffers */
 761                 FIXME("Unsupported write to render target %u\n", reg->idx);
 762                 sprintf(register_name, "unsupported_register");
 763             }
 764             break;
 765
 766         case WINED3DSPR_RASTOUT:
 767             sprintf(register_name, "%s", rastout_reg_names[reg->idx]);
 768             break;
 769
 770         case WINED3DSPR_DEPTHOUT:
 771             strcpy(register_name, "result.depth");
 772             break;
 773
 774         case WINED3DSPR_ATTROUT:
 775             if (pshader) sprintf(register_name, "oD[%u]", reg->idx);
 776             else if (reg->idx == 0) strcpy(register_name, "result.color.primary");
 777             else strcpy(register_name, "result.color.secondary");
 778             break;
 779
 780         case WINED3DSPR_TEXCRDOUT:
 781             if (pshader) sprintf(register_name, "oT[%u]", reg->idx);
 782             else sprintf(register_name, "result.texcoord[%u]", reg->idx);
 783             break;
 784
 785         case WINED3DSPR_LOOP:
 786             if(ctx->target_version >= NV2)
 787             {
 788                 /* Pshader has an implicitly declared loop index counter A0.x that cannot be renamed */
 789                 if(pshader) sprintf(register_name, "A0.x");
 790                 else sprintf(register_name, "aL.y");
 791             }
 792             else
 793             {
 794                 /* Unfortunately this code cannot return the value of ctx->aL here. An immediate value
 795                  * would be valid, but if aL is used for indexing(its only use), there's likely an offset,
 796                  * thus the result would be something like C[15 + 30], which is not valid in the ARB program
 797                  * grammar. So return a marker for the emulated aL and intercept it in constant and varying
 798                  * indexing
 799                  */
 800                 sprintf(register_name, "**aL_emul**");
 801             }
 802
 803             break;
 804
 805         case WINED3DSPR_CONSTINT:
 806             sprintf(register_name, "I%u", reg->idx);
 807             break;
 808
 809         case WINED3DSPR_MISCTYPE:
 810             if(reg->idx == 0)
 811             {
 812                 sprintf(register_name, "vpos");
 813             }
 814             else if(reg->idx == 1)
 815             {
 816                 sprintf(register_name, "fragment.facing.x");
 817             }
 818             else
 819             {
 820                 FIXME("Unknown MISCTYPE register index %u\n", reg->idx);
 821             }
 822             break;
 823
 824         default:
 825             FIXME("Unhandled register type %#x[%u]\n", reg->type, reg->idx);
 826             sprintf(register_name, "unrecognized_register[%u]", reg->idx);
 827             break;
 828     }
 829 }
 830
 831 static void shader_arb_get_dst_param(const struct wined3d_shader_instruction *ins,
 832         const struct wined3d_shader_dst_param *wined3d_dst, char *str)
 833 {
 834     char register_name[255];
 835     char write_mask[6];
 836     BOOL is_color;
 837
 838     shader_arb_get_register_name(ins, &wined3d_dst->reg, register_name, &is_color);
 839     strcpy(str, register_name);
 840
 841     shader_arb_get_write_mask(ins, wined3d_dst, write_mask);
 842     strcat(str, write_mask);
 843 }
 844
 845 static const char *shader_arb_get_fixup_swizzle(enum fixup_channel_source channel_source)
 846 {
 847     switch(channel_source)
 848     {
 849         case CHANNEL_SOURCE_ZERO: return "0";
 850         case CHANNEL_SOURCE_ONE: return "1";
 851         case CHANNEL_SOURCE_X: return "x";
 852         case CHANNEL_SOURCE_Y: return "y";
 853         case CHANNEL_SOURCE_Z: return "z";
 854         case CHANNEL_SOURCE_W: return "w";
 855         default:
 856             FIXME("Unhandled channel source %#x\n", channel_source);
 857             return "undefined";
 858     }
 859 }
 860
 861 static void gen_color_correction(SHADER_BUFFER *buffer, const char *reg, DWORD dst_mask,
 862                                  const char *one, const char *two, struct color_fixup_desc fixup)
 863 {
 864     DWORD mask;
 865
 866     if (is_yuv_fixup(fixup))
 867     {
 868         enum yuv_fixup yuv_fixup = get_yuv_fixup(fixup);
 869         FIXME("YUV fixup (%#x) not supported\n", yuv_fixup);
 870         return;
 871     }
 872
 873     mask = 0;
 874     if (fixup.x_source != CHANNEL_SOURCE_X) mask |= WINED3DSP_WRITEMASK_0;
 875     if (fixup.y_source != CHANNEL_SOURCE_Y) mask |= WINED3DSP_WRITEMASK_1;
 876     if (fixup.z_source != CHANNEL_SOURCE_Z) mask |= WINED3DSP_WRITEMASK_2;
 877     if (fixup.w_source != CHANNEL_SOURCE_W) mask |= WINED3DSP_WRITEMASK_3;
 878     mask &= dst_mask;
 879
 880     if (mask)
 881     {
 882         shader_addline(buffer, "SWZ %s, %s, %s, %s, %s, %s;\n", reg, reg,
 883                 shader_arb_get_fixup_swizzle(fixup.x_source), shader_arb_get_fixup_swizzle(fixup.y_source),
 884                 shader_arb_get_fixup_swizzle(fixup.z_source), shader_arb_get_fixup_swizzle(fixup.w_source));
 885     }
 886
 887     mask = 0;
 888     if (fixup.x_sign_fixup) mask |= WINED3DSP_WRITEMASK_0;
 889     if (fixup.y_sign_fixup) mask |= WINED3DSP_WRITEMASK_1;
 890     if (fixup.z_sign_fixup) mask |= WINED3DSP_WRITEMASK_2;
 891     if (fixup.w_sign_fixup) mask |= WINED3DSP_WRITEMASK_3;
 892     mask &= dst_mask;
 893
 894     if (mask)
 895     {
 896         char reg_mask[6];
 897         char *ptr = reg_mask;
 898
 899         if (mask != WINED3DSP_WRITEMASK_ALL)
 900         {
 901             *ptr++ = '.';
 902             if (mask & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
 903             if (mask & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
 904             if (mask & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
 905             if (mask & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
 906         }
 907         *ptr = '\0';
 908
 909         shader_addline(buffer, "MAD %s%s, %s, %s, -%s;\n", reg, reg_mask, reg, two, one);
 910     }
 911 }
 912
 913 static const char *shader_arb_get_modifier(const struct wined3d_shader_instruction *ins)
 914 {
 915     DWORD mod;
 916     const char *ret = "";
 917     if (!ins->dst_count) return "";
 918
 919     mod = ins->dst[0].modifiers;
 920     if(mod & WINED3DSPDM_SATURATE)
 921     {
 922         ret = "_SAT";
 923         mod &= ~WINED3DSPDM_SATURATE;
 924     }
 925     if(mod & WINED3DSPDM_PARTIALPRECISION)
 926     {
 927         FIXME("Unhandled modifier WINED3DSPDM_PARTIALPRECISION\n");
 928         mod &= ~WINED3DSPDM_PARTIALPRECISION;
 929     }
 930     if(mod & WINED3DSPDM_MSAMPCENTROID)
 931     {
 932         FIXME("Unhandled modifier WINED3DSPDM_MSAMPCENTROID\n");
 933         mod &= ~WINED3DSPDM_MSAMPCENTROID;
 934     }
 935     if(mod)
 936     {
 937         FIXME("Unknown modifiers 0x%08x\n", mod);
 938     }
 939     return ret;
 940 }
 941
 942 #define TEX_PROJ        0x1
 943 #define TEX_BIAS        0x2
 944 #define TEX_LOD         0x4
 945 #define TEX_DERIV       0x10
 946
 947 static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD sampler_idx,
 948         const char *dst_str, const char *coord_reg, WORD flags, const char *dsx, const char *dsy)
 949 {
 950     SHADER_BUFFER *buffer = ins->ctx->buffer;
 951     DWORD sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
 952     const char *tex_type;
 953     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
 954     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
 955     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
 956     const char *mod = shader_arb_get_modifier(ins);
 957
 958     switch(sampler_type) {
 959         case WINED3DSTT_1D:
 960             tex_type = "1D";
 961             break;
 962
 963         case WINED3DSTT_2D:
 964             if(device->stateBlock->textures[sampler_idx] &&
 965                IWineD3DBaseTexture_GetTextureDimensions(device->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
 966                 tex_type = "RECT";
 967             } else {
 968                 tex_type = "2D";
 969             }
 970             if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
 971             {
 972                 if(priv->cur_ps_args->super.np2_fixup & (1 << sampler_idx))
 973                 {
 974                     FIXME("NP2 texcoord fixup is currently not implemented in ARB mode (use GLSL instead).\n");
 975                 }
 976             }
 977             break;
 978
 979         case WINED3DSTT_VOLUME:
 980             tex_type = "3D";
 981             break;
 982
 983         case WINED3DSTT_CUBE:
 984             tex_type = "CUBE";
 985             break;
 986
 987         default:
 988             ERR("Unexpected texture type %d\n", sampler_type);
 989             tex_type = "";
 990     }
 991
 992     if (flags & TEX_DERIV)
 993     {
 994         if(flags & TEX_PROJ) FIXME("Projected texture sampling with custom derivates\n");
 995         if(flags & TEX_BIAS) FIXME("Biased texture sampling with custom derivates\n");
 996         shader_addline(buffer, "TXD%s %s, %s, %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg,
 997                        dsx, dsy,sampler_idx, tex_type);
 998     }
 999     else if(flags & TEX_LOD)
1000     {
1001         if(flags & TEX_PROJ) FIXME("Projected texture sampling with explicit lod\n");
1002         if(flags & TEX_BIAS) FIXME("Biased texture sampling with explicit lod\n");
1003         shader_addline(buffer, "TXL%s %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg,
1004                        sampler_idx, tex_type);
1005     }
1006     else if (flags & TEX_BIAS)
1007     {
1008         /* Shouldn't be possible, but let's check for it */
1009         if(flags & TEX_PROJ) FIXME("Biased and Projected texture sampling\n");
1010         /* TXB takes the 4th component of the source vector automatically, as d3d. Nothing more to do */
1011         shader_addline(buffer, "TXB%s %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg, sampler_idx, tex_type);
1012     }
1013     else if (flags & TEX_PROJ)
1014     {
1015         shader_addline(buffer, "TXP%s %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg, sampler_idx, tex_type);
1016     }
1017     else
1018     {
1019         shader_addline(buffer, "TEX%s %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg, sampler_idx, tex_type);
1020     }
1021
1022     if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
1023     {
1024         gen_color_correction(buffer, dst_str, ins->dst[0].write_mask,
1025                 "one", "coefmul.x", priv->cur_ps_args->super.color_fixup[sampler_idx]);
1026     }
1027 }
1028
1029 static void shader_arb_get_src_param(const struct wined3d_shader_instruction *ins,
1030         const struct wined3d_shader_src_param *src, unsigned int tmpreg, char *outregstr)
1031 {
1032     /* Generate a line that does the input modifier computation and return the input register to use */
1033     BOOL is_color = FALSE;
1034     char regstr[256];
1035     char swzstr[20];
1036     int insert_line;
1037     SHADER_BUFFER *buffer = ins->ctx->buffer;
1038     struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1039
1040     /* Assume a new line will be added */
1041     insert_line = 1;
1042
1043     /* Get register name */
1044     shader_arb_get_register_name(ins, &src->reg, regstr, &is_color);
1045     shader_arb_get_swizzle(src, is_color, swzstr);
1046
1047     switch (src->modifiers)
1048     {
1049     case WINED3DSPSM_NONE:
1050         sprintf(outregstr, "%s%s", regstr, swzstr);
1051         insert_line = 0;
1052         break;
1053     case WINED3DSPSM_NEG:
1054         sprintf(outregstr, "-%s%s", regstr, swzstr);
1055         insert_line = 0;
1056         break;
1057     case WINED3DSPSM_BIAS:
1058         shader_addline(buffer, "ADD T%c, %s, -coefdiv.x;\n", 'A' + tmpreg, regstr);
1059         break;
1060     case WINED3DSPSM_BIASNEG:
1061         shader_addline(buffer, "ADD T%c, -%s, coefdiv.x;\n", 'A' + tmpreg, regstr);
1062         break;
1063     case WINED3DSPSM_SIGN:
1064         shader_addline(buffer, "MAD T%c, %s, coefmul.x, -one.x;\n", 'A' + tmpreg, regstr);
1065         break;
1066     case WINED3DSPSM_SIGNNEG:
1067         shader_addline(buffer, "MAD T%c, %s, -coefmul.x, one.x;\n", 'A' + tmpreg, regstr);
1068         break;
1069     case WINED3DSPSM_COMP:
1070         shader_addline(buffer, "SUB T%c, one.x, %s;\n", 'A' + tmpreg, regstr);
1071         break;
1072     case WINED3DSPSM_X2:
1073         shader_addline(buffer, "ADD T%c, %s, %s;\n", 'A' + tmpreg, regstr, regstr);
1074         break;
1075     case WINED3DSPSM_X2NEG:
1076         shader_addline(buffer, "ADD T%c, -%s, -%s;\n", 'A' + tmpreg, regstr, regstr);
1077         break;
1078     case WINED3DSPSM_DZ:
1079         shader_addline(buffer, "RCP T%c, %s.z;\n", 'A' + tmpreg, regstr);
1080         shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
1081         break;
1082     case WINED3DSPSM_DW:
1083         shader_addline(buffer, "RCP T%c, %s.w;\n", 'A' + tmpreg, regstr);
1084         shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
1085         break;
1086     case WINED3DSPSM_ABS:
1087         if(ctx->target_version >= NV2) {
1088             sprintf(outregstr, "|%s%s|", regstr, swzstr);
1089             insert_line = 0;
1090         } else {
1091             shader_addline(buffer, "ABS T%c, %s;\n", 'A' + tmpreg, regstr);
1092         }
1093         break;
1094     case WINED3DSPSM_ABSNEG:
1095         if(ctx->target_version >= NV2) {
1096             sprintf(outregstr, "-|%s%s|", regstr, swzstr);
1097         } else {
1098             shader_addline(buffer, "ABS T%c, %s;\n", 'A' + tmpreg, regstr);
1099             sprintf(outregstr, "-T%c%s", 'A' + tmpreg, swzstr);
1100         }
1101         insert_line = 0;
1102         break;
1103     default:
1104         sprintf(outregstr, "%s%s", regstr, swzstr);
1105         insert_line = 0;
1106     }
1107
1108     /* Return modified or original register, with swizzle */
1109     if (insert_line)
1110         sprintf(outregstr, "T%c%s", 'A' + tmpreg, swzstr);
1111 }
1112
1113 static void pshader_hw_bem(const struct wined3d_shader_instruction *ins)
1114 {
1115     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1116     SHADER_BUFFER *buffer = ins->ctx->buffer;
1117     char dst_name[50];
1118     char src_name[2][50];
1119     DWORD sampler_code = dst->reg.idx;
1120
1121     shader_arb_get_dst_param(ins, dst, dst_name);
1122
1123     /* Sampling the perturbation map in Tsrc was done already, including the signedness correction if needed
1124      *
1125      * Keep in mind that src_name[1] can be "TB" and src_name[0] can be "TA" because modifiers like _x2 are valid
1126      * with bem. So delay loading the first parameter until after the perturbation calculation which needs two
1127      * temps is done.
1128      */
1129     shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1130     shader_addline(buffer, "SWZ TA, bumpenvmat%d, x, z, 0, 0;\n", sampler_code);
1131     shader_addline(buffer, "DP3 TC.r, TA, %s;\n", src_name[1]);
1132     shader_addline(buffer, "SWZ TA, bumpenvmat%d, y, w, 0, 0;\n", sampler_code);
1133     shader_addline(buffer, "DP3 TC.g, TA, %s;\n", src_name[1]);
1134
1135     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1136     shader_addline(buffer, "ADD %s, %s, TC;\n", dst_name, src_name[0]);
1137 }
1138
1139 static void pshader_hw_cnd(const struct wined3d_shader_instruction *ins)
1140 {
1141     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1142     SHADER_BUFFER *buffer = ins->ctx->buffer;
1143     char dst_name[50];
1144     char src_name[3][50];
1145     DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
1146             ins->ctx->reg_maps->shader_version.minor);
1147
1148     shader_arb_get_dst_param(ins, dst, dst_name);
1149     shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1150
1151     /* The coissue flag changes the semantic of the cnd instruction in <= 1.3 shaders */
1152     if (shader_version <= WINED3D_SHADER_VERSION(1, 3) && ins->coissue)
1153     {
1154         shader_addline(buffer, "MOV%s %s, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name[1]);
1155     } else {
1156         shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1157         shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1158         shader_addline(buffer, "ADD TA, -%s, coefdiv.x;\n", src_name[0]);
1159         shader_addline(buffer, "CMP%s %s, TA, %s, %s;\n",
1160                        shader_arb_get_modifier(ins), dst_name, src_name[1], src_name[2]);
1161     }
1162 }
1163
1164 static void pshader_hw_cmp(const struct wined3d_shader_instruction *ins)
1165 {
1166     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1167     SHADER_BUFFER *buffer = ins->ctx->buffer;
1168     char dst_name[50];
1169     char src_name[3][50];
1170
1171     shader_arb_get_dst_param(ins, dst, dst_name);
1172
1173     /* Generate input register names (with modifiers) */
1174     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1175     shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1176     shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1177
1178     shader_addline(buffer, "CMP%s %s, %s, %s, %s;\n", shader_arb_get_modifier(ins), dst_name,
1179                    src_name[0], src_name[2], src_name[1]);
1180 }
1181
1182 /** Process the WINED3DSIO_DP2ADD instruction in ARB.
1183  * dst = dot2(src0, src1) + src2 */
1184 static void pshader_hw_dp2add(const struct wined3d_shader_instruction *ins)
1185 {
1186     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1187     SHADER_BUFFER *buffer = ins->ctx->buffer;
1188     char dst_name[50];
1189     char src_name[3][50];
1190     struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1191
1192     shader_arb_get_dst_param(ins, dst, dst_name);
1193     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1194     shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1195
1196     if(ctx->target_version >= NV3)
1197     {
1198         /* GL_NV_fragment_program2 has a 1:1 matching instruction */
1199         shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1200         shader_addline(buffer, "DP2A%s %s, %s, %s, %s;\n", shader_arb_get_modifier(ins),
1201                        dst_name, src_name[0], src_name[1], src_name[2]);
1202     }
1203     else if(ctx->target_version >= NV2)
1204     {
1205         /* dst.x = src2.?, src0.x, src1.x + src0.y * src1.y
1206          * dst.y = src2.?, src0.x, src1.z + src0.y * src1.w
1207          * dst.z = src2.?, src0.x, src1.x + src0.y * src1.y
1208          * dst.z = src2.?, src0.x, src1.z + src0.y * src1.w
1209          *
1210          * Make sure that src1.zw = src1.xy, then we get a classic dp2add
1211          *
1212          * .xyxy and other swizzles that we could get with this are not valid in
1213          * plain ARBfp, but luckily the NV extension grammar lifts this limitation.
1214          */
1215         struct wined3d_shader_src_param tmp_param = ins->src[1];
1216         DWORD swizzle = tmp_param.swizzle & 0xf; /* Selects .xy */
1217         tmp_param.swizzle = swizzle | (swizzle << 4); /* Creates .xyxy */
1218
1219         shader_arb_get_src_param(ins, &tmp_param, 1, src_name[1]);
1220
1221         shader_addline(buffer, "X2D%s %s, %s, %s, %s;\n", shader_arb_get_modifier(ins),
1222                        dst_name, src_name[2], src_name[0], src_name[1]);
1223     }
1224     else
1225     {
1226         shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1227         /* Emulate a DP2 with a DP3 and 0.0. Don't use the dest as temp register, it could be src[1] or src[2]
1228         * src_name[0] can be TA, but TA is a private temp for modifiers, so it is save to overwrite
1229         */
1230         shader_addline(buffer, "MOV TA, %s;\n", src_name[0]);
1231         shader_addline(buffer, "MOV TA.z, 0.0;\n");
1232         shader_addline(buffer, "DP3 TA, TA, %s;\n", src_name[1]);
1233         shader_addline(buffer, "ADD%s %s, TA, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name[2]);
1234     }
1235 }
1236
1237 /* Map the opcode 1-to-1 to the GL code */
1238 static void shader_hw_map2gl(const struct wined3d_shader_instruction *ins)
1239 {
1240     SHADER_BUFFER *buffer = ins->ctx->buffer;
1241     const char *instruction;
1242     char arguments[256], dst_str[50];
1243     unsigned int i;
1244     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1245
1246     switch (ins->handler_idx)
1247     {
1248         case WINED3DSIH_ABS: instruction = "ABS"; break;
1249         case WINED3DSIH_ADD: instruction = "ADD"; break;
1250         case WINED3DSIH_CRS: instruction = "XPD"; break;
1251         case WINED3DSIH_DP3: instruction = "DP3"; break;
1252         case WINED3DSIH_DP4: instruction = "DP4"; break;
1253         case WINED3DSIH_DST: instruction = "DST"; break;
1254         case WINED3DSIH_EXP: instruction = "EX2"; break;
1255         case WINED3DSIH_EXPP: instruction = "EXP"; break;
1256         case WINED3DSIH_FRC: instruction = "FRC"; break;
1257         case WINED3DSIH_LIT: instruction = "LIT"; break;
1258         case WINED3DSIH_LOG: instruction = "LG2"; break;
1259         case WINED3DSIH_LOGP: instruction = "LOG"; break;
1260         case WINED3DSIH_LRP: instruction = "LRP"; break;
1261         case WINED3DSIH_MAD: instruction = "MAD"; break;
1262         case WINED3DSIH_MAX: instruction = "MAX"; break;
1263         case WINED3DSIH_MIN: instruction = "MIN"; break;
1264         case WINED3DSIH_MOV: instruction = "MOV"; break;
1265         case WINED3DSIH_MUL: instruction = "MUL"; break;
1266         case WINED3DSIH_POW: instruction = "POW"; break;
1267         case WINED3DSIH_SGE: instruction = "SGE"; break;
1268         case WINED3DSIH_SLT: instruction = "SLT"; break;
1269         case WINED3DSIH_SUB: instruction = "SUB"; break;
1270         case WINED3DSIH_MOVA:instruction = "ARR"; break;
1271         case WINED3DSIH_SGN: instruction = "SSG"; break;
1272         case WINED3DSIH_DSX: instruction = "DDX"; break;
1273         default: instruction = "";
1274             FIXME("Unhandled opcode %#x\n", ins->handler_idx);
1275             break;
1276     }
1277
1278     /* Note that shader_arb_add_dst_param() adds spaces. */
1279     arguments[0] = '\0';
1280     shader_arb_get_dst_param(ins, dst, dst_str);
1281     for (i = 0; i < ins->src_count; ++i)
1282     {
1283         char operand[100];
1284         strcat(arguments, ", ");
1285         shader_arb_get_src_param(ins, &ins->src[i], i, operand);
1286         strcat(arguments, operand);
1287     }
1288     shader_addline(buffer, "%s%s %s%s;\n", instruction, shader_arb_get_modifier(ins), dst_str, arguments);
1289 }
1290
1291 static void shader_hw_nop(const struct wined3d_shader_instruction *ins)
1292 {
1293     SHADER_BUFFER *buffer = ins->ctx->buffer;
1294     shader_addline(buffer, "NOP;\n");
1295 }
1296
1297 static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
1298 {
1299     IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
1300     BOOL pshader = shader_is_pshader_version(shader->baseShader.reg_maps.shader_version.type);
1301     struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1302
1303     SHADER_BUFFER *buffer = ins->ctx->buffer;
1304     char src0_param[256];
1305
1306     if(ins->handler_idx == WINED3DSIH_MOVA) {
1307         struct wined3d_shader_src_param tmp_src = ins->src[0];
1308         char write_mask[6];
1309
1310         if(ctx->target_version >= NV2) {
1311             shader_hw_map2gl(ins);
1312             return;
1313         }
1314         tmp_src.swizzle = (tmp_src.swizzle & 0x3) * 0x55;
1315         shader_arb_get_src_param(ins, &tmp_src, 0, src0_param);
1316         shader_arb_get_write_mask(ins, &ins->dst[0], write_mask);
1317
1318         /* This implements the mova formula used in GLSL. The first two instructions
1319          * prepare the sign() part. Note that it is fine to have my_sign(0.0) = 1.0
1320          * in this case:
1321          * mova A0.x, 0.0
1322          *
1323          * A0.x = arl(floor(abs(0.0) + 0.5) * 1.0) = floor(0.5) = 0.0 since arl does a floor
1324          *
1325          * The ARL is performed when A0 is used - the requested component is read from A0_SHADOW into
1326          * A0.x. We can use the overwritten component of A0_shadow as temporary storage for the sign.
1327          */
1328         shader_addline(buffer, "SGE A0_SHADOW%s, %s, mova_const.y;\n", write_mask, src0_param);
1329         shader_addline(buffer, "MAD A0_SHADOW%s, A0_SHADOW, mova_const.z, -mova_const.w;\n", write_mask);
1330
1331         shader_addline(buffer, "ABS TA%s, %s;\n", write_mask, src0_param);
1332         shader_addline(buffer, "ADD TA%s, TA, mova_const.x;\n", write_mask);
1333         shader_addline(buffer, "FLR TA%s, TA;\n", write_mask);
1334         shader_addline(buffer, "MUL A0_SHADOW%s, TA, A0_SHADOW;\n", write_mask);
1335
1336         ((struct shader_arb_ctx_priv *)ins->ctx->backend_data)->addr_reg[0] = '\0';
1337     } else if (ins->ctx->reg_maps->shader_version.major == 1
1338           && !shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)
1339           && ins->dst[0].reg.type == WINED3DSPR_ADDR)
1340     {
1341         src0_param[0] = '\0';
1342         if (((IWineD3DVertexShaderImpl *)shader)->rel_offset)
1343         {
1344             shader_arb_get_src_param(ins, &ins->src[0], 0, src0_param);
1345             shader_addline(buffer, "ADD TA.x, %s, helper_const.z;\n", src0_param);
1346             shader_addline(buffer, "ARL A0.x, TA.x;\n");
1347         }
1348         else
1349         {
1350             /* Apple's ARB_vertex_program implementation does not accept an ARL source argument
1351              * with more than one component. Thus replicate the first source argument over all
1352              * 4 components. For example, .xyzw -> .x (or better: .xxxx), .zwxy -> .z, etc) */
1353             struct wined3d_shader_src_param tmp_src = ins->src[0];
1354             tmp_src.swizzle = (tmp_src.swizzle & 0x3) * 0x55;
1355             shader_arb_get_src_param(ins, &tmp_src, 0, src0_param);
1356             shader_addline(buffer, "ARL A0.x, %s;\n", src0_param);
1357         }
1358     }
1359     else if(ins->dst[0].reg.type == WINED3DSPR_COLOROUT && ins->dst[0].reg.idx == 0 && pshader)
1360     {
1361         IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) shader;
1362         if(ctx->cur_ps_args->super.srgb_correction && ps->color0_mov)
1363         {
1364             shader_addline(buffer, "#mov handled in srgb write code\n");
1365             return;
1366         }
1367         shader_hw_map2gl(ins);
1368     }
1369     else
1370     {
1371         shader_hw_map2gl(ins);
1372     }
1373 }
1374
1375 static void pshader_hw_texkill(const struct wined3d_shader_instruction *ins)
1376 {
1377     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1378     SHADER_BUFFER *buffer = ins->ctx->buffer;
1379     char reg_dest[40];
1380
1381     /* No swizzles are allowed in d3d's texkill. PS 1.x ignores the 4th component as documented,
1382      * but >= 2.0 honors it(undocumented, but tested by the d3d9 testsuit)
1383      */
1384     shader_arb_get_dst_param(ins, dst, reg_dest);
1385
1386     if (ins->ctx->reg_maps->shader_version.major >= 2)
1387     {
1388         /* The arb backend doesn't claim ps 2.0 support, but try to eat what the app feeds to us */
1389         shader_arb_get_dst_param(ins, dst, reg_dest);
1390         shader_addline(buffer, "KIL %s;\n", reg_dest);
1391     } else {
1392         /* ARB fp doesn't like swizzles on the parameter of the KIL instruction. To mask the 4th component,
1393          * copy the register into our general purpose TMP variable, overwrite .w and pass TMP to KIL
1394          *
1395          * ps_1_3 shaders use the texcoord incarnation of the Tx register. ps_1_4 shaders can use the same,
1396          * or pass in any temporary register(in shader phase 2)
1397          */
1398         if(ins->ctx->reg_maps->shader_version.minor <= 3) {
1399             sprintf(reg_dest, "fragment.texcoord[%u]", dst->reg.idx);
1400         } else {
1401             shader_arb_get_dst_param(ins, dst, reg_dest);
1402         }
1403         shader_addline(buffer, "SWZ TA, %s, x, y, z, 1;\n", reg_dest);
1404         shader_addline(buffer, "KIL TA;\n");
1405     }
1406 }
1407
1408 static void pshader_hw_tex(const struct wined3d_shader_instruction *ins)
1409 {
1410     IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1411     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1412     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1413     DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
1414             ins->ctx->reg_maps->shader_version.minor);
1415     struct wined3d_shader_src_param src;
1416
1417     char reg_dest[40];
1418     char reg_coord[40];
1419     DWORD reg_sampler_code;
1420     DWORD myflags = 0;
1421
1422     /* All versions have a destination register */
1423     shader_arb_get_dst_param(ins, dst, reg_dest);
1424
1425     /* 1.0-1.4: Use destination register number as texture code.
1426        2.0+: Use provided sampler number as texure code. */
1427     if (shader_version < WINED3D_SHADER_VERSION(2,0))
1428         reg_sampler_code = dst->reg.idx;
1429     else
1430         reg_sampler_code = ins->src[1].reg.idx;
1431
1432     /* 1.0-1.3: Use the texcoord varying.
1433        1.4+: Use provided coordinate source register. */
1434     if (shader_version < WINED3D_SHADER_VERSION(1,4))
1435         sprintf(reg_coord, "fragment.texcoord[%u]", reg_sampler_code);
1436     else {
1437         /* TEX is the only instruction that can handle DW and DZ natively */
1438         src = ins->src[0];
1439         if(src.modifiers == WINED3DSPSM_DW) src.modifiers = WINED3DSPSM_NONE;
1440         if(src.modifiers == WINED3DSPSM_DZ) src.modifiers = WINED3DSPSM_NONE;
1441         shader_arb_get_src_param(ins, &src, 0, reg_coord);
1442     }
1443
1444     /* projection flag:
1445      * 1.1, 1.2, 1.3: Use WINED3DTSS_TEXTURETRANSFORMFLAGS
1446      * 1.4: Use WINED3DSPSM_DZ or WINED3DSPSM_DW on src[0]
1447      * 2.0+: Use WINED3DSI_TEXLD_PROJECT on the opcode
1448      */
1449     if (shader_version < WINED3D_SHADER_VERSION(1,4))
1450     {
1451         DWORD flags = 0;
1452         if(reg_sampler_code < MAX_TEXTURES) {
1453             flags = deviceImpl->stateBlock->textureState[reg_sampler_code][WINED3DTSS_TEXTURETRANSFORMFLAGS];
1454         }
1455         if (flags & WINED3DTTFF_PROJECTED) {
1456             myflags |= TEX_PROJ;
1457         }
1458     }
1459     else if (shader_version < WINED3D_SHADER_VERSION(2,0))
1460     {
1461         DWORD src_mod = ins->src[0].modifiers;
1462         if (src_mod == WINED3DSPSM_DZ) {
1463             /* TXP cannot handle DZ natively, so move the z coordinate to .w. reg_coord is a read-only
1464              * varying register, so we need a temp reg
1465              */
1466             shader_addline(ins->ctx->buffer, "SWZ TA, %s, x, y, z, z;\n", reg_coord);
1467             strcpy(reg_coord, "TA");
1468             myflags |= TEX_PROJ;
1469         } else if(src_mod == WINED3DSPSM_DW) {
1470             myflags |= TEX_PROJ;
1471         }
1472     } else {
1473         if (ins->flags & WINED3DSI_TEXLD_PROJECT) myflags |= TEX_PROJ;
1474         if (ins->flags & WINED3DSI_TEXLD_BIAS) myflags |= TEX_BIAS;
1475     }
1476     shader_hw_sample(ins, reg_sampler_code, reg_dest, reg_coord, myflags, NULL, NULL);
1477 }
1478
1479 static void pshader_hw_texcoord(const struct wined3d_shader_instruction *ins)
1480 {
1481     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1482     SHADER_BUFFER *buffer = ins->ctx->buffer;
1483     DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
1484             ins->ctx->reg_maps->shader_version.minor);
1485     char dst_str[50];
1486
1487     if (shader_version < WINED3D_SHADER_VERSION(1,4))
1488     {
1489         DWORD reg = dst->reg.idx;
1490
1491         shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1492         shader_addline(buffer, "MOV_SAT %s, fragment.texcoord[%u];\n", dst_str, reg);
1493     } else {
1494         char reg_src[40];
1495
1496         shader_arb_get_src_param(ins, &ins->src[0], 0, reg_src);
1497         shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1498         shader_addline(buffer, "MOV %s, %s;\n", dst_str, reg_src);
1499    }
1500 }
1501
1502 static void pshader_hw_texreg2ar(const struct wined3d_shader_instruction *ins)
1503 {
1504      SHADER_BUFFER *buffer = ins->ctx->buffer;
1505      IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1506      IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1507      DWORD flags;
1508
1509      DWORD reg1 = ins->dst[0].reg.idx;
1510      char dst_str[50];
1511      char src_str[50];
1512
1513      /* Note that texreg2ar treats Tx as a temporary register, not as a varying */
1514      shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1515      shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
1516      /* Move .x first in case src_str is "TA" */
1517      shader_addline(buffer, "MOV TA.y, %s.x;\n", src_str);
1518      shader_addline(buffer, "MOV TA.x, %s.w;\n", src_str);
1519      flags = reg1 < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg1][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
1520      shader_hw_sample(ins, reg1, dst_str, "TA", flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
1521 }
1522
1523 static void pshader_hw_texreg2gb(const struct wined3d_shader_instruction *ins)
1524 {
1525      SHADER_BUFFER *buffer = ins->ctx->buffer;
1526
1527      DWORD reg1 = ins->dst[0].reg.idx;
1528      char dst_str[50];
1529      char src_str[50];
1530
1531      /* Note that texreg2gb treats Tx as a temporary register, not as a varying */
1532      shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1533      shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
1534      shader_addline(buffer, "MOV TA.x, %s.y;\n", src_str);
1535      shader_addline(buffer, "MOV TA.y, %s.z;\n", src_str);
1536      shader_hw_sample(ins, reg1, dst_str, "TA", 0, NULL, NULL);
1537 }
1538
1539 static void pshader_hw_texreg2rgb(const struct wined3d_shader_instruction *ins)
1540 {
1541     DWORD reg1 = ins->dst[0].reg.idx;
1542     char dst_str[50];
1543     char src_str[50];
1544
1545     /* Note that texreg2rg treats Tx as a temporary register, not as a varying */
1546     shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1547     shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
1548     shader_hw_sample(ins, reg1, dst_str, src_str, 0, NULL, NULL);
1549 }
1550
1551 static void pshader_hw_texbem(const struct wined3d_shader_instruction *ins)
1552 {
1553     IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1554     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1555     SHADER_BUFFER *buffer = ins->ctx->buffer;
1556     char reg_coord[40], dst_reg[50], src_reg[50];
1557     DWORD reg_dest_code;
1558
1559     /* All versions have a destination register. The Tx where the texture coordinates come
1560      * from is the varying incarnation of the texture register
1561      */
1562     reg_dest_code = dst->reg.idx;
1563     shader_arb_get_dst_param(ins, &ins->dst[0], dst_reg);
1564     shader_arb_get_src_param(ins, &ins->src[0], 0, src_reg);
1565     sprintf(reg_coord, "fragment.texcoord[%u]", reg_dest_code);
1566
1567     /* Sampling the perturbation map in Tsrc was done already, including the signedness correction if needed
1568      * The Tx in which the perturbation map is stored is the tempreg incarnation of the texture register
1569      *
1570      * GL_NV_fragment_program_option could handle this in one instruction via X2D:
1571      * X2D TA.xy, fragment.texcoord, T%u, bumpenvmat%u.xzyw
1572      *
1573      * However, the NV extensions are never enabled for <= 2.0 shaders because of the performance penalty that
1574      * comes with it, and texbem is an 1.x only instruction. No 1.x instruction forces us to enable the NV
1575      * extension.
1576      */
1577     shader_addline(buffer, "SWZ TB, bumpenvmat%d, x, z, 0, 0;\n", reg_dest_code);
1578     shader_addline(buffer, "DP3 TA.x, TB, %s;\n", src_reg);
1579     shader_addline(buffer, "SWZ TB, bumpenvmat%d, y, w, 0, 0;\n", reg_dest_code);
1580     shader_addline(buffer, "DP3 TA.y, TB, %s;\n", src_reg);
1581
1582     /* with projective textures, texbem only divides the static texture coord, not the displacement,
1583      * so we can't let the GL handle this.
1584      */
1585     if (((IWineD3DDeviceImpl*) This->baseShader.device)->stateBlock->textureState[reg_dest_code][WINED3DTSS_TEXTURETRANSFORMFLAGS]
1586             & WINED3DTTFF_PROJECTED) {
1587         shader_addline(buffer, "RCP TB.w, %s.w;\n", reg_coord);
1588         shader_addline(buffer, "MUL TB.xy, %s, TB.w;\n", reg_coord);
1589         shader_addline(buffer, "ADD TA.xy, TA, TB;\n");
1590     } else {
1591         shader_addline(buffer, "ADD TA.xy, TA, %s;\n", reg_coord);
1592     }
1593
1594     shader_hw_sample(ins, reg_dest_code, dst_reg, "TA", 0, NULL, NULL);
1595
1596     if (ins->handler_idx == WINED3DSIH_TEXBEML)
1597     {
1598         /* No src swizzles are allowed, so this is ok */
1599         shader_addline(buffer, "MAD TA, %s.z, luminance%d.x, luminance%d.y;\n",
1600                        src_reg, reg_dest_code, reg_dest_code);
1601         shader_addline(buffer, "MUL %s, %s, TA;\n", dst_reg, dst_reg);
1602     }
1603 }
1604
1605 static void pshader_hw_texm3x2pad(const struct wined3d_shader_instruction *ins)
1606 {
1607     DWORD reg = ins->dst[0].reg.idx;
1608     SHADER_BUFFER *buffer = ins->ctx->buffer;
1609     char src0_name[50], dst_name[50];
1610     BOOL is_color;
1611     struct wined3d_shader_register tmp_reg = ins->dst[0].reg;
1612
1613     shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1614     /* The next instruction will be a texm3x2tex or texm3x2depth that writes to the uninitialized
1615      * T<reg+1> register. Use this register to store the calculated vector
1616      */
1617     tmp_reg.idx = reg + 1;
1618     shader_arb_get_register_name(ins, &tmp_reg, dst_name, &is_color);
1619     shader_addline(buffer, "DP3 %s.x, fragment.texcoord[%u], %s;\n", dst_name, reg, src0_name);
1620 }
1621
1622 static void pshader_hw_texm3x2tex(const struct wined3d_shader_instruction *ins)
1623 {
1624     IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1625     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1626     DWORD flags;
1627     DWORD reg = ins->dst[0].reg.idx;
1628     SHADER_BUFFER *buffer = ins->ctx->buffer;
1629     char dst_str[50];
1630     char src0_name[50];
1631     char dst_reg[50];
1632     BOOL is_color;
1633
1634     /* We know that we're writing to the uninitialized T<reg> register, so use it for temporary storage */
1635     shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
1636
1637     shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1638     shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1639     shader_addline(buffer, "DP3 %s.y, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
1640     flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
1641     shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
1642 }
1643
1644 static void pshader_hw_texm3x3pad(const struct wined3d_shader_instruction *ins)
1645 {
1646     IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1647     DWORD reg = ins->dst[0].reg.idx;
1648     SHADER_BUFFER *buffer = ins->ctx->buffer;
1649     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
1650     char src0_name[50], dst_name[50];
1651     struct wined3d_shader_register tmp_reg = ins->dst[0].reg;
1652     BOOL is_color;
1653
1654     /* There are always 2 texm3x3pad instructions followed by one texm3x3[tex,vspec, ...] instruction, with
1655      * incrementing ins->dst[0].register_idx numbers. So the pad instruction already knows the final destination
1656      * register, and this register is uninitialized(otherwise the assembler complains that it is 'redeclared')
1657      */
1658     tmp_reg.idx = reg + 2 - current_state->current_row;
1659     shader_arb_get_register_name(ins, &tmp_reg, dst_name, &is_color);
1660
1661     shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1662     shader_addline(buffer, "DP3 %s.%c, fragment.texcoord[%u], %s;\n",
1663                    dst_name, 'x' + current_state->current_row, reg, src0_name);
1664     current_state->texcoord_w[current_state->current_row++] = reg;
1665 }
1666
1667 static void pshader_hw_texm3x3tex(const struct wined3d_shader_instruction *ins)
1668 {
1669     IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1670     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1671     DWORD flags;
1672     DWORD reg = ins->dst[0].reg.idx;
1673     SHADER_BUFFER *buffer = ins->ctx->buffer;
1674     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
1675     char dst_str[50];
1676     char src0_name[50], dst_name[50];
1677     BOOL is_color;
1678
1679     shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
1680     shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1681     shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_name, reg, src0_name);
1682
1683     /* Sample the texture using the calculated coordinates */
1684     shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1685     flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
1686     shader_hw_sample(ins, reg, dst_str, dst_name, flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
1687     current_state->current_row = 0;
1688 }
1689
1690 static void pshader_hw_texm3x3vspec(const struct wined3d_shader_instruction *ins)
1691 {
1692     IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1693     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1694     DWORD flags;
1695     DWORD reg = ins->dst[0].reg.idx;
1696     SHADER_BUFFER *buffer = ins->ctx->buffer;
1697     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
1698     char dst_str[50];
1699     char src0_name[50];
1700     char dst_reg[8];
1701     BOOL is_color;
1702
1703     /* Get the dst reg without writemask strings. We know this register is uninitialized, so we can use all
1704      * components for temporary data storage
1705      */
1706     shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
1707     shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1708     shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
1709
1710     /* Construct the eye-ray vector from w coordinates */
1711     shader_addline(buffer, "MOV TB.x, fragment.texcoord[%u].w;\n", current_state->texcoord_w[0]);
1712     shader_addline(buffer, "MOV TB.y, fragment.texcoord[%u].w;\n", current_state->texcoord_w[1]);
1713     shader_addline(buffer, "MOV TB.z, fragment.texcoord[%u].w;\n", reg);
1714
1715     /* Calculate reflection vector
1716      */
1717     shader_addline(buffer, "DP3 %s.w, %s, TB;\n", dst_reg, dst_reg);
1718     /* The .w is ignored when sampling, so I can use TB.w to calculate dot(N, N) */
1719     shader_addline(buffer, "DP3 TB.w, %s, %s;\n", dst_reg, dst_reg);
1720     shader_addline(buffer, "RCP TB.w, TB.w;\n");
1721     shader_addline(buffer, "MUL %s.w, %s.w, TB.w;\n", dst_reg, dst_reg);
1722     shader_addline(buffer, "MUL %s, %s.w, %s;\n", dst_reg, dst_reg, dst_reg);
1723     shader_addline(buffer, "MAD %s, coefmul.x, %s, -TB;\n", dst_reg, dst_reg);
1724
1725     /* Sample the texture using the calculated coordinates */
1726     shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1727     flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
1728     shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
1729     current_state->current_row = 0;
1730 }
1731
1732 static void pshader_hw_texm3x3spec(const struct wined3d_shader_instruction *ins)
1733 {
1734     IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
1735     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
1736     DWORD flags;
1737     DWORD reg = ins->dst[0].reg.idx;
1738     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
1739     SHADER_BUFFER *buffer = ins->ctx->buffer;
1740     char dst_str[50];
1741     char src0_name[50];
1742     char src1_name[50];
1743     char dst_reg[8];
1744     BOOL is_color;
1745
1746     shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
1747     shader_arb_get_src_param(ins, &ins->src[0], 1, src1_name);
1748     shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
1749     /* Note: dst_reg.xy is input here, generated by two texm3x3pad instructions */
1750     shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
1751
1752     /* Calculate reflection vector.
1753      *
1754      *                   dot(N, E)
1755      * dst_reg.xyz = 2 * --------- * N - E
1756      *                   dot(N, N)
1757      *
1758      * Which normalizes the normal vector
1759      */
1760     shader_addline(buffer, "DP3 %s.w, %s, %s;\n", dst_reg, dst_reg, src1_name);
1761     shader_addline(buffer, "DP3 TC.w, %s, %s;\n", dst_reg, dst_reg);
1762     shader_addline(buffer, "RCP TC.w, TC.w;\n");
1763     shader_addline(buffer, "MUL %s.w, %s.w, TC.w;\n", dst_reg, dst_reg);
1764     shader_addline(buffer, "MUL %s, %s.w, %s;\n", dst_reg, dst_reg, dst_reg);
1765     shader_addline(buffer, "MAD %s, coefmul.x, %s, -%s;\n", dst_reg, dst_reg, src1_name);
1766
1767     /* Sample the texture using the calculated coordinates */
1768     shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1769     flags = reg < MAX_TEXTURES ? deviceImpl->stateBlock->textureState[reg][WINED3DTSS_TEXTURETRANSFORMFLAGS] : 0;
1770     shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3DTTFF_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
1771     current_state->current_row = 0;
1772 }
1773
1774 static void pshader_hw_texdepth(const struct wined3d_shader_instruction *ins)
1775 {
1776     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1777     SHADER_BUFFER *buffer = ins->ctx->buffer;
1778     char dst_name[50];
1779
1780     /* texdepth has an implicit destination, the fragment depth value. It's only parameter,
1781      * which is essentially an input, is the destination register because it is the first
1782      * parameter. According to the msdn, this must be register r5, but let's keep it more flexible
1783      * here(writemasks/swizzles are not valid on texdepth)
1784      */
1785     shader_arb_get_dst_param(ins, dst, dst_name);
1786
1787     /* According to the msdn, the source register(must be r5) is unusable after
1788      * the texdepth instruction, so we're free to modify it
1789      */
1790     shader_addline(buffer, "MIN %s.y, %s.y, one.y;\n", dst_name, dst_name);
1791
1792     /* How to deal with the special case dst_name.g == 0? if r != 0, then
1793      * the r * (1 / 0) will give infinity, which is clamped to 1.0, the correct
1794      * result. But if r = 0.0, then 0 * inf = 0, which is incorrect.
1795      */
1796     shader_addline(buffer, "RCP %s.y, %s.y;\n", dst_name, dst_name);
1797     shader_addline(buffer, "MUL TA.x, %s.x, %s.y;\n", dst_name, dst_name);
1798     shader_addline(buffer, "MIN TA.x, TA.x, one.x;\n");
1799     shader_addline(buffer, "MAX result.depth, TA.x, 0.0;\n");
1800 }
1801
1802 /** Process the WINED3DSIO_TEXDP3TEX instruction in ARB:
1803  * Take a 3-component dot product of the TexCoord[dstreg] and src,
1804  * then perform a 1D texture lookup from stage dstregnum, place into dst. */
1805 static void pshader_hw_texdp3tex(const struct wined3d_shader_instruction *ins)
1806 {
1807     SHADER_BUFFER *buffer = ins->ctx->buffer;
1808     DWORD sampler_idx = ins->dst[0].reg.idx;
1809     char src0[50];
1810     char dst_str[50];
1811
1812     shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
1813     shader_addline(buffer, "MOV TB, 0.0;\n");
1814     shader_addline(buffer, "DP3 TB.x, fragment.texcoord[%u], %s;\n", sampler_idx, src0);
1815
1816     shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
1817     shader_hw_sample(ins, sampler_idx, dst_str, "TB", 0 /* Only one coord, can't be projected */, NULL, NULL);
1818 }
1819
1820 /** Process the WINED3DSIO_TEXDP3 instruction in ARB:
1821  * Take a 3-component dot product of the TexCoord[dstreg] and src. */
1822 static void pshader_hw_texdp3(const struct wined3d_shader_instruction *ins)
1823 {
1824     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1825     char src0[50];
1826     char dst_str[50];
1827     SHADER_BUFFER *buffer = ins->ctx->buffer;
1828
1829     /* Handle output register */
1830     shader_arb_get_dst_param(ins, dst, dst_str);
1831     shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
1832     shader_addline(buffer, "DP3 %s, fragment.texcoord[%u], %s;\n", dst_str, dst->reg.idx, src0);
1833 }
1834
1835 /** Process the WINED3DSIO_TEXM3X3 instruction in ARB
1836  * Perform the 3rd row of a 3x3 matrix multiply */
1837 static void pshader_hw_texm3x3(const struct wined3d_shader_instruction *ins)
1838 {
1839     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1840     SHADER_BUFFER *buffer = ins->ctx->buffer;
1841     char dst_str[50], dst_name[50];
1842     char src0[50];
1843     BOOL is_color;
1844
1845     shader_arb_get_dst_param(ins, dst, dst_str);
1846     shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
1847     shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
1848     shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_name, dst->reg.idx, src0);
1849     shader_addline(buffer, "MOV %s, %s;\n", dst_str, dst_name);
1850 }
1851
1852 /** Process the WINED3DSIO_TEXM3X2DEPTH instruction in ARB:
1853  * Last row of a 3x2 matrix multiply, use the result to calculate the depth:
1854  * Calculate tmp0.y = TexCoord[dstreg] . src.xyz;  (tmp0.x has already been calculated)
1855  * depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
1856  */
1857 static void pshader_hw_texm3x2depth(const struct wined3d_shader_instruction *ins)
1858 {
1859     SHADER_BUFFER *buffer = ins->ctx->buffer;
1860     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1861     char src0[50], dst_name[50];
1862     BOOL is_color;
1863
1864     shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
1865     shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
1866     shader_addline(buffer, "DP3 %s.y, fragment.texcoord[%u], %s;\n", dst_name, dst->reg.idx, src0);
1867
1868     /* How to deal with the special case dst_name.g == 0? if r != 0, then
1869      * the r * (1 / 0) will give infinity, which is clamped to 1.0, the correct
1870      * result. But if r = 0.0, then 0 * inf = 0, which is incorrect.
1871      */
1872     shader_addline(buffer, "RCP %s.y, %s.y;\n", dst_name, dst_name);
1873     shader_addline(buffer, "MUL %s.x, %s.x, %s.y;\n", dst_name, dst_name, dst_name);
1874     shader_addline(buffer, "MIN %s.x, %s.x, one.x;\n", dst_name, dst_name);
1875     shader_addline(buffer, "MAX result.depth, %s.x, 0.0;\n", dst_name);
1876 }
1877
1878 /** Handles transforming all WINED3DSIO_M?x? opcodes for
1879     Vertex/Pixel shaders to ARB_vertex_program codes */
1880 static void shader_hw_mnxn(const struct wined3d_shader_instruction *ins)
1881 {
1882     int i;
1883     int nComponents = 0;
1884     struct wined3d_shader_dst_param tmp_dst = {{0}};
1885     struct wined3d_shader_src_param tmp_src[2] = {{{0}}};
1886     struct wined3d_shader_instruction tmp_ins;
1887
1888     memset(&tmp_ins, 0, sizeof(tmp_ins));
1889
1890     /* Set constants for the temporary argument */
1891     tmp_ins.ctx = ins->ctx;
1892     tmp_ins.dst_count = 1;
1893     tmp_ins.dst = &tmp_dst;
1894     tmp_ins.src_count = 2;
1895     tmp_ins.src = tmp_src;
1896
1897     switch(ins->handler_idx)
1898     {
1899         case WINED3DSIH_M4x4:
1900             nComponents = 4;
1901             tmp_ins.handler_idx = WINED3DSIH_DP4;
1902             break;
1903         case WINED3DSIH_M4x3:
1904             nComponents = 3;
1905             tmp_ins.handler_idx = WINED3DSIH_DP4;
1906             break;
1907         case WINED3DSIH_M3x4:
1908             nComponents = 4;
1909             tmp_ins.handler_idx = WINED3DSIH_DP3;
1910             break;
1911         case WINED3DSIH_M3x3:
1912             nComponents = 3;
1913             tmp_ins.handler_idx = WINED3DSIH_DP3;
1914             break;
1915         case WINED3DSIH_M3x2:
1916             nComponents = 2;
1917             tmp_ins.handler_idx = WINED3DSIH_DP3;
1918             break;
1919         default:
1920             FIXME("Unhandled opcode %#x\n", ins->handler_idx);
1921             break;
1922     }
1923
1924     tmp_dst = ins->dst[0];
1925     tmp_src[0] = ins->src[0];
1926     tmp_src[1] = ins->src[1];
1927     for (i = 0; i < nComponents; i++) {
1928         tmp_dst.write_mask = WINED3DSP_WRITEMASK_0 << i;
1929         shader_hw_map2gl(&tmp_ins);
1930         ++tmp_src[1].reg.idx;
1931     }
1932 }
1933
1934 static void shader_hw_rsq_rcp(const struct wined3d_shader_instruction *ins)
1935 {
1936     SHADER_BUFFER *buffer = ins->ctx->buffer;
1937     const char *instruction;
1938
1939     char dst[50];
1940     char src[50];
1941
1942     switch(ins->handler_idx)
1943     {
1944         case WINED3DSIH_RSQ: instruction = "RSQ"; break;
1945         case WINED3DSIH_RCP: instruction = "RCP"; break;
1946         default: instruction = "";
1947             FIXME("Unhandled opcode %#x\n", ins->handler_idx);
1948             break;
1949     }
1950
1951     shader_arb_get_dst_param(ins, &ins->dst[0], dst); /* Destination */
1952     shader_arb_get_src_param(ins, &ins->src[0], 0, src);
1953     if (ins->src[0].swizzle == WINED3DSP_NOSWIZZLE)
1954     {
1955         /* Dx sdk says .x is used if no swizzle is given, but our test shows that
1956          * .w is used
1957          */
1958         strcat(src, ".w");
1959     }
1960
1961     shader_addline(buffer, "%s%s %s, %s;\n", instruction, shader_arb_get_modifier(ins), dst, src);
1962 }
1963
1964 static void shader_hw_nrm(const struct wined3d_shader_instruction *ins)
1965 {
1966     SHADER_BUFFER *buffer = ins->ctx->buffer;
1967     char dst_name[50];
1968     char src_name[50];
1969     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
1970     BOOL pshader = shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type);
1971
1972     shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
1973     shader_arb_get_src_param(ins, &ins->src[0], 1 /* Use TB */, src_name);
1974
1975     if(pshader && priv->target_version >= NV3)
1976     {
1977         shader_addline(buffer, "NRM%s %s, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name);
1978     }
1979     else
1980     {
1981         shader_addline(buffer, "DP3 TA, %s, %s;\n", src_name, src_name);
1982         shader_addline(buffer, "RSQ TA, TA.x;\n");
1983         /* dst.w = src[0].w * 1 / (src.x^2 + src.y^2 + src.z^2)^(1/2) according to msdn*/
1984         shader_addline(buffer, "MUL%s %s, %s, TA;\n", shader_arb_get_modifier(ins), dst_name,
1985                     src_name);
1986     }
1987 }
1988
1989 static void shader_hw_lrp(const struct wined3d_shader_instruction *ins)
1990 {
1991     SHADER_BUFFER *buffer = ins->ctx->buffer;
1992     char dst_name[50];
1993     char src_name[3][50];
1994
1995     /* ARB_fragment_program has a convenient LRP instruction */
1996     if(shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)) {
1997         shader_hw_map2gl(ins);
1998         return;
1999     }
2000
2001     shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2002     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
2003     shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
2004     shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
2005
2006     shader_addline(buffer, "SUB TA, %s, %s;\n", src_name[1], src_name[2]);
2007     shader_addline(buffer, "MAD%s %s, %s, TA, %s;\n", shader_arb_get_modifier(ins),
2008                    dst_name, src_name[0], src_name[2]);
2009 }
2010
2011 static void shader_hw_sincos(const struct wined3d_shader_instruction *ins)
2012 {
2013     /* This instruction exists in ARB, but the d3d instruction takes two extra parameters which
2014      * must contain fixed constants. So we need a separate function to filter those constants and
2015      * can't use map2gl
2016      */
2017     SHADER_BUFFER *buffer = ins->ctx->buffer;
2018     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2019     const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2020     char dst_name[50];
2021     char src_name0[50], src_name1[50], src_name2[50];
2022     BOOL is_color;
2023
2024     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
2025     if(shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)) {
2026         shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2027         shader_addline(buffer, "SCS%s %s, %s;\n", shader_arb_get_modifier(ins), dst_name,
2028                        src_name0);
2029     } else if(priv->target_version >= NV2) {
2030         shader_arb_get_register_name(ins, &dst->reg, dst_name, &is_color);
2031
2032         /* Sincos writemask must be .x, .y or .xy */
2033         if(dst->write_mask & WINED3DSP_WRITEMASK_0)
2034             shader_addline(buffer, "COS%s %s.x, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name0);
2035         if(dst->write_mask & WINED3DSP_WRITEMASK_1)
2036             shader_addline(buffer, "SIN%s %s.y, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name0);
2037     } else {
2038         /* Approximate sine and cosine with a taylor series, as per math textbook. The application passes 8
2039          * helper constants(D3DSINCOSCONST1 and D3DSINCOSCONST2) in src1 and src2.
2040          *
2041          * sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ...
2042          * cos(x) = 1 - x^2/2! + x^4/4! - x^6/6! + ...
2043          *
2044          * The constants we get are:
2045          *
2046          *  +1   +1,     -1     -1     +1      +1      -1       -1
2047          *      ---- ,  ---- , ---- , ----- , ----- , ----- , ------
2048          *      1!*2    2!*4   3!*8   4!*16   5!*32   6!*64   7!*128
2049          *
2050          * If used with x^2, x^3, x^4 etc they calculate sin(x/2) and cos(x/2):
2051          *
2052          * (x/2)^2 = x^2 / 4
2053          * (x/2)^3 = x^3 / 8
2054          * (x/2)^4 = x^4 / 16
2055          * (x/2)^5 = x^5 / 32
2056          * etc
2057          *
2058          * To get the final result:
2059          * sin(x) = 2 * sin(x/2) * cos(x/2)
2060          * cos(x) = cos(x/2)^2 - sin(x/2)^2
2061          * (from sin(x+y) and cos(x+y) rules)
2062          *
2063          * As per MSDN, dst.z is undefined after the operation, and so is
2064          * dst.x and dst.y if they're masked out by the writemask. Ie
2065          * sincos dst.y, src1, c0, c1
2066          * returns the sine in dst.y. dst.x and dst.z are undefined, dst.w is not touched. The assembler
2067          * vsa.exe also stops with an error if the dest register is the same register as the source
2068          * register. This means we can use dest.xyz as temporary storage. The assembler vsa.exe output also
2069          * indicates that sincos consumes 8 instruction slots in vs_2_0(and, strangely, in vs_3_0).
2070          */
2071         shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
2072         shader_arb_get_src_param(ins, &ins->src[2], 2, src_name2);
2073         shader_arb_get_register_name(ins, &dst->reg, dst_name, &is_color);
2074
2075         shader_addline(buffer, "MUL %s.x, %s, %s;\n", dst_name, src_name0, src_name0);  /* x ^ 2 */
2076         shader_addline(buffer, "MUL TA.y, %s.x, %s;\n", dst_name, src_name0);           /* x ^ 3 */
2077         shader_addline(buffer, "MUL %s.y, TA.y, %s;\n", dst_name, src_name0);           /* x ^ 4 */
2078         shader_addline(buffer, "MUL TA.z, %s.y, %s;\n", dst_name, src_name0);           /* x ^ 5 */
2079         shader_addline(buffer, "MUL %s.z, TA.z, %s;\n", dst_name, src_name0);           /* x ^ 6 */
2080         shader_addline(buffer, "MUL TA.w, %s.z, %s;\n", dst_name, src_name0);           /* x ^ 7 */
2081
2082         /* sin(x/2)
2083          *
2084          * Unfortunately we don't get the constants in a DP4-capable form. Is there a way to
2085          * properly merge that with MULs in the code above?
2086          * The swizzles .yz and xw however fit into the .yzxw swizzle added to ps_2_0. Maybe
2087          * we can merge the sine and cosine MAD rows to calculate them together.
2088          */
2089         shader_addline(buffer, "MUL TA.x, %s, %s.w;\n", src_name0, src_name2); /* x^1, +1/(1!*2) */
2090         shader_addline(buffer, "MAD TA.x, TA.y, %s.x, TA.x;\n", src_name2); /* -1/(3!*8) */
2091         shader_addline(buffer, "MAD TA.x, TA.z, %s.w, TA.x;\n", src_name1); /* +1/(5!*32) */
2092         shader_addline(buffer, "MAD TA.x, TA.w, %s.x, TA.x;\n", src_name1); /* -1/(7!*128) */
2093
2094         /* cos(x/2) */
2095         shader_addline(buffer, "MAD TA.y, %s.x, %s.y, %s.z;\n", dst_name, src_name2, src_name2); /* -1/(2!*4), +1.0 */
2096         shader_addline(buffer, "MAD TA.y, %s.y, %s.z, TA.y;\n", dst_name, src_name1); /* +1/(4!*16) */
2097         shader_addline(buffer, "MAD TA.y, %s.z, %s.y, TA.y;\n", dst_name, src_name1); /* -1/(6!*64) */
2098
2099         if(dst->write_mask & WINED3DSP_WRITEMASK_0) {
2100             /* cos x */
2101             shader_addline(buffer, "MUL TA.z, TA.y, TA.y;\n");
2102             shader_addline(buffer, "MAD %s.x, -TA.x, TA.x, TA.z;\n", dst_name);
2103         }
2104         if(dst->write_mask & WINED3DSP_WRITEMASK_1) {
2105             /* sin x */
2106             shader_addline(buffer, "MUL %s.y, TA.x, TA.y;\n", dst_name);
2107             shader_addline(buffer, "ADD %s.y, %s.y, %s.y;\n", dst_name, dst_name, dst_name);
2108         }
2109     }
2110 }
2111
2112 /* GL locking is done by the caller */
2113 static void shader_hw_sgn(const struct wined3d_shader_instruction *ins)
2114 {
2115     SHADER_BUFFER *buffer = ins->ctx->buffer;
2116     char dst_name[50];
2117     char src_name[50];
2118     struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
2119
2120     /* SGN is only valid in vertex shaders */
2121     if(ctx->target_version == NV2) {
2122         shader_hw_map2gl(ins);
2123         return;
2124     }
2125     shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2126     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name);
2127
2128     FIXME("Emulated SGN untested\n");
2129     /* If SRC > 0.0, -SRC < SRC = TRUE, otherwise false.
2130      * if SRC < 0.0,  SRC < -SRC = TRUE. If neither is true, src = 0.0
2131      */
2132     if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE) {
2133         shader_addline(buffer, "SLT %s, -%s, %s;\n", dst_name, src_name, src_name);
2134     } else {
2135         shader_addline(buffer, "SLT TB, -%s, %s;\n", src_name, src_name);
2136         shader_addline(buffer, "SLT TC,  %s, -%s;\n", src_name, src_name);
2137         shader_addline(buffer, "ADD %s, TB, -TC;\n", dst_name);
2138     }
2139 }
2140
2141 static void shader_hw_dsy(const struct wined3d_shader_instruction *ins)
2142 {
2143     SHADER_BUFFER *buffer = ins->ctx->buffer;
2144     char src[50];
2145     char dst[50];
2146     char dst_name[50];
2147     BOOL is_color;
2148
2149     shader_arb_get_dst_param(ins, &ins->dst[0], dst);
2150     shader_arb_get_src_param(ins, &ins->src[0], 0, src);
2151     shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2152
2153     shader_addline(buffer, "DDY %s, %s;\n", dst, src);
2154     shader_addline(buffer, "MUL%s %s, %s, ycorrection.y;\n", shader_arb_get_modifier(ins), dst, dst_name);
2155 }
2156
2157 static void shader_hw_loop(const struct wined3d_shader_instruction *ins)
2158 {
2159     SHADER_BUFFER *buffer = ins->ctx->buffer;
2160     char src_name[50];
2161     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2162
2163     /* src0 is aL */
2164     shader_arb_get_src_param(ins, &ins->src[1], 0, src_name);
2165
2166     if(vshader)
2167     {
2168         struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2169         struct list *e = list_head(&priv->control_frames);
2170         struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2171
2172         if(priv->loop_depth > 1) shader_addline(buffer, "PUSHA aL;\n");
2173         /* The constant loader makes sure to load -1 into iX.w */
2174         shader_addline(buffer, "ARLC aL, %s.xywz;\n", src_name);
2175         shader_addline(buffer, "BRA loop_%u_end (LE.x);\n", control_frame->loop_no);
2176         shader_addline(buffer, "loop_%u_start:\n", control_frame->loop_no);
2177     }
2178     else
2179     {
2180         shader_addline(buffer, "LOOP %s;\n", src_name);
2181     }
2182 }
2183
2184 static void shader_hw_rep(const struct wined3d_shader_instruction *ins)
2185 {
2186     SHADER_BUFFER *buffer = ins->ctx->buffer;
2187     char src_name[50];
2188     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2189
2190     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name);
2191
2192     /* The constant loader makes sure to load -1 into iX.w */
2193     if(vshader)
2194     {
2195         struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2196         struct list *e = list_head(&priv->control_frames);
2197         struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2198
2199         if(priv->loop_depth > 1) shader_addline(buffer, "PUSHA aL;\n");
2200
2201         shader_addline(buffer, "ARLC aL, %s.xywz;\n", src_name);
2202         shader_addline(buffer, "BRA loop_%u_end (LE.x);\n", control_frame->loop_no);
2203         shader_addline(buffer, "loop_%u_start:\n", control_frame->loop_no);
2204     }
2205     else
2206     {
2207         shader_addline(buffer, "REP %s;\n", src_name);
2208     }
2209 }
2210
2211 static void shader_hw_endloop(const struct wined3d_shader_instruction *ins)
2212 {
2213     SHADER_BUFFER *buffer = ins->ctx->buffer;
2214     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2215
2216     if(vshader)
2217     {
2218         struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2219         struct list *e = list_head(&priv->control_frames);
2220         struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2221
2222         shader_addline(buffer, "ARAC aL.xy, aL;\n");
2223         shader_addline(buffer, "BRA loop_%u_start (GT.x);\n", control_frame->loop_no);
2224         shader_addline(buffer, "loop_%u_end:\n", control_frame->loop_no);
2225
2226         if(priv->loop_depth > 1) shader_addline(buffer, "POPA aL;\n");
2227     }
2228     else
2229     {
2230         shader_addline(buffer, "ENDLOOP;\n");
2231     }
2232 }
2233
2234 static void shader_hw_endrep(const struct wined3d_shader_instruction *ins)
2235 {
2236     SHADER_BUFFER *buffer = ins->ctx->buffer;
2237     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2238
2239     if(vshader)
2240     {
2241         struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2242         struct list *e = list_head(&priv->control_frames);
2243         struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2244
2245         shader_addline(buffer, "ARAC aL.xy, aL;\n");
2246         shader_addline(buffer, "BRA loop_%u_start (GT.x);\n", control_frame->loop_no);
2247         shader_addline(buffer, "loop_%u_end:\n", control_frame->loop_no);
2248
2249         if(priv->loop_depth > 1) shader_addline(buffer, "POPA aL;\n");
2250     }
2251     else
2252     {
2253         shader_addline(buffer, "ENDREP;\n");
2254     }
2255 }
2256
2257 static const struct control_frame *find_last_loop(const struct shader_arb_ctx_priv *priv)
2258 {
2259     struct control_frame *control_frame;
2260
2261     LIST_FOR_EACH_ENTRY(control_frame, &priv->control_frames, struct control_frame, entry)
2262     {
2263         if(control_frame->type == LOOP || control_frame->type == REP) return control_frame;
2264     }
2265     ERR("Could not find loop for break\n");
2266     return NULL;
2267 }
2268
2269 static void shader_hw_break(const struct wined3d_shader_instruction *ins)
2270 {
2271     SHADER_BUFFER *buffer = ins->ctx->buffer;
2272     const struct control_frame *control_frame = find_last_loop(ins->ctx->backend_data);
2273     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2274
2275     if(vshader)
2276     {
2277         shader_addline(buffer, "BRA loop_%u_end;\n", control_frame->loop_no);
2278     }
2279     else
2280     {
2281         shader_addline(buffer, "BRK;\n");
2282     }
2283 }
2284
2285 static void shader_hw_breakc(const struct wined3d_shader_instruction *ins)
2286 {
2287     SHADER_BUFFER *buffer = ins->ctx->buffer;
2288     const struct control_frame *control_frame = find_last_loop(ins->ctx->backend_data);
2289     char src_name0[50];
2290     char src_name1[50];
2291     const char *comp;
2292     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2293
2294     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
2295     shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
2296
2297     switch (ins->flags)
2298     {
2299         case COMPARISON_GT: comp = "GT"; break;
2300         case COMPARISON_EQ: comp = "EQ"; break;
2301         case COMPARISON_GE: comp = "GE"; break;
2302         case COMPARISON_LT: comp = "LT"; break;
2303         case COMPARISON_NE: comp = "NE"; break;
2304         case COMPARISON_LE: comp = "LE"; break;
2305         default:
2306             FIXME("Unrecognized comparison value: %u\n", ins->flags);
2307             comp = "(\?\?)";
2308     }
2309
2310     if(vshader)
2311     {
2312         /* SUBC CC, src0, src1" works only in pixel shaders, so use TA to throw
2313          * away the subtraction result
2314          */
2315         shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
2316         shader_addline(buffer, "BRA loop_%u_end (%s.x);\n", control_frame->loop_no, comp);
2317     }
2318     else
2319     {
2320         shader_addline(buffer, "SUBC CC, %s, %s;\n", src_name0, src_name1);
2321         shader_addline(buffer, "BRK (%s.x);\n", comp);
2322     }
2323 }
2324
2325 static void shader_hw_ifc(const struct wined3d_shader_instruction *ins)
2326 {
2327     SHADER_BUFFER *buffer = ins->ctx->buffer;
2328     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2329     struct list *e = list_head(&priv->control_frames);
2330     struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2331     const char *comp;
2332     char src_name0[50];
2333     char src_name1[50];
2334     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2335
2336     /* Invert the flag. We jump to the else label if the condition is NOT true */
2337     switch(ins->flags)
2338     {
2339         case COMPARISON_GT: comp = "LE"; break;
2340         case COMPARISON_EQ: comp = "NE"; break;
2341         case COMPARISON_GE: comp = "LT"; break;
2342         case COMPARISON_LT: comp = "GE"; break;
2343         case COMPARISON_NE: comp = "EQ"; break;
2344         case COMPARISON_LE: comp = "GT"; break;
2345         default:
2346             FIXME("Unrecognized comparison value: %u\n", ins->flags);
2347             comp = "\?\?";
2348     }
2349
2350     shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
2351     shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
2352
2353     if(vshader)
2354     {
2355         shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
2356         shader_addline(buffer, "BRA ifc_%u_endif (%s.x);\n", control_frame->ifc_no, comp);
2357     }
2358     else
2359     {
2360         shader_addline(buffer, "SUBC CC, %s, %s;\n", src_name0, src_name1);
2361         shader_addline(buffer, "IF %s.x;\n", comp);
2362     }
2363 }
2364
2365 static void shader_hw_else(const struct wined3d_shader_instruction *ins)
2366 {
2367     SHADER_BUFFER *buffer = ins->ctx->buffer;
2368     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2369     struct list *e = list_head(&priv->control_frames);
2370     struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2371     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2372
2373     if(vshader)
2374     {
2375         shader_addline(buffer, "BRA ifc_%u_endif;\n", control_frame->ifc_no);
2376         shader_addline(buffer, "ifc_%u_else:\n", control_frame->ifc_no);
2377         control_frame->had_else = TRUE;
2378     }
2379     else
2380     {
2381         shader_addline(buffer, "ELSE;\n");
2382     }
2383 }
2384
2385 static void shader_hw_endif(const struct wined3d_shader_instruction *ins)
2386 {
2387     SHADER_BUFFER *buffer = ins->ctx->buffer;
2388     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2389     struct list *e = list_head(&priv->control_frames);
2390     struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
2391     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2392
2393     if(vshader)
2394     {
2395         if(control_frame->had_else)
2396         {
2397             shader_addline(buffer, "ifc_%u_endif:\n", control_frame->ifc_no);
2398         }
2399         else
2400         {
2401             shader_addline(buffer, "#No else branch. else is endif\n");
2402             shader_addline(buffer, "ifc_%u_else:\n", control_frame->ifc_no);
2403         }
2404     }
2405     else
2406     {
2407         shader_addline(buffer, "ENDIF;\n");
2408     }
2409 }
2410
2411 static void shader_hw_texldd(const struct wined3d_shader_instruction *ins)
2412 {
2413     DWORD sampler_idx = ins->src[1].reg.idx;
2414     char reg_dest[40];
2415     char reg_src[3][40];
2416     DWORD flags = TEX_DERIV;
2417
2418     shader_arb_get_dst_param(ins, &ins->dst[0], reg_dest);
2419     shader_arb_get_src_param(ins, &ins->src[0], 0, reg_src[0]);
2420     shader_arb_get_src_param(ins, &ins->src[2], 1, reg_src[1]);
2421     shader_arb_get_src_param(ins, &ins->src[3], 2, reg_src[2]);
2422
2423     if (ins->flags & WINED3DSI_TEXLD_PROJECT) flags |= TEX_PROJ;
2424     if (ins->flags & WINED3DSI_TEXLD_BIAS) flags |= TEX_BIAS;
2425
2426     shader_hw_sample(ins, sampler_idx, reg_dest, reg_src[0], flags, reg_src[1], reg_src[2]);
2427 }
2428
2429 static void shader_hw_texldl(const struct wined3d_shader_instruction *ins)
2430 {
2431     DWORD sampler_idx = ins->src[1].reg.idx;
2432     char reg_dest[40];
2433     char reg_coord[40];
2434     DWORD flags = TEX_LOD;
2435
2436     shader_arb_get_dst_param(ins, &ins->dst[0], reg_dest);
2437     shader_arb_get_src_param(ins, &ins->src[0], 0, reg_coord);
2438
2439     if (ins->flags & WINED3DSI_TEXLD_PROJECT) flags |= TEX_PROJ;
2440     if (ins->flags & WINED3DSI_TEXLD_BIAS) flags |= TEX_BIAS;
2441
2442     shader_hw_sample(ins, sampler_idx, reg_dest, reg_coord, flags, NULL, NULL);
2443 }
2444
2445 static GLuint create_arb_blt_vertex_program(const WineD3D_GL_Info *gl_info)
2446 {
2447     GLuint program_id = 0;
2448     const char *blt_vprogram =
2449         "!!ARBvp1.0\n"
2450         "PARAM c[1] = { { 1, 0.5 } };\n"
2451         "MOV result.position, vertex.position;\n"
2452         "MOV result.color, c[0].x;\n"
2453         "MOV result.texcoord[0], vertex.texcoord[0];\n"
2454         "END\n";
2455
2456     GL_EXTCALL(glGenProgramsARB(1, &program_id));
2457     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, program_id));
2458     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_vprogram), blt_vprogram));
2459
2460     if (glGetError() == GL_INVALID_OPERATION) {
2461         GLint pos;
2462         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
2463         FIXME("Vertex program error at position %d: %s\n", pos,
2464             debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
2465     }
2466
2467     return program_id;
2468 }
2469
2470 /* GL locking is done by the caller */
2471 static GLuint create_arb_blt_fragment_program(const WineD3D_GL_Info *gl_info, enum tex_types tex_type)
2472 {
2473     GLuint program_id = 0;
2474     static const char * const blt_fprograms[tex_type_count] =
2475     {
2476         /* tex_1d */
2477         NULL,
2478         /* tex_2d */
2479         "!!ARBfp1.0\n"
2480         "TEMP R0;\n"
2481         "TEX R0.x, fragment.texcoord[0], texture[0], 2D;\n"
2482         "MOV result.depth.z, R0.x;\n"
2483         "END\n",
2484         /* tex_3d */
2485         NULL,
2486         /* tex_cube */
2487         "!!ARBfp1.0\n"
2488         "TEMP R0;\n"
2489         "TEX R0.x, fragment.texcoord[0], texture[0], CUBE;\n"
2490         "MOV result.depth.z, R0.x;\n"
2491         "END\n",
2492         /* tex_rect */
2493         "!!ARBfp1.0\n"
2494         "TEMP R0;\n"
2495         "TEX R0.x, fragment.texcoord[0], texture[0], RECT;\n"
2496         "MOV result.depth.z, R0.x;\n"
2497         "END\n",
2498     };
2499
2500     if (!blt_fprograms[tex_type])
2501     {
2502         FIXME("tex_type %#x not supported\n", tex_type);
2503         tex_type = tex_2d;
2504     }
2505
2506     GL_EXTCALL(glGenProgramsARB(1, &program_id));
2507     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program_id));
2508     GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_fprograms[tex_type]), blt_fprograms[tex_type]));
2509
2510     if (glGetError() == GL_INVALID_OPERATION) {
2511         GLint pos;
2512         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
2513         FIXME("Fragment program error at position %d: %s\n", pos,
2514             debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
2515     }
2516
2517     return program_id;
2518 }
2519
2520 static void arbfp_add_sRGB_correction(SHADER_BUFFER *buffer, const char *fragcolor, const char *tmp1,
2521                                       const char *tmp2, const char *tmp3, const char *tmp4, BOOL condcode) {
2522     /* Perform sRGB write correction. See GLX_EXT_framebuffer_sRGB */
2523
2524     if(condcode)
2525     {
2526         /* Sigh. MOVC CC doesn't work, so use one of the temps as dummy dest */
2527         shader_addline(buffer, "SUBC %s, %s.x, srgb_consts1.y;\n", tmp1, fragcolor);
2528         /* Calculate the > 0.0031308 case */
2529         shader_addline(buffer, "POW %s.x (GE), %s.x, srgb_consts1.z;\n", fragcolor, fragcolor);
2530         shader_addline(buffer, "POW %s.y (GE), %s.y, srgb_consts1.z;\n", fragcolor, fragcolor);
2531         shader_addline(buffer, "POW %s.z (GE), %s.z, srgb_consts1.z;\n", fragcolor, fragcolor);
2532         shader_addline(buffer, "MUL %s.xyz (GE), %s, srgb_consts1.w;\n", fragcolor, fragcolor);
2533         shader_addline(buffer, "SUB %s.xyz (GE), %s, srgb_consts2.x;\n", fragcolor, fragcolor);
2534         /* Calculate the < case */
2535         shader_addline(buffer, "MUL %s.xyz (LT), srgb_consts1.x, %s;\n", fragcolor, fragcolor);
2536     }
2537     else
2538     {
2539         /* Calculate the > 0.0031308 case */
2540         shader_addline(buffer, "POW %s.x, %s.x, srgb_consts1.z;\n", tmp1, fragcolor);
2541         shader_addline(buffer, "POW %s.y, %s.y, srgb_consts1.z;\n", tmp1, fragcolor);
2542         shader_addline(buffer, "POW %s.z, %s.z, srgb_consts1.z;\n", tmp1, fragcolor);
2543         shader_addline(buffer, "MUL %s, %s, srgb_consts1.w;\n", tmp1, tmp1);
2544         shader_addline(buffer, "SUB %s, %s, srgb_consts2.x;\n", tmp1, tmp1);
2545         /* Calculate the < case */
2546         shader_addline(buffer, "MUL %s, srgb_consts1.x, %s;\n", tmp2, fragcolor);
2547         /* Get 1.0 / 0.0 masks for > 0.0031308 and < 0.0031308 */
2548         shader_addline(buffer, "SLT %s, srgb_consts1.y, %s;\n", tmp3, fragcolor);
2549         shader_addline(buffer, "SGE %s, srgb_consts1.y, %s;\n", tmp4, fragcolor);
2550         /* Store the components > 0.0031308 in the destination */
2551         shader_addline(buffer, "MUL %s.xyz, %s, %s;\n", fragcolor, tmp1, tmp3);
2552         /* Add the components that are < 0.0031308 */
2553         shader_addline(buffer, "MAD %s.xyz, %s, %s, %s;\n", fragcolor, tmp2, tmp4, fragcolor);
2554         /* Move everything into result.color at once. Nvidia hardware cannot handle partial
2555         * result.color writes(.rgb first, then .a), or handle overwriting already written
2556         * components. The assembler uses a temporary register in this case, which is usually
2557         * not allocated from one of our registers that were used earlier.
2558         */
2559     }
2560     shader_addline(buffer, "MOV result.color, %s;\n", fragcolor);
2561     /* [0.0;1.0] clamping. Not needed, this is done implicitly */
2562 }
2563
2564 static const DWORD *find_loop_control_values(IWineD3DBaseShaderImpl *This, DWORD idx)
2565 {
2566     const local_constant *constant;
2567
2568     LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsI, local_constant, entry)
2569     {
2570         if (constant->idx == idx)
2571         {
2572             return constant->value;
2573         }
2574     }
2575     return NULL;
2576 }
2577
2578 /* GL locking is done by the caller */
2579 static GLuint shader_arb_generate_pshader(IWineD3DPixelShaderImpl *This,
2580         SHADER_BUFFER *buffer, const struct arb_ps_compile_args *args, struct arb_ps_compiled_shader *compiled)
2581 {
2582     const shader_reg_maps* reg_maps = &This->baseShader.reg_maps;
2583     CONST DWORD *function = This->baseShader.function;
2584     const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info;
2585     const local_constant *lconst;
2586     GLuint retval;
2587     char fragcolor[16];
2588     DWORD *lconst_map = local_const_mapping((IWineD3DBaseShaderImpl *) This), next_local, cur;
2589     struct shader_arb_ctx_priv priv_ctx;
2590     BOOL dcl_tmp = args->super.srgb_correction, dcl_td = FALSE;
2591     BOOL want_nv_prog = FALSE;
2592
2593     char srgbtmp[4][4];
2594     unsigned int i, found = 0;
2595
2596     for(i = 0; i < This->baseShader.limits.temporary; i++) {
2597
2598         /* Don't overwrite the color source */
2599         if(This->color0_mov && i == This->color0_reg) continue;
2600         else if(reg_maps->shader_version.major < 2 && i == 0) continue;
2601
2602         if(reg_maps->temporary[i]) {
2603             sprintf(srgbtmp[found], "R%u", i);
2604             found++;
2605             if(found == 4) break;
2606         }
2607     }
2608
2609     switch(found) {
2610         case 4: dcl_tmp = FALSE; break;
2611         case 0:
2612             sprintf(srgbtmp[0], "TA");
2613             sprintf(srgbtmp[1], "TB");
2614             sprintf(srgbtmp[2], "TC");
2615             sprintf(srgbtmp[3], "TD");
2616             dcl_td = TRUE;
2617             break;
2618         case 1:
2619             sprintf(srgbtmp[1], "TA");
2620             sprintf(srgbtmp[2], "TB");
2621             sprintf(srgbtmp[3], "TC");
2622             break;
2623         case 2:
2624             sprintf(srgbtmp[2], "TA");
2625             sprintf(srgbtmp[3], "TB");
2626             break;
2627         case 3:
2628             sprintf(srgbtmp[3], "TA");
2629             break;
2630     }
2631
2632     /*  Create the hw ARB shader */
2633     memset(&priv_ctx, 0, sizeof(priv_ctx));
2634     priv_ctx.cur_ps_args = args;
2635     priv_ctx.compiled_fprog = compiled;
2636     list_init(&priv_ctx.control_frames);
2637
2638     /* Avoid enabling NV_fragment_program* if we do not need it.
2639      *
2640      * Enabling GL_NV_fragment_program_option causes the driver to occupy a temporary register,
2641      * and it slows down the shader execution noticeably(about 5%). Usually our instruction emulation
2642      * is faster than what we gain from using higher native instructions. There are some things though
2643      * that cannot be emulated. In that case enable the extensions.
2644      * If the extension is enabled, instruction handlers that support both ways will use it.
2645      *
2646      * Testing shows no performance difference between OPTION NV_fragment_program2 and NV_fragment_program.
2647      * So enable the best we can get.
2648      */
2649     if(reg_maps->usesdsx || reg_maps->usesdsy || reg_maps->loop_depth > 0 || reg_maps->usestexldd ||
2650        reg_maps->usestexldl || reg_maps->usesfacing)
2651     {
2652         want_nv_prog = TRUE;
2653     }
2654
2655     shader_addline(buffer, "!!ARBfp1.0\n");
2656     if(want_nv_prog && GL_SUPPORT(NV_FRAGMENT_PROGRAM2)) {
2657         shader_addline(buffer, "OPTION NV_fragment_program2;\n");
2658         priv_ctx.target_version = NV3;
2659     } else if(want_nv_prog && GL_SUPPORT(NV_FRAGMENT_PROGRAM_OPTION)) {
2660         shader_addline(buffer, "OPTION NV_fragment_program;\n");
2661         priv_ctx.target_version = NV2;
2662     } else {
2663         if(want_nv_prog)
2664         {
2665             /* This is an error - either we're advertising the wrong shader version, or aren't enforcing some
2666              * limits properly
2667              */
2668             ERR("The shader requires instructions that are not available in plain GL_ARB_fragment_program\n");
2669             ERR("Try GLSL\n");
2670         }
2671         priv_ctx.target_version = ARB;
2672     }
2673
2674     if (reg_maps->shader_version.major < 3)
2675     {
2676         switch(args->super.fog) {
2677             case FOG_OFF:
2678                 break;
2679             case FOG_LINEAR:
2680                 shader_addline(buffer, "OPTION ARB_fog_linear;\n");
2681                 break;
2682             case FOG_EXP:
2683                 shader_addline(buffer, "OPTION ARB_fog_exp;\n");
2684                 break;
2685             case FOG_EXP2:
2686                 shader_addline(buffer, "OPTION ARB_fog_exp2;\n");
2687                 break;
2688         }
2689     }
2690
2691     /* For now always declare the temps. At least the Nvidia assembler optimizes completely
2692      * unused temps away(but occupies them for the whole shader if they're used once). Always
2693      * declaring them avoids tricky bookkeeping work
2694      */
2695     shader_addline(buffer, "TEMP TA;\n");      /* Used for modifiers */
2696     shader_addline(buffer, "TEMP TB;\n");      /* Used for modifiers */
2697     shader_addline(buffer, "TEMP TC;\n");      /* Used for modifiers */
2698     if(dcl_td) shader_addline(buffer, "TEMP TD;\n"); /* Used for sRGB writing */
2699     shader_addline(buffer, "PARAM coefdiv = { 0.5, 0.25, 0.125, 0.0625 };\n");
2700     shader_addline(buffer, "PARAM coefmul = { 2, 4, 8, 16 };\n");
2701     shader_addline(buffer, "PARAM one = { 1.0, 1.0, 1.0, 1.0 };\n");
2702
2703     if (reg_maps->shader_version.major < 2)
2704     {
2705         strcpy(fragcolor, "R0");
2706     } else {
2707         if(args->super.srgb_correction) {
2708             if(This->color0_mov) {
2709                 sprintf(fragcolor, "R%u", This->color0_reg);
2710             } else {
2711                 shader_addline(buffer, "TEMP TMP_COLOR;\n");
2712                 strcpy(fragcolor, "TMP_COLOR");
2713             }
2714         } else {
2715             strcpy(fragcolor, "result.color");
2716         }
2717     }
2718
2719     if(args->super.srgb_correction) {
2720         shader_addline(buffer, "PARAM srgb_consts1 = {%f, %f, %f, %f};\n",
2721                        srgb_mul_low, srgb_cmp, srgb_pow, srgb_mul_high);
2722         shader_addline(buffer, "PARAM srgb_consts2 = {%f, %f, %f, %f};\n",
2723                        srgb_sub_high, 0.0, 0.0, 0.0);
2724     }
2725
2726     /* Base Declarations */
2727     next_local = shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION, lconst_map);
2728
2729     for(i = 0; i < (sizeof(reg_maps->bumpmat) / sizeof(reg_maps->bumpmat[0])); i++) {
2730         if(!reg_maps->bumpmat[i]) continue;
2731
2732         cur = compiled->numbumpenvmatconsts;
2733         compiled->bumpenvmatconst[cur].const_num = WINED3D_CONST_NUM_UNUSED;
2734         compiled->bumpenvmatconst[cur].texunit = i;
2735         compiled->luminanceconst[cur].const_num = WINED3D_CONST_NUM_UNUSED;
2736         compiled->luminanceconst[cur].texunit = i;
2737
2738         /* We can fit the constants into the constant limit for sure because texbem, texbeml, bem and beml are only supported
2739          * in 1.x shaders, and GL_ARB_fragment_program has a constant limit of 24 constants. So in the worst case we're loading
2740          * 8 shader constants, 8 bump matrices and 8 luminance parameters and are perfectly fine. (No NP2 fixup on bumpmapped
2741          * textures due to conditional NP2 restrictions)
2742          *
2743          * Use local constants to load the bump env parameters, not program.env. This avoids collisions with d3d constants of
2744          * shaders in newer shader models. Since the bump env parameters have to share their space with NP2 fixup constants,
2745          * their location is shader dependent anyway and they cannot be loaded globally.
2746          */
2747         compiled->bumpenvmatconst[cur].const_num = next_local++;
2748         shader_addline(buffer, "PARAM bumpenvmat%d = program.local[%d];\n",
2749                        i, compiled->bumpenvmatconst[cur].const_num);
2750         compiled->numbumpenvmatconsts = cur + 1;
2751
2752         if(!reg_maps->luminanceparams[i]) continue;
2753
2754         compiled->luminanceconst[cur].const_num = next_local++;
2755         shader_addline(buffer, "PARAM luminance%d = program.local[%d];\n",
2756                        i, compiled->luminanceconst[cur].const_num);
2757     }
2758
2759     for(i = 0; i < MAX_CONST_I; i++)
2760     {
2761         compiled->int_consts[i] = WINED3D_CONST_NUM_UNUSED;
2762         if (reg_maps->integer_constants & (1 << i) && priv_ctx.target_version >= NV2)
2763         {
2764             const DWORD *control_values = find_loop_control_values((IWineD3DBaseShaderImpl *) This, i);
2765
2766             if(control_values)
2767             {
2768                 shader_addline(buffer, "PARAM I%u = {%u, %u, %u, -1};\n", i,
2769                                 control_values[0], control_values[1], control_values[2]);
2770             }
2771             else
2772             {
2773                 compiled->int_consts[i] = next_local;
2774                 compiled->num_int_consts++;
2775                 shader_addline(buffer, "PARAM I%u = program.local[%u];\n", i, next_local++);
2776             }
2777         }
2778     }
2779
2780     if(reg_maps->vpos || reg_maps->usesdsy)
2781     {
2782         compiled->ycorrection = next_local;
2783         shader_addline(buffer, "PARAM ycorrection = program.local[%u];\n", next_local++);
2784
2785         if(reg_maps->vpos)
2786         {
2787             shader_addline(buffer, "TEMP vpos;\n");
2788             /* ycorrection.x: Backbuffer height(onscreen) or 0(offscreen).
2789              * ycorrection.y: -1.0(onscreen), 1.0(offscreen)
2790              * ycorrection.z: 1.0
2791              * ycorrection.w: 0.0
2792              */
2793             shader_addline(buffer, "MAD vpos, fragment.position, ycorrection.zyww, ycorrection.wxww;\n");
2794             shader_addline(buffer, "FLR vpos.xy, vpos;\n");
2795         }
2796     }
2797     else
2798     {
2799         compiled->ycorrection = WINED3D_CONST_NUM_UNUSED;
2800     }
2801
2802     /* Base Shader Body */
2803     shader_generate_main((IWineD3DBaseShader *)This, buffer, reg_maps, function, &priv_ctx);
2804
2805     if(args->super.srgb_correction) {
2806         arbfp_add_sRGB_correction(buffer, fragcolor, srgbtmp[0], srgbtmp[1], srgbtmp[2], srgbtmp[3],
2807                                   priv_ctx.target_version >= NV2);
2808     } else if(reg_maps->shader_version.major < 2) {
2809         shader_addline(buffer, "MOV result.color, %s;\n", fragcolor);
2810     }
2811     shader_addline(buffer, "END\n");
2812
2813     /* TODO: change to resource.glObjectHandle or something like that */
2814     GL_EXTCALL(glGenProgramsARB(1, &retval));
2815
2816     TRACE("Creating a hw pixel shader, prg=%d\n", retval);
2817     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, retval));
2818
2819     TRACE("Created hw pixel shader, prg=%d\n", retval);
2820     /* Create the program and check for errors */
2821     GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
2822                buffer->bsize, buffer->buffer));
2823
2824     if (glGetError() == GL_INVALID_OPERATION) {
2825         GLint errPos;
2826         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
2827         FIXME("HW PixelShader Error at position %d: %s\n",
2828               errPos, debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
2829         retval = 0;
2830     }
2831
2832     /* Load immediate constants */
2833     if(lconst_map) {
2834         LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
2835             const float *value = (const float *)lconst->value;
2836             GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, lconst_map[lconst->idx], value));
2837             checkGLcall("glProgramLocalParameter4fvARB");
2838         }
2839         HeapFree(GetProcessHeap(), 0, lconst_map);
2840     }
2841
2842     return retval;
2843 }
2844
2845 /* GL locking is done by the caller */
2846 static GLuint shader_arb_generate_vshader(IWineD3DVertexShaderImpl *This,
2847         SHADER_BUFFER *buffer, const struct arb_vs_compile_args *args, struct arb_vs_compiled_shader *compiled)
2848 {
2849     const shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
2850     CONST DWORD *function = This->baseShader.function;
2851     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)This->baseShader.device;
2852     const WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
2853     const local_constant *lconst;
2854     GLuint ret;
2855     DWORD *lconst_map = local_const_mapping((IWineD3DBaseShaderImpl *) This), next_local;
2856     struct shader_arb_ctx_priv priv_ctx;
2857     unsigned int i;
2858
2859     memset(&priv_ctx, 0, sizeof(priv_ctx));
2860     priv_ctx.cur_vs_args = args;
2861     list_init(&priv_ctx.control_frames);
2862
2863     /*  Create the hw ARB shader */
2864     shader_addline(buffer, "!!ARBvp1.0\n");
2865
2866     /* Always enable the NV extension if available. Unlike fragment shaders, there is no
2867      * mesurable performance penalty, and we can always make use of it for clipplanes.
2868      */
2869     if(GL_SUPPORT(NV_VERTEX_PROGRAM3)) {
2870         shader_addline(buffer, "OPTION NV_vertex_program3;\n");
2871         priv_ctx.target_version = NV3;
2872         shader_addline(buffer, "ADDRESS aL;\n");
2873     } else if(GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION)) {
2874         shader_addline(buffer, "OPTION NV_vertex_program2;\n");
2875         priv_ctx.target_version = NV2;
2876         shader_addline(buffer, "ADDRESS aL;\n");
2877     } else {
2878         priv_ctx.target_version = ARB;
2879     }
2880
2881     shader_addline(buffer, "TEMP TMP_OUT;\n");
2882     if(need_helper_const(gl_info)) {
2883         shader_addline(buffer, "PARAM helper_const = { 2.0, -1.0, %d.0, 0.0 };\n", This->rel_offset);
2884     }
2885     if(need_mova_const((IWineD3DBaseShader *) This, gl_info)) {
2886         shader_addline(buffer, "PARAM mova_const = { 0.5, 0.0, 2.0, 1.0 };\n");
2887         shader_addline(buffer, "TEMP A0_SHADOW;\n");
2888     }
2889
2890     shader_addline(buffer, "TEMP TA;\n");
2891
2892     /* Base Declarations */
2893     next_local = shader_generate_arb_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION, lconst_map);
2894
2895     for(i = 0; i < MAX_CONST_I; i++)
2896     {
2897         compiled->int_consts[i] = WINED3D_CONST_NUM_UNUSED;
2898         if(reg_maps->integer_constants & (1 << i) && priv_ctx.target_version >= NV2)
2899         {
2900             const DWORD *control_values = find_loop_control_values((IWineD3DBaseShaderImpl *) This, i);
2901
2902             if(control_values)
2903             {
2904                 shader_addline(buffer, "PARAM I%u = {%u, %u, %u, -1};\n", i,
2905                                 control_values[0], control_values[1], control_values[2]);
2906             }
2907             else
2908             {
2909                 compiled->int_consts[i] = next_local;
2910                 compiled->num_int_consts++;
2911                 shader_addline(buffer, "PARAM I%u = program.local[%u];\n", i, next_local++);
2912             }
2913         }
2914     }
2915
2916     /* We need a constant to fixup the final position */
2917     shader_addline(buffer, "PARAM posFixup = program.env[%d];\n", ARB_SHADER_PRIVCONST_POS);
2918
2919     /* Initialize output parameters. GL_ARB_vertex_program does not require special initialization values
2920      * for output parameters. D3D in theory does not do that either, but some applications depend on a
2921      * proper initialization of the secondary color, and programs using the fixed function pipeline without
2922      * a replacement shader depend on the texcoord.w being set properly.
2923      *
2924      * GL_NV_vertex_program defines that all output values are initialized to {0.0, 0.0, 0.0, 1.0}. This
2925      * assertion is in effect even when using GL_ARB_vertex_program without any NV specific additions. So
2926      * skip this if NV_vertex_program is supported. Otherwise, initialize the secondary color. For the tex-
2927      * coords, we have a flag in the opengl caps. Many cards do not require the texcoord being set, and
2928      * this can eat a number of instructions, so skip it unless this cap is set as well
2929      */
2930     if(!GL_SUPPORT(NV_VERTEX_PROGRAM)) {
2931         shader_addline(buffer, "MOV result.color.secondary, -helper_const.wwwy;\n");
2932
2933         if((GLINFO_LOCATION).set_texcoord_w && !device->frag_pipe->ffp_proj_control) {
2934             int i;
2935             for(i = 0; i < min(8, MAX_REG_TEXCRD); i++) {
2936                 if(This->baseShader.reg_maps.texcoord_mask[i] != 0 &&
2937                 This->baseShader.reg_maps.texcoord_mask[i] != WINED3DSP_WRITEMASK_ALL) {
2938                     shader_addline(buffer, "MOV result.texcoord[%u].w, -helper_const.y;\n", i);
2939                 }
2940             }
2941         }
2942     }
2943
2944     /* Base Shader Body */
2945     shader_generate_main((IWineD3DBaseShader *)This, buffer, reg_maps, function, &priv_ctx);
2946
2947     /* The D3DRS_FOGTABLEMODE render state defines if the shader-generated fog coord is used
2948      * or if the fragment depth is used. If the fragment depth is used(FOGTABLEMODE != NONE),
2949      * the fog frag coord is thrown away. If the fog frag coord is used, but not written by
2950      * the shader, it is set to 0.0(fully fogged, since start = 1.0, end = 0.0)
2951      */
2952     if(args->super.fog_src == VS_FOG_Z) {
2953         shader_addline(buffer, "MOV result.fogcoord, TMP_OUT.z;\n");
2954     } else if (!reg_maps->fog) {
2955         /* posFixup.x is always 1.0, so we can savely use it */
2956         shader_addline(buffer, "ADD result.fogcoord, posFixup.x, -posFixup.x;\n");
2957     }
2958
2959     /* Write the final position.
2960      *
2961      * OpenGL coordinates specify the center of the pixel while d3d coords specify
2962      * the corner. The offsets are stored in z and w in posFixup. posFixup.y contains
2963      * 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
2964      * contains 1.0 to allow a mad, but arb vs swizzles are too restricted for that.
2965      */
2966     shader_addline(buffer, "MUL TA, posFixup, TMP_OUT.w;\n");
2967     shader_addline(buffer, "ADD TMP_OUT.x, TMP_OUT.x, TA.z;\n");
2968     shader_addline(buffer, "MAD TMP_OUT.y, TMP_OUT.y, posFixup.y, TA.w;\n");
2969
2970     if(priv_ctx.target_version >= NV2)
2971     {
2972         for(i = 0; i < GL_LIMITS(clipplanes); i++)
2973         {
2974             shader_addline(buffer, "DP4 result.clip[%u].x, TMP_OUT, state.clip[%u].plane;\n", i, i);
2975         }
2976     }
2977
2978     /* Z coord [0;1]->[-1;1] mapping, see comment in transform_projection in state.c
2979      * and the glsl equivalent
2980      */
2981     if(need_helper_const(gl_info)) {
2982         shader_addline(buffer, "MAD TMP_OUT.z, TMP_OUT.z, helper_const.x, -TMP_OUT.w;\n");
2983     } else {
2984         shader_addline(buffer, "ADD TMP_OUT.z, TMP_OUT.z, TMP_OUT.z;\n");
2985         shader_addline(buffer, "ADD TMP_OUT.z, TMP_OUT.z, -TMP_OUT.w;\n");
2986     }
2987
2988     shader_addline(buffer, "MOV result.position, TMP_OUT;\n");
2989
2990     shader_addline(buffer, "END\n");
2991
2992     /* TODO: change to resource.glObjectHandle or something like that */
2993     GL_EXTCALL(glGenProgramsARB(1, &ret));
2994
2995     TRACE("Creating a hw vertex shader, prg=%d\n", ret);
2996     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, ret));
2997
2998     TRACE("Created hw vertex shader, prg=%d\n", ret);
2999     /* Create the program and check for errors */
3000     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
3001                buffer->bsize, buffer->buffer));
3002
3003     if (glGetError() == GL_INVALID_OPERATION) {
3004         GLint errPos;
3005         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
3006         FIXME("HW VertexShader Error at position %d: %s\n",
3007               errPos, debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
3008         ret = -1;
3009     } else {
3010         /* Load immediate constants */
3011         if(lconst_map) {
3012             LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
3013                 const float *value = (const float *)lconst->value;
3014                 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, lconst_map[lconst->idx], value));
3015             }
3016         }
3017     }
3018     HeapFree(GetProcessHeap(), 0, lconst_map);
3019
3020     return ret;
3021 }
3022
3023 /* GL locking is done by the caller */
3024 static struct arb_ps_compiled_shader *find_arb_pshader(IWineD3DPixelShaderImpl *shader, const struct arb_ps_compile_args *args)
3025 {
3026     UINT i;
3027     DWORD new_size;
3028     struct arb_ps_compiled_shader *new_array;
3029     SHADER_BUFFER buffer;
3030     struct arb_pshader_private *shader_data;
3031     GLuint ret;
3032
3033     if(!shader->backend_priv) {
3034         shader->backend_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
3035     }
3036     shader_data = shader->backend_priv;
3037
3038     /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
3039      * so a linear search is more performant than a hashmap or a binary search
3040      * (cache coherency etc)
3041      */
3042     for(i = 0; i < shader_data->num_gl_shaders; i++) {
3043         if(memcmp(&shader_data->gl_shaders[i].args, args, sizeof(*args)) == 0) {
3044             return &shader_data->gl_shaders[i];
3045         }
3046     }
3047
3048     TRACE("No matching GL shader found, compiling a new shader\n");
3049     if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
3050         if (shader_data->num_gl_shaders)
3051         {
3052             new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
3053             new_array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, shader_data->gl_shaders,
3054                                     new_size * sizeof(*shader_data->gl_shaders));
3055         } else {
3056             new_array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data->gl_shaders));
3057             new_size = 1;
3058         }
3059
3060         if(!new_array) {
3061             ERR("Out of memory\n");
3062             return 0;
3063         }
3064         shader_data->gl_shaders = new_array;
3065         shader_data->shader_array_size = new_size;
3066     }
3067
3068     shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
3069
3070     pixelshader_update_samplers(&shader->baseShader.reg_maps,
3071             ((IWineD3DDeviceImpl *)shader->baseShader.device)->stateBlock->textures);
3072
3073     shader_buffer_init(&buffer);
3074     ret = shader_arb_generate_pshader(shader, &buffer, args,
3075                                       &shader_data->gl_shaders[shader_data->num_gl_shaders]);
3076     shader_buffer_free(&buffer);
3077     shader_data->gl_shaders[shader_data->num_gl_shaders].prgId = ret;
3078
3079     return &shader_data->gl_shaders[shader_data->num_gl_shaders++];
3080 }
3081
3082 static inline BOOL vs_args_equal(const struct arb_vs_compile_args *stored, const struct arb_vs_compile_args *new,
3083                                  const DWORD use_map, BOOL skip_int) {
3084     if((stored->super.swizzle_map & use_map) != new->super.swizzle_map) return FALSE;
3085     if(stored->super.fog_src != new->super.fog_src) return FALSE;
3086     if(stored->bools != new->bools) return FALSE;
3087     if(skip_int) return TRUE;
3088
3089     return memcmp(stored->loop_ctrl, new->loop_ctrl, sizeof(stored->loop_ctrl)) == 0;
3090 }
3091
3092 static struct arb_vs_compiled_shader *find_arb_vshader(IWineD3DVertexShaderImpl *shader, const struct arb_vs_compile_args *args)
3093 {
3094     UINT i;
3095     DWORD new_size;
3096     struct arb_vs_compiled_shader *new_array;
3097     DWORD use_map = ((IWineD3DDeviceImpl *)shader->baseShader.device)->strided_streams.use_map;
3098     SHADER_BUFFER buffer;
3099     struct arb_vshader_private *shader_data;
3100     GLuint ret;
3101     const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)shader->baseShader.device)->adapter->gl_info;
3102
3103     if(!shader->backend_priv) {
3104         shader->backend_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
3105     }
3106     shader_data = shader->backend_priv;
3107
3108     /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
3109      * so a linear search is more performant than a hashmap or a binary search
3110      * (cache coherency etc)
3111      */
3112     for(i = 0; i < shader_data->num_gl_shaders; i++) {
3113         if(vs_args_equal(&shader_data->gl_shaders[i].args, args, use_map, GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION))) {
3114             return &shader_data->gl_shaders[i];
3115         }
3116     }
3117
3118     TRACE("No matching GL shader found, compiling a new shader\n");
3119
3120     if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
3121         if (shader_data->num_gl_shaders)
3122         {
3123             new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
3124             new_array = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, shader_data->gl_shaders,
3125                                     new_size * sizeof(*shader_data->gl_shaders));
3126         } else {
3127             new_array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data->gl_shaders));
3128             new_size = 1;
3129         }
3130
3131         if(!new_array) {
3132             ERR("Out of memory\n");
3133             return 0;
3134         }
3135         shader_data->gl_shaders = new_array;
3136         shader_data->shader_array_size = new_size;
3137     }
3138
3139     shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
3140
3141     shader_buffer_init(&buffer);
3142     ret = shader_arb_generate_vshader(shader, &buffer, args,
3143             &shader_data->gl_shaders[shader_data->num_gl_shaders]);
3144     shader_buffer_free(&buffer);
3145     shader_data->gl_shaders[shader_data->num_gl_shaders].prgId = ret;
3146
3147     return &shader_data->gl_shaders[shader_data->num_gl_shaders++];
3148 }
3149
3150 static inline void find_arb_ps_compile_args(IWineD3DPixelShaderImpl *shader, IWineD3DStateBlockImpl *stateblock,
3151         struct arb_ps_compile_args *args)
3152 {
3153     int i;
3154     WORD int_skip;
3155     const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)shader->baseShader.device)->adapter->gl_info;
3156     find_ps_compile_args(shader, stateblock, &args->super);
3157
3158     /* This forces all local boolean constants to 1 to make them stateblock independent */
3159     args->bools = shader->baseShader.reg_maps.local_bool_consts;
3160
3161     for(i = 0; i < MAX_CONST_B; i++)
3162     {
3163         if(stateblock->pixelShaderConstantB[i]) args->bools |= ( 1 << i);
3164     }
3165
3166     /* Skip if unused or local, or supported natively */
3167     int_skip = ~shader->baseShader.reg_maps.integer_constants | shader->baseShader.reg_maps.local_int_consts;
3168     if(int_skip == 0xffff || GL_SUPPORT(NV_FRAGMENT_PROGRAM_OPTION))
3169     {
3170         memset(&args->loop_ctrl, 0, sizeof(args->loop_ctrl));
3171         return;
3172     }
3173
3174     for(i = 0; i < MAX_CONST_I; i++)
3175     {
3176         if(int_skip & (1 << i))
3177         {
3178             args->loop_ctrl[i][0] = 0;
3179             args->loop_ctrl[i][1] = 0;
3180             args->loop_ctrl[i][2] = 0;
3181         }
3182         else
3183         {
3184             args->loop_ctrl[i][0] = stateblock->pixelShaderConstantI[i * 4];
3185             args->loop_ctrl[i][1] = stateblock->pixelShaderConstantI[i * 4 + 1];
3186             args->loop_ctrl[i][2] = stateblock->pixelShaderConstantI[i * 4 + 2];
3187         }
3188     }
3189 }
3190
3191 static inline void find_arb_vs_compile_args(IWineD3DVertexShaderImpl *shader, IWineD3DStateBlockImpl *stateblock,
3192         struct arb_vs_compile_args *args)
3193 {
3194     int i;
3195     WORD int_skip;
3196     const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)shader->baseShader.device)->adapter->gl_info;
3197     find_vs_compile_args(shader, stateblock, &args->super);
3198
3199     /* This forces all local boolean constants to 1 to make them stateblock independent */
3200     args->bools = shader->baseShader.reg_maps.local_bool_consts;
3201
3202     /* TODO: Figure out if it would be better to store bool constants as bitmasks in the stateblock */
3203     for(i = 0; i < MAX_CONST_B; i++)
3204     {
3205         if(stateblock->vertexShaderConstantB[i]) args->bools |= ( 1 << i);
3206     }
3207
3208     /* Skip if unused or local */
3209     int_skip = ~shader->baseShader.reg_maps.integer_constants | shader->baseShader.reg_maps.local_int_consts;
3210     if(int_skip == 0xffff || GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION))
3211     {
3212         memset(&args->loop_ctrl, 0, sizeof(args->loop_ctrl));
3213         return;
3214     }
3215
3216     for(i = 0; i < MAX_CONST_I; i++)
3217     {
3218         if(int_skip & (1 << i))
3219         {
3220             args->loop_ctrl[i][0] = 0;
3221             args->loop_ctrl[i][1] = 0;
3222             args->loop_ctrl[i][2] = 0;
3223         }
3224         else
3225         {
3226             args->loop_ctrl[i][0] = stateblock->vertexShaderConstantI[i * 4];
3227             args->loop_ctrl[i][1] = stateblock->vertexShaderConstantI[i * 4 + 1];
3228             args->loop_ctrl[i][2] = stateblock->vertexShaderConstantI[i * 4 + 2];
3229         }
3230     }
3231 }
3232
3233 /* GL locking is done by the caller */
3234 static void shader_arb_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {
3235     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3236     struct shader_arb_priv *priv = This->shader_priv;
3237     const WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3238
3239     if (useVS) {
3240         struct arb_vs_compile_args compile_args;
3241         struct arb_vs_compiled_shader *compiled;
3242
3243         TRACE("Using vertex shader %p\n", This->stateBlock->vertexShader);
3244         find_arb_vs_compile_args((IWineD3DVertexShaderImpl *) This->stateBlock->vertexShader, This->stateBlock, &compile_args);
3245         compiled = find_arb_vshader((IWineD3DVertexShaderImpl *) This->stateBlock->vertexShader, &compile_args);
3246         priv->current_vprogram_id = compiled->prgId;
3247         priv->compiled_vprog = compiled;
3248
3249         /* Bind the vertex program */
3250         GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, priv->current_vprogram_id));
3251         checkGLcall("glBindProgramARB(GL_VERTEX_PROGRAM_ARB, priv->current_vprogram_id);");
3252
3253         /* Enable OpenGL vertex programs */
3254         glEnable(GL_VERTEX_PROGRAM_ARB);
3255         checkGLcall("glEnable(GL_VERTEX_PROGRAM_ARB);");
3256         TRACE("(%p) : Bound vertex program %u and enabled GL_VERTEX_PROGRAM_ARB\n", This, priv->current_vprogram_id);
3257         shader_arb_vs_local_constants(This);
3258     } else if(GL_SUPPORT(ARB_VERTEX_PROGRAM)) {
3259         priv->current_vprogram_id = 0;
3260         glDisable(GL_VERTEX_PROGRAM_ARB);
3261         checkGLcall("glDisable(GL_VERTEX_PROGRAM_ARB)");
3262     }
3263
3264     if (usePS) {
3265         struct arb_ps_compile_args compile_args;
3266         struct arb_ps_compiled_shader *compiled;
3267         TRACE("Using pixel shader\n");
3268         find_arb_ps_compile_args((IWineD3DPixelShaderImpl *) This->stateBlock->pixelShader, This->stateBlock, &compile_args);
3269         compiled = find_arb_pshader((IWineD3DPixelShaderImpl *) This->stateBlock->pixelShader,
3270                                     &compile_args);
3271         priv->current_fprogram_id = compiled->prgId;
3272         priv->compiled_fprog = compiled;
3273
3274         /* Bind the fragment program */
3275         GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, priv->current_fprogram_id));
3276         checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, priv->current_fprogram_id);");
3277
3278         if(!priv->use_arbfp_fixed_func) {
3279             /* Enable OpenGL fragment programs */
3280             glEnable(GL_FRAGMENT_PROGRAM_ARB);
3281             checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB);");
3282         }
3283         TRACE("(%p) : Bound fragment program %u and enabled GL_FRAGMENT_PROGRAM_ARB\n", This, priv->current_fprogram_id);
3284
3285         shader_arb_ps_local_constants(This);
3286     } else if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM) && !priv->use_arbfp_fixed_func) {
3287         /* Disable only if we're not using arbfp fixed function fragment processing. If this is used,
3288          * keep GL_FRAGMENT_PROGRAM_ARB enabled, and the fixed function pipeline will bind the fixed function
3289          * replacement shader
3290          */
3291         glDisable(GL_FRAGMENT_PROGRAM_ARB);
3292         checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
3293         priv->current_fprogram_id = 0;
3294     }
3295 }
3296
3297 /* GL locking is done by the caller */
3298 static void shader_arb_select_depth_blt(IWineD3DDevice *iface, enum tex_types tex_type) {
3299     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3300     struct shader_arb_priv *priv = This->shader_priv;
3301     GLuint *blt_fprogram = &priv->depth_blt_fprogram_id[tex_type];
3302     const WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3303
3304     if (!priv->depth_blt_vprogram_id) priv->depth_blt_vprogram_id = create_arb_blt_vertex_program(gl_info);
3305     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, priv->depth_blt_vprogram_id));
3306     glEnable(GL_VERTEX_PROGRAM_ARB);
3307
3308     if (!*blt_fprogram) *blt_fprogram = create_arb_blt_fragment_program(gl_info, tex_type);
3309     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, *blt_fprogram));
3310     glEnable(GL_FRAGMENT_PROGRAM_ARB);
3311 }
3312
3313 /* GL locking is done by the caller */
3314 static void shader_arb_deselect_depth_blt(IWineD3DDevice *iface) {
3315     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3316     struct shader_arb_priv *priv = This->shader_priv;
3317     const WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3318
3319     if (priv->current_vprogram_id) {
3320         GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, priv->current_vprogram_id));
3321         checkGLcall("glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertexShader->prgId);");
3322
3323         glEnable(GL_VERTEX_PROGRAM_ARB);
3324         checkGLcall("glEnable(GL_VERTEX_PROGRAM_ARB);");
3325
3326         TRACE("(%p) : Bound vertex program %u and enabled GL_VERTEX_PROGRAM_ARB\n", This, priv->current_vprogram_id);
3327     } else {
3328         glDisable(GL_VERTEX_PROGRAM_ARB);
3329         checkGLcall("glDisable(GL_VERTEX_PROGRAM_ARB)");
3330     }
3331
3332     if (priv->current_fprogram_id) {
3333         GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, priv->current_fprogram_id));
3334         checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, pixelShader->prgId);");
3335
3336         glEnable(GL_FRAGMENT_PROGRAM_ARB);
3337         checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB);");
3338
3339         TRACE("(%p) : Bound fragment program %u and enabled GL_FRAGMENT_PROGRAM_ARB\n", This, priv->current_fprogram_id);
3340     } else {
3341         glDisable(GL_FRAGMENT_PROGRAM_ARB);
3342         checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
3343     }
3344 }
3345
3346 static void shader_arb_destroy(IWineD3DBaseShader *iface) {
3347     IWineD3DBaseShaderImpl *baseShader = (IWineD3DBaseShaderImpl *) iface;
3348     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)baseShader->baseShader.device;
3349     const WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
3350
3351     ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
3352
3353     if (shader_is_pshader_version(baseShader->baseShader.reg_maps.shader_version.type))
3354     {
3355         IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface;
3356         struct arb_pshader_private *shader_data = This->backend_priv;
3357         UINT i;
3358
3359         if(!shader_data) return; /* This can happen if a shader was never compiled */
3360         ENTER_GL();
3361         for(i = 0; i < shader_data->num_gl_shaders; i++) {
3362             GL_EXTCALL(glDeleteProgramsARB(1, &shader_data->gl_shaders[i].prgId));
3363             checkGLcall("GL_EXTCALL(glDeleteProgramsARB(1, &shader_data->gl_shaders[i].prgId))");
3364         }
3365         LEAVE_GL();
3366         HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
3367         HeapFree(GetProcessHeap(), 0, shader_data);
3368         This->backend_priv = NULL;
3369     } else {
3370         IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *) iface;
3371         struct arb_vshader_private *shader_data = This->backend_priv;
3372         UINT i;
3373
3374         if(!shader_data) return; /* This can happen if a shader was never compiled */
3375         ENTER_GL();
3376         for(i = 0; i < shader_data->num_gl_shaders; i++) {
3377             GL_EXTCALL(glDeleteProgramsARB(1, &shader_data->gl_shaders[i].prgId));
3378             checkGLcall("GL_EXTCALL(glDeleteProgramsARB(1, &shader_data->gl_shaders[i].prgId))");
3379         }
3380         LEAVE_GL();
3381         HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
3382         HeapFree(GetProcessHeap(), 0, shader_data);
3383         This->backend_priv = NULL;
3384     }
3385 }
3386
3387 static HRESULT shader_arb_alloc(IWineD3DDevice *iface) {
3388     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3389     This->shader_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct shader_arb_priv));
3390     return WINED3D_OK;
3391 }
3392
3393 static void shader_arb_free(IWineD3DDevice *iface) {
3394     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3395     const WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3396     struct shader_arb_priv *priv = This->shader_priv;
3397     int i;
3398
3399     ENTER_GL();
3400     if(priv->depth_blt_vprogram_id) {
3401         GL_EXTCALL(glDeleteProgramsARB(1, &priv->depth_blt_vprogram_id));
3402     }
3403     for (i = 0; i < tex_type_count; ++i) {
3404         if (priv->depth_blt_fprogram_id[i]) {
3405             GL_EXTCALL(glDeleteProgramsARB(1, &priv->depth_blt_fprogram_id[i]));
3406         }
3407     }
3408     LEAVE_GL();
3409
3410     HeapFree(GetProcessHeap(), 0, This->shader_priv);
3411 }
3412
3413 static BOOL shader_arb_dirty_const(IWineD3DDevice *iface) {
3414     return TRUE;
3415 }
3416
3417 static void shader_arb_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *pCaps)
3418 {
3419     /* We don't have an ARB fixed function pipeline yet, so let the none backend set its caps,
3420      * then overwrite the shader specific ones
3421      */
3422     none_shader_backend.shader_get_caps(devtype, gl_info, pCaps);
3423
3424     if(GL_SUPPORT(ARB_VERTEX_PROGRAM)) {
3425         pCaps->VertexShaderVersion = WINED3DVS_VERSION(1,1);
3426         TRACE_(d3d_caps)("Hardware vertex shader version 1.1 enabled (ARB_PROGRAM)\n");
3427         pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF) - 1;
3428     }
3429
3430     if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
3431         pCaps->PixelShaderVersion    = WINED3DPS_VERSION(1,4);
3432         pCaps->PixelShader1xMaxValue = 8.0;
3433         TRACE_(d3d_caps)("Hardware pixel shader version 1.4 enabled (ARB_PROGRAM)\n");
3434         pCaps->MaxPixelShaderConst = GL_LIMITS(pshader_constantsF);
3435     }
3436
3437     pCaps->VSClipping = GL_SUPPORT(NV_VERTEX_PROGRAM2_OPTION);
3438 }
3439
3440 static BOOL shader_arb_color_fixup_supported(struct color_fixup_desc fixup)
3441 {
3442     if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
3443     {
3444         TRACE("Checking support for color_fixup:\n");
3445         dump_color_fixup_desc(fixup);
3446     }
3447
3448     /* We support everything except YUV conversions. */
3449     if (!is_yuv_fixup(fixup))
3450     {
3451         TRACE("[OK]\n");
3452         return TRUE;
3453     }
3454
3455     TRACE("[FAILED]\n");
3456     return FALSE;
3457 }
3458
3459 static void shader_arb_add_instruction_modifiers(const struct wined3d_shader_instruction *ins) {
3460     DWORD shift;
3461     char write_mask[20], regstr[50];
3462     SHADER_BUFFER *buffer = ins->ctx->buffer;
3463     BOOL is_color = FALSE;
3464     const struct wined3d_shader_dst_param *dst;
3465
3466     if (!ins->dst_count) return;
3467
3468     dst = &ins->dst[0];
3469     shift = dst->shift;
3470     if(shift == 0) return; /* Saturate alone is handled by the instructions */
3471
3472     shader_arb_get_write_mask(ins, dst, write_mask);
3473     shader_arb_get_register_name(ins, &dst->reg, regstr, &is_color);
3474
3475     /* Generate a line that does the output modifier computation
3476      * FIXME: _SAT vs shift? _SAT alone is already handled in the instructions, if this
3477      * maps problems in e.g. _d4_sat modify shader_arb_get_modifier
3478      */
3479     shader_addline(buffer, "MUL%s %s%s, %s, %s;\n", shader_arb_get_modifier(ins),
3480                    regstr, write_mask, regstr, shift_tab[shift]);
3481 }
3482
3483 static const SHADER_HANDLER shader_arb_instruction_handler_table[WINED3DSIH_TABLE_SIZE] =
3484 {
3485     /* WINED3DSIH_ABS           */ shader_hw_map2gl,
3486     /* WINED3DSIH_ADD           */ shader_hw_map2gl,
3487     /* WINED3DSIH_BEM           */ pshader_hw_bem,
3488     /* WINED3DSIH_BREAK         */ shader_hw_break,
3489     /* WINED3DSIH_BREAKC        */ shader_hw_breakc,
3490     /* WINED3DSIH_BREAKP        */ NULL,
3491     /* WINED3DSIH_CALL          */ NULL,
3492     /* WINED3DSIH_CALLNZ        */ NULL,
3493     /* WINED3DSIH_CMP           */ pshader_hw_cmp,
3494     /* WINED3DSIH_CND           */ pshader_hw_cnd,
3495     /* WINED3DSIH_CRS           */ shader_hw_map2gl,
3496     /* WINED3DSIH_DCL           */ NULL,
3497     /* WINED3DSIH_DEF           */ NULL,
3498     /* WINED3DSIH_DEFB          */ NULL,
3499     /* WINED3DSIH_DEFI          */ NULL,
3500     /* WINED3DSIH_DP2ADD        */ pshader_hw_dp2add,
3501     /* WINED3DSIH_DP3           */ shader_hw_map2gl,
3502     /* WINED3DSIH_DP4           */ shader_hw_map2gl,
3503     /* WINED3DSIH_DST           */ shader_hw_map2gl,
3504     /* WINED3DSIH_DSX           */ shader_hw_map2gl,
3505     /* WINED3DSIH_DSY           */ shader_hw_dsy,
3506     /* WINED3DSIH_ELSE          */ shader_hw_else,
3507     /* WINED3DSIH_ENDIF         */ shader_hw_endif,
3508     /* WINED3DSIH_ENDLOOP       */ shader_hw_endloop,
3509     /* WINED3DSIH_ENDREP        */ shader_hw_endrep,
3510     /* WINED3DSIH_EXP           */ shader_hw_map2gl,
3511     /* WINED3DSIH_EXPP          */ shader_hw_map2gl,
3512     /* WINED3DSIH_FRC           */ shader_hw_map2gl,
3513     /* WINED3DSIH_IF            */ NULL /* Hardcoded into the shader */,
3514     /* WINED3DSIH_IFC           */ shader_hw_ifc,
3515     /* WINED3DSIH_LABEL         */ NULL,
3516     /* WINED3DSIH_LIT           */ shader_hw_map2gl,
3517     /* WINED3DSIH_LOG           */ shader_hw_map2gl,
3518     /* WINED3DSIH_LOGP          */ shader_hw_map2gl,
3519     /* WINED3DSIH_LOOP          */ shader_hw_loop,
3520     /* WINED3DSIH_LRP           */ shader_hw_lrp,
3521     /* WINED3DSIH_M3x2          */ shader_hw_mnxn,
3522     /* WINED3DSIH_M3x3          */ shader_hw_mnxn,
3523     /* WINED3DSIH_M3x4          */ shader_hw_mnxn,
3524     /* WINED3DSIH_M4x3          */ shader_hw_mnxn,
3525     /* WINED3DSIH_M4x4          */ shader_hw_mnxn,
3526     /* WINED3DSIH_MAD           */ shader_hw_map2gl,
3527     /* WINED3DSIH_MAX           */ shader_hw_map2gl,
3528     /* WINED3DSIH_MIN           */ shader_hw_map2gl,
3529     /* WINED3DSIH_MOV           */ shader_hw_mov,
3530     /* WINED3DSIH_MOVA          */ shader_hw_mov,
3531     /* WINED3DSIH_MUL           */ shader_hw_map2gl,
3532     /* WINED3DSIH_NOP           */ shader_hw_nop,
3533     /* WINED3DSIH_NRM           */ shader_hw_nrm,
3534     /* WINED3DSIH_PHASE         */ NULL,
3535     /* WINED3DSIH_POW           */ shader_hw_map2gl,
3536     /* WINED3DSIH_RCP           */ shader_hw_rsq_rcp,
3537     /* WINED3DSIH_REP           */ shader_hw_rep,
3538     /* WINED3DSIH_RET           */ NULL,
3539     /* WINED3DSIH_RSQ           */ shader_hw_rsq_rcp,
3540     /* WINED3DSIH_SETP          */ NULL,
3541     /* WINED3DSIH_SGE           */ shader_hw_map2gl,
3542     /* WINED3DSIH_SGN           */ shader_hw_sgn,
3543     /* WINED3DSIH_SINCOS        */ shader_hw_sincos,
3544     /* WINED3DSIH_SLT           */ shader_hw_map2gl,
3545     /* WINED3DSIH_SUB           */ shader_hw_map2gl,
3546     /* WINED3DSIH_TEX           */ pshader_hw_tex,
3547     /* WINED3DSIH_TEXBEM        */ pshader_hw_texbem,
3548     /* WINED3DSIH_TEXBEML       */ pshader_hw_texbem,
3549     /* WINED3DSIH_TEXCOORD      */ pshader_hw_texcoord,
3550     /* WINED3DSIH_TEXDEPTH      */ pshader_hw_texdepth,
3551     /* WINED3DSIH_TEXDP3        */ pshader_hw_texdp3,
3552     /* WINED3DSIH_TEXDP3TEX     */ pshader_hw_texdp3tex,
3553     /* WINED3DSIH_TEXKILL       */ pshader_hw_texkill,
3554     /* WINED3DSIH_TEXLDD        */ shader_hw_texldd,
3555     /* WINED3DSIH_TEXLDL        */ shader_hw_texldl,
3556     /* WINED3DSIH_TEXM3x2DEPTH  */ pshader_hw_texm3x2depth,
3557     /* WINED3DSIH_TEXM3x2PAD    */ pshader_hw_texm3x2pad,
3558     /* WINED3DSIH_TEXM3x2TEX    */ pshader_hw_texm3x2tex,
3559     /* WINED3DSIH_TEXM3x3       */ pshader_hw_texm3x3,
3560     /* WINED3DSIH_TEXM3x3DIFF   */ NULL,
3561     /* WINED3DSIH_TEXM3x3PAD    */ pshader_hw_texm3x3pad,
3562     /* WINED3DSIH_TEXM3x3SPEC   */ pshader_hw_texm3x3spec,
3563     /* WINED3DSIH_TEXM3x3TEX    */ pshader_hw_texm3x3tex,
3564     /* WINED3DSIH_TEXM3x3VSPEC  */ pshader_hw_texm3x3vspec,
3565     /* WINED3DSIH_TEXREG2AR     */ pshader_hw_texreg2ar,
3566     /* WINED3DSIH_TEXREG2GB     */ pshader_hw_texreg2gb,
3567     /* WINED3DSIH_TEXREG2RGB    */ pshader_hw_texreg2rgb,
3568 };
3569
3570 static inline BOOL get_bool_const(const struct wined3d_shader_instruction *ins, IWineD3DBaseShaderImpl *This, DWORD idx)
3571 {
3572     BOOL vshader = shader_is_vshader_version(This->baseShader.reg_maps.shader_version.type);
3573     WORD bools = 0;
3574     WORD flag = (1 << idx);
3575     const local_constant *constant;
3576     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
3577
3578     if(This->baseShader.reg_maps.local_bool_consts & flag)
3579     {
3580         /* What good is a if(bool) with a hardcoded local constant? I don't know, but handle it */
3581         LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsB, local_constant, entry)
3582         {
3583             if (constant->idx == idx)
3584             {
3585                 return constant->value[0];
3586             }
3587         }
3588         ERR("Local constant not found\n");
3589         return FALSE;
3590     }
3591     else
3592     {
3593         if(vshader) bools = priv->cur_vs_args->bools;
3594         else bools = priv->cur_ps_args->bools;
3595         return bools & flag;
3596     }
3597 }
3598
3599 static inline void get_int_const(const struct wined3d_shader_instruction *ins, IWineD3DBaseShaderImpl *This, DWORD idx, int *ret)
3600 {
3601     BOOL vshader = shader_is_vshader_version(This->baseShader.reg_maps.shader_version.type);
3602     WORD flag = (1 << idx);
3603     const local_constant *constant;
3604     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
3605
3606     /* Integer constants can either be a local constant, or they can be stored in the shader
3607      * type specific compile args
3608      */
3609     if(This->baseShader.reg_maps.local_int_consts & flag)
3610     {
3611         LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsI, local_constant, entry)
3612         {
3613             if (constant->idx == idx)
3614             {
3615                 ret[0] = constant->value[0];
3616                 ret[1] = constant->value[1];
3617                 /* Step / stride is signed */
3618                 ret[2] = (int) constant->value[2];
3619                 return;
3620             }
3621         }
3622         /* If this happens the flag was set incorrectly */
3623         ERR("Local constant not found\n");
3624         ret[0] = 0;
3625         ret[1] = 0;
3626         ret[2] = 0;
3627         return;
3628     }
3629     else
3630     {
3631         if(vshader)
3632         {
3633             /* Count and aL start value are unsigned */
3634             ret[0] = priv->cur_vs_args->loop_ctrl[idx][0];
3635             ret[1] = priv->cur_vs_args->loop_ctrl[idx][1];
3636             /* The step/stride is signed */
3637             ret[2] = ((char) priv->cur_vs_args->loop_ctrl[idx][2]);
3638         }
3639         else
3640         {
3641             ret[0] = priv->cur_ps_args->loop_ctrl[idx][0];
3642             ret[1] = priv->cur_ps_args->loop_ctrl[idx][1];
3643             ret[2] = ((char) priv->cur_ps_args->loop_ctrl[idx][2]);
3644         }
3645         return;
3646     }
3647 }
3648
3649 static void record_instruction(struct list *list, const struct wined3d_shader_instruction *ins)
3650 {
3651     unsigned int i;
3652     struct wined3d_shader_dst_param *dst_param = NULL;
3653     struct wined3d_shader_src_param *src_param = NULL, *rel_addr = NULL;
3654     struct recorded_instruction *rec = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rec));
3655     if(!rec)
3656     {
3657         ERR("Out of memory\n");
3658         return;
3659     }
3660
3661     rec->ins = *ins;
3662     dst_param = HeapAlloc(GetProcessHeap(), 0, sizeof(*dst_param));
3663     if(!dst_param) goto free;
3664     *dst_param = *ins->dst;
3665     if(ins->dst->reg.rel_addr)
3666     {
3667         rel_addr = HeapAlloc(GetProcessHeap(), 0, sizeof(*dst_param->reg.rel_addr));
3668         if(!rel_addr) goto free;
3669         *rel_addr = *ins->dst->reg.rel_addr;
3670         dst_param->reg.rel_addr = rel_addr;
3671     }
3672     rec->ins.dst = dst_param;
3673
3674     src_param = HeapAlloc(GetProcessHeap(), 0, sizeof(*src_param) * ins->src_count);
3675     if(!src_param) goto free;
3676     for(i = 0; i < ins->src_count; i++)
3677     {
3678         src_param[i] = ins->src[i];
3679         if(ins->src[i].reg.rel_addr)
3680         {
3681             rel_addr = HeapAlloc(GetProcessHeap(), 0, sizeof(*rel_addr));
3682             if(!rel_addr) goto free;
3683             *rel_addr = *ins->src[i].reg.rel_addr;
3684             src_param[i].reg.rel_addr = rel_addr;
3685         }
3686     }
3687     rec->ins.src = src_param;
3688     list_add_tail(list, &rec->entry);
3689     return;
3690
3691 free:
3692     ERR("Out of memory\n");
3693     if(dst_param)
3694     {
3695         HeapFree(GetProcessHeap(), 0, (void *) dst_param->reg.rel_addr);
3696         HeapFree(GetProcessHeap(), 0, dst_param);
3697     }
3698     if(src_param)
3699     {
3700         for(i = 0; i < ins->src_count; i++)
3701         {
3702             HeapFree(GetProcessHeap(), 0, (void *) src_param[i].reg.rel_addr);
3703         }
3704         HeapFree(GetProcessHeap(), 0, src_param);
3705     }
3706     HeapFree(GetProcessHeap(), 0, rec);
3707 }
3708
3709 static void free_recorded_instruction(struct list *list)
3710 {
3711     struct recorded_instruction *rec_ins, *entry2;
3712     unsigned int i;
3713
3714     LIST_FOR_EACH_ENTRY_SAFE(rec_ins, entry2, list, struct recorded_instruction, entry)
3715     {
3716         list_remove(&rec_ins->entry);
3717         if(rec_ins->ins.dst)
3718         {
3719             HeapFree(GetProcessHeap(), 0, (void *) rec_ins->ins.dst->reg.rel_addr);
3720             HeapFree(GetProcessHeap(), 0, (void *) rec_ins->ins.dst);
3721         }
3722         if(rec_ins->ins.src)
3723         {
3724             for(i = 0; i < rec_ins->ins.src_count; i++)
3725             {
3726                 HeapFree(GetProcessHeap(), 0, (void *) rec_ins->ins.src[i].reg.rel_addr);
3727             }
3728             HeapFree(GetProcessHeap(), 0, (void *) rec_ins->ins.src);
3729         }
3730         HeapFree(GetProcessHeap(), 0, rec_ins);
3731     }
3732 }
3733
3734 static void shader_arb_handle_instruction(const struct wined3d_shader_instruction *ins) {
3735     SHADER_HANDLER hw_fct;
3736     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
3737     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3738     struct control_frame *control_frame;
3739     SHADER_BUFFER *buffer = ins->ctx->buffer;
3740
3741     if(ins->handler_idx == WINED3DSIH_LOOP || ins->handler_idx == WINED3DSIH_REP)
3742     {
3743         control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
3744         list_add_head(&priv->control_frames, &control_frame->entry);
3745
3746         if(ins->handler_idx == WINED3DSIH_LOOP) control_frame->type = LOOP;
3747         if(ins->handler_idx == WINED3DSIH_REP) control_frame->type = REP;
3748
3749         if(priv->target_version >= NV2)
3750         {
3751             control_frame->loop_no = priv->num_loops++;
3752             priv->loop_depth++;
3753         }
3754         else
3755         {
3756             /* Don't bother recording when we're in a not used if branch */
3757             if(priv->muted)
3758             {
3759                 return;
3760             }
3761
3762             if(!priv->recording)
3763             {
3764                 int control_values[3];
3765                 get_int_const(ins, This, ins->src[0].reg.idx, control_values);
3766                 list_init(&priv->record);
3767                 priv->recording = TRUE;
3768                 control_frame->outer_loop = TRUE;
3769                 control_frame->loop_control[0] = control_values[0];
3770                 control_frame->loop_control[1] = control_values[1];
3771                 control_frame->loop_control[2] = control_values[2];
3772                 return; /* Instruction is handled */
3773             }
3774             /* Record this loop in the outer loop's recording */
3775         }
3776     }
3777     else if(ins->handler_idx == WINED3DSIH_ENDLOOP || ins->handler_idx == WINED3DSIH_ENDREP)
3778     {
3779         if(priv->target_version >= NV2)
3780         {
3781             /* Nothing to do. The control frame is popped after the HW instr handler */
3782         }
3783         else
3784         {
3785             struct list *e = list_head(&priv->control_frames);
3786             control_frame = LIST_ENTRY(e, struct control_frame, entry);
3787             list_remove(&control_frame->entry);
3788
3789             if(control_frame->outer_loop)
3790             {
3791                 int iteration, aL = 0;
3792                 struct list copy;
3793
3794                 /* Turn off recording before playback */
3795                 priv->recording = FALSE;
3796
3797                 /* Move the recorded instructions to a separate list and get them out of the private data
3798                  * structure. If there are nested loops, the shader_arb_handle_instruction below will
3799                  * be recorded again, thus priv->record might be overwritten
3800                  */
3801                 list_init(&copy);
3802                 list_move_tail(&copy, &priv->record);
3803                 list_init(&priv->record);
3804
3805                 if(ins->handler_idx == WINED3DSIH_ENDLOOP)
3806                 {
3807                     shader_addline(buffer, "#unrolling loop: %d iterations, aL=%d, inc %d\n",
3808                                    control_frame->loop_control[0], control_frame->loop_control[1],
3809                                    control_frame->loop_control[2]);
3810                     aL = control_frame->loop_control[1];
3811                 }
3812                 else
3813                 {
3814                     shader_addline(buffer, "#unrolling rep: %d iterations\n", control_frame->loop_control[0]);
3815                 }
3816
3817                 for(iteration = 0; iteration < control_frame->loop_control[0]; iteration++)
3818                 {
3819                     struct recorded_instruction *rec_ins;
3820                     if(ins->handler_idx == WINED3DSIH_ENDLOOP)
3821                     {
3822                         priv->aL = aL;
3823                         shader_addline(buffer, "#Iteration %d, aL=%d\n", iteration, aL);
3824                     }
3825                     else
3826                     {
3827                         shader_addline(buffer, "#Iteration %d\n", iteration);
3828                     }
3829
3830                     LIST_FOR_EACH_ENTRY(rec_ins, &copy, struct recorded_instruction, entry)
3831                     {
3832                         shader_arb_handle_instruction(&rec_ins->ins);
3833                     }
3834
3835                     if(ins->handler_idx == WINED3DSIH_ENDLOOP)
3836                     {
3837                         aL += control_frame->loop_control[2];
3838                     }
3839                 }
3840                 shader_addline(buffer, "#end loop/rep\n");
3841
3842                 free_recorded_instruction(&copy);
3843                 HeapFree(GetProcessHeap(), 0, control_frame);
3844                 return; /* Instruction is handled */
3845             }
3846             else
3847             {
3848                 /* This is a nested loop. Proceed to the normal recording function */
3849                 HeapFree(GetProcessHeap(), 0, control_frame);
3850             }
3851         }
3852     }
3853
3854     if(priv->recording)
3855     {
3856         record_instruction(&priv->record, ins);
3857         return;
3858     }
3859
3860     /* boolean if */
3861     if(ins->handler_idx == WINED3DSIH_IF)
3862     {
3863         control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
3864         list_add_head(&priv->control_frames, &control_frame->entry);
3865         control_frame->type = IF;
3866
3867         if(!priv->muted && get_bool_const(ins, This, ins->src[0].reg.idx) == FALSE)
3868         {
3869             shader_addline(buffer, "#if(FALSE){\n");
3870             priv->muted = TRUE;
3871             control_frame->muting = TRUE;
3872         }
3873         else shader_addline(buffer, "#if(TRUE) {\n");
3874
3875         return; /* Instruction is handled */
3876     }
3877     else if(ins->handler_idx == WINED3DSIH_IFC)
3878     {
3879         /* IF(bool) and if_cond(a, b) use the same ELSE and ENDIF tokens */
3880         control_frame = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*control_frame));
3881         control_frame->type = IFC;
3882         control_frame->ifc_no = priv->num_ifcs++;
3883         list_add_head(&priv->control_frames, &control_frame->entry);
3884     }
3885     else if(ins->handler_idx == WINED3DSIH_ELSE)
3886     {
3887         struct list *e = list_head(&priv->control_frames);
3888         control_frame = LIST_ENTRY(e, struct control_frame, entry);
3889
3890         if(control_frame->type == IF)
3891         {
3892             shader_addline(buffer, "#} else {\n");
3893             if(!priv->muted && !control_frame->muting)
3894             {
3895                 priv->muted = TRUE;
3896                 control_frame->muting = TRUE;
3897             }
3898             else if(control_frame->muting) priv->muted = FALSE;
3899             return; /* Instruction is handled. */
3900         }
3901         /* In case of an ifc, generate a HW shader instruction */
3902     }
3903     else if(ins->handler_idx == WINED3DSIH_ENDIF)
3904     {
3905         struct list *e = list_head(&priv->control_frames);
3906         control_frame = LIST_ENTRY(e, struct control_frame, entry);
3907
3908         if(control_frame->type == IF)
3909         {
3910             shader_addline(buffer, "#} endif\n");
3911             if(control_frame->muting) priv->muted = FALSE;
3912             list_remove(&control_frame->entry);
3913             HeapFree(GetProcessHeap(), 0, control_frame);
3914             return; /* Instruction is handled */
3915         }
3916     }
3917
3918     if(priv->muted) return;
3919
3920     /* Select handler */
3921     hw_fct = shader_arb_instruction_handler_table[ins->handler_idx];
3922
3923     /* Unhandled opcode */
3924     if (!hw_fct)
3925     {
3926         FIXME("Backend can't handle opcode %#x\n", ins->handler_idx);
3927         return;
3928     }
3929     hw_fct(ins);
3930
3931     if(ins->handler_idx == WINED3DSIH_ENDLOOP || ins->handler_idx == WINED3DSIH_ENDREP)
3932     {
3933         struct list *e = list_head(&priv->control_frames);
3934         control_frame = LIST_ENTRY(e, struct control_frame, entry);
3935         list_remove(&control_frame->entry);
3936         HeapFree(GetProcessHeap(), 0, control_frame);
3937         priv->loop_depth--;
3938     }
3939     else if(ins->handler_idx == WINED3DSIH_ENDIF)
3940     {
3941         /* Non-ifc ENDIFs don't reach that place because of the return in the if block above */
3942         struct list *e = list_head(&priv->control_frames);
3943         control_frame = LIST_ENTRY(e, struct control_frame, entry);
3944         list_remove(&control_frame->entry);
3945         HeapFree(GetProcessHeap(), 0, control_frame);
3946     }
3947
3948
3949     shader_arb_add_instruction_modifiers(ins);
3950 }
3951
3952 const shader_backend_t arb_program_shader_backend = {
3953     shader_arb_handle_instruction,
3954     shader_arb_select,
3955     shader_arb_select_depth_blt,
3956     shader_arb_deselect_depth_blt,
3957     shader_arb_update_float_vertex_constants,
3958     shader_arb_update_float_pixel_constants,
3959     shader_arb_load_constants,
3960     shader_arb_load_np2fixup_constants,
3961     shader_arb_destroy,
3962     shader_arb_alloc,
3963     shader_arb_free,
3964     shader_arb_dirty_const,
3965     shader_arb_get_caps,
3966     shader_arb_color_fixup_supported,
3967 };
3968
3969 /* ARB_fragment_program fixed function pipeline replacement definitions */
3970 #define ARB_FFP_CONST_TFACTOR           0
3971 #define ARB_FFP_CONST_SPECULAR_ENABLE   ((ARB_FFP_CONST_TFACTOR) + 1)
3972 #define ARB_FFP_CONST_CONSTANT(i)       ((ARB_FFP_CONST_SPECULAR_ENABLE) + 1 + i)
3973 #define ARB_FFP_CONST_BUMPMAT(i)        ((ARB_FFP_CONST_CONSTANT(7)) + 1 + i)
3974 #define ARB_FFP_CONST_LUMINANCE(i)      ((ARB_FFP_CONST_BUMPMAT(7)) + 1 + i)
3975
3976 struct arbfp_ffp_desc
3977 {
3978     struct ffp_frag_desc parent;
3979     GLuint shader;
3980     unsigned int num_textures_used;
3981 };
3982
3983 static void arbfp_enable(IWineD3DDevice *iface, BOOL enable) {
3984     ENTER_GL();
3985     if(enable) {
3986         glEnable(GL_FRAGMENT_PROGRAM_ARB);
3987         checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB)");
3988     } else {
3989         glDisable(GL_FRAGMENT_PROGRAM_ARB);
3990         checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
3991     }
3992     LEAVE_GL();
3993 }
3994
3995 static HRESULT arbfp_alloc(IWineD3DDevice *iface) {
3996     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
3997     struct shader_arb_priv *priv;
3998     /* Share private data between the shader backend and the pipeline replacement, if both
3999      * are the arb implementation. This is needed to figure out whether ARBfp should be disabled
4000      * if no pixel shader is bound or not
4001      */
4002     if(This->shader_backend == &arb_program_shader_backend) {
4003         This->fragment_priv = This->shader_priv;
4004     } else {
4005         This->fragment_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct shader_arb_priv));
4006         if(!This->fragment_priv) return E_OUTOFMEMORY;
4007     }
4008     priv = This->fragment_priv;
4009     if (wine_rb_init(&priv->fragment_shaders, &wined3d_ffp_frag_program_rb_functions) == -1)
4010     {
4011         ERR("Failed to initialize rbtree.\n");
4012         HeapFree(GetProcessHeap(), 0, This->fragment_priv);
4013         return E_OUTOFMEMORY;
4014     }
4015     priv->use_arbfp_fixed_func = TRUE;
4016     return WINED3D_OK;
4017 }
4018
4019 static void arbfp_free_ffpshader(struct wine_rb_entry *entry, void *context)
4020 {
4021     const WineD3D_GL_Info *gl_info = context;
4022     struct arbfp_ffp_desc *entry_arb = WINE_RB_ENTRY_VALUE(entry, struct arbfp_ffp_desc, parent.entry);
4023
4024     ENTER_GL();
4025     GL_EXTCALL(glDeleteProgramsARB(1, &entry_arb->shader));
4026     checkGLcall("glDeleteProgramsARB(1, &entry_arb->shader)");
4027     HeapFree(GetProcessHeap(), 0, entry_arb);
4028     LEAVE_GL();
4029 }
4030
4031 static void arbfp_free(IWineD3DDevice *iface) {
4032     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
4033     struct shader_arb_priv *priv = This->fragment_priv;
4034
4035     wine_rb_destroy(&priv->fragment_shaders, arbfp_free_ffpshader, &This->adapter->gl_info);
4036     priv->use_arbfp_fixed_func = FALSE;
4037
4038     if(This->shader_backend != &arb_program_shader_backend) {
4039         HeapFree(GetProcessHeap(), 0, This->fragment_priv);
4040     }
4041 }
4042
4043 static void arbfp_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct fragment_caps *caps)
4044 {
4045     caps->TextureOpCaps =  WINED3DTEXOPCAPS_DISABLE                     |
4046                            WINED3DTEXOPCAPS_SELECTARG1                  |
4047                            WINED3DTEXOPCAPS_SELECTARG2                  |
4048                            WINED3DTEXOPCAPS_MODULATE4X                  |
4049                            WINED3DTEXOPCAPS_MODULATE2X                  |
4050                            WINED3DTEXOPCAPS_MODULATE                    |
4051                            WINED3DTEXOPCAPS_ADDSIGNED2X                 |
4052                            WINED3DTEXOPCAPS_ADDSIGNED                   |
4053                            WINED3DTEXOPCAPS_ADD                         |
4054                            WINED3DTEXOPCAPS_SUBTRACT                    |
4055                            WINED3DTEXOPCAPS_ADDSMOOTH                   |
4056                            WINED3DTEXOPCAPS_BLENDCURRENTALPHA           |
4057                            WINED3DTEXOPCAPS_BLENDFACTORALPHA            |
4058                            WINED3DTEXOPCAPS_BLENDTEXTUREALPHA           |
4059                            WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA           |
4060                            WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM         |
4061                            WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR      |
4062                            WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA      |
4063                            WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA   |
4064                            WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR   |
4065                            WINED3DTEXOPCAPS_DOTPRODUCT3                 |
4066                            WINED3DTEXOPCAPS_MULTIPLYADD                 |
4067                            WINED3DTEXOPCAPS_LERP                        |
4068                            WINED3DTEXOPCAPS_BUMPENVMAP                  |
4069                            WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE;
4070
4071     /* TODO: Implement WINED3DTEXOPCAPS_PREMODULATE */
4072
4073     caps->MaxTextureBlendStages   = 8;
4074     caps->MaxSimultaneousTextures = min(GL_LIMITS(fragment_samplers), 8);
4075
4076     caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_TSSARGTEMP;
4077 }
4078 #undef GLINFO_LOCATION
4079
4080 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
4081 static void state_texfactor_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
4082     float col[4];
4083     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
4084
4085     /* Don't load the parameter if we're using an arbfp pixel shader, otherwise we'll overwrite
4086      * application provided constants
4087      */
4088     if(device->shader_backend == &arb_program_shader_backend) {
4089         if (use_ps(stateblock)) return;
4090
4091         device = stateblock->wineD3DDevice;
4092         device->activeContext->pshader_const_dirty[ARB_FFP_CONST_TFACTOR] = 1;
4093         device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_TFACTOR + 1);
4094     }
4095
4096     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
4097     GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_TFACTOR, col));
4098     checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_TFACTOR, col)");
4099
4100 }
4101
4102 static void state_arb_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
4103     float col[4];
4104     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
4105
4106     /* Don't load the parameter if we're using an arbfp pixel shader, otherwise we'll overwrite
4107      * application provided constants
4108      */
4109     if(device->shader_backend == &arb_program_shader_backend) {
4110         if (use_ps(stateblock)) return;
4111
4112         device = stateblock->wineD3DDevice;
4113         device->activeContext->pshader_const_dirty[ARB_FFP_CONST_SPECULAR_ENABLE] = 1;
4114         device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_SPECULAR_ENABLE + 1);
4115     }
4116
4117     if(stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
4118         /* The specular color has no alpha */
4119         col[0] = 1.0; col[1] = 1.0;
4120         col[2] = 1.0; col[3] = 0.0;
4121     } else {
4122         col[0] = 0.0; col[1] = 0.0;
4123         col[2] = 0.0; col[3] = 0.0;
4124     }
4125     GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_SPECULAR_ENABLE, col));
4126     checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_SPECULAR_ENABLE, col)");
4127 }
4128
4129 static void set_bumpmat_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
4130     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
4131     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
4132     float mat[2][2];
4133
4134     if (use_ps(stateblock))
4135     {
4136         if(stage != 0 &&
4137            ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.bumpmat[stage]) {
4138             /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
4139              * anyway
4140              */
4141             if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT)) {
4142                 device->StateTable[STATE_PIXELSHADERCONSTANT].apply(STATE_PIXELSHADERCONSTANT, stateblock, context);
4143             }
4144         }
4145
4146         if(device->shader_backend == &arb_program_shader_backend) {
4147             /* Exit now, don't set the bumpmat below, otherwise we may overwrite pixel shader constants */
4148             return;
4149         }
4150     } else if(device->shader_backend == &arb_program_shader_backend) {
4151         device->activeContext->pshader_const_dirty[ARB_FFP_CONST_BUMPMAT(stage)] = 1;
4152         device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_BUMPMAT(stage) + 1);
4153     }
4154
4155     mat[0][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT00]);
4156     mat[0][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT01]);
4157     mat[1][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT10]);
4158     mat[1][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT11]);
4159
4160     GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_BUMPMAT(stage), &mat[0][0]));
4161     checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_BUMPMAT(stage), &mat[0][0])");
4162 }
4163
4164 static void tex_bumpenvlum_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
4165     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
4166     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
4167     float param[4];
4168
4169     if (use_ps(stateblock))
4170     {
4171         if(stage != 0 &&
4172            ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.luminanceparams[stage]) {
4173             /* The pixel shader has to know the luminance offset. Do a constants update if it
4174              * isn't scheduled anyway
4175              */
4176             if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT)) {
4177                 device->StateTable[STATE_PIXELSHADERCONSTANT].apply(STATE_PIXELSHADERCONSTANT, stateblock, context);
4178             }
4179         }
4180
4181         if(device->shader_backend == &arb_program_shader_backend) {
4182             /* Exit now, don't set the bumpmat below, otherwise we may overwrite pixel shader constants */
4183             return;
4184         }
4185     } else if(device->shader_backend == &arb_program_shader_backend) {
4186         device->activeContext->pshader_const_dirty[ARB_FFP_CONST_LUMINANCE(stage)] = 1;
4187         device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, ARB_FFP_CONST_LUMINANCE(stage) + 1);
4188     }
4189
4190     param[0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE]);
4191     param[1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET]);
4192     param[2] = 0.0;
4193     param[3] = 0.0;
4194
4195     GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_LUMINANCE(stage), param));
4196     checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, ARB_FFP_CONST_LUMINANCE(stage), param)");
4197 }
4198
4199 static const char *get_argreg(SHADER_BUFFER *buffer, DWORD argnum, unsigned int stage, DWORD arg) {
4200     const char *ret;
4201
4202     if(arg == ARG_UNUSED) return "unused"; /* This is the marker for unused registers */
4203
4204     switch(arg & WINED3DTA_SELECTMASK) {
4205         case WINED3DTA_DIFFUSE:
4206             ret = "fragment.color.primary"; break;
4207
4208         case WINED3DTA_CURRENT:
4209             if(stage == 0) ret = "fragment.color.primary";
4210             else ret = "ret";
4211             break;
4212
4213         case WINED3DTA_TEXTURE:
4214             switch(stage) {
4215                 case 0: ret = "tex0"; break;
4216                 case 1: ret = "tex1"; break;
4217                 case 2: ret = "tex2"; break;
4218                 case 3: ret = "tex3"; break;
4219                 case 4: ret = "tex4"; break;
4220                 case 5: ret = "tex5"; break;
4221                 case 6: ret = "tex6"; break;
4222                 case 7: ret = "tex7"; break;
4223                 default: ret = "unknown texture";
4224             }
4225             break;
4226
4227         case WINED3DTA_TFACTOR:
4228             ret = "tfactor"; break;
4229
4230         case WINED3DTA_SPECULAR:
4231             ret = "fragment.color.secondary"; break;
4232
4233         case WINED3DTA_TEMP:
4234             ret = "tempreg"; break;
4235
4236         case WINED3DTA_CONSTANT:
4237             FIXME("Implement perstage constants\n");
4238             switch(stage) {
4239                 case 0: ret = "const0"; break;
4240                 case 1: ret = "const1"; break;
4241                 case 2: ret = "const2"; break;
4242                 case 3: ret = "const3"; break;
4243                 case 4: ret = "const4"; break;
4244                 case 5: ret = "const5"; break;
4245                 case 6: ret = "const6"; break;
4246                 case 7: ret = "const7"; break;
4247                 default: ret = "unknown constant";
4248             }
4249             break;
4250
4251         default:
4252             return "unknown";
4253     }
4254
4255     if(arg & WINED3DTA_COMPLEMENT) {
4256         shader_addline(buffer, "SUB arg%u, const.x, %s;\n", argnum, ret);
4257         if(argnum == 0) ret = "arg0";
4258         if(argnum == 1) ret = "arg1";
4259         if(argnum == 2) ret = "arg2";
4260     }
4261     if(arg & WINED3DTA_ALPHAREPLICATE) {
4262         shader_addline(buffer, "MOV arg%u, %s.w;\n", argnum, ret);
4263         if(argnum == 0) ret = "arg0";
4264         if(argnum == 1) ret = "arg1";
4265         if(argnum == 2) ret = "arg2";
4266     }
4267     return ret;
4268 }
4269
4270 static void gen_ffp_instr(SHADER_BUFFER *buffer, unsigned int stage, BOOL color, BOOL alpha,
4271                           DWORD dst, DWORD op, DWORD dw_arg0, DWORD dw_arg1, DWORD dw_arg2) {
4272     const char *dstmask, *dstreg, *arg0, *arg1, *arg2;
4273     unsigned int mul = 1;
4274     BOOL mul_final_dest = FALSE;
4275
4276     if(color && alpha) dstmask = "";
4277     else if(color) dstmask = ".xyz";
4278     else dstmask = ".w";
4279
4280     if(dst == tempreg) dstreg = "tempreg";
4281     else dstreg = "ret";
4282
4283     arg0 = get_argreg(buffer, 0, stage, dw_arg0);
4284     arg1 = get_argreg(buffer, 1, stage, dw_arg1);
4285     arg2 = get_argreg(buffer, 2, stage, dw_arg2);
4286
4287     switch(op) {
4288         case WINED3DTOP_DISABLE:
4289             if(stage == 0) shader_addline(buffer, "MOV %s%s, fragment.color.primary;\n", dstreg, dstmask);
4290             break;
4291
4292         case WINED3DTOP_SELECTARG2:
4293             arg1 = arg2;
4294         case WINED3DTOP_SELECTARG1:
4295             shader_addline(buffer, "MOV %s%s, %s;\n", dstreg, dstmask, arg1);
4296             break;
4297
4298         case WINED3DTOP_MODULATE4X:
4299             mul = 2;
4300         case WINED3DTOP_MODULATE2X:
4301             mul *= 2;
4302             if(strcmp(dstreg, "result.color") == 0) {
4303                 dstreg = "ret";
4304                 mul_final_dest = TRUE;
4305             }
4306         case WINED3DTOP_MODULATE:
4307             shader_addline(buffer, "MUL %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
4308             break;
4309
4310         case WINED3DTOP_ADDSIGNED2X:
4311             mul = 2;
4312             if(strcmp(dstreg, "result.color") == 0) {
4313                 dstreg = "ret";
4314                 mul_final_dest = TRUE;
4315             }
4316         case WINED3DTOP_ADDSIGNED:
4317             shader_addline(buffer, "SUB arg2, %s, const.w;\n", arg2);
4318             arg2 = "arg2";
4319         case WINED3DTOP_ADD:
4320             shader_addline(buffer, "ADD_SAT %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
4321             break;
4322
4323         case WINED3DTOP_SUBTRACT:
4324             shader_addline(buffer, "SUB_SAT %s%s, %s, %s;\n", dstreg, dstmask, arg1, arg2);
4325             break;
4326
4327         case WINED3DTOP_ADDSMOOTH:
4328             shader_addline(buffer, "SUB arg1, const.x, %s;\n", arg1);
4329             shader_addline(buffer, "MAD_SAT %s%s, arg1, %s, %s;\n", dstreg, dstmask, arg2, arg1);
4330             break;
4331
4332         case WINED3DTOP_BLENDCURRENTALPHA:
4333             arg0 = get_argreg(buffer, 0, stage, WINED3DTA_CURRENT);
4334             shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
4335             break;
4336         case WINED3DTOP_BLENDFACTORALPHA:
4337             arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TFACTOR);
4338             shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
4339             break;
4340         case WINED3DTOP_BLENDTEXTUREALPHA:
4341             arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TEXTURE);
4342             shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
4343             break;
4344         case WINED3DTOP_BLENDDIFFUSEALPHA:
4345             arg0 = get_argreg(buffer, 0, stage, WINED3DTA_DIFFUSE);
4346             shader_addline(buffer, "LRP %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
4347             break;
4348
4349         case WINED3DTOP_BLENDTEXTUREALPHAPM:
4350             arg0 = get_argreg(buffer, 0, stage, WINED3DTA_TEXTURE);
4351             shader_addline(buffer, "SUB arg0.w, const.x, %s.w;\n", arg0);
4352             shader_addline(buffer, "MAD_SAT %s%s, %s, arg0.w, %s;\n", dstreg, dstmask, arg2, arg1);
4353             break;
4354
4355         /* D3DTOP_PREMODULATE ???? */
4356
4357         case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
4358             shader_addline(buffer, "SUB arg0.w, const.x, %s;\n", arg1);
4359             shader_addline(buffer, "MAD_SAT %s%s, arg0.w, %s, %s;\n", dstreg, dstmask, arg2, arg1);
4360             break;
4361         case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
4362             shader_addline(buffer, "MAD_SAT %s%s, %s.w, %s, %s;\n", dstreg, dstmask, arg1, arg2, arg1);
4363             break;
4364         case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
4365             shader_addline(buffer, "SUB arg0, const.x, %s;\n", arg1);
4366             shader_addline(buffer, "MAD_SAT %s%s, arg0, %s, %s.w;\n", dstreg, dstmask, arg2, arg1);
4367             break;
4368         case WINED3DTOP_MODULATECOLOR_ADDALPHA:
4369             shader_addline(buffer, "MAD_SAT %s%s, %s, %s, %s.w;\n", dstreg, dstmask, arg1, arg2, arg1);
4370             break;
4371
4372         case WINED3DTOP_DOTPRODUCT3:
4373             mul = 4;
4374             if(strcmp(dstreg, "result.color") == 0) {
4375                 dstreg = "ret";
4376                 mul_final_dest = TRUE;
4377             }
4378             shader_addline(buffer, "SUB arg1, %s, const.w;\n", arg1);
4379             shader_addline(buffer, "SUB arg2, %s, const.w;\n", arg2);
4380             shader_addline(buffer, "DP3_SAT %s%s, arg1, arg2;\n", dstreg, dstmask);
4381             break;
4382
4383         case WINED3DTOP_MULTIPLYADD:
4384             shader_addline(buffer, "MAD_SAT %s%s, %s, %s, %s;\n", dstreg, dstmask, arg1, arg2, arg0);
4385             break;
4386
4387         case WINED3DTOP_LERP:
4388             /* The msdn is not quite right here */
4389             shader_addline(buffer, "LRP %s%s, %s, %s, %s;\n", dstreg, dstmask, arg0, arg1, arg2);
4390             break;
4391
4392         case WINED3DTOP_BUMPENVMAP:
4393         case WINED3DTOP_BUMPENVMAPLUMINANCE:
4394             /* Those are handled in the first pass of the shader(generation pass 1 and 2) already */
4395             break;
4396
4397         default:
4398             FIXME("Unhandled texture op %08x\n", op);
4399     }
4400
4401     if(mul == 2) {
4402         shader_addline(buffer, "MUL_SAT %s%s, %s, const.y;\n", mul_final_dest ? "result.color" : dstreg, dstmask, dstreg);
4403     } else if(mul == 4) {
4404         shader_addline(buffer, "MUL_SAT %s%s, %s, const.z;\n", mul_final_dest ? "result.color" : dstreg, dstmask, dstreg);
4405     }
4406 }
4407
4408 /* The stateblock is passed for GLINFO_LOCATION */
4409 static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, IWineD3DStateBlockImpl *stateblock)
4410 {
4411     unsigned int stage;
4412     SHADER_BUFFER buffer;
4413     BOOL tex_read[MAX_TEXTURES] = {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE};
4414     BOOL bump_used[MAX_TEXTURES] = {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE};
4415     BOOL luminance_used[MAX_TEXTURES] = {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE};
4416     const char *textype;
4417     const char *instr, *sat;
4418     char colorcor_dst[8];
4419     GLuint ret;
4420     DWORD arg0, arg1, arg2;
4421     BOOL tempreg_used = FALSE, tfactor_used = FALSE;
4422     BOOL op_equal;
4423     const char *final_combiner_src = "ret";
4424
4425     /* Find out which textures are read */
4426     for(stage = 0; stage < MAX_TEXTURES; stage++) {
4427         if(settings->op[stage].cop == WINED3DTOP_DISABLE) break;
4428         arg0 = settings->op[stage].carg0 & WINED3DTA_SELECTMASK;
4429         arg1 = settings->op[stage].carg1 & WINED3DTA_SELECTMASK;
4430         arg2 = settings->op[stage].carg2 & WINED3DTA_SELECTMASK;
4431         if(arg0 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
4432         if(arg1 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
4433         if(arg2 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
4434
4435         if(settings->op[stage].cop == WINED3DTOP_BLENDTEXTUREALPHA) tex_read[stage] = TRUE;
4436         if(settings->op[stage].cop == WINED3DTOP_BLENDTEXTUREALPHAPM) tex_read[stage] = TRUE;
4437         if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAP) {
4438             bump_used[stage] = TRUE;
4439             tex_read[stage] = TRUE;
4440         }
4441         if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
4442             bump_used[stage] = TRUE;
4443             tex_read[stage] = TRUE;
4444             luminance_used[stage] = TRUE;
4445         } else if(settings->op[stage].cop == WINED3DTOP_BLENDFACTORALPHA) {
4446             tfactor_used = TRUE;
4447         }
4448
4449         if(arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR) {
4450             tfactor_used = TRUE;
4451         }
4452
4453         if(settings->op[stage].dst == tempreg) tempreg_used = TRUE;
4454         if(arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP) {
4455             tempreg_used = TRUE;
4456         }
4457
4458         if(settings->op[stage].aop == WINED3DTOP_DISABLE) continue;
4459         arg0 = settings->op[stage].aarg0 & WINED3DTA_SELECTMASK;
4460         arg1 = settings->op[stage].aarg1 & WINED3DTA_SELECTMASK;
4461         arg2 = settings->op[stage].aarg2 & WINED3DTA_SELECTMASK;
4462         if(arg0 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
4463         if(arg1 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
4464         if(arg2 == WINED3DTA_TEXTURE) tex_read[stage] = TRUE;
4465
4466         if(arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP) {
4467             tempreg_used = TRUE;
4468         }
4469         if(arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR) {
4470             tfactor_used = TRUE;
4471         }
4472     }
4473
4474     /* Shader header */
4475     shader_buffer_init(&buffer);
4476
4477     shader_addline(&buffer, "!!ARBfp1.0\n");
4478
4479     switch(settings->fog) {
4480         case FOG_OFF:                                                         break;
4481         case FOG_LINEAR: shader_addline(&buffer, "OPTION ARB_fog_linear;\n"); break;
4482         case FOG_EXP:    shader_addline(&buffer, "OPTION ARB_fog_exp;\n");    break;
4483         case FOG_EXP2:   shader_addline(&buffer, "OPTION ARB_fog_exp2;\n");   break;
4484         default: FIXME("Unexpected fog setting %d\n", settings->fog);
4485     }
4486
4487     shader_addline(&buffer, "PARAM const = {1, 2, 4, 0.5};\n");
4488     shader_addline(&buffer, "TEMP TMP;\n");
4489     shader_addline(&buffer, "TEMP ret;\n");
4490     if(tempreg_used || settings->sRGB_write) shader_addline(&buffer, "TEMP tempreg;\n");
4491     shader_addline(&buffer, "TEMP arg0;\n");
4492     shader_addline(&buffer, "TEMP arg1;\n");
4493     shader_addline(&buffer, "TEMP arg2;\n");
4494     for(stage = 0; stage < MAX_TEXTURES; stage++) {
4495         if(!tex_read[stage]) continue;
4496         shader_addline(&buffer, "TEMP tex%u;\n", stage);
4497         if(!bump_used[stage]) continue;
4498         shader_addline(&buffer, "PARAM bumpmat%u = program.env[%u];\n", stage, ARB_FFP_CONST_BUMPMAT(stage));
4499         if(!luminance_used[stage]) continue;
4500         shader_addline(&buffer, "PARAM luminance%u = program.env[%u];\n", stage, ARB_FFP_CONST_LUMINANCE(stage));
4501     }
4502     if(tfactor_used) {
4503         shader_addline(&buffer, "PARAM tfactor = program.env[%u];\n", ARB_FFP_CONST_TFACTOR);
4504     }
4505         shader_addline(&buffer, "PARAM specular_enable = program.env[%u];\n", ARB_FFP_CONST_SPECULAR_ENABLE);
4506
4507     if(settings->sRGB_write) {
4508         shader_addline(&buffer, "PARAM srgb_consts1 = {%f, %f, %f, %f};\n",
4509                        srgb_mul_low, srgb_cmp, srgb_pow, srgb_mul_high);
4510         shader_addline(&buffer, "PARAM srgb_consts2 = {%f, %f, %f, %f};\n",
4511                        srgb_sub_high, 0.0, 0.0, 0.0);
4512     }
4513
4514     /* Generate texture sampling instructions) */
4515     for(stage = 0; stage < MAX_TEXTURES && settings->op[stage].cop != WINED3DTOP_DISABLE; stage++) {
4516         if(!tex_read[stage]) continue;
4517
4518         switch(settings->op[stage].tex_type) {
4519             case tex_1d:                    textype = "1D";     break;
4520             case tex_2d:                    textype = "2D";     break;
4521             case tex_3d:                    textype = "3D";     break;
4522             case tex_cube:                  textype = "CUBE";   break;
4523             case tex_rect:                  textype = "RECT";   break;
4524             default: textype = "unexpected_textype";   break;
4525         }
4526
4527         if(settings->op[stage].cop == WINED3DTOP_BUMPENVMAP ||
4528            settings->op[stage].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
4529             sat = "";
4530         } else {
4531             sat = "_SAT";
4532         }
4533
4534         if(settings->op[stage].projected == proj_none) {
4535             instr = "TEX";
4536         } else if(settings->op[stage].projected == proj_count4 ||
4537                   settings->op[stage].projected == proj_count3) {
4538             instr = "TXP";
4539         } else {
4540             FIXME("Unexpected projection mode %d\n", settings->op[stage].projected);
4541             instr = "TXP";
4542         }
4543
4544         if(stage > 0 &&
4545            (settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAP ||
4546             settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAPLUMINANCE)) {
4547             shader_addline(&buffer, "SWZ arg1, bumpmat%u, x, z, 0, 0;\n", stage - 1);
4548             shader_addline(&buffer, "DP3 ret.x, arg1, tex%u;\n", stage - 1);
4549             shader_addline(&buffer, "SWZ arg1, bumpmat%u, y, w, 0, 0;\n", stage - 1);
4550             shader_addline(&buffer, "DP3 ret.y, arg1, tex%u;\n", stage - 1);
4551
4552             /* with projective textures, texbem only divides the static texture coord, not the displacement,
4553              * so multiply the displacement with the dividing parameter before passing it to TXP
4554              */
4555             if (settings->op[stage].projected != proj_none) {
4556                 if(settings->op[stage].projected == proj_count4) {
4557                     shader_addline(&buffer, "MOV ret.w, fragment.texcoord[%u].w;\n", stage);
4558                     shader_addline(&buffer, "MUL ret.xyz, ret, fragment.texcoord[%u].w, fragment.texcoord[%u];\n", stage, stage);
4559                 } else {
4560                     shader_addline(&buffer, "MOV ret.w, fragment.texcoord[%u].z;\n", stage);
4561                     shader_addline(&buffer, "MAD ret.xyz, ret, fragment.texcoord[%u].z, fragment.texcoord[%u];\n", stage, stage);
4562                 }
4563             } else {
4564                 shader_addline(&buffer, "ADD ret, ret, fragment.texcoord[%u];\n", stage);
4565             }
4566
4567             shader_addline(&buffer, "%s%s tex%u, ret, texture[%u], %s;\n",
4568                            instr, sat, stage, stage, textype);
4569             if(settings->op[stage - 1].cop == WINED3DTOP_BUMPENVMAPLUMINANCE) {
4570                 shader_addline(&buffer, "MAD_SAT ret.x, tex%u.z, luminance%u.x, luminance%u.y;\n",
4571                                stage - 1, stage - 1, stage - 1);
4572                 shader_addline(&buffer, "MUL tex%u, tex%u, ret.x;\n", stage, stage);
4573             }
4574         } else if(settings->op[stage].projected == proj_count3) {
4575             shader_addline(&buffer, "MOV ret, fragment.texcoord[%u];\n", stage);
4576             shader_addline(&buffer, "MOV ret.w, ret.z;\n");
4577             shader_addline(&buffer, "%s%s tex%u, ret, texture[%u], %s;\n",
4578                             instr, sat, stage, stage, textype);
4579         } else {
4580             shader_addline(&buffer, "%s%s tex%u, fragment.texcoord[%u], texture[%u], %s;\n",
4581                             instr, sat, stage, stage, stage, textype);
4582         }
4583
4584         sprintf(colorcor_dst, "tex%u", stage);
4585         gen_color_correction(&buffer, colorcor_dst, WINED3DSP_WRITEMASK_ALL, "const.x", "const.y",
4586                 settings->op[stage].color_fixup);
4587     }
4588
4589     /* Generate the main shader */
4590     for(stage = 0; stage < MAX_TEXTURES; stage++) {
4591         if(settings->op[stage].cop == WINED3DTOP_DISABLE) {
4592             if(stage == 0) {
4593                 final_combiner_src = "fragment.color.primary";
4594             }
4595             break;
4596         }
4597
4598         if(settings->op[stage].cop == WINED3DTOP_SELECTARG1 &&
4599            settings->op[stage].aop == WINED3DTOP_SELECTARG1) {
4600             op_equal = settings->op[stage].carg1 == settings->op[stage].aarg1;
4601         } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG1 &&
4602                   settings->op[stage].aop == WINED3DTOP_SELECTARG2) {
4603             op_equal = settings->op[stage].carg1 == settings->op[stage].aarg2;
4604         } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG2 &&
4605                   settings->op[stage].aop == WINED3DTOP_SELECTARG1) {
4606             op_equal = settings->op[stage].carg2 == settings->op[stage].aarg1;
4607         } else if(settings->op[stage].cop == WINED3DTOP_SELECTARG2 &&
4608                   settings->op[stage].aop == WINED3DTOP_SELECTARG2) {
4609             op_equal = settings->op[stage].carg2 == settings->op[stage].aarg2;
4610         } else {
4611             op_equal = settings->op[stage].aop   == settings->op[stage].cop &&
4612                        settings->op[stage].carg0 == settings->op[stage].aarg0 &&
4613                        settings->op[stage].carg1 == settings->op[stage].aarg1 &&
4614                        settings->op[stage].carg2 == settings->op[stage].aarg2;
4615         }
4616
4617         if(settings->op[stage].aop == WINED3DTOP_DISABLE) {
4618             gen_ffp_instr(&buffer, stage, TRUE, FALSE, settings->op[stage].dst,
4619                           settings->op[stage].cop, settings->op[stage].carg0,
4620                           settings->op[stage].carg1, settings->op[stage].carg2);
4621             if(stage == 0) {
4622                 shader_addline(&buffer, "MOV ret.w, fragment.color.primary.w;\n");
4623             }
4624         } else if(op_equal) {
4625             gen_ffp_instr(&buffer, stage, TRUE, TRUE, settings->op[stage].dst,
4626                           settings->op[stage].cop, settings->op[stage].carg0,
4627                           settings->op[stage].carg1, settings->op[stage].carg2);
4628         } else {
4629             gen_ffp_instr(&buffer, stage, TRUE, FALSE, settings->op[stage].dst,
4630                           settings->op[stage].cop, settings->op[stage].carg0,
4631                           settings->op[stage].carg1, settings->op[stage].carg2);
4632             gen_ffp_instr(&buffer, stage, FALSE, TRUE, settings->op[stage].dst,
4633                           settings->op[stage].aop, settings->op[stage].aarg0,
4634                           settings->op[stage].aarg1, settings->op[stage].aarg2);
4635         }
4636     }
4637
4638     if(settings->sRGB_write) {
4639         shader_addline(&buffer, "MAD ret, fragment.color.secondary, specular_enable, %s;\n", final_combiner_src);
4640         arbfp_add_sRGB_correction(&buffer, "ret", "arg0", "arg1", "arg2", "tempreg", FALSE);
4641     } else {
4642         shader_addline(&buffer, "MAD result.color, fragment.color.secondary, specular_enable, %s;\n", final_combiner_src);
4643     }
4644
4645     /* Footer */
4646     shader_addline(&buffer, "END\n");
4647
4648     /* Generate the shader */
4649     GL_EXTCALL(glGenProgramsARB(1, &ret));
4650     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ret));
4651     GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(buffer.buffer), buffer.buffer));
4652
4653     if (glGetError() == GL_INVALID_OPERATION) {
4654         GLint pos;
4655         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
4656         FIXME("Fragment program error at position %d: %s\n", pos,
4657               debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
4658     }
4659     shader_buffer_free(&buffer);
4660     return ret;
4661 }
4662
4663 static void fragment_prog_arbfp(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
4664     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
4665     struct shader_arb_priv *priv = device->fragment_priv;
4666     BOOL use_pshader = use_ps(stateblock);
4667     BOOL use_vshader = use_vs(stateblock);
4668     struct ffp_frag_settings settings;
4669     const struct arbfp_ffp_desc *desc;
4670     unsigned int i;
4671
4672     TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
4673
4674     if(isStateDirty(context, STATE_RENDER(WINED3DRS_FOGENABLE))) {
4675         if(!use_pshader && device->shader_backend == &arb_program_shader_backend && context->last_was_pshader) {
4676             /* Reload fixed function constants since they collide with the pixel shader constants */
4677             for(i = 0; i < MAX_TEXTURES; i++) {
4678                 set_bumpmat_arbfp(STATE_TEXTURESTAGE(i, WINED3DTSS_BUMPENVMAT00), stateblock, context);
4679             }
4680             state_texfactor_arbfp(STATE_RENDER(WINED3DRS_TEXTUREFACTOR), stateblock, context);
4681             state_arb_specularenable(STATE_RENDER(WINED3DRS_SPECULARENABLE), stateblock, context);
4682         } else if(use_pshader && !isStateDirty(context, device->StateTable[STATE_VSHADER].representative)) {
4683             device->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_pshader, use_vshader);
4684         }
4685         return;
4686     }
4687
4688     if(!use_pshader) {
4689         /* Find or create a shader implementing the fixed function pipeline settings, then activate it */
4690         gen_ffp_frag_op(stateblock, &settings, FALSE);
4691         desc = (const struct arbfp_ffp_desc *)find_ffp_frag_shader(&priv->fragment_shaders, &settings);
4692         if(!desc) {
4693             struct arbfp_ffp_desc *new_desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_desc));
4694             if (!new_desc)
4695             {
4696                 ERR("Out of memory\n");
4697                 return;
4698             }
4699             new_desc->num_textures_used = 0;
4700             for(i = 0; i < GL_LIMITS(texture_stages); i++) {
4701                 if(settings.op[i].cop == WINED3DTOP_DISABLE) break;
4702                 new_desc->num_textures_used = i;
4703             }
4704
4705             memcpy(&new_desc->parent.settings, &settings, sizeof(settings));
4706             new_desc->shader = gen_arbfp_ffp_shader(&settings, stateblock);
4707             add_ffp_frag_shader(&priv->fragment_shaders, &new_desc->parent);
4708             TRACE("Allocated fixed function replacement shader descriptor %p\n", new_desc);
4709             desc = new_desc;
4710         }
4711
4712         /* Now activate the replacement program. GL_FRAGMENT_PROGRAM_ARB is already active(however, note the
4713          * comment above the shader_select call below). If e.g. GLSL is active, the shader_select call will
4714          * deactivate it.
4715          */
4716         GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, desc->shader));
4717         checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, desc->shader)");
4718         priv->current_fprogram_id = desc->shader;
4719
4720         if(device->shader_backend == &arb_program_shader_backend && context->last_was_pshader) {
4721             /* Reload fixed function constants since they collide with the pixel shader constants */
4722             for(i = 0; i < MAX_TEXTURES; i++) {
4723                 set_bumpmat_arbfp(STATE_TEXTURESTAGE(i, WINED3DTSS_BUMPENVMAT00), stateblock, context);
4724             }
4725             state_texfactor_arbfp(STATE_RENDER(WINED3DRS_TEXTUREFACTOR), stateblock, context);
4726             state_arb_specularenable(STATE_RENDER(WINED3DRS_SPECULARENABLE), stateblock, context);
4727         }
4728         context->last_was_pshader = FALSE;
4729     } else {
4730         context->last_was_pshader = TRUE;
4731     }
4732
4733     /* Finally, select the shader. If a pixel shader is used, it will be set and enabled by the shader backend.
4734      * If this shader backend is arbfp(most likely), then it will simply overwrite the last fixed function replace-
4735      * ment shader. If the shader backend is not ARB, it currently is important that the opengl implementation
4736      * type overwrites GL_ARB_fragment_program. This is currently the case with GLSL. If we really want to use
4737      * atifs or nvrc pixel shaders with arb fragment programs we'd have to disable GL_FRAGMENT_PROGRAM_ARB here
4738      *
4739      * Don't call shader_select if the vertex shader is dirty, because it will be called later on by the vertex
4740      * shader handler
4741      */
4742     if(!isStateDirty(context, device->StateTable[STATE_VSHADER].representative)) {
4743         device->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_pshader, use_vshader);
4744
4745         if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (use_vshader || use_pshader)) {
4746             device->StateTable[STATE_VERTEXSHADERCONSTANT].apply(STATE_VERTEXSHADERCONSTANT, stateblock, context);
4747         }
4748     }
4749     if(use_pshader) {
4750         device->StateTable[STATE_PIXELSHADERCONSTANT].apply(STATE_PIXELSHADERCONSTANT, stateblock, context);
4751     }
4752 }
4753
4754 /* We can't link the fog states to the fragment state directly since the vertex pipeline links them
4755  * to FOGENABLE. A different linking in different pipeline parts can't be expressed in the combined
4756  * state table, so we need to handle that with a forwarding function. The other invisible side effect
4757  * is that changing the fog start and fog end(which links to FOGENABLE in vertex) results in the
4758  * fragment_prog_arbfp function being called because FOGENABLE is dirty, which calls this function here
4759  */
4760 static void state_arbfp_fog(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
4761     enum fogsource new_source;
4762
4763     TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
4764
4765     if(!isStateDirty(context, STATE_PIXELSHADER)) {
4766         fragment_prog_arbfp(state, stateblock, context);
4767     }
4768
4769     if(!stateblock->renderState[WINED3DRS_FOGENABLE]) return;
4770
4771     if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
4772         if(use_vs(stateblock)) {
4773             new_source = FOGSOURCE_VS;
4774         } else {
4775             if(stateblock->renderState[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE || context->last_was_rhw) {
4776                 new_source = FOGSOURCE_COORD;
4777             } else {
4778                 new_source = FOGSOURCE_FFP;
4779             }
4780         }
4781     } else {
4782         new_source = FOGSOURCE_FFP;
4783     }
4784     if(new_source != context->fog_source) {
4785         context->fog_source = new_source;
4786         state_fogstartend(STATE_RENDER(WINED3DRS_FOGSTART), stateblock, context);
4787     }
4788 }
4789
4790 static void textransform(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
4791     if(!isStateDirty(context, STATE_PIXELSHADER)) {
4792         fragment_prog_arbfp(state, stateblock, context);
4793     }
4794 }
4795
4796 #undef GLINFO_LOCATION
4797
4798 static const struct StateEntryTemplate arbfp_fragmentstate_template[] = {
4799     {STATE_RENDER(WINED3DRS_TEXTUREFACTOR),               { STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              state_texfactor_arbfp   }, WINED3D_GL_EXT_NONE             },
4800     {STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4801     {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4802     {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4803     {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4804     {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4805     {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4806     {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4807     {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4808     {STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4809     {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),      { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4810     {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01),      { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4811     {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10),      { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4812     {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11),      { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4813     {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4814     {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET),    { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4815     {STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4816     {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4817     {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4818     {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4819     {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4820     {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4821     {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4822     {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4823     {STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4824     {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),      { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4825     {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01),      { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4826     {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10),      { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4827     {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11),      { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4828     {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4829     {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET),    { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4830     {STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4831     {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4832     {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4833     {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4834     {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4835     {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4836     {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4837     {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4838     {STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4839     {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),      { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4840     {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01),      { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4841     {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10),      { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4842     {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11),      { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4843     {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4844     {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET),    { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4845     {STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4846     {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4847     {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4848     {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4849     {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4850     {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4851     {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4852     {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4853     {STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4854     {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),      { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4855     {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01),      { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4856     {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10),      { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4857     {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11),      { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4858     {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4859     {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET),    { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4860     {STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4861     {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4862     {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4863     {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4864     {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4865     {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4866     {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4867     {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4868     {STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4869     {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),      { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4870     {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01),      { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4871     {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10),      { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4872     {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11),      { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4873     {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4874     {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET),    { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4875     {STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4876     {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4877     {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4878     {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4879     {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4880     {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4881     {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4882     {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4883     {STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4884     {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),      { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4885     {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01),      { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4886     {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10),      { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4887     {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11),      { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4888     {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4889     {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET),    { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4890     {STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4891     {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4892     {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4893     {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4894     {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4895     {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4896     {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4897     {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4898     {STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4899     {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),      { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4900     {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01),      { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4901     {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10),      { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4902     {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11),      { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4903     {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4904     {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET),    { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4905     {STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4906     {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4907     {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4908     {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4909     {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),           { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4910     {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4911     {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4912     {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4913     {STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG),         { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4914     {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),      { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4915     {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01),      { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4916     {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10),      { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4917     {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11),      { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     set_bumpmat_arbfp       }, WINED3D_GL_EXT_NONE             },
4918     {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4919     {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET),    { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlum_arbfp    }, WINED3D_GL_EXT_NONE             },
4920     {STATE_SAMPLER(0),                                    { STATE_SAMPLER(0),                                   sampler_texdim          }, WINED3D_GL_EXT_NONE             },
4921     {STATE_SAMPLER(1),                                    { STATE_SAMPLER(1),                                   sampler_texdim          }, WINED3D_GL_EXT_NONE             },
4922     {STATE_SAMPLER(2),                                    { STATE_SAMPLER(2),                                   sampler_texdim          }, WINED3D_GL_EXT_NONE             },
4923     {STATE_SAMPLER(3),                                    { STATE_SAMPLER(3),                                   sampler_texdim          }, WINED3D_GL_EXT_NONE             },
4924     {STATE_SAMPLER(4),                                    { STATE_SAMPLER(4),                                   sampler_texdim          }, WINED3D_GL_EXT_NONE             },
4925     {STATE_SAMPLER(5),                                    { STATE_SAMPLER(5),                                   sampler_texdim          }, WINED3D_GL_EXT_NONE             },
4926     {STATE_SAMPLER(6),                                    { STATE_SAMPLER(6),                                   sampler_texdim          }, WINED3D_GL_EXT_NONE             },
4927     {STATE_SAMPLER(7),                                    { STATE_SAMPLER(7),                                   sampler_texdim          }, WINED3D_GL_EXT_NONE             },
4928     {STATE_PIXELSHADER,                                   { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4929     {STATE_RENDER(WINED3DRS_FOGENABLE),                   { STATE_RENDER(WINED3DRS_FOGENABLE),                  state_arbfp_fog         }, WINED3D_GL_EXT_NONE             },
4930     {STATE_RENDER(WINED3DRS_FOGTABLEMODE),                { STATE_RENDER(WINED3DRS_FOGENABLE),                  state_arbfp_fog         }, WINED3D_GL_EXT_NONE             },
4931     {STATE_RENDER(WINED3DRS_FOGVERTEXMODE),               { STATE_RENDER(WINED3DRS_FOGENABLE),                  state_arbfp_fog         }, WINED3D_GL_EXT_NONE             },
4932     {STATE_RENDER(WINED3DRS_FOGSTART),                    { STATE_RENDER(WINED3DRS_FOGSTART),                   state_fogstartend       }, WINED3D_GL_EXT_NONE             },
4933     {STATE_RENDER(WINED3DRS_FOGEND),                      { STATE_RENDER(WINED3DRS_FOGSTART),                   state_fogstartend       }, WINED3D_GL_EXT_NONE             },
4934     {STATE_RENDER(WINED3DRS_SRGBWRITEENABLE),             { STATE_PIXELSHADER,                                  fragment_prog_arbfp     }, WINED3D_GL_EXT_NONE             },
4935     {STATE_RENDER(WINED3DRS_FOGCOLOR),                    { STATE_RENDER(WINED3DRS_FOGCOLOR),                   state_fogcolor          }, WINED3D_GL_EXT_NONE             },
4936     {STATE_RENDER(WINED3DRS_FOGDENSITY),                  { STATE_RENDER(WINED3DRS_FOGDENSITY),                 state_fogdensity        }, WINED3D_GL_EXT_NONE             },
4937     {STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(0, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform      }, WINED3D_GL_EXT_NONE             },
4938     {STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(1, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform      }, WINED3D_GL_EXT_NONE             },
4939     {STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(2, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform      }, WINED3D_GL_EXT_NONE             },
4940     {STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(3, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform      }, WINED3D_GL_EXT_NONE             },
4941     {STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(4, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform      }, WINED3D_GL_EXT_NONE             },
4942     {STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(5, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform      }, WINED3D_GL_EXT_NONE             },
4943     {STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(6, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform      }, WINED3D_GL_EXT_NONE             },
4944     {STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(7, WINED3DTSS_TEXTURETRANSFORMFLAGS), textransform      }, WINED3D_GL_EXT_NONE             },
4945     {STATE_RENDER(WINED3DRS_SPECULARENABLE),              { STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_arb_specularenable}, WINED3D_GL_EXT_NONE             },
4946     {0 /* Terminate */,                                   { 0,                                                  0                       }, WINED3D_GL_EXT_NONE             },
4947 };
4948
4949 const struct fragment_pipeline arbfp_fragment_pipeline = {
4950     arbfp_enable,
4951     arbfp_get_caps,
4952     arbfp_alloc,
4953     arbfp_free,
4954     shader_arb_color_fixup_supported,
4955     arbfp_fragmentstate_template,
4956     TRUE /* We can disable projected textures */
4957 };
4958
4959 #define GLINFO_LOCATION device->adapter->gl_info
4960
4961 struct arbfp_blit_priv {
4962     GLenum yuy2_rect_shader, yuy2_2d_shader;
4963     GLenum uyvy_rect_shader, uyvy_2d_shader;
4964     GLenum yv12_rect_shader, yv12_2d_shader;
4965 };
4966
4967 static HRESULT arbfp_blit_alloc(IWineD3DDevice *iface) {
4968     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
4969     device->blit_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct arbfp_blit_priv));
4970     if(!device->blit_priv) {
4971         ERR("Out of memory\n");
4972         return E_OUTOFMEMORY;
4973     }
4974     return WINED3D_OK;
4975 }
4976 static void arbfp_blit_free(IWineD3DDevice *iface) {
4977     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
4978     struct arbfp_blit_priv *priv = device->blit_priv;
4979
4980     ENTER_GL();
4981     GL_EXTCALL(glDeleteProgramsARB(1, &priv->yuy2_rect_shader));
4982     GL_EXTCALL(glDeleteProgramsARB(1, &priv->yuy2_2d_shader));
4983     GL_EXTCALL(glDeleteProgramsARB(1, &priv->uyvy_rect_shader));
4984     GL_EXTCALL(glDeleteProgramsARB(1, &priv->uyvy_2d_shader));
4985     GL_EXTCALL(glDeleteProgramsARB(1, &priv->yv12_rect_shader));
4986     GL_EXTCALL(glDeleteProgramsARB(1, &priv->yv12_2d_shader));
4987     checkGLcall("Delete yuv programs\n");
4988     LEAVE_GL();
4989 }
4990
4991 static BOOL gen_planar_yuv_read(SHADER_BUFFER *buffer, enum yuv_fixup yuv_fixup, GLenum textype, char *luminance)
4992 {
4993     char chroma;
4994     const char *tex, *texinstr;
4995
4996     if (yuv_fixup == YUV_FIXUP_UYVY) {
4997         chroma = 'x';
4998         *luminance = 'w';
4999     } else {
5000         chroma = 'w';
5001         *luminance = 'x';
5002     }
5003     switch(textype) {
5004         case GL_TEXTURE_2D:             tex = "2D";     texinstr = "TXP"; break;
5005         case GL_TEXTURE_RECTANGLE_ARB:  tex = "RECT";   texinstr = "TEX"; break;
5006         default:
5007             /* This is more tricky than just replacing the texture type - we have to navigate
5008              * properly in the texture to find the correct chroma values
5009              */
5010             FIXME("Implement yuv correction for non-2d, non-rect textures\n");
5011             return FALSE;
5012     }
5013
5014     /* First we have to read the chroma values. This means we need at least two pixels(no filtering),
5015      * or 4 pixels(with filtering). To get the unmodified chromas, we have to rid ourselves of the
5016      * filtering when we sample the texture.
5017      *
5018      * These are the rules for reading the chroma:
5019      *
5020      * Even pixel: Cr
5021      * Even pixel: U
5022      * Odd pixel: V
5023      *
5024      * So we have to get the sampling x position in non-normalized coordinates in integers
5025      */
5026     if(textype != GL_TEXTURE_RECTANGLE_ARB) {
5027         shader_addline(buffer, "MUL texcrd.xy, fragment.texcoord[0], size.x;\n");
5028         shader_addline(buffer, "MOV texcrd.w, size.x;\n");
5029     } else {
5030         shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
5031     }
5032     /* We must not allow filtering between pixel x and x+1, this would mix U and V
5033      * Vertical filtering is ok. However, bear in mind that the pixel center is at
5034      * 0.5, so add 0.5.
5035      */
5036     shader_addline(buffer, "FLR texcrd.x, texcrd.x;\n");
5037     shader_addline(buffer, "ADD texcrd.x, texcrd.x, coef.y;\n");
5038
5039     /* Divide the x coordinate by 0.5 and get the fraction. This gives 0.25 and 0.75 for the
5040      * even and odd pixels respectively
5041      */
5042     shader_addline(buffer, "MUL texcrd2, texcrd, coef.y;\n");
5043     shader_addline(buffer, "FRC texcrd2, texcrd2;\n");
5044
5045     /* Sample Pixel 1 */
5046     shader_addline(buffer, "%s luminance, texcrd, texture[0], %s;\n", texinstr, tex);
5047
5048     /* Put the value into either of the chroma values */
5049     shader_addline(buffer, "SGE temp.x, texcrd2.x, coef.y;\n");
5050     shader_addline(buffer, "MUL chroma.x, luminance.%c, temp.x;\n", chroma);
5051     shader_addline(buffer, "SLT temp.x, texcrd2.x, coef.y;\n");
5052     shader_addline(buffer, "MUL chroma.y, luminance.%c, temp.x;\n", chroma);
5053
5054     /* Sample pixel 2. If we read an even pixel(SLT above returned 1), sample
5055      * the pixel right to the current one. Otherwise, sample the left pixel.
5056      * Bias and scale the SLT result to -1;1 and add it to the texcrd.x.
5057      */
5058     shader_addline(buffer, "MAD temp.x, temp.x, coef.z, -coef.x;\n");
5059     shader_addline(buffer, "ADD texcrd.x, texcrd, temp.x;\n");
5060     shader_addline(buffer, "%s luminance, texcrd, texture[0], %s;\n", texinstr, tex);
5061
5062     /* Put the value into the other chroma */
5063     shader_addline(buffer, "SGE temp.x, texcrd2.x, coef.y;\n");
5064     shader_addline(buffer, "MAD chroma.y, luminance.%c, temp.x, chroma.y;\n", chroma);
5065     shader_addline(buffer, "SLT temp.x, texcrd2.x, coef.y;\n");
5066     shader_addline(buffer, "MAD chroma.x, luminance.%c, temp.x, chroma.x;\n", chroma);
5067
5068     /* TODO: If filtering is enabled, sample a 2nd pair of pixels left or right of
5069      * the current one and lerp the two U and V values
5070      */
5071
5072     /* This gives the correctly filtered luminance value */
5073     shader_addline(buffer, "TEX luminance, fragment.texcoord[0], texture[0], %s;\n", tex);
5074
5075     return TRUE;
5076 }
5077
5078 static BOOL gen_yv12_read(SHADER_BUFFER *buffer, GLenum textype, char *luminance)
5079 {
5080     const char *tex;
5081
5082     switch(textype) {
5083         case GL_TEXTURE_2D:             tex = "2D";     break;
5084         case GL_TEXTURE_RECTANGLE_ARB:  tex = "RECT";   break;
5085         default:
5086             FIXME("Implement yv12 correction for non-2d, non-rect textures\n");
5087             return FALSE;
5088     }
5089
5090     /* YV12 surfaces contain a WxH sized luminance plane, followed by a (W/2)x(H/2)
5091      * V and a (W/2)x(H/2) U plane, each with 8 bit per pixel. So the effective
5092      * bitdepth is 12 bits per pixel. Since the U and V planes have only half the
5093      * pitch of the luminance plane, the packing into the gl texture is a bit
5094      * unfortunate. If the whole texture is interpreted as luminance data it looks
5095      * approximately like this:
5096      *
5097      *        +----------------------------------+----
5098      *        |                                  |
5099      *        |                                  |
5100      *        |                                  |
5101      *        |                                  |
5102      *        |                                  |   2
5103      *        |            LUMINANCE             |   -
5104      *        |                                  |   3
5105      *        |                                  |
5106      *        |                                  |
5107      *        |                                  |
5108      *        |                                  |
5109      *        +----------------+-----------------+----
5110      *        |                |                 |
5111      *        |  U even rows   |  U odd rows     |
5112      *        |                |                 |   1
5113      *        +----------------+------------------   -
5114      *        |                |                 |   3
5115      *        |  V even rows   |  V odd rows     |
5116      *        |                |                 |
5117      *        +----------------+-----------------+----
5118      *        |                |                 |
5119      *        |     0.5        |       0.5       |
5120      *
5121      * So it appears as if there are 4 chroma images, but in fact the odd rows
5122      * in the chroma images are in the same row as the even ones. So its is
5123      * kinda tricky to read
5124      *
5125      * When reading from rectangle textures, keep in mind that the input y coordinates
5126      * go from 0 to d3d_height, whereas the opengl texture height is 1.5 * d3d_height
5127      */
5128     shader_addline(buffer, "PARAM yv12_coef = {%f, %f, %f, %f};\n",
5129                    2.0 / 3.0, 1.0 / 6.0, (2.0 / 3.0) + (1.0 / 6.0), 1.0 / 3.0);
5130
5131     shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
5132     /* the chroma planes have only half the width */
5133     shader_addline(buffer, "MUL texcrd.x, texcrd.x, coef.y;\n");
5134
5135     /* The first value is between 2/3 and 5/6th of the texture's height, so scale+bias
5136      * the coordinate. Also read the right side of the image when reading odd lines
5137      *
5138      * Don't forget to clamp the y values in into the range, otherwise we'll get filtering
5139      * bleeding
5140      */
5141     if(textype == GL_TEXTURE_2D) {
5142
5143         shader_addline(buffer, "RCP chroma.w, size.y;\n");
5144
5145         shader_addline(buffer, "MUL texcrd2.y, texcrd.y, size.y;\n");
5146
5147         shader_addline(buffer, "FLR texcrd2.y, texcrd2.y;\n");
5148         shader_addline(buffer, "MAD texcrd.y, texcrd.y, yv12_coef.y, yv12_coef.x;\n");
5149
5150         /* Read odd lines from the right side(add size * 0.5 to the x coordinate */
5151         shader_addline(buffer, "ADD texcrd2.x, texcrd2.y, yv12_coef.y;\n"); /* To avoid 0.5 == 0.5 comparisons */
5152         shader_addline(buffer, "FRC texcrd2.x, texcrd2.x;\n");
5153         shader_addline(buffer, "SGE texcrd2.x, texcrd2.x, coef.y;\n");
5154         shader_addline(buffer, "MAD texcrd.x, texcrd2.x, coef.y, texcrd.x;\n");
5155
5156         /* clamp, keep the half pixel origin in mind */
5157         shader_addline(buffer, "MAD temp.y, coef.y, chroma.w, yv12_coef.x;\n");
5158         shader_addline(buffer, "MAX texcrd.y, temp.y, texcrd.y;\n");
5159         shader_addline(buffer, "MAD temp.y, -coef.y, chroma.w, yv12_coef.z;\n");
5160         shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
5161     } else {
5162         /* Read from [size - size+size/4] */
5163         shader_addline(buffer, "FLR texcrd.y, texcrd.y;\n");
5164         shader_addline(buffer, "MAD texcrd.y, texcrd.y, coef.w, size.y;\n");
5165
5166         /* Read odd lines from the right side(add size * 0.5 to the x coordinate */
5167         shader_addline(buffer, "ADD texcrd2.x, texcrd.y, yv12_coef.y;\n"); /* To avoid 0.5 == 0.5 comparisons */
5168         shader_addline(buffer, "FRC texcrd2.x, texcrd2.x;\n");
5169         shader_addline(buffer, "SGE texcrd2.x, texcrd2.x, coef.y;\n");
5170         shader_addline(buffer, "MUL texcrd2.x, texcrd2.x, size.x;\n");
5171         shader_addline(buffer, "MAD texcrd.x, texcrd2.x, coef.y, texcrd.x;\n");
5172
5173         /* Make sure to read exactly from the pixel center */
5174         shader_addline(buffer, "FLR texcrd.y, texcrd.y;\n");
5175         shader_addline(buffer, "ADD texcrd.y, texcrd.y, coef.y;\n");
5176
5177         /* Clamp */
5178         shader_addline(buffer, "MAD temp.y, size.y, coef.w, size.y;\n");
5179         shader_addline(buffer, "ADD temp.y, temp.y, -coef.y;\n");
5180         shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
5181         shader_addline(buffer, "ADD temp.y, size.y, -coef.y;\n");
5182         shader_addline(buffer, "MAX texcrd.y, temp.y, texcrd.y;\n");
5183     }
5184     /* Read the texture, put the result into the output register */
5185     shader_addline(buffer, "TEX temp, texcrd, texture[0], %s;\n", tex);
5186     shader_addline(buffer, "MOV chroma.x, temp.w;\n");
5187
5188     /* The other chroma value is 1/6th of the texture lower, from 5/6th to 6/6th
5189      * No need to clamp because we're just reusing the already clamped value from above
5190      */
5191     if(textype == GL_TEXTURE_2D) {
5192         shader_addline(buffer, "ADD texcrd.y, texcrd.y, yv12_coef.y;\n");
5193     } else {
5194         shader_addline(buffer, "MAD texcrd.y, size.y, coef.w, texcrd.y;\n");
5195     }
5196     shader_addline(buffer, "TEX temp, texcrd, texture[0], %s;\n", tex);
5197     shader_addline(buffer, "MOV chroma.y, temp.w;\n");
5198
5199     /* Sample the luminance value. It is in the top 2/3rd of the texture, so scale the y coordinate.
5200      * Clamp the y coordinate to prevent the chroma values from bleeding into the sampled luminance
5201      * values due to filtering
5202      */
5203     shader_addline(buffer, "MOV texcrd, fragment.texcoord[0];\n");
5204     if(textype == GL_TEXTURE_2D) {
5205         /* Multiply the y coordinate by 2/3 and clamp it */
5206         shader_addline(buffer, "MUL texcrd.y, texcrd.y, yv12_coef.x;\n");
5207         shader_addline(buffer, "MAD temp.y, -coef.y, chroma.w, yv12_coef.x;\n");
5208         shader_addline(buffer, "MIN texcrd.y, temp.y, texcrd.y;\n");
5209         shader_addline(buffer, "TEX luminance, texcrd, texture[0], %s;\n", tex);
5210     } else {
5211         /* Reading from texture_rectangles is pretty straightforward, just use the unmodified
5212          * texture coordinate. It is still a good idea to clamp it though, since the opengl texture
5213          * is bigger
5214          */
5215         shader_addline(buffer, "ADD temp.x, size.y, -coef.y;\n");
5216         shader_addline(buffer, "MIN texcrd.y, texcrd.y, size.x;\n");
5217         shader_addline(buffer, "TEX luminance, texcrd, texture[0], %s;\n", tex);
5218     }
5219     *luminance = 'a';
5220
5221     return TRUE;
5222 }
5223
5224 static GLuint gen_yuv_shader(IWineD3DDeviceImpl *device, enum yuv_fixup yuv_fixup, GLenum textype)
5225 {
5226     GLenum shader;
5227     SHADER_BUFFER buffer;
5228     char luminance_component;
5229     struct arbfp_blit_priv *priv = device->blit_priv;
5230
5231     /* Shader header */
5232     shader_buffer_init(&buffer);
5233
5234     ENTER_GL();
5235     GL_EXTCALL(glGenProgramsARB(1, &shader));
5236     checkGLcall("GL_EXTCALL(glGenProgramsARB(1, &shader))");
5237     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader));
5238     checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader)");
5239     LEAVE_GL();
5240     if(!shader) {
5241         shader_buffer_free(&buffer);
5242         return 0;
5243     }
5244
5245     /* The YUY2 and UYVY formats contain two pixels packed into a 32 bit macropixel,
5246      * giving effectively 16 bit per pixel. The color consists of a luminance(Y) and
5247      * two chroma(U and V) values. Each macropixel has two luminance values, one for
5248      * each single pixel it contains, and one U and one V value shared between both
5249      * pixels.
5250      *
5251      * The data is loaded into an A8L8 texture. With YUY2, the luminance component
5252      * contains the luminance and alpha the chroma. With UYVY it is vice versa. Thus
5253      * take the format into account when generating the read swizzles
5254      *
5255      * Reading the Y value is straightforward - just sample the texture. The hardware
5256      * takes care of filtering in the horizontal and vertical direction.
5257      *
5258      * Reading the U and V values is harder. We have to avoid filtering horizontally,
5259      * because that would mix the U and V values of one pixel or two adjacent pixels.
5260      * Thus floor the texture coordinate and add 0.5 to get an unfiltered read,
5261      * regardless of the filtering setting. Vertical filtering works automatically
5262      * though - the U and V values of two rows are mixed nicely.
5263      *
5264      * Appart of avoiding filtering issues, the code has to know which value it just
5265      * read, and where it can find the other one. To determine this, it checks if
5266      * it sampled an even or odd pixel, and shifts the 2nd read accordingly.
5267      *
5268      * Handling horizontal filtering of U and V values requires reading a 2nd pair
5269      * of pixels, extracting U and V and mixing them. This is not implemented yet.
5270      *
5271      * An alternative implementation idea is to load the texture as A8R8G8B8 texture,
5272      * with width / 2. This way one read gives all 3 values, finding U and V is easy
5273      * in an unfiltered situation. Finding the luminance on the other hand requires
5274      * finding out if it is an odd or even pixel. The real drawback of this approach
5275      * is filtering. This would have to be emulated completely in the shader, reading
5276      * up two 2 packed pixels in up to 2 rows and interpolating both horizontally and
5277      * vertically. Beyond that it would require adjustments to the texture handling
5278      * code to deal with the width scaling
5279      */
5280     shader_addline(&buffer, "!!ARBfp1.0\n");
5281     shader_addline(&buffer, "TEMP luminance;\n");
5282     shader_addline(&buffer, "TEMP temp;\n");
5283     shader_addline(&buffer, "TEMP chroma;\n");
5284     shader_addline(&buffer, "TEMP texcrd;\n");
5285     shader_addline(&buffer, "TEMP texcrd2;\n");
5286     shader_addline(&buffer, "PARAM coef = {1.0, 0.5, 2.0, 0.25};\n");
5287     shader_addline(&buffer, "PARAM yuv_coef = {1.403, 0.344, 0.714, 1.770};\n");
5288     shader_addline(&buffer, "PARAM size = program.local[0];\n");
5289
5290     switch (yuv_fixup)
5291     {
5292         case YUV_FIXUP_UYVY:
5293         case YUV_FIXUP_YUY2:
5294             if (!gen_planar_yuv_read(&buffer, yuv_fixup, textype, &luminance_component))
5295             {
5296                 shader_buffer_free(&buffer);
5297                 return 0;
5298             }
5299             break;
5300
5301         case YUV_FIXUP_YV12:
5302             if (!gen_yv12_read(&buffer, textype, &luminance_component))
5303             {
5304                 shader_buffer_free(&buffer);
5305                 return 0;
5306             }
5307             break;
5308
5309         default:
5310             FIXME("Unsupported YUV fixup %#x\n", yuv_fixup);
5311             shader_buffer_free(&buffer);
5312             return 0;
5313     }
5314
5315     /* Calculate the final result. Formula is taken from
5316      * http://www.fourcc.org/fccyvrgb.php. Note that the chroma
5317      * ranges from -0.5 to 0.5
5318      */
5319     shader_addline(&buffer, "SUB chroma.xy, chroma, coef.y;\n");
5320
5321     shader_addline(&buffer, "MAD result.color.x, chroma.x, yuv_coef.x, luminance.%c;\n", luminance_component);
5322     shader_addline(&buffer, "MAD temp.x, -chroma.y, yuv_coef.y, luminance.%c;\n", luminance_component);
5323     shader_addline(&buffer, "MAD result.color.y, -chroma.x, yuv_coef.z, temp.x;\n");
5324     shader_addline(&buffer, "MAD result.color.z, chroma.y, yuv_coef.w, luminance.%c;\n", luminance_component);
5325     shader_addline(&buffer, "END\n");
5326
5327     ENTER_GL();
5328     GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(buffer.buffer), buffer.buffer));
5329
5330     if (glGetError() == GL_INVALID_OPERATION) {
5331         GLint pos;
5332         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
5333         FIXME("Fragment program error at position %d: %s\n", pos,
5334               debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
5335     }
5336     shader_buffer_free(&buffer);
5337     LEAVE_GL();
5338
5339     switch (yuv_fixup)
5340     {
5341         case YUV_FIXUP_YUY2:
5342             if (textype == GL_TEXTURE_RECTANGLE_ARB) priv->yuy2_rect_shader = shader;
5343             else priv->yuy2_2d_shader = shader;
5344             break;
5345
5346         case YUV_FIXUP_UYVY:
5347             if (textype == GL_TEXTURE_RECTANGLE_ARB) priv->uyvy_rect_shader = shader;
5348             else priv->uyvy_2d_shader = shader;
5349             break;
5350
5351         case YUV_FIXUP_YV12:
5352             if (textype == GL_TEXTURE_RECTANGLE_ARB) priv->yv12_rect_shader = shader;
5353             else priv->yv12_2d_shader = shader;
5354             break;
5355     }
5356
5357     return shader;
5358 }
5359
5360 static HRESULT arbfp_blit_set(IWineD3DDevice *iface, const struct GlPixelFormatDesc *format_desc,
5361         GLenum textype, UINT width, UINT height)
5362 {
5363     GLenum shader;
5364     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
5365     float size[4] = {width, height, 1, 1};
5366     struct arbfp_blit_priv *priv = device->blit_priv;
5367     enum yuv_fixup yuv_fixup;
5368
5369     if (!is_yuv_fixup(format_desc->color_fixup))
5370     {
5371         TRACE("Fixup:\n");
5372         dump_color_fixup_desc(format_desc->color_fixup);
5373         /* Don't bother setting up a shader for unconverted formats */
5374         ENTER_GL();
5375         glEnable(textype);
5376         checkGLcall("glEnable(textype)");
5377         LEAVE_GL();
5378         return WINED3D_OK;
5379     }
5380
5381     yuv_fixup = get_yuv_fixup(format_desc->color_fixup);
5382
5383     switch(yuv_fixup)
5384     {
5385         case YUV_FIXUP_YUY2:
5386             shader = textype == GL_TEXTURE_RECTANGLE_ARB ? priv->yuy2_rect_shader : priv->yuy2_2d_shader;
5387             break;
5388
5389         case YUV_FIXUP_UYVY:
5390             shader = textype == GL_TEXTURE_RECTANGLE_ARB ? priv->uyvy_rect_shader : priv->uyvy_2d_shader;
5391             break;
5392
5393         case YUV_FIXUP_YV12:
5394             shader = textype == GL_TEXTURE_RECTANGLE_ARB ? priv->yv12_rect_shader : priv->yv12_2d_shader;
5395             break;
5396
5397         default:
5398             FIXME("Unsupported YUV fixup %#x, not setting a shader\n", yuv_fixup);
5399             ENTER_GL();
5400             glEnable(textype);
5401             checkGLcall("glEnable(textype)");
5402             LEAVE_GL();
5403             return E_NOTIMPL;
5404     }
5405
5406     if (!shader) shader = gen_yuv_shader(device, yuv_fixup, textype);
5407
5408     ENTER_GL();
5409     glEnable(GL_FRAGMENT_PROGRAM_ARB);
5410     checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB)");
5411     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader));
5412     checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader)");
5413     GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0, size));
5414     checkGLcall("glProgramLocalParameter4fvARB");
5415     LEAVE_GL();
5416
5417     return WINED3D_OK;
5418 }
5419
5420 static void arbfp_blit_unset(IWineD3DDevice *iface) {
5421     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) iface;
5422
5423     ENTER_GL();
5424     glDisable(GL_FRAGMENT_PROGRAM_ARB);
5425     checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
5426     glDisable(GL_TEXTURE_2D);
5427     checkGLcall("glDisable(GL_TEXTURE_2D)");
5428     if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
5429         glDisable(GL_TEXTURE_CUBE_MAP_ARB);
5430         checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
5431     }
5432     if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
5433         glDisable(GL_TEXTURE_RECTANGLE_ARB);
5434         checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
5435     }
5436     LEAVE_GL();
5437 }
5438
5439 static BOOL arbfp_blit_color_fixup_supported(struct color_fixup_desc fixup)
5440 {
5441     enum yuv_fixup yuv_fixup;
5442
5443     if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
5444     {
5445         TRACE("Checking support for fixup:\n");
5446         dump_color_fixup_desc(fixup);
5447     }
5448
5449     if (is_identity_fixup(fixup))
5450     {
5451         TRACE("[OK]\n");
5452         return TRUE;
5453     }
5454
5455     /* We only support YUV conversions. */
5456     if (!is_yuv_fixup(fixup))
5457     {
5458         TRACE("[FAILED]\n");
5459         return FALSE;
5460     }
5461
5462     yuv_fixup = get_yuv_fixup(fixup);
5463     switch(yuv_fixup)
5464     {
5465         case YUV_FIXUP_YUY2:
5466         case YUV_FIXUP_UYVY:
5467         case YUV_FIXUP_YV12:
5468             TRACE("[OK]\n");
5469             return TRUE;
5470
5471         default:
5472             FIXME("Unsupported YUV fixup %#x\n", yuv_fixup);
5473             TRACE("[FAILED]\n");
5474             return FALSE;
5475     }
5476 }
5477
5478 const struct blit_shader arbfp_blit = {
5479     arbfp_blit_alloc,
5480     arbfp_blit_free,
5481     arbfp_blit_set,
5482     arbfp_blit_unset,
5483     arbfp_blit_color_fixup_supported,
5484 };
5485
5486 #undef GLINFO_LOCATION