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

   1 /*
   2  * GLSL pixel and vertex shader implementation
   3  *
   4  * Copyright 2006 Jason Green
   5  * Copyright 2006-2007 Henri Verbeet
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /*
  23  * D3D shader asm has swizzles on source parameters, and write masks for
  24  * destination parameters. GLSL uses swizzles for both. The result of this is
  25  * that for example "mov dst.xw, src.zyxw" becomes "dst.xw = src.zw" in GLSL.
  26  * Ie, to generate a proper GLSL source swizzle, we need to take the D3D write
  27  * mask for the destination parameter into account.
  28  */
  29
  30 #include "config.h"
  31 #include <stdio.h>
  32 #include "wined3d_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  35 WINE_DECLARE_DEBUG_CHANNEL(d3d_constants);
  36
  37 #define GLINFO_LOCATION      (*gl_info)
  38
  39 typedef struct {
  40     char reg_name[50];
  41     char mask_str[6];
  42 } glsl_dst_param_t;
  43
  44 typedef struct {
  45     char reg_name[50];
  46     char param_str[100];
  47 } glsl_src_param_t;
  48
  49 typedef struct {
  50     const char *name;
  51     DWORD coord_mask;
  52 } glsl_sample_function_t;
  53
  54 /** Prints the GLSL info log which will contain error messages if they exist */
  55 void print_glsl_info_log(WineD3D_GL_Info *gl_info, GLhandleARB obj) {
  56
  57     int infologLength = 0;
  58     char *infoLog;
  59
  60     GL_EXTCALL(glGetObjectParameterivARB(obj,
  61                GL_OBJECT_INFO_LOG_LENGTH_ARB,
  62                &infologLength));
  63
  64     /* A size of 1 is just a null-terminated string, so the log should be bigger than
  65      * that if there are errors. */
  66     if (infologLength > 1)
  67     {
  68         infoLog = HeapAlloc(GetProcessHeap(), 0, infologLength);
  69         GL_EXTCALL(glGetInfoLogARB(obj, infologLength, NULL, infoLog));
  70         FIXME("Error received from GLSL shader #%u: %s\n", obj, debugstr_a(infoLog));
  71         HeapFree(GetProcessHeap(), 0, infoLog);
  72     }
  73 }
  74
  75 /**
  76  * Loads (pixel shader) samplers
  77  */
  78 static void shader_glsl_load_psamplers(
  79     WineD3D_GL_Info *gl_info,
  80     IWineD3DStateBlock* iface,
  81     GLhandleARB programId) {
  82
  83     IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
  84     GLhandleARB name_loc;
  85     int i;
  86     char sampler_name[20];
  87
  88     for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
  89         snprintf(sampler_name, sizeof(sampler_name), "Psampler%d", i);
  90         name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
  91         if (name_loc != -1) {
  92             int mapped_unit = stateBlock->wineD3DDevice->texUnitMap[i];
  93             if (mapped_unit != -1 && mapped_unit < GL_LIMITS(fragment_samplers)) {
  94                 TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
  95                 GL_EXTCALL(glUniform1iARB(name_loc, mapped_unit));
  96                 checkGLcall("glUniform1iARB");
  97             } else {
  98                 ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
  99             }
 100         }
 101     }
 102 }
 103
 104 static void shader_glsl_load_vsamplers(WineD3D_GL_Info *gl_info, IWineD3DStateBlock* iface, GLhandleARB programId) {
 105     IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
 106     GLhandleARB name_loc;
 107     char sampler_name[20];
 108     int i;
 109
 110     for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
 111         snprintf(sampler_name, sizeof(sampler_name), "Vsampler%d", i);
 112         name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
 113         if (name_loc != -1) {
 114             int mapped_unit = stateBlock->wineD3DDevice->texUnitMap[MAX_FRAGMENT_SAMPLERS + i];
 115             if (mapped_unit != -1 && mapped_unit < GL_LIMITS(combined_samplers)) {
 116                 TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
 117                 GL_EXTCALL(glUniform1iARB(name_loc, mapped_unit));
 118                 checkGLcall("glUniform1iARB");
 119             } else {
 120                 ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
 121             }
 122         }
 123     }
 124 }
 125
 126 /**
 127  * Loads floating point constants (aka uniforms) into the currently set GLSL program.
 128  * When constant_list == NULL, it will load all the constants.
 129  */
 130 static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL_Info *gl_info,
 131         unsigned int max_constants, float* constants, GLhandleARB *constant_locations,
 132         struct list *constant_list) {
 133     constants_entry *constant;
 134     local_constant* lconst;
 135     GLhandleARB tmp_loc;
 136     DWORD i, j, k;
 137     DWORD *idx;
 138
 139     if (TRACE_ON(d3d_shader)) {
 140         LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
 141             idx = constant->idx;
 142             j = constant->count;
 143             while (j--) {
 144                 i = *idx++;
 145                 tmp_loc = constant_locations[i];
 146                 if (tmp_loc != -1) {
 147                     TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i,
 148                             constants[i * 4 + 0], constants[i * 4 + 1],
 149                             constants[i * 4 + 2], constants[i * 4 + 3]);
 150                 }
 151             }
 152         }
 153     }
 154
 155     /* 1.X pshaders have the constants clamped to [-1;1] implicitly. */
 156     if(WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
 157        shader_is_pshader_version(This->baseShader.hex_version)) {
 158         float lcl_const[4];
 159
 160         LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
 161             idx = constant->idx;
 162             j = constant->count;
 163             while (j--) {
 164                 i = *idx++;
 165                 tmp_loc = constant_locations[i];
 166                 if (tmp_loc != -1) {
 167                     /* We found this uniform name in the program - go ahead and send the data */
 168                     k = i * 4;
 169                     if(constants[k + 0] < -1.0) lcl_const[0] = -1.0;
 170                     else if(constants[k + 0] > 1.0) lcl_const[0] = 1.0;
 171                     else lcl_const[0] = constants[k + 0];
 172                     if(constants[k + 1] < -1.0) lcl_const[1] = -1.0;
 173                     else if(constants[k + 1] > 1.0) lcl_const[1] = 1.0;
 174                     else lcl_const[1] = constants[k + 1];
 175                     if(constants[k + 2] < -1.0) lcl_const[2] = -1.0;
 176                     else if(constants[k + 2] > 1.0) lcl_const[2] = 1.0;
 177                     else lcl_const[2] = constants[k + 2];
 178                     if(constants[k + 3] < -1.0) lcl_const[3] = -1.0;
 179                     else if(constants[k + 3] > 1.0) lcl_const[3] = 1.0;
 180                     else lcl_const[3] = constants[k + 3];
 181
 182                     GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, lcl_const));
 183                 }
 184             }
 185         }
 186     } else {
 187         LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
 188             idx = constant->idx;
 189             j = constant->count;
 190             while (j--) {
 191                 i = *idx++;
 192                 tmp_loc = constant_locations[i];
 193                 if (tmp_loc != -1) {
 194                     /* We found this uniform name in the program - go ahead and send the data */
 195                     GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, constants + (i * 4)));
 196                 }
 197             }
 198         }
 199     }
 200     checkGLcall("glUniform4fvARB()");
 201
 202     if(!This->baseShader.load_local_constsF) {
 203         TRACE("No need to load local float constants for this shader\n");
 204         return;
 205     }
 206
 207     /* Load immediate constants */
 208     if (TRACE_ON(d3d_shader)) {
 209         LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 210             tmp_loc = constant_locations[lconst->idx];
 211             if (tmp_loc != -1) {
 212                 GLfloat* values = (GLfloat*)lconst->value;
 213                 TRACE_(d3d_constants)("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
 214                         values[0], values[1], values[2], values[3]);
 215             }
 216         }
 217     }
 218     /* Immediate constants are clamped to [-1;1] at shader creation time if needed */
 219     LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 220         tmp_loc = constant_locations[lconst->idx];
 221         if (tmp_loc != -1) {
 222             /* We found this uniform name in the program - go ahead and send the data */
 223             GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, (GLfloat*)lconst->value));
 224         }
 225     }
 226     checkGLcall("glUniform4fvARB()");
 227 }
 228
 229 /**
 230  * Loads integer constants (aka uniforms) into the currently set GLSL program.
 231  * When @constants_set == NULL, it will load all the constants.
 232  */
 233 static void shader_glsl_load_constantsI(
 234     IWineD3DBaseShaderImpl* This,
 235     WineD3D_GL_Info *gl_info,
 236     GLhandleARB programId,
 237     GLhandleARB locations[MAX_CONST_I],
 238     unsigned max_constants,
 239     int* constants,
 240     BOOL* constants_set) {
 241
 242     int i;
 243     struct list* ptr;
 244
 245     for (i=0; i<max_constants; ++i) {
 246         if (NULL == constants_set || constants_set[i]) {
 247
 248             TRACE_(d3d_constants)("Loading constants %i: %i, %i, %i, %i\n",
 249                   i, constants[i*4], constants[i*4+1], constants[i*4+2], constants[i*4+3]);
 250
 251             /* We found this uniform name in the program - go ahead and send the data */
 252             GL_EXTCALL(glUniform4ivARB(locations[i], 1, &constants[i*4]));
 253             checkGLcall("glUniform4ivARB");
 254         }
 255     }
 256
 257     /* Load immediate constants */
 258     ptr = list_head(&This->baseShader.constantsI);
 259     while (ptr) {
 260         local_constant* lconst = LIST_ENTRY(ptr, struct local_constant, entry);
 261         unsigned int idx = lconst->idx;
 262         GLint* values = (GLint*) lconst->value;
 263
 264         TRACE_(d3d_constants)("Loading local constants %i: %i, %i, %i, %i\n", idx,
 265             values[0], values[1], values[2], values[3]);
 266
 267         /* We found this uniform name in the program - go ahead and send the data */
 268         GL_EXTCALL(glUniform4ivARB(locations[idx], 1, values));
 269         checkGLcall("glUniform4ivARB");
 270         ptr = list_next(&This->baseShader.constantsI, ptr);
 271     }
 272 }
 273
 274 /**
 275  * Loads boolean constants (aka uniforms) into the currently set GLSL program.
 276  * When @constants_set == NULL, it will load all the constants.
 277  */
 278 static void shader_glsl_load_constantsB(
 279     IWineD3DBaseShaderImpl* This,
 280     WineD3D_GL_Info *gl_info,
 281     GLhandleARB programId,
 282     unsigned max_constants,
 283     BOOL* constants,
 284     BOOL* constants_set) {
 285
 286     GLhandleARB tmp_loc;
 287     int i;
 288     char tmp_name[8];
 289     char is_pshader = shader_is_pshader_version(This->baseShader.hex_version);
 290     const char* prefix = is_pshader? "PB":"VB";
 291     struct list* ptr;
 292
 293     for (i=0; i<max_constants; ++i) {
 294         if (NULL == constants_set || constants_set[i]) {
 295
 296             TRACE_(d3d_constants)("Loading constants %i: %i;\n", i, constants[i]);
 297
 298             /* TODO: Benchmark and see if it would be beneficial to store the
 299              * locations of the constants to avoid looking up each time */
 300             snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i);
 301             tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 302             if (tmp_loc != -1) {
 303                 /* We found this uniform name in the program - go ahead and send the data */
 304                 GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, &constants[i]));
 305                 checkGLcall("glUniform1ivARB");
 306             }
 307         }
 308     }
 309
 310     /* Load immediate constants */
 311     ptr = list_head(&This->baseShader.constantsB);
 312     while (ptr) {
 313         local_constant* lconst = LIST_ENTRY(ptr, struct local_constant, entry);
 314         unsigned int idx = lconst->idx;
 315         GLint* values = (GLint*) lconst->value;
 316
 317         TRACE_(d3d_constants)("Loading local constants %i: %i\n", idx, values[0]);
 318
 319         snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, idx);
 320         tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 321         if (tmp_loc != -1) {
 322             /* We found this uniform name in the program - go ahead and send the data */
 323             GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, values));
 324             checkGLcall("glUniform1ivARB");
 325         }
 326         ptr = list_next(&This->baseShader.constantsB, ptr);
 327     }
 328 }
 329
 330
 331
 332 /**
 333  * Loads the app-supplied constants into the currently set GLSL program.
 334  */
 335 void shader_glsl_load_constants(
 336     IWineD3DDevice* device,
 337     char usePixelShader,
 338     char useVertexShader) {
 339
 340     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device;
 341     IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
 342     WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
 343
 344     GLhandleARB *constant_locations;
 345     struct list *constant_list;
 346     GLhandleARB programId;
 347     struct glsl_shader_prog_link *prog = stateBlock->glsl_program;
 348
 349     if (!prog) {
 350         /* No GLSL program set - nothing to do. */
 351         return;
 352     }
 353     programId = prog->programId;
 354
 355     if (useVertexShader) {
 356         IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
 357
 358         constant_locations = prog->vuniformF_locations;
 359         constant_list = &stateBlock->set_vconstantsF;
 360
 361         /* Load DirectX 9 float constants/uniforms for vertex shader */
 362         shader_glsl_load_constantsF(vshader, gl_info, GL_LIMITS(vshader_constantsF),
 363                 stateBlock->vertexShaderConstantF, constant_locations, constant_list);
 364
 365         /* Load DirectX 9 integer constants/uniforms for vertex shader */
 366         shader_glsl_load_constantsI(vshader, gl_info, programId,
 367                                     prog->vuniformI_locations, MAX_CONST_I,
 368                                     stateBlock->vertexShaderConstantI,
 369                                     stateBlock->changed.vertexShaderConstantsI);
 370
 371         /* Load DirectX 9 boolean constants/uniforms for vertex shader */
 372         shader_glsl_load_constantsB(vshader, gl_info, programId, MAX_CONST_B,
 373                                     stateBlock->vertexShaderConstantB,
 374                                     stateBlock->changed.vertexShaderConstantsB);
 375
 376         /* Upload the position fixup params */
 377         GL_EXTCALL(glUniform4fvARB(prog->posFixup_location, 1, &deviceImpl->posFixup[0]));
 378         checkGLcall("glUniform4fvARB");
 379     }
 380
 381     if (usePixelShader) {
 382
 383         IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
 384
 385         constant_locations = prog->puniformF_locations;
 386         constant_list = &stateBlock->set_pconstantsF;
 387
 388         /* Load DirectX 9 float constants/uniforms for pixel shader */
 389         shader_glsl_load_constantsF(pshader, gl_info, GL_LIMITS(pshader_constantsF),
 390                 stateBlock->pixelShaderConstantF, constant_locations, constant_list);
 391
 392         /* Load DirectX 9 integer constants/uniforms for pixel shader */
 393         shader_glsl_load_constantsI(pshader, gl_info, programId,
 394                                     prog->puniformI_locations, MAX_CONST_I,
 395                                     stateBlock->pixelShaderConstantI,
 396                                     stateBlock->changed.pixelShaderConstantsI);
 397
 398         /* Load DirectX 9 boolean constants/uniforms for pixel shader */
 399         shader_glsl_load_constantsB(pshader, gl_info, programId, MAX_CONST_B,
 400                                     stateBlock->pixelShaderConstantB,
 401                                     stateBlock->changed.pixelShaderConstantsB);
 402
 403         /* Upload the environment bump map matrix if needed. The needsbumpmat member specifies the texture stage to load the matrix from.
 404          * It can't be 0 for a valid texbem instruction.
 405          */
 406         if(((IWineD3DPixelShaderImpl *) pshader)->needsbumpmat != -1) {
 407             float *data = (float *) &stateBlock->textureState[(int) ((IWineD3DPixelShaderImpl *) pshader)->needsbumpmat][WINED3DTSS_BUMPENVMAT00];
 408             GL_EXTCALL(glUniformMatrix2fvARB(prog->bumpenvmat_location, 1, 0, data));
 409             checkGLcall("glUniformMatrix2fvARB");
 410
 411             /* texbeml needs the luminance scale and offset too. If texbeml is used, needsbumpmat
 412              * is set too, so we can check that in the needsbumpmat check
 413              */
 414             if(((IWineD3DPixelShaderImpl *) pshader)->baseShader.reg_maps.luminanceparams != -1) {
 415                 int stage = ((IWineD3DPixelShaderImpl *) pshader)->baseShader.reg_maps.luminanceparams;
 416                 GLfloat *scale = (GLfloat *) &stateBlock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
 417                 GLfloat *offset = (GLfloat *) &stateBlock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
 418
 419                 GL_EXTCALL(glUniform1fvARB(prog->luminancescale_location, 1, scale));
 420                 checkGLcall("glUniform1fvARB");
 421                 GL_EXTCALL(glUniform1fvARB(prog->luminanceoffset_location, 1, offset));
 422                 checkGLcall("glUniform1fvARB");
 423             }
 424         } else if(((IWineD3DPixelShaderImpl *) pshader)->srgb_enabled &&
 425                   !((IWineD3DPixelShaderImpl *) pshader)->srgb_mode_hardcoded) {
 426             float comparison[4];
 427             float mul_low[4];
 428
 429             if(stateBlock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
 430                 comparison[0] = srgb_cmp; comparison[1] = srgb_cmp;
 431                 comparison[2] = srgb_cmp; comparison[3] = srgb_cmp;
 432
 433                 mul_low[0] = srgb_mul_low; mul_low[1] = srgb_mul_low;
 434                 mul_low[2] = srgb_mul_low; mul_low[3] = srgb_mul_low;
 435             } else {
 436                 comparison[0] = 1.0 / 0.0; comparison[1] = 1.0 / 0.0;
 437                 comparison[2] = 1.0 / 0.0; comparison[3] = 1.0 / 0.0;
 438
 439                 mul_low[0] = 1.0; mul_low[1] = 1.0;
 440                 mul_low[2] = 1.0; mul_low[3] = 1.0;
 441             }
 442
 443             GL_EXTCALL(glUniform4fvARB(prog->srgb_comparison_location, 1, comparison));
 444             GL_EXTCALL(glUniform4fvARB(prog->srgb_mul_low_location, 1, mul_low));
 445         }
 446         if(((IWineD3DPixelShaderImpl *) pshader)->vpos_uniform) {
 447             float correction_params[4];
 448             if(deviceImpl->render_offscreen) {
 449                 correction_params[0] = 0.0;
 450                 correction_params[1] = 1.0;
 451             } else {
 452                 /* position is window relative, not viewport relative */
 453                 correction_params[0] = ((IWineD3DSurfaceImpl *) deviceImpl->render_targets[0])->currentDesc.Height;
 454                 correction_params[1] = -1.0;
 455             }
 456             GL_EXTCALL(glUniform4fvARB(prog->ycorrection_location, 1, correction_params));
 457         }
 458     }
 459 }
 460
 461 /** Generate the variable & register declarations for the GLSL output target */
 462 void shader_generate_glsl_declarations(
 463     IWineD3DBaseShader *iface,
 464     shader_reg_maps* reg_maps,
 465     SHADER_BUFFER* buffer,
 466     WineD3D_GL_Info* gl_info) {
 467
 468     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 469     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
 470     int i;
 471     unsigned int extra_constants_needed = 0;
 472     local_constant* lconst;
 473
 474     /* There are some minor differences between pixel and vertex shaders */
 475     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 476     char prefix = pshader ? 'P' : 'V';
 477
 478     /* Prototype the subroutines */
 479     for (i = 0; i < This->baseShader.limits.label; i++) {
 480         if (reg_maps->labels[i])
 481             shader_addline(buffer, "void subroutine%u();\n", i);
 482     }
 483
 484     /* Declare the constants (aka uniforms) */
 485     if (This->baseShader.limits.constant_float > 0) {
 486         unsigned max_constantsF = min(This->baseShader.limits.constant_float,
 487                 (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
 488         shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF);
 489     }
 490
 491     if (This->baseShader.limits.constant_int > 0)
 492         shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, This->baseShader.limits.constant_int);
 493
 494     if (This->baseShader.limits.constant_bool > 0)
 495         shader_addline(buffer, "uniform bool %cB[%u];\n", prefix, This->baseShader.limits.constant_bool);
 496
 497     if(!pshader) {
 498         shader_addline(buffer, "uniform vec4 posFixup;\n");
 499         /* Predeclaration; This function is added at link time based on the pixel shader.
 500          * VS 3.0 shaders have an array OUT[] the shader writes to, earlier versions don't have
 501          * that. We know the input to the reorder function at vertex shader compile time, so
 502          * we can deal with that. The reorder function for a 1.x and 2.x vertex shader can just
 503          * read gl_FrontColor. The output depends on the pixel shader. The reorder function for a
 504          * 1.x and 2.x pshader or for fixed function will write gl_FrontColor, and for a 3.0 shader
 505          * it will write to the varying array. Here we depend on the shader optimizer on sorting that
 506          * out. The nvidia driver only does that if the parameter is inout instead of out, hence the
 507          * inout.
 508          */
 509         if(This->baseShader.hex_version >= WINED3DVS_VERSION(3, 0)) {
 510             shader_addline(buffer, "void order_ps_input(in vec4[%u]);\n", MAX_REG_OUTPUT);
 511         } else {
 512             shader_addline(buffer, "void order_ps_input();\n");
 513         }
 514     } else {
 515         IWineD3DPixelShaderImpl *ps_impl = (IWineD3DPixelShaderImpl *) This;
 516
 517         if(reg_maps->bumpmat != -1) {
 518             shader_addline(buffer, "uniform mat2 bumpenvmat;\n");
 519             if(reg_maps->luminanceparams) {
 520                 shader_addline(buffer, "uniform float luminancescale;\n");
 521                 shader_addline(buffer, "uniform float luminanceoffset;\n");
 522                 extra_constants_needed++;
 523             }
 524             extra_constants_needed++;
 525         }
 526
 527         if(device->stateBlock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
 528             ps_impl->srgb_enabled = 1;
 529             if(This->baseShader.limits.constant_float + extra_constants_needed + 1 < GL_LIMITS(pshader_constantsF)) {
 530                 shader_addline(buffer, "uniform vec4 srgb_mul_low;\n");
 531                 shader_addline(buffer, "uniform vec4 srgb_comparison;\n");
 532                 ps_impl->srgb_mode_hardcoded = 0;
 533                 extra_constants_needed++;
 534             } else {
 535                 ps_impl->srgb_mode_hardcoded = 1;
 536                 shader_addline(buffer, "const vec4 srgb_mul_low = vec4(%f, %f, %f, %f);\n",
 537                                srgb_mul_low, srgb_mul_low, srgb_mul_low, srgb_mul_low);
 538                 shader_addline(buffer, "const vec4 srgb_comparison = vec4(%f, %f, %f, %f);\n",
 539                                srgb_cmp, srgb_cmp, srgb_cmp, srgb_cmp);
 540             }
 541         } else {
 542             IWineD3DPixelShaderImpl *ps_impl = (IWineD3DPixelShaderImpl *) This;
 543
 544             /* Do not write any srgb fixup into the shader to save shader size and processing time.
 545              * As a consequence, we can't toggle srgb write on without recompilation
 546              */
 547             ps_impl->srgb_enabled = 0;
 548             ps_impl->srgb_mode_hardcoded = 1;
 549         }
 550         if(reg_maps->vpos || reg_maps->usesdsy) {
 551             if(This->baseShader.limits.constant_float + extra_constants_needed + 1 < GL_LIMITS(pshader_constantsF)) {
 552                 shader_addline(buffer, "uniform vec4 ycorrection;\n");
 553                 ((IWineD3DPixelShaderImpl *) This)->vpos_uniform = 1;
 554                 extra_constants_needed++;
 555             } else {
 556                 /* This happens because we do not have proper tracking of the constant registers that are
 557                  * actually used, only the max limit of the shader version
 558                  */
 559                 FIXME("Cannot find a free uniform for vpos correction params\n");
 560                 shader_addline(buffer, "const vec4 ycorrection = vec4(%f, %f, 0.0, 0.0);\n",
 561                                device->render_offscreen ? 0.0 : ((IWineD3DSurfaceImpl *) device->render_targets[0])->currentDesc.Height,
 562                                device->render_offscreen ? 1.0 : -1.0);
 563             }
 564             shader_addline(buffer, "vec4 vpos;\n");
 565         }
 566     }
 567
 568     /* Declare texture samplers */
 569     for (i = 0; i < This->baseShader.limits.sampler; i++) {
 570         if (reg_maps->samplers[i]) {
 571
 572             DWORD stype = reg_maps->samplers[i] & WINED3DSP_TEXTURETYPE_MASK;
 573             switch (stype) {
 574
 575                 case WINED3DSTT_1D:
 576                     shader_addline(buffer, "uniform sampler1D %csampler%u;\n", prefix, i);
 577                     break;
 578                 case WINED3DSTT_2D:
 579                     if(device->stateBlock->textures[i] &&
 580                        IWineD3DBaseTexture_GetTextureDimensions(device->stateBlock->textures[i]) == GL_TEXTURE_RECTANGLE_ARB) {
 581                         shader_addline(buffer, "uniform sampler2DRect %csampler%u;\n", prefix, i);
 582                     } else {
 583                         shader_addline(buffer, "uniform sampler2D %csampler%u;\n", prefix, i);
 584                     }
 585                     break;
 586                 case WINED3DSTT_CUBE:
 587                     shader_addline(buffer, "uniform samplerCube %csampler%u;\n", prefix, i);
 588                     break;
 589                 case WINED3DSTT_VOLUME:
 590                     shader_addline(buffer, "uniform sampler3D %csampler%u;\n", prefix, i);
 591                     break;
 592                 default:
 593                     shader_addline(buffer, "uniform unsupported_sampler %csampler%u;\n", prefix, i);
 594                     FIXME("Unrecognized sampler type: %#x\n", stype);
 595                     break;
 596             }
 597         }
 598     }
 599
 600     /* Declare address variables */
 601     for (i = 0; i < This->baseShader.limits.address; i++) {
 602         if (reg_maps->address[i])
 603             shader_addline(buffer, "ivec4 A%d;\n", i);
 604     }
 605
 606     /* Declare texture coordinate temporaries and initialize them */
 607     for (i = 0; i < This->baseShader.limits.texcoord; i++) {
 608         if (reg_maps->texcoord[i])
 609             shader_addline(buffer, "vec4 T%u = gl_TexCoord[%u];\n", i, i);
 610     }
 611
 612     /* Declare input register varyings. Only pixel shader, vertex shaders have that declared in the
 613      * helper function shader that is linked in at link time
 614      */
 615     if(pshader && This->baseShader.hex_version >= WINED3DVS_VERSION(3, 0)) {
 616         if(use_vs(device)) {
 617             shader_addline(buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
 618         } else {
 619             /* TODO: Write a replacement shader for the fixed function vertex pipeline, so this isn't needed.
 620              * For fixed function vertex processing + 3.0 pixel shader we need a separate function in the
 621              * pixel shader that reads the fixed function color into the packed input registers.
 622              */
 623             shader_addline(buffer, "vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
 624         }
 625     }
 626
 627     /* Declare output register temporaries */
 628     if(This->baseShader.limits.packed_output) {
 629         shader_addline(buffer, "vec4 OUT[%u];\n", This->baseShader.limits.packed_output);
 630     }
 631
 632     /* Declare temporary variables */
 633     for(i = 0; i < This->baseShader.limits.temporary; i++) {
 634         if (reg_maps->temporary[i])
 635             shader_addline(buffer, "vec4 R%u;\n", i);
 636     }
 637
 638     /* Declare attributes */
 639     for (i = 0; i < This->baseShader.limits.attributes; i++) {
 640         if (reg_maps->attributes[i])
 641             shader_addline(buffer, "attribute vec4 attrib%i;\n", i);
 642     }
 643
 644     /* Declare loop registers aLx */
 645     for (i = 0; i < reg_maps->loop_depth; i++) {
 646         shader_addline(buffer, "int aL%u;\n", i);
 647         shader_addline(buffer, "int tmpInt%u;\n", i);
 648     }
 649
 650     /* Temporary variables for matrix operations */
 651     shader_addline(buffer, "vec4 tmp0;\n");
 652     shader_addline(buffer, "vec4 tmp1;\n");
 653
 654     /* Hardcodeable local constants */
 655     if(!This->baseShader.load_local_constsF) {
 656         LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 657             float *value = (float *) lconst->value;
 658             shader_addline(buffer, "const vec4 LC%u = vec4(%f, %f, %f, %f);\n", lconst->idx,
 659                            value[0], value[1], value[2], value[3]);
 660         }
 661     }
 662
 663     /* Start the main program */
 664     shader_addline(buffer, "void main() {\n");
 665     if(pshader && reg_maps->vpos) {
 666         shader_addline(buffer, "vpos = vec4(0, ycorrection[0], 0, 0) + gl_FragCoord * vec4(1, ycorrection[1], 1, 1) - 0.5;\n");
 667     }
 668 }
 669
 670 /*****************************************************************************
 671  * Functions to generate GLSL strings from DirectX Shader bytecode begin here.
 672  *
 673  * For more information, see http://wiki.winehq.org/DirectX-Shaders
 674  ****************************************************************************/
 675
 676 /* Prototypes */
 677 static void shader_glsl_add_src_param(SHADER_OPCODE_ARG* arg, const DWORD param,
 678         const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param);
 679
 680 /** Used for opcode modifiers - They multiply the result by the specified amount */
 681 static const char * const shift_glsl_tab[] = {
 682     "",           /*  0 (none) */
 683     "2.0 * ",     /*  1 (x2)   */
 684     "4.0 * ",     /*  2 (x4)   */
 685     "8.0 * ",     /*  3 (x8)   */
 686     "16.0 * ",    /*  4 (x16)  */
 687     "32.0 * ",    /*  5 (x32)  */
 688     "",           /*  6 (x64)  */
 689     "",           /*  7 (x128) */
 690     "",           /*  8 (d256) */
 691     "",           /*  9 (d128) */
 692     "",           /* 10 (d64)  */
 693     "",           /* 11 (d32)  */
 694     "0.0625 * ",  /* 12 (d16)  */
 695     "0.125 * ",   /* 13 (d8)   */
 696     "0.25 * ",    /* 14 (d4)   */
 697     "0.5 * "      /* 15 (d2)   */
 698 };
 699
 700 /* Generate a GLSL parameter that does the input modifier computation and return the input register/mask to use */
 701 static void shader_glsl_gen_modifier (
 702     const DWORD instr,
 703     const char *in_reg,
 704     const char *in_regswizzle,
 705     char *out_str) {
 706
 707     out_str[0] = 0;
 708
 709     if (instr == WINED3DSIO_TEXKILL)
 710         return;
 711
 712     switch (instr & WINED3DSP_SRCMOD_MASK) {
 713     case WINED3DSPSM_DZ: /* Need to handle this in the instructions itself (texld & texcrd). */
 714     case WINED3DSPSM_DW:
 715     case WINED3DSPSM_NONE:
 716         sprintf(out_str, "%s%s", in_reg, in_regswizzle);
 717         break;
 718     case WINED3DSPSM_NEG:
 719         sprintf(out_str, "-%s%s", in_reg, in_regswizzle);
 720         break;
 721     case WINED3DSPSM_NOT:
 722         sprintf(out_str, "!%s%s", in_reg, in_regswizzle);
 723         break;
 724     case WINED3DSPSM_BIAS:
 725         sprintf(out_str, "(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
 726         break;
 727     case WINED3DSPSM_BIASNEG:
 728         sprintf(out_str, "-(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
 729         break;
 730     case WINED3DSPSM_SIGN:
 731         sprintf(out_str, "(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
 732         break;
 733     case WINED3DSPSM_SIGNNEG:
 734         sprintf(out_str, "-(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
 735         break;
 736     case WINED3DSPSM_COMP:
 737         sprintf(out_str, "(1.0 - %s%s)", in_reg, in_regswizzle);
 738         break;
 739     case WINED3DSPSM_X2:
 740         sprintf(out_str, "(2.0 * %s%s)", in_reg, in_regswizzle);
 741         break;
 742     case WINED3DSPSM_X2NEG:
 743         sprintf(out_str, "-(2.0 * %s%s)", in_reg, in_regswizzle);
 744         break;
 745     case WINED3DSPSM_ABS:
 746         sprintf(out_str, "abs(%s%s)", in_reg, in_regswizzle);
 747         break;
 748     case WINED3DSPSM_ABSNEG:
 749         sprintf(out_str, "-abs(%s%s)", in_reg, in_regswizzle);
 750         break;
 751     default:
 752         FIXME("Unhandled modifier %u\n", (instr & WINED3DSP_SRCMOD_MASK));
 753         sprintf(out_str, "%s%s", in_reg, in_regswizzle);
 754     }
 755 }
 756
 757 static BOOL constant_is_local(IWineD3DBaseShaderImpl* This, DWORD reg) {
 758     local_constant* lconst;
 759
 760     if(This->baseShader.load_local_constsF) return FALSE;
 761     LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 762         if(lconst->idx == reg) return TRUE;
 763     }
 764     return FALSE;
 765
 766 }
 767
 768 /** Writes the GLSL variable name that corresponds to the register that the
 769  * DX opcode parameter is trying to access */
 770 static void shader_glsl_get_register_name(
 771     const DWORD param,
 772     const DWORD addr_token,
 773     char* regstr,
 774     BOOL* is_color,
 775     SHADER_OPCODE_ARG* arg) {
 776
 777     /* oPos, oFog and oPts in D3D */
 778     static const char * const hwrastout_reg_names[] = { "gl_Position", "gl_FogFragCoord", "gl_PointSize" };
 779
 780     DWORD reg = param & WINED3DSP_REGNUM_MASK;
 781     DWORD regtype = shader_get_regtype(param);
 782     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) arg->shader;
 783     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
 784     WineD3D_GL_Info* gl_info = &deviceImpl->adapter->gl_info;
 785
 786     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 787     char tmpStr[50];
 788
 789     *is_color = FALSE;
 790
 791     switch (regtype) {
 792     case WINED3DSPR_TEMP:
 793         sprintf(tmpStr, "R%u", reg);
 794     break;
 795     case WINED3DSPR_INPUT:
 796         if (pshader) {
 797             /* Pixel shaders >= 3.0 */
 798             if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3) {
 799                 if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
 800                     glsl_src_param_t rel_param;
 801                     shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
 802
 803                     /* Removing a + 0 would be an obvious optimization, but macos doesn't see the NOP
 804                      * operation there
 805                      */
 806                     if(((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg]) {
 807                         sprintf(tmpStr, "IN[%s + %u]", rel_param.param_str,
 808                                 ((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg]);
 809                     } else {
 810                         sprintf(tmpStr, "IN[%s]", rel_param.param_str);
 811                     }
 812                 } else {
 813                     sprintf(tmpStr, "IN[%u]",
 814                             ((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg]);
 815                 }
 816             } else {
 817                 if (reg==0)
 818                     strcpy(tmpStr, "gl_Color");
 819                 else
 820                     strcpy(tmpStr, "gl_SecondaryColor");
 821             }
 822         } else {
 823             if (vshader_input_is_color((IWineD3DVertexShader*) This, reg))
 824                *is_color = TRUE;
 825             sprintf(tmpStr, "attrib%u", reg);
 826         }
 827         break;
 828     case WINED3DSPR_CONST:
 829     {
 830         const char* prefix = pshader? "PC":"VC";
 831
 832         /* Relative addressing */
 833         if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
 834
 835            /* Relative addressing on shaders 2.0+ have a relative address token,
 836             * prior to that, it was hard-coded as "A0.x" because there's only 1 register */
 837            if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2)  {
 838                glsl_src_param_t rel_param;
 839                shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
 840                if(reg) {
 841                    sprintf(tmpStr, "%s[%s + %u]", prefix, rel_param.param_str, reg);
 842                } else {
 843                    sprintf(tmpStr, "%s[%s]", prefix, rel_param.param_str);
 844                }
 845            } else {
 846                if(reg) {
 847                    sprintf(tmpStr, "%s[A0.x + %u]", prefix, reg);
 848                } else {
 849                    sprintf(tmpStr, "%s[A0.x]", prefix);
 850                }
 851            }
 852
 853         } else {
 854             if(constant_is_local(This, reg)) {
 855                 sprintf(tmpStr, "LC%u", reg);
 856             } else {
 857                 sprintf(tmpStr, "%s[%u]", prefix, reg);
 858             }
 859         }
 860
 861         break;
 862     }
 863     case WINED3DSPR_CONSTINT:
 864         if (pshader)
 865             sprintf(tmpStr, "PI[%u]", reg);
 866         else
 867             sprintf(tmpStr, "VI[%u]", reg);
 868         break;
 869     case WINED3DSPR_CONSTBOOL:
 870         if (pshader)
 871             sprintf(tmpStr, "PB[%u]", reg);
 872         else
 873             sprintf(tmpStr, "VB[%u]", reg);
 874         break;
 875     case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
 876         if (pshader) {
 877             sprintf(tmpStr, "T%u", reg);
 878         } else {
 879             sprintf(tmpStr, "A%u", reg);
 880         }
 881     break;
 882     case WINED3DSPR_LOOP:
 883         sprintf(tmpStr, "aL%u", This->baseShader.cur_loop_regno - 1);
 884     break;
 885     case WINED3DSPR_SAMPLER:
 886         if (pshader)
 887             sprintf(tmpStr, "Psampler%u", reg);
 888         else
 889             sprintf(tmpStr, "Vsampler%u", reg);
 890     break;
 891     case WINED3DSPR_COLOROUT:
 892         if (reg >= GL_LIMITS(buffers)) {
 893             WARN("Write to render target %u, only %d supported\n", reg, 4);
 894         }
 895         if (GL_SUPPORT(ARB_DRAW_BUFFERS)) {
 896             sprintf(tmpStr, "gl_FragData[%u]", reg);
 897         } else { /* On older cards with GLSL support like the GeforceFX there's only one buffer. */
 898             sprintf(tmpStr, "gl_FragColor");
 899         }
 900     break;
 901     case WINED3DSPR_RASTOUT:
 902         sprintf(tmpStr, "%s", hwrastout_reg_names[reg]);
 903     break;
 904     case WINED3DSPR_DEPTHOUT:
 905         sprintf(tmpStr, "gl_FragDepth");
 906     break;
 907     case WINED3DSPR_ATTROUT:
 908         if (reg == 0) {
 909             sprintf(tmpStr, "gl_FrontColor");
 910         } else {
 911             sprintf(tmpStr, "gl_FrontSecondaryColor");
 912         }
 913     break;
 914     case WINED3DSPR_TEXCRDOUT:
 915         /* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
 916         if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3)
 917             sprintf(tmpStr, "OUT[%u]", reg);
 918         else
 919             sprintf(tmpStr, "gl_TexCoord[%u]", reg);
 920     break;
 921     case WINED3DSPR_MISCTYPE:
 922         if (reg == 0) {
 923             /* vPos */
 924             sprintf(tmpStr, "vpos");
 925         } else if (reg == 1){
 926             /* Note that gl_FrontFacing is a bool, while vFace is
 927              * a float for which the sign determines front/back
 928              */
 929             sprintf(tmpStr, "(gl_FrontFacing ? 1.0 : -1.0)");
 930         } else {
 931             FIXME("Unhandled misctype register %d\n", reg);
 932             sprintf(tmpStr, "unrecognized_register");
 933         }
 934         break;
 935     default:
 936         FIXME("Unhandled register name Type(%d)\n", regtype);
 937         sprintf(tmpStr, "unrecognized_register");
 938     break;
 939     }
 940
 941     strcat(regstr, tmpStr);
 942 }
 943
 944 /* Get the GLSL write mask for the destination register */
 945 static DWORD shader_glsl_get_write_mask(const DWORD param, char *write_mask) {
 946     char *ptr = write_mask;
 947     DWORD mask = param & WINED3DSP_WRITEMASK_ALL;
 948
 949     if (shader_is_scalar(param)) {
 950         mask = WINED3DSP_WRITEMASK_0;
 951     } else {
 952         *ptr++ = '.';
 953         if (param & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
 954         if (param & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
 955         if (param & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
 956         if (param & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
 957     }
 958
 959     *ptr = '\0';
 960
 961     return mask;
 962 }
 963
 964 static size_t shader_glsl_get_write_mask_size(DWORD write_mask) {
 965     size_t size = 0;
 966
 967     if (write_mask & WINED3DSP_WRITEMASK_0) ++size;
 968     if (write_mask & WINED3DSP_WRITEMASK_1) ++size;
 969     if (write_mask & WINED3DSP_WRITEMASK_2) ++size;
 970     if (write_mask & WINED3DSP_WRITEMASK_3) ++size;
 971
 972     return size;
 973 }
 974
 975 static void shader_glsl_get_swizzle(const DWORD param, BOOL fixup, DWORD mask, char *swizzle_str) {
 976     /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
 977      * but addressed as "rgba". To fix this we need to swap the register's x
 978      * and z components. */
 979     DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
 980     const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
 981     char *ptr = swizzle_str;
 982
 983     if (!shader_is_scalar(param)) {
 984         *ptr++ = '.';
 985         /* swizzle bits fields: wwzzyyxx */
 986         if (mask & WINED3DSP_WRITEMASK_0) *ptr++ = swizzle_chars[swizzle & 0x03];
 987         if (mask & WINED3DSP_WRITEMASK_1) *ptr++ = swizzle_chars[(swizzle >> 2) & 0x03];
 988         if (mask & WINED3DSP_WRITEMASK_2) *ptr++ = swizzle_chars[(swizzle >> 4) & 0x03];
 989         if (mask & WINED3DSP_WRITEMASK_3) *ptr++ = swizzle_chars[(swizzle >> 6) & 0x03];
 990     }
 991
 992     *ptr = '\0';
 993 }
 994
 995 /* From a given parameter token, generate the corresponding GLSL string.
 996  * Also, return the actual register name and swizzle in case the
 997  * caller needs this information as well. */
 998 static void shader_glsl_add_src_param(SHADER_OPCODE_ARG* arg, const DWORD param,
 999         const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param) {
1000     BOOL is_color = FALSE;
1001     char swizzle_str[6];
1002
1003     src_param->reg_name[0] = '\0';
1004     src_param->param_str[0] = '\0';
1005     swizzle_str[0] = '\0';
1006
1007     shader_glsl_get_register_name(param, addr_token, src_param->reg_name, &is_color, arg);
1008
1009     shader_glsl_get_swizzle(param, is_color, mask, swizzle_str);
1010     shader_glsl_gen_modifier(param, src_param->reg_name, swizzle_str, src_param->param_str);
1011 }
1012
1013 /* From a given parameter token, generate the corresponding GLSL string.
1014  * Also, return the actual register name and swizzle in case the
1015  * caller needs this information as well. */
1016 static DWORD shader_glsl_add_dst_param(SHADER_OPCODE_ARG* arg, const DWORD param,
1017         const DWORD addr_token, glsl_dst_param_t *dst_param) {
1018     BOOL is_color = FALSE;
1019
1020     dst_param->mask_str[0] = '\0';
1021     dst_param->reg_name[0] = '\0';
1022
1023     shader_glsl_get_register_name(param, addr_token, dst_param->reg_name, &is_color, arg);
1024     return shader_glsl_get_write_mask(param, dst_param->mask_str);
1025 }
1026
1027 /* Append the destination part of the instruction to the buffer, return the effective write mask */
1028 static DWORD shader_glsl_append_dst_ext(SHADER_BUFFER *buffer, SHADER_OPCODE_ARG *arg, const DWORD param) {
1029     glsl_dst_param_t dst_param;
1030     DWORD mask;
1031     int shift;
1032
1033     mask = shader_glsl_add_dst_param(arg, param, arg->dst_addr, &dst_param);
1034
1035     if(mask) {
1036         shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
1037         shader_addline(buffer, "%s%s = %s(", dst_param.reg_name, dst_param.mask_str, shift_glsl_tab[shift]);
1038     }
1039
1040     return mask;
1041 }
1042
1043 /* Append the destination part of the instruction to the buffer, return the effective write mask */
1044 static DWORD shader_glsl_append_dst(SHADER_BUFFER *buffer, SHADER_OPCODE_ARG *arg) {
1045     return shader_glsl_append_dst_ext(buffer, arg, arg->dst);
1046 }
1047
1048 /** Process GLSL instruction modifiers */
1049 void shader_glsl_add_instruction_modifiers(SHADER_OPCODE_ARG* arg) {
1050
1051     DWORD mask = arg->dst & WINED3DSP_DSTMOD_MASK;
1052
1053     if (arg->opcode->dst_token && mask != 0) {
1054         glsl_dst_param_t dst_param;
1055
1056         shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
1057
1058         if (mask & WINED3DSPDM_SATURATE) {
1059             /* _SAT means to clamp the value of the register to between 0 and 1 */
1060             shader_addline(arg->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_param.reg_name,
1061                     dst_param.mask_str, dst_param.reg_name, dst_param.mask_str);
1062         }
1063         if (mask & WINED3DSPDM_MSAMPCENTROID) {
1064             FIXME("_centroid modifier not handled\n");
1065         }
1066         if (mask & WINED3DSPDM_PARTIALPRECISION) {
1067             /* MSDN says this modifier can be safely ignored, so that's what we'll do. */
1068         }
1069     }
1070 }
1071
1072 static inline const char* shader_get_comp_op(
1073     const DWORD opcode) {
1074
1075     DWORD op = (opcode & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
1076     switch (op) {
1077         case COMPARISON_GT: return ">";
1078         case COMPARISON_EQ: return "==";
1079         case COMPARISON_GE: return ">=";
1080         case COMPARISON_LT: return "<";
1081         case COMPARISON_NE: return "!=";
1082         case COMPARISON_LE: return "<=";
1083         default:
1084             FIXME("Unrecognized comparison value: %u\n", op);
1085             return "(\?\?)";
1086     }
1087 }
1088
1089 static void shader_glsl_get_sample_function(DWORD sampler_type, BOOL projected, BOOL texrect, glsl_sample_function_t *sample_function) {
1090     /* Note that there's no such thing as a projected cube texture. */
1091     switch(sampler_type) {
1092         case WINED3DSTT_1D:
1093             sample_function->name = projected ? "texture1DProj" : "texture1D";
1094             sample_function->coord_mask = WINED3DSP_WRITEMASK_0;
1095             break;
1096         case WINED3DSTT_2D:
1097             if(texrect) {
1098                 sample_function->name = projected ? "texture2DRectProj" : "texture2DRect";
1099             } else {
1100                 sample_function->name = projected ? "texture2DProj" : "texture2D";
1101             }
1102             sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1;
1103             break;
1104         case WINED3DSTT_CUBE:
1105             sample_function->name = "textureCube";
1106             sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1107             break;
1108         case WINED3DSTT_VOLUME:
1109             sample_function->name = projected ? "texture3DProj" : "texture3D";
1110             sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1111             break;
1112         default:
1113             sample_function->name = "";
1114             FIXME("Unrecognized sampler type: %#x;\n", sampler_type);
1115             break;
1116     }
1117 }
1118
1119 static void shader_glsl_color_correction(SHADER_OPCODE_ARG* arg) {
1120     IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1121     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) shader->baseShader.device;
1122     WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
1123     glsl_dst_param_t dst_param;
1124     glsl_dst_param_t dst_param2;
1125     WINED3DFORMAT fmt;
1126     WINED3DFORMAT conversion_group;
1127     IWineD3DBaseTextureImpl *texture;
1128     DWORD mask, mask_size;
1129     UINT i;
1130     BOOL recorded = FALSE;
1131     DWORD sampler_idx;
1132     DWORD hex_version = shader->baseShader.hex_version;
1133
1134     switch(arg->opcode->opcode) {
1135         case WINED3DSIO_TEX:
1136             if (hex_version < WINED3DPS_VERSION(2,0)) {
1137                 sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
1138             } else {
1139                 sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
1140             }
1141             break;
1142
1143         case WINED3DSIO_TEXLDL:
1144             FIXME("Add color fixup for vertex texture WINED3DSIO_TEXLDL\n");
1145             return;
1146
1147         case WINED3DSIO_TEXDP3TEX:
1148         case WINED3DSIO_TEXM3x3TEX:
1149         case WINED3DSIO_TEXM3x3SPEC:
1150         case WINED3DSIO_TEXM3x3VSPEC:
1151         case WINED3DSIO_TEXBEM:
1152         case WINED3DSIO_TEXREG2AR:
1153         case WINED3DSIO_TEXREG2GB:
1154         case WINED3DSIO_TEXREG2RGB:
1155             sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
1156             break;
1157
1158         default:
1159             /* Not a texture sampling instruction, nothing to do */
1160             return;
1161     };
1162
1163     texture = (IWineD3DBaseTextureImpl *) deviceImpl->stateBlock->textures[sampler_idx];
1164     if(texture) {
1165         fmt = texture->resource.format;
1166         conversion_group = texture->baseTexture.shader_conversion_group;
1167     } else {
1168         fmt = WINED3DFMT_UNKNOWN;
1169         conversion_group = WINED3DFMT_UNKNOWN;
1170     }
1171
1172     /* before doing anything, record the sampler with the format in the format conversion list,
1173      * but check if it's not there already
1174      */
1175     for(i = 0; i < shader->baseShader.num_sampled_samplers; i++) {
1176         if(shader->baseShader.sampled_samplers[i] == sampler_idx) {
1177             recorded = TRUE;
1178             break;
1179         }
1180     }
1181     if(!recorded) {
1182         shader->baseShader.sampled_samplers[shader->baseShader.num_sampled_samplers] = sampler_idx;
1183         shader->baseShader.num_sampled_samplers++;
1184         shader->baseShader.sampled_format[sampler_idx] = conversion_group;
1185     }
1186
1187     switch(fmt) {
1188         case WINED3DFMT_V8U8:
1189         case WINED3DFMT_V16U16:
1190             if(GL_SUPPORT(NV_TEXTURE_SHADER) ||
1191               (GL_SUPPORT(ATI_ENVMAP_BUMPMAP) && fmt == WINED3DFMT_V8U8)) {
1192                 /* The 3rd channel returns 1.0 in d3d, but 0.0 in gl. Fix this while we're at it :-) */
1193                 mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_2, &dst_param);
1194                 mask_size = shader_glsl_get_write_mask_size(mask);
1195                 if(mask_size >= 3) {
1196                     shader_addline(arg->buffer, "%s.%c = 1.0;\n", dst_param.reg_name, dst_param.mask_str[3]);
1197                 }
1198             } else {
1199                 /* Correct the sign, but leave the blue as it is - it was loaded correctly already */
1200                 mask = shader_glsl_add_dst_param(arg, arg->dst,
1201                                           WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1,
1202                                           &dst_param);
1203                 mask_size = shader_glsl_get_write_mask_size(mask);
1204                 if(mask_size >= 2) {
1205                     shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
1206                     dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2],
1207                     dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2]);
1208                 } else if(mask_size == 1) {
1209                     shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n", dst_param.reg_name, dst_param.mask_str[1],
1210                     dst_param.reg_name, dst_param.mask_str[1]);
1211                 }
1212             }
1213             break;
1214
1215         case WINED3DFMT_X8L8V8U8:
1216             if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
1217                 /* Red and blue are the signed channels, fix them up; Blue(=L) is correct already,
1218                  * and a(X) is always 1.0
1219                  */
1220                 mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &dst_param);
1221                 mask_size = shader_glsl_get_write_mask_size(mask);
1222                 if(mask_size >= 2) {
1223                     shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
1224                                    dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2],
1225                                    dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2]);
1226                 } else if(mask_size == 1) {
1227                     shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n",
1228                                    dst_param.reg_name, dst_param.mask_str[1],
1229                                    dst_param.reg_name, dst_param.mask_str[1]);
1230                 }
1231             }
1232             break;
1233
1234         case WINED3DFMT_L6V5U5:
1235             if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
1236                 mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &dst_param);
1237                 mask_size = shader_glsl_get_write_mask_size(mask);
1238                 shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_2, &dst_param2);
1239                 if(mask_size >= 3) {
1240                     /* Swap y and z (U and L), and do a sign conversion on x and the new y(V and U) */
1241                     shader_addline(arg->buffer, "tmp0.g = %s.%c;\n",
1242                                    dst_param.reg_name, dst_param.mask_str[2]);
1243                     shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
1244                                    dst_param.reg_name, dst_param.mask_str[2], dst_param.mask_str[1],
1245                                    dst_param2.reg_name, dst_param.mask_str[1], dst_param.mask_str[3]);
1246                     shader_addline(arg->buffer, "%s.%c = tmp0.g;\n", dst_param.reg_name,
1247                                    dst_param.mask_str[3]);
1248                 } else if(mask_size == 2) {
1249                     /* This is bad: We have VL, but we need VU */
1250                     FIXME("2 components sampled from a converted L6V5U5 texture\n");
1251                 } else {
1252                     shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n",
1253                                    dst_param.reg_name, dst_param.mask_str[1],
1254                                    dst_param2.reg_name, dst_param.mask_str[1]);
1255                 }
1256             }
1257             break;
1258
1259         case WINED3DFMT_Q8W8V8U8:
1260             if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
1261                 /* Correct the sign in all channels. The writemask just applies as-is, no
1262                  * need for checking the mask size
1263                  */
1264                 shader_glsl_add_dst_param(arg, arg->dst,
1265                                           WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 |
1266                                           WINED3DSP_WRITEMASK_2 | WINED3DSP_WRITEMASK_3,
1267                                           &dst_param);
1268                 shader_addline(arg->buffer, "%s%s = %s%s * 2.0 - 1.0;\n", dst_param.reg_name, dst_param.mask_str,
1269                                dst_param.reg_name, dst_param.mask_str);
1270             }
1271             break;
1272
1273             /* stupid compiler */
1274         default:
1275             break;
1276     }
1277 }
1278
1279 /*****************************************************************************
1280  *
1281  * Begin processing individual instruction opcodes
1282  *
1283  ****************************************************************************/
1284
1285 /* Generate GLSL arithmetic functions (dst = src1 + src2) */
1286 void shader_glsl_arith(SHADER_OPCODE_ARG* arg) {
1287     CONST SHADER_OPCODE* curOpcode = arg->opcode;
1288     SHADER_BUFFER* buffer = arg->buffer;
1289     glsl_src_param_t src0_param;
1290     glsl_src_param_t src1_param;
1291     DWORD write_mask;
1292     char op;
1293
1294     /* Determine the GLSL operator to use based on the opcode */
1295     switch (curOpcode->opcode) {
1296         case WINED3DSIO_MUL: op = '*'; break;
1297         case WINED3DSIO_ADD: op = '+'; break;
1298         case WINED3DSIO_SUB: op = '-'; break;
1299         default:
1300             op = ' ';
1301             FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
1302             break;
1303     }
1304
1305     write_mask = shader_glsl_append_dst(buffer, arg);
1306     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1307     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1308     shader_addline(buffer, "%s %c %s);\n", src0_param.param_str, op, src1_param.param_str);
1309 }
1310
1311 /* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
1312 void shader_glsl_mov(SHADER_OPCODE_ARG* arg) {
1313     IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1314     SHADER_BUFFER* buffer = arg->buffer;
1315     glsl_src_param_t src0_param;
1316     DWORD write_mask;
1317
1318     write_mask = shader_glsl_append_dst(buffer, arg);
1319     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1320
1321     /* In vs_1_1 WINED3DSIO_MOV can write to the address register. In later
1322      * shader versions WINED3DSIO_MOVA is used for this. */
1323     if ((WINED3DSHADER_VERSION_MAJOR(shader->baseShader.hex_version) == 1 &&
1324             !shader_is_pshader_version(shader->baseShader.hex_version) &&
1325             shader_get_regtype(arg->dst) == WINED3DSPR_ADDR)) {
1326         /* This is a simple floor() */
1327         size_t mask_size = shader_glsl_get_write_mask_size(write_mask);
1328         if (mask_size > 1) {
1329             shader_addline(buffer, "ivec%d(floor(%s)));\n", mask_size, src0_param.param_str);
1330         } else {
1331             shader_addline(buffer, "int(floor(%s)));\n", src0_param.param_str);
1332         }
1333     } else if(arg->opcode->opcode == WINED3DSIO_MOVA) {
1334         /* We need to *round* to the nearest int here. */
1335         size_t mask_size = shader_glsl_get_write_mask_size(write_mask);
1336         if (mask_size > 1) {
1337             shader_addline(buffer, "ivec%d(floor(abs(%s) + vec%d(0.5)) * sign(%s)));\n", mask_size, src0_param.param_str, mask_size, src0_param.param_str);
1338         } else {
1339             shader_addline(buffer, "int(floor(abs(%s) + 0.5) * sign(%s)));\n", src0_param.param_str, src0_param.param_str);
1340         }
1341     } else {
1342         shader_addline(buffer, "%s);\n", src0_param.param_str);
1343     }
1344 }
1345
1346 /* Process the dot product operators DP3 and DP4 in GLSL (dst = dot(src0, src1)) */
1347 void shader_glsl_dot(SHADER_OPCODE_ARG* arg) {
1348     CONST SHADER_OPCODE* curOpcode = arg->opcode;
1349     SHADER_BUFFER* buffer = arg->buffer;
1350     glsl_src_param_t src0_param;
1351     glsl_src_param_t src1_param;
1352     DWORD dst_write_mask, src_write_mask;
1353     size_t dst_size = 0;
1354
1355     dst_write_mask = shader_glsl_append_dst(buffer, arg);
1356     dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
1357
1358     /* dp3 works on vec3, dp4 on vec4 */
1359     if (curOpcode->opcode == WINED3DSIO_DP4) {
1360         src_write_mask = WINED3DSP_WRITEMASK_ALL;
1361     } else {
1362         src_write_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1363     }
1364
1365     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_write_mask, &src0_param);
1366     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_write_mask, &src1_param);
1367
1368     if (dst_size > 1) {
1369         shader_addline(buffer, "vec%d(dot(%s, %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
1370     } else {
1371         shader_addline(buffer, "dot(%s, %s));\n", src0_param.param_str, src1_param.param_str);
1372     }
1373 }
1374
1375 /* Note that this instruction has some restrictions. The destination write mask
1376  * can't contain the w component, and the source swizzles have to be .xyzw */
1377 void shader_glsl_cross(SHADER_OPCODE_ARG *arg) {
1378     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1379     glsl_src_param_t src0_param;
1380     glsl_src_param_t src1_param;
1381     char dst_mask[6];
1382
1383     shader_glsl_get_write_mask(arg->dst, dst_mask);
1384     shader_glsl_append_dst(arg->buffer, arg);
1385     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
1386     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_mask, &src1_param);
1387     shader_addline(arg->buffer, "cross(%s, %s)%s);\n", src0_param.param_str, src1_param.param_str, dst_mask);
1388 }
1389
1390 /* Process the WINED3DSIO_POW instruction in GLSL (dst = |src0|^src1)
1391  * Src0 and src1 are scalars. Note that D3D uses the absolute of src0, while
1392  * GLSL uses the value as-is. */
1393 void shader_glsl_pow(SHADER_OPCODE_ARG *arg) {
1394     SHADER_BUFFER *buffer = arg->buffer;
1395     glsl_src_param_t src0_param;
1396     glsl_src_param_t src1_param;
1397     DWORD dst_write_mask;
1398     size_t dst_size;
1399
1400     dst_write_mask = shader_glsl_append_dst(buffer, arg);
1401     dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
1402
1403     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1404     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
1405
1406     if (dst_size > 1) {
1407         shader_addline(buffer, "vec%d(pow(abs(%s), %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
1408     } else {
1409         shader_addline(buffer, "pow(abs(%s), %s));\n", src0_param.param_str, src1_param.param_str);
1410     }
1411 }
1412
1413 /* Process the WINED3DSIO_LOG instruction in GLSL (dst = log2(|src0|))
1414  * Src0 is a scalar. Note that D3D uses the absolute of src0, while
1415  * GLSL uses the value as-is. */
1416 void shader_glsl_log(SHADER_OPCODE_ARG *arg) {
1417     SHADER_BUFFER *buffer = arg->buffer;
1418     glsl_src_param_t src0_param;
1419     DWORD dst_write_mask;
1420     size_t dst_size;
1421
1422     dst_write_mask = shader_glsl_append_dst(buffer, arg);
1423     dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
1424
1425     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1426
1427     if (dst_size > 1) {
1428         shader_addline(buffer, "vec%d(log2(abs(%s))));\n", dst_size, src0_param.param_str);
1429     } else {
1430         shader_addline(buffer, "log2(abs(%s)));\n", src0_param.param_str);
1431     }
1432 }
1433
1434 /* Map the opcode 1-to-1 to the GL code (arg->dst = instruction(src0, src1, ...) */
1435 void shader_glsl_map2gl(SHADER_OPCODE_ARG* arg) {
1436     CONST SHADER_OPCODE* curOpcode = arg->opcode;
1437     SHADER_BUFFER* buffer = arg->buffer;
1438     glsl_src_param_t src_param;
1439     const char *instruction;
1440     char arguments[256];
1441     DWORD write_mask;
1442     unsigned i;
1443
1444     /* Determine the GLSL function to use based on the opcode */
1445     /* TODO: Possibly make this a table for faster lookups */
1446     switch (curOpcode->opcode) {
1447         case WINED3DSIO_MIN: instruction = "min"; break;
1448         case WINED3DSIO_MAX: instruction = "max"; break;
1449         case WINED3DSIO_ABS: instruction = "abs"; break;
1450         case WINED3DSIO_FRC: instruction = "fract"; break;
1451         case WINED3DSIO_NRM: instruction = "normalize"; break;
1452         case WINED3DSIO_LOGP:
1453         case WINED3DSIO_LOG: instruction = "log2"; break;
1454         case WINED3DSIO_EXP: instruction = "exp2"; break;
1455         case WINED3DSIO_SGN: instruction = "sign"; break;
1456         case WINED3DSIO_DSX: instruction = "dFdx"; break;
1457         case WINED3DSIO_DSY: instruction = "ycorrection.y * dFdy"; break;
1458         default: instruction = "";
1459             FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
1460             break;
1461     }
1462
1463     write_mask = shader_glsl_append_dst(buffer, arg);
1464
1465     arguments[0] = '\0';
1466     if (curOpcode->num_params > 0) {
1467         shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src_param);
1468         strcat(arguments, src_param.param_str);
1469         for (i = 2; i < curOpcode->num_params; ++i) {
1470             strcat(arguments, ", ");
1471             shader_glsl_add_src_param(arg, arg->src[i-1], arg->src_addr[i-1], write_mask, &src_param);
1472             strcat(arguments, src_param.param_str);
1473         }
1474     }
1475
1476     shader_addline(buffer, "%s(%s));\n", instruction, arguments);
1477 }
1478
1479 /** Process the WINED3DSIO_EXPP instruction in GLSL:
1480  * For shader model 1.x, do the following (and honor the writemask, so use a temporary variable):
1481  *   dst.x = 2^(floor(src))
1482  *   dst.y = src - floor(src)
1483  *   dst.z = 2^src   (partial precision is allowed, but optional)
1484  *   dst.w = 1.0;
1485  * For 2.0 shaders, just do this (honoring writemask and swizzle):
1486  *   dst = 2^src;    (partial precision is allowed, but optional)
1487  */
1488 void shader_glsl_expp(SHADER_OPCODE_ARG* arg) {
1489     IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)arg->shader;
1490     glsl_src_param_t src_param;
1491
1492     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src_param);
1493
1494     if (shader->baseShader.hex_version < WINED3DPS_VERSION(2,0)) {
1495         char dst_mask[6];
1496
1497         shader_addline(arg->buffer, "tmp0.x = exp2(floor(%s));\n", src_param.param_str);
1498         shader_addline(arg->buffer, "tmp0.y = %s - floor(%s);\n", src_param.param_str, src_param.param_str);
1499         shader_addline(arg->buffer, "tmp0.z = exp2(%s);\n", src_param.param_str);
1500         shader_addline(arg->buffer, "tmp0.w = 1.0;\n");
1501
1502         shader_glsl_append_dst(arg->buffer, arg);
1503         shader_glsl_get_write_mask(arg->dst, dst_mask);
1504         shader_addline(arg->buffer, "tmp0%s);\n", dst_mask);
1505     } else {
1506         DWORD write_mask;
1507         size_t mask_size;
1508
1509         write_mask = shader_glsl_append_dst(arg->buffer, arg);
1510         mask_size = shader_glsl_get_write_mask_size(write_mask);
1511
1512         if (mask_size > 1) {
1513             shader_addline(arg->buffer, "vec%d(exp2(%s)));\n", mask_size, src_param.param_str);
1514         } else {
1515             shader_addline(arg->buffer, "exp2(%s));\n", src_param.param_str);
1516         }
1517     }
1518 }
1519
1520 /** Process the RCP (reciprocal or inverse) opcode in GLSL (dst = 1 / src) */
1521 void shader_glsl_rcp(SHADER_OPCODE_ARG* arg) {
1522     glsl_src_param_t src_param;
1523     DWORD write_mask;
1524     size_t mask_size;
1525
1526     write_mask = shader_glsl_append_dst(arg->buffer, arg);
1527     mask_size = shader_glsl_get_write_mask_size(write_mask);
1528     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
1529
1530     if (mask_size > 1) {
1531         shader_addline(arg->buffer, "vec%d(1.0 / %s));\n", mask_size, src_param.param_str);
1532     } else {
1533         shader_addline(arg->buffer, "1.0 / %s);\n", src_param.param_str);
1534     }
1535 }
1536
1537 void shader_glsl_rsq(SHADER_OPCODE_ARG* arg) {
1538     SHADER_BUFFER* buffer = arg->buffer;
1539     glsl_src_param_t src_param;
1540     DWORD write_mask;
1541     size_t mask_size;
1542
1543     write_mask = shader_glsl_append_dst(buffer, arg);
1544     mask_size = shader_glsl_get_write_mask_size(write_mask);
1545
1546     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
1547
1548     if (mask_size > 1) {
1549         shader_addline(buffer, "vec%d(inversesqrt(%s)));\n", mask_size, src_param.param_str);
1550     } else {
1551         shader_addline(buffer, "inversesqrt(%s));\n", src_param.param_str);
1552     }
1553 }
1554
1555 /** Process signed comparison opcodes in GLSL. */
1556 void shader_glsl_compare(SHADER_OPCODE_ARG* arg) {
1557     glsl_src_param_t src0_param;
1558     glsl_src_param_t src1_param;
1559     DWORD write_mask;
1560     size_t mask_size;
1561
1562     write_mask = shader_glsl_append_dst(arg->buffer, arg);
1563     mask_size = shader_glsl_get_write_mask_size(write_mask);
1564     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1565     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1566
1567     if (mask_size > 1) {
1568         const char *compare;
1569
1570         switch(arg->opcode->opcode) {
1571             case WINED3DSIO_SLT: compare = "lessThan"; break;
1572             case WINED3DSIO_SGE: compare = "greaterThanEqual"; break;
1573             default: compare = "";
1574                 FIXME("Can't handle opcode %s\n", arg->opcode->name);
1575         }
1576
1577         shader_addline(arg->buffer, "vec%d(%s(%s, %s)));\n", mask_size, compare,
1578                 src0_param.param_str, src1_param.param_str);
1579     } else {
1580         switch(arg->opcode->opcode) {
1581             case WINED3DSIO_SLT:
1582                 /* Step(src0, src1) is not suitable here because if src0 == src1 SLT is supposed,
1583                  * to return 0.0 but step returns 1.0 because step is not < x
1584                  * An alternative is a bvec compare padded with an unused secound component.
1585                  * step(src1 * -1.0, src0 * -1.0) is not an option because it suffers from the same
1586                  * issue. Playing with not() is not possible either because not() does not accept
1587                  * a scalar.
1588                  */
1589                 shader_addline(arg->buffer, "(%s < %s) ? 1.0 : 0.0);\n", src0_param.param_str, src1_param.param_str);
1590                 break;
1591             case WINED3DSIO_SGE:
1592                 /* Here we can use the step() function and safe a conditional */
1593                 shader_addline(arg->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
1594                 break;
1595             default:
1596                 FIXME("Can't handle opcode %s\n", arg->opcode->name);
1597         }
1598
1599     }
1600 }
1601
1602 /** Process CMP instruction in GLSL (dst = src0 >= 0.0 ? src1 : src2), per channel */
1603 void shader_glsl_cmp(SHADER_OPCODE_ARG* arg) {
1604     glsl_src_param_t src0_param;
1605     glsl_src_param_t src1_param;
1606     glsl_src_param_t src2_param;
1607     DWORD write_mask, cmp_channel = 0;
1608     unsigned int i, j;
1609     char mask_char[6];
1610     BOOL temp_destination = FALSE;
1611
1612     DWORD src0reg = arg->src[0] & WINED3DSP_REGNUM_MASK;
1613     DWORD src1reg = arg->src[1] & WINED3DSP_REGNUM_MASK;
1614     DWORD src2reg = arg->src[2] & WINED3DSP_REGNUM_MASK;
1615     DWORD src0regtype = shader_get_regtype(arg->src[0]);
1616     DWORD src1regtype = shader_get_regtype(arg->src[1]);
1617     DWORD src2regtype = shader_get_regtype(arg->src[2]);
1618     DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
1619     DWORD dstregtype = shader_get_regtype(arg->dst);
1620
1621     /* Cycle through all source0 channels */
1622     for (i=0; i<4; i++) {
1623         write_mask = 0;
1624         /* Find the destination channels which use the current source0 channel */
1625         for (j=0; j<4; j++) {
1626             if ( ((arg->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2*j)) & 0x3) == i ) {
1627                 write_mask |= WINED3DSP_WRITEMASK_0 << j;
1628                 cmp_channel = WINED3DSP_WRITEMASK_0 << j;
1629             }
1630         }
1631
1632         /* Splitting the cmp instruction up in multiple lines imposes a problem:
1633          * The first lines may overwrite source parameters of the following lines.
1634          * Deal with that by using a temporary destination register if needed
1635          */
1636         if((src0reg == dstreg && src0regtype == dstregtype) ||
1637            (src1reg == dstreg && src1regtype == dstregtype) ||
1638            (src2reg == dstreg && src2regtype == dstregtype)) {
1639
1640             write_mask = shader_glsl_get_write_mask(arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask), mask_char);
1641             if (!write_mask) continue;
1642             shader_addline(arg->buffer, "tmp0%s = (", mask_char);
1643             temp_destination = TRUE;
1644         } else {
1645             write_mask = shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
1646             if (!write_mask) continue;
1647         }
1648
1649         shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], cmp_channel, &src0_param);
1650         shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1651         shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1652
1653             shader_addline(arg->buffer, "%s >= 0.0 ? %s : %s);\n",
1654                            src0_param.param_str, src1_param.param_str, src2_param.param_str);
1655     }
1656
1657     if(temp_destination) {
1658         shader_glsl_get_write_mask(arg->dst, mask_char);
1659         shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst);
1660         shader_addline(arg->buffer, "tmp0%s);\n", mask_char);
1661     }
1662
1663 }
1664
1665 /** Process the CND opcode in GLSL (dst = (src0 > 0.5) ? src1 : src2) */
1666 /* For ps 1.1-1.3, only a single component of src0 is used. For ps 1.4
1667  * the compare is done per component of src0. */
1668 void shader_glsl_cnd(SHADER_OPCODE_ARG* arg) {
1669     IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1670     glsl_src_param_t src0_param;
1671     glsl_src_param_t src1_param;
1672     glsl_src_param_t src2_param;
1673     DWORD write_mask, cmp_channel = 0;
1674     unsigned int i, j;
1675
1676     if (shader->baseShader.hex_version < WINED3DPS_VERSION(1, 4)) {
1677         write_mask = shader_glsl_append_dst(arg->buffer, arg);
1678         shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1679         shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1680         shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1681
1682         /* Fun: The D3DSI_COISSUE flag changes the semantic of the cnd instruction for < 1.4 shaders */
1683         if(arg->opcode_token & WINED3DSI_COISSUE) {
1684             shader_addline(arg->buffer, "%s /* COISSUE! */);\n", src1_param.param_str);
1685         } else {
1686             shader_addline(arg->buffer, "%s > 0.5 ? %s : %s);\n",
1687                     src0_param.param_str, src1_param.param_str, src2_param.param_str);
1688         }
1689         return;
1690     }
1691     /* Cycle through all source0 channels */
1692     for (i=0; i<4; i++) {
1693         write_mask = 0;
1694         /* Find the destination channels which use the current source0 channel */
1695         for (j=0; j<4; j++) {
1696             if ( ((arg->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2*j)) & 0x3) == i ) {
1697                 write_mask |= WINED3DSP_WRITEMASK_0 << j;
1698                 cmp_channel = WINED3DSP_WRITEMASK_0 << j;
1699             }
1700         }
1701         write_mask = shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
1702         if (!write_mask) continue;
1703
1704         shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], cmp_channel, &src0_param);
1705         shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1706         shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1707
1708         shader_addline(arg->buffer, "%s > 0.5 ? %s : %s);\n",
1709                 src0_param.param_str, src1_param.param_str, src2_param.param_str);
1710     }
1711 }
1712
1713 /** GLSL code generation for WINED3DSIO_MAD: Multiply the first 2 opcodes, then add the last */
1714 void shader_glsl_mad(SHADER_OPCODE_ARG* arg) {
1715     glsl_src_param_t src0_param;
1716     glsl_src_param_t src1_param;
1717     glsl_src_param_t src2_param;
1718     DWORD write_mask;
1719
1720     write_mask = shader_glsl_append_dst(arg->buffer, arg);
1721     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1722     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1723     shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1724     shader_addline(arg->buffer, "(%s * %s) + %s);\n",
1725             src0_param.param_str, src1_param.param_str, src2_param.param_str);
1726 }
1727
1728 /** Handles transforming all WINED3DSIO_M?x? opcodes for
1729     Vertex shaders to GLSL codes */
1730 void shader_glsl_mnxn(SHADER_OPCODE_ARG* arg) {
1731     int i;
1732     int nComponents = 0;
1733     SHADER_OPCODE_ARG tmpArg;
1734
1735     memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
1736
1737     /* Set constants for the temporary argument */
1738     tmpArg.shader      = arg->shader;
1739     tmpArg.buffer      = arg->buffer;
1740     tmpArg.src[0]      = arg->src[0];
1741     tmpArg.src_addr[0] = arg->src_addr[0];
1742     tmpArg.src_addr[1] = arg->src_addr[1];
1743     tmpArg.reg_maps = arg->reg_maps;
1744
1745     switch(arg->opcode->opcode) {
1746         case WINED3DSIO_M4x4:
1747             nComponents = 4;
1748             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
1749             break;
1750         case WINED3DSIO_M4x3:
1751             nComponents = 3;
1752             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
1753             break;
1754         case WINED3DSIO_M3x4:
1755             nComponents = 4;
1756             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1757             break;
1758         case WINED3DSIO_M3x3:
1759             nComponents = 3;
1760             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1761             break;
1762         case WINED3DSIO_M3x2:
1763             nComponents = 2;
1764             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1765             break;
1766         default:
1767             break;
1768     }
1769
1770     for (i = 0; i < nComponents; i++) {
1771         tmpArg.dst = ((arg->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
1772         tmpArg.src[1]      = arg->src[1]+i;
1773         shader_glsl_dot(&tmpArg);
1774     }
1775 }
1776
1777 /**
1778     The LRP instruction performs a component-wise linear interpolation
1779     between the second and third operands using the first operand as the
1780     blend factor.  Equation:  (dst = src2 + src0 * (src1 - src2))
1781     This is equivalent to mix(src2, src1, src0);
1782 */
1783 void shader_glsl_lrp(SHADER_OPCODE_ARG* arg) {
1784     glsl_src_param_t src0_param;
1785     glsl_src_param_t src1_param;
1786     glsl_src_param_t src2_param;
1787     DWORD write_mask;
1788
1789     write_mask = shader_glsl_append_dst(arg->buffer, arg);
1790
1791     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
1792     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
1793     shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
1794
1795     shader_addline(arg->buffer, "mix(%s, %s, %s));\n",
1796             src2_param.param_str, src1_param.param_str, src0_param.param_str);
1797 }
1798
1799 /** Process the WINED3DSIO_LIT instruction in GLSL:
1800  * dst.x = dst.w = 1.0
1801  * dst.y = (src0.x > 0) ? src0.x
1802  * dst.z = (src0.x > 0) ? ((src0.y > 0) ? pow(src0.y, src.w) : 0) : 0
1803  *                                        where src.w is clamped at +- 128
1804  */
1805 void shader_glsl_lit(SHADER_OPCODE_ARG* arg) {
1806     glsl_src_param_t src0_param;
1807     glsl_src_param_t src1_param;
1808     glsl_src_param_t src3_param;
1809     char dst_mask[6];
1810
1811     shader_glsl_append_dst(arg->buffer, arg);
1812     shader_glsl_get_write_mask(arg->dst, dst_mask);
1813
1814     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1815     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_1, &src1_param);
1816     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src3_param);
1817
1818     /* The sdk specifies the instruction like this
1819      * dst.x = 1.0;
1820      * if(src.x > 0.0) dst.y = src.x
1821      * else dst.y = 0.0.
1822      * if(src.x > 0.0 && src.y > 0.0) dst.z = pow(src.y, power);
1823      * else dst.z = 0.0;
1824      * dst.w = 1.0;
1825      *
1826      * Obviously that has quite a few conditionals in it which we don't like. So the first step is this:
1827      * dst.x = 1.0                                  ... No further explanation needed
1828      * dst.y = max(src.y, 0.0);                     ... If x < 0.0, use 0.0, otherwise x. Same as the conditional
1829      * dst.z = x > 0.0 ? pow(max(y, 0.0), p) : 0;   ... 0 ^ power is 0, and otherwise we use y anyway
1830      * dst.w = 1.0.                                 ... Nothing fancy.
1831      *
1832      * So we still have one conditional in there. So do this:
1833      * dst.z = pow(max(0.0, src.y) * step(0.0, src.x), power);
1834      *
1835      * step(0.0, x) will return 1 if src.x > 0.0, and 0 otherwise. So if y is 0 we get pow(0.0 * 1.0, power),
1836      * which sets dst.z to 0. If y > 0, but x = 0.0, we get pow(y * 0.0, power), which results in 0 too.
1837      * if both x and y are > 0, we get pow(y * 1.0, power), as it is supposed to
1838      */
1839     shader_addline(arg->buffer, "vec4(1.0, max(%s, 0.0), pow(max(0.0, %s) * step(0.0, %s), clamp(%s, -128.0, 128.0)), 1.0)%s);\n",
1840                    src0_param.param_str, src1_param.param_str, src0_param.param_str, src3_param.param_str, dst_mask);
1841 }
1842
1843 /** Process the WINED3DSIO_DST instruction in GLSL:
1844  * dst.x = 1.0
1845  * dst.y = src0.x * src0.y
1846  * dst.z = src0.z
1847  * dst.w = src1.w
1848  */
1849 void shader_glsl_dst(SHADER_OPCODE_ARG* arg) {
1850     glsl_src_param_t src0y_param;
1851     glsl_src_param_t src0z_param;
1852     glsl_src_param_t src1y_param;
1853     glsl_src_param_t src1w_param;
1854     char dst_mask[6];
1855
1856     shader_glsl_append_dst(arg->buffer, arg);
1857     shader_glsl_get_write_mask(arg->dst, dst_mask);
1858
1859     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_1, &src0y_param);
1860     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &src0z_param);
1861     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_1, &src1y_param);
1862     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_3, &src1w_param);
1863
1864     shader_addline(arg->buffer, "vec4(1.0, %s * %s, %s, %s))%s;\n",
1865             src0y_param.param_str, src1y_param.param_str, src0z_param.param_str, src1w_param.param_str, dst_mask);
1866 }
1867
1868 /** Process the WINED3DSIO_SINCOS instruction in GLSL:
1869  * VS 2.0 requires that specific cosine and sine constants be passed to this instruction so the hardware
1870  * can handle it.  But, these functions are built-in for GLSL, so we can just ignore the last 2 params.
1871  *
1872  * dst.x = cos(src0.?)
1873  * dst.y = sin(src0.?)
1874  * dst.z = dst.z
1875  * dst.w = dst.w
1876  */
1877 void shader_glsl_sincos(SHADER_OPCODE_ARG* arg) {
1878     glsl_src_param_t src0_param;
1879     DWORD write_mask;
1880
1881     write_mask = shader_glsl_append_dst(arg->buffer, arg);
1882     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1883
1884     switch (write_mask) {
1885         case WINED3DSP_WRITEMASK_0:
1886             shader_addline(arg->buffer, "cos(%s));\n", src0_param.param_str);
1887             break;
1888
1889         case WINED3DSP_WRITEMASK_1:
1890             shader_addline(arg->buffer, "sin(%s));\n", src0_param.param_str);
1891             break;
1892
1893         case (WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1):
1894             shader_addline(arg->buffer, "vec2(cos(%s), sin(%s)));\n", src0_param.param_str, src0_param.param_str);
1895             break;
1896
1897         default:
1898             ERR("Write mask should be .x, .y or .xy\n");
1899             break;
1900     }
1901 }
1902
1903 /** Process the WINED3DSIO_LOOP instruction in GLSL:
1904  * Start a for() loop where src1.y is the initial value of aL,
1905  *  increment aL by src1.z for a total of src1.x iterations.
1906  *  Need to use a temporary variable for this operation.
1907  */
1908 /* FIXME: I don't think nested loops will work correctly this way. */
1909 void shader_glsl_loop(SHADER_OPCODE_ARG* arg) {
1910     glsl_src_param_t src1_param;
1911     IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1912     DWORD regtype = shader_get_regtype(arg->src[1]);
1913     DWORD reg = arg->src[1] & WINED3DSP_REGNUM_MASK;
1914     const DWORD *control_values = NULL;
1915     local_constant *constant;
1916
1917     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_ALL, &src1_param);
1918
1919     /* Try to hardcode the loop control parameters if possible. Direct3D 9 class hardware doesn't support real
1920      * varying indexing, but Microsoft designed this feature for Shader model 2.x+. If the loop control is
1921      * known at compile time, the GLSL compiler can unroll the loop, and replace indirect addressing with direct
1922      * addressing.
1923      */
1924     if(regtype == WINED3DSPR_CONSTINT) {
1925         LIST_FOR_EACH_ENTRY(constant, &shader->baseShader.constantsI, local_constant, entry) {
1926             if(constant->idx == reg) {
1927                 control_values = constant->value;
1928                 break;
1929             }
1930         }
1931     }
1932
1933     if(control_values) {
1934         if(control_values[2] > 0) {
1935             shader_addline(arg->buffer, "for (aL%u = %d; aL%u < (%d * %d + %d); aL%u += %d) {\n",
1936                            shader->baseShader.cur_loop_depth, control_values[1],
1937                            shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
1938                            shader->baseShader.cur_loop_depth, control_values[2]);
1939         } else if(control_values[2] == 0) {
1940             shader_addline(arg->buffer, "for (aL%u = %d, tmpInt%u = 0; tmpInt%u < %d; tmpInt%u++) {\n",
1941                            shader->baseShader.cur_loop_depth, control_values[1], shader->baseShader.cur_loop_depth,
1942                            shader->baseShader.cur_loop_depth, control_values[0],
1943                            shader->baseShader.cur_loop_depth);
1944         } else {
1945             shader_addline(arg->buffer, "for (aL%u = %d; aL%u > (%d * %d + %d); aL%u += %d) {\n",
1946                            shader->baseShader.cur_loop_depth, control_values[1],
1947                            shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
1948                            shader->baseShader.cur_loop_depth, control_values[2]);
1949         }
1950     } else {
1951         shader_addline(arg->buffer, "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z) {\n",
1952                        shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno,
1953                        src1_param.reg_name, shader->baseShader.cur_loop_depth, src1_param.reg_name,
1954                        shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno, src1_param.reg_name);
1955     }
1956
1957     shader->baseShader.cur_loop_depth++;
1958     shader->baseShader.cur_loop_regno++;
1959 }
1960
1961 void shader_glsl_end(SHADER_OPCODE_ARG* arg) {
1962     IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1963
1964     shader_addline(arg->buffer, "}\n");
1965
1966     if(arg->opcode->opcode == WINED3DSIO_ENDLOOP) {
1967         shader->baseShader.cur_loop_depth--;
1968         shader->baseShader.cur_loop_regno--;
1969     }
1970     if(arg->opcode->opcode == WINED3DSIO_ENDREP) {
1971         shader->baseShader.cur_loop_depth--;
1972     }
1973 }
1974
1975 void shader_glsl_rep(SHADER_OPCODE_ARG* arg) {
1976     IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
1977     glsl_src_param_t src0_param;
1978
1979     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1980     shader_addline(arg->buffer, "for (tmpInt%d = 0; tmpInt%d < %s; tmpInt%d++) {\n",
1981                    shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_depth,
1982                    src0_param.param_str, shader->baseShader.cur_loop_depth);
1983     shader->baseShader.cur_loop_depth++;
1984 }
1985
1986 void shader_glsl_if(SHADER_OPCODE_ARG* arg) {
1987     glsl_src_param_t src0_param;
1988
1989     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1990     shader_addline(arg->buffer, "if (%s) {\n", src0_param.param_str);
1991 }
1992
1993 void shader_glsl_ifc(SHADER_OPCODE_ARG* arg) {
1994     glsl_src_param_t src0_param;
1995     glsl_src_param_t src1_param;
1996
1997     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
1998     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
1999
2000     shader_addline(arg->buffer, "if (%s %s %s) {\n",
2001             src0_param.param_str, shader_get_comp_op(arg->opcode_token), src1_param.param_str);
2002 }
2003
2004 void shader_glsl_else(SHADER_OPCODE_ARG* arg) {
2005     shader_addline(arg->buffer, "} else {\n");
2006 }
2007
2008 void shader_glsl_break(SHADER_OPCODE_ARG* arg) {
2009     shader_addline(arg->buffer, "break;\n");
2010 }
2011
2012 /* FIXME: According to MSDN the compare is done per component. */
2013 void shader_glsl_breakc(SHADER_OPCODE_ARG* arg) {
2014     glsl_src_param_t src0_param;
2015     glsl_src_param_t src1_param;
2016
2017     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
2018     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
2019
2020     shader_addline(arg->buffer, "if (%s %s %s) break;\n",
2021             src0_param.param_str, shader_get_comp_op(arg->opcode_token), src1_param.param_str);
2022 }
2023
2024 void shader_glsl_label(SHADER_OPCODE_ARG* arg) {
2025
2026     DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
2027     shader_addline(arg->buffer, "}\n");
2028     shader_addline(arg->buffer, "void subroutine%u () {\n",  snum);
2029 }
2030
2031 void shader_glsl_call(SHADER_OPCODE_ARG* arg) {
2032     DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
2033     shader_addline(arg->buffer, "subroutine%u();\n", snum);
2034 }
2035
2036 void shader_glsl_callnz(SHADER_OPCODE_ARG* arg) {
2037     glsl_src_param_t src1_param;
2038
2039     DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
2040     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
2041     shader_addline(arg->buffer, "if (%s) subroutine%u();\n", src1_param.param_str, snum);
2042 }
2043
2044 /*********************************************
2045  * Pixel Shader Specific Code begins here
2046  ********************************************/
2047 void pshader_glsl_tex(SHADER_OPCODE_ARG* arg) {
2048     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2049     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
2050     DWORD hex_version = This->baseShader.hex_version;
2051     char dst_swizzle[6];
2052     glsl_sample_function_t sample_function;
2053     DWORD sampler_type;
2054     DWORD sampler_idx;
2055     BOOL projected, texrect = FALSE;
2056     DWORD mask = 0;
2057
2058     /* All versions have a destination register */
2059     shader_glsl_append_dst(arg->buffer, arg);
2060
2061     /* 1.0-1.4: Use destination register as sampler source.
2062      * 2.0+: Use provided sampler source. */
2063     if (hex_version < WINED3DPS_VERSION(1,4)) {
2064         DWORD flags;
2065
2066         sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2067         flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2068
2069         if (flags & WINED3DTTFF_PROJECTED) {
2070             projected = TRUE;
2071             switch (flags & ~WINED3DTTFF_PROJECTED) {
2072                 case WINED3DTTFF_COUNT1: FIXME("WINED3DTTFF_PROJECTED with WINED3DTTFF_COUNT1?\n"); break;
2073                 case WINED3DTTFF_COUNT2: mask = WINED3DSP_WRITEMASK_1; break;
2074                 case WINED3DTTFF_COUNT3: mask = WINED3DSP_WRITEMASK_2; break;
2075                 case WINED3DTTFF_COUNT4:
2076                 case WINED3DTTFF_DISABLE: mask = WINED3DSP_WRITEMASK_3; break;
2077             }
2078         } else {
2079             projected = FALSE;
2080         }
2081     } else if (hex_version < WINED3DPS_VERSION(2,0)) {
2082         DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
2083         sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2084
2085         if (src_mod == WINED3DSPSM_DZ) {
2086             projected = TRUE;
2087             mask = WINED3DSP_WRITEMASK_2;
2088         } else if (src_mod == WINED3DSPSM_DW) {
2089             projected = TRUE;
2090             mask = WINED3DSP_WRITEMASK_3;
2091         } else {
2092             projected = FALSE;
2093         }
2094     } else {
2095         sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
2096         if(arg->opcode_token & WINED3DSI_TEXLD_PROJECT) {
2097                 /* ps 2.0 texldp instruction always divides by the fourth component. */
2098                 projected = TRUE;
2099                 mask = WINED3DSP_WRITEMASK_3;
2100         } else {
2101             projected = FALSE;
2102         }
2103     }
2104
2105     if(deviceImpl->stateBlock->textures[sampler_idx] &&
2106        IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
2107         texrect = TRUE;
2108     }
2109
2110     sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2111     shader_glsl_get_sample_function(sampler_type, projected, texrect, &sample_function);
2112     mask |= sample_function.coord_mask;
2113
2114     if (hex_version < WINED3DPS_VERSION(2,0)) {
2115         shader_glsl_get_write_mask(arg->dst, dst_swizzle);
2116     } else {
2117         shader_glsl_get_swizzle(arg->src[1], FALSE, arg->dst, dst_swizzle);
2118     }
2119
2120     /* 1.0-1.3: Use destination register as coordinate source.
2121        1.4+: Use provided coordinate source register. */
2122     if (hex_version < WINED3DPS_VERSION(1,4)) {
2123         char coord_mask[6];
2124         shader_glsl_get_write_mask(mask, coord_mask);
2125         shader_addline(arg->buffer, "%s(Psampler%u, T%u%s)%s);\n",
2126                 sample_function.name, sampler_idx, sampler_idx, coord_mask, dst_swizzle);
2127     } else {
2128         glsl_src_param_t coord_param;
2129         shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], mask, &coord_param);
2130         if(arg->opcode_token & WINED3DSI_TEXLD_BIAS) {
2131             glsl_src_param_t bias;
2132             shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &bias);
2133
2134             shader_addline(arg->buffer, "%s(Psampler%u, %s, %s)%s);\n",
2135                     sample_function.name, sampler_idx, coord_param.param_str,
2136                     bias.param_str, dst_swizzle);
2137         } else {
2138             shader_addline(arg->buffer, "%s(Psampler%u, %s)%s);\n",
2139                     sample_function.name, sampler_idx, coord_param.param_str, dst_swizzle);
2140         }
2141     }
2142 }
2143
2144 void shader_glsl_texldl(SHADER_OPCODE_ARG* arg) {
2145     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*)arg->shader;
2146     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
2147     glsl_sample_function_t sample_function;
2148     glsl_src_param_t coord_param, lod_param;
2149     char dst_swizzle[6];
2150     DWORD sampler_type;
2151     DWORD sampler_idx;
2152     BOOL texrect = FALSE;
2153
2154     shader_glsl_append_dst(arg->buffer, arg);
2155     shader_glsl_get_swizzle(arg->src[1], FALSE, arg->dst, dst_swizzle);
2156
2157     sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
2158     sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2159     if(deviceImpl->stateBlock->textures[sampler_idx] &&
2160        IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
2161         texrect = TRUE;
2162     }
2163     shader_glsl_get_sample_function(sampler_type, FALSE, texrect, &sample_function);    shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], sample_function.coord_mask, &coord_param);
2164
2165     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &lod_param);
2166
2167     if (shader_is_pshader_version(This->baseShader.hex_version)) {
2168         /* The GLSL spec claims the Lod sampling functions are only supported in vertex shaders.
2169          * However, they seem to work just fine in fragment shaders as well. */
2170         WARN("Using %sLod in fragment shader.\n", sample_function.name);
2171         shader_addline(arg->buffer, "%sLod(Psampler%u, %s, %s)%s);\n",
2172                 sample_function.name, sampler_idx, coord_param.param_str, lod_param.param_str, dst_swizzle);
2173     } else {
2174         shader_addline(arg->buffer, "%sLod(Vsampler%u, %s, %s)%s);\n",
2175                 sample_function.name, sampler_idx, coord_param.param_str, lod_param.param_str, dst_swizzle);
2176     }
2177 }
2178
2179 void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg) {
2180
2181     /* FIXME: Make this work for more than just 2D textures */
2182
2183     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2184     SHADER_BUFFER* buffer = arg->buffer;
2185     DWORD hex_version = This->baseShader.hex_version;
2186     DWORD write_mask;
2187     char dst_mask[6];
2188
2189     write_mask = shader_glsl_append_dst(arg->buffer, arg);
2190     shader_glsl_get_write_mask(write_mask, dst_mask);
2191
2192     if (hex_version != WINED3DPS_VERSION(1,4)) {
2193         DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2194         shader_addline(buffer, "clamp(gl_TexCoord[%u], 0.0, 1.0)%s);\n", reg, dst_mask);
2195     } else {
2196         DWORD reg = arg->src[0] & WINED3DSP_REGNUM_MASK;
2197         DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
2198         char dst_swizzle[6];
2199
2200         shader_glsl_get_swizzle(arg->src[0], FALSE, write_mask, dst_swizzle);
2201
2202         if (src_mod == WINED3DSPSM_DZ) {
2203             glsl_src_param_t div_param;
2204             size_t mask_size = shader_glsl_get_write_mask_size(write_mask);
2205             shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &div_param);
2206
2207             if (mask_size > 1) {
2208                 shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
2209             } else {
2210                 shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
2211             }
2212         } else if (src_mod == WINED3DSPSM_DW) {
2213             glsl_src_param_t div_param;
2214             size_t mask_size = shader_glsl_get_write_mask_size(write_mask);
2215             shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &div_param);
2216
2217             if (mask_size > 1) {
2218                 shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
2219             } else {
2220                 shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
2221             }
2222         } else {
2223             shader_addline(buffer, "gl_TexCoord[%u]%s);\n", reg, dst_swizzle);
2224         }
2225     }
2226 }
2227
2228 /** Process the WINED3DSIO_TEXDP3TEX instruction in GLSL:
2229  * Take a 3-component dot product of the TexCoord[dstreg] and src,
2230  * then perform a 1D texture lookup from stage dstregnum, place into dst. */
2231 void pshader_glsl_texdp3tex(SHADER_OPCODE_ARG* arg) {
2232     glsl_src_param_t src0_param;
2233     char dst_mask[6];
2234     glsl_sample_function_t sample_function;
2235     DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2236     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2237     DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2238
2239     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2240
2241     shader_glsl_append_dst(arg->buffer, arg);
2242     shader_glsl_get_write_mask(arg->dst, dst_mask);
2243
2244     /* Do I have to take care about the projected bit? I don't think so, since the dp3 returns only one
2245      * scalar, and projected sampling would require 4.
2246      *
2247      * It is a dependent read - not valid with conditional NP2 textures
2248      */
2249     shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2250
2251     switch(count_bits(sample_function.coord_mask)) {
2252         case 1:
2253             shader_addline(arg->buffer, "%s(Psampler%u, dot(gl_TexCoord[%u].xyz, %s))%s);\n",
2254                            sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
2255             break;
2256
2257         case 2:
2258             shader_addline(arg->buffer, "%s(Psampler%u, vec2(dot(gl_TexCoord[%u].xyz, %s), 0.0))%s);\n",
2259                           sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
2260             break;
2261
2262         case 3:
2263             shader_addline(arg->buffer, "%s(Psampler%u, vec3(dot(gl_TexCoord[%u].xyz, %s), 0.0, 0.0))%s);\n",
2264                            sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
2265             break;
2266         default:
2267             FIXME("Unexpected mask bitcount %d\n", count_bits(sample_function.coord_mask));
2268     }
2269 }
2270
2271 /** Process the WINED3DSIO_TEXDP3 instruction in GLSL:
2272  * Take a 3-component dot product of the TexCoord[dstreg] and src. */
2273 void pshader_glsl_texdp3(SHADER_OPCODE_ARG* arg) {
2274     glsl_src_param_t src0_param;
2275     DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
2276     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2277     DWORD dst_mask;
2278     size_t mask_size;
2279
2280     dst_mask = shader_glsl_append_dst(arg->buffer, arg);
2281     mask_size = shader_glsl_get_write_mask_size(dst_mask);
2282     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2283
2284     if (mask_size > 1) {
2285         shader_addline(arg->buffer, "vec%d(dot(T%u.xyz, %s)));\n", mask_size, dstreg, src0_param.param_str);
2286     } else {
2287         shader_addline(arg->buffer, "dot(T%u.xyz, %s));\n", dstreg, src0_param.param_str);
2288     }
2289 }
2290
2291 /** Process the WINED3DSIO_TEXDEPTH instruction in GLSL:
2292  * Calculate the depth as dst.x / dst.y   */
2293 void pshader_glsl_texdepth(SHADER_OPCODE_ARG* arg) {
2294     glsl_dst_param_t dst_param;
2295
2296     shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
2297
2298     /* Tests show that texdepth never returns anything below 0.0, and that r5.y is clamped to 1.0.
2299      * Negative input is accepted, -0.25 / -0.5 returns 0.5. GL should clamp gl_FragDepth to [0;1], but
2300      * this doesn't always work, so clamp the results manually. Whether or not the x value is clamped at 1
2301      * too is irrelevant, since if x = 0, any y value < 1.0 (and > 1.0 is not allowed) results in a result
2302      * >= 1.0 or < 0.0
2303      */
2304     shader_addline(arg->buffer, "gl_FragDepth = clamp((%s.x / min(%s.y, 1.0)), 0.0, 1.0);\n", dst_param.reg_name, dst_param.reg_name);
2305 }
2306
2307 /** Process the WINED3DSIO_TEXM3X2DEPTH instruction in GLSL:
2308  * Last row of a 3x2 matrix multiply, use the result to calculate the depth:
2309  * Calculate tmp0.y = TexCoord[dstreg] . src.xyz;  (tmp0.x has already been calculated)
2310  * depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
2311  */
2312 void pshader_glsl_texm3x2depth(SHADER_OPCODE_ARG* arg) {
2313     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2314     DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
2315     glsl_src_param_t src0_param;
2316
2317     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2318
2319     shader_addline(arg->buffer, "tmp0.y = dot(T%u.xyz, %s);\n", dstreg, src0_param.param_str);
2320     shader_addline(arg->buffer, "gl_FragDepth = (tmp0.y == 0.0) ? 1.0 : clamp(tmp0.x / tmp0.y, 0.0, 1.0);\n");
2321 }
2322
2323 /** Process the WINED3DSIO_TEXM3X2PAD instruction in GLSL
2324  * Calculate the 1st of a 2-row matrix multiplication. */
2325 void pshader_glsl_texm3x2pad(SHADER_OPCODE_ARG* arg) {
2326     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2327     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2328     SHADER_BUFFER* buffer = arg->buffer;
2329     glsl_src_param_t src0_param;
2330
2331     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2332     shader_addline(buffer, "tmp0.x = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
2333 }
2334
2335 /** Process the WINED3DSIO_TEXM3X3PAD instruction in GLSL
2336  * Calculate the 1st or 2nd row of a 3-row matrix multiplication. */
2337 void pshader_glsl_texm3x3pad(SHADER_OPCODE_ARG* arg) {
2338
2339     IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
2340     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2341     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2342     SHADER_BUFFER* buffer = arg->buffer;
2343     SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
2344     glsl_src_param_t src0_param;
2345
2346     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2347     shader_addline(buffer, "tmp0.%c = dot(T%u.xyz, %s);\n", 'x' + current_state->current_row, reg, src0_param.param_str);
2348     current_state->texcoord_w[current_state->current_row++] = reg;
2349 }
2350
2351 void pshader_glsl_texm3x2tex(SHADER_OPCODE_ARG* arg) {
2352     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2353     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2354     SHADER_BUFFER* buffer = arg->buffer;
2355     glsl_src_param_t src0_param;
2356     char dst_mask[6];
2357
2358     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2359     shader_addline(buffer, "tmp0.y = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
2360
2361     shader_glsl_append_dst(buffer, arg);
2362     shader_glsl_get_write_mask(arg->dst, dst_mask);
2363
2364     /* Sample the texture using the calculated coordinates */
2365     shader_addline(buffer, "texture2D(Psampler%u, tmp0.xy)%s);\n", reg, dst_mask);
2366 }
2367
2368 /** Process the WINED3DSIO_TEXM3X3TEX instruction in GLSL
2369  * Perform the 3rd row of a 3x3 matrix multiply, then sample the texture using the calculated coordinates */
2370 void pshader_glsl_texm3x3tex(SHADER_OPCODE_ARG* arg) {
2371     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2372     glsl_src_param_t src0_param;
2373     char dst_mask[6];
2374     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2375     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2376     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
2377     DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
2378     glsl_sample_function_t sample_function;
2379
2380     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2381     shader_addline(arg->buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
2382
2383     shader_glsl_append_dst(arg->buffer, arg);
2384     shader_glsl_get_write_mask(arg->dst, dst_mask);
2385     /* Dependent read, not valid with conditional NP2 */
2386     shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2387
2388     /* Sample the texture using the calculated coordinates */
2389     shader_addline(arg->buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
2390
2391     current_state->current_row = 0;
2392 }
2393
2394 /** Process the WINED3DSIO_TEXM3X3 instruction in GLSL
2395  * Perform the 3rd row of a 3x3 matrix multiply */
2396 void pshader_glsl_texm3x3(SHADER_OPCODE_ARG* arg) {
2397     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2398     glsl_src_param_t src0_param;
2399     char dst_mask[6];
2400     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2401     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2402     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
2403
2404     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2405
2406     shader_glsl_append_dst(arg->buffer, arg);
2407     shader_glsl_get_write_mask(arg->dst, dst_mask);
2408     shader_addline(arg->buffer, "vec4(tmp0.xy, dot(T%u.xyz, %s), 1.0)%s);\n", reg, src0_param.param_str, dst_mask);
2409
2410     current_state->current_row = 0;
2411 }
2412
2413 /** Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL
2414  * Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */
2415 void pshader_glsl_texm3x3spec(SHADER_OPCODE_ARG* arg) {
2416
2417     IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
2418     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2419     glsl_src_param_t src0_param;
2420     glsl_src_param_t src1_param;
2421     char dst_mask[6];
2422     SHADER_BUFFER* buffer = arg->buffer;
2423     SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
2424     DWORD stype = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
2425     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2426     glsl_sample_function_t sample_function;
2427
2428     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2429     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_mask, &src1_param);
2430
2431     /* Perform the last matrix multiply operation */
2432     shader_addline(buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
2433     /* Reflection calculation */
2434     shader_addline(buffer, "tmp0.xyz = -reflect((%s), normalize(tmp0.xyz));\n", src1_param.param_str);
2435
2436     shader_glsl_append_dst(buffer, arg);
2437     shader_glsl_get_write_mask(arg->dst, dst_mask);
2438     /* Dependent read, not valid with conditional NP2 */
2439     shader_glsl_get_sample_function(stype, FALSE, FALSE, &sample_function);
2440
2441     /* Sample the texture */
2442     shader_addline(buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
2443
2444     current_state->current_row = 0;
2445 }
2446
2447 /** Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL
2448  * Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */
2449 void pshader_glsl_texm3x3vspec(SHADER_OPCODE_ARG* arg) {
2450
2451     IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
2452     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
2453     SHADER_BUFFER* buffer = arg->buffer;
2454     SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
2455     glsl_src_param_t src0_param;
2456     char dst_mask[6];
2457     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2458     DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
2459     glsl_sample_function_t sample_function;
2460
2461     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
2462
2463     /* Perform the last matrix multiply operation */
2464     shader_addline(buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_param.param_str);
2465
2466     /* Construct the eye-ray vector from w coordinates */
2467     shader_addline(buffer, "tmp1.xyz = normalize(vec3(gl_TexCoord[%u].w, gl_TexCoord[%u].w, gl_TexCoord[%u].w));\n",
2468             current_state->texcoord_w[0], current_state->texcoord_w[1], reg);
2469     shader_addline(buffer, "tmp0.xyz = -reflect(tmp1.xyz, normalize(tmp0.xyz));\n");
2470
2471     shader_glsl_append_dst(buffer, arg);
2472     shader_glsl_get_write_mask(arg->dst, dst_mask);
2473     /* Dependent read, not valid with conditional NP2 */
2474     shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2475
2476     /* Sample the texture using the calculated coordinates */
2477     shader_addline(buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
2478
2479     current_state->current_row = 0;
2480 }
2481
2482 /** Process the WINED3DSIO_TEXBEM instruction in GLSL.
2483  * Apply a fake bump map transform.
2484  * texbem is pshader <= 1.3 only, this saves a few version checks
2485  */
2486 void pshader_glsl_texbem(SHADER_OPCODE_ARG* arg) {
2487     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2488     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
2489     char dst_swizzle[6];
2490     glsl_sample_function_t sample_function;
2491     glsl_src_param_t coord_param;
2492     DWORD sampler_type;
2493     DWORD sampler_idx;
2494     DWORD mask;
2495     DWORD flags;
2496     char coord_mask[6];
2497
2498     sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2499     flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2500
2501     sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2502     /* Dependent read, not valid with conditional NP2 */
2503     shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2504     mask = sample_function.coord_mask;
2505
2506     shader_glsl_get_write_mask(arg->dst, dst_swizzle);
2507
2508     shader_glsl_get_write_mask(mask, coord_mask);
2509
2510     /* with projective textures, texbem only divides the static texture coord, not the displacement,
2511          * so we can't let the GL handle this.
2512          */
2513     if (flags & WINED3DTTFF_PROJECTED) {
2514         DWORD div_mask=0;
2515         char coord_div_mask[3];
2516         switch (flags & ~WINED3DTTFF_PROJECTED) {
2517             case WINED3DTTFF_COUNT1: FIXME("WINED3DTTFF_PROJECTED with WINED3DTTFF_COUNT1?\n"); break;
2518             case WINED3DTTFF_COUNT2: div_mask = WINED3DSP_WRITEMASK_1; break;
2519             case WINED3DTTFF_COUNT3: div_mask = WINED3DSP_WRITEMASK_2; break;
2520             case WINED3DTTFF_COUNT4:
2521             case WINED3DTTFF_DISABLE: div_mask = WINED3DSP_WRITEMASK_3; break;
2522         }
2523         shader_glsl_get_write_mask(div_mask, coord_div_mask);
2524         shader_addline(arg->buffer, "T%u%s /= T%u%s;\n", sampler_idx, coord_mask, sampler_idx, coord_div_mask);
2525     }
2526
2527     shader_glsl_append_dst(arg->buffer, arg);
2528     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &coord_param);
2529     if(arg->opcode->opcode == WINED3DSIO_TEXBEML) {
2530         glsl_src_param_t luminance_param;
2531         shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &luminance_param);
2532         shader_addline(arg->buffer, "(%s(Psampler%u, T%u%s + vec4(bumpenvmat * %s, 0.0, 0.0)%s )*(%s * luminancescale + luminanceoffset))%s);\n",
2533                        sample_function.name, sampler_idx, sampler_idx, coord_mask, coord_param.param_str, coord_mask,
2534                        luminance_param.param_str, dst_swizzle);
2535     } else {
2536         shader_addline(arg->buffer, "%s(Psampler%u, T%u%s + vec4(bumpenvmat * %s, 0.0, 0.0)%s )%s);\n",
2537                        sample_function.name, sampler_idx, sampler_idx, coord_mask, coord_param.param_str, coord_mask, dst_swizzle);
2538     }
2539 }
2540
2541 void pshader_glsl_bem(SHADER_OPCODE_ARG* arg) {
2542     glsl_src_param_t src0_param, src1_param;
2543
2544     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &src0_param);
2545     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &src1_param);
2546
2547     shader_glsl_append_dst(arg->buffer, arg);
2548     shader_addline(arg->buffer, "%s + bumpenvmat * %s);\n",
2549                    src0_param.param_str, src1_param.param_str);
2550 }
2551
2552 /** Process the WINED3DSIO_TEXREG2AR instruction in GLSL
2553  * Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */
2554 void pshader_glsl_texreg2ar(SHADER_OPCODE_ARG* arg) {
2555
2556     glsl_src_param_t src0_param;
2557     DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2558     char dst_mask[6];
2559
2560     shader_glsl_append_dst(arg->buffer, arg);
2561     shader_glsl_get_write_mask(arg->dst, dst_mask);
2562     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
2563
2564     shader_addline(arg->buffer, "texture2D(Psampler%u, %s.wx)%s);\n", sampler_idx, src0_param.reg_name, dst_mask);
2565 }
2566
2567 /** Process the WINED3DSIO_TEXREG2GB instruction in GLSL
2568  * Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */
2569 void pshader_glsl_texreg2gb(SHADER_OPCODE_ARG* arg) {
2570     glsl_src_param_t src0_param;
2571     DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2572     char dst_mask[6];
2573
2574     shader_glsl_append_dst(arg->buffer, arg);
2575     shader_glsl_get_write_mask(arg->dst, dst_mask);
2576     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
2577
2578     shader_addline(arg->buffer, "texture2D(Psampler%u, %s.yz)%s);\n", sampler_idx, src0_param.reg_name, dst_mask);
2579 }
2580
2581 /** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL
2582  * Sample texture at dst using the rgb (xyz) components of src as texture coordinates */
2583 void pshader_glsl_texreg2rgb(SHADER_OPCODE_ARG* arg) {
2584     glsl_src_param_t src0_param;
2585     char dst_mask[6];
2586     DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
2587     DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
2588     glsl_sample_function_t sample_function;
2589
2590     shader_glsl_append_dst(arg->buffer, arg);
2591     shader_glsl_get_write_mask(arg->dst, dst_mask);
2592     /* Dependent read, not valid with conditional NP2 */
2593     shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
2594     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], sample_function.coord_mask, &src0_param);
2595
2596     shader_addline(arg->buffer, "%s(Psampler%u, %s)%s);\n", sample_function.name, sampler_idx, src0_param.param_str, dst_mask);
2597 }
2598
2599 /** Process the WINED3DSIO_TEXKILL instruction in GLSL.
2600  * If any of the first 3 components are < 0, discard this pixel */
2601 void pshader_glsl_texkill(SHADER_OPCODE_ARG* arg) {
2602     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
2603     DWORD hex_version = This->baseShader.hex_version;
2604     glsl_dst_param_t dst_param;
2605
2606     /* The argument is a destination parameter, and no writemasks are allowed */
2607     shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
2608     if((hex_version >= WINED3DPS_VERSION(2,0))) {
2609         /* 2.0 shaders compare all 4 components in texkill */
2610         shader_addline(arg->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name);
2611     } else {
2612         /* 1.X shaders only compare the first 3 components, probably due to the nature of the texkill
2613          * instruction as a tex* instruction, and phase, which kills all a / w components. Even if all
2614          * 4 components are defined, only the first 3 are used
2615          */
2616         shader_addline(arg->buffer, "if (any(lessThan(%s.xyz, vec3(0.0)))) discard;\n", dst_param.reg_name);
2617     }
2618 }
2619
2620 /** Process the WINED3DSIO_DP2ADD instruction in GLSL.
2621  * dst = dot2(src0, src1) + src2 */
2622 void pshader_glsl_dp2add(SHADER_OPCODE_ARG* arg) {
2623     glsl_src_param_t src0_param;
2624     glsl_src_param_t src1_param;
2625     glsl_src_param_t src2_param;
2626     DWORD write_mask;
2627     size_t mask_size;
2628
2629     write_mask = shader_glsl_append_dst(arg->buffer, arg);
2630     mask_size = shader_glsl_get_write_mask_size(write_mask);
2631
2632     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
2633     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
2634     shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], WINED3DSP_WRITEMASK_0, &src2_param);
2635
2636     shader_addline(arg->buffer, "dot(%s, %s) + %s);\n", src0_param.param_str, src1_param.param_str, src2_param.param_str);
2637 }
2638
2639 void pshader_glsl_input_pack(
2640    SHADER_BUFFER* buffer,
2641    semantic* semantics_in,
2642    IWineD3DPixelShader *iface) {
2643
2644    unsigned int i;
2645    IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface;
2646
2647    for (i = 0; i < MAX_REG_INPUT; i++) {
2648
2649        DWORD usage_token = semantics_in[i].usage;
2650        DWORD register_token = semantics_in[i].reg;
2651        DWORD usage, usage_idx;
2652        char reg_mask[6];
2653
2654        /* Uninitialized */
2655        if (!usage_token) continue;
2656        usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
2657        usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
2658        shader_glsl_get_write_mask(register_token, reg_mask);
2659
2660        switch(usage) {
2661
2662            case WINED3DDECLUSAGE_TEXCOORD:
2663                if(usage_idx < 8 && This->vertexprocessing == pretransformed) {
2664                    shader_addline(buffer, "IN[%u]%s = gl_TexCoord[%u]%s;\n",
2665                                   This->input_reg_map[i], reg_mask, usage_idx, reg_mask);
2666                } else {
2667                    shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2668                                   This->input_reg_map[i], reg_mask, reg_mask);
2669                }
2670                break;
2671
2672            case WINED3DDECLUSAGE_COLOR:
2673                if (usage_idx == 0)
2674                    shader_addline(buffer, "IN[%u]%s = vec4(gl_Color)%s;\n",
2675                        This->input_reg_map[i], reg_mask, reg_mask);
2676                else if (usage_idx == 1)
2677                    shader_addline(buffer, "IN[%u]%s = vec4(gl_SecondaryColor)%s;\n",
2678                        This->input_reg_map[i], reg_mask, reg_mask);
2679                else
2680                    shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2681                        This->input_reg_map[i], reg_mask, reg_mask);
2682                break;
2683
2684            default:
2685                shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2686                    This->input_reg_map[i], reg_mask, reg_mask);
2687         }
2688     }
2689 }
2690
2691 /*********************************************
2692  * Vertex Shader Specific Code begins here
2693  ********************************************/
2694
2695 static void add_glsl_program_entry(IWineD3DDeviceImpl *device, struct glsl_shader_prog_link *entry) {
2696     glsl_program_key_t *key;
2697
2698     key = HeapAlloc(GetProcessHeap(), 0, sizeof(glsl_program_key_t));
2699     key->vshader = entry->vshader;
2700     key->pshader = entry->pshader;
2701
2702     hash_table_put(device->glsl_program_lookup, key, entry);
2703 }
2704
2705 static struct glsl_shader_prog_link *get_glsl_program_entry(IWineD3DDeviceImpl *device,
2706         GLhandleARB vshader, GLhandleARB pshader) {
2707     glsl_program_key_t key;
2708
2709     key.vshader = vshader;
2710     key.pshader = pshader;
2711
2712     return (struct glsl_shader_prog_link *)hash_table_get(device->glsl_program_lookup, &key);
2713 }
2714
2715 void delete_glsl_program_entry(IWineD3DDevice *iface, struct glsl_shader_prog_link *entry) {
2716     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2717     WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
2718     glsl_program_key_t *key;
2719
2720     key = HeapAlloc(GetProcessHeap(), 0, sizeof(glsl_program_key_t));
2721     key->vshader = entry->vshader;
2722     key->pshader = entry->pshader;
2723     hash_table_remove(This->glsl_program_lookup, key);
2724
2725     GL_EXTCALL(glDeleteObjectARB(entry->programId));
2726     if (entry->vshader) list_remove(&entry->vshader_entry);
2727     if (entry->pshader) list_remove(&entry->pshader_entry);
2728     HeapFree(GetProcessHeap(), 0, entry->vuniformF_locations);
2729     HeapFree(GetProcessHeap(), 0, entry->puniformF_locations);
2730     HeapFree(GetProcessHeap(), 0, entry);
2731 }
2732
2733 static void handle_ps3_input(SHADER_BUFFER *buffer, semantic *semantics_in, semantic *semantics_out, WineD3D_GL_Info *gl_info, DWORD *map) {
2734     unsigned int i, j;
2735     DWORD usage_token, usage_token_out;
2736     DWORD register_token, register_token_out;
2737     DWORD usage, usage_idx, usage_out, usage_idx_out;
2738     DWORD *set;
2739     char reg_mask[6], reg_mask_out[6];
2740
2741     set = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*set) * (GL_LIMITS(glsl_varyings) / 4));
2742
2743     for(i = 0; i < MAX_REG_INPUT; i++) {
2744         usage_token = semantics_in[i].usage;
2745         if (!usage_token) continue;
2746         if(map[i] >= (GL_LIMITS(glsl_varyings) / 4)) {
2747             FIXME("More input varyings declared than supported, expect issues\n");
2748             continue;
2749         } else if(map[i] == -1) {
2750             /* Declared, but not read register */
2751             continue;
2752         }
2753         register_token = semantics_in[i].reg;
2754
2755         usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
2756         usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
2757         set[map[i]] = shader_glsl_get_write_mask(register_token, reg_mask);
2758
2759         if(!semantics_out) {
2760             switch(usage) {
2761                 case WINED3DDECLUSAGE_COLOR:
2762                     if (usage_idx == 0)
2763                         shader_addline(buffer, "IN[%u]%s = gl_FrontColor%s;\n",
2764                                        map[i], reg_mask, reg_mask);
2765                     else if (usage_idx == 1)
2766                         shader_addline(buffer, "IN[%u]%s = gl_FrontSecondaryColor%s;\n",
2767                                        map[i], reg_mask, reg_mask);
2768                     else
2769                         shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2770                                        map[i], reg_mask, reg_mask);
2771                     break;
2772
2773                 case WINED3DDECLUSAGE_TEXCOORD:
2774                     if (usage_idx < 8) {
2775                         shader_addline(buffer, "IN[%u]%s = gl_TexCoord[%u]%s;\n",
2776                                        map[i], reg_mask, usage_idx, reg_mask);
2777                     } else {
2778                         shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2779                                        map[i], reg_mask, reg_mask);
2780                     }
2781                     break;
2782
2783                 case WINED3DDECLUSAGE_FOG:
2784                     shader_addline(buffer, "IN[%u]%s = vec4(gl_FogFragCoord, 0.0, 0.0, 0.0)%s;\n",
2785                                    map[i], reg_mask, reg_mask);
2786                     break;
2787
2788                 default:
2789                     shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2790                                    map[i], reg_mask, reg_mask);
2791             }
2792         } else {
2793             BOOL found = FALSE;
2794             for(j = 0; j < MAX_REG_OUTPUT; j++) {
2795                 usage_token_out = semantics_out[j].usage;
2796                 if (!usage_token_out) continue;
2797                 register_token_out = semantics_out[j].reg;
2798
2799                 usage_out = (usage_token_out & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
2800                 usage_idx_out = (usage_token_out & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
2801                 shader_glsl_get_write_mask(register_token_out, reg_mask_out);
2802
2803                 if(usage == usage_out &&
2804                    usage_idx == usage_idx_out) {
2805                     shader_addline(buffer, "IN[%u]%s = OUT[%u]%s;\n",
2806                                    map[i], reg_mask, j, reg_mask);
2807                     found = TRUE;
2808                 }
2809             }
2810             if(!found) {
2811                 shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
2812                                map[i], reg_mask, reg_mask);
2813             }
2814         }
2815     }
2816
2817     /* This is solely to make the compiler / linker happy and avoid warning about undefined
2818      * varyings. It shouldn't result in any real code executed on the GPU, since all read
2819      * input varyings are assigned above, if the optimizer works properly.
2820      */
2821     for(i = 0; i < GL_LIMITS(glsl_varyings) / 4; i++) {
2822         if(set[i] != WINED3DSP_WRITEMASK_ALL) {
2823             unsigned int size = 0;
2824             memset(reg_mask, 0, sizeof(reg_mask));
2825             if(!(set[i] & WINED3DSP_WRITEMASK_0)) {
2826                 reg_mask[size] = 'x';
2827                 size++;
2828             }
2829             if(!(set[i] & WINED3DSP_WRITEMASK_1)) {
2830                 reg_mask[size] = 'y';
2831                 size++;
2832             }
2833             if(!(set[i] & WINED3DSP_WRITEMASK_2)) {
2834                 reg_mask[size] = 'z';
2835                 size++;
2836             }
2837             if(!(set[i] & WINED3DSP_WRITEMASK_3)) {
2838                 reg_mask[size] = 'w';
2839                 size++;
2840             }
2841             switch(size) {
2842                 case 1:
2843                     shader_addline(buffer, "IN[%u].%s = 0.0;\n", i, reg_mask);
2844                     break;
2845                 case 2:
2846                     shader_addline(buffer, "IN[%u].%s = vec2(0.0, 0.0);\n", i, reg_mask);
2847                     break;
2848                 case 3:
2849                     shader_addline(buffer, "IN[%u].%s = vec3(0.0, 0.0, 0.0);\n", i, reg_mask);
2850                     break;
2851                 case 4:
2852                     shader_addline(buffer, "IN[%u].%s = vec4(0.0, 0.0, 0.0, 0.0);\n", i, reg_mask);
2853                     break;
2854             }
2855         }
2856     }
2857
2858     HeapFree(GetProcessHeap(), 0, set);
2859 }
2860
2861 static GLhandleARB generate_param_reorder_function(IWineD3DVertexShader *vertexshader,
2862         IWineD3DPixelShader *pixelshader,
2863         WineD3D_GL_Info *gl_info) {
2864     GLhandleARB ret = 0;
2865     IWineD3DVertexShaderImpl *vs = (IWineD3DVertexShaderImpl *) vertexshader;
2866     IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) pixelshader;
2867     DWORD vs_major = vs ? WINED3DSHADER_VERSION_MAJOR(vs->baseShader.hex_version) : 0;
2868     DWORD ps_major = ps ? WINED3DSHADER_VERSION_MAJOR(ps->baseShader.hex_version) : 0;
2869     unsigned int i;
2870     SHADER_BUFFER buffer;
2871     DWORD usage_token;
2872     DWORD register_token;
2873     DWORD usage, usage_idx, writemask;
2874     char reg_mask[6];
2875     semantic *semantics_out, *semantics_in;
2876
2877     buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE);
2878     buffer.bsize = 0;
2879     buffer.lineNo = 0;
2880     buffer.newline = TRUE;
2881
2882     if(vs_major < 3 && ps_major < 3) {
2883         /* That one is easy: The vertex shader writes to the builtin varyings, the pixel shader reads from them.
2884          * Take care about the texcoord .w fixup though if we're using the fixed function fragment pipeline
2885          */
2886         if((GLINFO_LOCATION).set_texcoord_w && ps_major == 0 && vs_major > 0) {
2887             shader_addline(&buffer, "void order_ps_input() {\n");
2888             for(i = 0; i < min(8, MAX_REG_TEXCRD); i++) {
2889                 if(vs->baseShader.reg_maps.texcoord_mask[i] != 0 &&
2890                    vs->baseShader.reg_maps.texcoord_mask[i] != WINED3DSP_WRITEMASK_ALL) {
2891                     shader_addline(&buffer, "gl_TexCoord[%u].w = 1.0;\n", i);
2892                 }
2893             }
2894             shader_addline(&buffer, "}\n");
2895         } else {
2896             shader_addline(&buffer, "void order_ps_input() { /* do nothing */ }\n");
2897         }
2898     } else if(ps_major < 3 && vs_major >= 3) {
2899         /* The vertex shader writes to its own varyings, the pixel shader needs them in the builtin ones */
2900         semantics_out = vs->semantics_out;
2901
2902         shader_addline(&buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
2903         for(i = 0; i < MAX_REG_OUTPUT; i++) {
2904             usage_token = semantics_out[i].usage;
2905             if (!usage_token) continue;
2906             register_token = semantics_out[i].reg;
2907
2908             usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
2909             usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
2910             writemask = shader_glsl_get_write_mask(register_token, reg_mask);
2911
2912             switch(usage) {
2913                 case WINED3DDECLUSAGE_COLOR:
2914                     if (usage_idx == 0)
2915                         shader_addline(&buffer, "gl_FrontColor%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
2916                     else if (usage_idx == 1)
2917                         shader_addline(&buffer, "gl_FrontSecondaryColor%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
2918                     break;
2919
2920                 case WINED3DDECLUSAGE_POSITION:
2921                     shader_addline(&buffer, "gl_Position%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
2922                     break;
2923
2924                 case WINED3DDECLUSAGE_TEXCOORD:
2925                     if (usage_idx < 8) {
2926                         if(!(GLINFO_LOCATION).set_texcoord_w || ps_major > 0) writemask |= WINED3DSP_WRITEMASK_3;
2927
2928                         shader_addline(&buffer, "gl_TexCoord[%u]%s = OUT[%u]%s;\n",
2929                                         usage_idx, reg_mask, i, reg_mask);
2930                         if(!(writemask & WINED3DSP_WRITEMASK_3)) {
2931                             shader_addline(&buffer, "gl_TexCoord[%u].w = 1.0;\n", usage_idx);
2932                         }
2933                     }
2934                     break;
2935
2936                 case WINED3DDECLUSAGE_PSIZE:
2937                     shader_addline(&buffer, "gl_PointSize = OUT[%u].x;\n", i);
2938                     break;
2939
2940                 case WINED3DDECLUSAGE_FOG:
2941                     shader_addline(&buffer, "gl_FogFragCoord = OUT[%u].%c;\n", i, reg_mask[1]);
2942                     break;
2943
2944                 default:
2945                     break;
2946             }
2947         }
2948         shader_addline(&buffer, "}\n");
2949
2950     } else if(ps_major >= 3 && vs_major >= 3) {
2951         semantics_out = vs->semantics_out;
2952         semantics_in = ps->semantics_in;
2953
2954         /* This one is tricky: a 3.0 pixel shader reads from a 3.0 vertex shader */
2955         shader_addline(&buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
2956         shader_addline(&buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
2957
2958         /* First, sort out position and point size. Those are not passed to the pixel shader */
2959         for(i = 0; i < MAX_REG_OUTPUT; i++) {
2960             usage_token = semantics_out[i].usage;
2961             if (!usage_token) continue;
2962             register_token = semantics_out[i].reg;
2963
2964             usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
2965             usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
2966             shader_glsl_get_write_mask(register_token, reg_mask);
2967
2968             switch(usage) {
2969                 case WINED3DDECLUSAGE_POSITION:
2970                     shader_addline(&buffer, "gl_Position%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
2971                     break;
2972
2973                 case WINED3DDECLUSAGE_PSIZE:
2974                     shader_addline(&buffer, "gl_PointSize = OUT[%u].x;\n", i);
2975                     break;
2976
2977                 default:
2978                     break;
2979             }
2980         }
2981
2982         /* Then, fix the pixel shader input */
2983         handle_ps3_input(&buffer, semantics_in, semantics_out, gl_info, ps->input_reg_map);
2984
2985         shader_addline(&buffer, "}\n");
2986     } else if(ps_major >= 3 && vs_major < 3) {
2987         semantics_in = ps->semantics_in;
2988
2989         shader_addline(&buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
2990         shader_addline(&buffer, "void order_ps_input() {\n");
2991         /* The vertex shader wrote to the builtin varyings. There is no need to figure out position and
2992          * point size, but we depend on the optimizers kindness to find out that the pixel shader doesn't
2993          * read gl_TexCoord and gl_ColorX, otherwise we'll run out of varyings
2994          */
2995         handle_ps3_input(&buffer, semantics_in, NULL, gl_info, ps->input_reg_map);
2996         shader_addline(&buffer, "}\n");
2997     } else {
2998         ERR("Unexpected vertex and pixel shader version condition: vs: %d, ps: %d\n", vs_major, ps_major);
2999     }
3000
3001     ret = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
3002     checkGLcall("glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)");
3003     GL_EXTCALL(glShaderSourceARB(ret, 1, (const char**)&buffer.buffer, NULL));
3004     checkGLcall("glShaderSourceARB(ret, 1, (const char**)&buffer.buffer, NULL)");
3005     GL_EXTCALL(glCompileShaderARB(ret));
3006     checkGLcall("glCompileShaderARB(ret)");
3007
3008     HeapFree(GetProcessHeap(), 0, buffer.buffer);
3009     return ret;
3010 }
3011
3012 /** Sets the GLSL program ID for the given pixel and vertex shader combination.
3013  * It sets the programId on the current StateBlock (because it should be called
3014  * inside of the DrawPrimitive() part of the render loop).
3015  *
3016  * If a program for the given combination does not exist, create one, and store
3017  * the program in the hash table.  If it creates a program, it will link the
3018  * given objects, too.
3019  */
3020 static void set_glsl_shader_program(IWineD3DDevice *iface, BOOL use_ps, BOOL use_vs) {
3021     IWineD3DDeviceImpl *This               = (IWineD3DDeviceImpl *)iface;
3022     WineD3D_GL_Info *gl_info               = &This->adapter->gl_info;
3023     IWineD3DPixelShader  *pshader          = This->stateBlock->pixelShader;
3024     IWineD3DVertexShader *vshader          = This->stateBlock->vertexShader;
3025     struct glsl_shader_prog_link *entry    = NULL;
3026     GLhandleARB programId                  = 0;
3027     GLhandleARB reorder_shader_id          = 0;
3028     int i;
3029     char glsl_name[8];
3030
3031     GLhandleARB vshader_id = use_vs ? ((IWineD3DBaseShaderImpl*)vshader)->baseShader.prgId : 0;
3032     GLhandleARB pshader_id = use_ps ? ((IWineD3DBaseShaderImpl*)pshader)->baseShader.prgId : 0;
3033     entry = get_glsl_program_entry(This, vshader_id, pshader_id);
3034     if (entry) {
3035         This->stateBlock->glsl_program = entry;
3036         return;
3037     }
3038
3039     /* If we get to this point, then no matching program exists, so we create one */
3040     programId = GL_EXTCALL(glCreateProgramObjectARB());
3041     TRACE("Created new GLSL shader program %u\n", programId);
3042
3043     /* Create the entry */
3044     entry = HeapAlloc(GetProcessHeap(), 0, sizeof(struct glsl_shader_prog_link));
3045     entry->programId = programId;
3046     entry->vshader = vshader_id;
3047     entry->pshader = pshader_id;
3048     /* Add the hash table entry */
3049     add_glsl_program_entry(This, entry);
3050
3051     /* Set the current program */
3052     This->stateBlock->glsl_program = entry;
3053
3054     /* Attach GLSL vshader */
3055     if (vshader_id) {
3056         int max_attribs = 16;   /* TODO: Will this always be the case? It is at the moment... */
3057         char tmp_name[10];
3058
3059         reorder_shader_id = generate_param_reorder_function(vshader, pshader, gl_info);
3060         TRACE("Attaching GLSL shader object %u to program %u\n", reorder_shader_id, programId);
3061         GL_EXTCALL(glAttachObjectARB(programId, reorder_shader_id));
3062         checkGLcall("glAttachObjectARB");
3063         /* Flag the reorder function for deletion, then it will be freed automatically when the program
3064          * is destroyed
3065          */
3066         GL_EXTCALL(glDeleteObjectARB(reorder_shader_id));
3067
3068         TRACE("Attaching GLSL shader object %u to program %u\n", vshader_id, programId);
3069         GL_EXTCALL(glAttachObjectARB(programId, vshader_id));
3070         checkGLcall("glAttachObjectARB");
3071
3072         /* Bind vertex attributes to a corresponding index number to match
3073          * the same index numbers as ARB_vertex_programs (makes loading
3074          * vertex attributes simpler).  With this method, we can use the
3075          * exact same code to load the attributes later for both ARB and
3076          * GLSL shaders.
3077          *
3078          * We have to do this here because we need to know the Program ID
3079          * in order to make the bindings work, and it has to be done prior
3080          * to linking the GLSL program. */
3081         for (i = 0; i < max_attribs; ++i) {
3082             if (((IWineD3DBaseShaderImpl*)vshader)->baseShader.reg_maps.attributes[i]) {
3083                 snprintf(tmp_name, sizeof(tmp_name), "attrib%i", i);
3084                 GL_EXTCALL(glBindAttribLocationARB(programId, i, tmp_name));
3085             }
3086         }
3087         checkGLcall("glBindAttribLocationARB");
3088
3089         list_add_head(&((IWineD3DBaseShaderImpl *)vshader)->baseShader.linked_programs, &entry->vshader_entry);
3090     }
3091
3092     /* Attach GLSL pshader */
3093     if (pshader_id) {
3094         TRACE("Attaching GLSL shader object %u to program %u\n", pshader_id, programId);
3095         GL_EXTCALL(glAttachObjectARB(programId, pshader_id));
3096         checkGLcall("glAttachObjectARB");
3097
3098         list_add_head(&((IWineD3DBaseShaderImpl *)pshader)->baseShader.linked_programs, &entry->pshader_entry);
3099     }
3100
3101     /* Link the program */
3102     TRACE("Linking GLSL shader program %u\n", programId);
3103     GL_EXTCALL(glLinkProgramARB(programId));
3104     print_glsl_info_log(&GLINFO_LOCATION, programId);
3105
3106     entry->vuniformF_locations = HeapAlloc(GetProcessHeap(), 0, sizeof(GLhandleARB) * GL_LIMITS(vshader_constantsF));
3107     for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
3108         snprintf(glsl_name, sizeof(glsl_name), "VC[%i]", i);
3109         entry->vuniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3110     }
3111     for (i = 0; i < MAX_CONST_I; ++i) {
3112         snprintf(glsl_name, sizeof(glsl_name), "VI[%i]", i);
3113         entry->vuniformI_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3114     }
3115     entry->puniformF_locations = HeapAlloc(GetProcessHeap(), 0, sizeof(GLhandleARB) * GL_LIMITS(pshader_constantsF));
3116     for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i) {
3117         snprintf(glsl_name, sizeof(glsl_name), "PC[%i]", i);
3118         entry->puniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3119     }
3120     for (i = 0; i < MAX_CONST_I; ++i) {
3121         snprintf(glsl_name, sizeof(glsl_name), "PI[%i]", i);
3122         entry->puniformI_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3123     }
3124
3125     entry->posFixup_location = GL_EXTCALL(glGetUniformLocationARB(programId, "posFixup"));
3126     entry->bumpenvmat_location = GL_EXTCALL(glGetUniformLocationARB(programId, "bumpenvmat"));
3127     entry->luminancescale_location = GL_EXTCALL(glGetUniformLocationARB(programId, "luminancescale"));
3128     entry->luminanceoffset_location = GL_EXTCALL(glGetUniformLocationARB(programId, "luminanceoffset"));
3129     entry->srgb_comparison_location = GL_EXTCALL(glGetUniformLocationARB(programId, "srgb_comparison"));
3130     entry->srgb_mul_low_location = GL_EXTCALL(glGetUniformLocationARB(programId, "srgb_mul_low"));
3131     entry->ycorrection_location = GL_EXTCALL(glGetUniformLocationARB(programId, "ycorrection"));
3132     checkGLcall("Find glsl program uniform locations");
3133
3134     /* Set the shader to allow uniform loading on it */
3135     GL_EXTCALL(glUseProgramObjectARB(programId));
3136     checkGLcall("glUseProgramObjectARB(programId)");
3137
3138     /* Load the vertex and pixel samplers now. The function that finds the mappings makes sure
3139      * that it stays the same for each vertexshader-pixelshader pair(=linked glsl program). If
3140      * a pshader with fixed function pipeline is used there are no vertex samplers, and if a
3141      * vertex shader with fixed function pixel processing is used we make sure that the card
3142      * supports enough samplers to allow the max number of vertex samplers with all possible
3143      * fixed function fragment processing setups. So once the program is linked these samplers
3144      * won't change.
3145      */
3146     if(vshader_id) {
3147         /* Load vertex shader samplers */
3148         shader_glsl_load_vsamplers(gl_info, (IWineD3DStateBlock*)This->stateBlock, programId);
3149     }
3150     if(pshader_id) {
3151         /* Load pixel shader samplers */
3152         shader_glsl_load_psamplers(gl_info, (IWineD3DStateBlock*)This->stateBlock, programId);
3153     }
3154 }
3155
3156 static GLhandleARB create_glsl_blt_shader(WineD3D_GL_Info *gl_info) {
3157     GLhandleARB program_id;
3158     GLhandleARB vshader_id, pshader_id;
3159     const char *blt_vshader[] = {
3160         "void main(void)\n"
3161         "{\n"
3162         "    gl_Position = gl_Vertex;\n"
3163         "    gl_FrontColor = vec4(1.0);\n"
3164         "    gl_TexCoord[0].x = (gl_Vertex.x * 0.5) + 0.5;\n"
3165         "    gl_TexCoord[0].y = (-gl_Vertex.y * 0.5) + 0.5;\n"
3166         "}\n"
3167     };
3168
3169     const char *blt_pshader[] = {
3170         "uniform sampler2D sampler;\n"
3171         "void main(void)\n"
3172         "{\n"
3173         "    gl_FragDepth = texture2D(sampler, gl_TexCoord[0].xy).x;\n"
3174         "}\n"
3175     };
3176
3177     vshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
3178     GL_EXTCALL(glShaderSourceARB(vshader_id, 1, blt_vshader, NULL));
3179     GL_EXTCALL(glCompileShaderARB(vshader_id));
3180
3181     pshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
3182     GL_EXTCALL(glShaderSourceARB(pshader_id, 1, blt_pshader, NULL));
3183     GL_EXTCALL(glCompileShaderARB(pshader_id));
3184
3185     program_id = GL_EXTCALL(glCreateProgramObjectARB());
3186     GL_EXTCALL(glAttachObjectARB(program_id, vshader_id));
3187     GL_EXTCALL(glAttachObjectARB(program_id, pshader_id));
3188     GL_EXTCALL(glLinkProgramARB(program_id));
3189
3190     print_glsl_info_log(&GLINFO_LOCATION, program_id);
3191
3192     return program_id;
3193 }
3194
3195 static void shader_glsl_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {
3196     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3197     WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3198     GLhandleARB program_id = 0;
3199
3200     if (useVS || usePS) set_glsl_shader_program(iface, usePS, useVS);
3201     else This->stateBlock->glsl_program = NULL;
3202
3203     program_id = This->stateBlock->glsl_program ? This->stateBlock->glsl_program->programId : 0;
3204     if (program_id) TRACE("Using GLSL program %u\n", program_id);
3205     GL_EXTCALL(glUseProgramObjectARB(program_id));
3206     checkGLcall("glUseProgramObjectARB");
3207 }
3208
3209 static void shader_glsl_select_depth_blt(IWineD3DDevice *iface) {
3210     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3211     WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3212     static GLhandleARB program_id = 0;
3213     static GLhandleARB loc = -1;
3214
3215     if (!program_id) {
3216         program_id = create_glsl_blt_shader(gl_info);
3217         loc = GL_EXTCALL(glGetUniformLocationARB(program_id, "sampler"));
3218     }
3219
3220     GL_EXTCALL(glUseProgramObjectARB(program_id));
3221     GL_EXTCALL(glUniform1iARB(loc, 0));
3222 }
3223
3224 static void shader_glsl_cleanup(IWineD3DDevice *iface) {
3225     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3226     WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
3227     GL_EXTCALL(glUseProgramObjectARB(0));
3228 }
3229
3230 static void shader_glsl_destroy(IWineD3DBaseShader *iface) {
3231     struct list *linked_programs;
3232     IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) iface;
3233     WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *) This->baseShader.device)->adapter->gl_info;
3234
3235     /* Note: Do not use QueryInterface here to find out which shader type this is because this code
3236      * can be called from IWineD3DBaseShader::Release
3237      */
3238     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
3239
3240     if(This->baseShader.prgId == 0) return;
3241     linked_programs = &This->baseShader.linked_programs;
3242
3243     TRACE("Deleting linked programs\n");
3244     if (linked_programs->next) {
3245         struct glsl_shader_prog_link *entry, *entry2;
3246
3247         if(pshader) {
3248             LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, pshader_entry) {
3249                 delete_glsl_program_entry(This->baseShader.device, entry);
3250             }
3251         } else {
3252             LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, vshader_entry) {
3253                 delete_glsl_program_entry(This->baseShader.device, entry);
3254             }
3255         }
3256     }
3257
3258     TRACE("Deleting shader object %u\n", This->baseShader.prgId);
3259     GL_EXTCALL(glDeleteObjectARB(This->baseShader.prgId));
3260     checkGLcall("glDeleteObjectARB");
3261 }
3262
3263 const shader_backend_t glsl_shader_backend = {
3264     &shader_glsl_select,
3265     &shader_glsl_select_depth_blt,
3266     &shader_glsl_load_constants,
3267     &shader_glsl_cleanup,
3268     &shader_glsl_color_correction,
3269     &shader_glsl_destroy
3270 };