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  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
   7  * Copyright 2009-2011 Henri Verbeet for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 /*
  25  * D3D shader asm has swizzles on source parameters, and write masks for
  26  * destination parameters. GLSL uses swizzles for both. The result of this is
  27  * that for example "mov dst.xw, src.zyxw" becomes "dst.xw = src.zw" in GLSL.
  28  * Ie, to generate a proper GLSL source swizzle, we need to take the D3D write
  29  * mask for the destination parameter into account.
  30  */
  31
  32 #include "config.h"
  33 #include "wine/port.h"
  34
  35 #include <limits.h>
  36 #include <stdio.h>
  37
  38 #include "wined3d_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  41 WINE_DECLARE_DEBUG_CHANNEL(d3d_constants);
  42 WINE_DECLARE_DEBUG_CHANNEL(d3d);
  43 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  44
  45 #define WINED3D_GLSL_SAMPLE_PROJECTED   0x1
  46 #define WINED3D_GLSL_SAMPLE_NPOT        0x2
  47 #define WINED3D_GLSL_SAMPLE_LOD         0x4
  48 #define WINED3D_GLSL_SAMPLE_GRAD        0x8
  49
  50 struct glsl_dst_param
  51 {
  52     char reg_name[150];
  53     char mask_str[6];
  54 };
  55
  56 struct glsl_src_param
  57 {
  58     char reg_name[150];
  59     char param_str[200];
  60 };
  61
  62 struct glsl_sample_function
  63 {
  64     const char *name;
  65     DWORD coord_mask;
  66 };
  67
  68 enum heap_node_op
  69 {
  70     HEAP_NODE_TRAVERSE_LEFT,
  71     HEAP_NODE_TRAVERSE_RIGHT,
  72     HEAP_NODE_POP,
  73 };
  74
  75 struct constant_entry
  76 {
  77     unsigned int idx;
  78     unsigned int version;
  79 };
  80
  81 struct constant_heap
  82 {
  83     struct constant_entry *entries;
  84     unsigned int *positions;
  85     unsigned int size;
  86 };
  87
  88 /* GLSL shader private data */
  89 struct shader_glsl_priv {
  90     struct wined3d_shader_buffer shader_buffer;
  91     struct wine_rb_tree program_lookup;
  92     struct glsl_shader_prog_link *glsl_program;
  93     struct constant_heap vconst_heap;
  94     struct constant_heap pconst_heap;
  95     unsigned char *stack;
  96     GLhandleARB depth_blt_program_full[tex_type_count];
  97     GLhandleARB depth_blt_program_masked[tex_type_count];
  98     UINT next_constant_version;
  99
 100     const struct fragment_pipeline *fragment_pipe;
 101     struct wine_rb_tree ffp_fragment_shaders;
 102     BOOL ffp_proj_control;
 103 };
 104
 105 struct glsl_vs_program
 106 {
 107     struct list shader_entry;
 108     GLhandleARB id;
 109     GLenum vertex_color_clamp;
 110     GLint *uniform_f_locations;
 111     GLint uniform_i_locations[MAX_CONST_I];
 112     GLint pos_fixup_location;
 113 };
 114
 115 struct glsl_gs_program
 116 {
 117     struct list shader_entry;
 118     GLhandleARB id;
 119 };
 120
 121 struct glsl_ps_program
 122 {
 123     struct list shader_entry;
 124     GLhandleARB id;
 125     GLint *uniform_f_locations;
 126     GLint uniform_i_locations[MAX_CONST_I];
 127     GLint bumpenv_mat_location[MAX_TEXTURES];
 128     GLint bumpenv_lum_scale_location[MAX_TEXTURES];
 129     GLint bumpenv_lum_offset_location[MAX_TEXTURES];
 130     GLint tex_factor_location;
 131     GLint specular_enable_location;
 132     GLint ycorrection_location;
 133     GLint np2_fixup_location;
 134     const struct ps_np2fixup_info *np2_fixup_info;
 135 };
 136
 137 /* Struct to maintain data about a linked GLSL program */
 138 struct glsl_shader_prog_link
 139 {
 140     struct wine_rb_entry program_lookup_entry;
 141     struct glsl_vs_program vs;
 142     struct glsl_gs_program gs;
 143     struct glsl_ps_program ps;
 144     GLhandleARB programId;
 145     UINT constant_version;
 146 };
 147
 148 struct glsl_program_key
 149 {
 150     GLhandleARB vs_id;
 151     GLhandleARB gs_id;
 152     GLhandleARB ps_id;
 153 };
 154
 155 struct shader_glsl_ctx_priv {
 156     const struct vs_compile_args    *cur_vs_args;
 157     const struct ps_compile_args    *cur_ps_args;
 158     struct ps_np2fixup_info         *cur_np2fixup_info;
 159 };
 160
 161 struct glsl_ps_compiled_shader
 162 {
 163     struct ps_compile_args          args;
 164     struct ps_np2fixup_info         np2fixup;
 165     GLhandleARB                     prgId;
 166 };
 167
 168 struct glsl_vs_compiled_shader
 169 {
 170     struct vs_compile_args          args;
 171     GLhandleARB                     prgId;
 172 };
 173
 174 struct glsl_gs_compiled_shader
 175 {
 176     GLhandleARB id;
 177 };
 178
 179 struct glsl_shader_private
 180 {
 181     union
 182     {
 183         struct glsl_vs_compiled_shader *vs;
 184         struct glsl_gs_compiled_shader *gs;
 185         struct glsl_ps_compiled_shader *ps;
 186     } gl_shaders;
 187     UINT num_gl_shaders, shader_array_size;
 188 };
 189
 190 struct glsl_ffp_fragment_shader
 191 {
 192     struct ffp_frag_desc entry;
 193     GLhandleARB id;
 194     struct list linked_programs;
 195 };
 196
 197 static const char *debug_gl_shader_type(GLenum type)
 198 {
 199     switch (type)
 200     {
 201 #define WINED3D_TO_STR(u) case u: return #u
 202         WINED3D_TO_STR(GL_VERTEX_SHADER_ARB);
 203         WINED3D_TO_STR(GL_GEOMETRY_SHADER_ARB);
 204         WINED3D_TO_STR(GL_FRAGMENT_SHADER_ARB);
 205 #undef WINED3D_TO_STR
 206         default:
 207             return wine_dbg_sprintf("UNKNOWN(%#x)", type);
 208     }
 209 }
 210
 211 static const char *shader_glsl_get_prefix(enum wined3d_shader_type type)
 212 {
 213     switch (type)
 214     {
 215         case WINED3D_SHADER_TYPE_VERTEX:
 216             return "vs";
 217
 218         case WINED3D_SHADER_TYPE_GEOMETRY:
 219             return "gs";
 220
 221         case WINED3D_SHADER_TYPE_PIXEL:
 222             return "ps";
 223
 224         default:
 225             FIXME("Unhandled shader type %#x.\n", type);
 226             return "unknown";
 227     }
 228 }
 229
 230 /* Extract a line from the info log.
 231  * Note that this modifies the source string. */
 232 static char *get_info_log_line(char **ptr)
 233 {
 234     char *p, *q;
 235
 236     p = *ptr;
 237     if (!(q = strstr(p, "\n")))
 238     {
 239         if (!*p) return NULL;
 240         *ptr += strlen(p);
 241         return p;
 242     }
 243     *q = '\0';
 244     *ptr = q + 1;
 245
 246     return p;
 247 }
 248
 249 /* Context activation is done by the caller. */
 250 static void print_glsl_info_log(const struct wined3d_gl_info *gl_info, GLhandleARB obj)
 251 {
 252     int infologLength = 0;
 253     char *infoLog;
 254
 255     if (!WARN_ON(d3d_shader) && !FIXME_ON(d3d_shader))
 256         return;
 257
 258     GL_EXTCALL(glGetObjectParameterivARB(obj,
 259                GL_OBJECT_INFO_LOG_LENGTH_ARB,
 260                &infologLength));
 261
 262     /* A size of 1 is just a null-terminated string, so the log should be bigger than
 263      * that if there are errors. */
 264     if (infologLength > 1)
 265     {
 266         char *ptr, *line;
 267
 268         infoLog = HeapAlloc(GetProcessHeap(), 0, infologLength);
 269         /* The info log is supposed to be zero-terminated, but at least some
 270          * versions of fglrx don't terminate the string properly. The reported
 271          * length does include the terminator, so explicitly set it to zero
 272          * here. */
 273         infoLog[infologLength - 1] = 0;
 274         GL_EXTCALL(glGetInfoLogARB(obj, infologLength, NULL, infoLog));
 275
 276         ptr = infoLog;
 277         if (gl_info->quirks & WINED3D_QUIRK_INFO_LOG_SPAM)
 278         {
 279             WARN("Info log received from GLSL shader #%u:\n", obj);
 280             while ((line = get_info_log_line(&ptr))) WARN("    %s\n", line);
 281         }
 282         else
 283         {
 284             FIXME("Info log received from GLSL shader #%u:\n", obj);
 285             while ((line = get_info_log_line(&ptr))) FIXME("    %s\n", line);
 286         }
 287         HeapFree(GetProcessHeap(), 0, infoLog);
 288     }
 289 }
 290
 291 /* Context activation is done by the caller. */
 292 static void shader_glsl_compile(const struct wined3d_gl_info *gl_info, GLhandleARB shader, const char *src)
 293 {
 294     TRACE("Compiling shader object %u.\n", shader);
 295     GL_EXTCALL(glShaderSourceARB(shader, 1, &src, NULL));
 296     checkGLcall("glShaderSourceARB");
 297     GL_EXTCALL(glCompileShaderARB(shader));
 298     checkGLcall("glCompileShaderARB");
 299     print_glsl_info_log(gl_info, shader);
 300 }
 301
 302 /* Context activation is done by the caller. */
 303 static void shader_glsl_dump_program_source(const struct wined3d_gl_info *gl_info, GLhandleARB program)
 304 {
 305     GLint i, object_count, source_size = -1;
 306     GLhandleARB *objects;
 307     char *source = NULL;
 308
 309     GL_EXTCALL(glGetObjectParameterivARB(program, GL_OBJECT_ATTACHED_OBJECTS_ARB, &object_count));
 310     objects = HeapAlloc(GetProcessHeap(), 0, object_count * sizeof(*objects));
 311     if (!objects)
 312     {
 313         ERR("Failed to allocate object array memory.\n");
 314         return;
 315     }
 316
 317     GL_EXTCALL(glGetAttachedObjectsARB(program, object_count, NULL, objects));
 318     for (i = 0; i < object_count; ++i)
 319     {
 320         char *ptr, *line;
 321         GLint tmp;
 322
 323         GL_EXTCALL(glGetObjectParameterivARB(objects[i], GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, &tmp));
 324
 325         if (source_size < tmp)
 326         {
 327             HeapFree(GetProcessHeap(), 0, source);
 328
 329             source = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, tmp);
 330             if (!source)
 331             {
 332                 ERR("Failed to allocate %d bytes for shader source.\n", tmp);
 333                 HeapFree(GetProcessHeap(), 0, objects);
 334                 return;
 335             }
 336             source_size = tmp;
 337         }
 338
 339         FIXME("Object %u:\n", objects[i]);
 340         GL_EXTCALL(glGetObjectParameterivARB(objects[i], GL_OBJECT_SUBTYPE_ARB, &tmp));
 341         FIXME("    GL_OBJECT_SUBTYPE_ARB: %s.\n", debug_gl_shader_type(tmp));
 342         GL_EXTCALL(glGetObjectParameterivARB(objects[i], GL_OBJECT_COMPILE_STATUS_ARB, &tmp));
 343         FIXME("    GL_OBJECT_COMPILE_STATUS_ARB: %d.\n", tmp);
 344         FIXME("\n");
 345
 346         ptr = source;
 347         GL_EXTCALL(glGetShaderSourceARB(objects[i], source_size, NULL, source));
 348         while ((line = get_info_log_line(&ptr))) FIXME("    %s\n", line);
 349         FIXME("\n");
 350     }
 351
 352     HeapFree(GetProcessHeap(), 0, source);
 353     HeapFree(GetProcessHeap(), 0, objects);
 354 }
 355
 356 /* Context activation is done by the caller. */
 357 static void shader_glsl_validate_link(const struct wined3d_gl_info *gl_info, GLhandleARB program)
 358 {
 359     GLint tmp;
 360
 361     if (!TRACE_ON(d3d_shader) && !FIXME_ON(d3d_shader)) return;
 362
 363     GL_EXTCALL(glGetObjectParameterivARB(program, GL_OBJECT_TYPE_ARB, &tmp));
 364     if (tmp == GL_PROGRAM_OBJECT_ARB)
 365     {
 366         GL_EXTCALL(glGetObjectParameterivARB(program, GL_OBJECT_LINK_STATUS_ARB, &tmp));
 367         if (!tmp)
 368         {
 369             FIXME("Program %u link status invalid.\n", program);
 370             shader_glsl_dump_program_source(gl_info, program);
 371         }
 372     }
 373
 374     print_glsl_info_log(gl_info, program);
 375 }
 376
 377 /* Context activation is done by the caller. */
 378 static void shader_glsl_load_psamplers(const struct wined3d_gl_info *gl_info,
 379         const DWORD *tex_unit_map, GLhandleARB programId)
 380 {
 381     GLint name_loc;
 382     char sampler_name[20];
 383     unsigned int i;
 384
 385     for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
 386     {
 387         snprintf(sampler_name, sizeof(sampler_name), "ps_sampler%u", i);
 388         name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
 389         if (name_loc != -1) {
 390             DWORD mapped_unit = tex_unit_map[i];
 391             if (mapped_unit != WINED3D_UNMAPPED_STAGE && mapped_unit < gl_info->limits.fragment_samplers)
 392             {
 393                 TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
 394                 GL_EXTCALL(glUniform1iARB(name_loc, mapped_unit));
 395                 checkGLcall("glUniform1iARB");
 396             } else {
 397                 ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
 398             }
 399         }
 400     }
 401 }
 402
 403 /* Context activation is done by the caller. */
 404 static void shader_glsl_load_vsamplers(const struct wined3d_gl_info *gl_info,
 405         const DWORD *tex_unit_map, GLhandleARB programId)
 406 {
 407     GLint name_loc;
 408     char sampler_name[20];
 409     unsigned int i;
 410
 411     for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i)
 412     {
 413         snprintf(sampler_name, sizeof(sampler_name), "vs_sampler%u", i);
 414         name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
 415         if (name_loc != -1) {
 416             DWORD mapped_unit = tex_unit_map[MAX_FRAGMENT_SAMPLERS + i];
 417             if (mapped_unit != WINED3D_UNMAPPED_STAGE && mapped_unit < gl_info->limits.combined_samplers)
 418             {
 419                 TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
 420                 GL_EXTCALL(glUniform1iARB(name_loc, mapped_unit));
 421                 checkGLcall("glUniform1iARB");
 422             } else {
 423                 ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
 424             }
 425         }
 426     }
 427 }
 428
 429 /* Context activation is done by the caller. */
 430 static inline void walk_constant_heap(const struct wined3d_gl_info *gl_info, const float *constants,
 431         const GLint *constant_locations, const struct constant_heap *heap, unsigned char *stack, DWORD version)
 432 {
 433     int stack_idx = 0;
 434     unsigned int heap_idx = 1;
 435     unsigned int idx;
 436
 437     if (heap->entries[heap_idx].version <= version) return;
 438
 439     idx = heap->entries[heap_idx].idx;
 440     if (constant_locations[idx] != -1) GL_EXTCALL(glUniform4fvARB(constant_locations[idx], 1, &constants[idx * 4]));
 441     stack[stack_idx] = HEAP_NODE_TRAVERSE_LEFT;
 442
 443     while (stack_idx >= 0)
 444     {
 445         /* Note that we fall through to the next case statement. */
 446         switch(stack[stack_idx])
 447         {
 448             case HEAP_NODE_TRAVERSE_LEFT:
 449             {
 450                 unsigned int left_idx = heap_idx << 1;
 451                 if (left_idx < heap->size && heap->entries[left_idx].version > version)
 452                 {
 453                     heap_idx = left_idx;
 454                     idx = heap->entries[heap_idx].idx;
 455                     if (constant_locations[idx] != -1)
 456                         GL_EXTCALL(glUniform4fvARB(constant_locations[idx], 1, &constants[idx * 4]));
 457
 458                     stack[stack_idx++] = HEAP_NODE_TRAVERSE_RIGHT;
 459                     stack[stack_idx] = HEAP_NODE_TRAVERSE_LEFT;
 460                     break;
 461                 }
 462             }
 463
 464             case HEAP_NODE_TRAVERSE_RIGHT:
 465             {
 466                 unsigned int right_idx = (heap_idx << 1) + 1;
 467                 if (right_idx < heap->size && heap->entries[right_idx].version > version)
 468                 {
 469                     heap_idx = right_idx;
 470                     idx = heap->entries[heap_idx].idx;
 471                     if (constant_locations[idx] != -1)
 472                         GL_EXTCALL(glUniform4fvARB(constant_locations[idx], 1, &constants[idx * 4]));
 473
 474                     stack[stack_idx++] = HEAP_NODE_POP;
 475                     stack[stack_idx] = HEAP_NODE_TRAVERSE_LEFT;
 476                     break;
 477                 }
 478             }
 479
 480             case HEAP_NODE_POP:
 481                 heap_idx >>= 1;
 482                 --stack_idx;
 483                 break;
 484         }
 485     }
 486     checkGLcall("walk_constant_heap()");
 487 }
 488
 489 /* Context activation is done by the caller. */
 490 static inline void apply_clamped_constant(const struct wined3d_gl_info *gl_info, GLint location, const GLfloat *data)
 491 {
 492     GLfloat clamped_constant[4];
 493
 494     if (location == -1) return;
 495
 496     clamped_constant[0] = data[0] < -1.0f ? -1.0f : data[0] > 1.0f ? 1.0f : data[0];
 497     clamped_constant[1] = data[1] < -1.0f ? -1.0f : data[1] > 1.0f ? 1.0f : data[1];
 498     clamped_constant[2] = data[2] < -1.0f ? -1.0f : data[2] > 1.0f ? 1.0f : data[2];
 499     clamped_constant[3] = data[3] < -1.0f ? -1.0f : data[3] > 1.0f ? 1.0f : data[3];
 500
 501     GL_EXTCALL(glUniform4fvARB(location, 1, clamped_constant));
 502 }
 503
 504 /* Context activation is done by the caller. */
 505 static inline void walk_constant_heap_clamped(const struct wined3d_gl_info *gl_info, const float *constants,
 506         const GLint *constant_locations, const struct constant_heap *heap, unsigned char *stack, DWORD version)
 507 {
 508     int stack_idx = 0;
 509     unsigned int heap_idx = 1;
 510     unsigned int idx;
 511
 512     if (heap->entries[heap_idx].version <= version) return;
 513
 514     idx = heap->entries[heap_idx].idx;
 515     apply_clamped_constant(gl_info, constant_locations[idx], &constants[idx * 4]);
 516     stack[stack_idx] = HEAP_NODE_TRAVERSE_LEFT;
 517
 518     while (stack_idx >= 0)
 519     {
 520         /* Note that we fall through to the next case statement. */
 521         switch(stack[stack_idx])
 522         {
 523             case HEAP_NODE_TRAVERSE_LEFT:
 524             {
 525                 unsigned int left_idx = heap_idx << 1;
 526                 if (left_idx < heap->size && heap->entries[left_idx].version > version)
 527                 {
 528                     heap_idx = left_idx;
 529                     idx = heap->entries[heap_idx].idx;
 530                     apply_clamped_constant(gl_info, constant_locations[idx], &constants[idx * 4]);
 531
 532                     stack[stack_idx++] = HEAP_NODE_TRAVERSE_RIGHT;
 533                     stack[stack_idx] = HEAP_NODE_TRAVERSE_LEFT;
 534                     break;
 535                 }
 536             }
 537
 538             case HEAP_NODE_TRAVERSE_RIGHT:
 539             {
 540                 unsigned int right_idx = (heap_idx << 1) + 1;
 541                 if (right_idx < heap->size && heap->entries[right_idx].version > version)
 542                 {
 543                     heap_idx = right_idx;
 544                     idx = heap->entries[heap_idx].idx;
 545                     apply_clamped_constant(gl_info, constant_locations[idx], &constants[idx * 4]);
 546
 547                     stack[stack_idx++] = HEAP_NODE_POP;
 548                     stack[stack_idx] = HEAP_NODE_TRAVERSE_LEFT;
 549                     break;
 550                 }
 551             }
 552
 553             case HEAP_NODE_POP:
 554                 heap_idx >>= 1;
 555                 --stack_idx;
 556                 break;
 557         }
 558     }
 559     checkGLcall("walk_constant_heap_clamped()");
 560 }
 561
 562 /* Context activation is done by the caller. */
 563 static void shader_glsl_load_constantsF(const struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info,
 564         const float *constants, const GLint *constant_locations, const struct constant_heap *heap,
 565         unsigned char *stack, UINT version)
 566 {
 567     const struct wined3d_shader_lconst *lconst;
 568
 569     /* 1.X pshaders have the constants clamped to [-1;1] implicitly. */
 570     if (shader->reg_maps.shader_version.major == 1
 571             && shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
 572         walk_constant_heap_clamped(gl_info, constants, constant_locations, heap, stack, version);
 573     else
 574         walk_constant_heap(gl_info, constants, constant_locations, heap, stack, version);
 575
 576     if (!shader->load_local_constsF)
 577     {
 578         TRACE("No need to load local float constants for this shader\n");
 579         return;
 580     }
 581
 582     /* Immediate constants are clamped to [-1;1] at shader creation time if needed */
 583     LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
 584     {
 585         GL_EXTCALL(glUniform4fvARB(constant_locations[lconst->idx], 1, (const GLfloat *)lconst->value));
 586     }
 587     checkGLcall("glUniform4fvARB()");
 588 }
 589
 590 /* Context activation is done by the caller. */
 591 static void shader_glsl_load_constantsI(const struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info,
 592         const GLint locations[MAX_CONST_I], const int *constants, WORD constants_set)
 593 {
 594     unsigned int i;
 595     struct list* ptr;
 596
 597     for (i = 0; constants_set; constants_set >>= 1, ++i)
 598     {
 599         if (!(constants_set & 1)) continue;
 600
 601         TRACE_(d3d_constants)("Loading constants %u: %i, %i, %i, %i\n",
 602                 i, constants[i*4], constants[i*4+1], constants[i*4+2], constants[i*4+3]);
 603
 604         /* We found this uniform name in the program - go ahead and send the data */
 605         GL_EXTCALL(glUniform4ivARB(locations[i], 1, &constants[i*4]));
 606         checkGLcall("glUniform4ivARB");
 607     }
 608
 609     /* Load immediate constants */
 610     ptr = list_head(&shader->constantsI);
 611     while (ptr)
 612     {
 613         const struct wined3d_shader_lconst *lconst = LIST_ENTRY(ptr, const struct wined3d_shader_lconst, entry);
 614         unsigned int idx = lconst->idx;
 615         const GLint *values = (const GLint *)lconst->value;
 616
 617         TRACE_(d3d_constants)("Loading local constants %i: %i, %i, %i, %i\n", idx,
 618             values[0], values[1], values[2], values[3]);
 619
 620         /* We found this uniform name in the program - go ahead and send the data */
 621         GL_EXTCALL(glUniform4ivARB(locations[idx], 1, values));
 622         checkGLcall("glUniform4ivARB");
 623         ptr = list_next(&shader->constantsI, ptr);
 624     }
 625 }
 626
 627 /* Context activation is done by the caller. */
 628 static void shader_glsl_load_constantsB(const struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info,
 629         GLhandleARB programId, const BOOL *constants, WORD constants_set)
 630 {
 631     GLint tmp_loc;
 632     unsigned int i;
 633     char tmp_name[10];
 634     const char *prefix;
 635     struct list* ptr;
 636
 637     prefix = shader_glsl_get_prefix(shader->reg_maps.shader_version.type);
 638
 639     /* TODO: Benchmark and see if it would be beneficial to store the
 640      * locations of the constants to avoid looking up each time */
 641     for (i = 0; constants_set; constants_set >>= 1, ++i)
 642     {
 643         if (!(constants_set & 1)) continue;
 644
 645         TRACE_(d3d_constants)("Loading constants %i: %i;\n", i, constants[i]);
 646
 647         /* TODO: Benchmark and see if it would be beneficial to store the
 648          * locations of the constants to avoid looking up each time */
 649         snprintf(tmp_name, sizeof(tmp_name), "%s_b[%i]", prefix, i);
 650         tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 651         GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, &constants[i]));
 652     }
 653
 654     /* Load immediate constants */
 655     ptr = list_head(&shader->constantsB);
 656     while (ptr)
 657     {
 658         const struct wined3d_shader_lconst *lconst = LIST_ENTRY(ptr, const struct wined3d_shader_lconst, entry);
 659         unsigned int idx = lconst->idx;
 660         const GLint *values = (const GLint *)lconst->value;
 661
 662         TRACE_(d3d_constants)("Loading local constants %i: %i\n", idx, values[0]);
 663
 664         snprintf(tmp_name, sizeof(tmp_name), "%s_b[%i]", prefix, idx);
 665         tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 666         GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, values));
 667         ptr = list_next(&shader->constantsB, ptr);
 668     }
 669
 670     checkGLcall("shader_glsl_load_constantsB()");
 671 }
 672
 673 static void reset_program_constant_version(struct wine_rb_entry *entry, void *context)
 674 {
 675     WINE_RB_ENTRY_VALUE(entry, struct glsl_shader_prog_link, program_lookup_entry)->constant_version = 0;
 676 }
 677
 678 /* Context activation is done by the caller (state handler). */
 679 static void shader_glsl_load_np2fixup_constants(void *shader_priv,
 680         const struct wined3d_gl_info *gl_info, const struct wined3d_state *state)
 681 {
 682     struct shader_glsl_priv *glsl_priv = shader_priv;
 683     const struct glsl_shader_prog_link *prog = glsl_priv->glsl_program;
 684
 685     /* No GLSL program set - nothing to do. */
 686     if (!prog) return;
 687
 688     /* NP2 texcoord fixup is (currently) only done for pixelshaders. */
 689     if (!use_ps(state)) return;
 690
 691     if (prog->ps.np2_fixup_info && prog->ps.np2_fixup_location != -1)
 692     {
 693         UINT i;
 694         UINT fixup = prog->ps.np2_fixup_info->active;
 695         GLfloat np2fixup_constants[4 * MAX_FRAGMENT_SAMPLERS];
 696
 697         for (i = 0; fixup; fixup >>= 1, ++i)
 698         {
 699             const struct wined3d_texture *tex = state->textures[i];
 700             const unsigned char idx = prog->ps.np2_fixup_info->idx[i];
 701             GLfloat *tex_dim = &np2fixup_constants[(idx >> 1) * 4];
 702
 703             if (!tex)
 704             {
 705                 ERR("Nonexistent texture is flagged for NP2 texcoord fixup.\n");
 706                 continue;
 707             }
 708
 709             if (idx % 2)
 710             {
 711                 tex_dim[2] = tex->pow2_matrix[0];
 712                 tex_dim[3] = tex->pow2_matrix[5];
 713             }
 714             else
 715             {
 716                 tex_dim[0] = tex->pow2_matrix[0];
 717                 tex_dim[1] = tex->pow2_matrix[5];
 718             }
 719         }
 720
 721         GL_EXTCALL(glUniform4fvARB(prog->ps.np2_fixup_location,
 722                 prog->ps.np2_fixup_info->num_consts, np2fixup_constants));
 723     }
 724 }
 725
 726 /* Context activation is done by the caller (state handler). */
 727 static void shader_glsl_load_constants(const struct wined3d_context *context,
 728         BOOL usePixelShader, BOOL useVertexShader)
 729 {
 730     const struct wined3d_gl_info *gl_info = context->gl_info;
 731     struct wined3d_device *device = context->swapchain->device;
 732     struct wined3d_stateblock *stateBlock = device->stateBlock;
 733     const struct wined3d_state *state = &stateBlock->state;
 734     struct shader_glsl_priv *priv = device->shader_priv;
 735     float position_fixup[4];
 736
 737     GLhandleARB programId;
 738     struct glsl_shader_prog_link *prog = priv->glsl_program;
 739     UINT constant_version;
 740     int i;
 741
 742     if (!prog) {
 743         /* No GLSL program set - nothing to do. */
 744         return;
 745     }
 746     programId = prog->programId;
 747     constant_version = prog->constant_version;
 748
 749     if (useVertexShader)
 750     {
 751         const struct wined3d_shader *vshader = state->vertex_shader;
 752
 753         /* Load DirectX 9 float constants/uniforms for vertex shader */
 754         shader_glsl_load_constantsF(vshader, gl_info, state->vs_consts_f,
 755                 prog->vs.uniform_f_locations, &priv->vconst_heap, priv->stack, constant_version);
 756
 757         /* Load DirectX 9 integer constants/uniforms for vertex shader */
 758         shader_glsl_load_constantsI(vshader, gl_info, prog->vs.uniform_i_locations, state->vs_consts_i,
 759                 stateBlock->changed.vertexShaderConstantsI & vshader->reg_maps.integer_constants);
 760
 761         /* Load DirectX 9 boolean constants/uniforms for vertex shader */
 762         shader_glsl_load_constantsB(vshader, gl_info, programId, state->vs_consts_b,
 763                 stateBlock->changed.vertexShaderConstantsB & vshader->reg_maps.boolean_constants);
 764
 765         /* Upload the position fixup params */
 766         shader_get_position_fixup(context, state, position_fixup);
 767         GL_EXTCALL(glUniform4fvARB(prog->vs.pos_fixup_location, 1, position_fixup));
 768         checkGLcall("glUniform4fvARB");
 769     }
 770
 771     if (usePixelShader)
 772     {
 773         const struct wined3d_shader *pshader = state->pixel_shader;
 774
 775         /* Load DirectX 9 float constants/uniforms for pixel shader */
 776         shader_glsl_load_constantsF(pshader, gl_info, state->ps_consts_f,
 777                 prog->ps.uniform_f_locations, &priv->pconst_heap, priv->stack, constant_version);
 778
 779         /* Load DirectX 9 integer constants/uniforms for pixel shader */
 780         shader_glsl_load_constantsI(pshader, gl_info, prog->ps.uniform_i_locations, state->ps_consts_i,
 781                 stateBlock->changed.pixelShaderConstantsI & pshader->reg_maps.integer_constants);
 782
 783         /* Load DirectX 9 boolean constants/uniforms for pixel shader */
 784         shader_glsl_load_constantsB(pshader, gl_info, programId, state->ps_consts_b,
 785                 stateBlock->changed.pixelShaderConstantsB & pshader->reg_maps.boolean_constants);
 786
 787         /* Upload the environment bump map matrix if needed. The needsbumpmat
 788          * member specifies the texture stage to load the matrix from. It
 789          * can't be 0 for a valid texbem instruction. */
 790         for (i = 0; i < MAX_TEXTURES; ++i)
 791         {
 792             const float *data;
 793
 794             if (prog->ps.bumpenv_mat_location[i] == -1)
 795                 continue;
 796
 797             data = (const float *)&state->texture_states[i][WINED3D_TSS_BUMPENV_MAT00];
 798             GL_EXTCALL(glUniformMatrix2fvARB(prog->ps.bumpenv_mat_location[i], 1, 0, data));
 799             checkGLcall("glUniformMatrix2fvARB");
 800
 801             /* texbeml needs the luminance scale and offset too. If texbeml
 802              * is used, needsbumpmat is set too, so we can check that in the
 803              * needsbumpmat check. */
 804             if (prog->ps.bumpenv_lum_scale_location[i] != -1)
 805             {
 806                 const GLfloat *scale = (const GLfloat *)&state->texture_states[i][WINED3D_TSS_BUMPENV_LSCALE];
 807                 const GLfloat *offset = (const GLfloat *)&state->texture_states[i][WINED3D_TSS_BUMPENV_LOFFSET];
 808
 809                 GL_EXTCALL(glUniform1fvARB(prog->ps.bumpenv_lum_scale_location[i], 1, scale));
 810                 checkGLcall("glUniform1fvARB");
 811                 GL_EXTCALL(glUniform1fvARB(prog->ps.bumpenv_lum_offset_location[i], 1, offset));
 812                 checkGLcall("glUniform1fvARB");
 813             }
 814         }
 815
 816         if (prog->ps.ycorrection_location != -1)
 817         {
 818             float correction_params[4];
 819
 820             if (context->render_offscreen)
 821             {
 822                 correction_params[0] = 0.0f;
 823                 correction_params[1] = 1.0f;
 824             } else {
 825                 /* position is window relative, not viewport relative */
 826                 correction_params[0] = (float) context->current_rt->resource.height;
 827                 correction_params[1] = -1.0f;
 828             }
 829             GL_EXTCALL(glUniform4fvARB(prog->ps.ycorrection_location, 1, correction_params));
 830         }
 831     }
 832     else if (priv->fragment_pipe == &glsl_fragment_pipe)
 833     {
 834         float col[4];
 835
 836         for (i = 0; i < MAX_TEXTURES; ++i)
 837         {
 838             GL_EXTCALL(glUniformMatrix2fvARB(prog->ps.bumpenv_mat_location[i], 1, 0,
 839                         (const float *)&state->texture_states[i][WINED3D_TSS_BUMPENV_MAT00]));
 840             GL_EXTCALL(glUniform1fARB(prog->ps.bumpenv_lum_scale_location[i],
 841                         *(const float *)&state->texture_states[i][WINED3D_TSS_BUMPENV_LSCALE]));
 842             GL_EXTCALL(glUniform1fARB(prog->ps.bumpenv_lum_offset_location[i],
 843                         *(const float *)&state->texture_states[i][WINED3D_TSS_BUMPENV_LOFFSET]));
 844         }
 845
 846         D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_TEXTUREFACTOR], col);
 847         GL_EXTCALL(glUniform4fARB(prog->ps.tex_factor_location, col[0], col[1], col[2], col[3]));
 848
 849         if (state->render_states[WINED3D_RS_SPECULARENABLE])
 850             GL_EXTCALL(glUniform4fARB(prog->ps.specular_enable_location, 1.0f, 1.0f, 1.0f, 0.0f));
 851         else
 852             GL_EXTCALL(glUniform4fARB(prog->ps.specular_enable_location, 0.0f, 0.0f, 0.0f, 0.0f));
 853
 854         checkGLcall("fixed function uniforms");
 855     }
 856
 857     if (priv->next_constant_version == UINT_MAX)
 858     {
 859         TRACE("Max constant version reached, resetting to 0.\n");
 860         wine_rb_for_each_entry(&priv->program_lookup, reset_program_constant_version, NULL);
 861         priv->next_constant_version = 1;
 862     }
 863     else
 864     {
 865         prog->constant_version = priv->next_constant_version++;
 866     }
 867 }
 868
 869 static void update_heap_entry(const struct constant_heap *heap, unsigned int idx,
 870         unsigned int heap_idx, DWORD new_version)
 871 {
 872     struct constant_entry *entries = heap->entries;
 873     unsigned int *positions = heap->positions;
 874     unsigned int parent_idx;
 875
 876     while (heap_idx > 1)
 877     {
 878         parent_idx = heap_idx >> 1;
 879
 880         if (new_version <= entries[parent_idx].version) break;
 881
 882         entries[heap_idx] = entries[parent_idx];
 883         positions[entries[parent_idx].idx] = heap_idx;
 884         heap_idx = parent_idx;
 885     }
 886
 887     entries[heap_idx].version = new_version;
 888     entries[heap_idx].idx = idx;
 889     positions[idx] = heap_idx;
 890 }
 891
 892 static void shader_glsl_update_float_vertex_constants(struct wined3d_device *device, UINT start, UINT count)
 893 {
 894     struct shader_glsl_priv *priv = device->shader_priv;
 895     struct constant_heap *heap = &priv->vconst_heap;
 896     UINT i;
 897
 898     for (i = start; i < count + start; ++i)
 899     {
 900         if (!device->stateBlock->changed.vertexShaderConstantsF[i])
 901             update_heap_entry(heap, i, heap->size++, priv->next_constant_version);
 902         else
 903             update_heap_entry(heap, i, heap->positions[i], priv->next_constant_version);
 904     }
 905 }
 906
 907 static void shader_glsl_update_float_pixel_constants(struct wined3d_device *device, UINT start, UINT count)
 908 {
 909     struct shader_glsl_priv *priv = device->shader_priv;
 910     struct constant_heap *heap = &priv->pconst_heap;
 911     UINT i;
 912
 913     for (i = start; i < count + start; ++i)
 914     {
 915         if (!device->stateBlock->changed.pixelShaderConstantsF[i])
 916             update_heap_entry(heap, i, heap->size++, priv->next_constant_version);
 917         else
 918             update_heap_entry(heap, i, heap->positions[i], priv->next_constant_version);
 919     }
 920 }
 921
 922 static unsigned int vec4_varyings(DWORD shader_major, const struct wined3d_gl_info *gl_info)
 923 {
 924     unsigned int ret = gl_info->limits.glsl_varyings / 4;
 925     /* 4.0 shaders do not write clip coords because d3d10 does not support user clipplanes */
 926     if(shader_major > 3) return ret;
 927
 928     /* 3.0 shaders may need an extra varying for the clip coord on some cards(mostly dx10 ones) */
 929     if (gl_info->quirks & WINED3D_QUIRK_GLSL_CLIP_VARYING) ret -= 1;
 930     return ret;
 931 }
 932
 933 /** Generate the variable & register declarations for the GLSL output target */
 934 static void shader_generate_glsl_declarations(const struct wined3d_context *context,
 935         struct wined3d_shader_buffer *buffer, const struct wined3d_shader *shader,
 936         const struct wined3d_shader_reg_maps *reg_maps, const struct shader_glsl_ctx_priv *ctx_priv)
 937 {
 938     const struct wined3d_shader_version *version = &reg_maps->shader_version;
 939     const struct wined3d_state *state = &shader->device->stateBlock->state;
 940     const struct ps_compile_args *ps_args = ctx_priv->cur_ps_args;
 941     const struct wined3d_gl_info *gl_info = context->gl_info;
 942     const struct wined3d_fb_state *fb = &shader->device->fb;
 943     unsigned int i, extra_constants_needed = 0;
 944     const struct wined3d_shader_lconst *lconst;
 945     const char *prefix;
 946     DWORD map;
 947
 948     prefix = shader_glsl_get_prefix(version->type);
 949
 950     /* Prototype the subroutines */
 951     for (i = 0, map = reg_maps->labels; map; map >>= 1, ++i)
 952     {
 953         if (map & 1) shader_addline(buffer, "void subroutine%u();\n", i);
 954     }
 955
 956     /* Declare the constants (aka uniforms) */
 957     if (shader->limits.constant_float > 0)
 958     {
 959         unsigned max_constantsF;
 960
 961         /* Unless the shader uses indirect addressing, always declare the
 962          * maximum array size and ignore that we need some uniforms privately.
 963          * E.g. if GL supports 256 uniforms, and we need 2 for the pos fixup
 964          * and immediate values, still declare VC[256]. If the shader needs
 965          * more uniforms than we have it won't work in any case. If it uses
 966          * less, the compiler will figure out which uniforms are really used
 967          * and strip them out. This allows a shader to use c255 on a dx9 card,
 968          * as long as it doesn't also use all the other constants.
 969          *
 970          * If the shader uses indirect addressing the compiler must assume
 971          * that all declared uniforms are used. In this case, declare only the
 972          * amount that we're assured to have.
 973          *
 974          * Thus we run into problems in these two cases:
 975          * 1) The shader really uses more uniforms than supported.
 976          * 2) The shader uses indirect addressing, less constants than
 977          *    supported, but uses a constant index > #supported consts. */
 978         if (version->type == WINED3D_SHADER_TYPE_PIXEL)
 979         {
 980             /* No indirect addressing here. */
 981             max_constantsF = gl_info->limits.glsl_ps_float_constants;
 982         }
 983         else
 984         {
 985             if (reg_maps->usesrelconstF)
 986             {
 987                 /* Subtract the other potential uniforms from the max
 988                  * available (bools, ints, and 1 row of projection matrix).
 989                  * Subtract another uniform for immediate values, which have
 990                  * to be loaded via uniform by the driver as well. The shader
 991                  * code only uses 0.5, 2.0, 1.0, 128 and -128 in vertex
 992                  * shader code, so one vec4 should be enough. (Unfortunately
 993                  * the Nvidia driver doesn't store 128 and -128 in one float).
 994                  *
 995                  * Writing gl_ClipVertex requires one uniform for each
 996                  * clipplane as well. */
 997                 max_constantsF = gl_info->limits.glsl_vs_float_constants - 3;
 998                 if(ctx_priv->cur_vs_args->clip_enabled)
 999                 {
1000                     max_constantsF -= gl_info->limits.clipplanes;
1001                 }
1002                 max_constantsF -= count_bits(reg_maps->integer_constants);
1003                 /* Strictly speaking a bool only uses one scalar, but the nvidia(Linux) compiler doesn't pack them properly,
1004                  * so each scalar requires a full vec4. We could work around this by packing the booleans ourselves, but
1005                  * for now take this into account when calculating the number of available constants
1006                  */
1007                 max_constantsF -= count_bits(reg_maps->boolean_constants);
1008                 /* Set by driver quirks in directx.c */
1009                 max_constantsF -= gl_info->reserved_glsl_constants;
1010
1011                 if (max_constantsF < shader->limits.constant_float)
1012                 {
1013                     static unsigned int once;
1014
1015                     if (!once++)
1016                         ERR_(winediag)("The hardware does not support enough uniform components to run this shader,"
1017                                 " it may not render correctly.\n");
1018                     else
1019                         WARN("The hardware does not support enough uniform components to run this shader.\n");
1020                 }
1021             }
1022             else
1023             {
1024                 max_constantsF = gl_info->limits.glsl_vs_float_constants;
1025             }
1026         }
1027         max_constantsF = min(shader->limits.constant_float, max_constantsF);
1028         shader_addline(buffer, "uniform vec4 %s_c[%u];\n", prefix, max_constantsF);
1029     }
1030
1031     /* Always declare the full set of constants, the compiler can remove the
1032      * unused ones because d3d doesn't (yet) support indirect int and bool
1033      * constant addressing. This avoids problems if the app uses e.g. i0 and i9. */
1034     if (shader->limits.constant_int > 0 && reg_maps->integer_constants)
1035         shader_addline(buffer, "uniform ivec4 %s_i[%u];\n", prefix, shader->limits.constant_int);
1036
1037     if (shader->limits.constant_bool > 0 && reg_maps->boolean_constants)
1038         shader_addline(buffer, "uniform bool %s_b[%u];\n", prefix, shader->limits.constant_bool);
1039
1040     for (i = 0; i < WINED3D_MAX_CBS; ++i)
1041     {
1042         if (reg_maps->cb_sizes[i])
1043             shader_addline(buffer, "uniform vec4 %s_cb%u[%u];\n", prefix, i, reg_maps->cb_sizes[i]);
1044     }
1045
1046     /* Declare texture samplers */
1047     for (i = 0; i < shader->limits.sampler; ++i)
1048     {
1049         if (reg_maps->sampler_type[i])
1050         {
1051             BOOL shadow_sampler = version->type == WINED3D_SHADER_TYPE_PIXEL && (ps_args->shadow & (1 << i));
1052             BOOL tex_rect;
1053
1054             switch (reg_maps->sampler_type[i])
1055             {
1056                 case WINED3DSTT_1D:
1057                     if (shadow_sampler)
1058                         shader_addline(buffer, "uniform sampler1DShadow %s_sampler%u;\n", prefix, i);
1059                     else
1060                         shader_addline(buffer, "uniform sampler1D %s_sampler%u;\n", prefix, i);
1061                     break;
1062                 case WINED3DSTT_2D:
1063                     tex_rect = version->type == WINED3D_SHADER_TYPE_PIXEL && (ps_args->np2_fixup & (1 << i));
1064                     tex_rect = tex_rect && gl_info->supported[ARB_TEXTURE_RECTANGLE];
1065                     if (shadow_sampler)
1066                     {
1067                         if (tex_rect)
1068                             shader_addline(buffer, "uniform sampler2DRectShadow %s_sampler%u;\n", prefix, i);
1069                         else
1070                             shader_addline(buffer, "uniform sampler2DShadow %s_sampler%u;\n", prefix, i);
1071                     }
1072                     else
1073                     {
1074                         if (tex_rect)
1075                             shader_addline(buffer, "uniform sampler2DRect %s_sampler%u;\n", prefix, i);
1076                         else
1077                             shader_addline(buffer, "uniform sampler2D %s_sampler%u;\n", prefix, i);
1078                     }
1079                     break;
1080                 case WINED3DSTT_CUBE:
1081                     if (shadow_sampler)
1082                         FIXME("Unsupported Cube shadow sampler.\n");
1083                     shader_addline(buffer, "uniform samplerCube %s_sampler%u;\n", prefix, i);
1084                     break;
1085                 case WINED3DSTT_VOLUME:
1086                     if (shadow_sampler)
1087                         FIXME("Unsupported 3D shadow sampler.\n");
1088                     shader_addline(buffer, "uniform sampler3D %s_sampler%u;\n", prefix, i);
1089                     break;
1090                 default:
1091                     shader_addline(buffer, "uniform unsupported_sampler %s_sampler%u;\n", prefix, i);
1092                     FIXME("Unrecognized sampler type: %#x\n", reg_maps->sampler_type[i]);
1093                     break;
1094             }
1095         }
1096     }
1097
1098     /* Declare uniforms for NP2 texcoord fixup:
1099      * This is NOT done inside the loop that declares the texture samplers
1100      * since the NP2 fixup code is currently only used for the GeforceFX
1101      * series and when forcing the ARB_npot extension off. Modern cards just
1102      * skip the code anyway, so put it inside a separate loop. */
1103     if (version->type == WINED3D_SHADER_TYPE_PIXEL && ps_args->np2_fixup)
1104     {
1105         struct ps_np2fixup_info *fixup = ctx_priv->cur_np2fixup_info;
1106         UINT cur = 0;
1107
1108         /* NP2/RECT textures in OpenGL use texcoords in the range [0,width]x[0,height]
1109          * while D3D has them in the (normalized) [0,1]x[0,1] range.
1110          * samplerNP2Fixup stores texture dimensions and is updated through
1111          * shader_glsl_load_np2fixup_constants when the sampler changes. */
1112
1113         for (i = 0; i < shader->limits.sampler; ++i)
1114         {
1115             if (reg_maps->sampler_type[i])
1116             {
1117                 if (!(ps_args->np2_fixup & (1 << i))) continue;
1118
1119                 if (WINED3DSTT_2D != reg_maps->sampler_type[i]) {
1120                     FIXME("Non-2D texture is flagged for NP2 texcoord fixup.\n");
1121                     continue;
1122                 }
1123
1124                 fixup->idx[i] = cur++;
1125             }
1126         }
1127
1128         fixup->num_consts = (cur + 1) >> 1;
1129         fixup->active = ps_args->np2_fixup;
1130         shader_addline(buffer, "uniform vec4 %s_samplerNP2Fixup[%u];\n", prefix, fixup->num_consts);
1131     }
1132
1133     /* Declare address variables */
1134     for (i = 0, map = reg_maps->address; map; map >>= 1, ++i)
1135     {
1136         if (map & 1) shader_addline(buffer, "ivec4 A%u;\n", i);
1137     }
1138
1139     /* Declare texture coordinate temporaries and initialize them */
1140     for (i = 0, map = reg_maps->texcoord; map; map >>= 1, ++i)
1141     {
1142         if (map & 1) shader_addline(buffer, "vec4 T%u = gl_TexCoord[%u];\n", i, i);
1143     }
1144
1145     if (version->type == WINED3D_SHADER_TYPE_VERTEX)
1146     {
1147         /* Declare attributes. */
1148         for (i = 0, map = reg_maps->input_registers; map; map >>= 1, ++i)
1149         {
1150             if (map & 1)
1151                 shader_addline(buffer, "attribute vec4 %s_in%u;\n", prefix, i);
1152         }
1153
1154         shader_addline(buffer, "uniform vec4 posFixup;\n");
1155         shader_addline(buffer, "void order_ps_input(in vec4[%u]);\n", shader->limits.packed_output);
1156     }
1157     else if (version->type == WINED3D_SHADER_TYPE_GEOMETRY)
1158     {
1159         shader_addline(buffer, "varying in vec4 gs_in[][%u];\n", shader->limits.packed_input);
1160     }
1161     else if (version->type == WINED3D_SHADER_TYPE_PIXEL)
1162     {
1163         if (version->major >= 3)
1164         {
1165             UINT in_count = min(vec4_varyings(version->major, gl_info), shader->limits.packed_input);
1166
1167             if (use_vs(state))
1168                 shader_addline(buffer, "varying vec4 %s_in[%u];\n", prefix, in_count);
1169             else
1170                 /* TODO: Write a replacement shader for the fixed function
1171                  * vertex pipeline, so this isn't needed. For fixed function
1172                  * vertex processing + 3.0 pixel shader we need a separate
1173                  * function in the pixel shader that reads the fixed function
1174                  * color into the packed input registers. */
1175                 shader_addline(buffer, "vec4 %s_in[%u];\n", prefix, in_count);
1176         }
1177
1178         for (i = 0, map = reg_maps->bumpmat; map; map >>= 1, ++i)
1179         {
1180             if (!(map & 1))
1181                 continue;
1182
1183             shader_addline(buffer, "uniform mat2 bumpenv_mat%u;\n", i);
1184
1185             if (reg_maps->luminanceparams & (1 << i))
1186             {
1187                 shader_addline(buffer, "uniform float bumpenv_lum_scale%u;\n", i);
1188                 shader_addline(buffer, "uniform float bumpenv_lum_offset%u;\n", i);
1189                 extra_constants_needed++;
1190             }
1191
1192             extra_constants_needed++;
1193         }
1194
1195         if (ps_args->srgb_correction)
1196         {
1197             shader_addline(buffer, "const vec4 srgb_const0 = vec4(%.8e, %.8e, %.8e, %.8e);\n",
1198                     srgb_pow, srgb_mul_high, srgb_sub_high, srgb_mul_low);
1199             shader_addline(buffer, "const vec4 srgb_const1 = vec4(%.8e, 0.0, 0.0, 0.0);\n",
1200                     srgb_cmp);
1201         }
1202         if (reg_maps->vpos || reg_maps->usesdsy)
1203         {
1204             if (shader->limits.constant_float + extra_constants_needed
1205                     + 1 < gl_info->limits.glsl_ps_float_constants)
1206             {
1207                 shader_addline(buffer, "uniform vec4 ycorrection;\n");
1208                 extra_constants_needed++;
1209             }
1210             else
1211             {
1212                 /* This happens because we do not have proper tracking of the constant registers that are
1213                  * actually used, only the max limit of the shader version
1214                  */
1215                 FIXME("Cannot find a free uniform for vpos correction params\n");
1216                 shader_addline(buffer, "const vec4 ycorrection = vec4(%f, %f, 0.0, 0.0);\n",
1217                         context->render_offscreen ? 0.0f : fb->render_targets[0]->resource.height,
1218                         context->render_offscreen ? 1.0f : -1.0f);
1219             }
1220             shader_addline(buffer, "vec4 vpos;\n");
1221         }
1222     }
1223
1224     /* Declare output register temporaries */
1225     if (shader->limits.packed_output)
1226         shader_addline(buffer, "vec4 %s_out[%u];\n", prefix, shader->limits.packed_output);
1227
1228     /* Declare temporary variables */
1229     for (i = 0, map = reg_maps->temporary; map; map >>= 1, ++i)
1230     {
1231         if (map & 1) shader_addline(buffer, "vec4 R%u;\n", i);
1232     }
1233
1234     /* Declare loop registers aLx */
1235     if (version->major < 4)
1236     {
1237         for (i = 0; i < reg_maps->loop_depth; ++i)
1238         {
1239             shader_addline(buffer, "int aL%u;\n", i);
1240             shader_addline(buffer, "int tmpInt%u;\n", i);
1241         }
1242     }
1243
1244     /* Temporary variables for matrix operations */
1245     shader_addline(buffer, "vec4 tmp0;\n");
1246     shader_addline(buffer, "vec4 tmp1;\n");
1247
1248     if (!shader->load_local_constsF)
1249     {
1250         LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
1251         {
1252             const float *value;
1253             value = (const float *)lconst->value;
1254             shader_addline(buffer, "const vec4 %s_lc%u = vec4(%.8e, %.8e, %.8e, %.8e);\n",
1255                     prefix, lconst->idx, value[0], value[1], value[2], value[3]);
1256         }
1257     }
1258
1259     /* Start the main program. */
1260     shader_addline(buffer, "void main()\n{\n");
1261
1262     /* Direct3D applications expect integer vPos values, while OpenGL drivers
1263      * add approximately 0.5. This causes off-by-one problems as spotted by
1264      * the vPos d3d9 visual test. Unfortunately ATI cards do not add exactly
1265      * 0.5, but rather something like 0.49999999 or 0.50000001, which still
1266      * causes precision troubles when we just subtract 0.5.
1267      *
1268      * To deal with that, just floor() the position. This will eliminate the
1269      * fraction on all cards.
1270      *
1271      * TODO: Test how this behaves with multisampling.
1272      *
1273      * An advantage of floor is that it works even if the driver doesn't add
1274      * 0.5. It is somewhat questionable if 1.5, 2.5, ... are the proper values
1275      * to return in gl_FragCoord, even though coordinates specify the pixel
1276      * centers instead of the pixel corners. This code will behave correctly
1277      * on drivers that returns integer values. */
1278     if (version->type == WINED3D_SHADER_TYPE_PIXEL && reg_maps->vpos)
1279         shader_addline(buffer,
1280                 "vpos = floor(vec4(0, ycorrection[0], 0, 0) + gl_FragCoord * vec4(1, ycorrection[1], 1, 1));\n");
1281 }
1282
1283 /*****************************************************************************
1284  * Functions to generate GLSL strings from DirectX Shader bytecode begin here.
1285  *
1286  * For more information, see http://wiki.winehq.org/DirectX-Shaders
1287  ****************************************************************************/
1288
1289 /* Prototypes */
1290 static void shader_glsl_add_src_param(const struct wined3d_shader_instruction *ins,
1291         const struct wined3d_shader_src_param *wined3d_src, DWORD mask, struct glsl_src_param *glsl_src);
1292
1293 /** Used for opcode modifiers - They multiply the result by the specified amount */
1294 static const char * const shift_glsl_tab[] = {
1295     "",           /*  0 (none) */
1296     "2.0 * ",     /*  1 (x2)   */
1297     "4.0 * ",     /*  2 (x4)   */
1298     "8.0 * ",     /*  3 (x8)   */
1299     "16.0 * ",    /*  4 (x16)  */
1300     "32.0 * ",    /*  5 (x32)  */
1301     "",           /*  6 (x64)  */
1302     "",           /*  7 (x128) */
1303     "",           /*  8 (d256) */
1304     "",           /*  9 (d128) */
1305     "",           /* 10 (d64)  */
1306     "",           /* 11 (d32)  */
1307     "0.0625 * ",  /* 12 (d16)  */
1308     "0.125 * ",   /* 13 (d8)   */
1309     "0.25 * ",    /* 14 (d4)   */
1310     "0.5 * "      /* 15 (d2)   */
1311 };
1312
1313 /* Generate a GLSL parameter that does the input modifier computation and return the input register/mask to use */
1314 static void shader_glsl_gen_modifier(enum wined3d_shader_src_modifier src_modifier,
1315         const char *in_reg, const char *in_regswizzle, char *out_str)
1316 {
1317     out_str[0] = 0;
1318
1319     switch (src_modifier)
1320     {
1321     case WINED3DSPSM_DZ: /* Need to handle this in the instructions itself (texld & texcrd). */
1322     case WINED3DSPSM_DW:
1323     case WINED3DSPSM_NONE:
1324         sprintf(out_str, "%s%s", in_reg, in_regswizzle);
1325         break;
1326     case WINED3DSPSM_NEG:
1327         sprintf(out_str, "-%s%s", in_reg, in_regswizzle);
1328         break;
1329     case WINED3DSPSM_NOT:
1330         sprintf(out_str, "!%s%s", in_reg, in_regswizzle);
1331         break;
1332     case WINED3DSPSM_BIAS:
1333         sprintf(out_str, "(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
1334         break;
1335     case WINED3DSPSM_BIASNEG:
1336         sprintf(out_str, "-(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
1337         break;
1338     case WINED3DSPSM_SIGN:
1339         sprintf(out_str, "(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
1340         break;
1341     case WINED3DSPSM_SIGNNEG:
1342         sprintf(out_str, "-(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
1343         break;
1344     case WINED3DSPSM_COMP:
1345         sprintf(out_str, "(1.0 - %s%s)", in_reg, in_regswizzle);
1346         break;
1347     case WINED3DSPSM_X2:
1348         sprintf(out_str, "(2.0 * %s%s)", in_reg, in_regswizzle);
1349         break;
1350     case WINED3DSPSM_X2NEG:
1351         sprintf(out_str, "-(2.0 * %s%s)", in_reg, in_regswizzle);
1352         break;
1353     case WINED3DSPSM_ABS:
1354         sprintf(out_str, "abs(%s%s)", in_reg, in_regswizzle);
1355         break;
1356     case WINED3DSPSM_ABSNEG:
1357         sprintf(out_str, "-abs(%s%s)", in_reg, in_regswizzle);
1358         break;
1359     default:
1360         FIXME("Unhandled modifier %u\n", src_modifier);
1361         sprintf(out_str, "%s%s", in_reg, in_regswizzle);
1362     }
1363 }
1364
1365 /** Writes the GLSL variable name that corresponds to the register that the
1366  * DX opcode parameter is trying to access */
1367 static void shader_glsl_get_register_name(const struct wined3d_shader_register *reg,
1368         char *register_name, BOOL *is_color, const struct wined3d_shader_instruction *ins)
1369 {
1370     /* oPos, oFog and oPts in D3D */
1371     static const char * const hwrastout_reg_names[] = {"vs_out[10]", "vs_out[11].x", "vs_out[11].y"};
1372
1373     const struct wined3d_shader *shader = ins->ctx->shader;
1374     const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
1375     const struct wined3d_shader_version *version = &reg_maps->shader_version;
1376     const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
1377     const char *prefix = shader_glsl_get_prefix(version->type);
1378     struct glsl_src_param rel_param0, rel_param1;
1379
1380     if (reg->idx[0].offset != ~0U && reg->idx[0].rel_addr)
1381         shader_glsl_add_src_param(ins, reg->idx[0].rel_addr, WINED3DSP_WRITEMASK_0, &rel_param0);
1382     if (reg->idx[1].offset != ~0U && reg->idx[1].rel_addr)
1383         shader_glsl_add_src_param(ins, reg->idx[1].rel_addr, WINED3DSP_WRITEMASK_0, &rel_param1);
1384     *is_color = FALSE;
1385
1386     switch (reg->type)
1387     {
1388         case WINED3DSPR_TEMP:
1389             sprintf(register_name, "R%u", reg->idx[0].offset);
1390             break;
1391
1392         case WINED3DSPR_INPUT:
1393             /* vertex shaders */
1394             if (version->type == WINED3D_SHADER_TYPE_VERTEX)
1395             {
1396                 struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
1397                 if (priv->cur_vs_args->swizzle_map & (1 << reg->idx[0].offset))
1398                     *is_color = TRUE;
1399                 sprintf(register_name, "%s_in%u", prefix, reg->idx[0].offset);
1400                 break;
1401             }
1402
1403             if (version->type == WINED3D_SHADER_TYPE_GEOMETRY)
1404             {
1405                 if (reg->idx[0].rel_addr)
1406                 {
1407                     if (reg->idx[1].rel_addr)
1408                         sprintf(register_name, "gs_in[%s + %u][%s + %u]",
1409                                 rel_param0.param_str, reg->idx[0].offset, rel_param1.param_str, reg->idx[1].offset);
1410                     else
1411                         sprintf(register_name, "gs_in[%s + %u][%u]",
1412                                 rel_param0.param_str, reg->idx[0].offset, reg->idx[1].offset);
1413                 }
1414                 else if (reg->idx[1].rel_addr)
1415                     sprintf(register_name, "gs_in[%u][%s + %u]",
1416                             reg->idx[0].offset, rel_param1.param_str, reg->idx[1].offset);
1417                 else
1418                     sprintf(register_name, "gs_in[%u][%u]", reg->idx[0].offset, reg->idx[1].offset);
1419                 break;
1420             }
1421
1422             /* pixel shaders >= 3.0 */
1423             if (version->major >= 3)
1424             {
1425                 DWORD idx = shader->u.ps.input_reg_map[reg->idx[0].offset];
1426                 unsigned int in_count = vec4_varyings(version->major, gl_info);
1427
1428                 if (reg->idx[0].rel_addr)
1429                 {
1430                     /* Removing a + 0 would be an obvious optimization, but
1431                      * OS X doesn't see the NOP operation there. */
1432                     if (idx)
1433                     {
1434                         if (shader->u.ps.declared_in_count > in_count)
1435                         {
1436                             sprintf(register_name,
1437                                     "((%s + %u) > %u ? (%s + %u) > %u ? gl_SecondaryColor : gl_Color : %s_in[%s + %u])",
1438                                     rel_param0.param_str, idx, in_count - 1, rel_param0.param_str, idx, in_count,
1439                                     prefix, rel_param0.param_str, idx);
1440                         }
1441                         else
1442                         {
1443                             sprintf(register_name, "%s_in[%s + %u]", prefix, rel_param0.param_str, idx);
1444                         }
1445                     }
1446                     else
1447                     {
1448                         if (shader->u.ps.declared_in_count > in_count)
1449                         {
1450                             sprintf(register_name, "((%s) > %u ? (%s) > %u ? gl_SecondaryColor : gl_Color : %s_in[%s])",
1451                                     rel_param0.param_str, in_count - 1, rel_param0.param_str, in_count,
1452                                     prefix, rel_param0.param_str);
1453                         }
1454                         else
1455                         {
1456                             sprintf(register_name, "%s_in[%s]", prefix, rel_param0.param_str);
1457                         }
1458                     }
1459                 }
1460                 else
1461                 {
1462                     if (idx == in_count) sprintf(register_name, "gl_Color");
1463                     else if (idx == in_count + 1) sprintf(register_name, "gl_SecondaryColor");
1464                     else sprintf(register_name, "%s_in[%u]", prefix, idx);
1465                 }
1466             }
1467             else
1468             {
1469                 if (!reg->idx[0].offset)
1470                     strcpy(register_name, "gl_Color");
1471                 else
1472                     strcpy(register_name, "gl_SecondaryColor");
1473                 break;
1474             }
1475             break;
1476
1477         case WINED3DSPR_CONST:
1478             {
1479                 /* Relative addressing */
1480                 if (reg->idx[0].rel_addr)
1481                 {
1482                     if (reg->idx[0].offset)
1483                         sprintf(register_name, "%s_c[%s + %u]", prefix, rel_param0.param_str, reg->idx[0].offset);
1484                     else
1485                         sprintf(register_name, "%s_c[%s]", prefix, rel_param0.param_str);
1486                 }
1487                 else
1488                 {
1489                     if (shader_constant_is_local(shader, reg->idx[0].offset))
1490                         sprintf(register_name, "%s_lc%u", prefix, reg->idx[0].offset);
1491                     else
1492                         sprintf(register_name, "%s_c[%u]", prefix, reg->idx[0].offset);
1493                 }
1494             }
1495             break;
1496
1497         case WINED3DSPR_CONSTINT:
1498             sprintf(register_name, "%s_i[%u]", prefix, reg->idx[0].offset);
1499             break;
1500
1501         case WINED3DSPR_CONSTBOOL:
1502             sprintf(register_name, "%s_b[%u]", prefix, reg->idx[0].offset);
1503             break;
1504
1505         case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
1506             if (version->type == WINED3D_SHADER_TYPE_PIXEL)
1507                 sprintf(register_name, "T%u", reg->idx[0].offset);
1508             else
1509                 sprintf(register_name, "A%u", reg->idx[0].offset);
1510             break;
1511
1512         case WINED3DSPR_LOOP:
1513             sprintf(register_name, "aL%u", ins->ctx->loop_state->current_reg - 1);
1514             break;
1515
1516         case WINED3DSPR_SAMPLER:
1517             sprintf(register_name, "%s_sampler%u", prefix, reg->idx[0].offset);
1518             break;
1519
1520         case WINED3DSPR_COLOROUT:
1521             if (reg->idx[0].offset >= gl_info->limits.buffers)
1522                 WARN("Write to render target %u, only %d supported.\n",
1523                         reg->idx[0].offset, gl_info->limits.buffers);
1524
1525             sprintf(register_name, "gl_FragData[%u]", reg->idx[0].offset);
1526             break;
1527
1528         case WINED3DSPR_RASTOUT:
1529             sprintf(register_name, "%s", hwrastout_reg_names[reg->idx[0].offset]);
1530             break;
1531
1532         case WINED3DSPR_DEPTHOUT:
1533             sprintf(register_name, "gl_FragDepth");
1534             break;
1535
1536         case WINED3DSPR_ATTROUT:
1537             if (!reg->idx[0].offset)
1538                 sprintf(register_name, "%s_out[8]", prefix);
1539             else
1540                 sprintf(register_name, "%s_out[9]", prefix);
1541             break;
1542
1543         case WINED3DSPR_TEXCRDOUT:
1544             /* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
1545             sprintf(register_name, "%s_out[%u]", prefix, reg->idx[0].offset);
1546             break;
1547
1548         case WINED3DSPR_MISCTYPE:
1549             if (!reg->idx[0].offset)
1550             {
1551                 /* vPos */
1552                 sprintf(register_name, "vpos");
1553             }
1554             else if (reg->idx[0].offset == 1)
1555             {
1556                 /* Note that gl_FrontFacing is a bool, while vFace is
1557                  * a float for which the sign determines front/back */
1558                 sprintf(register_name, "(gl_FrontFacing ? 1.0 : -1.0)");
1559             }
1560             else
1561             {
1562                 FIXME("Unhandled misctype register %u.\n", reg->idx[0].offset);
1563                 sprintf(register_name, "unrecognized_register");
1564             }
1565             break;
1566
1567         case WINED3DSPR_IMMCONST:
1568             switch (reg->immconst_type)
1569             {
1570                 case WINED3D_IMMCONST_SCALAR:
1571                     switch (reg->data_type)
1572                     {
1573                         case WINED3D_DATA_FLOAT:
1574                             sprintf(register_name, "%.8e", *(const float *)reg->immconst_data);
1575                             break;
1576                         case WINED3D_DATA_INT:
1577                             sprintf(register_name, "%#x", reg->immconst_data[0]);
1578                             break;
1579                         case WINED3D_DATA_RESOURCE:
1580                         case WINED3D_DATA_SAMPLER:
1581                         case WINED3D_DATA_UINT:
1582                             sprintf(register_name, "%#xu", reg->immconst_data[0]);
1583                             break;
1584                         default:
1585                             sprintf(register_name, "<unhandled data type %#x>", reg->data_type);
1586                             break;
1587                     }
1588                     break;
1589
1590                 case WINED3D_IMMCONST_VEC4:
1591                     switch (reg->data_type)
1592                     {
1593                         case WINED3D_DATA_FLOAT:
1594                             sprintf(register_name, "vec4(%.8e, %.8e, %.8e, %.8e)",
1595                                     *(const float *)&reg->immconst_data[0], *(const float *)&reg->immconst_data[1],
1596                                     *(const float *)&reg->immconst_data[2], *(const float *)&reg->immconst_data[3]);
1597                             break;
1598                         case WINED3D_DATA_INT:
1599                             sprintf(register_name, "ivec4(%#x, %#x, %#x, %#x)",
1600                                     reg->immconst_data[0], reg->immconst_data[1],
1601                                     reg->immconst_data[2], reg->immconst_data[3]);
1602                             break;
1603                         case WINED3D_DATA_RESOURCE:
1604                         case WINED3D_DATA_SAMPLER:
1605                         case WINED3D_DATA_UINT:
1606                             sprintf(register_name, "uvec4(%#xu, %#xu, %#xu, %#xu)",
1607                                     reg->immconst_data[0], reg->immconst_data[1],
1608                                     reg->immconst_data[2], reg->immconst_data[3]);
1609                             break;
1610                         default:
1611                             sprintf(register_name, "<unhandled data type %#x>", reg->data_type);
1612                             break;
1613                     }
1614                     break;
1615
1616                 default:
1617                     FIXME("Unhandled immconst type %#x\n", reg->immconst_type);
1618                     sprintf(register_name, "<unhandled_immconst_type %#x>", reg->immconst_type);
1619             }
1620             break;
1621
1622         case WINED3DSPR_CONSTBUFFER:
1623             if (reg->idx[1].rel_addr)
1624                 sprintf(register_name, "%s_cb%u[%s + %u]",
1625                         prefix, reg->idx[0].offset, rel_param1.param_str, reg->idx[1].offset);
1626             else
1627                 sprintf(register_name, "%s_cb%u[%u]", prefix, reg->idx[0].offset, reg->idx[1].offset);
1628             break;
1629
1630         case WINED3DSPR_PRIMID:
1631             sprintf(register_name, "uint(gl_PrimitiveIDIn)");
1632             break;
1633
1634         default:
1635             FIXME("Unhandled register type %#x.\n", reg->type);
1636             sprintf(register_name, "unrecognized_register");
1637             break;
1638     }
1639 }
1640
1641 static void shader_glsl_write_mask_to_str(DWORD write_mask, char *str)
1642 {
1643     *str++ = '.';
1644     if (write_mask & WINED3DSP_WRITEMASK_0) *str++ = 'x';
1645     if (write_mask & WINED3DSP_WRITEMASK_1) *str++ = 'y';
1646     if (write_mask & WINED3DSP_WRITEMASK_2) *str++ = 'z';
1647     if (write_mask & WINED3DSP_WRITEMASK_3) *str++ = 'w';
1648     *str = '\0';
1649 }
1650
1651 /* Get the GLSL write mask for the destination register */
1652 static DWORD shader_glsl_get_write_mask(const struct wined3d_shader_dst_param *param, char *write_mask)
1653 {
1654     DWORD mask = param->write_mask;
1655
1656     if (shader_is_scalar(&param->reg))
1657     {
1658         mask = WINED3DSP_WRITEMASK_0;
1659         *write_mask = '\0';
1660     }
1661     else
1662     {
1663         shader_glsl_write_mask_to_str(mask, write_mask);
1664     }
1665
1666     return mask;
1667 }
1668
1669 static unsigned int shader_glsl_get_write_mask_size(DWORD write_mask) {
1670     unsigned int size = 0;
1671
1672     if (write_mask & WINED3DSP_WRITEMASK_0) ++size;
1673     if (write_mask & WINED3DSP_WRITEMASK_1) ++size;
1674     if (write_mask & WINED3DSP_WRITEMASK_2) ++size;
1675     if (write_mask & WINED3DSP_WRITEMASK_3) ++size;
1676
1677     return size;
1678 }
1679
1680 static void shader_glsl_swizzle_to_str(const DWORD swizzle, BOOL fixup, DWORD mask, char *str)
1681 {
1682     /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
1683      * but addressed as "rgba". To fix this we need to swap the register's x
1684      * and z components. */
1685     const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
1686
1687     *str++ = '.';
1688     /* swizzle bits fields: wwzzyyxx */
1689     if (mask & WINED3DSP_WRITEMASK_0) *str++ = swizzle_chars[swizzle & 0x03];
1690     if (mask & WINED3DSP_WRITEMASK_1) *str++ = swizzle_chars[(swizzle >> 2) & 0x03];
1691     if (mask & WINED3DSP_WRITEMASK_2) *str++ = swizzle_chars[(swizzle >> 4) & 0x03];
1692     if (mask & WINED3DSP_WRITEMASK_3) *str++ = swizzle_chars[(swizzle >> 6) & 0x03];
1693     *str = '\0';
1694 }
1695
1696 static void shader_glsl_get_swizzle(const struct wined3d_shader_src_param *param,
1697         BOOL fixup, DWORD mask, char *swizzle_str)
1698 {
1699     if (shader_is_scalar(&param->reg))
1700         *swizzle_str = '\0';
1701     else
1702         shader_glsl_swizzle_to_str(param->swizzle, fixup, mask, swizzle_str);
1703 }
1704
1705 /* From a given parameter token, generate the corresponding GLSL string.
1706  * Also, return the actual register name and swizzle in case the
1707  * caller needs this information as well. */
1708 static void shader_glsl_add_src_param(const struct wined3d_shader_instruction *ins,
1709         const struct wined3d_shader_src_param *wined3d_src, DWORD mask, struct glsl_src_param *glsl_src)
1710 {
1711     BOOL is_color = FALSE;
1712     char swizzle_str[6];
1713
1714     glsl_src->reg_name[0] = '\0';
1715     glsl_src->param_str[0] = '\0';
1716     swizzle_str[0] = '\0';
1717
1718     shader_glsl_get_register_name(&wined3d_src->reg, glsl_src->reg_name, &is_color, ins);
1719     shader_glsl_get_swizzle(wined3d_src, is_color, mask, swizzle_str);
1720
1721     if (wined3d_src->reg.type == WINED3DSPR_IMMCONST || wined3d_src->reg.type == WINED3DSPR_PRIMID)
1722     {
1723         shader_glsl_gen_modifier(wined3d_src->modifiers, glsl_src->reg_name, swizzle_str, glsl_src->param_str);
1724     }
1725     else
1726     {
1727         char param_str[200];
1728
1729         shader_glsl_gen_modifier(wined3d_src->modifiers, glsl_src->reg_name, swizzle_str, param_str);
1730
1731         switch (wined3d_src->reg.data_type)
1732         {
1733             case WINED3D_DATA_FLOAT:
1734                 sprintf(glsl_src->param_str, "%s", param_str);
1735                 break;
1736             case WINED3D_DATA_INT:
1737                 sprintf(glsl_src->param_str, "floatBitsToInt(%s)", param_str);
1738                 break;
1739             case WINED3D_DATA_RESOURCE:
1740             case WINED3D_DATA_SAMPLER:
1741             case WINED3D_DATA_UINT:
1742                 sprintf(glsl_src->param_str, "floatBitsToUint(%s)", param_str);
1743                 break;
1744             default:
1745                 FIXME("Unhandled data type %#x.\n", wined3d_src->reg.data_type);
1746                 sprintf(glsl_src->param_str, "%s", param_str);
1747                 break;
1748         }
1749     }
1750 }
1751
1752 /* From a given parameter token, generate the corresponding GLSL string.
1753  * Also, return the actual register name and swizzle in case the
1754  * caller needs this information as well. */
1755 static DWORD shader_glsl_add_dst_param(const struct wined3d_shader_instruction *ins,
1756         const struct wined3d_shader_dst_param *wined3d_dst, struct glsl_dst_param *glsl_dst)
1757 {
1758     BOOL is_color = FALSE;
1759
1760     glsl_dst->mask_str[0] = '\0';
1761     glsl_dst->reg_name[0] = '\0';
1762
1763     shader_glsl_get_register_name(&wined3d_dst->reg, glsl_dst->reg_name, &is_color, ins);
1764     return shader_glsl_get_write_mask(wined3d_dst, glsl_dst->mask_str);
1765 }
1766
1767 /* Append the destination part of the instruction to the buffer, return the effective write mask */
1768 static DWORD shader_glsl_append_dst_ext(struct wined3d_shader_buffer *buffer,
1769         const struct wined3d_shader_instruction *ins, const struct wined3d_shader_dst_param *dst)
1770 {
1771     struct glsl_dst_param glsl_dst;
1772     DWORD mask;
1773
1774     if ((mask = shader_glsl_add_dst_param(ins, dst, &glsl_dst)))
1775     {
1776         switch (dst->reg.data_type)
1777         {
1778             case WINED3D_DATA_FLOAT:
1779                 shader_addline(buffer, "%s%s = %s(",
1780                         glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]);
1781                 break;
1782             case WINED3D_DATA_INT:
1783                 shader_addline(buffer, "%s%s = %sintBitsToFloat(",
1784                         glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]);
1785                 break;
1786             case WINED3D_DATA_RESOURCE:
1787             case WINED3D_DATA_SAMPLER:
1788             case WINED3D_DATA_UINT:
1789                 shader_addline(buffer, "%s%s = %suintBitsToFloat(",
1790                         glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]);
1791                 break;
1792             default:
1793                 FIXME("Unhandled data type %#x.\n", dst->reg.data_type);
1794                 shader_addline(buffer, "%s%s = %s(",
1795                         glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]);
1796                 break;
1797         }
1798     }
1799
1800     return mask;
1801 }
1802
1803 /* Append the destination part of the instruction to the buffer, return the effective write mask */
1804 static DWORD shader_glsl_append_dst(struct wined3d_shader_buffer *buffer, const struct wined3d_shader_instruction *ins)
1805 {
1806     return shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0]);
1807 }
1808
1809 /** Process GLSL instruction modifiers */
1810 static void shader_glsl_add_instruction_modifiers(const struct wined3d_shader_instruction *ins)
1811 {
1812     struct glsl_dst_param dst_param;
1813     DWORD modifiers;
1814
1815     if (!ins->dst_count) return;
1816
1817     modifiers = ins->dst[0].modifiers;
1818     if (!modifiers) return;
1819
1820     shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
1821
1822     if (modifiers & WINED3DSPDM_SATURATE)
1823     {
1824         /* _SAT means to clamp the value of the register to between 0 and 1 */
1825         shader_addline(ins->ctx->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_param.reg_name,
1826                 dst_param.mask_str, dst_param.reg_name, dst_param.mask_str);
1827     }
1828
1829     if (modifiers & WINED3DSPDM_MSAMPCENTROID)
1830     {
1831         FIXME("_centroid modifier not handled\n");
1832     }
1833
1834     if (modifiers & WINED3DSPDM_PARTIALPRECISION)
1835     {
1836         /* MSDN says this modifier can be safely ignored, so that's what we'll do. */
1837     }
1838 }
1839
1840 static const char *shader_glsl_get_rel_op(enum wined3d_shader_rel_op op)
1841 {
1842     switch (op)
1843     {
1844         case WINED3D_SHADER_REL_OP_GT: return ">";
1845         case WINED3D_SHADER_REL_OP_EQ: return "==";
1846         case WINED3D_SHADER_REL_OP_GE: return ">=";
1847         case WINED3D_SHADER_REL_OP_LT: return "<";
1848         case WINED3D_SHADER_REL_OP_NE: return "!=";
1849         case WINED3D_SHADER_REL_OP_LE: return "<=";
1850         default:
1851             FIXME("Unrecognized operator %#x.\n", op);
1852             return "(\?\?)";
1853     }
1854 }
1855
1856 static void shader_glsl_get_sample_function(const struct wined3d_shader_context *ctx,
1857         DWORD sampler_idx, DWORD flags, struct glsl_sample_function *sample_function)
1858 {
1859     enum wined3d_sampler_texture_type sampler_type = ctx->reg_maps->sampler_type[sampler_idx];
1860     const struct wined3d_gl_info *gl_info = ctx->gl_info;
1861     BOOL shadow = ctx->reg_maps->shader_version.type == WINED3D_SHADER_TYPE_PIXEL
1862             && (((const struct shader_glsl_ctx_priv *)ctx->backend_data)->cur_ps_args->shadow & (1 << sampler_idx));
1863     BOOL projected = flags & WINED3D_GLSL_SAMPLE_PROJECTED;
1864     BOOL texrect = flags & WINED3D_GLSL_SAMPLE_NPOT && gl_info->supported[ARB_TEXTURE_RECTANGLE];
1865     BOOL lod = flags & WINED3D_GLSL_SAMPLE_LOD;
1866     BOOL grad = flags & WINED3D_GLSL_SAMPLE_GRAD;
1867
1868     /* Note that there's no such thing as a projected cube texture. */
1869     switch(sampler_type) {
1870         case WINED3DSTT_1D:
1871             if (shadow)
1872             {
1873                 if (lod)
1874                 {
1875                     sample_function->name = projected ? "shadow1DProjLod" : "shadow1DLod";
1876                 }
1877                 else if (grad)
1878                 {
1879                     if (gl_info->supported[EXT_GPU_SHADER4])
1880                         sample_function->name = projected ? "shadow1DProjGrad" : "shadow1DGrad";
1881                     else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
1882                         sample_function->name = projected ? "shadow1DProjGradARB" : "shadow1DGradARB";
1883                     else
1884                     {
1885                         FIXME("Unsupported 1D shadow grad function.\n");
1886                         sample_function->name = "unsupported1DGrad";
1887                     }
1888                 }
1889                 else
1890                 {
1891                     sample_function->name = projected ? "shadow1DProj" : "shadow1D";
1892                 }
1893                 sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1;
1894             }
1895             else
1896             {
1897                 if (lod)
1898                 {
1899                     sample_function->name = projected ? "texture1DProjLod" : "texture1DLod";
1900                 }
1901                 else if (grad)
1902                 {
1903                     if (gl_info->supported[EXT_GPU_SHADER4])
1904                         sample_function->name = projected ? "texture1DProjGrad" : "texture1DGrad";
1905                     else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
1906                         sample_function->name = projected ? "texture1DProjGradARB" : "texture1DGradARB";
1907                     else
1908                     {
1909                         FIXME("Unsupported 1D grad function.\n");
1910                         sample_function->name = "unsupported1DGrad";
1911                     }
1912                 }
1913                 else
1914                 {
1915                     sample_function->name = projected ? "texture1DProj" : "texture1D";
1916                 }
1917                 sample_function->coord_mask = WINED3DSP_WRITEMASK_0;
1918             }
1919             break;
1920
1921         case WINED3DSTT_2D:
1922             if (shadow)
1923             {
1924                 if (texrect)
1925                 {
1926                     if (lod)
1927                     {
1928                         sample_function->name = projected ? "shadow2DRectProjLod" : "shadow2DRectLod";
1929                     }
1930                     else if (grad)
1931                     {
1932                         if (gl_info->supported[EXT_GPU_SHADER4])
1933                             sample_function->name = projected ? "shadow2DRectProjGrad" : "shadow2DRectGrad";
1934                         else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
1935                             sample_function->name = projected ? "shadow2DRectProjGradARB" : "shadow2DRectGradARB";
1936                         else
1937                         {
1938                             FIXME("Unsupported RECT shadow grad function.\n");
1939                             sample_function->name = "unsupported2DRectGrad";
1940                         }
1941                     }
1942                     else
1943                     {
1944                         sample_function->name = projected ? "shadow2DRectProj" : "shadow2DRect";
1945                     }
1946                 }
1947                 else
1948                 {
1949                     if (lod)
1950                     {
1951                         sample_function->name = projected ? "shadow2DProjLod" : "shadow2DLod";
1952                     }
1953                     else if (grad)
1954                     {
1955                         if (gl_info->supported[EXT_GPU_SHADER4])
1956                             sample_function->name = projected ? "shadow2DProjGrad" : "shadow2DGrad";
1957                         else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
1958                             sample_function->name = projected ? "shadow2DProjGradARB" : "shadow2DGradARB";
1959                         else
1960                         {
1961                             FIXME("Unsupported 2D shadow grad function.\n");
1962                             sample_function->name = "unsupported2DGrad";
1963                         }
1964                     }
1965                     else
1966                     {
1967                         sample_function->name = projected ? "shadow2DProj" : "shadow2D";
1968                     }
1969                 }
1970                 sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
1971             }
1972             else
1973             {
1974                 if (texrect)
1975                 {
1976                     if (lod)
1977                     {
1978                         sample_function->name = projected ? "texture2DRectProjLod" : "texture2DRectLod";
1979                     }
1980                     else if (grad)
1981                     {
1982                         if (gl_info->supported[EXT_GPU_SHADER4])
1983                             sample_function->name = projected ? "texture2DRectProjGrad" : "texture2DRectGrad";
1984                         else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
1985                             sample_function->name = projected ? "texture2DRectProjGradARB" : "texture2DRectGradARB";
1986                         else
1987                         {
1988                             FIXME("Unsupported RECT grad function.\n");
1989                             sample_function->name = "unsupported2DRectGrad";
1990                         }
1991                     }
1992                     else
1993                     {
1994                         sample_function->name = projected ? "texture2DRectProj" : "texture2DRect";
1995                     }
1996                 }
1997                 else
1998                 {
1999                     if (lod)
2000                     {
2001                         sample_function->name = projected ? "texture2DProjLod" : "texture2DLod";
2002                     }
2003                     else if (grad)
2004                     {
2005                         if (gl_info->supported[EXT_GPU_SHADER4])
2006                             sample_function->name = projected ? "texture2DProjGrad" : "texture2DGrad";
2007                         else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
2008                             sample_function->name = projected ? "texture2DProjGradARB" : "texture2DGradARB";
2009                         else
2010                         {
2011                             FIXME("Unsupported 2D grad function.\n");
2012                             sample_function->name = "unsupported2DGrad";
2013                         }
2014                     }
2015                     else
2016                     {
2017                         sample_function->name = projected ? "texture2DProj" : "texture2D";
2018                     }
2019                 }
2020                 sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1;
2021             }
2022             break;
2023
2024         case WINED3DSTT_CUBE:
2025             if (shadow)
2026             {
2027                 FIXME("Unsupported Cube shadow function.\n");
2028                 sample_function->name = "unsupportedCubeShadow";
2029                 sample_function->coord_mask = 0;
2030             }
2031             else
2032             {
2033                 if (lod)
2034                 {
2035                     sample_function->name = "textureCubeLod";
2036                 }
2037                 else if (grad)
2038                 {
2039                     if (gl_info->supported[EXT_GPU_SHADER4])
2040                         sample_function->name = "textureCubeGrad";
2041                     else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
2042                         sample_function->name = "textureCubeGradARB";
2043                     else
2044                     {
2045                         FIXME("Unsupported Cube grad function.\n");
2046                         sample_function->name = "unsupportedCubeGrad";
2047                     }
2048                 }
2049                 else
2050                 {
2051                     sample_function->name = "textureCube";
2052                 }
2053                 sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2054             }
2055             break;
2056
2057         case WINED3DSTT_VOLUME:
2058             if (shadow)
2059             {
2060                 FIXME("Unsupported 3D shadow function.\n");
2061                 sample_function->name = "unsupported3DShadow";
2062                 sample_function->coord_mask = 0;
2063             }
2064             else
2065             {
2066                 if (lod)
2067                 {
2068                     sample_function->name = projected ? "texture3DProjLod" : "texture3DLod";
2069                 }
2070                 else  if (grad)
2071                 {
2072                     if (gl_info->supported[EXT_GPU_SHADER4])
2073                         sample_function->name = projected ? "texture3DProjGrad" : "texture3DGrad";
2074                     else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
2075                         sample_function->name = projected ? "texture3DProjGradARB" : "texture3DGradARB";
2076                     else
2077                     {
2078                         FIXME("Unsupported 3D grad function.\n");
2079                         sample_function->name = "unsupported3DGrad";
2080                     }
2081                 }
2082                 else
2083                 {
2084                     sample_function->name = projected ? "texture3DProj" : "texture3D";
2085                 }
2086                 sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2087             }
2088             break;
2089
2090         default:
2091             sample_function->name = "";
2092             sample_function->coord_mask = 0;
2093             FIXME("Unrecognized sampler type: %#x;\n", sampler_type);
2094             break;
2095     }
2096 }
2097
2098 static void shader_glsl_append_fixup_arg(char *arguments, const char *reg_name,
2099         BOOL sign_fixup, enum fixup_channel_source channel_source)
2100 {
2101     switch(channel_source)
2102     {
2103         case CHANNEL_SOURCE_ZERO:
2104             strcat(arguments, "0.0");
2105             break;
2106
2107         case CHANNEL_SOURCE_ONE:
2108             strcat(arguments, "1.0");
2109             break;
2110
2111         case CHANNEL_SOURCE_X:
2112             strcat(arguments, reg_name);
2113             strcat(arguments, ".x");
2114             break;
2115
2116         case CHANNEL_SOURCE_Y:
2117             strcat(arguments, reg_name);
2118             strcat(arguments, ".y");
2119             break;
2120
2121         case CHANNEL_SOURCE_Z:
2122             strcat(arguments, reg_name);
2123             strcat(arguments, ".z");
2124             break;
2125
2126         case CHANNEL_SOURCE_W:
2127             strcat(arguments, reg_name);
2128             strcat(arguments, ".w");
2129             break;
2130
2131         default:
2132             FIXME("Unhandled channel source %#x\n", channel_source);
2133             strcat(arguments, "undefined");
2134             break;
2135     }
2136
2137     if (sign_fixup) strcat(arguments, " * 2.0 - 1.0");
2138 }
2139
2140 static void shader_glsl_color_correction_ext(struct wined3d_shader_buffer *buffer,
2141         const char *reg_name, DWORD mask, struct color_fixup_desc fixup)
2142 {
2143     unsigned int mask_size, remaining;
2144     DWORD fixup_mask = 0;
2145     char arguments[256];
2146     char mask_str[6];
2147
2148     if (fixup.x_sign_fixup || fixup.x_source != CHANNEL_SOURCE_X) fixup_mask |= WINED3DSP_WRITEMASK_0;
2149     if (fixup.y_sign_fixup || fixup.y_source != CHANNEL_SOURCE_Y) fixup_mask |= WINED3DSP_WRITEMASK_1;
2150     if (fixup.z_sign_fixup || fixup.z_source != CHANNEL_SOURCE_Z) fixup_mask |= WINED3DSP_WRITEMASK_2;
2151     if (fixup.w_sign_fixup || fixup.w_source != CHANNEL_SOURCE_W) fixup_mask |= WINED3DSP_WRITEMASK_3;
2152     if (!(mask &= fixup_mask))
2153         return;
2154
2155     if (is_complex_fixup(fixup))
2156     {
2157         enum complex_fixup complex_fixup = get_complex_fixup(fixup);
2158         FIXME("Complex fixup (%#x) not supported\n",complex_fixup);
2159         return;
2160     }
2161
2162     shader_glsl_write_mask_to_str(mask, mask_str);
2163     mask_size = shader_glsl_get_write_mask_size(mask);
2164
2165     arguments[0] = '\0';
2166     remaining = mask_size;
2167     if (mask & WINED3DSP_WRITEMASK_0)
2168     {
2169         shader_glsl_append_fixup_arg(arguments, reg_name, fixup.x_sign_fixup, fixup.x_source);
2170         if (--remaining) strcat(arguments, ", ");
2171     }
2172     if (mask & WINED3DSP_WRITEMASK_1)
2173     {
2174         shader_glsl_append_fixup_arg(arguments, reg_name, fixup.y_sign_fixup, fixup.y_source);
2175         if (--remaining) strcat(arguments, ", ");
2176     }
2177     if (mask & WINED3DSP_WRITEMASK_2)
2178     {
2179         shader_glsl_append_fixup_arg(arguments, reg_name, fixup.z_sign_fixup, fixup.z_source);
2180         if (--remaining) strcat(arguments, ", ");
2181     }
2182     if (mask & WINED3DSP_WRITEMASK_3)
2183     {
2184         shader_glsl_append_fixup_arg(arguments, reg_name, fixup.w_sign_fixup, fixup.w_source);
2185         if (--remaining) strcat(arguments, ", ");
2186     }
2187
2188     if (mask_size > 1)
2189         shader_addline(buffer, "%s%s = vec%u(%s);\n", reg_name, mask_str, mask_size, arguments);
2190     else
2191         shader_addline(buffer, "%s%s = %s;\n", reg_name, mask_str, arguments);
2192 }
2193
2194 static void shader_glsl_color_correction(const struct wined3d_shader_instruction *ins, struct color_fixup_desc fixup)
2195 {
2196     char reg_name[256];
2197     BOOL is_color;
2198
2199     shader_glsl_get_register_name(&ins->dst[0].reg, reg_name, &is_color, ins);
2200     shader_glsl_color_correction_ext(ins->ctx->buffer, reg_name, ins->dst[0].write_mask, fixup);
2201 }
2202
2203 static void PRINTF_ATTR(8, 9) shader_glsl_gen_sample_code(const struct wined3d_shader_instruction *ins,
2204         DWORD sampler, const struct glsl_sample_function *sample_function, DWORD swizzle,
2205         const char *dx, const char *dy, const char *bias, const char *coord_reg_fmt, ...)
2206 {
2207     const struct wined3d_shader_version *version = &ins->ctx->reg_maps->shader_version;
2208     char dst_swizzle[6];
2209     struct color_fixup_desc fixup;
2210     BOOL np2_fixup = FALSE;
2211     va_list args;
2212
2213     shader_glsl_swizzle_to_str(swizzle, FALSE, ins->dst[0].write_mask, dst_swizzle);
2214
2215     if (version->type == WINED3D_SHADER_TYPE_PIXEL)
2216     {
2217         const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
2218         fixup = priv->cur_ps_args->color_fixup[sampler];
2219
2220         if(priv->cur_ps_args->np2_fixup & (1 << sampler)) {
2221             if(bias) {
2222                 FIXME("Biased sampling from NP2 textures is unsupported\n");
2223             } else {
2224                 np2_fixup = TRUE;
2225             }
2226         }
2227     }
2228     else
2229     {
2230         fixup = COLOR_FIXUP_IDENTITY; /* FIXME: Vshader color fixup */
2231     }
2232
2233     shader_glsl_append_dst(ins->ctx->buffer, ins);
2234
2235     shader_addline(ins->ctx->buffer, "%s(%s_sampler%u, ",
2236             sample_function->name, shader_glsl_get_prefix(version->type), sampler);
2237
2238     va_start(args, coord_reg_fmt);
2239     shader_vaddline(ins->ctx->buffer, coord_reg_fmt, args);
2240     va_end(args);
2241
2242     if(bias) {
2243         shader_addline(ins->ctx->buffer, ", %s)%s);\n", bias, dst_swizzle);
2244     } else {
2245         if (np2_fixup) {
2246             const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
2247             const unsigned char idx = priv->cur_np2fixup_info->idx[sampler];
2248
2249             shader_addline(ins->ctx->buffer, " * ps_samplerNP2Fixup[%u].%s)%s);\n", idx >> 1,
2250                            (idx % 2) ? "zw" : "xy", dst_swizzle);
2251         } else if(dx && dy) {
2252             shader_addline(ins->ctx->buffer, ", %s, %s)%s);\n", dx, dy, dst_swizzle);
2253         } else {
2254             shader_addline(ins->ctx->buffer, ")%s);\n", dst_swizzle);
2255         }
2256     }
2257
2258     if(!is_identity_fixup(fixup)) {
2259         shader_glsl_color_correction(ins, fixup);
2260     }
2261 }
2262
2263 /*****************************************************************************
2264  * Begin processing individual instruction opcodes
2265  ****************************************************************************/
2266
2267 static void shader_glsl_binop(const struct wined3d_shader_instruction *ins)
2268 {
2269     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2270     struct glsl_src_param src0_param;
2271     struct glsl_src_param src1_param;
2272     DWORD write_mask;
2273     const char *op;
2274
2275     /* Determine the GLSL operator to use based on the opcode */
2276     switch (ins->handler_idx)
2277     {
2278         case WINED3DSIH_ADD:  op = "+";  break;
2279         case WINED3DSIH_AND:  op = "&";  break;
2280         case WINED3DSIH_DIV:  op = "/";  break;
2281         case WINED3DSIH_IADD: op = "+";  break;
2282         case WINED3DSIH_MUL:  op = "*";  break;
2283         case WINED3DSIH_SUB:  op = "-";  break;
2284         case WINED3DSIH_USHR: op = ">>"; break;
2285         case WINED3DSIH_XOR:  op = "^";  break;
2286         default:
2287             op = "<unhandled operator>";
2288             FIXME("Opcode %#x not yet handled in GLSL\n", ins->handler_idx);
2289             break;
2290     }
2291
2292     write_mask = shader_glsl_append_dst(buffer, ins);
2293     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2294     shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2295     shader_addline(buffer, "%s %s %s);\n", src0_param.param_str, op, src1_param.param_str);
2296 }
2297
2298 static void shader_glsl_relop(const struct wined3d_shader_instruction *ins)
2299 {
2300     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2301     struct glsl_src_param src0_param;
2302     struct glsl_src_param src1_param;
2303     unsigned int mask_size;
2304     DWORD write_mask;
2305     const char *op;
2306
2307     write_mask = shader_glsl_append_dst(buffer, ins);
2308     mask_size = shader_glsl_get_write_mask_size(write_mask);
2309     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2310     shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2311
2312     if (mask_size > 1)
2313     {
2314         switch (ins->handler_idx)
2315         {
2316             case WINED3DSIH_EQ:  op = "equal"; break;
2317             case WINED3DSIH_GE:  op = "greaterThanEqual"; break;
2318             case WINED3DSIH_IGE: op = "greaterThanEqual"; break;
2319             case WINED3DSIH_LT:  op = "lessThan"; break;
2320             default:
2321                 op = "<unhandled operator>";
2322                 ERR("Unhandled opcode %#x.\n", ins->handler_idx);
2323                 break;
2324         }
2325
2326         shader_addline(buffer, "uvec%u(%s(%s, %s)) * 0xffffffffu);\n",
2327                 mask_size, op, src0_param.param_str, src1_param.param_str);
2328     }
2329     else
2330     {
2331         switch (ins->handler_idx)
2332         {
2333             case WINED3DSIH_EQ:  op = "=="; break;
2334             case WINED3DSIH_GE:  op = ">="; break;
2335             case WINED3DSIH_IGE: op = ">="; break;
2336             case WINED3DSIH_LT:  op = "<"; break;
2337             default:
2338                 op = "<unhandled operator>";
2339                 ERR("Unhandled opcode %#x.\n", ins->handler_idx);
2340                 break;
2341         }
2342
2343         shader_addline(buffer, "%s %s %s ? 0xffffffffu : 0u);\n",
2344                 src0_param.param_str, op, src1_param.param_str);
2345     }
2346 }
2347
2348 static void shader_glsl_imul(const struct wined3d_shader_instruction *ins)
2349 {
2350     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2351     struct glsl_src_param src0_param;
2352     struct glsl_src_param src1_param;
2353     DWORD write_mask;
2354
2355     /* If we have ARB_gpu_shader5 or GLSL 4.0, we can use imulExtended(). If
2356      * not, we can emulate it. */
2357     if (ins->dst[0].reg.type != WINED3DSPR_NULL)
2358         FIXME("64-bit integer multiplies not implemented.\n");
2359
2360     if (ins->dst[1].reg.type != WINED3DSPR_NULL)
2361     {
2362         write_mask = shader_glsl_append_dst_ext(buffer, ins, &ins->dst[1]);
2363         shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2364         shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2365
2366         shader_addline(ins->ctx->buffer, "%s * %s);\n",
2367                 src0_param.param_str, src1_param.param_str);
2368     }
2369 }
2370
2371 static void shader_glsl_udiv(const struct wined3d_shader_instruction *ins)
2372 {
2373     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2374     struct glsl_src_param src0_param, src1_param;
2375     DWORD write_mask;
2376
2377     if (ins->dst[0].reg.type != WINED3DSPR_NULL)
2378     {
2379
2380         if (ins->dst[1].reg.type != WINED3DSPR_NULL)
2381         {
2382             char dst_mask[6];
2383
2384             write_mask = shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
2385             shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2386             shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2387             shader_addline(buffer, "tmp0%s = %s / %s;\n",
2388                     dst_mask, src0_param.param_str, src1_param.param_str);
2389
2390             write_mask = shader_glsl_append_dst_ext(buffer, ins, &ins->dst[1]);
2391             shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2392             shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2393             shader_addline(buffer, "%s %% %s));\n", src0_param.param_str, src1_param.param_str);
2394
2395             shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0]);
2396             shader_addline(buffer, "tmp0%s);\n", dst_mask);
2397         }
2398         else
2399         {
2400             write_mask = shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0]);
2401             shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2402             shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2403             shader_addline(buffer, "%s / %s);\n", src0_param.param_str, src1_param.param_str);
2404         }
2405     }
2406     else if (ins->dst[1].reg.type != WINED3DSPR_NULL)
2407     {
2408         write_mask = shader_glsl_append_dst_ext(buffer, ins, &ins->dst[1]);
2409         shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2410         shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2411         shader_addline(buffer, "%s %% %s);\n", src0_param.param_str, src1_param.param_str);
2412     }
2413 }
2414
2415 /* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
2416 static void shader_glsl_mov(const struct wined3d_shader_instruction *ins)
2417 {
2418     const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
2419     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2420     struct glsl_src_param src0_param;
2421     DWORD write_mask;
2422
2423     write_mask = shader_glsl_append_dst(buffer, ins);
2424     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2425
2426     /* In vs_1_1 WINED3DSIO_MOV can write to the address register. In later
2427      * shader versions WINED3DSIO_MOVA is used for this. */
2428     if (ins->ctx->reg_maps->shader_version.major == 1
2429             && ins->ctx->reg_maps->shader_version.type == WINED3D_SHADER_TYPE_VERTEX
2430             && ins->dst[0].reg.type == WINED3DSPR_ADDR)
2431     {
2432         /* This is a simple floor() */
2433         unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
2434         if (mask_size > 1) {
2435             shader_addline(buffer, "ivec%d(floor(%s)));\n", mask_size, src0_param.param_str);
2436         } else {
2437             shader_addline(buffer, "int(floor(%s)));\n", src0_param.param_str);
2438         }
2439     }
2440     else if(ins->handler_idx == WINED3DSIH_MOVA)
2441     {
2442         /* We need to *round* to the nearest int here. */
2443         unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
2444
2445         if (gl_info->supported[EXT_GPU_SHADER4])
2446         {
2447             if (mask_size > 1)
2448                 shader_addline(buffer, "ivec%d(round(%s)));\n", mask_size, src0_param.param_str);
2449             else
2450                 shader_addline(buffer, "int(round(%s)));\n", src0_param.param_str);
2451         }
2452         else
2453         {
2454             if (mask_size > 1)
2455                 shader_addline(buffer, "ivec%d(floor(abs(%s) + vec%d(0.5)) * sign(%s)));\n",
2456                         mask_size, src0_param.param_str, mask_size, src0_param.param_str);
2457             else
2458                 shader_addline(buffer, "int(floor(abs(%s) + 0.5) * sign(%s)));\n",
2459                         src0_param.param_str, src0_param.param_str);
2460         }
2461     }
2462     else
2463     {
2464         shader_addline(buffer, "%s);\n", src0_param.param_str);
2465     }
2466 }
2467
2468 /* Process the dot product operators DP3 and DP4 in GLSL (dst = dot(src0, src1)) */
2469 static void shader_glsl_dot(const struct wined3d_shader_instruction *ins)
2470 {
2471     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2472     struct glsl_src_param src0_param;
2473     struct glsl_src_param src1_param;
2474     DWORD dst_write_mask, src_write_mask;
2475     unsigned int dst_size = 0;
2476
2477     dst_write_mask = shader_glsl_append_dst(buffer, ins);
2478     dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
2479
2480     /* dp3 works on vec3, dp4 on vec4 */
2481     if (ins->handler_idx == WINED3DSIH_DP4)
2482     {
2483         src_write_mask = WINED3DSP_WRITEMASK_ALL;
2484     } else {
2485         src_write_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2486     }
2487
2488     shader_glsl_add_src_param(ins, &ins->src[0], src_write_mask, &src0_param);
2489     shader_glsl_add_src_param(ins, &ins->src[1], src_write_mask, &src1_param);
2490
2491     if (dst_size > 1) {
2492         shader_addline(buffer, "vec%d(dot(%s, %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
2493     } else {
2494         shader_addline(buffer, "dot(%s, %s));\n", src0_param.param_str, src1_param.param_str);
2495     }
2496 }
2497
2498 /* Note that this instruction has some restrictions. The destination write mask
2499  * can't contain the w component, and the source swizzles have to be .xyzw */
2500 static void shader_glsl_cross(const struct wined3d_shader_instruction *ins)
2501 {
2502     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
2503     struct glsl_src_param src0_param;
2504     struct glsl_src_param src1_param;
2505     char dst_mask[6];
2506
2507     shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
2508     shader_glsl_append_dst(ins->ctx->buffer, ins);
2509     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
2510     shader_glsl_add_src_param(ins, &ins->src[1], src_mask, &src1_param);
2511     shader_addline(ins->ctx->buffer, "cross(%s, %s)%s);\n", src0_param.param_str, src1_param.param_str, dst_mask);
2512 }
2513
2514 static void shader_glsl_cut(const struct wined3d_shader_instruction *ins)
2515 {
2516     shader_addline(ins->ctx->buffer, "EndPrimitive();\n");
2517 }
2518
2519 /* Process the WINED3DSIO_POW instruction in GLSL (dst = |src0|^src1)
2520  * Src0 and src1 are scalars. Note that D3D uses the absolute of src0, while
2521  * GLSL uses the value as-is. */
2522 static void shader_glsl_pow(const struct wined3d_shader_instruction *ins)
2523 {
2524     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2525     struct glsl_src_param src0_param;
2526     struct glsl_src_param src1_param;
2527     DWORD dst_write_mask;
2528     unsigned int dst_size;
2529
2530     dst_write_mask = shader_glsl_append_dst(buffer, ins);
2531     dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
2532
2533     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
2534     shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0, &src1_param);
2535
2536     if (dst_size > 1)
2537     {
2538         shader_addline(buffer, "vec%u(%s == 0.0 ? 1.0 : pow(abs(%s), %s)));\n",
2539                 dst_size, src1_param.param_str, src0_param.param_str, src1_param.param_str);
2540     }
2541     else
2542     {
2543         shader_addline(buffer, "%s == 0.0 ? 1.0 : pow(abs(%s), %s));\n",
2544                 src1_param.param_str, src0_param.param_str, src1_param.param_str);
2545     }
2546 }
2547
2548 /* Process the WINED3DSIO_LOG instruction in GLSL (dst = log2(|src0|))
2549  * Src0 is a scalar. Note that D3D uses the absolute of src0, while
2550  * GLSL uses the value as-is. */
2551 static void shader_glsl_log(const struct wined3d_shader_instruction *ins)
2552 {
2553     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2554     struct glsl_src_param src0_param;
2555     DWORD dst_write_mask;
2556     unsigned int dst_size;
2557
2558     dst_write_mask = shader_glsl_append_dst(buffer, ins);
2559     dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
2560
2561     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
2562
2563     if (dst_size > 1)
2564     {
2565         shader_addline(buffer, "vec%u(log2(abs(%s))));\n",
2566                 dst_size, src0_param.param_str);
2567     }
2568     else
2569     {
2570         shader_addline(buffer, "log2(abs(%s)));\n",
2571                 src0_param.param_str);
2572     }
2573 }
2574
2575 /* Map the opcode 1-to-1 to the GL code (arg->dst = instruction(src0, src1, ...) */
2576 static void shader_glsl_map2gl(const struct wined3d_shader_instruction *ins)
2577 {
2578     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2579     struct glsl_src_param src_param;
2580     const char *instruction;
2581     DWORD write_mask;
2582     unsigned i;
2583
2584     /* Determine the GLSL function to use based on the opcode */
2585     /* TODO: Possibly make this a table for faster lookups */
2586     switch (ins->handler_idx)
2587     {
2588         case WINED3DSIH_MIN: instruction = "min"; break;
2589         case WINED3DSIH_MAX: instruction = "max"; break;
2590         case WINED3DSIH_ABS: instruction = "abs"; break;
2591         case WINED3DSIH_FRC: instruction = "fract"; break;
2592         case WINED3DSIH_EXP: instruction = "exp2"; break;
2593         case WINED3DSIH_DSX: instruction = "dFdx"; break;
2594         case WINED3DSIH_DSY: instruction = "ycorrection.y * dFdy"; break;
2595         case WINED3DSIH_ROUND_NI: instruction = "floor"; break;
2596         default: instruction = "";
2597             FIXME("Opcode %#x not yet handled in GLSL\n", ins->handler_idx);
2598             break;
2599     }
2600
2601     write_mask = shader_glsl_append_dst(buffer, ins);
2602
2603     shader_addline(buffer, "%s(", instruction);
2604
2605     if (ins->src_count)
2606     {
2607         shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param);
2608         shader_addline(buffer, "%s", src_param.param_str);
2609         for (i = 1; i < ins->src_count; ++i)
2610         {
2611             shader_glsl_add_src_param(ins, &ins->src[i], write_mask, &src_param);
2612             shader_addline(buffer, ", %s", src_param.param_str);
2613         }
2614     }
2615
2616     shader_addline(buffer, "));\n");
2617 }
2618
2619 static void shader_glsl_nop(const struct wined3d_shader_instruction *ins) {}
2620
2621 static void shader_glsl_nrm(const struct wined3d_shader_instruction *ins)
2622 {
2623     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2624     struct glsl_src_param src_param;
2625     unsigned int mask_size;
2626     DWORD write_mask;
2627     char dst_mask[6];
2628
2629     write_mask = shader_glsl_get_write_mask(ins->dst, dst_mask);
2630     mask_size = shader_glsl_get_write_mask_size(write_mask);
2631     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param);
2632
2633     shader_addline(buffer, "tmp0.x = dot(%s, %s);\n",
2634             src_param.param_str, src_param.param_str);
2635     shader_glsl_append_dst(buffer, ins);
2636
2637     if (mask_size > 1)
2638     {
2639         shader_addline(buffer, "tmp0.x == 0.0 ? vec%u(0.0) : (%s * inversesqrt(tmp0.x)));\n",
2640                 mask_size, src_param.param_str);
2641     }
2642     else
2643     {
2644         shader_addline(buffer, "tmp0.x == 0.0 ? 0.0 : (%s * inversesqrt(tmp0.x)));\n",
2645                 src_param.param_str);
2646     }
2647 }
2648
2649 /** Process the WINED3DSIO_EXPP instruction in GLSL:
2650  * For shader model 1.x, do the following (and honor the writemask, so use a temporary variable):
2651  *   dst.x = 2^(floor(src))
2652  *   dst.y = src - floor(src)
2653  *   dst.z = 2^src   (partial precision is allowed, but optional)
2654  *   dst.w = 1.0;
2655  * For 2.0 shaders, just do this (honoring writemask and swizzle):
2656  *   dst = 2^src;    (partial precision is allowed, but optional)
2657  */
2658 static void shader_glsl_expp(const struct wined3d_shader_instruction *ins)
2659 {
2660     struct glsl_src_param src_param;
2661
2662     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src_param);
2663
2664     if (ins->ctx->reg_maps->shader_version.major < 2)
2665     {
2666         char dst_mask[6];
2667
2668         shader_addline(ins->ctx->buffer, "tmp0.x = exp2(floor(%s));\n", src_param.param_str);
2669         shader_addline(ins->ctx->buffer, "tmp0.y = %s - floor(%s);\n", src_param.param_str, src_param.param_str);
2670         shader_addline(ins->ctx->buffer, "tmp0.z = exp2(%s);\n", src_param.param_str);
2671         shader_addline(ins->ctx->buffer, "tmp0.w = 1.0;\n");
2672
2673         shader_glsl_append_dst(ins->ctx->buffer, ins);
2674         shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
2675         shader_addline(ins->ctx->buffer, "tmp0%s);\n", dst_mask);
2676     } else {
2677         DWORD write_mask;
2678         unsigned int mask_size;
2679
2680         write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
2681         mask_size = shader_glsl_get_write_mask_size(write_mask);
2682
2683         if (mask_size > 1) {
2684             shader_addline(ins->ctx->buffer, "vec%d(exp2(%s)));\n", mask_size, src_param.param_str);
2685         } else {
2686             shader_addline(ins->ctx->buffer, "exp2(%s));\n", src_param.param_str);
2687         }
2688     }
2689 }
2690
2691 static void shader_glsl_to_int(const struct wined3d_shader_instruction *ins)
2692 {
2693     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2694     struct glsl_src_param src_param;
2695     unsigned int mask_size;
2696     DWORD write_mask;
2697
2698     write_mask = shader_glsl_append_dst(buffer, ins);
2699     mask_size = shader_glsl_get_write_mask_size(write_mask);
2700     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param);
2701
2702     if (mask_size > 1)
2703         shader_addline(buffer, "ivec%u(%s));\n", mask_size, src_param.param_str);
2704     else
2705         shader_addline(buffer, "int(%s));\n", src_param.param_str);
2706 }
2707
2708 static void shader_glsl_to_float(const struct wined3d_shader_instruction *ins)
2709 {
2710     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2711     struct glsl_src_param src_param;
2712     unsigned int mask_size;
2713     DWORD write_mask;
2714
2715     write_mask = shader_glsl_append_dst(buffer, ins);
2716     mask_size = shader_glsl_get_write_mask_size(write_mask);
2717     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param);
2718
2719     if (mask_size > 1)
2720         shader_addline(buffer, "vec%u(%s));\n", mask_size, src_param.param_str);
2721     else
2722         shader_addline(buffer, "float(%s));\n", src_param.param_str);
2723 }
2724
2725 /** Process the RCP (reciprocal or inverse) opcode in GLSL (dst = 1 / src) */
2726 static void shader_glsl_rcp(const struct wined3d_shader_instruction *ins)
2727 {
2728     struct glsl_src_param src_param;
2729     DWORD write_mask;
2730     unsigned int mask_size;
2731
2732     write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
2733     mask_size = shader_glsl_get_write_mask_size(write_mask);
2734     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &src_param);
2735
2736     if (mask_size > 1)
2737     {
2738         shader_addline(ins->ctx->buffer, "vec%u(1.0 / %s));\n",
2739                 mask_size, src_param.param_str);
2740     }
2741     else
2742     {
2743         shader_addline(ins->ctx->buffer, "1.0 / %s);\n",
2744                 src_param.param_str);
2745     }
2746 }
2747
2748 static void shader_glsl_rsq(const struct wined3d_shader_instruction *ins)
2749 {
2750     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
2751     struct glsl_src_param src_param;
2752     DWORD write_mask;
2753     unsigned int mask_size;
2754
2755     write_mask = shader_glsl_append_dst(buffer, ins);
2756     mask_size = shader_glsl_get_write_mask_size(write_mask);
2757
2758     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &src_param);
2759
2760     if (mask_size > 1)
2761     {
2762         shader_addline(buffer, "vec%u(inversesqrt(abs(%s))));\n",
2763                 mask_size, src_param.param_str);
2764     }
2765     else
2766     {
2767         shader_addline(buffer, "inversesqrt(abs(%s)));\n",
2768                 src_param.param_str);
2769     }
2770 }
2771
2772 /** Process signed comparison opcodes in GLSL. */
2773 static void shader_glsl_compare(const struct wined3d_shader_instruction *ins)
2774 {
2775     struct glsl_src_param src0_param;
2776     struct glsl_src_param src1_param;
2777     DWORD write_mask;
2778     unsigned int mask_size;
2779
2780     write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
2781     mask_size = shader_glsl_get_write_mask_size(write_mask);
2782     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2783     shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2784
2785     if (mask_size > 1) {
2786         const char *compare;
2787
2788         switch(ins->handler_idx)
2789         {
2790             case WINED3DSIH_SLT: compare = "lessThan"; break;
2791             case WINED3DSIH_SGE: compare = "greaterThanEqual"; break;
2792             default: compare = "";
2793                 FIXME("Can't handle opcode %#x\n", ins->handler_idx);
2794         }
2795
2796         shader_addline(ins->ctx->buffer, "vec%d(%s(%s, %s)));\n", mask_size, compare,
2797                 src0_param.param_str, src1_param.param_str);
2798     } else {
2799         switch(ins->handler_idx)
2800         {
2801             case WINED3DSIH_SLT:
2802                 /* Step(src0, src1) is not suitable here because if src0 == src1 SLT is supposed,
2803                  * to return 0.0 but step returns 1.0 because step is not < x
2804                  * An alternative is a bvec compare padded with an unused second component.
2805                  * step(src1 * -1.0, src0 * -1.0) is not an option because it suffers from the same
2806                  * issue. Playing with not() is not possible either because not() does not accept
2807                  * a scalar.
2808                  */
2809                 shader_addline(ins->ctx->buffer, "(%s < %s) ? 1.0 : 0.0);\n",
2810                         src0_param.param_str, src1_param.param_str);
2811                 break;
2812             case WINED3DSIH_SGE:
2813                 /* Here we can use the step() function and safe a conditional */
2814                 shader_addline(ins->ctx->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
2815                 break;
2816             default:
2817                 FIXME("Can't handle opcode %#x\n", ins->handler_idx);
2818         }
2819
2820     }
2821 }
2822
2823 static void shader_glsl_conditional_move(const struct wined3d_shader_instruction *ins)
2824 {
2825     const char *condition_prefix, *condition_suffix;
2826     struct wined3d_shader_dst_param dst;
2827     struct glsl_src_param src0_param;
2828     struct glsl_src_param src1_param;
2829     struct glsl_src_param src2_param;
2830     BOOL temp_destination = FALSE;
2831     DWORD cmp_channel = 0;
2832     unsigned int i, j;
2833     char mask_char[6];
2834     DWORD write_mask;
2835
2836     switch (ins->handler_idx)
2837     {
2838         case WINED3DSIH_CMP:
2839             condition_prefix = "";
2840             condition_suffix = " >= 0.0";
2841             break;
2842
2843         case WINED3DSIH_CND:
2844             condition_prefix = "";
2845             condition_suffix = " > 0.5";
2846             break;
2847
2848         case WINED3DSIH_MOVC:
2849             condition_prefix = "bool(";
2850             condition_suffix = ")";
2851             break;
2852
2853         default:
2854             FIXME("Unhandled instruction %#x.\n", ins->handler_idx);
2855             condition_prefix = "<unhandled prefix>";
2856             condition_suffix = "<unhandled suffix>";
2857             break;
2858     }
2859
2860     if (shader_is_scalar(&ins->dst[0].reg) || shader_is_scalar(&ins->src[0].reg))
2861     {
2862         write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
2863         shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2864         shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2865         shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
2866
2867         shader_addline(ins->ctx->buffer, "%s%s%s ? %s : %s);\n",
2868                 condition_prefix, src0_param.param_str, condition_suffix,
2869                 src1_param.param_str, src2_param.param_str);
2870         return;
2871     }
2872
2873     dst = ins->dst[0];
2874
2875     /* Splitting the instruction up in multiple lines imposes a problem:
2876      * The first lines may overwrite source parameters of the following lines.
2877      * Deal with that by using a temporary destination register if needed. */
2878     if ((ins->src[0].reg.idx[0].offset == dst.reg.idx[0].offset
2879                 && ins->src[0].reg.type == dst.reg.type)
2880             || (ins->src[1].reg.idx[0].offset == dst.reg.idx[0].offset
2881                 && ins->src[1].reg.type == dst.reg.type)
2882             || (ins->src[2].reg.idx[0].offset == dst.reg.idx[0].offset
2883                 && ins->src[2].reg.type == dst.reg.type))
2884         temp_destination = TRUE;
2885
2886     /* Cycle through all source0 channels. */
2887     for (i = 0; i < 4; ++i)
2888     {
2889         write_mask = 0;
2890         /* Find the destination channels which use the current source0 channel. */
2891         for (j = 0; j < 4; ++j)
2892         {
2893             if (((ins->src[0].swizzle >> (2 * j)) & 0x3) == i)
2894             {
2895                 write_mask |= WINED3DSP_WRITEMASK_0 << j;
2896                 cmp_channel = WINED3DSP_WRITEMASK_0 << j;
2897             }
2898         }
2899         dst.write_mask = ins->dst[0].write_mask & write_mask;
2900
2901         if (temp_destination)
2902         {
2903             if (!(write_mask = shader_glsl_get_write_mask(&dst, mask_char)))
2904                 continue;
2905             shader_addline(ins->ctx->buffer, "tmp0%s = (", mask_char);
2906         }
2907         else if (!(write_mask = shader_glsl_append_dst_ext(ins->ctx->buffer, ins, &dst)))
2908             continue;
2909
2910         shader_glsl_add_src_param(ins, &ins->src[0], cmp_channel, &src0_param);
2911         shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2912         shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
2913
2914         shader_addline(ins->ctx->buffer, "%s%s%s ? %s : %s);\n",
2915                 condition_prefix, src0_param.param_str, condition_suffix,
2916                 src1_param.param_str, src2_param.param_str);
2917     }
2918
2919     if (temp_destination)
2920     {
2921         shader_glsl_get_write_mask(&ins->dst[0], mask_char);
2922         shader_glsl_append_dst(ins->ctx->buffer, ins);
2923         shader_addline(ins->ctx->buffer, "tmp0%s);\n", mask_char);
2924     }
2925 }
2926
2927 /** Process the CND opcode in GLSL (dst = (src0 > 0.5) ? src1 : src2) */
2928 /* For ps 1.1-1.3, only a single component of src0 is used. For ps 1.4
2929  * the compare is done per component of src0. */
2930 static void shader_glsl_cnd(const struct wined3d_shader_instruction *ins)
2931 {
2932     struct glsl_src_param src0_param;
2933     struct glsl_src_param src1_param;
2934     struct glsl_src_param src2_param;
2935     DWORD write_mask;
2936     DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
2937             ins->ctx->reg_maps->shader_version.minor);
2938
2939     if (shader_version < WINED3D_SHADER_VERSION(1, 4))
2940     {
2941         write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
2942         shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
2943         shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2944         shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
2945
2946         /* Fun: The D3DSI_COISSUE flag changes the semantic of the cnd instruction for < 1.4 shaders */
2947         if (ins->coissue)
2948         {
2949             shader_addline(ins->ctx->buffer, "%s /* COISSUE! */);\n", src1_param.param_str);
2950         } else {
2951             shader_addline(ins->ctx->buffer, "%s > 0.5 ? %s : %s);\n",
2952                     src0_param.param_str, src1_param.param_str, src2_param.param_str);
2953         }
2954         return;
2955     }
2956
2957     shader_glsl_conditional_move(ins);
2958 }
2959
2960 /** GLSL code generation for WINED3DSIO_MAD: Multiply the first 2 opcodes, then add the last */
2961 static void shader_glsl_mad(const struct wined3d_shader_instruction *ins)
2962 {
2963     struct glsl_src_param src0_param;
2964     struct glsl_src_param src1_param;
2965     struct glsl_src_param src2_param;
2966     DWORD write_mask;
2967
2968     write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
2969     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
2970     shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
2971     shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
2972     shader_addline(ins->ctx->buffer, "(%s * %s) + %s);\n",
2973             src0_param.param_str, src1_param.param_str, src2_param.param_str);
2974 }
2975
2976 /* Handles transforming all WINED3DSIO_M?x? opcodes for
2977    Vertex shaders to GLSL codes */
2978 static void shader_glsl_mnxn(const struct wined3d_shader_instruction *ins)
2979 {
2980     int i;
2981     int nComponents = 0;
2982     struct wined3d_shader_dst_param tmp_dst = {{0}};
2983     struct wined3d_shader_src_param tmp_src[2] = {{{0}}};
2984     struct wined3d_shader_instruction tmp_ins;
2985
2986     memset(&tmp_ins, 0, sizeof(tmp_ins));
2987
2988     /* Set constants for the temporary argument */
2989     tmp_ins.ctx = ins->ctx;
2990     tmp_ins.dst_count = 1;
2991     tmp_ins.dst = &tmp_dst;
2992     tmp_ins.src_count = 2;
2993     tmp_ins.src = tmp_src;
2994
2995     switch(ins->handler_idx)
2996     {
2997         case WINED3DSIH_M4x4:
2998             nComponents = 4;
2999             tmp_ins.handler_idx = WINED3DSIH_DP4;
3000             break;
3001         case WINED3DSIH_M4x3:
3002             nComponents = 3;
3003             tmp_ins.handler_idx = WINED3DSIH_DP4;
3004             break;
3005         case WINED3DSIH_M3x4:
3006             nComponents = 4;
3007             tmp_ins.handler_idx = WINED3DSIH_DP3;
3008             break;
3009         case WINED3DSIH_M3x3:
3010             nComponents = 3;
3011             tmp_ins.handler_idx = WINED3DSIH_DP3;
3012             break;
3013         case WINED3DSIH_M3x2:
3014             nComponents = 2;
3015             tmp_ins.handler_idx = WINED3DSIH_DP3;
3016             break;
3017         default:
3018             break;
3019     }
3020
3021     tmp_dst = ins->dst[0];
3022     tmp_src[0] = ins->src[0];
3023     tmp_src[1] = ins->src[1];
3024     for (i = 0; i < nComponents; ++i)
3025     {
3026         tmp_dst.write_mask = WINED3DSP_WRITEMASK_0 << i;
3027         shader_glsl_dot(&tmp_ins);
3028         ++tmp_src[1].reg.idx[0].offset;
3029     }
3030 }
3031
3032 /**
3033     The LRP instruction performs a component-wise linear interpolation
3034     between the second and third operands using the first operand as the
3035     blend factor.  Equation:  (dst = src2 + src0 * (src1 - src2))
3036     This is equivalent to mix(src2, src1, src0);
3037 */
3038 static void shader_glsl_lrp(const struct wined3d_shader_instruction *ins)
3039 {
3040     struct glsl_src_param src0_param;
3041     struct glsl_src_param src1_param;
3042     struct glsl_src_param src2_param;
3043     DWORD write_mask;
3044
3045     write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3046
3047     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3048     shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3049     shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
3050
3051     shader_addline(ins->ctx->buffer, "mix(%s, %s, %s));\n",
3052             src2_param.param_str, src1_param.param_str, src0_param.param_str);
3053 }
3054
3055 /** Process the WINED3DSIO_LIT instruction in GLSL:
3056  * dst.x = dst.w = 1.0
3057  * dst.y = (src0.x > 0) ? src0.x
3058  * dst.z = (src0.x > 0) ? ((src0.y > 0) ? pow(src0.y, src.w) : 0) : 0
3059  *                                        where src.w is clamped at +- 128
3060  */
3061 static void shader_glsl_lit(const struct wined3d_shader_instruction *ins)
3062 {
3063     struct glsl_src_param src0_param;
3064     struct glsl_src_param src1_param;
3065     struct glsl_src_param src3_param;
3066     char dst_mask[6];
3067
3068     shader_glsl_append_dst(ins->ctx->buffer, ins);
3069     shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3070
3071     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3072     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_1, &src1_param);
3073     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &src3_param);
3074
3075     /* The sdk specifies the instruction like this
3076      * dst.x = 1.0;
3077      * if(src.x > 0.0) dst.y = src.x
3078      * else dst.y = 0.0.
3079      * if(src.x > 0.0 && src.y > 0.0) dst.z = pow(src.y, power);
3080      * else dst.z = 0.0;
3081      * dst.w = 1.0;
3082      * (where power = src.w clamped between -128 and 128)
3083      *
3084      * Obviously that has quite a few conditionals in it which we don't like. So the first step is this:
3085      * dst.x = 1.0                                  ... No further explanation needed
3086      * dst.y = max(src.y, 0.0);                     ... If x < 0.0, use 0.0, otherwise x. Same as the conditional
3087      * dst.z = x > 0.0 ? pow(max(y, 0.0), p) : 0;   ... 0 ^ power is 0, and otherwise we use y anyway
3088      * dst.w = 1.0.                                 ... Nothing fancy.
3089      *
3090      * So we still have one conditional in there. So do this:
3091      * dst.z = pow(max(0.0, src.y) * step(0.0, src.x), power);
3092      *
3093      * 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),
3094      * 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.
3095      * if both x and y are > 0, we get pow(y * 1.0, power), as it is supposed to.
3096      *
3097      * Unfortunately pow(0.0 ^ 0.0) returns NaN on most GPUs, but lit with src.y = 0 and src.w = 0 returns
3098      * a non-NaN value in dst.z. What we return doesn't matter, as long as it is not NaN. Return 0, which is
3099      * what all Windows HW drivers and GL_ARB_vertex_program's LIT do.
3100      */
3101     shader_addline(ins->ctx->buffer,
3102             "vec4(1.0, max(%s, 0.0), %s == 0.0 ? 0.0 : "
3103             "pow(max(0.0, %s) * step(0.0, %s), clamp(%s, -128.0, 128.0)), 1.0)%s);\n",
3104             src0_param.param_str, src3_param.param_str, src1_param.param_str,
3105             src0_param.param_str, src3_param.param_str, dst_mask);
3106 }
3107
3108 /** Process the WINED3DSIO_DST instruction in GLSL:
3109  * dst.x = 1.0
3110  * dst.y = src0.x * src0.y
3111  * dst.z = src0.z
3112  * dst.w = src1.w
3113  */
3114 static void shader_glsl_dst(const struct wined3d_shader_instruction *ins)
3115 {
3116     struct glsl_src_param src0y_param;
3117     struct glsl_src_param src0z_param;
3118     struct glsl_src_param src1y_param;
3119     struct glsl_src_param src1w_param;
3120     char dst_mask[6];
3121
3122     shader_glsl_append_dst(ins->ctx->buffer, ins);
3123     shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3124
3125     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_1, &src0y_param);
3126     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_2, &src0z_param);
3127     shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_1, &src1y_param);
3128     shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_3, &src1w_param);
3129
3130     shader_addline(ins->ctx->buffer, "vec4(1.0, %s * %s, %s, %s))%s;\n",
3131             src0y_param.param_str, src1y_param.param_str, src0z_param.param_str, src1w_param.param_str, dst_mask);
3132 }
3133
3134 /** Process the WINED3DSIO_SINCOS instruction in GLSL:
3135  * VS 2.0 requires that specific cosine and sine constants be passed to this instruction so the hardware
3136  * can handle it.  But, these functions are built-in for GLSL, so we can just ignore the last 2 params.
3137  *
3138  * dst.x = cos(src0.?)
3139  * dst.y = sin(src0.?)
3140  * dst.z = dst.z
3141  * dst.w = dst.w
3142  */
3143 static void shader_glsl_sincos(const struct wined3d_shader_instruction *ins)
3144 {
3145     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3146     struct glsl_src_param src0_param;
3147     DWORD write_mask;
3148
3149     if (ins->ctx->reg_maps->shader_version.major < 4)
3150     {
3151         shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3152
3153         write_mask = shader_glsl_append_dst(buffer, ins);
3154         switch (write_mask)
3155         {
3156             case WINED3DSP_WRITEMASK_0:
3157                 shader_addline(buffer, "cos(%s));\n", src0_param.param_str);
3158                 break;
3159
3160             case WINED3DSP_WRITEMASK_1:
3161                 shader_addline(buffer, "sin(%s));\n", src0_param.param_str);
3162                 break;
3163
3164             case (WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1):
3165                 shader_addline(buffer, "vec2(cos(%s), sin(%s)));\n",
3166                         src0_param.param_str, src0_param.param_str);
3167                 break;
3168
3169             default:
3170                 ERR("Write mask should be .x, .y or .xy\n");
3171                 break;
3172         }
3173
3174         return;
3175     }
3176
3177     if (ins->dst[0].reg.type != WINED3DSPR_NULL)
3178     {
3179
3180         if (ins->dst[1].reg.type != WINED3DSPR_NULL)
3181         {
3182             char dst_mask[6];
3183
3184             write_mask = shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3185             shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3186             shader_addline(buffer, "tmp0%s = sin(%s);\n", dst_mask, src0_param.param_str);
3187
3188             write_mask = shader_glsl_append_dst_ext(buffer, ins, &ins->dst[1]);
3189             shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3190             shader_addline(buffer, "cos(%s));\n", src0_param.param_str);
3191
3192             shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0]);
3193             shader_addline(buffer, "tmp0%s);\n", dst_mask);
3194         }
3195         else
3196         {
3197             write_mask = shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0]);
3198             shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3199             shader_addline(buffer, "sin(%s));\n", src0_param.param_str);
3200         }
3201     }
3202     else if (ins->dst[1].reg.type != WINED3DSPR_NULL)
3203     {
3204         write_mask = shader_glsl_append_dst_ext(buffer, ins, &ins->dst[1]);
3205         shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3206         shader_addline(buffer, "cos(%s));\n", src0_param.param_str);
3207     }
3208 }
3209
3210 /* sgn in vs_2_0 has 2 extra parameters(registers for temporary storage) which we don't use
3211  * here. But those extra parameters require a dedicated function for sgn, since map2gl would
3212  * generate invalid code
3213  */
3214 static void shader_glsl_sgn(const struct wined3d_shader_instruction *ins)
3215 {
3216     struct glsl_src_param src0_param;
3217     DWORD write_mask;
3218
3219     write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3220     shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3221
3222     shader_addline(ins->ctx->buffer, "sign(%s));\n", src0_param.param_str);
3223 }
3224
3225 /** Process the WINED3DSIO_LOOP instruction in GLSL:
3226  * Start a for() loop where src1.y is the initial value of aL,
3227  *  increment aL by src1.z for a total of src1.x iterations.
3228  *  Need to use a temporary variable for this operation.
3229  */
3230 /* FIXME: I don't think nested loops will work correctly this way. */
3231 static void shader_glsl_loop(const struct wined3d_shader_instruction *ins)
3232 {
3233     struct wined3d_shader_loop_state *loop_state = ins->ctx->loop_state;
3234     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3235     const struct wined3d_shader *shader = ins->ctx->shader;
3236     const struct wined3d_shader_lconst *constant;
3237     struct glsl_src_param src1_param;
3238     const DWORD *control_values = NULL;
3239
3240     if (ins->ctx->reg_maps->shader_version.major < 4)
3241     {
3242         shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_ALL, &src1_param);
3243
3244         /* Try to hardcode the loop control parameters if possible. Direct3D 9
3245          * class hardware doesn't support real varying indexing, but Microsoft
3246          * designed this feature for Shader model 2.x+. If the loop control is
3247          * known at compile time, the GLSL compiler can unroll the loop, and
3248          * replace indirect addressing with direct addressing. */
3249         if (ins->src[1].reg.type == WINED3DSPR_CONSTINT)
3250         {
3251             LIST_FOR_EACH_ENTRY(constant, &shader->constantsI, struct wined3d_shader_lconst, entry)
3252             {
3253                 if (constant->idx == ins->src[1].reg.idx[0].offset)
3254                 {
3255                     control_values = constant->value;
3256                     break;
3257                 }
3258             }
3259         }
3260
3261         if (control_values)
3262         {
3263             struct wined3d_shader_loop_control loop_control;
3264             loop_control.count = control_values[0];
3265             loop_control.start = control_values[1];
3266             loop_control.step = (int)control_values[2];
3267
3268             if (loop_control.step > 0)
3269             {
3270                 shader_addline(buffer, "for (aL%u = %u; aL%u < (%u * %d + %u); aL%u += %d)\n{\n",
3271                         loop_state->current_depth, loop_control.start,
3272                         loop_state->current_depth, loop_control.count, loop_control.step, loop_control.start,
3273                         loop_state->current_depth, loop_control.step);
3274             }
3275             else if (loop_control.step < 0)
3276             {
3277                 shader_addline(buffer, "for (aL%u = %u; aL%u > (%u * %d + %u); aL%u += %d)\n{\n",
3278                         loop_state->current_depth, loop_control.start,
3279                         loop_state->current_depth, loop_control.count, loop_control.step, loop_control.start,
3280                         loop_state->current_depth, loop_control.step);
3281             }
3282             else
3283             {
3284                 shader_addline(buffer, "for (aL%u = %u, tmpInt%u = 0; tmpInt%u < %u; tmpInt%u++)\n{\n",
3285                         loop_state->current_depth, loop_control.start, loop_state->current_depth,
3286                         loop_state->current_depth, loop_control.count,
3287                         loop_state->current_depth);
3288             }
3289         }
3290         else
3291         {
3292             shader_addline(buffer, "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z)\n{\n",
3293                     loop_state->current_depth, loop_state->current_reg,
3294                     src1_param.reg_name, loop_state->current_depth, src1_param.reg_name,
3295                     loop_state->current_depth, loop_state->current_reg, src1_param.reg_name);
3296         }
3297
3298         ++loop_state->current_reg;
3299     }
3300     else
3301     {
3302         shader_addline(buffer, "for (;;)\n{\n");
3303     }
3304
3305     ++loop_state->current_depth;
3306 }
3307
3308 static void shader_glsl_end(const struct wined3d_shader_instruction *ins)
3309 {
3310     struct wined3d_shader_loop_state *loop_state = ins->ctx->loop_state;
3311
3312     shader_addline(ins->ctx->buffer, "}\n");
3313
3314     if (ins->handler_idx == WINED3DSIH_ENDLOOP)
3315     {
3316         --loop_state->current_depth;
3317         --loop_state->current_reg;
3318     }
3319
3320     if (ins->handler_idx == WINED3DSIH_ENDREP)
3321     {
3322         --loop_state->current_depth;
3323     }
3324 }
3325
3326 static void shader_glsl_rep(const struct wined3d_shader_instruction *ins)
3327 {
3328     const struct wined3d_shader *shader = ins->ctx->shader;
3329     struct wined3d_shader_loop_state *loop_state = ins->ctx->loop_state;
3330     const struct wined3d_shader_lconst *constant;
3331     struct glsl_src_param src0_param;
3332     const DWORD *control_values = NULL;
3333
3334     /* Try to hardcode local values to help the GLSL compiler to unroll and optimize the loop */
3335     if (ins->src[0].reg.type == WINED3DSPR_CONSTINT)
3336     {
3337         LIST_FOR_EACH_ENTRY(constant, &shader->constantsI, struct wined3d_shader_lconst, entry)
3338         {
3339             if (constant->idx == ins->src[0].reg.idx[0].offset)
3340             {
3341                 control_values = constant->value;
3342                 break;
3343             }
3344         }
3345     }
3346
3347     if (control_values)
3348     {
3349         shader_addline(ins->ctx->buffer, "for (tmpInt%d = 0; tmpInt%d < %d; tmpInt%d++) {\n",
3350                 loop_state->current_depth, loop_state->current_depth,
3351                 control_values[0], loop_state->current_depth);
3352     }
3353     else
3354     {
3355         shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3356         shader_addline(ins->ctx->buffer, "for (tmpInt%d = 0; tmpInt%d < %s; tmpInt%d++) {\n",
3357                 loop_state->current_depth, loop_state->current_depth,
3358                 src0_param.param_str, loop_state->current_depth);
3359     }
3360
3361     ++loop_state->current_depth;
3362 }
3363
3364 static void shader_glsl_if(const struct wined3d_shader_instruction *ins)
3365 {
3366     struct glsl_src_param src0_param;
3367
3368     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3369     shader_addline(ins->ctx->buffer, "if (%s) {\n", src0_param.param_str);
3370 }
3371
3372 static void shader_glsl_ifc(const struct wined3d_shader_instruction *ins)
3373 {
3374     struct glsl_src_param src0_param;
3375     struct glsl_src_param src1_param;
3376
3377     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3378     shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0, &src1_param);
3379
3380     shader_addline(ins->ctx->buffer, "if (%s %s %s) {\n",
3381             src0_param.param_str, shader_glsl_get_rel_op(ins->flags), src1_param.param_str);
3382 }
3383
3384 static void shader_glsl_else(const struct wined3d_shader_instruction *ins)
3385 {
3386     shader_addline(ins->ctx->buffer, "} else {\n");
3387 }
3388
3389 static void shader_glsl_emit(const struct wined3d_shader_instruction *ins)
3390 {
3391     shader_addline(ins->ctx->buffer, "EmitVertex();\n");
3392 }
3393
3394 static void shader_glsl_break(const struct wined3d_shader_instruction *ins)
3395 {
3396     shader_addline(ins->ctx->buffer, "break;\n");
3397 }
3398
3399 /* FIXME: According to MSDN the compare is done per component. */
3400 static void shader_glsl_breakc(const struct wined3d_shader_instruction *ins)
3401 {
3402     struct glsl_src_param src0_param;
3403     struct glsl_src_param src1_param;
3404
3405     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3406     shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0, &src1_param);
3407
3408     shader_addline(ins->ctx->buffer, "if (%s %s %s) break;\n",
3409             src0_param.param_str, shader_glsl_get_rel_op(ins->flags), src1_param.param_str);
3410 }
3411
3412 static void shader_glsl_breakp(const struct wined3d_shader_instruction *ins)
3413 {
3414     struct glsl_src_param src_param;
3415
3416     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src_param);
3417     shader_addline(ins->ctx->buffer, "if (bool(%s)) break;\n", src_param.param_str);
3418 }
3419
3420 static void shader_glsl_label(const struct wined3d_shader_instruction *ins)
3421 {
3422     shader_addline(ins->ctx->buffer, "}\n");
3423     shader_addline(ins->ctx->buffer, "void subroutine%u()\n{\n", ins->src[0].reg.idx[0].offset);
3424 }
3425
3426 static void shader_glsl_call(const struct wined3d_shader_instruction *ins)
3427 {
3428     shader_addline(ins->ctx->buffer, "subroutine%u();\n", ins->src[0].reg.idx[0].offset);
3429 }
3430
3431 static void shader_glsl_callnz(const struct wined3d_shader_instruction *ins)
3432 {
3433     struct glsl_src_param src1_param;
3434
3435     shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0, &src1_param);
3436     shader_addline(ins->ctx->buffer, "if (%s) subroutine%u();\n",
3437             src1_param.param_str, ins->src[0].reg.idx[0].offset);
3438 }
3439
3440 static void shader_glsl_ret(const struct wined3d_shader_instruction *ins)
3441 {
3442     /* No-op. The closing } is written when a new function is started, and at the end of the shader. This
3443      * function only suppresses the unhandled instruction warning
3444      */
3445 }
3446
3447 /*********************************************
3448  * Pixel Shader Specific Code begins here
3449  ********************************************/
3450 static void shader_glsl_tex(const struct wined3d_shader_instruction *ins)
3451 {
3452     DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
3453             ins->ctx->reg_maps->shader_version.minor);
3454     struct glsl_sample_function sample_function;
3455     DWORD sample_flags = 0;
3456     DWORD sampler_idx;
3457     DWORD mask = 0, swizzle;
3458     const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3459
3460     /* 1.0-1.4: Use destination register as sampler source.
3461      * 2.0+: Use provided sampler source. */
3462     if (shader_version < WINED3D_SHADER_VERSION(2,0))
3463         sampler_idx = ins->dst[0].reg.idx[0].offset;
3464     else
3465         sampler_idx = ins->src[1].reg.idx[0].offset;
3466
3467     if (shader_version < WINED3D_SHADER_VERSION(1,4))
3468     {
3469         DWORD flags = (priv->cur_ps_args->tex_transform >> sampler_idx * WINED3D_PSARGS_TEXTRANSFORM_SHIFT)
3470                 & WINED3D_PSARGS_TEXTRANSFORM_MASK;
3471         enum wined3d_sampler_texture_type sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3472
3473         /* Projected cube textures don't make a lot of sense, the resulting coordinates stay the same. */
3474         if (flags & WINED3D_PSARGS_PROJECTED && sampler_type != WINED3DSTT_CUBE)
3475         {
3476             sample_flags |= WINED3D_GLSL_SAMPLE_PROJECTED;
3477             switch (flags & ~WINED3D_PSARGS_PROJECTED)
3478             {
3479                 case WINED3D_TTFF_COUNT1:
3480                     FIXME("WINED3D_TTFF_PROJECTED with WINED3D_TTFF_COUNT1?\n");
3481                     break;
3482                 case WINED3D_TTFF_COUNT2:
3483                     mask = WINED3DSP_WRITEMASK_1;
3484                     break;
3485                 case WINED3D_TTFF_COUNT3:
3486                     mask = WINED3DSP_WRITEMASK_2;
3487                     break;
3488                 case WINED3D_TTFF_COUNT4:
3489                 case WINED3D_TTFF_DISABLE:
3490                     mask = WINED3DSP_WRITEMASK_3;
3491                     break;
3492             }
3493         }
3494     }
3495     else if (shader_version < WINED3D_SHADER_VERSION(2,0))
3496     {
3497         enum wined3d_shader_src_modifier src_mod = ins->src[0].modifiers;
3498
3499         if (src_mod == WINED3DSPSM_DZ) {
3500             sample_flags |= WINED3D_GLSL_SAMPLE_PROJECTED;
3501             mask = WINED3DSP_WRITEMASK_2;
3502         } else if (src_mod == WINED3DSPSM_DW) {
3503             sample_flags |= WINED3D_GLSL_SAMPLE_PROJECTED;
3504             mask = WINED3DSP_WRITEMASK_3;
3505         }
3506     } else {
3507         if (ins->flags & WINED3DSI_TEXLD_PROJECT)
3508         {
3509             /* ps 2.0 texldp instruction always divides by the fourth component. */
3510             sample_flags |= WINED3D_GLSL_SAMPLE_PROJECTED;
3511             mask = WINED3DSP_WRITEMASK_3;
3512         }
3513     }
3514
3515     if (priv->cur_ps_args->np2_fixup & (1 << sampler_idx))
3516         sample_flags |= WINED3D_GLSL_SAMPLE_NPOT;
3517
3518     shader_glsl_get_sample_function(ins->ctx, sampler_idx, sample_flags, &sample_function);
3519     mask |= sample_function.coord_mask;
3520
3521     if (shader_version < WINED3D_SHADER_VERSION(2,0)) swizzle = WINED3DSP_NOSWIZZLE;
3522     else swizzle = ins->src[1].swizzle;
3523
3524     /* 1.0-1.3: Use destination register as coordinate source.
3525        1.4+: Use provided coordinate source register. */
3526     if (shader_version < WINED3D_SHADER_VERSION(1,4))
3527     {
3528         char coord_mask[6];
3529         shader_glsl_write_mask_to_str(mask, coord_mask);
3530         shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL, NULL, NULL,
3531                 "T%u%s", sampler_idx, coord_mask);
3532     }
3533     else
3534     {
3535         struct glsl_src_param coord_param;
3536         shader_glsl_add_src_param(ins, &ins->src[0], mask, &coord_param);
3537         if (ins->flags & WINED3DSI_TEXLD_BIAS)
3538         {
3539             struct glsl_src_param bias;
3540             shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &bias);
3541             shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL, NULL, bias.param_str,
3542                     "%s", coord_param.param_str);
3543         } else {
3544             shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL, NULL, NULL,
3545                     "%s", coord_param.param_str);
3546         }
3547     }
3548 }
3549
3550 static void shader_glsl_texldd(const struct wined3d_shader_instruction *ins)
3551 {
3552     const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3553     struct glsl_src_param coord_param, dx_param, dy_param;
3554     DWORD sample_flags = WINED3D_GLSL_SAMPLE_GRAD;
3555     struct glsl_sample_function sample_function;
3556     DWORD sampler_idx;
3557     DWORD swizzle = ins->src[1].swizzle;
3558     const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3559
3560     if (!gl_info->supported[ARB_SHADER_TEXTURE_LOD] && !gl_info->supported[EXT_GPU_SHADER4])
3561     {
3562         FIXME("texldd used, but not supported by hardware. Falling back to regular tex\n");
3563         shader_glsl_tex(ins);
3564         return;
3565     }
3566
3567     sampler_idx = ins->src[1].reg.idx[0].offset;
3568     if (priv->cur_ps_args->np2_fixup & (1 << sampler_idx))
3569         sample_flags |= WINED3D_GLSL_SAMPLE_NPOT;
3570
3571     shader_glsl_get_sample_function(ins->ctx, sampler_idx, sample_flags, &sample_function);
3572     shader_glsl_add_src_param(ins, &ins->src[0], sample_function.coord_mask, &coord_param);
3573     shader_glsl_add_src_param(ins, &ins->src[2], sample_function.coord_mask, &dx_param);
3574     shader_glsl_add_src_param(ins, &ins->src[3], sample_function.coord_mask, &dy_param);
3575
3576     shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, dx_param.param_str, dy_param.param_str, NULL,
3577                                 "%s", coord_param.param_str);
3578 }
3579
3580 static void shader_glsl_texldl(const struct wined3d_shader_instruction *ins)
3581 {
3582     const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3583     struct glsl_src_param coord_param, lod_param;
3584     DWORD sample_flags = WINED3D_GLSL_SAMPLE_LOD;
3585     struct glsl_sample_function sample_function;
3586     DWORD sampler_idx;
3587     DWORD swizzle = ins->src[1].swizzle;
3588     const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3589
3590     sampler_idx = ins->src[1].reg.idx[0].offset;
3591     if (ins->ctx->reg_maps->shader_version.type == WINED3D_SHADER_TYPE_PIXEL
3592             && priv->cur_ps_args->np2_fixup & (1 << sampler_idx))
3593         sample_flags |= WINED3D_GLSL_SAMPLE_NPOT;
3594
3595     shader_glsl_get_sample_function(ins->ctx, sampler_idx, sample_flags, &sample_function);
3596     shader_glsl_add_src_param(ins, &ins->src[0], sample_function.coord_mask, &coord_param);
3597
3598     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &lod_param);
3599
3600     if (!gl_info->supported[ARB_SHADER_TEXTURE_LOD] && !gl_info->supported[EXT_GPU_SHADER4]
3601             && ins->ctx->reg_maps->shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
3602     {
3603         /* Plain GLSL only supports Lod sampling functions in vertex shaders.
3604          * However, the NVIDIA drivers allow them in fragment shaders as well,
3605          * even without the appropriate extension. */
3606         WARN("Using %s in fragment shader.\n", sample_function.name);
3607     }
3608     shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL, NULL, lod_param.param_str,
3609             "%s", coord_param.param_str);
3610 }
3611
3612 static void shader_glsl_texcoord(const struct wined3d_shader_instruction *ins)
3613 {
3614     /* FIXME: Make this work for more than just 2D textures */
3615     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3616     DWORD write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3617
3618     if (!(ins->ctx->reg_maps->shader_version.major == 1 && ins->ctx->reg_maps->shader_version.minor == 4))
3619     {
3620         char dst_mask[6];
3621
3622         shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3623         shader_addline(buffer, "clamp(gl_TexCoord[%u], 0.0, 1.0)%s);\n",
3624                 ins->dst[0].reg.idx[0].offset, dst_mask);
3625     }
3626     else
3627     {
3628         enum wined3d_shader_src_modifier src_mod = ins->src[0].modifiers;
3629         DWORD reg = ins->src[0].reg.idx[0].offset;
3630         char dst_swizzle[6];
3631
3632         shader_glsl_get_swizzle(&ins->src[0], FALSE, write_mask, dst_swizzle);
3633
3634         if (src_mod == WINED3DSPSM_DZ)
3635         {
3636             unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
3637             struct glsl_src_param div_param;
3638
3639             shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_2, &div_param);
3640
3641             if (mask_size > 1) {
3642                 shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
3643             } else {
3644                 shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
3645             }
3646         }
3647         else if (src_mod == WINED3DSPSM_DW)
3648         {
3649             unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
3650             struct glsl_src_param div_param;
3651
3652             shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &div_param);
3653
3654             if (mask_size > 1) {
3655                 shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
3656             } else {
3657                 shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
3658             }
3659         } else {
3660             shader_addline(buffer, "gl_TexCoord[%u]%s);\n", reg, dst_swizzle);
3661         }
3662     }
3663 }
3664
3665 /** Process the WINED3DSIO_TEXDP3TEX instruction in GLSL:
3666  * Take a 3-component dot product of the TexCoord[dstreg] and src,
3667  * then perform a 1D texture lookup from stage dstregnum, place into dst. */
3668 static void shader_glsl_texdp3tex(const struct wined3d_shader_instruction *ins)
3669 {
3670     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3671     DWORD sampler_idx = ins->dst[0].reg.idx[0].offset;
3672     struct glsl_sample_function sample_function;
3673     struct glsl_src_param src0_param;
3674     UINT mask_size;
3675
3676     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3677
3678     /* Do I have to take care about the projected bit? I don't think so, since the dp3 returns only one
3679      * scalar, and projected sampling would require 4.
3680      *
3681      * It is a dependent read - not valid with conditional NP2 textures
3682      */
3683     shader_glsl_get_sample_function(ins->ctx, sampler_idx, 0, &sample_function);
3684     mask_size = shader_glsl_get_write_mask_size(sample_function.coord_mask);
3685
3686     switch(mask_size)
3687     {
3688         case 1:
3689             shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3690                     "dot(gl_TexCoord[%u].xyz, %s)", sampler_idx, src0_param.param_str);
3691             break;
3692
3693         case 2:
3694             shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3695                     "vec2(dot(gl_TexCoord[%u].xyz, %s), 0.0)", sampler_idx, src0_param.param_str);
3696             break;
3697
3698         case 3:
3699             shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3700                     "vec3(dot(gl_TexCoord[%u].xyz, %s), 0.0, 0.0)", sampler_idx, src0_param.param_str);
3701             break;
3702
3703         default:
3704             FIXME("Unexpected mask size %u\n", mask_size);
3705             break;
3706     }
3707 }
3708
3709 /** Process the WINED3DSIO_TEXDP3 instruction in GLSL:
3710  * Take a 3-component dot product of the TexCoord[dstreg] and src. */
3711 static void shader_glsl_texdp3(const struct wined3d_shader_instruction *ins)
3712 {
3713     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3714     DWORD dstreg = ins->dst[0].reg.idx[0].offset;
3715     struct glsl_src_param src0_param;
3716     DWORD dst_mask;
3717     unsigned int mask_size;
3718
3719     dst_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3720     mask_size = shader_glsl_get_write_mask_size(dst_mask);
3721     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3722
3723     if (mask_size > 1) {
3724         shader_addline(ins->ctx->buffer, "vec%d(dot(T%u.xyz, %s)));\n", mask_size, dstreg, src0_param.param_str);
3725     } else {
3726         shader_addline(ins->ctx->buffer, "dot(T%u.xyz, %s));\n", dstreg, src0_param.param_str);
3727     }
3728 }
3729
3730 /** Process the WINED3DSIO_TEXDEPTH instruction in GLSL:
3731  * Calculate the depth as dst.x / dst.y   */
3732 static void shader_glsl_texdepth(const struct wined3d_shader_instruction *ins)
3733 {
3734     struct glsl_dst_param dst_param;
3735
3736     shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
3737
3738     /* Tests show that texdepth never returns anything below 0.0, and that r5.y is clamped to 1.0.
3739      * Negative input is accepted, -0.25 / -0.5 returns 0.5. GL should clamp gl_FragDepth to [0;1], but
3740      * this doesn't always work, so clamp the results manually. Whether or not the x value is clamped at 1
3741      * too is irrelevant, since if x = 0, any y value < 1.0 (and > 1.0 is not allowed) results in a result
3742      * >= 1.0 or < 0.0
3743      */
3744     shader_addline(ins->ctx->buffer, "gl_FragDepth = clamp((%s.x / min(%s.y, 1.0)), 0.0, 1.0);\n",
3745             dst_param.reg_name, dst_param.reg_name);
3746 }
3747
3748 /** Process the WINED3DSIO_TEXM3X2DEPTH instruction in GLSL:
3749  * Last row of a 3x2 matrix multiply, use the result to calculate the depth:
3750  * Calculate tmp0.y = TexCoord[dstreg] . src.xyz;  (tmp0.x has already been calculated)
3751  * depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
3752  */
3753 static void shader_glsl_texm3x2depth(const struct wined3d_shader_instruction *ins)
3754 {
3755     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3756     DWORD dstreg = ins->dst[0].reg.idx[0].offset;
3757     struct glsl_src_param src0_param;
3758
3759     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3760
3761     shader_addline(ins->ctx->buffer, "tmp0.y = dot(T%u.xyz, %s);\n", dstreg, src0_param.param_str);
3762     shader_addline(ins->ctx->buffer, "gl_FragDepth = (tmp0.y == 0.0) ? 1.0 : clamp(tmp0.x / tmp0.y, 0.0, 1.0);\n");
3763 }
3764
3765 /** Process the WINED3DSIO_TEXM3X2PAD instruction in GLSL
3766  * Calculate the 1st of a 2-row matrix multiplication. */
3767 static void shader_glsl_texm3x2pad(const struct wined3d_shader_instruction *ins)
3768 {
3769     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3770     DWORD reg = ins->dst[0].reg.idx[0].offset;
3771     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3772     struct glsl_src_param src0_param;
3773
3774     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3775     shader_addline(buffer, "tmp0.x = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
3776 }
3777
3778 /** Process the WINED3DSIO_TEXM3X3PAD instruction in GLSL
3779  * Calculate the 1st or 2nd row of a 3-row matrix multiplication. */
3780 static void shader_glsl_texm3x3pad(const struct wined3d_shader_instruction *ins)
3781 {
3782     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3783     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3784     struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
3785     DWORD reg = ins->dst[0].reg.idx[0].offset;
3786     struct glsl_src_param src0_param;
3787
3788     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3789     shader_addline(buffer, "tmp0.%c = dot(T%u.xyz, %s);\n", 'x' + tex_mx->current_row, reg, src0_param.param_str);
3790     tex_mx->texcoord_w[tex_mx->current_row++] = reg;
3791 }
3792
3793 static void shader_glsl_texm3x2tex(const struct wined3d_shader_instruction *ins)
3794 {
3795     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3796     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3797     struct glsl_sample_function sample_function;
3798     DWORD reg = ins->dst[0].reg.idx[0].offset;
3799     struct glsl_src_param src0_param;
3800
3801     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3802     shader_addline(buffer, "tmp0.y = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
3803
3804     shader_glsl_get_sample_function(ins->ctx, reg, 0, &sample_function);
3805
3806     /* Sample the texture using the calculated coordinates */
3807     shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, "tmp0.xy");
3808 }
3809
3810 /** Process the WINED3DSIO_TEXM3X3TEX instruction in GLSL
3811  * Perform the 3rd row of a 3x3 matrix multiply, then sample the texture using the calculated coordinates */
3812 static void shader_glsl_texm3x3tex(const struct wined3d_shader_instruction *ins)
3813 {
3814     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3815     struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
3816     struct glsl_sample_function sample_function;
3817     DWORD reg = ins->dst[0].reg.idx[0].offset;
3818     struct glsl_src_param src0_param;
3819
3820     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3821     shader_addline(ins->ctx->buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
3822
3823     /* Dependent read, not valid with conditional NP2 */
3824     shader_glsl_get_sample_function(ins->ctx, reg, 0, &sample_function);
3825
3826     /* Sample the texture using the calculated coordinates */
3827     shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, "tmp0.xyz");
3828
3829     tex_mx->current_row = 0;
3830 }
3831
3832 /** Process the WINED3DSIO_TEXM3X3 instruction in GLSL
3833  * Perform the 3rd row of a 3x3 matrix multiply */
3834 static void shader_glsl_texm3x3(const struct wined3d_shader_instruction *ins)
3835 {
3836     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3837     struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
3838     DWORD reg = ins->dst[0].reg.idx[0].offset;
3839     struct glsl_src_param src0_param;
3840     char dst_mask[6];
3841
3842     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3843
3844     shader_glsl_append_dst(ins->ctx->buffer, ins);
3845     shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3846     shader_addline(ins->ctx->buffer, "vec4(tmp0.xy, dot(T%u.xyz, %s), 1.0)%s);\n", reg, src0_param.param_str, dst_mask);
3847
3848     tex_mx->current_row = 0;
3849 }
3850
3851 /* Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL
3852  * Perform the final texture lookup based on the previous 2 3x3 matrix multiplies */
3853 static void shader_glsl_texm3x3spec(const struct wined3d_shader_instruction *ins)
3854 {
3855     struct glsl_src_param src0_param;
3856     struct glsl_src_param src1_param;
3857     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3858     struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
3859     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3860     struct glsl_sample_function sample_function;
3861     DWORD reg = ins->dst[0].reg.idx[0].offset;
3862     char coord_mask[6];
3863
3864     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3865     shader_glsl_add_src_param(ins, &ins->src[1], src_mask, &src1_param);
3866
3867     /* Perform the last matrix multiply operation */
3868     shader_addline(buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
3869     /* Reflection calculation */
3870     shader_addline(buffer, "tmp0.xyz = -reflect((%s), normalize(tmp0.xyz));\n", src1_param.param_str);
3871
3872     /* Dependent read, not valid with conditional NP2 */
3873     shader_glsl_get_sample_function(ins->ctx, reg, 0, &sample_function);
3874     shader_glsl_write_mask_to_str(sample_function.coord_mask, coord_mask);
3875
3876     /* Sample the texture */
3877     shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DSP_NOSWIZZLE,
3878             NULL, NULL, NULL, "tmp0%s", coord_mask);
3879
3880     tex_mx->current_row = 0;
3881 }
3882
3883 /* Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL
3884  * Perform the final texture lookup based on the previous 2 3x3 matrix multiplies */
3885 static void shader_glsl_texm3x3vspec(const struct wined3d_shader_instruction *ins)
3886 {
3887     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3888     struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
3889     DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3890     struct glsl_sample_function sample_function;
3891     DWORD reg = ins->dst[0].reg.idx[0].offset;
3892     struct glsl_src_param src0_param;
3893     char coord_mask[6];
3894
3895     shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3896
3897     /* Perform the last matrix multiply operation */
3898     shader_addline(buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_param.param_str);
3899
3900     /* Construct the eye-ray vector from w coordinates */
3901     shader_addline(buffer, "tmp1.xyz = normalize(vec3(gl_TexCoord[%u].w, gl_TexCoord[%u].w, gl_TexCoord[%u].w));\n",
3902             tex_mx->texcoord_w[0], tex_mx->texcoord_w[1], reg);
3903     shader_addline(buffer, "tmp0.xyz = -reflect(tmp1.xyz, normalize(tmp0.xyz));\n");
3904
3905     /* Dependent read, not valid with conditional NP2 */
3906     shader_glsl_get_sample_function(ins->ctx, reg, 0, &sample_function);
3907     shader_glsl_write_mask_to_str(sample_function.coord_mask, coord_mask);
3908
3909     /* Sample the texture using the calculated coordinates */
3910     shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DSP_NOSWIZZLE,
3911             NULL, NULL, NULL, "tmp0%s", coord_mask);
3912
3913     tex_mx->current_row = 0;
3914 }
3915
3916 /** Process the WINED3DSIO_TEXBEM instruction in GLSL.
3917  * Apply a fake bump map transform.
3918  * texbem is pshader <= 1.3 only, this saves a few version checks
3919  */
3920 static void shader_glsl_texbem(const struct wined3d_shader_instruction *ins)
3921 {
3922     const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3923     struct glsl_sample_function sample_function;
3924     struct glsl_src_param coord_param;
3925     DWORD sampler_idx;
3926     DWORD mask;
3927     DWORD flags;
3928     char coord_mask[6];
3929
3930     sampler_idx = ins->dst[0].reg.idx[0].offset;
3931     flags = (priv->cur_ps_args->tex_transform >> sampler_idx * WINED3D_PSARGS_TEXTRANSFORM_SHIFT)
3932             & WINED3D_PSARGS_TEXTRANSFORM_MASK;
3933
3934     /* Dependent read, not valid with conditional NP2 */
3935     shader_glsl_get_sample_function(ins->ctx, sampler_idx, 0, &sample_function);
3936     mask = sample_function.coord_mask;
3937
3938     shader_glsl_write_mask_to_str(mask, coord_mask);
3939
3940     /* With projected textures, texbem only divides the static texture coord,
3941      * not the displacement, so we can't let GL handle this. */
3942     if (flags & WINED3D_PSARGS_PROJECTED)
3943     {
3944         DWORD div_mask=0;
3945         char coord_div_mask[3];
3946         switch (flags & ~WINED3D_PSARGS_PROJECTED)
3947         {
3948             case WINED3D_TTFF_COUNT1:
3949                 FIXME("WINED3D_TTFF_PROJECTED with WINED3D_TTFF_COUNT1?\n");
3950                 break;
3951             case WINED3D_TTFF_COUNT2:
3952                 div_mask = WINED3DSP_WRITEMASK_1;
3953                 break;
3954             case WINED3D_TTFF_COUNT3:
3955                 div_mask = WINED3DSP_WRITEMASK_2;
3956                 break;
3957             case WINED3D_TTFF_COUNT4:
3958             case WINED3D_TTFF_DISABLE:
3959                 div_mask = WINED3DSP_WRITEMASK_3;
3960                 break;
3961         }
3962         shader_glsl_write_mask_to_str(div_mask, coord_div_mask);
3963         shader_addline(ins->ctx->buffer, "T%u%s /= T%u%s;\n", sampler_idx, coord_mask, sampler_idx, coord_div_mask);
3964     }
3965
3966     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &coord_param);
3967
3968     shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3969             "T%u%s + vec4(bumpenv_mat%u * %s, 0.0, 0.0)%s", sampler_idx, coord_mask, sampler_idx,
3970             coord_param.param_str, coord_mask);
3971
3972     if (ins->handler_idx == WINED3DSIH_TEXBEML)
3973     {
3974         struct glsl_src_param luminance_param;
3975         struct glsl_dst_param dst_param;
3976
3977         shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_2, &luminance_param);
3978         shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
3979
3980         shader_addline(ins->ctx->buffer, "%s%s *= (%s * bumpenv_lum_scale%u + bumpenv_lum_offset%u);\n",
3981                 dst_param.reg_name, dst_param.mask_str,
3982                 luminance_param.param_str, sampler_idx, sampler_idx);
3983     }
3984 }
3985
3986 static void shader_glsl_bem(const struct wined3d_shader_instruction *ins)
3987 {
3988     DWORD sampler_idx = ins->dst[0].reg.idx[0].offset;
3989     struct glsl_src_param src0_param, src1_param;
3990
3991     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
3992     shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
3993
3994     shader_glsl_append_dst(ins->ctx->buffer, ins);
3995     shader_addline(ins->ctx->buffer, "%s + bumpenv_mat%u * %s);\n",
3996             src0_param.param_str, sampler_idx, src1_param.param_str);
3997 }
3998
3999 /** Process the WINED3DSIO_TEXREG2AR instruction in GLSL
4000  * Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */
4001 static void shader_glsl_texreg2ar(const struct wined3d_shader_instruction *ins)
4002 {
4003     DWORD sampler_idx = ins->dst[0].reg.idx[0].offset;
4004     struct glsl_sample_function sample_function;
4005     struct glsl_src_param src0_param;
4006
4007     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
4008
4009     shader_glsl_get_sample_function(ins->ctx, sampler_idx, 0, &sample_function);
4010     shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
4011             "%s.wx", src0_param.reg_name);
4012 }
4013
4014 /** Process the WINED3DSIO_TEXREG2GB instruction in GLSL
4015  * Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */
4016 static void shader_glsl_texreg2gb(const struct wined3d_shader_instruction *ins)
4017 {
4018     DWORD sampler_idx = ins->dst[0].reg.idx[0].offset;
4019     struct glsl_sample_function sample_function;
4020     struct glsl_src_param src0_param;
4021
4022     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
4023
4024     shader_glsl_get_sample_function(ins->ctx, sampler_idx, 0, &sample_function);
4025     shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
4026             "%s.yz", src0_param.reg_name);
4027 }
4028
4029 /** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL
4030  * Sample texture at dst using the rgb (xyz) components of src as texture coordinates */
4031 static void shader_glsl_texreg2rgb(const struct wined3d_shader_instruction *ins)
4032 {
4033     DWORD sampler_idx = ins->dst[0].reg.idx[0].offset;
4034     struct glsl_sample_function sample_function;
4035     struct glsl_src_param src0_param;
4036
4037     /* Dependent read, not valid with conditional NP2 */
4038     shader_glsl_get_sample_function(ins->ctx, sampler_idx, 0, &sample_function);
4039     shader_glsl_add_src_param(ins, &ins->src[0], sample_function.coord_mask, &src0_param);
4040
4041     shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
4042             "%s", src0_param.param_str);
4043 }
4044
4045 /** Process the WINED3DSIO_TEXKILL instruction in GLSL.
4046  * If any of the first 3 components are < 0, discard this pixel */
4047 static void shader_glsl_texkill(const struct wined3d_shader_instruction *ins)
4048 {
4049     struct glsl_dst_param dst_param;
4050
4051     /* The argument is a destination parameter, and no writemasks are allowed */
4052     shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
4053     if (ins->ctx->reg_maps->shader_version.major >= 2)
4054     {
4055         /* 2.0 shaders compare all 4 components in texkill */
4056         shader_addline(ins->ctx->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name);
4057     } else {
4058         /* 1.X shaders only compare the first 3 components, probably due to the nature of the texkill
4059          * instruction as a tex* instruction, and phase, which kills all a / w components. Even if all
4060          * 4 components are defined, only the first 3 are used
4061          */
4062         shader_addline(ins->ctx->buffer, "if (any(lessThan(%s.xyz, vec3(0.0)))) discard;\n", dst_param.reg_name);
4063     }
4064 }
4065
4066 /** Process the WINED3DSIO_DP2ADD instruction in GLSL.
4067  * dst = dot2(src0, src1) + src2 */
4068 static void shader_glsl_dp2add(const struct wined3d_shader_instruction *ins)
4069 {
4070     struct glsl_src_param src0_param;
4071     struct glsl_src_param src1_param;
4072     struct glsl_src_param src2_param;
4073     DWORD write_mask;
4074     unsigned int mask_size;
4075
4076     write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
4077     mask_size = shader_glsl_get_write_mask_size(write_mask);
4078
4079     shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
4080     shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
4081     shader_glsl_add_src_param(ins, &ins->src[2], WINED3DSP_WRITEMASK_0, &src2_param);
4082
4083     if (mask_size > 1) {
4084         shader_addline(ins->ctx->buffer, "vec%d(dot(%s, %s) + %s));\n",
4085                 mask_size, src0_param.param_str, src1_param.param_str, src2_param.param_str);
4086     } else {
4087         shader_addline(ins->ctx->buffer, "dot(%s, %s) + %s);\n",
4088                 src0_param.param_str, src1_param.param_str, src2_param.param_str);
4089     }
4090 }
4091
4092 static void shader_glsl_input_pack(const struct wined3d_shader *shader, struct wined3d_shader_buffer *buffer,
4093         const struct wined3d_shader_signature_element *input_signature,
4094         const struct wined3d_shader_reg_maps *reg_maps,
4095         enum vertexprocessing_mode vertexprocessing)
4096 {
4097     WORD map = reg_maps->input_registers;
4098     unsigned int i;
4099
4100     for (i = 0; map; map >>= 1, ++i)
4101     {
4102         const char *semantic_name;
4103         UINT semantic_idx;
4104         char reg_mask[6];
4105
4106         /* Unused */
4107         if (!(map & 1)) continue;
4108
4109         semantic_name = input_signature[i].semantic_name;
4110         semantic_idx = input_signature[i].semantic_idx;
4111         shader_glsl_write_mask_to_str(input_signature[i].mask, reg_mask);
4112
4113         if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_TEXCOORD))
4114         {
4115             if (semantic_idx < 8 && vertexprocessing == pretransformed)
4116                 shader_addline(buffer, "ps_in[%u]%s = gl_TexCoord[%u]%s;\n",
4117                         shader->u.ps.input_reg_map[i], reg_mask, semantic_idx, reg_mask);
4118             else
4119                 shader_addline(buffer, "ps_in[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
4120                         shader->u.ps.input_reg_map[i], reg_mask, reg_mask);
4121         }
4122         else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_COLOR))
4123         {
4124             if (!semantic_idx)
4125                 shader_addline(buffer, "ps_in[%u]%s = vec4(gl_Color)%s;\n",
4126                         shader->u.ps.input_reg_map[i], reg_mask, reg_mask);
4127             else if (semantic_idx == 1)
4128                 shader_addline(buffer, "ps_in[%u]%s = vec4(gl_SecondaryColor)%s;\n",
4129                         shader->u.ps.input_reg_map[i], reg_mask, reg_mask);
4130             else
4131                 shader_addline(buffer, "ps_in[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
4132                         shader->u.ps.input_reg_map[i], reg_mask, reg_mask);
4133         }
4134         else
4135         {
4136             shader_addline(buffer, "ps_in[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
4137                     shader->u.ps.input_reg_map[i], reg_mask, reg_mask);
4138         }
4139     }
4140 }
4141
4142 /*********************************************
4143  * Vertex Shader Specific Code begins here
4144  ********************************************/
4145
4146 static void add_glsl_program_entry(struct shader_glsl_priv *priv, struct glsl_shader_prog_link *entry)
4147 {
4148     struct glsl_program_key key;
4149
4150     key.vs_id = entry->vs.id;
4151     key.gs_id = entry->gs.id;
4152     key.ps_id = entry->ps.id;
4153
4154     if (wine_rb_put(&priv->program_lookup, &key, &entry->program_lookup_entry) == -1)
4155     {
4156         ERR("Failed to insert program entry.\n");
4157     }
4158 }
4159
4160 static struct glsl_shader_prog_link *get_glsl_program_entry(const struct shader_glsl_priv *priv,
4161         GLhandleARB vs_id, GLhandleARB gs_id, GLhandleARB ps_id)
4162 {
4163     struct wine_rb_entry *entry;
4164     struct glsl_program_key key;
4165
4166     key.vs_id = vs_id;
4167     key.gs_id = gs_id;
4168     key.ps_id = ps_id;
4169
4170     entry = wine_rb_get(&priv->program_lookup, &key);
4171     return entry ? WINE_RB_ENTRY_VALUE(entry, struct glsl_shader_prog_link, program_lookup_entry) : NULL;
4172 }
4173
4174 /* Context activation is done by the caller. */
4175 static void delete_glsl_program_entry(struct shader_glsl_priv *priv, const struct wined3d_gl_info *gl_info,
4176         struct glsl_shader_prog_link *entry)
4177 {
4178     struct glsl_program_key key;
4179
4180     key.vs_id = entry->vs.id;
4181     key.gs_id = entry->gs.id;
4182     key.ps_id = entry->ps.id;
4183     wine_rb_remove(&priv->program_lookup, &key);
4184
4185     GL_EXTCALL(glDeleteObjectARB(entry->programId));
4186     if (entry->vs.id)
4187         list_remove(&entry->vs.shader_entry);
4188     if (entry->gs.id)
4189         list_remove(&entry->gs.shader_entry);
4190     if (entry->ps.id)
4191         list_remove(&entry->ps.shader_entry);
4192     HeapFree(GetProcessHeap(), 0, entry->vs.uniform_f_locations);
4193     HeapFree(GetProcessHeap(), 0, entry->ps.uniform_f_locations);
4194     HeapFree(GetProcessHeap(), 0, entry);
4195 }
4196
4197 static void handle_ps3_input(struct wined3d_shader_buffer *buffer,
4198         const struct wined3d_gl_info *gl_info, const DWORD *map,
4199         const struct wined3d_shader_signature_element *input_signature,
4200         const struct wined3d_shader_reg_maps *reg_maps_in,
4201         const struct wined3d_shader_signature_element *output_signature,
4202         const struct wined3d_shader_reg_maps *reg_maps_out)
4203 {
4204     unsigned int i, j;
4205     const char *semantic_name_in;
4206     UINT semantic_idx_in;
4207     DWORD *set;
4208     DWORD in_idx;
4209     unsigned int in_count = vec4_varyings(3, gl_info);
4210     char reg_mask[6];
4211     char destination[50];
4212     WORD input_map, output_map;
4213
4214     set = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*set) * (in_count + 2));
4215
4216     input_map = reg_maps_in->input_registers;
4217     for (i = 0; input_map; input_map >>= 1, ++i)
4218     {
4219         if (!(input_map & 1)) continue;
4220
4221         in_idx = map[i];
4222         /* Declared, but not read register */
4223         if (in_idx == ~0U) continue;
4224         if (in_idx >= (in_count + 2))
4225         {
4226             FIXME("More input varyings declared than supported, expect issues.\n");
4227             continue;
4228         }
4229
4230         if (in_idx == in_count)
4231             sprintf(destination, "gl_FrontColor");
4232         else if (in_idx == in_count + 1)
4233             sprintf(destination, "gl_FrontSecondaryColor");
4234         else
4235             sprintf(destination, "ps_in[%u]", in_idx);
4236
4237         semantic_name_in = input_signature[i].semantic_name;
4238         semantic_idx_in = input_signature[i].semantic_idx;
4239         set[in_idx] = ~0U;
4240
4241         output_map = reg_maps_out->output_registers;
4242         for (j = 0; output_map; output_map >>= 1, ++j)
4243         {
4244             DWORD mask;
4245
4246             if (!(output_map & 1)
4247                     || semantic_idx_in != output_signature[j].semantic_idx
4248                     || strcmp(semantic_name_in, output_signature[j].semantic_name)
4249                     || !(mask = input_signature[i].mask & output_signature[j].mask))
4250                 continue;
4251
4252             set[in_idx] = mask;
4253             shader_glsl_write_mask_to_str(mask, reg_mask);
4254
4255             shader_addline(buffer, "%s%s = vs_out[%u]%s;\n",
4256                     destination, reg_mask, j, reg_mask);
4257         }
4258     }
4259
4260     for (i = 0; i < in_count + 2; ++i)
4261     {
4262         unsigned int size;
4263
4264         if (!set[i] || set[i] == WINED3DSP_WRITEMASK_ALL)
4265             continue;
4266
4267         if (set[i] == ~0U) set[i] = 0;
4268
4269         size = 0;
4270         if (!(set[i] & WINED3DSP_WRITEMASK_0)) reg_mask[size++] = 'x';
4271         if (!(set[i] & WINED3DSP_WRITEMASK_1)) reg_mask[size++] = 'y';
4272         if (!(set[i] & WINED3DSP_WRITEMASK_2)) reg_mask[size++] = 'z';
4273         if (!(set[i] & WINED3DSP_WRITEMASK_3)) reg_mask[size++] = 'w';
4274         reg_mask[size] = '\0';
4275
4276         if (i == in_count)
4277             sprintf(destination, "gl_FrontColor");
4278         else if (i == in_count + 1)
4279             sprintf(destination, "gl_FrontSecondaryColor");
4280         else
4281             sprintf(destination, "ps_in[%u]", i);
4282
4283         if (size == 1) shader_addline(buffer, "%s.%s = 0.0;\n", destination, reg_mask);
4284         else shader_addline(buffer, "%s.%s = vec%u(0.0);\n", destination, reg_mask, size);
4285     }
4286
4287     HeapFree(GetProcessHeap(), 0, set);
4288 }
4289
4290 /* Context activation is done by the caller. */
4291 static GLhandleARB generate_param_reorder_function(struct wined3d_shader_buffer *buffer,
4292         const struct wined3d_shader *vs, const struct wined3d_shader *ps,
4293         const struct wined3d_gl_info *gl_info)
4294 {
4295     GLhandleARB ret = 0;
4296     DWORD ps_major = ps ? ps->reg_maps.shader_version.major : 0;
4297     unsigned int i;
4298     const char *semantic_name;
4299     UINT semantic_idx;
4300     char reg_mask[6];
4301     const struct wined3d_shader_signature_element *output_signature = vs->output_signature;
4302     WORD map = vs->reg_maps.output_registers;
4303
4304     shader_buffer_clear(buffer);
4305
4306     shader_addline(buffer, "#version 120\n");
4307
4308     if (ps_major < 3)
4309     {
4310         shader_addline(buffer, "void order_ps_input(in vec4 vs_out[%u])\n{\n", vs->limits.packed_output);
4311
4312         for (i = 0; map; map >>= 1, ++i)
4313         {
4314             DWORD write_mask;
4315
4316             if (!(map & 1)) continue;
4317
4318             semantic_name = output_signature[i].semantic_name;
4319             semantic_idx = output_signature[i].semantic_idx;
4320             write_mask = output_signature[i].mask;
4321             shader_glsl_write_mask_to_str(write_mask, reg_mask);
4322
4323             if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_COLOR))
4324             {
4325                 if (!semantic_idx)
4326                     shader_addline(buffer, "gl_FrontColor%s = vs_out[%u]%s;\n",
4327                             reg_mask, i, reg_mask);
4328                 else if (semantic_idx == 1)
4329                     shader_addline(buffer, "gl_FrontSecondaryColor%s = vs_out[%u]%s;\n",
4330                             reg_mask, i, reg_mask);
4331             }
4332             else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_POSITION))
4333             {
4334                 shader_addline(buffer, "gl_Position%s = vs_out[%u]%s;\n",
4335                         reg_mask, i, reg_mask);
4336             }
4337             else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_TEXCOORD))
4338             {
4339                 if (semantic_idx < 8)
4340                 {
4341                     if (!(gl_info->quirks & WINED3D_QUIRK_SET_TEXCOORD_W) || ps_major > 0)
4342                         write_mask |= WINED3DSP_WRITEMASK_3;
4343
4344                     shader_addline(buffer, "gl_TexCoord[%u]%s = vs_out[%u]%s;\n",
4345                             semantic_idx, reg_mask, i, reg_mask);
4346                     if (!(write_mask & WINED3DSP_WRITEMASK_3))
4347                         shader_addline(buffer, "gl_TexCoord[%u].w = 1.0;\n", semantic_idx);
4348                 }
4349             }
4350             else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_PSIZE))
4351             {
4352                 shader_addline(buffer, "gl_PointSize = vs_out[%u].%c;\n", i, reg_mask[1]);
4353             }
4354             else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_FOG))
4355             {
4356                 shader_addline(buffer, "gl_FogFragCoord = clamp(vs_out[%u].%c, 0.0, 1.0);\n", i, reg_mask[1]);
4357             }
4358         }
4359         shader_addline(buffer, "}\n");
4360     }
4361     else
4362     {
4363         UINT in_count = min(vec4_varyings(ps_major, gl_info), ps->limits.packed_input);
4364         /* This one is tricky: a 3.0 pixel shader reads from a 3.0 vertex shader */
4365         shader_addline(buffer, "varying vec4 ps_in[%u];\n", in_count);
4366         shader_addline(buffer, "void order_ps_input(in vec4 vs_out[%u])\n{\n", vs->limits.packed_output);
4367
4368         /* First, sort out position and point size. Those are not passed to the pixel shader */
4369         for (i = 0; map; map >>= 1, ++i)
4370         {
4371             if (!(map & 1)) continue;
4372
4373             semantic_name = output_signature[i].semantic_name;
4374             shader_glsl_write_mask_to_str(output_signature[i].mask, reg_mask);
4375
4376             if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_POSITION))
4377             {
4378                 shader_addline(buffer, "gl_Position%s = vs_out[%u]%s;\n",
4379                         reg_mask, i, reg_mask);
4380             }
4381             else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_PSIZE))
4382             {
4383                 shader_addline(buffer, "gl_PointSize = vs_out[%u].%c;\n", i, reg_mask[1]);
4384             }
4385         }
4386
4387         /* Then, fix the pixel shader input */
4388         handle_ps3_input(buffer, gl_info, ps->u.ps.input_reg_map, ps->input_signature,
4389                 &ps->reg_maps, output_signature, &vs->reg_maps);
4390
4391         shader_addline(buffer, "}\n");
4392     }
4393
4394     ret = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
4395     checkGLcall("glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)");
4396     shader_glsl_compile(gl_info, ret, buffer->buffer);
4397
4398     return ret;
4399 }
4400
4401 static void shader_glsl_generate_srgb_write_correction(struct wined3d_shader_buffer *buffer)
4402 {
4403     shader_addline(buffer, "tmp0.xyz = pow(gl_FragData[0].xyz, vec3(srgb_const0.x));\n");
4404     shader_addline(buffer, "tmp0.xyz = tmp0.xyz * vec3(srgb_const0.y) - vec3(srgb_const0.z);\n");
4405     shader_addline(buffer, "tmp1.xyz = gl_FragData[0].xyz * vec3(srgb_const0.w);\n");
4406     shader_addline(buffer, "bvec3 srgb_compare = lessThan(gl_FragData[0].xyz, vec3(srgb_const1.x));\n");
4407     shader_addline(buffer, "gl_FragData[0].xyz = mix(tmp0.xyz, tmp1.xyz, vec3(srgb_compare));\n");
4408     shader_addline(buffer, "gl_FragData[0] = clamp(gl_FragData[0], 0.0, 1.0);\n");
4409 }
4410
4411 static void shader_glsl_generate_fog_code(struct wined3d_shader_buffer *buffer, enum fogmode mode)
4412 {
4413     switch (mode)
4414     {
4415         case FOG_OFF:
4416             return;
4417
4418         case FOG_LINEAR:
4419             /* Fog = (gl_Fog.end - gl_FogFragCoord) / (gl_Fog.end - gl_Fog.start) */
4420             shader_addline(buffer, "float Fog = (gl_Fog.end - gl_FogFragCoord) / (gl_Fog.end - gl_Fog.start);\n");
4421             break;
4422
4423         case FOG_EXP:
4424             /* Fog = e^-(gl_Fog.density * gl_FogFragCoord) */
4425             shader_addline(buffer, "float Fog = exp(-gl_Fog.density * gl_FogFragCoord);\n");
4426             break;
4427
4428         case FOG_EXP2:
4429             /* Fog = e^-((gl_Fog.density * gl_FogFragCoord)^2) */
4430             shader_addline(buffer, "float Fog = exp(-gl_Fog.density * gl_Fog.density * gl_FogFragCoord * gl_FogFragCoord);\n");
4431             break;
4432
4433         default:
4434             ERR("Invalid fog mode %#x.\n", mode);
4435             return;
4436     }
4437
4438     shader_addline(buffer, "gl_FragData[0].xyz = mix(gl_Fog.color.xyz, gl_FragData[0].xyz, clamp(Fog, 0.0, 1.0));\n");
4439 }
4440
4441 /* Context activation is done by the caller. */
4442 static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context,
4443         struct wined3d_shader_buffer *buffer, const struct wined3d_shader *shader,
4444         const struct ps_compile_args *args, struct ps_np2fixup_info *np2fixup_info)
4445 {
4446     const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
4447     const struct wined3d_gl_info *gl_info = context->gl_info;
4448     const DWORD *function = shader->function;
4449     struct shader_glsl_ctx_priv priv_ctx;
4450
4451     /* Create the hw GLSL shader object and assign it as the shader->prgId */
4452     GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
4453
4454     memset(&priv_ctx, 0, sizeof(priv_ctx));
4455     priv_ctx.cur_ps_args = args;
4456     priv_ctx.cur_np2fixup_info = np2fixup_info;
4457
4458     shader_addline(buffer, "#version 120\n");
4459
4460     if (gl_info->supported[ARB_SHADER_BIT_ENCODING])
4461         shader_addline(buffer, "#extension GL_ARB_shader_bit_encoding : enable\n");
4462     if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
4463         shader_addline(buffer, "#extension GL_ARB_shader_texture_lod : enable\n");
4464     /* The spec says that it doesn't have to be explicitly enabled, but the
4465      * nvidia drivers write a warning if we don't do so. */
4466     if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
4467         shader_addline(buffer, "#extension GL_ARB_texture_rectangle : enable\n");
4468     if (gl_info->supported[EXT_GPU_SHADER4])
4469         shader_addline(buffer, "#extension GL_EXT_gpu_shader4 : enable\n");
4470
4471     /* Base Declarations */
4472     shader_generate_glsl_declarations(context, buffer, shader, reg_maps, &priv_ctx);
4473
4474     /* Pack 3.0 inputs */
4475     if (reg_maps->shader_version.major >= 3 && args->vp_mode != vertexshader)
4476         shader_glsl_input_pack(shader, buffer, shader->input_signature, reg_maps, args->vp_mode);
4477
4478     /* Base Shader Body */
4479     shader_generate_main(shader, buffer, reg_maps, function, &priv_ctx);
4480
4481     /* Pixel shaders < 2.0 place the resulting color in R0 implicitly */
4482     if (reg_maps->shader_version.major < 2)
4483     {
4484         /* Some older cards like GeforceFX ones don't support multiple buffers, so also not gl_FragData */
4485         shader_addline(buffer, "gl_FragData[0] = R0;\n");
4486     }
4487
4488     if (args->srgb_correction)
4489         shader_glsl_generate_srgb_write_correction(buffer);
4490
4491     /* SM < 3 does not replace the fog stage. */
4492     if (reg_maps->shader_version.major < 3)
4493         shader_glsl_generate_fog_code(buffer, args->fog);
4494
4495     shader_addline(buffer, "}\n");
4496
4497     TRACE("Compiling shader object %u\n", shader_obj);
4498     shader_glsl_compile(gl_info, shader_obj, buffer->buffer);
4499
4500     /* Store the shader object */
4501     return shader_obj;
4502 }
4503
4504 /* Context activation is done by the caller. */
4505 static GLuint shader_glsl_generate_vshader(const struct wined3d_context *context,
4506         struct wined3d_shader_buffer *buffer, const struct wined3d_shader *shader,
4507         const struct vs_compile_args *args)
4508 {
4509     const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
4510     const struct wined3d_gl_info *gl_info = context->gl_info;
4511     const DWORD *function = shader->function;
4512     struct shader_glsl_ctx_priv priv_ctx;
4513
4514     /* Create the hw GLSL shader program and assign it as the shader->prgId */
4515     GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
4516
4517     shader_addline(buffer, "#version 120\n");
4518
4519     if (gl_info->supported[ARB_SHADER_BIT_ENCODING])
4520         shader_addline(buffer, "#extension GL_ARB_shader_bit_encoding : enable\n");
4521     if (gl_info->supported[EXT_GPU_SHADER4])
4522         shader_addline(buffer, "#extension GL_EXT_gpu_shader4 : enable\n");
4523
4524     memset(&priv_ctx, 0, sizeof(priv_ctx));
4525     priv_ctx.cur_vs_args = args;
4526
4527     /* Base Declarations */
4528     shader_generate_glsl_declarations(context, buffer, shader, reg_maps, &priv_ctx);
4529
4530     /* Base Shader Body */
4531     shader_generate_main(shader, buffer, reg_maps, function, &priv_ctx);
4532
4533     /* Unpack outputs */
4534     shader_addline(buffer, "order_ps_input(vs_out);\n");
4535
4536     /* The D3DRS_FOGTABLEMODE render state defines if the shader-generated fog coord is used
4537      * or if the fragment depth is used. If the fragment depth is used(FOGTABLEMODE != NONE),
4538      * the fog frag coord is thrown away. If the fog frag coord is used, but not written by
4539      * the shader, it is set to 0.0(fully fogged, since start = 1.0, end = 0.0)
4540      */
4541     if (args->fog_src == VS_FOG_Z)
4542         shader_addline(buffer, "gl_FogFragCoord = gl_Position.z;\n");
4543     else if (!reg_maps->fog)
4544         shader_addline(buffer, "gl_FogFragCoord = 0.0;\n");
4545
4546     /* We always store the clipplanes without y inversion */
4547     if (args->clip_enabled)
4548         shader_addline(buffer, "gl_ClipVertex = gl_Position;\n");
4549
4550     /* Write the final position.
4551      *
4552      * OpenGL coordinates specify the center of the pixel while d3d coords specify
4553      * the corner. The offsets are stored in z and w in posFixup. posFixup.y contains
4554      * 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
4555      * contains 1.0 to allow a mad.
4556      */
4557     shader_addline(buffer, "gl_Position.y = gl_Position.y * posFixup.y;\n");
4558     shader_addline(buffer, "gl_Position.xy += posFixup.zw * gl_Position.ww;\n");
4559
4560     /* Z coord [0;1]->[-1;1] mapping, see comment in transform_projection in state.c
4561      *
4562      * Basically we want (in homogeneous coordinates) z = z * 2 - 1. However, shaders are run
4563      * before the homogeneous divide, so we have to take the w into account: z = ((z / w) * 2 - 1) * w,
4564      * which is the same as z = z * 2 - w.
4565      */
4566     shader_addline(buffer, "gl_Position.z = gl_Position.z * 2.0 - gl_Position.w;\n");
4567
4568     shader_addline(buffer, "}\n");
4569
4570     TRACE("Compiling shader object %u\n", shader_obj);
4571     shader_glsl_compile(gl_info, shader_obj, buffer->buffer);
4572
4573     return shader_obj;
4574 }
4575
4576 /* Context activation is done by the caller. */
4577 static GLhandleARB shader_glsl_generate_geometry_shader(const struct wined3d_context *context,
4578         struct wined3d_shader_buffer *buffer, const struct wined3d_shader *shader)
4579 {
4580     const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
4581     const struct wined3d_gl_info *gl_info = context->gl_info;
4582     const DWORD *function = shader->function;
4583     struct shader_glsl_ctx_priv priv_ctx;
4584     GLhandleARB shader_id;
4585
4586     shader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_GEOMETRY_SHADER_ARB));
4587
4588     shader_addline(buffer, "#version 120\n");
4589
4590     if (gl_info->supported[ARB_GEOMETRY_SHADER4])
4591         shader_addline(buffer, "#extension GL_ARB_geometry_shader4 : enable\n");
4592     if (gl_info->supported[ARB_SHADER_BIT_ENCODING])
4593         shader_addline(buffer, "#extension GL_ARB_shader_bit_encoding : enable\n");
4594     if (gl_info->supported[EXT_GPU_SHADER4])
4595         shader_addline(buffer, "#extension GL_EXT_gpu_shader4 : enable\n");
4596
4597     memset(&priv_ctx, 0, sizeof(priv_ctx));
4598     shader_generate_glsl_declarations(context, buffer, shader, reg_maps, &priv_ctx);
4599     shader_generate_main(shader, buffer, reg_maps, function, &priv_ctx);
4600     shader_addline(buffer, "}\n");
4601
4602     TRACE("Compiling shader object %u.\n", shader_id);
4603     shader_glsl_compile(gl_info, shader_id, buffer->buffer);
4604
4605     return shader_id;
4606 }
4607
4608 static GLhandleARB find_glsl_pshader(const struct wined3d_context *context,
4609         struct wined3d_shader_buffer *buffer, struct wined3d_shader *shader,
4610         const struct ps_compile_args *args, const struct ps_np2fixup_info **np2fixup_info)
4611 {
4612     struct glsl_ps_compiled_shader *gl_shaders, *new_array;
4613     struct glsl_shader_private *shader_data;
4614     struct ps_np2fixup_info *np2fixup;
4615     UINT i;
4616     DWORD new_size;
4617     GLhandleARB ret;
4618
4619     if (!shader->backend_data)
4620     {
4621         shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
4622         if (!shader->backend_data)
4623         {
4624             ERR("Failed to allocate backend data.\n");
4625             return 0;
4626         }
4627     }
4628     shader_data = shader->backend_data;
4629     gl_shaders = shader_data->gl_shaders.ps;
4630
4631     /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
4632      * so a linear search is more performant than a hashmap or a binary search
4633      * (cache coherency etc)
4634      */
4635     for (i = 0; i < shader_data->num_gl_shaders; ++i)
4636     {
4637         if (!memcmp(&gl_shaders[i].args, args, sizeof(*args)))
4638         {
4639             if (args->np2_fixup)
4640                 *np2fixup_info = &gl_shaders[i].np2fixup;
4641             return gl_shaders[i].prgId;
4642         }
4643     }
4644
4645     TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
4646     if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
4647         if (shader_data->num_gl_shaders)
4648         {
4649             new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
4650             new_array = HeapReAlloc(GetProcessHeap(), 0, shader_data->gl_shaders.ps,
4651                     new_size * sizeof(*gl_shaders));
4652         }
4653         else
4654         {
4655             new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*gl_shaders));
4656             new_size = 1;
4657         }
4658
4659         if(!new_array) {
4660             ERR("Out of memory\n");
4661             return 0;
4662         }
4663         shader_data->gl_shaders.ps = new_array;
4664         shader_data->shader_array_size = new_size;
4665         gl_shaders = new_array;
4666     }
4667
4668     gl_shaders[shader_data->num_gl_shaders].args = *args;
4669
4670     np2fixup = &gl_shaders[shader_data->num_gl_shaders].np2fixup;
4671     memset(np2fixup, 0, sizeof(*np2fixup));
4672     *np2fixup_info = args->np2_fixup ? np2fixup : NULL;
4673
4674     pixelshader_update_samplers(shader, args->tex_types);
4675
4676     shader_buffer_clear(buffer);
4677     ret = shader_glsl_generate_pshader(context, buffer, shader, args, np2fixup);
4678     gl_shaders[shader_data->num_gl_shaders++].prgId = ret;
4679
4680     return ret;
4681 }
4682
4683 static inline BOOL vs_args_equal(const struct vs_compile_args *stored, const struct vs_compile_args *new,
4684                                  const DWORD use_map) {
4685     if((stored->swizzle_map & use_map) != new->swizzle_map) return FALSE;
4686     if((stored->clip_enabled) != new->clip_enabled) return FALSE;
4687     return stored->fog_src == new->fog_src;
4688 }
4689
4690 static GLhandleARB find_glsl_vshader(const struct wined3d_context *context,
4691         struct wined3d_shader_buffer *buffer, struct wined3d_shader *shader,
4692         const struct vs_compile_args *args)
4693 {
4694     UINT i;
4695     DWORD new_size;
4696     DWORD use_map = shader->device->stream_info.use_map;
4697     struct glsl_vs_compiled_shader *gl_shaders, *new_array;
4698     struct glsl_shader_private *shader_data;
4699     GLhandleARB ret;
4700
4701     if (!shader->backend_data)
4702     {
4703         shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
4704         if (!shader->backend_data)
4705         {
4706             ERR("Failed to allocate backend data.\n");
4707             return 0;
4708         }
4709     }
4710     shader_data = shader->backend_data;
4711     gl_shaders = shader_data->gl_shaders.vs;
4712
4713     /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
4714      * so a linear search is more performant than a hashmap or a binary search
4715      * (cache coherency etc)
4716      */
4717     for (i = 0; i < shader_data->num_gl_shaders; ++i)
4718     {
4719         if (vs_args_equal(&gl_shaders[i].args, args, use_map))
4720             return gl_shaders[i].prgId;
4721     }
4722
4723     TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
4724
4725     if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
4726         if (shader_data->num_gl_shaders)
4727         {
4728             new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
4729             new_array = HeapReAlloc(GetProcessHeap(), 0, shader_data->gl_shaders.vs,
4730                     new_size * sizeof(*gl_shaders));
4731         }
4732         else
4733         {
4734             new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*gl_shaders));
4735             new_size = 1;
4736         }
4737
4738         if(!new_array) {
4739             ERR("Out of memory\n");
4740             return 0;
4741         }
4742         shader_data->gl_shaders.vs = new_array;
4743         shader_data->shader_array_size = new_size;
4744         gl_shaders = new_array;
4745     }
4746
4747     gl_shaders[shader_data->num_gl_shaders].args = *args;
4748
4749     shader_buffer_clear(buffer);
4750     ret = shader_glsl_generate_vshader(context, buffer, shader, args);
4751     gl_shaders[shader_data->num_gl_shaders++].prgId = ret;
4752
4753     return ret;
4754 }
4755
4756 static GLhandleARB find_glsl_geometry_shader(const struct wined3d_context *context,
4757         struct wined3d_shader_buffer *buffer, struct wined3d_shader *shader)
4758 {
4759     struct glsl_gs_compiled_shader *gl_shaders;
4760     struct glsl_shader_private *shader_data;
4761     GLhandleARB ret;
4762
4763     if (!shader->backend_data)
4764     {
4765         if (!(shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data))))
4766         {
4767             ERR("Failed to allocate backend data.\n");
4768             return 0;
4769         }
4770     }
4771     shader_data = shader->backend_data;
4772     gl_shaders = shader_data->gl_shaders.gs;
4773
4774     if (shader_data->num_gl_shaders)
4775         return gl_shaders[0].id;
4776
4777     TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
4778
4779     if (!(shader_data->gl_shaders.gs = HeapAlloc(GetProcessHeap(), 0, sizeof(*gl_shaders))))
4780     {
4781         ERR("Failed to allocate GL shader array.\n");
4782         return 0;
4783     }
4784     shader_data->shader_array_size = 1;
4785     gl_shaders = shader_data->gl_shaders.gs;
4786
4787     shader_buffer_clear(buffer);
4788     ret = shader_glsl_generate_geometry_shader(context, buffer, shader);
4789     gl_shaders[shader_data->num_gl_shaders++].id = ret;
4790
4791     return ret;
4792 }
4793
4794 static const char *shader_glsl_get_ffp_fragment_op_arg(struct wined3d_shader_buffer *buffer,
4795         DWORD argnum, unsigned int stage, DWORD arg)
4796 {
4797     const char *ret;
4798
4799     if (arg == ARG_UNUSED)
4800         return "<unused arg>";
4801
4802     switch (arg & WINED3DTA_SELECTMASK)
4803     {
4804         case WINED3DTA_DIFFUSE:
4805             ret = "gl_Color";
4806             break;
4807
4808         case WINED3DTA_CURRENT:
4809             if (!stage)
4810                 ret = "gl_Color";
4811             else
4812                 ret = "ret";
4813             break;
4814
4815         case WINED3DTA_TEXTURE:
4816             switch (stage)
4817             {
4818                 case 0: ret = "tex0"; break;
4819                 case 1: ret = "tex1"; break;
4820                 case 2: ret = "tex2"; break;
4821                 case 3: ret = "tex3"; break;
4822                 case 4: ret = "tex4"; break;
4823                 case 5: ret = "tex5"; break;
4824                 case 6: ret = "tex6"; break;
4825                 case 7: ret = "tex7"; break;
4826                 default:
4827                     ret = "<invalid texture>";
4828                     break;
4829             }
4830             break;
4831
4832         case WINED3DTA_TFACTOR:
4833             ret = "tex_factor";
4834             break;
4835
4836         case WINED3DTA_SPECULAR:
4837             ret = "gl_SecondaryColor";
4838             break;
4839
4840         case WINED3DTA_TEMP:
4841             ret = "temp_reg";
4842             break;
4843
4844         case WINED3DTA_CONSTANT:
4845             FIXME("Per-stage constants not implemented.\n");
4846             switch (stage)
4847             {
4848                 case 0: ret = "const0"; break;
4849                 case 1: ret = "const1"; break;
4850                 case 2: ret = "const2"; break;
4851                 case 3: ret = "const3"; break;
4852                 case 4: ret = "const4"; break;
4853                 case 5: ret = "const5"; break;
4854                 case 6: ret = "const6"; break;
4855                 case 7: ret = "const7"; break;
4856                 default:
4857                     ret = "<invalid constant>";
4858                     break;
4859             }
4860             break;
4861
4862         default:
4863             return "<unhandled arg>";
4864     }
4865
4866     if (arg & WINED3DTA_COMPLEMENT)
4867     {
4868         shader_addline(buffer, "arg%u = vec4(1.0) - %s;\n", argnum, ret);
4869         if (argnum == 0)
4870             ret = "arg0";
4871         else if (argnum == 1)
4872             ret = "arg1";
4873         else if (argnum == 2)
4874             ret = "arg2";
4875     }
4876
4877     if (arg & WINED3DTA_ALPHAREPLICATE)
4878     {
4879         shader_addline(buffer, "arg%u = vec4(%s.w);\n", argnum, ret);
4880         if (argnum == 0)
4881             ret = "arg0";
4882         else if (argnum == 1)
4883             ret = "arg1";
4884         else if (argnum == 2)
4885             ret = "arg2";
4886     }
4887
4888     return ret;
4889 }
4890
4891 static void shader_glsl_ffp_fragment_op(struct wined3d_shader_buffer *buffer, unsigned int stage, BOOL color,
4892         BOOL alpha, DWORD dst, DWORD op, DWORD dw_arg0, DWORD dw_arg1, DWORD dw_arg2)
4893 {
4894     const char *dstmask, *dstreg, *arg0, *arg1, *arg2;
4895
4896     if (color && alpha)
4897         dstmask = "";
4898     else if (color)
4899         dstmask = ".xyz";
4900     else
4901         dstmask = ".w";
4902
4903     if (dst == tempreg)
4904         dstreg = "temp_reg";
4905     else
4906         dstreg = "ret";
4907
4908     arg0 = shader_glsl_get_ffp_fragment_op_arg(buffer, 0, stage, dw_arg0);
4909     arg1 = shader_glsl_get_ffp_fragment_op_arg(buffer, 1, stage, dw_arg1);
4910     arg2 = shader_glsl_get_ffp_fragment_op_arg(buffer, 2, stage, dw_arg2);
4911
4912     switch (op)
4913     {
4914         case WINED3D_TOP_DISABLE:
4915             if (!stage)
4916                 shader_addline(buffer, "%s%s = gl_Color%s;\n", dstreg, dstmask, dstmask);
4917             break;
4918
4919         case WINED3D_TOP_SELECT_ARG1:
4920             shader_addline(buffer, "%s%s = %s%s;\n", dstreg, dstmask, arg1, dstmask);
4921             break;
4922
4923         case WINED3D_TOP_SELECT_ARG2:
4924             shader_addline(buffer, "%s%s = %s%s;\n", dstreg, dstmask, arg2, dstmask);
4925             break;
4926
4927         case WINED3D_TOP_MODULATE:
4928             shader_addline(buffer, "%s%s = %s%s * %s%s;\n", dstreg, dstmask, arg1, dstmask, arg2, dstmask);
4929             break;
4930
4931         case WINED3D_TOP_MODULATE_4X:
4932             shader_addline(buffer, "%s%s = clamp(%s%s * %s%s * 4.0, 0.0, 1.0);\n",
4933                     dstreg, dstmask, arg1, dstmask, arg2, dstmask);
4934             break;
4935
4936         case WINED3D_TOP_MODULATE_2X:
4937             shader_addline(buffer, "%s%s = clamp(%s%s * %s%s * 2.0, 0.0, 1.0);\n",
4938                     dstreg, dstmask, arg1, dstmask, arg2, dstmask);
4939             break;
4940
4941         case WINED3D_TOP_ADD:
4942             shader_addline(buffer, "%s%s = clamp(%s%s + %s%s, 0.0, 1.0);\n",
4943                     dstreg, dstmask, arg1, dstmask, arg2, dstmask);
4944             break;
4945
4946         case WINED3D_TOP_ADD_SIGNED:
4947             shader_addline(buffer, "%s%s = clamp(%s%s + (%s - vec4(0.5))%s, 0.0, 1.0);\n",
4948                     dstreg, dstmask, arg1, dstmask, arg2, dstmask);
4949             break;
4950
4951         case WINED3D_TOP_ADD_SIGNED_2X:
4952             shader_addline(buffer, "%s%s = clamp((%s%s + (%s - vec4(0.5))%s) * 2.0, 0.0, 1.0);\n",
4953                     dstreg, dstmask, arg1, dstmask, arg2, dstmask);
4954             break;
4955
4956         case WINED3D_TOP_SUBTRACT:
4957             shader_addline(buffer, "%s%s = clamp(%s%s - %s%s, 0.0, 1.0);\n",
4958                     dstreg, dstmask, arg1, dstmask, arg2, dstmask);
4959             break;
4960
4961         case WINED3D_TOP_ADD_SMOOTH:
4962             shader_addline(buffer, "%s%s = clamp((vec4(1.0) - %s)%s * %s%s + %s%s, 0.0, 1.0);\n",
4963                     dstreg, dstmask, arg1, dstmask, arg2, dstmask, arg1, dstmask);
4964             break;
4965
4966         case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
4967             arg0 = shader_glsl_get_ffp_fragment_op_arg(buffer, 0, stage, WINED3DTA_DIFFUSE);
4968             shader_addline(buffer, "%s%s = mix(%s%s, %s%s, %s.w);\n",
4969                     dstreg, dstmask, arg2, dstmask, arg1, dstmask, arg0);
4970             break;
4971
4972         case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
4973             arg0 = shader_glsl_get_ffp_fragment_op_arg(buffer, 0, stage, WINED3DTA_TEXTURE);
4974             shader_addline(buffer, "%s%s = mix(%s%s, %s%s, %s.w);\n",
4975                     dstreg, dstmask, arg2, dstmask, arg1, dstmask, arg0);
4976             break;
4977
4978         case WINED3D_TOP_BLEND_FACTOR_ALPHA:
4979             arg0 = shader_glsl_get_ffp_fragment_op_arg(buffer, 0, stage, WINED3DTA_TFACTOR);
4980             shader_addline(buffer, "%s%s = mix(%s%s, %s%s, %s.w);\n",
4981                     dstreg, dstmask, arg2, dstmask, arg1, dstmask, arg0);
4982             break;
4983
4984         case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
4985             arg0 = shader_glsl_get_ffp_fragment_op_arg(buffer, 0, stage, WINED3DTA_TEXTURE);
4986             shader_addline(buffer, "%s%s = clamp(%s%s * (1.0 - %s.w) + %s%s, 0.0, 1.0);\n",
4987                     dstreg, dstmask, arg2, dstmask, arg0, arg1, dstmask);
4988             break;
4989
4990         case WINED3D_TOP_BLEND_CURRENT_ALPHA:
4991             arg0 = shader_glsl_get_ffp_fragment_op_arg(buffer, 0, stage, WINED3DTA_CURRENT);
4992             shader_addline(buffer, "%s%s = mix(%s%s, %s%s, %s.w);\n",
4993                     dstreg, dstmask, arg2, dstmask, arg1, dstmask, arg0);
4994             break;
4995
4996         case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
4997             shader_addline(buffer, "%s%s = clamp(%s%s * %s.w + %s%s, 0.0, 1.0);\n",
4998                     dstreg, dstmask, arg2, dstmask, arg1, arg1, dstmask);
4999             break;
5000
5001         case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
5002             shader_addline(buffer, "%s%s = clamp(%s%s * %s%s + %s.w, 0.0, 1.0);\n",
5003                     dstreg, dstmask, arg1, dstmask, arg2, dstmask, arg1);
5004             break;
5005
5006         case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
5007             shader_addline(buffer, "%s%s = clamp(%s%s * (1.0 - %s.w) + %s%s, 0.0, 1.0);\n",
5008                     dstreg, dstmask, arg2, dstmask, arg1, arg1, dstmask);
5009             break;
5010         case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
5011             shader_addline(buffer, "%s%s = clamp((vec4(1.0) - %s)%s * %s%s + %s.w, 0.0, 1.0);\n",
5012                     dstreg, dstmask, arg1, dstmask, arg2, dstmask, arg1);
5013             break;
5014
5015         case WINED3D_TOP_BUMPENVMAP:
5016         case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
5017             /* These are handled in the first pass, nothing to do. */
5018             break;
5019
5020         case WINED3D_TOP_DOTPRODUCT3:
5021             shader_addline(buffer, "%s%s = vec4(clamp(dot(%s.xyz - 0.5, %s.xyz - 0.5) * 4.0, 0.0, 1.0))%s;\n",
5022                     dstreg, dstmask, arg1, arg2, dstmask);
5023             break;
5024
5025         case WINED3D_TOP_MULTIPLY_ADD:
5026             shader_addline(buffer, "%s%s = clamp(%s%s * %s%s + %s%s, 0.0, 1.0);\n",
5027                     dstreg, dstmask, arg1, dstmask, arg2, dstmask, arg0, dstmask);
5028             break;
5029
5030         case WINED3D_TOP_LERP:
5031             /* MSDN isn't quite right here. */
5032             shader_addline(buffer, "%s%s = mix(%s%s, %s%s, %s%s);\n",
5033                     dstreg, dstmask, arg2, dstmask, arg1, dstmask, arg0, dstmask);
5034             break;
5035
5036         default:
5037             FIXME("Unhandled operation %#x.\n", op);
5038             break;
5039     }
5040 }
5041
5042 /* Context activation is done by the caller. */
5043 static GLuint shader_glsl_generate_ffp_fragment_shader(struct wined3d_shader_buffer *buffer,
5044         const struct ffp_frag_settings *settings, const struct wined3d_gl_info *gl_info)
5045 {
5046     BOOL tempreg_used = FALSE, tfactor_used = FALSE;
5047     BYTE lum_map = 0, bump_map = 0, tex_map = 0;
5048     const char *final_combiner_src = "ret";
5049     UINT lowest_disabled_stage;
5050     GLhandleARB shader_obj;
5051     DWORD arg0, arg1, arg2;
5052     unsigned int stage;
5053
5054     shader_buffer_clear(buffer);
5055
5056     /* Find out which textures are read */
5057     for (stage = 0; stage < MAX_TEXTURES; ++stage)
5058     {
5059         if (settings->op[stage].cop == WINED3D_TOP_DISABLE)
5060             break;
5061
5062         arg0 = settings->op[stage].carg0 & WINED3DTA_SELECTMASK;
5063         arg1 = settings->op[stage].carg1 & WINED3DTA_SELECTMASK;
5064         arg2 = settings->op[stage].carg2 & WINED3DTA_SELECTMASK;
5065
5066         if (arg0 == WINED3DTA_TEXTURE || arg1 == WINED3DTA_TEXTURE || arg2 == WINED3DTA_TEXTURE)
5067             tex_map |= 1 << stage;
5068         if (arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR)
5069             tfactor_used = TRUE;
5070         if (arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP)
5071             tempreg_used = TRUE;
5072         if (settings->op[stage].dst == tempreg)
5073             tempreg_used = TRUE;
5074
5075         switch (settings->op[stage].cop)
5076         {
5077             case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
5078                 lum_map |= 1 << stage;
5079                 /* fall through */
5080             case WINED3D_TOP_BUMPENVMAP:
5081                 bump_map |= 1 << stage;
5082                 /* fall through */
5083             case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
5084             case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
5085                 tex_map |= 1 << stage;
5086                 break;
5087
5088             case WINED3D_TOP_BLEND_FACTOR_ALPHA:
5089                 tfactor_used = TRUE;
5090                 break;
5091
5092             default:
5093                 break;
5094         }
5095
5096         if (settings->op[stage].aop == WINED3D_TOP_DISABLE)
5097             continue;
5098
5099         arg0 = settings->op[stage].aarg0 & WINED3DTA_SELECTMASK;
5100         arg1 = settings->op[stage].aarg1 & WINED3DTA_SELECTMASK;
5101         arg2 = settings->op[stage].aarg2 & WINED3DTA_SELECTMASK;
5102
5103         if (arg0 == WINED3DTA_TEXTURE || arg1 == WINED3DTA_TEXTURE || arg2 == WINED3DTA_TEXTURE)
5104             tex_map |= 1 << stage;
5105         if (arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR)
5106             tfactor_used = TRUE;
5107         if (arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP)
5108             tempreg_used = TRUE;
5109     }
5110     lowest_disabled_stage = stage;
5111
5112     shader_addline(buffer, "#version 120\n");
5113
5114     if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
5115         shader_addline(buffer, "#extension GL_ARB_texture_rectangle : enable\n");
5116
5117     shader_addline(buffer, "vec4 tmp0, tmp1;\n");
5118     shader_addline(buffer, "vec4 ret;\n");
5119     if (tempreg_used || settings->sRGB_write)
5120         shader_addline(buffer, "vec4 temp_reg;\n");
5121     shader_addline(buffer, "vec4 arg0, arg1, arg2;\n");
5122
5123     for (stage = 0; stage < MAX_TEXTURES; ++stage)
5124     {
5125         if (!(tex_map & (1 << stage)))
5126             continue;
5127
5128         switch (settings->op[stage].tex_type)
5129         {
5130             case tex_1d:
5131                 shader_addline(buffer, "uniform sampler1D ps_sampler%u;\n", stage);
5132                 break;
5133             case tex_2d:
5134                 shader_addline(buffer, "uniform sampler2D ps_sampler%u;\n", stage);
5135                 break;
5136             case tex_3d:
5137                 shader_addline(buffer, "uniform sampler3D ps_sampler%u;\n", stage);
5138                 break;
5139             case tex_cube:
5140                 shader_addline(buffer, "uniform samplerCube ps_sampler%u;\n", stage);
5141                 break;
5142             case tex_rect:
5143                 shader_addline(buffer, "uniform sampler2DRect ps_sampler%u;\n", stage);
5144                 break;
5145             default:
5146                 FIXME("Unhandled sampler type %#x.\n", settings->op[stage].tex_type);
5147                 break;
5148         }
5149
5150         shader_addline(buffer, "vec4 tex%u;\n", stage);
5151
5152         if (!(bump_map & (1 << stage)))
5153             continue;
5154         shader_addline(buffer, "uniform mat2 bumpenv_mat%u;\n", stage);
5155
5156         if (!(lum_map & (1 << stage)))
5157             continue;
5158         shader_addline(buffer, "uniform float bumpenv_lum_scale%u;\n", stage);
5159         shader_addline(buffer, "uniform float bumpenv_lum_offset%u;\n", stage);
5160     }
5161     if (tfactor_used)
5162         shader_addline(buffer, "uniform vec4 tex_factor;\n");
5163     shader_addline(buffer, "uniform vec4 specular_enable;\n");
5164
5165     if (settings->sRGB_write)
5166     {
5167         shader_addline(buffer, "const vec4 srgb_const0 = vec4(%.8e, %.8e, %.8e, %.8e);\n",
5168                 srgb_pow, srgb_mul_high, srgb_sub_high, srgb_mul_low);
5169         shader_addline(buffer, "const vec4 srgb_const1 = vec4(%.8e, 0.0, 0.0, 0.0);\n",
5170                 srgb_cmp);
5171     }
5172
5173     shader_addline(buffer, "void main()\n{\n");
5174
5175     if (lowest_disabled_stage < 7 && settings->emul_clipplanes)
5176         shader_addline(buffer, "if (any(lessThan(gl_texCoord[7], vec4(0.0)))) discard;\n");
5177
5178     /* Generate texture sampling instructions) */
5179     for (stage = 0; stage < MAX_TEXTURES && settings->op[stage].cop != WINED3D_TOP_DISABLE; ++stage)
5180     {
5181         const char *texture_function, *coord_mask;
5182         char tex_reg_name[8];
5183         BOOL proj, clamp;
5184
5185         if (!(tex_map & (1 << stage)))
5186             continue;
5187
5188         if (settings->op[stage].projected == proj_none)
5189         {
5190             proj = FALSE;
5191         }
5192         else if (settings->op[stage].projected == proj_count4
5193                 || settings->op[stage].projected == proj_count3)
5194         {
5195             proj = TRUE;
5196         }
5197         else
5198         {
5199             FIXME("Unexpected projection mode %d\n", settings->op[stage].projected);
5200             proj = TRUE;
5201         }
5202
5203         if (settings->op[stage].cop == WINED3D_TOP_BUMPENVMAP
5204                 || settings->op[stage].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
5205             clamp = FALSE;
5206         else
5207             clamp = TRUE;
5208
5209         switch (settings->op[stage].tex_type)
5210         {
5211             case tex_1d:
5212                 if (proj)
5213                 {
5214                     texture_function = "texture1DProj";
5215                     coord_mask = "xw";
5216                 }
5217                 else
5218                 {
5219                     texture_function = "texture1D";
5220                     coord_mask = "x";
5221                 }
5222                 break;
5223             case tex_2d:
5224                 if (proj)
5225                 {
5226                     texture_function = "texture2DProj";
5227                     coord_mask = "xyw";
5228                 }
5229                 else
5230                 {
5231                     texture_function = "texture2D";
5232                     coord_mask = "xy";
5233                 }
5234                 break;
5235             case tex_3d:
5236                 if (proj)
5237                 {
5238                     texture_function = "texture3DProj";
5239                     coord_mask = "xyzw";
5240                 }
5241                 else
5242                 {
5243                     texture_function = "texture3D";
5244                     coord_mask = "xyz";
5245                 }
5246                 break;
5247             case tex_cube:
5248                 texture_function = "textureCube";
5249                 coord_mask = "xyz";
5250                 break;
5251             case tex_rect:
5252                 if (proj)
5253                 {
5254                     texture_function = "texture2DRectProj";
5255                     coord_mask = "xyw";
5256                 }
5257                 else
5258                 {
5259                     texture_function = "texture2DRect";
5260                     coord_mask = "xy";
5261                 }
5262                 break;
5263             default:
5264                 FIXME("Unhandled texture type %#x.\n", settings->op[stage].tex_type);
5265                 texture_function = "";
5266                 coord_mask = "xyzw";
5267                 break;
5268         }
5269
5270         if (stage > 0
5271                 && (settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP
5272                 || settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE))
5273         {
5274             shader_addline(buffer, "ret.xy = bumpenv_mat%u * tex%u.xy;\n", stage - 1, stage - 1);
5275
5276             /* With projective textures, texbem only divides the static
5277              * texture coord, not the displacement, so multiply the
5278              * displacement with the dividing parameter before passing it to
5279              * TXP. */
5280             if (settings->op[stage].projected != proj_none)
5281             {
5282                 if (settings->op[stage].projected == proj_count4)
5283                 {
5284                     shader_addline(buffer, "ret.xy = (ret.xy * gl_TexCoord[%u].w) + gl_TexCoord[%u].xy;\n",
5285                             stage, stage);
5286                     shader_addline(buffer, "ret.zw = gl_TexCoord[%u].ww;\n", stage);
5287                 }
5288                 else
5289                 {
5290                     shader_addline(buffer, "ret.xy = (ret.xy * gl_TexCoord[%u].z) + gl_TexCoord[%u].xy;\n",
5291                             stage, stage);
5292                     shader_addline(buffer, "ret.zw = gl_TexCoord[%u].zz;\n", stage);
5293                 }
5294             }
5295             else
5296             {
5297                 shader_addline(buffer, "ret = gl_TexCoord[%u] + ret.xyxy;\n", stage);
5298             }
5299
5300             if (clamp)
5301                 shader_addline(buffer, "tex%u = clamp(%s(ps_sampler%u, ret.%s), 0.0, 1.0);\n",
5302                         stage, texture_function, stage, coord_mask);
5303             else
5304                 shader_addline(buffer, "tex%u = %s(ps_sampler%u, ret.%s);\n",
5305                         stage, texture_function, stage, coord_mask);
5306
5307             if (settings->op[stage - 1].cop == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
5308                 shader_addline(buffer, "tex%u *= clamp(tex%u.z * bumpenv_lum_scale%u + bumpenv_lum_offset%u, 0.0, 1.0);\n",
5309                         stage, stage - 1, stage - 1, stage - 1);
5310         }
5311         else if (settings->op[stage].projected == proj_count3)
5312         {
5313             if (clamp)
5314                 shader_addline(buffer, "tex%u = clamp(%s(ps_sampler%u, gl_TexCoord[%u].xyz), 0.0, 1.0);\n",
5315                         stage, texture_function, stage, stage);
5316             else
5317                 shader_addline(buffer, "tex%u = %s(ps_sampler%u, gl_TexCoord[%u].xyz);\n",
5318                         stage, texture_function, stage, stage);
5319         }
5320         else
5321         {
5322             if (clamp)
5323                 shader_addline(buffer, "tex%u = clamp(%s(ps_sampler%u, gl_TexCoord[%u].%s), 0.0, 1.0);\n",
5324                         stage, texture_function, stage, stage, coord_mask);
5325             else
5326                 shader_addline(buffer, "tex%u = %s(ps_sampler%u, gl_TexCoord[%u].%s);\n",
5327                         stage, texture_function, stage, stage, coord_mask);
5328         }
5329
5330         sprintf(tex_reg_name, "tex%u", stage);
5331         shader_glsl_color_correction_ext(buffer, tex_reg_name, WINED3DSP_WRITEMASK_ALL,
5332                 settings->op[stage].color_fixup);
5333     }
5334
5335     /* Generate the main shader */
5336     for (stage = 0; stage < MAX_TEXTURES; ++stage)
5337     {
5338         BOOL op_equal;
5339
5340         if (settings->op[stage].cop == WINED3D_TOP_DISABLE)
5341         {
5342             if (!stage)
5343                 final_combiner_src = "gl_Color";
5344             break;
5345         }
5346
5347         if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG1
5348                 && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG1)
5349             op_equal = settings->op[stage].carg1 == settings->op[stage].aarg1;
5350         else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG1
5351                 && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG2)
5352             op_equal = settings->op[stage].carg1 == settings->op[stage].aarg2;
5353         else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG2
5354                 && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG1)
5355             op_equal = settings->op[stage].carg2 == settings->op[stage].aarg1;
5356         else if (settings->op[stage].cop == WINED3D_TOP_SELECT_ARG2
5357                 && settings->op[stage].aop == WINED3D_TOP_SELECT_ARG2)
5358             op_equal = settings->op[stage].carg2 == settings->op[stage].aarg2;
5359         else
5360             op_equal = settings->op[stage].aop == settings->op[stage].cop
5361                     && settings->op[stage].carg0 == settings->op[stage].aarg0
5362                     && settings->op[stage].carg1 == settings->op[stage].aarg1
5363                     && settings->op[stage].carg2 == settings->op[stage].aarg2;
5364
5365         if (settings->op[stage].aop == WINED3D_TOP_DISABLE)
5366         {
5367             shader_glsl_ffp_fragment_op(buffer, stage, TRUE, FALSE, settings->op[stage].dst,
5368                     settings->op[stage].cop, settings->op[stage].carg0,
5369                     settings->op[stage].carg1, settings->op[stage].carg2);
5370             if (!stage)
5371                 shader_addline(buffer, "ret.w = gl_Color.w;\n");
5372         }
5373         else if (op_equal)
5374         {
5375             shader_glsl_ffp_fragment_op(buffer, stage, TRUE, TRUE, settings->op[stage].dst,
5376                     settings->op[stage].cop, settings->op[stage].carg0,
5377                     settings->op[stage].carg1, settings->op[stage].carg2);
5378         }
5379         else
5380         {
5381             shader_glsl_ffp_fragment_op(buffer, stage, TRUE, FALSE, settings->op[stage].dst,
5382                     settings->op[stage].cop, settings->op[stage].carg0,
5383                     settings->op[stage].carg1, settings->op[stage].carg2);
5384             shader_glsl_ffp_fragment_op(buffer, stage, FALSE, TRUE, settings->op[stage].dst,
5385                     settings->op[stage].aop, settings->op[stage].aarg0,
5386                     settings->op[stage].aarg1, settings->op[stage].aarg2);
5387         }
5388     }
5389
5390     shader_addline(buffer, "gl_FragData[0] = gl_SecondaryColor * specular_enable + %s;\n", final_combiner_src);
5391
5392     if (settings->sRGB_write)
5393         shader_glsl_generate_srgb_write_correction(buffer);
5394
5395     shader_glsl_generate_fog_code(buffer, settings->fog);
5396
5397     shader_addline(buffer, "}\n");
5398
5399     shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
5400     shader_glsl_compile(gl_info, shader_obj, buffer->buffer);
5401     return shader_obj;
5402 }
5403
5404 static struct glsl_ffp_fragment_shader *shader_glsl_find_ffp_fragment_shader(struct shader_glsl_priv *priv,
5405         const struct wined3d_gl_info *gl_info, const struct ffp_frag_settings *args)
5406 {
5407     struct glsl_ffp_fragment_shader *glsl_desc;
5408     const struct ffp_frag_desc *desc;
5409
5410     if ((desc = find_ffp_frag_shader(&priv->ffp_fragment_shaders, args)))
5411         return CONTAINING_RECORD(desc, struct glsl_ffp_fragment_shader, entry);
5412
5413     if (!(glsl_desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*glsl_desc))))
5414         return NULL;
5415
5416     glsl_desc->entry.settings = *args;
5417     glsl_desc->id = shader_glsl_generate_ffp_fragment_shader(&priv->shader_buffer, args, gl_info);
5418     list_init(&glsl_desc->linked_programs);
5419     add_ffp_frag_shader(&priv->ffp_fragment_shaders, &glsl_desc->entry);
5420
5421     return glsl_desc;
5422 }
5423
5424
5425 static void shader_glsl_init_vs_uniform_locations(const struct wined3d_gl_info *gl_info,
5426         GLhandleARB program_id, struct glsl_vs_program *vs)
5427 {
5428     unsigned int i;
5429     char name[32];
5430
5431     vs->uniform_f_locations = HeapAlloc(GetProcessHeap(), 0,
5432             sizeof(GLhandleARB) * gl_info->limits.glsl_vs_float_constants);
5433     for (i = 0; i < gl_info->limits.glsl_vs_float_constants; ++i)
5434     {
5435         snprintf(name, sizeof(name), "vs_c[%u]", i);
5436         vs->uniform_f_locations[i] = GL_EXTCALL(glGetUniformLocationARB(program_id, name));
5437     }
5438
5439     for (i = 0; i < MAX_CONST_I; ++i)
5440     {
5441         snprintf(name, sizeof(name), "vs_i[%u]", i);
5442         vs->uniform_i_locations[i] = GL_EXTCALL(glGetUniformLocationARB(program_id, name));
5443     }
5444
5445     vs->pos_fixup_location = GL_EXTCALL(glGetUniformLocationARB(program_id, "posFixup"));
5446 }
5447
5448 static void shader_glsl_init_ps_uniform_locations(const struct wined3d_gl_info *gl_info,
5449         GLhandleARB program_id, struct glsl_ps_program *ps)
5450 {
5451     unsigned int i;
5452     char name[32];
5453
5454     ps->uniform_f_locations = HeapAlloc(GetProcessHeap(), 0,
5455             sizeof(GLhandleARB) * gl_info->limits.glsl_ps_float_constants);
5456     for (i = 0; i < gl_info->limits.glsl_ps_float_constants; ++i)
5457     {
5458         snprintf(name, sizeof(name), "ps_c[%u]", i);
5459         ps->uniform_f_locations[i] = GL_EXTCALL(glGetUniformLocationARB(program_id, name));
5460     }
5461
5462     for (i = 0; i < MAX_CONST_I; ++i)
5463     {
5464         snprintf(name, sizeof(name), "ps_i[%u]", i);
5465         ps->uniform_i_locations[i] = GL_EXTCALL(glGetUniformLocationARB(program_id, name));
5466     }
5467
5468     for (i = 0; i < MAX_TEXTURES; ++i)
5469     {
5470         snprintf(name, sizeof(name), "bumpenv_mat%u", i);
5471         ps->bumpenv_mat_location[i] = GL_EXTCALL(glGetUniformLocationARB(program_id, name));
5472         snprintf(name, sizeof(name), "bumpenv_lum_scale%u", i);
5473         ps->bumpenv_lum_scale_location[i] = GL_EXTCALL(glGetUniformLocationARB(program_id, name));
5474         snprintf(name, sizeof(name), "bumpenv_lum_offset%u", i);
5475         ps->bumpenv_lum_offset_location[i] = GL_EXTCALL(glGetUniformLocationARB(program_id, name));
5476     }
5477
5478     ps->tex_factor_location = GL_EXTCALL(glGetUniformLocationARB(program_id, "tex_factor"));
5479     ps->specular_enable_location = GL_EXTCALL(glGetUniformLocationARB(program_id, "specular_enable"));
5480     ps->np2_fixup_location = GL_EXTCALL(glGetUniformLocationARB(program_id, "ps_samplerNP2Fixup"));
5481     ps->ycorrection_location = GL_EXTCALL(glGetUniformLocationARB(program_id, "ycorrection"));
5482 }
5483
5484 /* Context activation is done by the caller. */
5485 static void set_glsl_shader_program(const struct wined3d_context *context, struct wined3d_device *device,
5486         enum wined3d_shader_mode vertex_mode, enum wined3d_shader_mode fragment_mode)
5487 {
5488     const struct wined3d_state *state = &device->stateBlock->state;
5489     const struct wined3d_gl_info *gl_info = context->gl_info;
5490     const struct ps_np2fixup_info *np2fixup_info = NULL;
5491     struct shader_glsl_priv *priv = device->shader_priv;
5492     struct glsl_shader_prog_link *entry = NULL;
5493     struct wined3d_shader *vshader = NULL;
5494     struct wined3d_shader *gshader = NULL;
5495     struct wined3d_shader *pshader = NULL;
5496     GLhandleARB programId                  = 0;
5497     GLhandleARB reorder_shader_id          = 0;
5498     unsigned int i;
5499     struct ps_compile_args ps_compile_args;
5500     struct vs_compile_args vs_compile_args;
5501     GLhandleARB vs_id, gs_id, ps_id;
5502     struct list *ps_list;
5503
5504     if (vertex_mode == WINED3D_SHADER_MODE_SHADER)
5505     {
5506         vshader = state->vertex_shader;
5507         find_vs_compile_args(state, vshader, &vs_compile_args);
5508         vs_id = find_glsl_vshader(context, &priv->shader_buffer, vshader, &vs_compile_args);
5509
5510         if ((gshader = state->geometry_shader))
5511             gs_id = find_glsl_geometry_shader(context, &priv->shader_buffer, gshader);
5512         else
5513             gs_id = 0;
5514     }
5515     else
5516     {
5517         vs_id = 0;
5518         gs_id = 0;
5519     }
5520
5521     if (fragment_mode == WINED3D_SHADER_MODE_SHADER)
5522     {
5523         pshader = state->pixel_shader;
5524         find_ps_compile_args(state, pshader, &ps_compile_args);
5525         ps_id = find_glsl_pshader(context, &priv->shader_buffer,
5526                 pshader, &ps_compile_args, &np2fixup_info);
5527         ps_list = &pshader->linked_programs;
5528     }
5529     else if (fragment_mode == WINED3D_SHADER_MODE_FFP && priv->fragment_pipe == &glsl_fragment_pipe)
5530     {
5531         struct glsl_ffp_fragment_shader *ffp_shader;
5532         struct ffp_frag_settings settings;
5533
5534         gen_ffp_frag_op(device, state, &settings, FALSE);
5535         ffp_shader = shader_glsl_find_ffp_fragment_shader(priv, gl_info, &settings);
5536         ps_id = ffp_shader->id;
5537         ps_list = &ffp_shader->linked_programs;
5538     }
5539     else
5540     {
5541         ps_id = 0;
5542     }
5543
5544     if ((!vs_id && !gs_id && !ps_id) || (entry = get_glsl_program_entry(priv, vs_id, gs_id, ps_id)))
5545     {
5546         priv->glsl_program = entry;
5547         return;
5548     }
5549
5550     /* If we get to this point, then no matching program exists, so we create one */
5551     programId = GL_EXTCALL(glCreateProgramObjectARB());
5552     TRACE("Created new GLSL shader program %u\n", programId);
5553
5554     /* Create the entry */
5555     entry = HeapAlloc(GetProcessHeap(), 0, sizeof(struct glsl_shader_prog_link));
5556     entry->programId = programId;
5557     entry->vs.id = vs_id;
5558     entry->gs.id = gs_id;
5559     entry->ps.id = ps_id;
5560     entry->constant_version = 0;
5561     entry->ps.np2_fixup_info = np2fixup_info;
5562     /* Add the hash table entry */
5563     add_glsl_program_entry(priv, entry);
5564
5565     /* Set the current program */
5566     priv->glsl_program = entry;
5567
5568     /* Attach GLSL vshader */
5569     if (vshader)
5570     {
5571         WORD map = vshader->reg_maps.input_registers;
5572         char tmp_name[10];
5573
5574         reorder_shader_id = generate_param_reorder_function(&priv->shader_buffer, vshader, pshader, gl_info);
5575         TRACE("Attaching GLSL shader object %u to program %u\n", reorder_shader_id, programId);
5576         GL_EXTCALL(glAttachObjectARB(programId, reorder_shader_id));
5577         checkGLcall("glAttachObjectARB");
5578         /* Flag the reorder function for deletion, then it will be freed automatically when the program
5579          * is destroyed
5580          */
5581         GL_EXTCALL(glDeleteObjectARB(reorder_shader_id));
5582
5583         TRACE("Attaching GLSL shader object %u to program %u.\n", vs_id, programId);
5584         GL_EXTCALL(glAttachObjectARB(programId, vs_id));
5585         checkGLcall("glAttachObjectARB");
5586
5587         /* Bind vertex attributes to a corresponding index number to match
5588          * the same index numbers as ARB_vertex_programs (makes loading
5589          * vertex attributes simpler).  With this method, we can use the
5590          * exact same code to load the attributes later for both ARB and
5591          * GLSL shaders.
5592          *
5593          * We have to do this here because we need to know the Program ID
5594          * in order to make the bindings work, and it has to be done prior
5595          * to linking the GLSL program. */
5596         for (i = 0; map; map >>= 1, ++i)
5597         {
5598             if (!(map & 1)) continue;
5599
5600             snprintf(tmp_name, sizeof(tmp_name), "vs_in%u", i);
5601             GL_EXTCALL(glBindAttribLocationARB(programId, i, tmp_name));
5602         }
5603         checkGLcall("glBindAttribLocationARB");
5604
5605         list_add_head(&vshader->linked_programs, &entry->vs.shader_entry);
5606     }
5607
5608     if (gshader)
5609     {
5610         TRACE("Attaching GLSL geometry shader object %u to program %u.\n", gs_id, programId);
5611         GL_EXTCALL(glAttachObjectARB(programId, gs_id));
5612         checkGLcall("glAttachObjectARB");
5613
5614         TRACE("input type %s, output type %s, vertices out %u.\n",
5615                 debug_d3dprimitivetype(gshader->u.gs.input_type),
5616                 debug_d3dprimitivetype(gshader->u.gs.output_type),
5617                 gshader->u.gs.vertices_out);
5618         GL_EXTCALL(glProgramParameteriARB(programId, GL_GEOMETRY_INPUT_TYPE_ARB,
5619                 gl_primitive_type_from_d3d(gshader->u.gs.input_type)));
5620         GL_EXTCALL(glProgramParameteriARB(programId, GL_GEOMETRY_OUTPUT_TYPE_ARB,
5621                 gl_primitive_type_from_d3d(gshader->u.gs.output_type)));
5622         GL_EXTCALL(glProgramParameteriARB(programId, GL_GEOMETRY_VERTICES_OUT_ARB,
5623                 gshader->u.gs.vertices_out));
5624         checkGLcall("glProgramParameteriARB");
5625
5626         list_add_head(&gshader->linked_programs, &entry->gs.shader_entry);
5627     }
5628
5629     /* Attach GLSL pshader */
5630     if (ps_id)
5631     {
5632         TRACE("Attaching GLSL shader object %u to program %u.\n", ps_id, programId);
5633         GL_EXTCALL(glAttachObjectARB(programId, ps_id));
5634         checkGLcall("glAttachObjectARB");
5635
5636         list_add_head(ps_list, &entry->ps.shader_entry);
5637     }
5638
5639     /* Link the program */
5640     TRACE("Linking GLSL shader program %u\n", programId);
5641     GL_EXTCALL(glLinkProgramARB(programId));
5642     shader_glsl_validate_link(gl_info, programId);
5643
5644     shader_glsl_init_vs_uniform_locations(gl_info, programId, &entry->vs);
5645     shader_glsl_init_ps_uniform_locations(gl_info, programId, &entry->ps);
5646     checkGLcall("Find glsl program uniform locations");
5647
5648     if (pshader && pshader->reg_maps.shader_version.major >= 3
5649             && pshader->u.ps.declared_in_count > vec4_varyings(3, gl_info))
5650     {
5651         TRACE("Shader %d needs vertex color clamping disabled\n", programId);
5652         entry->vs.vertex_color_clamp = GL_FALSE;
5653     }
5654     else
5655     {
5656         entry->vs.vertex_color_clamp = GL_FIXED_ONLY_ARB;
5657     }
5658
5659     /* Set the shader to allow uniform loading on it */
5660     GL_EXTCALL(glUseProgramObjectARB(programId));
5661     checkGLcall("glUseProgramObjectARB(programId)");
5662
5663     /* Load the vertex and pixel samplers now. The function that finds the mappings makes sure
5664      * that it stays the same for each vertexshader-pixelshader pair(=linked glsl program). If
5665      * a pshader with fixed function pipeline is used there are no vertex samplers, and if a
5666      * vertex shader with fixed function pixel processing is used we make sure that the card
5667      * supports enough samplers to allow the max number of vertex samplers with all possible
5668      * fixed function fragment processing setups. So once the program is linked these samplers
5669      * won't change.
5670      */
5671     shader_glsl_load_vsamplers(gl_info, device->texUnitMap, programId);
5672     shader_glsl_load_psamplers(gl_info, device->texUnitMap, programId);
5673 }
5674
5675 /* Context activation is done by the caller. */
5676 static GLhandleARB create_glsl_blt_shader(const struct wined3d_gl_info *gl_info, enum tex_types tex_type, BOOL masked)
5677 {
5678     GLhandleARB program_id;
5679     GLhandleARB vshader_id, pshader_id;
5680     const char *blt_pshader;
5681
5682     static const char *blt_vshader =
5683         "#version 120\n"
5684         "void main(void)\n"
5685         "{\n"
5686         "    gl_Position = gl_Vertex;\n"
5687         "    gl_FrontColor = vec4(1.0);\n"
5688         "    gl_TexCoord[0] = gl_MultiTexCoord0;\n"
5689         "}\n";
5690
5691     static const char * const blt_pshaders_full[tex_type_count] =
5692     {
5693         /* tex_1d */
5694         NULL,
5695         /* tex_2d */
5696         "#version 120\n"
5697         "uniform sampler2D sampler;\n"
5698         "void main(void)\n"
5699         "{\n"
5700         "    gl_FragDepth = texture2D(sampler, gl_TexCoord[0].xy).x;\n"
5701         "}\n",
5702         /* tex_3d */
5703         NULL,
5704         /* tex_cube */
5705         "#version 120\n"
5706         "uniform samplerCube sampler;\n"
5707         "void main(void)\n"
5708         "{\n"
5709         "    gl_FragDepth = textureCube(sampler, gl_TexCoord[0].xyz).x;\n"
5710         "}\n",
5711         /* tex_rect */
5712         "#version 120\n"
5713         "#extension GL_ARB_texture_rectangle : enable\n"
5714         "uniform sampler2DRect sampler;\n"
5715         "void main(void)\n"
5716         "{\n"
5717         "    gl_FragDepth = texture2DRect(sampler, gl_TexCoord[0].xy).x;\n"
5718         "}\n",
5719     };
5720
5721     static const char * const blt_pshaders_masked[tex_type_count] =
5722     {
5723         /* tex_1d */
5724         NULL,
5725         /* tex_2d */
5726         "#version 120\n"
5727         "uniform sampler2D sampler;\n"
5728         "uniform vec4 mask;\n"
5729         "void main(void)\n"
5730         "{\n"
5731         "    if (all(lessThan(gl_FragCoord.xy, mask.zw))) discard;\n"
5732         "    gl_FragDepth = texture2D(sampler, gl_TexCoord[0].xy).x;\n"
5733         "}\n",
5734         /* tex_3d */
5735         NULL,
5736         /* tex_cube */
5737         "#version 120\n"
5738         "uniform samplerCube sampler;\n"
5739         "uniform vec4 mask;\n"
5740         "void main(void)\n"
5741         "{\n"
5742         "    if (all(lessThan(gl_FragCoord.xy, mask.zw))) discard;\n"
5743         "    gl_FragDepth = textureCube(sampler, gl_TexCoord[0].xyz).x;\n"
5744         "}\n",
5745         /* tex_rect */
5746         "#version 120\n"
5747         "#extension GL_ARB_texture_rectangle : enable\n"
5748         "uniform sampler2DRect sampler;\n"
5749         "uniform vec4 mask;\n"
5750         "void main(void)\n"
5751         "{\n"
5752         "    if (all(lessThan(gl_FragCoord.xy, mask.zw))) discard;\n"
5753         "    gl_FragDepth = texture2DRect(sampler, gl_TexCoord[0].xy).x;\n"
5754         "}\n",
5755     };
5756
5757     blt_pshader = masked ? blt_pshaders_masked[tex_type] : blt_pshaders_full[tex_type];
5758     if (!blt_pshader)
5759     {
5760         FIXME("tex_type %#x not supported\n", tex_type);
5761         return 0;
5762     }
5763
5764     vshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
5765     shader_glsl_compile(gl_info, vshader_id, blt_vshader);
5766
5767     pshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
5768     shader_glsl_compile(gl_info, pshader_id, blt_pshader);
5769
5770     program_id = GL_EXTCALL(glCreateProgramObjectARB());
5771     GL_EXTCALL(glAttachObjectARB(program_id, vshader_id));
5772     GL_EXTCALL(glAttachObjectARB(program_id, pshader_id));
5773     GL_EXTCALL(glLinkProgramARB(program_id));
5774
5775     shader_glsl_validate_link(gl_info, program_id);
5776
5777     /* Once linked we can mark the shaders for deletion. They will be deleted once the program
5778      * is destroyed
5779      */
5780     GL_EXTCALL(glDeleteObjectARB(vshader_id));
5781     GL_EXTCALL(glDeleteObjectARB(pshader_id));
5782     return program_id;
5783 }
5784
5785 /* Context activation is done by the caller. */
5786 static void shader_glsl_select(const struct wined3d_context *context, enum wined3d_shader_mode vertex_mode,
5787         enum wined3d_shader_mode fragment_mode)
5788 {
5789     const struct wined3d_gl_info *gl_info = context->gl_info;
5790     struct wined3d_device *device = context->swapchain->device;
5791     struct shader_glsl_priv *priv = device->shader_priv;
5792     GLhandleARB program_id = 0;
5793     GLenum old_vertex_color_clamp, current_vertex_color_clamp;
5794
5795     old_vertex_color_clamp = priv->glsl_program ? priv->glsl_program->vs.vertex_color_clamp : GL_FIXED_ONLY_ARB;
5796     set_glsl_shader_program(context, device, vertex_mode, fragment_mode);
5797     current_vertex_color_clamp = priv->glsl_program ? priv->glsl_program->vs.vertex_color_clamp : GL_FIXED_ONLY_ARB;
5798     if (old_vertex_color_clamp != current_vertex_color_clamp)
5799     {
5800         if (gl_info->supported[ARB_COLOR_BUFFER_FLOAT])
5801         {
5802             GL_EXTCALL(glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, current_vertex_color_clamp));
5803             checkGLcall("glClampColorARB");
5804         }
5805         else
5806         {
5807             FIXME("vertex color clamp needs to be changed, but extension not supported.\n");
5808         }
5809     }
5810
5811     program_id = priv->glsl_program ? priv->glsl_program->programId : 0;
5812     if (program_id) TRACE("Using GLSL program %u\n", program_id);
5813     GL_EXTCALL(glUseProgramObjectARB(program_id));
5814     checkGLcall("glUseProgramObjectARB");
5815
5816     /* In case that NP2 texcoord fixup data is found for the selected program, trigger a reload of the
5817      * constants. This has to be done because it can't be guaranteed that sampler() (from state.c) is
5818      * called between selecting the shader and using it, which results in wrong fixup for some frames. */
5819     if (priv->glsl_program && priv->glsl_program->ps.np2_fixup_info)
5820     {
5821         shader_glsl_load_np2fixup_constants(priv, gl_info, &device->stateBlock->state);
5822     }
5823 }
5824
5825 /* Context activation is done by the caller. */
5826 static void shader_glsl_select_depth_blt(void *shader_priv, const struct wined3d_gl_info *gl_info,
5827         enum tex_types tex_type, const SIZE *ds_mask_size)
5828 {
5829     BOOL masked = ds_mask_size->cx && ds_mask_size->cy;
5830     struct shader_glsl_priv *priv = shader_priv;
5831     GLhandleARB *blt_program;
5832     GLint loc;
5833
5834     blt_program = masked ? &priv->depth_blt_program_masked[tex_type] : &priv->depth_blt_program_full[tex_type];
5835     if (!*blt_program)
5836     {
5837         *blt_program = create_glsl_blt_shader(gl_info, tex_type, masked);
5838         loc = GL_EXTCALL(glGetUniformLocationARB(*blt_program, "sampler"));
5839         GL_EXTCALL(glUseProgramObjectARB(*blt_program));
5840         GL_EXTCALL(glUniform1iARB(loc, 0));
5841     }
5842     else
5843     {
5844         GL_EXTCALL(glUseProgramObjectARB(*blt_program));
5845     }
5846
5847     if (masked)
5848     {
5849         loc = GL_EXTCALL(glGetUniformLocationARB(*blt_program, "mask"));
5850         GL_EXTCALL(glUniform4fARB(loc, 0.0f, 0.0f, (float)ds_mask_size->cx, (float)ds_mask_size->cy));
5851     }
5852 }
5853
5854 /* Context activation is done by the caller. */
5855 static void shader_glsl_deselect_depth_blt(void *shader_priv, const struct wined3d_gl_info *gl_info)
5856 {
5857     struct shader_glsl_priv *priv = shader_priv;
5858     GLhandleARB program_id;
5859
5860     program_id = priv->glsl_program ? priv->glsl_program->programId : 0;
5861     if (program_id) TRACE("Using GLSL program %u\n", program_id);
5862
5863     GL_EXTCALL(glUseProgramObjectARB(program_id));
5864     checkGLcall("glUseProgramObjectARB");
5865 }
5866
5867 static void shader_glsl_destroy(struct wined3d_shader *shader)
5868 {
5869     struct glsl_shader_private *shader_data = shader->backend_data;
5870     struct wined3d_device *device = shader->device;
5871     struct shader_glsl_priv *priv = device->shader_priv;
5872     const struct wined3d_gl_info *gl_info;
5873     const struct list *linked_programs;
5874     struct wined3d_context *context;
5875
5876     if (!shader_data || !shader_data->num_gl_shaders)
5877     {
5878         HeapFree(GetProcessHeap(), 0, shader_data);
5879         shader->backend_data = NULL;
5880         return;
5881     }
5882
5883     context = context_acquire(device, NULL);
5884     gl_info = context->gl_info;
5885
5886     TRACE("Deleting linked programs.\n");
5887     linked_programs = &shader->linked_programs;
5888     if (linked_programs->next)
5889     {
5890         struct glsl_shader_prog_link *entry, *entry2;
5891         UINT i;
5892
5893         switch (shader->reg_maps.shader_version.type)
5894         {
5895             case WINED3D_SHADER_TYPE_PIXEL:
5896             {
5897                 struct glsl_ps_compiled_shader *gl_shaders = shader_data->gl_shaders.ps;
5898
5899                 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
5900                         struct glsl_shader_prog_link, ps.shader_entry)
5901                 {
5902                     delete_glsl_program_entry(priv, gl_info, entry);
5903                 }
5904
5905                 for (i = 0; i < shader_data->num_gl_shaders; ++i)
5906                 {
5907                     TRACE("Deleting pixel shader %u.\n", gl_shaders[i].prgId);
5908                     if (priv->glsl_program && priv->glsl_program->ps.id == gl_shaders[i].prgId)
5909                         shader_glsl_select(context, WINED3D_SHADER_MODE_NONE, WINED3D_SHADER_MODE_NONE);
5910                     GL_EXTCALL(glDeleteObjectARB(gl_shaders[i].prgId));
5911                     checkGLcall("glDeleteObjectARB");
5912                 }
5913                 HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.ps);
5914
5915                 break;
5916             }
5917
5918             case WINED3D_SHADER_TYPE_VERTEX:
5919             {
5920                 struct glsl_vs_compiled_shader *gl_shaders = shader_data->gl_shaders.vs;
5921
5922                 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
5923                         struct glsl_shader_prog_link, vs.shader_entry)
5924                 {
5925                     delete_glsl_program_entry(priv, gl_info, entry);
5926                 }
5927
5928                 for (i = 0; i < shader_data->num_gl_shaders; ++i)
5929                 {
5930                     TRACE("Deleting vertex shader %u.\n", gl_shaders[i].prgId);
5931                     if (priv->glsl_program && priv->glsl_program->vs.id == gl_shaders[i].prgId)
5932                         shader_glsl_select(context, WINED3D_SHADER_MODE_NONE, WINED3D_SHADER_MODE_NONE);
5933                     GL_EXTCALL(glDeleteObjectARB(gl_shaders[i].prgId));
5934                     checkGLcall("glDeleteObjectARB");
5935                 }
5936                 HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.vs);
5937
5938                 break;
5939             }
5940
5941             case WINED3D_SHADER_TYPE_GEOMETRY:
5942             {
5943                 struct glsl_gs_compiled_shader *gl_shaders = shader_data->gl_shaders.gs;
5944
5945                 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs,
5946                         struct glsl_shader_prog_link, gs.shader_entry)
5947                 {
5948                     delete_glsl_program_entry(priv, gl_info, entry);
5949                 }
5950
5951                 for (i = 0; i < shader_data->num_gl_shaders; ++i)
5952                 {
5953                     TRACE("Deleting geometry shader %u.\n", gl_shaders[i].id);
5954                     if (priv->glsl_program && priv->glsl_program->gs.id == gl_shaders[i].id)
5955                         shader_glsl_select(context, WINED3D_SHADER_MODE_NONE, WINED3D_SHADER_MODE_NONE);
5956                     GL_EXTCALL(glDeleteObjectARB(gl_shaders[i].id));
5957                     checkGLcall("glDeleteObjectARB");
5958                 }
5959                 HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders.gs);
5960
5961                 break;
5962             }
5963
5964             default:
5965                 ERR("Unhandled shader type %#x.\n", shader->reg_maps.shader_version.type);
5966                 break;
5967         }
5968     }
5969
5970     HeapFree(GetProcessHeap(), 0, shader->backend_data);
5971     shader->backend_data = NULL;
5972
5973     context_release(context);
5974 }
5975
5976 static int glsl_program_key_compare(const void *key, const struct wine_rb_entry *entry)
5977 {
5978     const struct glsl_program_key *k = key;
5979     const struct glsl_shader_prog_link *prog = WINE_RB_ENTRY_VALUE(entry,
5980             const struct glsl_shader_prog_link, program_lookup_entry);
5981
5982     if (k->vs_id > prog->vs.id) return 1;
5983     else if (k->vs_id < prog->vs.id) return -1;
5984
5985     if (k->gs_id > prog->gs.id) return 1;
5986     else if (k->gs_id < prog->gs.id) return -1;
5987
5988     if (k->ps_id > prog->ps.id) return 1;
5989     else if (k->ps_id < prog->ps.id) return -1;
5990
5991     return 0;
5992 }
5993
5994 static BOOL constant_heap_init(struct constant_heap *heap, unsigned int constant_count)
5995 {
5996     SIZE_T size = (constant_count + 1) * sizeof(*heap->entries) + constant_count * sizeof(*heap->positions);
5997     void *mem = HeapAlloc(GetProcessHeap(), 0, size);
5998
5999     if (!mem)
6000     {
6001         ERR("Failed to allocate memory\n");
6002         return FALSE;
6003     }
6004
6005     heap->entries = mem;
6006     heap->entries[1].version = 0;
6007     heap->positions = (unsigned int *)(heap->entries + constant_count + 1);
6008     heap->size = 1;
6009
6010     return TRUE;
6011 }
6012
6013 static void constant_heap_free(struct constant_heap *heap)
6014 {
6015     HeapFree(GetProcessHeap(), 0, heap->entries);
6016 }
6017
6018 static const struct wine_rb_functions wined3d_glsl_program_rb_functions =
6019 {
6020     wined3d_rb_alloc,
6021     wined3d_rb_realloc,
6022     wined3d_rb_free,
6023     glsl_program_key_compare,
6024 };
6025
6026 static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct fragment_pipeline *fragment_pipe)
6027 {
6028     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
6029     struct shader_glsl_priv *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct shader_glsl_priv));
6030     SIZE_T stack_size = wined3d_log2i(max(gl_info->limits.glsl_vs_float_constants,
6031             gl_info->limits.glsl_ps_float_constants)) + 1;
6032     struct fragment_caps fragment_caps;
6033     void *fragment_priv;
6034
6035     if (!(fragment_priv = fragment_pipe->alloc_private(&glsl_shader_backend, priv)))
6036     {
6037         ERR("Failed to initialize fragment pipe.\n");
6038         HeapFree(GetProcessHeap(), 0, priv);
6039         return E_FAIL;
6040     }
6041
6042     if (!shader_buffer_init(&priv->shader_buffer))
6043     {
6044         ERR("Failed to initialize shader buffer.\n");
6045         goto fail;
6046     }
6047
6048     priv->stack = HeapAlloc(GetProcessHeap(), 0, stack_size * sizeof(*priv->stack));
6049     if (!priv->stack)
6050     {
6051         ERR("Failed to allocate memory.\n");
6052         goto fail;
6053     }
6054
6055     if (!constant_heap_init(&priv->vconst_heap, gl_info->limits.glsl_vs_float_constants))
6056     {
6057         ERR("Failed to initialize vertex shader constant heap\n");
6058         goto fail;
6059     }
6060
6061     if (!constant_heap_init(&priv->pconst_heap, gl_info->limits.glsl_ps_float_constants))
6062     {
6063         ERR("Failed to initialize pixel shader constant heap\n");
6064         goto fail;
6065     }
6066
6067     if (wine_rb_init(&priv->program_lookup, &wined3d_glsl_program_rb_functions) == -1)
6068     {
6069         ERR("Failed to initialize rbtree.\n");
6070         goto fail;
6071     }
6072
6073     priv->next_constant_version = 1;
6074     fragment_pipe->get_caps(gl_info, &fragment_caps);
6075     priv->ffp_proj_control = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_PROJ_CONTROL;
6076     device->fragment_priv = fragment_priv;
6077     priv->fragment_pipe = fragment_pipe;
6078
6079     device->shader_priv = priv;
6080     return WINED3D_OK;
6081
6082 fail:
6083     constant_heap_free(&priv->pconst_heap);
6084     constant_heap_free(&priv->vconst_heap);
6085     HeapFree(GetProcessHeap(), 0, priv->stack);
6086     shader_buffer_free(&priv->shader_buffer);
6087     fragment_pipe->free_private(device);
6088     HeapFree(GetProcessHeap(), 0, priv);
6089     return E_OUTOFMEMORY;
6090 }
6091
6092 /* Context activation is done by the caller. */
6093 static void shader_glsl_free(struct wined3d_device *device)
6094 {
6095     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
6096     struct shader_glsl_priv *priv = device->shader_priv;
6097     int i;
6098
6099     for (i = 0; i < tex_type_count; ++i)
6100     {
6101         if (priv->depth_blt_program_full[i])
6102         {
6103             GL_EXTCALL(glDeleteObjectARB(priv->depth_blt_program_full[i]));
6104         }
6105         if (priv->depth_blt_program_masked[i])
6106         {
6107             GL_EXTCALL(glDeleteObjectARB(priv->depth_blt_program_masked[i]));
6108         }
6109     }
6110
6111     wine_rb_destroy(&priv->program_lookup, NULL, NULL);
6112     constant_heap_free(&priv->pconst_heap);
6113     constant_heap_free(&priv->vconst_heap);
6114     HeapFree(GetProcessHeap(), 0, priv->stack);
6115     shader_buffer_free(&priv->shader_buffer);
6116     priv->fragment_pipe->free_private(device);
6117
6118     HeapFree(GetProcessHeap(), 0, device->shader_priv);
6119     device->shader_priv = NULL;
6120 }
6121
6122 static void shader_glsl_context_destroyed(void *shader_priv, const struct wined3d_context *context) {}
6123
6124 static void shader_glsl_get_caps(const struct wined3d_gl_info *gl_info, struct shader_caps *caps)
6125 {
6126     UINT shader_model;
6127
6128     if (gl_info->supported[EXT_GPU_SHADER4] && gl_info->supported[ARB_SHADER_BIT_ENCODING]
6129             && gl_info->supported[ARB_GEOMETRY_SHADER4] && gl_info->glsl_version >= MAKEDWORD_VERSION(1, 50)
6130             && gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX] && gl_info->supported[ARB_DRAW_INSTANCED])
6131         shader_model = 4;
6132     /* ARB_shader_texture_lod or EXT_gpu_shader4 is required for the SM3
6133      * texldd and texldl instructions. */
6134     else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD] || gl_info->supported[EXT_GPU_SHADER4])
6135         shader_model = 3;
6136     else
6137         shader_model = 2;
6138     TRACE("Shader model %u.\n", shader_model);
6139
6140     caps->vs_version = min(wined3d_settings.max_sm_vs, shader_model);
6141     caps->gs_version = min(wined3d_settings.max_sm_gs, shader_model);
6142     caps->ps_version = min(wined3d_settings.max_sm_ps, shader_model);
6143
6144     caps->vs_uniform_count = gl_info->limits.glsl_vs_float_constants;
6145     caps->ps_uniform_count = gl_info->limits.glsl_ps_float_constants;
6146
6147     /* FIXME: The following line is card dependent. -8.0 to 8.0 is the
6148      * Direct3D minimum requirement.
6149      *
6150      * Both GL_ARB_fragment_program and GLSL require a "maximum representable magnitude"
6151      * of colors to be 2^10, and 2^32 for other floats. Should we use 1024 here?
6152      *
6153      * The problem is that the refrast clamps temporary results in the shader to
6154      * [-MaxValue;+MaxValue]. If the card's max value is bigger than the one we advertize here,
6155      * then applications may miss the clamping behavior. On the other hand, if it is smaller,
6156      * the shader will generate incorrect results too. Unfortunately, GL deliberately doesn't
6157      * offer a way to query this.
6158      */
6159     caps->ps_1x_max_value = 8.0;
6160
6161     /* Ideally we'd only set caps like sRGB writes here if supported by both
6162      * the shader backend and the fragment pipe, but we can get called before
6163      * shader_glsl_alloc(). */
6164     caps->wined3d_caps = WINED3D_SHADER_CAP_VS_CLIPPING
6165             | WINED3D_SHADER_CAP_SRGB_WRITE;
6166 }
6167
6168 static BOOL shader_glsl_color_fixup_supported(struct color_fixup_desc fixup)
6169 {
6170     if (TRACE_ON(d3d_shader) && TRACE_ON(d3d))
6171     {
6172         TRACE("Checking support for fixup:\n");
6173         dump_color_fixup_desc(fixup);
6174     }
6175
6176     /* We support everything except YUV conversions. */
6177     if (!is_complex_fixup(fixup))
6178     {
6179         TRACE("[OK]\n");
6180         return TRUE;
6181     }
6182
6183     TRACE("[FAILED]\n");
6184     return FALSE;
6185 }
6186
6187 static const SHADER_HANDLER shader_glsl_instruction_handler_table[WINED3DSIH_TABLE_SIZE] =
6188 {
6189     /* WINED3DSIH_ABS                   */ shader_glsl_map2gl,
6190     /* WINED3DSIH_ADD                   */ shader_glsl_binop,
6191     /* WINED3DSIH_AND                   */ shader_glsl_binop,
6192     /* WINED3DSIH_BEM                   */ shader_glsl_bem,
6193     /* WINED3DSIH_BREAK                 */ shader_glsl_break,
6194     /* WINED3DSIH_BREAKC                */ shader_glsl_breakc,
6195     /* WINED3DSIH_BREAKP                */ shader_glsl_breakp,
6196     /* WINED3DSIH_CALL                  */ shader_glsl_call,
6197     /* WINED3DSIH_CALLNZ                */ shader_glsl_callnz,
6198     /* WINED3DSIH_CMP                   */ shader_glsl_conditional_move,
6199     /* WINED3DSIH_CND                   */ shader_glsl_cnd,
6200     /* WINED3DSIH_CRS                   */ shader_glsl_cross,
6201     /* WINED3DSIH_CUT                   */ shader_glsl_cut,
6202     /* WINED3DSIH_DCL                   */ shader_glsl_nop,
6203     /* WINED3DSIH_DCL_CONSTANT_BUFFER   */ shader_glsl_nop,
6204     /* WINED3DSIH_DCL_INPUT_PRIMITIVE   */ shader_glsl_nop,
6205     /* WINED3DSIH_DCL_OUTPUT_TOPOLOGY   */ shader_glsl_nop,
6206     /* WINED3DSIH_DCL_VERTICES_OUT      */ shader_glsl_nop,
6207     /* WINED3DSIH_DEF                   */ shader_glsl_nop,
6208     /* WINED3DSIH_DEFB                  */ shader_glsl_nop,
6209     /* WINED3DSIH_DEFI                  */ shader_glsl_nop,
6210     /* WINED3DSIH_DIV                   */ shader_glsl_binop,
6211     /* WINED3DSIH_DP2ADD                */ shader_glsl_dp2add,
6212     /* WINED3DSIH_DP3                   */ shader_glsl_dot,
6213     /* WINED3DSIH_DP4                   */ shader_glsl_dot,
6214     /* WINED3DSIH_DST                   */ shader_glsl_dst,
6215     /* WINED3DSIH_DSX                   */ shader_glsl_map2gl,
6216     /* WINED3DSIH_DSY                   */ shader_glsl_map2gl,
6217     /* WINED3DSIH_ELSE                  */ shader_glsl_else,
6218     /* WINED3DSIH_EMIT                  */ shader_glsl_emit,
6219     /* WINED3DSIH_ENDIF                 */ shader_glsl_end,
6220     /* WINED3DSIH_ENDLOOP               */ shader_glsl_end,
6221     /* WINED3DSIH_ENDREP                */ shader_glsl_end,
6222     /* WINED3DSIH_EQ                    */ shader_glsl_relop,
6223     /* WINED3DSIH_EXP                   */ shader_glsl_map2gl,
6224     /* WINED3DSIH_EXPP                  */ shader_glsl_expp,
6225     /* WINED3DSIH_FRC                   */ shader_glsl_map2gl,
6226     /* WINED3DSIH_FTOI                  */ shader_glsl_to_int,
6227     /* WINED3DSIH_GE                    */ shader_glsl_relop,
6228     /* WINED3DSIH_IADD                  */ shader_glsl_binop,
6229     /* WINED3DSIH_IEQ                   */ NULL,
6230     /* WINED3DSIH_IF                    */ shader_glsl_if,
6231     /* WINED3DSIH_IFC                   */ shader_glsl_ifc,
6232     /* WINED3DSIH_IGE                   */ shader_glsl_relop,
6233     /* WINED3DSIH_IMUL                  */ shader_glsl_imul,
6234     /* WINED3DSIH_ITOF                  */ shader_glsl_to_float,
6235     /* WINED3DSIH_LABEL                 */ shader_glsl_label,
6236     /* WINED3DSIH_LD                    */ NULL,
6237     /* WINED3DSIH_LIT                   */ shader_glsl_lit,
6238     /* WINED3DSIH_LOG                   */ shader_glsl_log,
6239     /* WINED3DSIH_LOGP                  */ shader_glsl_log,
6240     /* WINED3DSIH_LOOP                  */ shader_glsl_loop,
6241     /* WINED3DSIH_LRP                   */ shader_glsl_lrp,
6242     /* WINED3DSIH_LT                    */ shader_glsl_relop,
6243     /* WINED3DSIH_M3x2                  */ shader_glsl_mnxn,
6244     /* WINED3DSIH_M3x3                  */ shader_glsl_mnxn,
6245     /* WINED3DSIH_M3x4                  */ shader_glsl_mnxn,
6246     /* WINED3DSIH_M4x3                  */ shader_glsl_mnxn,
6247     /* WINED3DSIH_M4x4                  */ shader_glsl_mnxn,
6248     /* WINED3DSIH_MAD                   */ shader_glsl_mad,
6249     /* WINED3DSIH_MAX                   */ shader_glsl_map2gl,
6250     /* WINED3DSIH_MIN                   */ shader_glsl_map2gl,
6251     /* WINED3DSIH_MOV                   */ shader_glsl_mov,
6252     /* WINED3DSIH_MOVA                  */ shader_glsl_mov,
6253     /* WINED3DSIH_MOVC                  */ shader_glsl_conditional_move,
6254     /* WINED3DSIH_MUL                   */ shader_glsl_binop,
6255     /* WINED3DSIH_NOP                   */ shader_glsl_nop,
6256     /* WINED3DSIH_NRM                   */ shader_glsl_nrm,
6257     /* WINED3DSIH_PHASE                 */ shader_glsl_nop,
6258     /* WINED3DSIH_POW                   */ shader_glsl_pow,
6259     /* WINED3DSIH_RCP                   */ shader_glsl_rcp,
6260     /* WINED3DSIH_REP                   */ shader_glsl_rep,
6261     /* WINED3DSIH_RET                   */ shader_glsl_ret,
6262     /* WINED3DSIH_ROUND_NI              */ shader_glsl_map2gl,
6263     /* WINED3DSIH_RSQ                   */ shader_glsl_rsq,
6264     /* WINED3DSIH_SAMPLE                */ NULL,
6265     /* WINED3DSIH_SAMPLE_GRAD           */ NULL,
6266     /* WINED3DSIH_SAMPLE_LOD            */ NULL,
6267     /* WINED3DSIH_SETP                  */ NULL,
6268     /* WINED3DSIH_SGE                   */ shader_glsl_compare,
6269     /* WINED3DSIH_SGN                   */ shader_glsl_sgn,
6270     /* WINED3DSIH_SINCOS                */ shader_glsl_sincos,
6271     /* WINED3DSIH_SLT                   */ shader_glsl_compare,
6272     /* WINED3DSIH_SQRT                  */ NULL,
6273     /* WINED3DSIH_SUB                   */ shader_glsl_binop,
6274     /* WINED3DSIH_TEX                   */ shader_glsl_tex,
6275     /* WINED3DSIH_TEXBEM                */ shader_glsl_texbem,
6276     /* WINED3DSIH_TEXBEML               */ shader_glsl_texbem,
6277     /* WINED3DSIH_TEXCOORD              */ shader_glsl_texcoord,
6278     /* WINED3DSIH_TEXDEPTH              */ shader_glsl_texdepth,
6279     /* WINED3DSIH_TEXDP3                */ shader_glsl_texdp3,
6280     /* WINED3DSIH_TEXDP3TEX             */ shader_glsl_texdp3tex,
6281     /* WINED3DSIH_TEXKILL               */ shader_glsl_texkill,
6282     /* WINED3DSIH_TEXLDD                */ shader_glsl_texldd,
6283     /* WINED3DSIH_TEXLDL                */ shader_glsl_texldl,
6284     /* WINED3DSIH_TEXM3x2DEPTH          */ shader_glsl_texm3x2depth,
6285     /* WINED3DSIH_TEXM3x2PAD            */ shader_glsl_texm3x2pad,
6286     /* WINED3DSIH_TEXM3x2TEX            */ shader_glsl_texm3x2tex,
6287     /* WINED3DSIH_TEXM3x3               */ shader_glsl_texm3x3,
6288     /* WINED3DSIH_TEXM3x3DIFF           */ NULL,
6289     /* WINED3DSIH_TEXM3x3PAD            */ shader_glsl_texm3x3pad,
6290     /* WINED3DSIH_TEXM3x3SPEC           */ shader_glsl_texm3x3spec,
6291     /* WINED3DSIH_TEXM3x3TEX            */ shader_glsl_texm3x3tex,
6292     /* WINED3DSIH_TEXM3x3VSPEC          */ shader_glsl_texm3x3vspec,
6293     /* WINED3DSIH_TEXREG2AR             */ shader_glsl_texreg2ar,
6294     /* WINED3DSIH_TEXREG2GB             */ shader_glsl_texreg2gb,
6295     /* WINED3DSIH_TEXREG2RGB            */ shader_glsl_texreg2rgb,
6296     /* WINED3DSIH_UDIV                  */ shader_glsl_udiv,
6297     /* WINED3DSIH_USHR                  */ shader_glsl_binop,
6298     /* WINED3DSIH_UTOF                  */ shader_glsl_to_float,
6299     /* WINED3DSIH_XOR                   */ shader_glsl_binop,
6300 };
6301
6302 static void shader_glsl_handle_instruction(const struct wined3d_shader_instruction *ins) {
6303     SHADER_HANDLER hw_fct;
6304
6305     /* Select handler */
6306     hw_fct = shader_glsl_instruction_handler_table[ins->handler_idx];
6307
6308     /* Unhandled opcode */
6309     if (!hw_fct)
6310     {
6311         FIXME("Backend can't handle opcode %#x\n", ins->handler_idx);
6312         return;
6313     }
6314     hw_fct(ins);
6315
6316     shader_glsl_add_instruction_modifiers(ins);
6317 }
6318
6319 static BOOL shader_glsl_has_ffp_proj_control(void *shader_priv)
6320 {
6321     struct shader_glsl_priv *priv = shader_priv;
6322
6323     return priv->ffp_proj_control;
6324 }
6325
6326 const struct wined3d_shader_backend_ops glsl_shader_backend =
6327 {
6328     shader_glsl_handle_instruction,
6329     shader_glsl_select,
6330     shader_glsl_select_depth_blt,
6331     shader_glsl_deselect_depth_blt,
6332     shader_glsl_update_float_vertex_constants,
6333     shader_glsl_update_float_pixel_constants,
6334     shader_glsl_load_constants,
6335     shader_glsl_load_np2fixup_constants,
6336     shader_glsl_destroy,
6337     shader_glsl_alloc,
6338     shader_glsl_free,
6339     shader_glsl_context_destroyed,
6340     shader_glsl_get_caps,
6341     shader_glsl_color_fixup_supported,
6342     shader_glsl_has_ffp_proj_control,
6343 };
6344
6345 static void glsl_fragment_pipe_enable(const struct wined3d_gl_info *gl_info, BOOL enable)
6346 {
6347     /* Nothing to do. */
6348 }
6349
6350 static void glsl_fragment_pipe_get_caps(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps)
6351 {
6352     caps->wined3d_caps = WINED3D_FRAGMENT_CAP_PROJ_CONTROL
6353             | WINED3D_FRAGMENT_CAP_SRGB_WRITE;
6354     caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_TSSARGTEMP;
6355     caps->TextureOpCaps = WINED3DTEXOPCAPS_DISABLE
6356             | WINED3DTEXOPCAPS_SELECTARG1
6357             | WINED3DTEXOPCAPS_SELECTARG2
6358             | WINED3DTEXOPCAPS_MODULATE4X
6359             | WINED3DTEXOPCAPS_MODULATE2X
6360             | WINED3DTEXOPCAPS_MODULATE
6361             | WINED3DTEXOPCAPS_ADDSIGNED2X
6362             | WINED3DTEXOPCAPS_ADDSIGNED
6363             | WINED3DTEXOPCAPS_ADD
6364             | WINED3DTEXOPCAPS_SUBTRACT
6365             | WINED3DTEXOPCAPS_ADDSMOOTH
6366             | WINED3DTEXOPCAPS_BLENDCURRENTALPHA
6367             | WINED3DTEXOPCAPS_BLENDFACTORALPHA
6368             | WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
6369             | WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
6370             | WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
6371             | WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
6372             | WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
6373             | WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA
6374             | WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
6375             | WINED3DTEXOPCAPS_DOTPRODUCT3
6376             | WINED3DTEXOPCAPS_MULTIPLYADD
6377             | WINED3DTEXOPCAPS_LERP
6378             | WINED3DTEXOPCAPS_BUMPENVMAP
6379             | WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE;
6380     caps->MaxTextureBlendStages = 8;
6381     caps->MaxSimultaneousTextures = min(gl_info->limits.fragment_samplers, 8);
6382 }
6383
6384 static void *glsl_fragment_pipe_alloc(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv)
6385 {
6386     struct shader_glsl_priv *priv;
6387
6388     if (shader_backend == &glsl_shader_backend)
6389     {
6390         priv = shader_priv;
6391
6392         if (wine_rb_init(&priv->ffp_fragment_shaders, &wined3d_ffp_frag_program_rb_functions) == -1)
6393         {
6394             ERR("Failed to initialize rbtree.\n");
6395             return NULL;
6396         }
6397
6398         return priv;
6399     }
6400
6401     FIXME("GLSL fragment pipe without GLSL shader backend not implemented.\n");
6402
6403     return NULL;
6404 }
6405
6406 struct glsl_ffp_destroy_ctx
6407 {
6408     struct shader_glsl_priv *priv;
6409     const struct wined3d_gl_info *gl_info;
6410 };
6411
6412 static void shader_glsl_free_ffp_fragment_shader(struct wine_rb_entry *entry, void *context)
6413 {
6414     struct glsl_ffp_fragment_shader *shader = WINE_RB_ENTRY_VALUE(entry,
6415             struct glsl_ffp_fragment_shader, entry.entry);
6416     struct glsl_shader_prog_link *program, *program2;
6417     struct glsl_ffp_destroy_ctx *ctx = context;
6418
6419     LIST_FOR_EACH_ENTRY_SAFE(program, program2, &shader->linked_programs,
6420             struct glsl_shader_prog_link, ps.shader_entry)
6421     {
6422         delete_glsl_program_entry(ctx->priv, ctx->gl_info, program);
6423     }
6424     ctx->gl_info->gl_ops.ext.p_glDeleteObjectARB(shader->id);
6425     HeapFree(GetProcessHeap(), 0, shader);
6426 }
6427
6428 /* Context activation is done by the caller. */
6429 static void glsl_fragment_pipe_free(struct wined3d_device *device)
6430 {
6431     struct shader_glsl_priv *priv = device->fragment_priv;
6432     struct glsl_ffp_destroy_ctx ctx;
6433
6434     ctx.priv = priv;
6435     ctx.gl_info = &device->adapter->gl_info;
6436     wine_rb_destroy(&priv->ffp_fragment_shaders, shader_glsl_free_ffp_fragment_shader, &ctx);
6437 }
6438
6439 static void glsl_fragment_pipe_shader(struct wined3d_context *context,
6440         const struct wined3d_state *state, DWORD state_id)
6441 {
6442     context->last_was_pshader = use_ps(state);
6443
6444     context->select_shader = 1;
6445     context->load_constants = 1;
6446 }
6447
6448 static void glsl_fragment_pipe_fog(struct wined3d_context *context,
6449         const struct wined3d_state *state, DWORD state_id)
6450 {
6451     BOOL use_vshader = use_vs(state);
6452     enum fogsource new_source;
6453
6454     context->select_shader = 1;
6455     context->load_constants = 1;
6456
6457     if (!state->render_states[WINED3D_RS_FOGENABLE])
6458         return;
6459
6460     if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3D_FOG_NONE)
6461     {
6462         if (use_vshader)
6463             new_source = FOGSOURCE_VS;
6464         else if (state->render_states[WINED3D_RS_FOGVERTEXMODE] == WINED3D_FOG_NONE || context->last_was_rhw)
6465             new_source = FOGSOURCE_COORD;
6466         else
6467             new_source = FOGSOURCE_FFP;
6468     }
6469     else
6470     {
6471         new_source = FOGSOURCE_FFP;
6472     }
6473
6474     if (new_source != context->fog_source)
6475     {
6476         context->fog_source = new_source;
6477         state_fogstartend(context, state, STATE_RENDER(WINED3D_RS_FOGSTART));
6478     }
6479 }
6480
6481 static void glsl_fragment_pipe_tex_transform(struct wined3d_context *context,
6482         const struct wined3d_state *state, DWORD state_id)
6483 {
6484     context->select_shader = 1;
6485     context->load_constants = 1;
6486 }
6487
6488 static void glsl_fragment_pipe_invalidate_constants(struct wined3d_context *context,
6489         const struct wined3d_state *state, DWORD state_id)
6490 {
6491     context->load_constants = 1;
6492 }
6493
6494 static const struct StateEntryTemplate glsl_fragment_pipe_state_template[] =
6495 {
6496     {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR),                    {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR),                     glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6497     {STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6498     {STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6499     {STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6500     {STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6501     {STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6502     {STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6503     {STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6504     {STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6505     {STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6506     {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00),          {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00),           glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6507     {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01),          {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6508     {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10),          {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6509     {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11),          {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6510     {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE),         {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE),          glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6511     {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LOFFSET),        {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE),          NULL                                   }, WINED3D_GL_EXT_NONE },
6512     {STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6513     {STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6514     {STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6515     {STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6516     {STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6517     {STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6518     {STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6519     {STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6520     {STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6521     {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00),          {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00),           glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6522     {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01),          {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6523     {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10),          {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6524     {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11),          {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6525     {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE),         {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE),          glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6526     {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LOFFSET),        {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE),          NULL                                   }, WINED3D_GL_EXT_NONE },
6527     {STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6528     {STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6529     {STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6530     {STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6531     {STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6532     {STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6533     {STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6534     {STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6535     {STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6536     {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00),          {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00),           glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6537     {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01),          {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6538     {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10),          {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6539     {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11),          {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6540     {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE),         {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE),          glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6541     {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LOFFSET),        {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE),          NULL                                   }, WINED3D_GL_EXT_NONE },
6542     {STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6543     {STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6544     {STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6545     {STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6546     {STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6547     {STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6548     {STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6549     {STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6550     {STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6551     {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00),          {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00),           glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6552     {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01),          {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6553     {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10),          {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6554     {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11),          {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6555     {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE),         {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE),          glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6556     {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LOFFSET),        {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE),          NULL                                   }, WINED3D_GL_EXT_NONE },
6557     {STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6558     {STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6559     {STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6560     {STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6561     {STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6562     {STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6563     {STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6564     {STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6565     {STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6566     {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00),          {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00),           glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6567     {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01),          {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6568     {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10),          {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6569     {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11),          {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6570     {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE),         {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE),          glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6571     {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LOFFSET),        {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE),          NULL                                   }, WINED3D_GL_EXT_NONE },
6572     {STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6573     {STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6574     {STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6575     {STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6576     {STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6577     {STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6578     {STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6579     {STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6580     {STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6581     {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00),          {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00),           glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6582     {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01),          {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6583     {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10),          {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6584     {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11),          {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6585     {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE),         {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE),          glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6586     {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LOFFSET),        {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE),          NULL                                   }, WINED3D_GL_EXT_NONE },
6587     {STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6588     {STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6589     {STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6590     {STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6591     {STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6592     {STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6593     {STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6594     {STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6595     {STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6596     {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00),          {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00),           glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6597     {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01),          {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6598     {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10),          {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6599     {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11),          {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6600     {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE),         {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE),          glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6601     {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LOFFSET),        {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE),          NULL                                   }, WINED3D_GL_EXT_NONE },
6602     {STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6603     {STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6604     {STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6605     {STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6606     {STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP),               {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6607     {STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG1),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6608     {STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG2),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6609     {STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG0),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6610     {STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG),             {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6611     {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00),          {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00),           glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6612     {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01),          {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6613     {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10),          {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6614     {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11),          {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00),           NULL                                   }, WINED3D_GL_EXT_NONE },
6615     {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE),         {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE),          glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6616     {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LOFFSET),        {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE),          NULL                                   }, WINED3D_GL_EXT_NONE },
6617     {STATE_PIXELSHADER,                                         {STATE_PIXELSHADER,                                          glsl_fragment_pipe_shader              }, WINED3D_GL_EXT_NONE },
6618     {STATE_RENDER(WINED3D_RS_FOGENABLE),                        {STATE_RENDER(WINED3D_RS_FOGENABLE),                         glsl_fragment_pipe_fog                 }, WINED3D_GL_EXT_NONE },
6619     {STATE_RENDER(WINED3D_RS_FOGTABLEMODE),                     {STATE_RENDER(WINED3D_RS_FOGENABLE),                         NULL                                   }, WINED3D_GL_EXT_NONE },
6620     {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE),                    {STATE_RENDER(WINED3D_RS_FOGENABLE),                         NULL                                   }, WINED3D_GL_EXT_NONE },
6621     {STATE_RENDER(WINED3D_RS_FOGSTART),                         {STATE_RENDER(WINED3D_RS_FOGSTART),                          state_fogstartend                      }, WINED3D_GL_EXT_NONE },
6622     {STATE_RENDER(WINED3D_RS_FOGEND),                           {STATE_RENDER(WINED3D_RS_FOGSTART),                          NULL                                   }, WINED3D_GL_EXT_NONE },
6623     {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE),                  {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE),                   state_srgbwrite                        }, ARB_FRAMEBUFFER_SRGB},
6624     {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE),                  {STATE_PIXELSHADER,                                          NULL                                   }, WINED3D_GL_EXT_NONE },
6625     {STATE_RENDER(WINED3D_RS_FOGCOLOR),                         {STATE_RENDER(WINED3D_RS_FOGCOLOR),                          state_fogcolor                         }, WINED3D_GL_EXT_NONE },
6626     {STATE_RENDER(WINED3D_RS_FOGDENSITY),                       {STATE_RENDER(WINED3D_RS_FOGDENSITY),                        state_fogdensity                       }, WINED3D_GL_EXT_NONE },
6627     {STATE_TEXTURESTAGE(0,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_fragment_pipe_tex_transform       }, WINED3D_GL_EXT_NONE },
6628     {STATE_TEXTURESTAGE(1,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_fragment_pipe_tex_transform       }, WINED3D_GL_EXT_NONE },
6629     {STATE_TEXTURESTAGE(2,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_fragment_pipe_tex_transform       }, WINED3D_GL_EXT_NONE },
6630     {STATE_TEXTURESTAGE(3,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_fragment_pipe_tex_transform       }, WINED3D_GL_EXT_NONE },
6631     {STATE_TEXTURESTAGE(4,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_fragment_pipe_tex_transform       }, WINED3D_GL_EXT_NONE },
6632     {STATE_TEXTURESTAGE(5,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_fragment_pipe_tex_transform       }, WINED3D_GL_EXT_NONE },
6633     {STATE_TEXTURESTAGE(6,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_fragment_pipe_tex_transform       }, WINED3D_GL_EXT_NONE },
6634     {STATE_TEXTURESTAGE(7,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_fragment_pipe_tex_transform       }, WINED3D_GL_EXT_NONE },
6635     {STATE_RENDER(WINED3D_RS_SPECULARENABLE),                   {STATE_RENDER(WINED3D_RS_SPECULARENABLE),                    glsl_fragment_pipe_invalidate_constants}, WINED3D_GL_EXT_NONE },
6636     {0 /* Terminate */,                                         {0,                                                          0                                      }, WINED3D_GL_EXT_NONE },
6637 };
6638
6639 const struct fragment_pipeline glsl_fragment_pipe =
6640 {
6641     glsl_fragment_pipe_enable,
6642     glsl_fragment_pipe_get_caps,
6643     glsl_fragment_pipe_alloc,
6644     glsl_fragment_pipe_free,
6645     shader_glsl_color_fixup_supported,
6646     glsl_fragment_pipe_state_template,
6647 };