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

   1 /*
   2  * GLSL pixel and vertex shader implementation
   3  *
   4  * Copyright 2006 Jason Green
   5  * Copyright 2006-2007 Henri Verbeet
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /*
  23  * D3D shader asm has swizzles on source parameters, and write masks for
  24  * destination parameters. GLSL uses swizzles for both. The result of this is
  25  * that for example "mov dst.xw, src.zyxw" becomes "dst.xw = src.zw" in GLSL.
  26  * Ie, to generate a proper GLSL source swizzle, we need to take the D3D write
  27  * mask for the destination parameter into account.
  28  */
  29
  30 #include "config.h"
  31 #include <stdio.h>
  32 #include "wined3d_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  35
  36 #define GLINFO_LOCATION      (*gl_info)
  37
  38 /** Prints the GLSL info log which will contain error messages if they exist */
  39 void print_glsl_info_log(WineD3D_GL_Info *gl_info, GLhandleARB obj) {
  40
  41     int infologLength = 0;
  42     char *infoLog;
  43
  44     GL_EXTCALL(glGetObjectParameterivARB(obj,
  45                GL_OBJECT_INFO_LOG_LENGTH_ARB,
  46                &infologLength));
  47
  48     /* A size of 1 is just a null-terminated string, so the log should be bigger than
  49      * that if there are errors. */
  50     if (infologLength > 1)
  51     {
  52         infoLog = (char *)HeapAlloc(GetProcessHeap(), 0, infologLength);
  53         GL_EXTCALL(glGetInfoLogARB(obj, infologLength, NULL, infoLog));
  54         FIXME("Error received from GLSL shader #%u: %s\n", obj, debugstr_a(infoLog));
  55         HeapFree(GetProcessHeap(), 0, infoLog);
  56     }
  57 }
  58
  59 /**
  60  * Loads (pixel shader) samplers
  61  */
  62 void shader_glsl_load_psamplers(
  63     WineD3D_GL_Info *gl_info,
  64     IWineD3DStateBlock* iface) {
  65
  66     IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
  67     GLhandleARB programId = stateBlock->glsl_program->programId;
  68     GLhandleARB name_loc;
  69     int i;
  70     char sampler_name[20];
  71
  72     for (i=0; i< GL_LIMITS(samplers); ++i) {
  73         if (stateBlock->textures[i] != NULL) {
  74            snprintf(sampler_name, sizeof(sampler_name), "Psampler%d", i);
  75            name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
  76            if (name_loc != -1) {
  77                TRACE("Loading %s for texture %d\n", sampler_name, i);
  78                GL_EXTCALL(glUniform1iARB(name_loc, i));
  79                checkGLcall("glUniform1iARB");
  80            }
  81         }
  82     }
  83 }
  84
  85 /**
  86  * Loads floating point constants (aka uniforms) into the currently set GLSL program.
  87  * When constant_list == NULL, it will load all the constants.
  88  */
  89 static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL_Info *gl_info,
  90         unsigned int max_constants, float* constants, GLhandleARB *constant_locations,
  91         struct list *constant_list) {
  92     local_constant* lconst;
  93     GLhandleARB tmp_loc;
  94     int i;
  95
  96     if (!constant_list) {
  97         if (TRACE_ON(d3d_shader)) {
  98             for (i = 0; i < max_constants; ++i) {
  99                 tmp_loc = constant_locations[i];
 100                 if (tmp_loc != -1) {
 101                     TRACE("Loading constants %i: %f, %f, %f, %f\n", i,
 102                             constants[i * 4 + 0], constants[i * 4 + 1],
 103                             constants[i * 4 + 2], constants[i * 4 + 3]);
 104                 }
 105             }
 106         }
 107         for (i = 0; i < max_constants; ++i) {
 108             tmp_loc = constant_locations[i];
 109             if (tmp_loc != -1) {
 110                 /* We found this uniform name in the program - go ahead and send the data */
 111                 GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, constants + (i * 4)));
 112             }
 113         }
 114         checkGLcall("glUniform4fvARB()");
 115     } else {
 116         constant_entry *constant;
 117         if (TRACE_ON(d3d_shader)) {
 118             LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) {
 119                 i = constant->idx;
 120                 tmp_loc = constant_locations[i];
 121                 if (tmp_loc != -1) {
 122                     TRACE("Loading constants %i: %f, %f, %f, %f\n", i,
 123                             constants[i * 4 + 0], constants[i * 4 + 1],
 124                             constants[i * 4 + 2], constants[i * 4 + 3]);
 125                 }
 126             }
 127         }
 128         LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) {
 129             i = constant->idx;
 130             tmp_loc = constant_locations[i];
 131             if (tmp_loc != -1) {
 132                 /* We found this uniform name in the program - go ahead and send the data */
 133                 GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, constants + (i * 4)));
 134             }
 135         }
 136         checkGLcall("glUniform4fvARB()");
 137     }
 138
 139     /* Load immediate constants */
 140     if (TRACE_ON(d3d_shader)) {
 141         LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 142             tmp_loc = constant_locations[lconst->idx];
 143             if (tmp_loc != -1) {
 144                 GLfloat* values = (GLfloat*)lconst->value;
 145                 TRACE("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
 146                         values[0], values[1], values[2], values[3]);
 147             }
 148         }
 149     }
 150     LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
 151         tmp_loc = constant_locations[lconst->idx];
 152         if (tmp_loc != -1) {
 153             /* We found this uniform name in the program - go ahead and send the data */
 154             GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, (GLfloat*)lconst->value));
 155         }
 156     }
 157     checkGLcall("glUniform4fvARB()");
 158 }
 159
 160 /**
 161  * Loads integer constants (aka uniforms) into the currently set GLSL program.
 162  * When @constants_set == NULL, it will load all the constants.
 163  */
 164 void shader_glsl_load_constantsI(
 165     IWineD3DBaseShaderImpl* This,
 166     WineD3D_GL_Info *gl_info,
 167     GLhandleARB programId,
 168     unsigned max_constants,
 169     int* constants,
 170     BOOL* constants_set) {
 171
 172     GLhandleARB tmp_loc;
 173     int i;
 174     char tmp_name[8];
 175     char is_pshader = shader_is_pshader_version(This->baseShader.hex_version);
 176     const char* prefix = is_pshader? "PI":"VI";
 177     struct list* ptr;
 178
 179     for (i=0; i<max_constants; ++i) {
 180         if (NULL == constants_set || constants_set[i]) {
 181
 182             TRACE("Loading constants %i: %i, %i, %i, %i\n",
 183                   i, constants[i*4], constants[i*4+1], constants[i*4+2], constants[i*4+3]);
 184
 185             /* TODO: Benchmark and see if it would be beneficial to store the
 186              * locations of the constants to avoid looking up each time */
 187             snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i);
 188             tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 189             if (tmp_loc != -1) {
 190                 /* We found this uniform name in the program - go ahead and send the data */
 191                 GL_EXTCALL(glUniform4ivARB(tmp_loc, 1, &constants[i*4]));
 192                 checkGLcall("glUniform4ivARB");
 193             }
 194         }
 195     }
 196
 197     /* Load immediate constants */
 198     ptr = list_head(&This->baseShader.constantsI);
 199     while (ptr) {
 200         local_constant* lconst = LIST_ENTRY(ptr, struct local_constant, entry);
 201         unsigned int idx = lconst->idx;
 202         GLint* values = (GLint*) lconst->value;
 203
 204         TRACE("Loading local constants %i: %i, %i, %i, %i\n", idx,
 205             values[0], values[1], values[2], values[3]);
 206
 207         snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, idx);
 208         tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 209         if (tmp_loc != -1) {
 210             /* We found this uniform name in the program - go ahead and send the data */
 211             GL_EXTCALL(glUniform4ivARB(tmp_loc, 1, values));
 212             checkGLcall("glUniform4ivARB");
 213         }
 214         ptr = list_next(&This->baseShader.constantsI, ptr);
 215     }
 216 }
 217
 218 /**
 219  * Loads boolean constants (aka uniforms) into the currently set GLSL program.
 220  * When @constants_set == NULL, it will load all the constants.
 221  */
 222 void shader_glsl_load_constantsB(
 223     IWineD3DBaseShaderImpl* This,
 224     WineD3D_GL_Info *gl_info,
 225     GLhandleARB programId,
 226     unsigned max_constants,
 227     BOOL* constants,
 228     BOOL* constants_set) {
 229
 230     GLhandleARB tmp_loc;
 231     int i;
 232     char tmp_name[8];
 233     char is_pshader = shader_is_pshader_version(This->baseShader.hex_version);
 234     const char* prefix = is_pshader? "PB":"VB";
 235     struct list* ptr;
 236
 237     for (i=0; i<max_constants; ++i) {
 238         if (NULL == constants_set || constants_set[i]) {
 239
 240             TRACE("Loading constants %i: %i;\n", i, constants[i*4]);
 241
 242             /* TODO: Benchmark and see if it would be beneficial to store the
 243              * locations of the constants to avoid looking up each time */
 244             snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i);
 245             tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 246             if (tmp_loc != -1) {
 247                 /* We found this uniform name in the program - go ahead and send the data */
 248                 GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, &constants[i*4]));
 249                 checkGLcall("glUniform1ivARB");
 250             }
 251         }
 252     }
 253
 254     /* Load immediate constants */
 255     ptr = list_head(&This->baseShader.constantsB);
 256     while (ptr) {
 257         local_constant* lconst = LIST_ENTRY(ptr, struct local_constant, entry);
 258         unsigned int idx = lconst->idx;
 259         GLint* values = (GLint*) lconst->value;
 260
 261         TRACE("Loading local constants %i: %i\n", idx, values[0]);
 262
 263         snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, idx);
 264         tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 265         if (tmp_loc != -1) {
 266             /* We found this uniform name in the program - go ahead and send the data */
 267             GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, values));
 268             checkGLcall("glUniform1ivARB");
 269         }
 270         ptr = list_next(&This->baseShader.constantsB, ptr);
 271     }
 272 }
 273
 274
 275
 276 /**
 277  * Loads the app-supplied constants into the currently set GLSL program.
 278  */
 279 void shader_glsl_load_constants(
 280     IWineD3DDevice* device,
 281     char usePixelShader,
 282     char useVertexShader) {
 283
 284     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device;
 285     IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
 286     WineD3D_GL_Info *gl_info = &((IWineD3DImpl*) deviceImpl->wineD3D)->gl_info;
 287
 288     GLhandleARB *constant_locations;
 289     struct list *constant_list;
 290     GLhandleARB programId;
 291
 292     if (!stateBlock->glsl_program) {
 293         /* No GLSL program set - nothing to do. */
 294         return;
 295     }
 296     programId = stateBlock->glsl_program->programId;
 297
 298     if (useVertexShader) {
 299         IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
 300         IWineD3DVertexShaderImpl* vshader_impl = (IWineD3DVertexShaderImpl*) vshader;
 301         GLint pos;
 302
 303         IWineD3DVertexDeclarationImpl* vertexDeclaration =
 304             (IWineD3DVertexDeclarationImpl*) vshader_impl->vertexDeclaration;
 305
 306         constant_locations = stateBlock->glsl_program->vuniformF_locations;
 307         constant_list = &stateBlock->set_vconstantsF;
 308
 309         if (NULL != vertexDeclaration && NULL != vertexDeclaration->constants) {
 310             /* Load DirectX 8 float constants/uniforms for vertex shader */
 311             shader_glsl_load_constantsF(vshader, gl_info, GL_LIMITS(vshader_constantsF),
 312                     vertexDeclaration->constants, constant_locations, NULL);
 313         }
 314
 315         /* Load DirectX 9 float constants/uniforms for vertex shader */
 316         shader_glsl_load_constantsF(vshader, gl_info, GL_LIMITS(vshader_constantsF),
 317                 stateBlock->vertexShaderConstantF, constant_locations, constant_list);
 318
 319         /* Load DirectX 9 integer constants/uniforms for vertex shader */
 320         shader_glsl_load_constantsI(vshader, gl_info, programId, MAX_CONST_I,
 321                                     stateBlock->vertexShaderConstantI,
 322                                     stateBlock->set.vertexShaderConstantsI);
 323
 324         /* Load DirectX 9 boolean constants/uniforms for vertex shader */
 325         shader_glsl_load_constantsB(vshader, gl_info, programId, MAX_CONST_B,
 326                                     stateBlock->vertexShaderConstantB,
 327                                     stateBlock->set.vertexShaderConstantsB);
 328
 329         /* Upload the position fixup params */
 330         pos = GL_EXTCALL(glGetUniformLocationARB(programId, "posFixup"));
 331         checkGLcall("glGetUniformLocationARB");
 332         GL_EXTCALL(glUniform4fvARB(pos, 1, &deviceImpl->posFixup[0]));
 333         checkGLcall("glUniform4fvARB");
 334     }
 335
 336     if (usePixelShader) {
 337
 338         IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
 339
 340         constant_locations = stateBlock->glsl_program->puniformF_locations;
 341         constant_list = &stateBlock->set_pconstantsF;
 342
 343         /* Load pixel shader samplers */
 344         shader_glsl_load_psamplers(gl_info, (IWineD3DStateBlock*) stateBlock);
 345
 346         /* Load DirectX 9 float constants/uniforms for pixel shader */
 347         shader_glsl_load_constantsF(pshader, gl_info, GL_LIMITS(pshader_constantsF),
 348                 stateBlock->pixelShaderConstantF, constant_locations, constant_list);
 349
 350         /* Load DirectX 9 integer constants/uniforms for pixel shader */
 351         shader_glsl_load_constantsI(pshader, gl_info, programId, MAX_CONST_I,
 352                                     stateBlock->pixelShaderConstantI,
 353                                     stateBlock->set.pixelShaderConstantsI);
 354
 355         /* Load DirectX 9 boolean constants/uniforms for pixel shader */
 356         shader_glsl_load_constantsB(pshader, gl_info, programId, MAX_CONST_B,
 357                                     stateBlock->pixelShaderConstantB,
 358                                     stateBlock->set.pixelShaderConstantsB);
 359     }
 360 }
 361
 362 /** Generate the variable & register declarations for the GLSL output target */
 363 void shader_generate_glsl_declarations(
 364     IWineD3DBaseShader *iface,
 365     shader_reg_maps* reg_maps,
 366     SHADER_BUFFER* buffer,
 367     WineD3D_GL_Info* gl_info) {
 368
 369     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 370     int i;
 371
 372     /* There are some minor differences between pixel and vertex shaders */
 373     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 374     char prefix = pshader ? 'P' : 'V';
 375
 376     /* Prototype the subroutines */
 377     for (i = 0; i < This->baseShader.limits.label; i++) {
 378         if (reg_maps->labels[i])
 379             shader_addline(buffer, "void subroutine%lu();\n", i);
 380     }
 381
 382     /* Declare the constants (aka uniforms) */
 383     if (This->baseShader.limits.constant_float > 0) {
 384         unsigned max_constantsF = min(This->baseShader.limits.constant_float,
 385                 (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
 386         shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF);
 387     }
 388
 389     if (This->baseShader.limits.constant_int > 0)
 390         shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, This->baseShader.limits.constant_int);
 391
 392     if (This->baseShader.limits.constant_bool > 0)
 393         shader_addline(buffer, "uniform bool %cB[%u];\n", prefix, This->baseShader.limits.constant_bool);
 394
 395     if(!pshader)
 396         shader_addline(buffer, "uniform vec4 posFixup;\n");
 397
 398     /* Declare texture samplers */
 399     for (i = 0; i < This->baseShader.limits.sampler; i++) {
 400         if (reg_maps->samplers[i]) {
 401
 402             DWORD stype = reg_maps->samplers[i] & WINED3DSP_TEXTURETYPE_MASK;
 403             switch (stype) {
 404
 405                 case WINED3DSTT_1D:
 406                     shader_addline(buffer, "uniform sampler1D %csampler%lu;\n", prefix, i);
 407                     break;
 408                 case WINED3DSTT_2D:
 409                     shader_addline(buffer, "uniform sampler2D %csampler%lu;\n", prefix, i);
 410                     break;
 411                 case WINED3DSTT_CUBE:
 412                     shader_addline(buffer, "uniform samplerCube %csampler%lu;\n", prefix, i);
 413                     break;
 414                 case WINED3DSTT_VOLUME:
 415                     shader_addline(buffer, "uniform sampler3D %csampler%lu;\n", prefix, i);
 416                     break;
 417                 default:
 418                     shader_addline(buffer, "uniform unsupported_sampler %csampler%lu;\n", prefix, i);
 419                     FIXME("Unrecognized sampler type: %#x\n", stype);
 420                     break;
 421             }
 422         }
 423     }
 424
 425     /* Declare address variables */
 426     for (i = 0; i < This->baseShader.limits.address; i++) {
 427         if (reg_maps->address[i])
 428             shader_addline(buffer, "ivec4 A%d;\n", i);
 429     }
 430
 431     /* Declare texture coordinate temporaries and initialize them */
 432     for (i = 0; i < This->baseShader.limits.texcoord; i++) {
 433         if (reg_maps->texcoord[i])
 434             shader_addline(buffer, "vec4 T%lu = gl_TexCoord[%lu];\n", i, i);
 435     }
 436
 437     /* Declare input register temporaries */
 438     for (i=0; i < This->baseShader.limits.packed_input; i++) {
 439         if (reg_maps->packed_input[i])
 440             shader_addline(buffer, "vec4 IN%lu;\n", i);
 441     }
 442
 443     /* Declare output register temporaries */
 444     for (i = 0; i < This->baseShader.limits.packed_output; i++) {
 445         if (reg_maps->packed_output[i])
 446             shader_addline(buffer, "vec4 OUT%lu;\n", i);
 447     }
 448
 449     /* Declare temporary variables */
 450     for(i = 0; i < This->baseShader.limits.temporary; i++) {
 451         if (reg_maps->temporary[i])
 452             shader_addline(buffer, "vec4 R%lu;\n", i);
 453     }
 454
 455     /* Declare attributes */
 456     for (i = 0; i < This->baseShader.limits.attributes; i++) {
 457         if (reg_maps->attributes[i])
 458             shader_addline(buffer, "attribute vec4 attrib%i;\n", i);
 459     }
 460
 461     /* Declare loop register aL */
 462     if (reg_maps->loop) {
 463         shader_addline(buffer, "int aL;\n");
 464         shader_addline(buffer, "int tmpInt;\n");
 465     }
 466
 467     /* Temporary variables for matrix operations */
 468     shader_addline(buffer, "vec4 tmp0;\n");
 469     shader_addline(buffer, "vec4 tmp1;\n");
 470
 471     /* Start the main program */
 472     shader_addline(buffer, "void main() {\n");
 473 }
 474
 475 /*****************************************************************************
 476  * Functions to generate GLSL strings from DirectX Shader bytecode begin here.
 477  *
 478  * For more information, see http://wiki.winehq.org/DirectX-Shaders
 479  ****************************************************************************/
 480
 481 /* Prototypes */
 482 static void shader_glsl_add_src_param(SHADER_OPCODE_ARG* arg, const DWORD param,
 483         const DWORD addr_token, DWORD mask, char *reg_name, char *swizzle, char *out_str);
 484
 485 /* FIXME: This should be removed */
 486 static void shader_glsl_add_src_param_old(SHADER_OPCODE_ARG* arg, const DWORD param,
 487         const DWORD addr_token, char *reg_name, char *swizzle, char *out_str) {
 488     shader_glsl_add_src_param(arg, param, addr_token, 0, reg_name, swizzle, out_str);
 489 }
 490
 491 /** Used for opcode modifiers - They multiply the result by the specified amount */
 492 static const char * const shift_glsl_tab[] = {
 493     "",           /*  0 (none) */
 494     "2.0 * ",     /*  1 (x2)   */
 495     "4.0 * ",     /*  2 (x4)   */
 496     "8.0 * ",     /*  3 (x8)   */
 497     "16.0 * ",    /*  4 (x16)  */
 498     "32.0 * ",    /*  5 (x32)  */
 499     "",           /*  6 (x64)  */
 500     "",           /*  7 (x128) */
 501     "",           /*  8 (d256) */
 502     "",           /*  9 (d128) */
 503     "",           /* 10 (d64)  */
 504     "",           /* 11 (d32)  */
 505     "0.0625 * ",  /* 12 (d16)  */
 506     "0.125 * ",   /* 13 (d8)   */
 507     "0.25 * ",    /* 14 (d4)   */
 508     "0.5 * "      /* 15 (d2)   */
 509 };
 510
 511 /** Print the beginning of the generated GLSL string. example: "reg_name.xyzw = vec4("
 512  * Will also change the reg_mask if necessary (not all register types are equal in DX vs GL)  */
 513 static void shader_glsl_add_dst_old(DWORD param, const char* reg_name, char* reg_mask, char* outStr) {
 514
 515     int shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
 516     char cast[6];
 517
 518     if ((shader_get_regtype(param) == WINED3DSPR_RASTOUT)
 519          && ((param & WINED3DSP_REGNUM_MASK) != 0)) {
 520         /* gl_FogFragCoord or glPointSize - both floats */
 521         strcpy(cast, "float");
 522         strcpy(reg_mask, "");
 523
 524     } else if (reg_name[0] == 'A') {
 525         /* Address register for vertex shaders (ivec4) */
 526         strcpy(cast, "ivec4");
 527
 528     } else {
 529         /* Everything else should be a 4 component float vector */
 530         strcpy(cast, "vec4");
 531     }
 532
 533     sprintf(outStr, "%s%s = %s%s(", reg_name, reg_mask, shift_glsl_tab[shift], cast);
 534 }
 535
 536 /* Generate a GLSL parameter that does the input modifier computation and return the input register/mask to use */
 537 static void shader_glsl_gen_modifier (
 538     const DWORD instr,
 539     const char *in_reg,
 540     const char *in_regswizzle,
 541     char *out_str) {
 542
 543     out_str[0] = 0;
 544
 545     if (instr == WINED3DSIO_TEXKILL)
 546         return;
 547
 548     switch (instr & WINED3DSP_SRCMOD_MASK) {
 549     case WINED3DSPSM_NONE:
 550         sprintf(out_str, "%s%s", in_reg, in_regswizzle);
 551         break;
 552     case WINED3DSPSM_NEG:
 553         sprintf(out_str, "-%s%s", in_reg, in_regswizzle);
 554         break;
 555     case WINED3DSPSM_NOT:
 556         sprintf(out_str, "!%s%s", in_reg, in_regswizzle);
 557         break;
 558     case WINED3DSPSM_BIAS:
 559         sprintf(out_str, "(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
 560         break;
 561     case WINED3DSPSM_BIASNEG:
 562         sprintf(out_str, "-(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
 563         break;
 564     case WINED3DSPSM_SIGN:
 565         sprintf(out_str, "(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
 566         break;
 567     case WINED3DSPSM_SIGNNEG:
 568         sprintf(out_str, "-(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
 569         break;
 570     case WINED3DSPSM_COMP:
 571         sprintf(out_str, "(1.0 - %s%s)", in_reg, in_regswizzle);
 572         break;
 573     case WINED3DSPSM_X2:
 574         sprintf(out_str, "(2.0 * %s%s)", in_reg, in_regswizzle);
 575         break;
 576     case WINED3DSPSM_X2NEG:
 577         sprintf(out_str, "-(2.0 * %s%s)", in_reg, in_regswizzle);
 578         break;
 579     case WINED3DSPSM_DZ:    /* reg1_db = { reg1.r/b, reg1.g/b, ...}  The g & a components are undefined, so we'll leave them alone */
 580         sprintf(out_str, "vec4(%s.r / %s.b, %s.g / %s.b, %s.b, %s.a)", in_reg, in_reg, in_reg, in_reg, in_reg, in_reg);
 581         break;
 582     case WINED3DSPSM_DW:
 583         sprintf(out_str, "vec4(%s.r / %s.a, %s.g / %s.a, %s.b, %s.a)", in_reg, in_reg, in_reg, in_reg, in_reg, in_reg);
 584         break;
 585     case WINED3DSPSM_ABS:
 586         sprintf(out_str, "abs(%s%s)", in_reg, in_regswizzle);
 587         break;
 588     case WINED3DSPSM_ABSNEG:
 589         sprintf(out_str, "-abs(%s%s)", in_reg, in_regswizzle);
 590         break;
 591     default:
 592         FIXME("Unhandled modifier %u\n", (instr & WINED3DSP_SRCMOD_MASK));
 593         sprintf(out_str, "%s%s", in_reg, in_regswizzle);
 594     }
 595 }
 596
 597 /** Writes the GLSL variable name that corresponds to the register that the
 598  * DX opcode parameter is trying to access */
 599 static void shader_glsl_get_register_name(
 600     const DWORD param,
 601     const DWORD addr_token,
 602     char* regstr,
 603     BOOL* is_color,
 604     SHADER_OPCODE_ARG* arg) {
 605
 606     /* oPos, oFog and oPts in D3D */
 607     static const char * const hwrastout_reg_names[] = { "gl_Position", "gl_FogFragCoord", "gl_PointSize" };
 608
 609     DWORD reg = param & WINED3DSP_REGNUM_MASK;
 610     DWORD regtype = shader_get_regtype(param);
 611     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) arg->shader;
 612     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
 613     WineD3D_GL_Info* gl_info = &((IWineD3DImpl*)deviceImpl->wineD3D)->gl_info;
 614
 615     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 616     char tmpStr[50];
 617
 618     *is_color = FALSE;
 619
 620     switch (regtype) {
 621     case WINED3DSPR_TEMP:
 622         sprintf(tmpStr, "R%u", reg);
 623     break;
 624     case WINED3DSPR_INPUT:
 625         if (pshader) {
 626             /* Pixel shaders >= 3.0 */
 627             if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3)
 628                 sprintf(tmpStr, "IN%u", reg);
 629              else {
 630                 if (reg==0)
 631                     strcpy(tmpStr, "gl_Color");
 632                 else
 633                     strcpy(tmpStr, "gl_SecondaryColor");
 634             }
 635         } else {
 636             if (vshader_input_is_color((IWineD3DVertexShader*) This, reg))
 637                *is_color = TRUE;
 638             sprintf(tmpStr, "attrib%u", reg);
 639         }
 640         break;
 641     case WINED3DSPR_CONST:
 642     {
 643         const char* prefix = pshader? "PC":"VC";
 644
 645         /* Relative addressing */
 646         if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
 647
 648            /* Relative addressing on shaders 2.0+ have a relative address token,
 649             * prior to that, it was hard-coded as "A0.x" because there's only 1 register */
 650            if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2)  {
 651                char relStr[100], relReg[50], relMask[6];
 652                shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, relReg, relMask, relStr);
 653                sprintf(tmpStr, "%s[%s + %u]", prefix, relStr, reg);
 654            } else
 655                sprintf(tmpStr, "%s[A0.x + %u]", prefix, reg);
 656
 657         } else
 658              sprintf(tmpStr, "%s[%u]", prefix, reg);
 659
 660         break;
 661     }
 662     case WINED3DSPR_CONSTINT:
 663         if (pshader)
 664             sprintf(tmpStr, "PI[%u]", reg);
 665         else
 666             sprintf(tmpStr, "VI[%u]", reg);
 667         break;
 668     case WINED3DSPR_CONSTBOOL:
 669         if (pshader)
 670             sprintf(tmpStr, "PB[%u]", reg);
 671         else
 672             sprintf(tmpStr, "VB[%u]", reg);
 673         break;
 674     case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
 675         if (pshader) {
 676             sprintf(tmpStr, "T%u", reg);
 677         } else {
 678             sprintf(tmpStr, "A%u", reg);
 679         }
 680     break;
 681     case WINED3DSPR_LOOP:
 682         sprintf(tmpStr, "aL");
 683     break;
 684     case WINED3DSPR_SAMPLER:
 685         if (pshader)
 686             sprintf(tmpStr, "Psampler%u", reg);
 687         else
 688             sprintf(tmpStr, "Vsampler%u", reg);
 689     break;
 690     case WINED3DSPR_COLOROUT:
 691         if (reg >= GL_LIMITS(buffers)) {
 692             WARN("Write to render target %u, only %d supported\n", reg, 4);
 693         }
 694         if (GL_SUPPORT(ARB_DRAW_BUFFERS)) {
 695             sprintf(tmpStr, "gl_FragData[%u]", reg);
 696         } else { /* On older cards with GLSL support like the GeforceFX there's only one buffer. */
 697             sprintf(tmpStr, "gl_FragColor");
 698         }
 699     break;
 700     case WINED3DSPR_RASTOUT:
 701         sprintf(tmpStr, "%s", hwrastout_reg_names[reg]);
 702     break;
 703     case WINED3DSPR_DEPTHOUT:
 704         sprintf(tmpStr, "gl_FragDepth");
 705     break;
 706     case WINED3DSPR_ATTROUT:
 707         if (reg == 0) {
 708             sprintf(tmpStr, "gl_FrontColor");
 709         } else {
 710             sprintf(tmpStr, "gl_FrontSecondaryColor");
 711         }
 712     break;
 713     case WINED3DSPR_TEXCRDOUT:
 714         /* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
 715         if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3)
 716             sprintf(tmpStr, "OUT%u", reg);
 717         else
 718             sprintf(tmpStr, "gl_TexCoord[%u]", reg);
 719     break;
 720     default:
 721         FIXME("Unhandled register name Type(%d)\n", regtype);
 722         sprintf(tmpStr, "unrecognized_register");
 723     break;
 724     }
 725
 726     strcat(regstr, tmpStr);
 727 }
 728
 729 /* Get the GLSL write mask for the destination register */
 730 static DWORD shader_glsl_get_write_mask(const DWORD param, char *write_mask) {
 731     char *ptr = write_mask;
 732     DWORD mask = param & WINED3DSP_WRITEMASK_ALL;
 733
 734     /* gl_FogFragCoord and glPointSize are floats, fixup the write mask. */
 735     if ((shader_get_regtype(param) == WINED3DSPR_RASTOUT) && ((param & WINED3DSP_REGNUM_MASK) != 0)) {
 736         mask = WINED3DSP_WRITEMASK_0;
 737     } else {
 738         if (mask != WINED3DSP_WRITEMASK_ALL) {
 739             *ptr++ = '.';
 740             if (param & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
 741             if (param & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
 742             if (param & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
 743             if (param & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
 744         }
 745     }
 746
 747     *ptr = '\0';
 748
 749     return mask;
 750 }
 751
 752 static void shader_glsl_get_swizzle(const DWORD param, BOOL fixup, DWORD mask, char *swizzle_str) {
 753     /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
 754      * but addressed as "rgba". To fix this we need to swap the register's x
 755      * and z components. */
 756     const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
 757     char *ptr = swizzle_str;
 758
 759     /* swizzle bits fields: wwzzyyxx */
 760     DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
 761     DWORD swizzle_x = swizzle & 0x03;
 762     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 763     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 764     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 765
 766     /* FIXME: This is here to keep shader_glsl_add_src_param_old happy.
 767      * As soon as that is removed, this needs to go as well. */
 768     if (!mask) {
 769         /* If the swizzle is the default swizzle (ie, "xyzw"), we don't need to
 770          * generate a swizzle string. Unless we need to our own swizzling. */
 771         if ((WINED3DSP_NOSWIZZLE >> WINED3DSP_SWIZZLE_SHIFT) != swizzle || fixup) {
 772             *ptr++ = '.';
 773             if (swizzle_x == swizzle_y && swizzle_x == swizzle_z && swizzle_x == swizzle_w) {
 774                 *ptr++ = swizzle_chars[swizzle_x];
 775             } else {
 776                 *ptr++ = swizzle_chars[swizzle_x];
 777                 *ptr++ = swizzle_chars[swizzle_y];
 778                 *ptr++ = swizzle_chars[swizzle_z];
 779                 *ptr++ = swizzle_chars[swizzle_w];
 780             }
 781         }
 782     } else {
 783         *ptr++ = '.';
 784         if (mask & WINED3DSP_WRITEMASK_0) *ptr++ = swizzle_chars[swizzle_x];
 785         if (mask & WINED3DSP_WRITEMASK_1) *ptr++ = swizzle_chars[swizzle_y];
 786         if (mask & WINED3DSP_WRITEMASK_2) *ptr++ = swizzle_chars[swizzle_z];
 787         if (mask & WINED3DSP_WRITEMASK_3) *ptr++ = swizzle_chars[swizzle_w];
 788     }
 789
 790     *ptr = '\0';
 791 }
 792
 793 /* From a given parameter token, generate the corresponding GLSL string.
 794  * Also, return the actual register name and swizzle in case the
 795  * caller needs this information as well. */
 796 static void shader_glsl_add_src_param(SHADER_OPCODE_ARG* arg, const DWORD param,
 797         const DWORD addr_token, DWORD mask, char *reg_name, char *swizzle, char *out_str) {
 798     BOOL is_color = FALSE;
 799     swizzle[0] = reg_name[0] = out_str[0] = 0;
 800
 801     shader_glsl_get_register_name(param, addr_token, reg_name, &is_color, arg);
 802
 803     shader_glsl_get_swizzle(param, is_color, mask, swizzle);
 804     shader_glsl_gen_modifier(param, reg_name, swizzle, out_str);
 805 }
 806
 807 /* From a given parameter token, generate the corresponding GLSL string.
 808  * Also, return the actual register name and swizzle in case the
 809  * caller needs this information as well. */
 810 static DWORD shader_glsl_add_dst_param(SHADER_OPCODE_ARG* arg, const DWORD param,
 811         const DWORD addr_token, char *reg_name, char *write_mask, char *out_str) {
 812     BOOL is_color = FALSE;
 813     DWORD mask;
 814     write_mask[0] = reg_name[0] = out_str[0] = 0;
 815
 816     shader_glsl_get_register_name(param, addr_token, reg_name, &is_color, arg);
 817
 818     mask = shader_glsl_get_write_mask(param, write_mask);
 819     sprintf(out_str, "%s%s", reg_name, write_mask);
 820
 821     return mask;
 822 }
 823
 824 /* Append the destination part of the instruction to the buffer, return the effective write mask */
 825 static DWORD shader_glsl_append_dst(SHADER_BUFFER *buffer, SHADER_OPCODE_ARG *arg) {
 826     char reg_name[50], write_mask[6], reg_str[100];
 827     DWORD mask;
 828     int shift;
 829
 830     shift = (arg->dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
 831     mask = shader_glsl_add_dst_param(arg, arg->dst, arg->dst_addr, reg_name, write_mask, reg_str);
 832     shader_addline(buffer, "%s = %s(", reg_str, shift_glsl_tab[shift]);
 833
 834     return mask;
 835 }
 836
 837 /** Process GLSL instruction modifiers */
 838 void shader_glsl_add_instruction_modifiers(SHADER_OPCODE_ARG* arg) {
 839
 840     DWORD mask = arg->dst & WINED3DSP_DSTMOD_MASK;
 841
 842     if (arg->opcode->dst_token && mask != 0) {
 843         char dst_reg[50];
 844         char dst_mask[6];
 845         char dst_str[100];
 846
 847         shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
 848
 849         if (mask & WINED3DSPDM_SATURATE) {
 850             /* _SAT means to clamp the value of the register to between 0 and 1 */
 851             shader_addline(arg->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_reg, dst_mask, dst_reg, dst_mask);
 852         }
 853         if (mask & WINED3DSPDM_MSAMPCENTROID) {
 854             FIXME("_centroid modifier not handled\n");
 855         }
 856         if (mask & WINED3DSPDM_PARTIALPRECISION) {
 857             /* MSDN says this modifier can be safely ignored, so that's what we'll do. */
 858         }
 859     }
 860 }
 861
 862 static inline const char* shader_get_comp_op(
 863     const DWORD opcode) {
 864
 865     DWORD op = (opcode & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
 866     switch (op) {
 867         case COMPARISON_GT: return ">";
 868         case COMPARISON_EQ: return "==";
 869         case COMPARISON_GE: return ">=";
 870         case COMPARISON_LT: return "<";
 871         case COMPARISON_NE: return "!=";
 872         case COMPARISON_LE: return "<=";
 873         default:
 874             FIXME("Unrecognized comparison value: %u\n", op);
 875             return "(\?\?)";
 876     }
 877 }
 878
 879 static void shader_glsl_sample(SHADER_OPCODE_ARG* arg, DWORD sampler_idx, const char *dst_str, const char *coord_reg) {
 880     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 881     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
 882     DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
 883     const char sampler_prefix = shader_is_pshader_version(This->baseShader.hex_version) ? 'P' : 'V';
 884     SHADER_BUFFER* buffer = arg->buffer;
 885
 886     if(deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS] & WINED3DTTFF_PROJECTED) {
 887         /* Note that there's no such thing as a projected cube texture. */
 888         switch(sampler_type) {
 889             case WINED3DSTT_2D:
 890                 shader_addline(buffer, "%s = texture2DProj(%csampler%u, %s);\n", dst_str, sampler_prefix, sampler_idx, coord_reg);
 891                 break;
 892             case WINED3DSTT_VOLUME:
 893                 shader_addline(buffer, "%s = texture3DProj(%csampler%u, %s);\n", dst_str, sampler_prefix, sampler_idx, coord_reg);
 894                 break;
 895             default:
 896                 shader_addline(buffer, "%s = unrecognized_stype(%csampler%u, %s);\n", dst_str, sampler_prefix, sampler_idx, coord_reg);
 897                 FIXME("Unrecognized sampler type: %#x;\n", sampler_type);
 898                 break;
 899         }
 900     } else {
 901         switch(sampler_type) {
 902             case WINED3DSTT_2D:
 903                 shader_addline(buffer, "%s = texture2D(%csampler%u, %s.xy);\n", dst_str, sampler_prefix, sampler_idx, coord_reg);
 904                 break;
 905             case WINED3DSTT_CUBE:
 906                 shader_addline(buffer, "%s = textureCube(%csampler%u, %s.xyz);\n", dst_str, sampler_prefix, sampler_idx, coord_reg);
 907                 break;
 908             case WINED3DSTT_VOLUME:
 909                 shader_addline(buffer, "%s = texture3D(%csampler%u, %s.xyz);\n", dst_str, sampler_prefix, sampler_idx, coord_reg);
 910                 break;
 911             default:
 912                 shader_addline(buffer, "%s = unrecognized_stype(%csampler%u, %s);\n", dst_str, sampler_prefix, sampler_idx, coord_reg);
 913                 FIXME("Unrecognized sampler type: %#x;\n", sampler_type);
 914                 break;
 915         }
 916     }
 917 }
 918
 919
 920 /*****************************************************************************
 921  *
 922  * Begin processing individual instruction opcodes
 923  *
 924  ****************************************************************************/
 925
 926 /* Generate GLSL arithmetic functions (dst = src1 + src2) */
 927 void shader_glsl_arith(SHADER_OPCODE_ARG* arg) {
 928     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 929     SHADER_BUFFER* buffer = arg->buffer;
 930     char src0_reg[50], src1_reg[50];
 931     char src0_mask[6], src1_mask[6];
 932     char src0_str[100], src1_str[100];
 933     DWORD write_mask;
 934     char op;
 935
 936     /* Determine the GLSL operator to use based on the opcode */
 937     switch (curOpcode->opcode) {
 938         case WINED3DSIO_MUL: op = '*'; break;
 939         case WINED3DSIO_ADD: op = '+'; break;
 940         case WINED3DSIO_SUB: op = '-'; break;
 941         default:
 942             op = ' ';
 943             FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
 944             break;
 945     }
 946
 947     write_mask = shader_glsl_append_dst(buffer, arg);
 948     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, src0_reg, src0_mask, src0_str);
 949     shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, src1_reg, src1_mask, src1_str);
 950     shader_addline(buffer, "%s %c %s);\n", src0_str, op, src1_str);
 951 }
 952
 953 /* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
 954 void shader_glsl_mov(SHADER_OPCODE_ARG* arg) {
 955
 956     SHADER_BUFFER* buffer = arg->buffer;
 957     char tmpLine[256];
 958     char dst_str[100], src0_str[100];
 959     char dst_reg[50], src0_reg[50];
 960     char dst_mask[6], src0_mask[6];
 961
 962     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
 963     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
 964     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
 965     shader_addline(buffer, "%s%s)%s;\n", tmpLine, src0_str, dst_mask);
 966 }
 967
 968 /* Process the dot product operators DP3 and DP4 in GLSL (dst = dot(src0, src1)) */
 969 void shader_glsl_dot(SHADER_OPCODE_ARG* arg) {
 970
 971     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 972     SHADER_BUFFER* buffer = arg->buffer;
 973     char tmpDest[100];
 974     char dst_str[100], src0_str[100], src1_str[100];
 975     char dst_reg[50], src0_reg[50], src1_reg[50];
 976     char dst_mask[6], src0_mask[6], src1_mask[6];
 977     char cast[6];
 978
 979     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
 980     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
 981     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
 982
 983     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpDest);
 984
 985     /* Need to cast the src vectors to vec3 for dp3, and vec4 for dp4 */
 986     if (curOpcode->opcode == WINED3DSIO_DP4)
 987         strcpy(cast, "vec4(");
 988     else
 989         strcpy(cast, "vec3(");
 990
 991     shader_addline(buffer, "%sdot(%s%s), %s%s)))%s;\n",
 992                    tmpDest, cast, src0_str, cast, src1_str, dst_mask);
 993 }
 994
 995 /* Map the opcode 1-to-1 to the GL code (arg->dst = instruction(src0, src1, ...) */
 996 void shader_glsl_map2gl(SHADER_OPCODE_ARG* arg) {
 997
 998     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 999     SHADER_BUFFER* buffer = arg->buffer;
1000     char tmpLine[256];
1001     char dst_str[100], src_str[100];
1002     char dst_reg[50], src_reg[50];
1003     char dst_mask[6], src_mask[6];
1004     unsigned i;
1005
1006     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1007
1008     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1009
1010     /* Determine the GLSL function to use based on the opcode */
1011     /* TODO: Possibly make this a table for faster lookups */
1012     switch (curOpcode->opcode) {
1013             case WINED3DSIO_MIN:    strcat(tmpLine, "min"); break;
1014             case WINED3DSIO_MAX:    strcat(tmpLine, "max"); break;
1015             case WINED3DSIO_RSQ:    strcat(tmpLine, "inversesqrt"); break;
1016             case WINED3DSIO_ABS:    strcat(tmpLine, "abs"); break;
1017             case WINED3DSIO_FRC:    strcat(tmpLine, "fract"); break;
1018             case WINED3DSIO_POW:    strcat(tmpLine, "pow"); break;
1019             case WINED3DSIO_CRS:    strcat(tmpLine, "cross"); break;
1020             case WINED3DSIO_NRM:    strcat(tmpLine, "normalize"); break;
1021             case WINED3DSIO_LOGP:
1022             case WINED3DSIO_LOG:    strcat(tmpLine, "log2"); break;
1023             case WINED3DSIO_EXP:    strcat(tmpLine, "exp2"); break;
1024             case WINED3DSIO_SGE:    strcat(tmpLine, "greaterThanEqual"); break;
1025             case WINED3DSIO_SLT:    strcat(tmpLine, "lessThan"); break;
1026             case WINED3DSIO_SGN:    strcat(tmpLine, "sign"); break;
1027         default:
1028             FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
1029             break;
1030     }
1031
1032     strcat(tmpLine, "(");
1033
1034     if (curOpcode->num_params > 0) {
1035         strcat(tmpLine, "vec4(");
1036         shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src_reg, src_mask, src_str);
1037         strcat(tmpLine, src_str);
1038         strcat(tmpLine, ")");
1039         for (i = 2; i < curOpcode->num_params; ++i) {
1040             strcat(tmpLine, ", vec4(");
1041             shader_glsl_add_src_param_old(arg, arg->src[i-1], arg->src_addr[i-1], src_reg, src_mask, src_str);
1042             strcat(tmpLine, src_str);
1043             strcat(tmpLine, ")");
1044         }
1045     }
1046     shader_addline(buffer, "%s))%s;\n", tmpLine, dst_mask);
1047
1048 }
1049
1050 /** Process the WINED3DSIO_EXPP instruction in GLSL:
1051  * For shader model 1.x, do the following (and honor the writemask, so use a temporary variable):
1052  *   dst.x = 2^(floor(src))
1053  *   dst.y = src - floor(src)
1054  *   dst.z = 2^src   (partial precision is allowed, but optional)
1055  *   dst.w = 1.0;
1056  * For 2.0 shaders, just do this (honoring writemask and swizzle):
1057  *   dst = 2^src;    (partial precision is allowed, but optional)
1058  */
1059 void shader_glsl_expp(SHADER_OPCODE_ARG* arg) {
1060
1061     char tmpLine[256];
1062     char dst_str[100], src_str[100];
1063     char dst_reg[50], src_reg[50];
1064     char dst_mask[6], src_mask[6];
1065     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
1066     DWORD hex_version = This->baseShader.hex_version;
1067
1068     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1069     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src_reg, src_mask, src_str);
1070     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1071
1072     if (hex_version < WINED3DPS_VERSION(2,0)) {
1073         shader_addline(arg->buffer, "tmp0.x = vec4(exp2(floor(%s))).x;\n", src_str);
1074         shader_addline(arg->buffer, "tmp0.y = vec4(%s - floor(%s)).y;\n", src_str, src_str);
1075         shader_addline(arg->buffer, "tmp0.z = vec4(exp2(%s)).x;\n", src_str);
1076         shader_addline(arg->buffer, "tmp0.w = 1.0;\n");
1077         shader_addline(arg->buffer, "%svec4(tmp0))%s;\n", tmpLine, dst_mask);
1078     } else {
1079         shader_addline(arg->buffer, "%svec4(exp2(%s)))%s;\n", tmpLine, src_str, dst_mask);
1080     }
1081 }
1082
1083 /** Process the RCP (reciprocal or inverse) opcode in GLSL (dst = 1 / src) */
1084 void shader_glsl_rcp(SHADER_OPCODE_ARG* arg) {
1085
1086     char tmpLine[256];
1087     char dst_str[100], src_str[100];
1088     char dst_reg[50], src_reg[50];
1089     char dst_mask[6], src_mask[6];
1090
1091     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1092     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src_reg, src_mask, src_str);
1093     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1094     strcat(tmpLine, "1.0 / ");
1095     shader_addline(arg->buffer, "%s%s)%s;\n", tmpLine, src_str, dst_mask);
1096 }
1097
1098 /** Process signed comparison opcodes in GLSL. */
1099 void shader_glsl_compare(SHADER_OPCODE_ARG* arg) {
1100
1101     char tmpLine[256];
1102     char dst_str[100], src0_str[100], src1_str[100];
1103     char dst_reg[50], src0_reg[50], src1_reg[50];
1104     char dst_mask[6], src0_mask[6], src1_mask[6];
1105
1106     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1107     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1108     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1109
1110     /* If we are comparing vectors and not scalars, we should process this through map2gl using the GLSL functions. */
1111     if (strlen(src0_mask) != 2) {
1112         shader_glsl_map2gl(arg);
1113     } else {
1114         char compareStr[3];
1115         compareStr[0] = 0;
1116         shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1117
1118         switch (arg->opcode->opcode) {
1119             case WINED3DSIO_SLT:    strcpy(compareStr, "<"); break;
1120             case WINED3DSIO_SGE:    strcpy(compareStr, ">="); break;
1121             default:
1122                 FIXME("Can't handle opcode %s\n", arg->opcode->name);
1123         }
1124         shader_addline(arg->buffer, "%s(float(%s) %s float(%s)) ? 1.0 : 0.0)%s;\n",
1125                        tmpLine, src0_str, compareStr, src1_str, dst_mask);
1126     }
1127 }
1128
1129 /** Process CMP instruction in GLSL (dst = src0.x > 0.0 ? src1.x : src2.x), per channel */
1130 void shader_glsl_cmp(SHADER_OPCODE_ARG* arg) {
1131
1132     char tmpLine[256];
1133     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
1134     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
1135     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
1136
1137     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1138     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1139     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1140     shader_glsl_add_src_param_old(arg, arg->src[2], arg->src_addr[2], src2_reg, src2_mask, src2_str);
1141
1142     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1143     shader_addline(arg->buffer, "%smix(vec4(%s), vec4(%s), vec4(lessThan(vec4(%s), vec4(0.0)))))%s;\n",
1144         tmpLine, src1_str, src2_str, src0_str, dst_mask);
1145 }
1146
1147 /** Process the CND opcode in GLSL (dst = (src0 < 0.5) ? src1 : src2) */
1148 void shader_glsl_cnd(SHADER_OPCODE_ARG* arg) {
1149
1150     char tmpLine[256];
1151     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
1152     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
1153     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
1154
1155     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1156     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1157     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1158     shader_glsl_add_src_param_old(arg, arg->src[2], arg->src_addr[2], src2_reg, src2_mask, src2_str);
1159     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1160     shader_addline(arg->buffer, "%s(%s < 0.5) ? %s : %s)%s;\n",
1161                    tmpLine, src0_str, src1_str, src2_str, dst_mask);
1162 }
1163
1164 /** GLSL code generation for WINED3DSIO_MAD: Multiply the first 2 opcodes, then add the last */
1165 void shader_glsl_mad(SHADER_OPCODE_ARG* arg) {
1166
1167     char tmpLine[256];
1168     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
1169     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
1170     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
1171
1172     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1173     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1174     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1175     shader_glsl_add_src_param_old(arg, arg->src[2], arg->src_addr[2], src2_reg, src2_mask, src2_str);
1176     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1177
1178     shader_addline(arg->buffer, "%s(vec4(%s) * vec4(%s)) + vec4(%s))%s;\n",
1179                    tmpLine, src0_str, src1_str, src2_str, dst_mask);
1180 }
1181
1182 /** Handles transforming all WINED3DSIO_M?x? opcodes for
1183     Vertex shaders to GLSL codes */
1184 void shader_glsl_mnxn(SHADER_OPCODE_ARG* arg) {
1185     int i;
1186     int nComponents = 0;
1187     SHADER_OPCODE_ARG tmpArg;
1188
1189     memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
1190
1191     /* Set constants for the temporary argument */
1192     tmpArg.shader      = arg->shader;
1193     tmpArg.buffer      = arg->buffer;
1194     tmpArg.src[0]      = arg->src[0];
1195     tmpArg.src_addr[0] = arg->src_addr[0];
1196     tmpArg.src_addr[1] = arg->src_addr[1];
1197     tmpArg.reg_maps = arg->reg_maps;
1198
1199     switch(arg->opcode->opcode) {
1200         case WINED3DSIO_M4x4:
1201             nComponents = 4;
1202             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
1203             break;
1204         case WINED3DSIO_M4x3:
1205             nComponents = 3;
1206             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
1207             break;
1208         case WINED3DSIO_M3x4:
1209             nComponents = 4;
1210             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1211             break;
1212         case WINED3DSIO_M3x3:
1213             nComponents = 3;
1214             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1215             break;
1216         case WINED3DSIO_M3x2:
1217             nComponents = 2;
1218             tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
1219             break;
1220         default:
1221             break;
1222     }
1223
1224     for (i = 0; i < nComponents; i++) {
1225         tmpArg.dst = ((arg->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
1226         tmpArg.src[1]      = arg->src[1]+i;
1227         shader_glsl_dot(&tmpArg);
1228     }
1229 }
1230
1231 /**
1232     The LRP instruction performs a component-wise linear interpolation
1233     between the second and third operands using the first operand as the
1234     blend factor.  Equation:  (dst = src2 * (src1 - src0) + src0)
1235 */
1236 void shader_glsl_lrp(SHADER_OPCODE_ARG* arg) {
1237
1238     char tmpLine[256];
1239     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
1240     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
1241     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
1242
1243     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1244     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1245     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1246     shader_glsl_add_src_param_old(arg, arg->src[2], arg->src_addr[2], src2_reg, src2_mask, src2_str);
1247
1248     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1249
1250     shader_addline(arg->buffer, "%s%s + %s * (%s - %s))%s;\n",
1251                    tmpLine, src2_str, src0_str, src1_str, src2_str, dst_mask);
1252 }
1253
1254 /** Process the WINED3DSIO_LIT instruction in GLSL:
1255  * dst.x = dst.w = 1.0
1256  * dst.y = (src0.x > 0) ? src0.x
1257  * dst.z = (src0.x > 0) ? ((src0.y > 0) ? pow(src0.y, src.w) : 0) : 0
1258  *                                        where src.w is clamped at +- 128
1259  */
1260 void shader_glsl_lit(SHADER_OPCODE_ARG* arg) {
1261
1262     char dst_str[100], src0_str[100];
1263     char dst_reg[50], src0_reg[50];
1264     char dst_mask[6], src0_mask[6];
1265
1266     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1267     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1268
1269     shader_addline(arg->buffer,
1270         "%s = vec4(1.0, (%s.x > 0.0 ? %s.x : 0.0), (%s.x > 0.0 ? ((%s.y > 0.0) ? pow(%s.y, clamp(%s.w, -128.0, 128.0)) : 0.0) : 0.0), 1.0)%s;\n",
1271         dst_str, src0_reg, src0_reg, src0_reg, src0_reg, src0_reg, src0_reg, dst_mask);
1272 }
1273
1274 /** Process the WINED3DSIO_DST instruction in GLSL:
1275  * dst.x = 1.0
1276  * dst.y = src0.x * src0.y
1277  * dst.z = src0.z
1278  * dst.w = src1.w
1279  */
1280 void shader_glsl_dst(SHADER_OPCODE_ARG* arg) {
1281
1282     char dst_str[100], src0_str[100], src1_str[100];
1283     char dst_reg[50], src0_reg[50], src1_reg[50];
1284     char dst_mask[6], src0_mask[6], src1_mask[6];
1285
1286     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1287     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1288     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1289
1290     shader_addline(arg->buffer, "%s = vec4(1.0, %s.x * %s.y, %s.z, %s.w)%s;\n",
1291                    dst_str, src0_reg, src1_reg, src0_reg, src1_reg, dst_mask);
1292 }
1293
1294 /** Process the WINED3DSIO_SINCOS instruction in GLSL:
1295  * VS 2.0 requires that specific cosine and sine constants be passed to this instruction so the hardware
1296  * can handle it.  But, these functions are built-in for GLSL, so we can just ignore the last 2 params.
1297  *
1298  * dst.x = cos(src0.?)
1299  * dst.y = sin(src0.?)
1300  * dst.z = dst.z
1301  * dst.w = dst.w
1302  */
1303 void shader_glsl_sincos(SHADER_OPCODE_ARG* arg) {
1304     char src0_str[100];
1305     char src0_reg[50];
1306     char src0_mask[6];
1307     DWORD write_mask;
1308
1309     write_mask = shader_glsl_append_dst(arg->buffer, arg);
1310     shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, src0_reg, src0_mask, src0_str);
1311
1312     switch (write_mask) {
1313         case WINED3DSP_WRITEMASK_0:
1314             shader_addline(arg->buffer, "cos(%s));\n", src0_str);
1315             break;
1316
1317         case WINED3DSP_WRITEMASK_1:
1318             shader_addline(arg->buffer, "sin(%s));\n", src0_str);
1319             break;
1320
1321         case (WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1):
1322             shader_addline(arg->buffer, "vec2(cos(%s), sin(%s)));\n", src0_str, src0_str);
1323             break;
1324
1325         default:
1326             ERR("Write mask should be .x, .y or .xy\n");
1327             break;
1328     }
1329 }
1330
1331 /** Process the WINED3DSIO_LOOP instruction in GLSL:
1332  * Start a for() loop where src0.y is the initial value of aL,
1333  *  increment aL by src0.z for a total of src0.x iterations.
1334  *  Need to use a temporary variable for this operation.
1335  */
1336 void shader_glsl_loop(SHADER_OPCODE_ARG* arg) {
1337
1338     char src1_str[100];
1339     char src1_reg[50];
1340     char src1_mask[6];
1341
1342     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1343
1344     shader_addline(arg->buffer, "for (tmpInt = 0, aL = %s.y; tmpInt < %s.x; tmpInt++, aL += %s.z) {\n",
1345                    src1_reg, src1_reg, src1_reg);
1346 }
1347
1348 void shader_glsl_end(SHADER_OPCODE_ARG* arg) {
1349     shader_addline(arg->buffer, "}\n");
1350 }
1351
1352 void shader_glsl_rep(SHADER_OPCODE_ARG* arg) {
1353
1354     char src0_str[100];
1355     char src0_reg[50];
1356     char src0_mask[6];
1357
1358     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1359     shader_addline(arg->buffer, "for (tmpInt = 0; tmpInt < %s.x; tmpInt++) {\n", src0_reg);
1360 }
1361
1362 void shader_glsl_if(SHADER_OPCODE_ARG* arg) {
1363
1364     char src0_str[100];
1365     char src0_reg[50];
1366     char src0_mask[6];
1367
1368     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1369     shader_addline(arg->buffer, "if (%s) {\n", src0_str);
1370 }
1371
1372 void shader_glsl_ifc(SHADER_OPCODE_ARG* arg) {
1373
1374     char src0_str[100], src1_str[100];
1375     char src0_reg[50], src1_reg[50];
1376     char src0_mask[6], src1_mask[6];
1377
1378     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1379     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1380
1381     shader_addline(arg->buffer, "if (%s %s %s) {\n",
1382         src0_str, shader_get_comp_op(arg->opcode_token), src1_str);
1383 }
1384
1385 void shader_glsl_else(SHADER_OPCODE_ARG* arg) {
1386     shader_addline(arg->buffer, "} else {\n");
1387 }
1388
1389 void shader_glsl_break(SHADER_OPCODE_ARG* arg) {
1390     shader_addline(arg->buffer, "break;\n");
1391 }
1392
1393 void shader_glsl_breakc(SHADER_OPCODE_ARG* arg) {
1394
1395     char src0_str[100], src1_str[100];
1396     char src0_reg[50], src1_reg[50];
1397     char src0_mask[6], src1_mask[6];
1398
1399     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1400     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1401
1402     shader_addline(arg->buffer, "if (%s %s %s) break;\n",
1403         src0_str, shader_get_comp_op(arg->opcode_token), src1_str);
1404 }
1405
1406 void shader_glsl_label(SHADER_OPCODE_ARG* arg) {
1407
1408     DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
1409     shader_addline(arg->buffer, "}\n");
1410     shader_addline(arg->buffer, "void subroutine%lu () {\n",  snum);
1411 }
1412
1413 void shader_glsl_call(SHADER_OPCODE_ARG* arg) {
1414     DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
1415     shader_addline(arg->buffer, "subroutine%lu();\n", snum);
1416 }
1417
1418 void shader_glsl_callnz(SHADER_OPCODE_ARG* arg) {
1419
1420     char src1_str[100];
1421     char src1_reg[50];
1422     char src1_mask[6];
1423
1424     DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
1425     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1426     shader_addline(arg->buffer, "if (%s) subroutine%lu();\n", src1_str, snum);
1427 }
1428
1429 /*********************************************
1430  * Pixel Shader Specific Code begins here
1431  ********************************************/
1432 void pshader_glsl_tex(SHADER_OPCODE_ARG* arg) {
1433     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
1434
1435     DWORD hex_version = This->baseShader.hex_version;
1436
1437     char dst_str[100],   dst_reg[50],  dst_mask[6];
1438     char coord_str[100], coord_reg[50], coord_mask[6];
1439
1440     /* All versions have a destination register */
1441     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1442
1443     /* 1.0-1.3: Use destination register as coordinate source.
1444        1.4+: Use provided coordinate source register. */
1445     if (hex_version < WINED3DPS_VERSION(1,4))
1446        strcpy(coord_reg, dst_reg);
1447     else
1448        shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], coord_reg, coord_mask, coord_str);
1449
1450     /* 1.0-1.4: Use destination register as sampler source.
1451      * 2.0+: Use provided sampler source. */
1452     if (hex_version < WINED3DPS_VERSION(2,0)) {
1453         shader_glsl_sample(arg, arg->dst & WINED3DSP_REGNUM_MASK, dst_str, coord_reg);
1454     } else {
1455         shader_glsl_sample(arg, arg->src[1] & WINED3DSP_REGNUM_MASK, dst_str, coord_reg);
1456     }
1457
1458 }
1459
1460 void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg) {
1461
1462     /* FIXME: Make this work for more than just 2D textures */
1463
1464     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
1465     SHADER_BUFFER* buffer = arg->buffer;
1466     DWORD hex_version = This->baseShader.hex_version;
1467
1468     char tmpStr[100];
1469     char tmpReg[50];
1470     char tmpMask[6];
1471     tmpReg[0] = 0;
1472
1473     shader_glsl_add_dst_param(arg, arg->dst, 0, tmpReg, tmpMask, tmpStr);
1474
1475     if (hex_version != WINED3DPS_VERSION(1,4)) {
1476         DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
1477         shader_addline(buffer, "%s = clamp(gl_TexCoord[%u], 0.0, 1.0);\n", tmpReg, reg);
1478     } else {
1479         DWORD reg2 = arg->src[0] & WINED3DSP_REGNUM_MASK;
1480         shader_addline(buffer, "%s = gl_TexCoord[%u]%s;\n", tmpStr, reg2, tmpMask);
1481    }
1482 }
1483
1484 /** Process the WINED3DSIO_TEXDP3TEX instruction in GLSL:
1485  * Take a 3-component dot product of the TexCoord[dstreg] and src,
1486  * then perform a 1D texture lookup from stage dstregnum, place into dst. */
1487 void pshader_glsl_texdp3tex(SHADER_OPCODE_ARG* arg) {
1488
1489     DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
1490     char src0_str[100], dst_str[100];
1491     char src0_name[50], dst_name[50];
1492     char src0_mask[6],  dst_mask[6];
1493
1494     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_name, dst_mask, dst_str);
1495     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1496
1497     shader_addline(arg->buffer, "tmp0.x = dot(vec3(gl_TexCoord[%u]), vec3(%s));\n", dstreg, src0_str);
1498     shader_addline(arg->buffer, "%s = vec4(texture1D(Psampler%u, tmp0.x))%s;\n", dst_str, dstreg, dst_mask);
1499 }
1500
1501 /** Process the WINED3DSIO_TEXDP3 instruction in GLSL:
1502  * Take a 3-component dot product of the TexCoord[dstreg] and src. */
1503 void pshader_glsl_texdp3(SHADER_OPCODE_ARG* arg) {
1504
1505     DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
1506     char src0_str[100], dst_str[100];
1507     char src0_name[50], dst_name[50];
1508     char src0_mask[6],  dst_mask[6];
1509
1510     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_name, dst_mask, dst_str);
1511     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1512
1513     shader_addline(arg->buffer, "%s = vec4(dot(vec3(T%u), vec3(%s)))%s;\n",
1514             dst_str, dstreg, src0_str, dst_mask);
1515 }
1516
1517 /** Process the WINED3DSIO_TEXDEPTH instruction in GLSL:
1518  * Calculate the depth as dst.x / dst.y   */
1519 void pshader_glsl_texdepth(SHADER_OPCODE_ARG* arg) {
1520
1521     char dst_str[100];
1522     char dst_reg[50];
1523     char dst_mask[6];
1524
1525     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1526
1527     shader_addline(arg->buffer, "gl_FragDepth = %s.x / %s.y;\n", dst_reg, dst_reg);
1528 }
1529
1530 /** Process the WINED3DSIO_TEXM3X2DEPTH instruction in GLSL:
1531  * Last row of a 3x2 matrix multiply, use the result to calculate the depth:
1532  * Calculate tmp0.y = TexCoord[dstreg] . src.xyz;  (tmp0.x has already been calculated)
1533  * depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
1534  */
1535 void pshader_glsl_texm3x2depth(SHADER_OPCODE_ARG* arg) {
1536
1537     DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
1538     char src0_str[100], dst_str[100];
1539     char src0_name[50], dst_name[50];
1540     char src0_mask[6],  dst_mask[6];
1541
1542     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_name, dst_mask, dst_str);
1543     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1544
1545     shader_addline(arg->buffer, "tmp0.y = dot(vec3(T%u), vec3(%s));\n", dstreg, src0_str);
1546     shader_addline(arg->buffer, "gl_FragDepth = vec4((tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y)%s;\n", dst_str, dst_name);
1547 }
1548
1549 /** Process the WINED3DSIO_TEXM3X2PAD instruction in GLSL
1550  * Calculate the 1st of a 2-row matrix multiplication. */
1551 void pshader_glsl_texm3x2pad(SHADER_OPCODE_ARG* arg) {
1552
1553     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
1554     SHADER_BUFFER* buffer = arg->buffer;
1555     char src0_str[100];
1556     char src0_name[50];
1557     char src0_mask[6];
1558
1559     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1560     shader_addline(buffer, "tmp0.x = dot(vec3(T%u), vec3(%s));\n", reg, src0_str);
1561 }
1562
1563 /** Process the WINED3DSIO_TEXM3X3PAD instruction in GLSL
1564  * Calculate the 1st or 2nd row of a 3-row matrix multiplication. */
1565 void pshader_glsl_texm3x3pad(SHADER_OPCODE_ARG* arg) {
1566
1567     IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
1568     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
1569     SHADER_BUFFER* buffer = arg->buffer;
1570     SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
1571     char src0_str[100];
1572     char src0_name[50];
1573     char src0_mask[6];
1574
1575     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1576     shader_addline(buffer, "tmp0.%c = dot(vec3(T%u), vec3(%s));\n", 'x' + current_state->current_row, reg, src0_str);
1577     current_state->texcoord_w[current_state->current_row++] = reg;
1578 }
1579
1580 void pshader_glsl_texm3x2tex(SHADER_OPCODE_ARG* arg) {
1581     char dst_str[8];
1582     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
1583     SHADER_BUFFER* buffer = arg->buffer;
1584     char src0_str[100];
1585     char src0_name[50];
1586     char src0_mask[6];
1587
1588     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1589     shader_addline(buffer, "tmp0.y = dot(vec3(T%u), vec3(%s));\n", reg, src0_str);
1590
1591     /* Sample the texture using the calculated coordinates */
1592     sprintf(dst_str, "T%u", reg);
1593     shader_glsl_sample(arg, reg, dst_str, "tmp0");
1594 }
1595
1596 /** Process the WINED3DSIO_TEXM3X3TEX instruction in GLSL
1597  * Perform the 3rd row of a 3x3 matrix multiply, then sample the texture using the calculated coordinates */
1598 void pshader_glsl_texm3x3tex(SHADER_OPCODE_ARG* arg) {
1599     char dst_str[8];
1600     char src0_str[100];
1601     char src0_name[50];
1602     char src0_mask[6];
1603     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
1604     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
1605     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
1606
1607     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1608     shader_addline(arg->buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_str);
1609
1610     /* Sample the texture using the calculated coordinates */
1611     sprintf(dst_str, "T%u", reg);
1612     shader_glsl_sample(arg, reg, dst_str, "tmp0");
1613     current_state->current_row = 0;
1614 }
1615
1616 /** Process the WINED3DSIO_TEXM3X3 instruction in GLSL
1617  * Perform the 3rd row of a 3x3 matrix multiply */
1618 void pshader_glsl_texm3x3(SHADER_OPCODE_ARG* arg) {
1619
1620     char src0_str[100];
1621     char src0_name[50];
1622     char src0_mask[6];
1623     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
1624     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
1625     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
1626
1627     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1628
1629     shader_addline(arg->buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_str);
1630     shader_addline(arg->buffer, "T%u = vec4(tmp0.x, tmp0.y, tmp0.z, 1.0);\n", reg);
1631     current_state->current_row = 0;
1632 }
1633
1634 /** Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL
1635  * Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */
1636 void pshader_glsl_texm3x3spec(SHADER_OPCODE_ARG* arg) {
1637
1638     IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
1639     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
1640     char dimensions[5];
1641     char dst_str[8];
1642     char src0_str[100], src0_name[50], src0_mask[6];
1643     char src1_str[100], src1_name[50], src1_mask[6];
1644     SHADER_BUFFER* buffer = arg->buffer;
1645     SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
1646     DWORD stype = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
1647
1648     switch (stype) {
1649         case WINED3DSTT_2D:     strcpy(dimensions, "2D");   break;
1650         case WINED3DSTT_CUBE:   strcpy(dimensions, "Cube"); break;
1651         case WINED3DSTT_VOLUME: strcpy(dimensions, "3D");   break;
1652         default:
1653             strcpy(dimensions, "");
1654             FIXME("Unrecognized sampler type: %#x\n", stype);
1655             break;
1656     }
1657
1658     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1659     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_name, src1_mask, src1_str);
1660
1661     /* Perform the last matrix multiply operation */
1662     shader_addline(buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_str);
1663
1664     /* Calculate reflection vector */
1665     shader_addline(buffer, "tmp0.xyz = reflect(-vec3(%s), vec3(tmp0));\n", src1_str);
1666
1667     /* Sample the texture */
1668     sprintf(dst_str, "T%u", reg);
1669     shader_glsl_sample(arg, reg, dst_str, "tmp0");
1670     current_state->current_row = 0;
1671 }
1672
1673 /** Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL
1674  * Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */
1675 void pshader_glsl_texm3x3vspec(SHADER_OPCODE_ARG* arg) {
1676
1677     IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
1678     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
1679     SHADER_BUFFER* buffer = arg->buffer;
1680     SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
1681     char dst_str[8];
1682     char src0_str[100], src0_name[50], src0_mask[6];
1683
1684     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_name, src0_mask, src0_str);
1685
1686     /* Perform the last matrix multiply operation */
1687     shader_addline(buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_str);
1688
1689     /* Construct the eye-ray vector from w coordinates */
1690     shader_addline(buffer, "tmp1.x = gl_TexCoord[%u].w;\n", current_state->texcoord_w[0]);
1691     shader_addline(buffer, "tmp1.y = gl_TexCoord[%u].w;\n", current_state->texcoord_w[1]);
1692     shader_addline(buffer, "tmp1.z = gl_TexCoord[%u].w;\n", reg);
1693
1694     /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
1695     shader_addline(buffer, "tmp0.x = dot(vec3(tmp0), vec3(tmp1));\n");
1696     shader_addline(buffer, "tmp0 = tmp0.w * tmp0;\n");
1697     shader_addline(buffer, "tmp0 = (2.0 * tmp0) - tmp1;\n");
1698
1699     /* Sample the texture using the calculated coordinates */
1700     sprintf(dst_str, "T%u", reg);
1701     shader_glsl_sample(arg, reg, dst_str, "tmp0");
1702     current_state->current_row = 0;
1703 }
1704
1705 /** Process the WINED3DSIO_TEXBEM instruction in GLSL.
1706  * Apply a fake bump map transform.
1707  * FIXME: Should apply the BUMPMAPENV matrix.  For now, just sample the texture */
1708 void pshader_glsl_texbem(SHADER_OPCODE_ARG* arg) {
1709
1710     DWORD reg1 = arg->dst & WINED3DSP_REGNUM_MASK;
1711     DWORD reg2 = arg->src[0] & WINED3DSP_REGNUM_MASK;
1712
1713     FIXME("Not applying the BUMPMAPENV matrix for pixel shader instruction texbem.\n");
1714     shader_addline(arg->buffer, "T%u = texture2D(Psampler%u, gl_TexCoord[%u].xy + T%u.xy);\n",
1715             reg1, reg1, reg1, reg2);
1716 }
1717
1718 /** Process the WINED3DSIO_TEXREG2AR instruction in GLSL
1719  * Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */
1720 void pshader_glsl_texreg2ar(SHADER_OPCODE_ARG* arg) {
1721
1722     char tmpLine[255];
1723     char dst_str[100], src0_str[100];
1724     char dst_reg[50], src0_reg[50];
1725     char dst_mask[6], src0_mask[6];
1726     DWORD src0_regnum = arg->src[0] & WINED3DSP_REGNUM_MASK;
1727
1728     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1729     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1730
1731     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1732     shader_addline(arg->buffer, "%stexture2D(Psampler%u, %s.yz))%s;\n",
1733             tmpLine, src0_regnum, dst_reg, dst_mask);
1734 }
1735
1736 /** Process the WINED3DSIO_TEXREG2GB instruction in GLSL
1737  * Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */
1738 void pshader_glsl_texreg2gb(SHADER_OPCODE_ARG* arg) {
1739
1740     char tmpLine[255];
1741     char dst_str[100], src0_str[100];
1742     char dst_reg[50], src0_reg[50];
1743     char dst_mask[6], src0_mask[6];
1744     DWORD src0_regnum = arg->src[0] & WINED3DSP_REGNUM_MASK;
1745
1746     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1747     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1748
1749     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1750     shader_addline(arg->buffer, "%stexture2D(Psampler%u, %s.yz))%s;\n",
1751             tmpLine, src0_regnum, dst_reg, dst_mask);
1752 }
1753
1754 /** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL
1755  * Sample texture at dst using the rgb (xyz) components of src as texture coordinates */
1756 void pshader_glsl_texreg2rgb(SHADER_OPCODE_ARG* arg) {
1757
1758     char tmpLine[255];
1759     char dst_str[100], src0_str[100];
1760     char dst_reg[50], src0_reg[50];
1761     char dst_mask[6], src0_mask[6];
1762     char dimensions[5];
1763     DWORD src0_regnum = arg->src[0] & WINED3DSP_REGNUM_MASK;
1764     DWORD stype = arg->reg_maps->samplers[src0_regnum] & WINED3DSP_TEXTURETYPE_MASK;
1765     switch (stype) {
1766         case WINED3DSTT_2D:     strcpy(dimensions, "2D");   break;
1767         case WINED3DSTT_CUBE:   strcpy(dimensions, "Cube"); break;
1768         case WINED3DSTT_VOLUME: strcpy(dimensions, "3D");   break;
1769         default:
1770             strcpy(dimensions, "");
1771             FIXME("Unrecognized sampler type: %#x\n", stype);
1772             break;
1773     }
1774
1775     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1776     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1777
1778     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1779     shader_addline(arg->buffer, "%stexture%s(Psampler%u, %s.%s))%s;\n",
1780             tmpLine, dimensions, src0_regnum, dst_reg, (stype == WINED3DSTT_2D) ? "xy" : "xyz", dst_mask);
1781 }
1782
1783 /** Process the WINED3DSIO_TEXKILL instruction in GLSL.
1784  * If any of the first 3 components are < 0, discard this pixel */
1785 void pshader_glsl_texkill(SHADER_OPCODE_ARG* arg) {
1786
1787     char dst_str[100], dst_name[50], dst_mask[6];
1788
1789     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_name, dst_mask, dst_str);
1790     shader_addline(arg->buffer, "if (any(lessThan(%s.xyz, vec3(0.0)))) discard;\n", dst_name);
1791 }
1792
1793 /** Process the WINED3DSIO_DP2ADD instruction in GLSL.
1794  * dst = dot2(src0, src1) + src2 */
1795 void pshader_glsl_dp2add(SHADER_OPCODE_ARG* arg) {
1796
1797     char tmpLine[256];
1798     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
1799     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
1800     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
1801
1802     shader_glsl_add_dst_param(arg, arg->dst, 0, dst_reg, dst_mask, dst_str);
1803     shader_glsl_add_src_param_old(arg, arg->src[0], arg->src_addr[0], src0_reg, src0_mask, src0_str);
1804     shader_glsl_add_src_param_old(arg, arg->src[1], arg->src_addr[1], src1_reg, src1_mask, src1_str);
1805     shader_glsl_add_src_param_old(arg, arg->src[2], arg->src_addr[2], src2_reg, src2_mask, src2_str);
1806     shader_glsl_add_dst_old(arg->dst, dst_reg, dst_mask, tmpLine);
1807     shader_addline(arg->buffer, "%sdot(vec2(%s), vec2(%s)) + %s)%s;\n",
1808                    tmpLine, src0_str, src1_str, src2_str, dst_mask);
1809 }
1810
1811 void pshader_glsl_input_pack(
1812    SHADER_BUFFER* buffer,
1813    semantic* semantics_in) {
1814
1815    unsigned int i;
1816
1817    for (i = 0; i < MAX_REG_INPUT; i++) {
1818
1819        DWORD usage_token = semantics_in[i].usage;
1820        DWORD register_token = semantics_in[i].reg;
1821        DWORD usage, usage_idx;
1822        char reg_mask[6];
1823
1824        /* Uninitialized */
1825        if (!usage_token) continue;
1826        usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
1827        usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
1828        shader_glsl_get_write_mask(register_token, reg_mask);
1829
1830        switch(usage) {
1831
1832            case D3DDECLUSAGE_COLOR:
1833                if (usage_idx == 0)
1834                    shader_addline(buffer, "IN%u%s = vec4(gl_Color)%s;\n",
1835                        i, reg_mask, reg_mask);
1836                else if (usage_idx == 1)
1837                    shader_addline(buffer, "IN%u%s = vec4(gl_SecondaryColor)%s;\n",
1838                        i, reg_mask, reg_mask);
1839                else
1840                    shader_addline(buffer, "IN%u%s = vec4(unsupported_color_input)%s;\n",
1841                        i, reg_mask, reg_mask);
1842                break;
1843
1844            case D3DDECLUSAGE_TEXCOORD:
1845                shader_addline(buffer, "IN%u%s = vec4(gl_TexCoord[%u])%s;\n",
1846                    i, reg_mask, usage_idx, reg_mask );
1847                break;
1848
1849            case D3DDECLUSAGE_FOG:
1850                shader_addline(buffer, "IN%u%s = vec4(gl_FogFragCoord)%s;\n",
1851                    i, reg_mask, reg_mask);
1852                break;
1853
1854            default:
1855                shader_addline(buffer, "IN%u%s = vec4(unsupported_input)%s;\n",
1856                    i, reg_mask, reg_mask);
1857         }
1858     }
1859 }
1860
1861 /*********************************************
1862  * Vertex Shader Specific Code begins here
1863  ********************************************/
1864
1865 void vshader_glsl_output_unpack(
1866    SHADER_BUFFER* buffer,
1867    semantic* semantics_out) {
1868
1869    unsigned int i;
1870
1871    for (i = 0; i < MAX_REG_OUTPUT; i++) {
1872
1873        DWORD usage_token = semantics_out[i].usage;
1874        DWORD register_token = semantics_out[i].reg;
1875        DWORD usage, usage_idx;
1876        char reg_mask[6];
1877
1878        /* Uninitialized */
1879        if (!usage_token) continue;
1880
1881        usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
1882        usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
1883        shader_glsl_get_write_mask(register_token, reg_mask);
1884
1885        switch(usage) {
1886
1887            case D3DDECLUSAGE_COLOR:
1888                if (usage_idx == 0)
1889                    shader_addline(buffer, "gl_FrontColor%s = OUT%u%s;\n", reg_mask, i, reg_mask);
1890                else if (usage_idx == 1)
1891                    shader_addline(buffer, "gl_FrontSecondaryColor%s = OUT%u%s;\n", reg_mask, i, reg_mask);
1892                else
1893                    shader_addline(buffer, "unsupported_color_output%s = OUT%u%s;\n", reg_mask, i, reg_mask);
1894                break;
1895
1896            case D3DDECLUSAGE_POSITION:
1897                shader_addline(buffer, "gl_Position%s = OUT%u%s;\n", reg_mask, i, reg_mask);
1898                break;
1899
1900            case D3DDECLUSAGE_TEXCOORD:
1901                shader_addline(buffer, "gl_TexCoord[%u]%s = OUT%u%s;\n",
1902                    usage_idx, reg_mask, i, reg_mask);
1903                break;
1904
1905            case WINED3DSHADERDECLUSAGE_PSIZE:
1906                shader_addline(buffer, "gl_PointSize = OUT%u.x;\n", i);
1907                break;
1908
1909            case WINED3DSHADERDECLUSAGE_FOG:
1910                shader_addline(buffer, "gl_FogFragCoord%s = OUT%u%s;\n", reg_mask, i, reg_mask);
1911                break;
1912
1913            default:
1914                shader_addline(buffer, "unsupported_output%s = OUT%u%s;\n", reg_mask, i, reg_mask);
1915        }
1916     }
1917 }
1918
1919 /** Attach a GLSL pixel or vertex shader object to the shader program */
1920 static void attach_glsl_shader(IWineD3DDevice *iface, IWineD3DBaseShader* shader) {
1921     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1922     WineD3D_GL_Info *gl_info = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
1923     GLhandleARB shaderObj = ((IWineD3DBaseShaderImpl*)shader)->baseShader.prgId;
1924     if (This->stateBlock->glsl_program && shaderObj != 0) {
1925         TRACE("Attaching GLSL shader object %u to program %u\n", shaderObj, This->stateBlock->glsl_program->programId);
1926         GL_EXTCALL(glAttachObjectARB(This->stateBlock->glsl_program->programId, shaderObj));
1927         checkGLcall("glAttachObjectARB");
1928     }
1929 }
1930
1931 /** Sets the GLSL program ID for the given pixel and vertex shader combination.
1932  * It sets the programId on the current StateBlock (because it should be called
1933  * inside of the DrawPrimitive() part of the render loop).
1934  *
1935  * If a program for the given combination does not exist, create one, and store
1936  * the program in the list.  If it creates a program, it will link the given
1937  * objects, too.
1938  *
1939  * We keep the shader programs around on a list because linking
1940  * shader objects together is an expensive operation.  It's much
1941  * faster to loop through a list of pre-compiled & linked programs
1942  * each time that the application sets a new pixel or vertex shader
1943  * than it is to re-link them together at that time.
1944  *
1945  * The list will be deleted in IWineD3DDevice::Release().
1946  */
1947 static void set_glsl_shader_program(IWineD3DDevice *iface) {
1948     IWineD3DDeviceImpl *This               = (IWineD3DDeviceImpl *)iface;
1949     WineD3D_GL_Info *gl_info               = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
1950     IWineD3DPixelShader  *pshader          = This->stateBlock->pixelShader;
1951     IWineD3DVertexShader *vshader          = This->stateBlock->vertexShader;
1952     struct glsl_shader_prog_link *curLink  = NULL;
1953     struct glsl_shader_prog_link *newLink  = NULL;
1954     struct list *ptr                       = NULL;
1955     GLhandleARB programId                  = 0;
1956     int i;
1957     char glsl_name[8];
1958
1959     ptr = list_head( &This->glsl_shader_progs );
1960     while (ptr) {
1961         /* At least one program exists - see if it matches our ps/vs combination */
1962         curLink = LIST_ENTRY( ptr, struct glsl_shader_prog_link, entry );
1963         if (vshader == curLink->vertexShader && pshader == curLink->pixelShader) {
1964             /* Existing Program found, use it */
1965             TRACE("Found existing program (%u) for this vertex/pixel shader combination\n",
1966                    curLink->programId);
1967             This->stateBlock->glsl_program = curLink;
1968             return;
1969         }
1970         /* This isn't the entry we need - try the next one */
1971         ptr = list_next( &This->glsl_shader_progs, ptr );
1972     }
1973
1974     /* If we get to this point, then no matching program exists, so we create one */
1975     programId = GL_EXTCALL(glCreateProgramObjectARB());
1976     TRACE("Created new GLSL shader program %u\n", programId);
1977
1978     /* Allocate a new link for the list of programs */
1979     newLink = HeapAlloc(GetProcessHeap(), 0, sizeof(struct glsl_shader_prog_link));
1980     newLink->programId    = programId;
1981     This->stateBlock->glsl_program = newLink;
1982
1983     /* Attach GLSL vshader */
1984     if (NULL != vshader && This->vs_selected_mode == SHADER_GLSL) {
1985         int i;
1986         int max_attribs = 16;   /* TODO: Will this always be the case? It is at the moment... */
1987         char tmp_name[10];
1988
1989         TRACE("Attaching vertex shader to GLSL program\n");
1990         attach_glsl_shader(iface, (IWineD3DBaseShader*)vshader);
1991
1992         /* Bind vertex attributes to a corresponding index number to match
1993          * the same index numbers as ARB_vertex_programs (makes loading
1994          * vertex attributes simpler).  With this method, we can use the
1995          * exact same code to load the attributes later for both ARB and
1996          * GLSL shaders.
1997          *
1998          * We have to do this here because we need to know the Program ID
1999          * in order to make the bindings work, and it has to be done prior
2000          * to linking the GLSL program. */
2001         for (i = 0; i < max_attribs; ++i) {
2002              snprintf(tmp_name, sizeof(tmp_name), "attrib%i", i);
2003              GL_EXTCALL(glBindAttribLocationARB(programId, i, tmp_name));
2004         }
2005         checkGLcall("glBindAttribLocationARB");
2006         newLink->vertexShader = vshader;
2007     }
2008
2009     /* Attach GLSL pshader */
2010     if (NULL != pshader && This->ps_selected_mode == SHADER_GLSL) {
2011         TRACE("Attaching pixel shader to GLSL program\n");
2012         attach_glsl_shader(iface, (IWineD3DBaseShader*)pshader);
2013         newLink->pixelShader = pshader;
2014     }
2015
2016     /* Link the program */
2017     TRACE("Linking GLSL shader program %u\n", programId);
2018     GL_EXTCALL(glLinkProgramARB(programId));
2019     print_glsl_info_log(&GLINFO_LOCATION, programId);
2020     list_add_head( &This->glsl_shader_progs, &newLink->entry);
2021
2022     newLink->vuniformF_locations = HeapAlloc(GetProcessHeap(), 0, sizeof(GLhandleARB) * GL_LIMITS(vshader_constantsF));
2023     for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
2024         snprintf(glsl_name, sizeof(glsl_name), "VC[%i]", i);
2025         newLink->vuniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
2026     }
2027     newLink->puniformF_locations = HeapAlloc(GetProcessHeap(), 0, sizeof(GLhandleARB) * GL_LIMITS(pshader_constantsF));
2028     for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i) {
2029         snprintf(glsl_name, sizeof(glsl_name), "PC[%i]", i);
2030         newLink->puniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
2031     }
2032
2033     return;
2034 }
2035
2036 static GLhandleARB create_glsl_blt_shader(WineD3D_GL_Info *gl_info) {
2037     GLhandleARB program_id;
2038     GLhandleARB vshader_id, pshader_id;
2039     const char *blt_vshader[] = {
2040         "void main(void)\n"
2041         "{\n"
2042         "    gl_Position = gl_Vertex;\n"
2043         "    gl_FrontColor = vec4(1.0);\n"
2044         "    gl_TexCoord[0].x = (gl_Vertex.x * 0.5) + 0.5;\n"
2045         "    gl_TexCoord[0].y = (-gl_Vertex.y * 0.5) + 0.5;\n"
2046         "}\n"
2047     };
2048
2049     const char *blt_pshader[] = {
2050         "uniform sampler2D sampler;\n"
2051         "void main(void)\n"
2052         "{\n"
2053         "    gl_FragDepth = texture2D(sampler, gl_TexCoord[0].xy).x;\n"
2054         "}\n"
2055     };
2056
2057     vshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
2058     GL_EXTCALL(glShaderSourceARB(vshader_id, 1, blt_vshader, NULL));
2059     GL_EXTCALL(glCompileShaderARB(vshader_id));
2060
2061     pshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
2062     GL_EXTCALL(glShaderSourceARB(pshader_id, 1, blt_pshader, NULL));
2063     GL_EXTCALL(glCompileShaderARB(pshader_id));
2064
2065     program_id = GL_EXTCALL(glCreateProgramObjectARB());
2066     GL_EXTCALL(glAttachObjectARB(program_id, vshader_id));
2067     GL_EXTCALL(glAttachObjectARB(program_id, pshader_id));
2068     GL_EXTCALL(glLinkProgramARB(program_id));
2069
2070     print_glsl_info_log(&GLINFO_LOCATION, program_id);
2071
2072     return program_id;
2073 }
2074
2075 static void shader_glsl_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {
2076     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2077     WineD3D_GL_Info *gl_info = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
2078     GLhandleARB program_id = 0;
2079
2080     if (useVS || usePS) set_glsl_shader_program(iface);
2081     else This->stateBlock->glsl_program = NULL;
2082
2083     program_id = This->stateBlock->glsl_program ? This->stateBlock->glsl_program->programId : 0;
2084     if (program_id) TRACE("Using GLSL program %u\n", program_id);
2085     GL_EXTCALL(glUseProgramObjectARB(program_id));
2086     checkGLcall("glUseProgramObjectARB");
2087 }
2088
2089 static void shader_glsl_select_depth_blt(IWineD3DDevice *iface) {
2090     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2091     WineD3D_GL_Info *gl_info = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
2092     static GLhandleARB program_id = 0;
2093     static GLhandleARB loc = -1;
2094
2095     if (!program_id) {
2096         program_id = create_glsl_blt_shader(gl_info);
2097         loc = GL_EXTCALL(glGetUniformLocationARB(program_id, "sampler"));
2098     }
2099
2100     GL_EXTCALL(glUseProgramObjectARB(program_id));
2101     GL_EXTCALL(glUniform1iARB(loc, 0));
2102 }
2103
2104 static void shader_glsl_cleanup(BOOL usePS, BOOL useVS) {
2105     /* Nothing to do */
2106 }
2107
2108 const shader_backend_t glsl_shader_backend = {
2109     &shader_glsl_select,
2110     &shader_glsl_select_depth_blt,
2111     &shader_glsl_load_constants,
2112     &shader_glsl_cleanup
2113 };