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  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include "wined3d_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  26
  27 #define GLINFO_LOCATION      (*gl_info)
  28
  29 /** Prints the GLSL info log which will contain error messages if they exist */
  30 void print_glsl_info_log(WineD3D_GL_Info *gl_info, GLhandleARB obj) {
  31
  32     int infologLength = 0;
  33     char *infoLog;
  34
  35     GL_EXTCALL(glGetObjectParameterivARB(obj,
  36                GL_OBJECT_INFO_LOG_LENGTH_ARB,
  37                &infologLength));
  38
  39     /* A size of 1 is just a null-terminated string, so the log should be bigger than
  40      * that if there are errors. */
  41     if (infologLength > 1)
  42     {
  43         infoLog = (char *)HeapAlloc(GetProcessHeap(), 0, infologLength);
  44         GL_EXTCALL(glGetInfoLogARB(obj, infologLength, NULL, infoLog));
  45         FIXME("Error received from GLSL shader #%u: %s\n", obj, debugstr_a(infoLog));
  46         HeapFree(GetProcessHeap(), 0, infoLog);
  47     }
  48 }
  49
  50 /**
  51  * Loads (pixel shader) samplers
  52  */
  53 void shader_glsl_load_psamplers(
  54     WineD3D_GL_Info *gl_info,
  55     IWineD3DStateBlock* iface) {
  56
  57     IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
  58     GLhandleARB programId = stateBlock->shaderPrgId;
  59     GLhandleARB name_loc;
  60     int i;
  61     char sampler_name[20];
  62
  63     for (i=0; i< GL_LIMITS(textures); ++i) {
  64         if (stateBlock->textures[i] != NULL) {
  65            snprintf(sampler_name, sizeof(sampler_name), "Psampler%d", i);
  66            name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
  67            if (name_loc != -1) {
  68                TRACE_(d3d_shader)("Loading %s for texture %d\n", sampler_name, i);
  69                GL_EXTCALL(glUniform1iARB(name_loc, i));
  70                checkGLcall("glUniform1iARB");
  71            }
  72         }
  73     }
  74 }
  75
  76 /**
  77  * Loads floating point constants (aka uniforms) into the currently set GLSL program.
  78  * When @constants_set == NULL, it will load all the constants.
  79  */
  80 void shader_glsl_load_constantsF(
  81     WineD3D_GL_Info *gl_info,
  82     GLhandleARB programId,
  83     unsigned max_constants,
  84     float* constants,
  85     BOOL* constants_set,
  86     char is_pshader) {
  87
  88     GLhandleARB tmp_loc;
  89     int i;
  90     char tmp_name[7];
  91     const char* prefix = is_pshader? "PC":"VC";
  92
  93     for (i=0; i<max_constants; ++i) {
  94         if (NULL == constants_set || constants_set[i]) {
  95
  96             TRACE("Loading constants %i: %f, %f, %f, %f\n", i,
  97                   constants[i * sizeof(float) + 0], constants[i * sizeof(float) + 1],
  98                   constants[i * sizeof(float) + 2], constants[i * sizeof(float) + 3]);
  99
 100             /* TODO: Benchmark and see if it would be beneficial to store the
 101              * locations of the constants to avoid looking up each time */
 102             snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i);
 103             tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
 104             if (tmp_loc != -1) {
 105                 /* We found this uniform name in the program - go ahead and send the data */
 106                 GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, &constants[i * sizeof(float)]));
 107                 checkGLcall("glUniform4fvARB");
 108             }
 109         }
 110     }
 111 }
 112
 113 /**
 114  * Loads the app-supplied constants into the currently set GLSL program.
 115  */
 116 void shader_glsl_load_constants(
 117     IWineD3DStateBlock* iface,
 118     char usePixelShader,
 119     char useVertexShader) {
 120
 121     IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
 122     WineD3D_GL_Info *gl_info = &((IWineD3DImpl*)stateBlock->wineD3DDevice->wineD3D)->gl_info;
 123     GLhandleARB programId = stateBlock->shaderPrgId;
 124
 125     if (programId == 0) {
 126         /* No GLSL program set - nothing to do. */
 127         return;
 128     }
 129
 130     if (useVertexShader) {
 131         IWineD3DVertexShaderImpl* vshader = (IWineD3DVertexShaderImpl*) stateBlock->vertexShader;
 132         IWineD3DVertexDeclarationImpl* vertexDeclaration =
 133             (IWineD3DVertexDeclarationImpl*) vshader->vertexDeclaration;
 134
 135         if (NULL != vertexDeclaration && NULL != vertexDeclaration->constants) {
 136             /* Load DirectX 8 float constants/uniforms for vertex shader */
 137             shader_glsl_load_constantsF(gl_info, programId, WINED3D_VSHADER_MAX_CONSTANTS,
 138                                         vertexDeclaration->constants, NULL, 0);
 139         }
 140
 141         /* Load DirectX 9 float constants/uniforms for vertex shader */
 142         shader_glsl_load_constantsF(gl_info, programId, WINED3D_VSHADER_MAX_CONSTANTS,
 143                                     stateBlock->vertexShaderConstantF,
 144                                     stateBlock->set.vertexShaderConstantsF, 0);
 145
 146         /* TODO: Load boolean & integer constants for vertex shader */
 147     }
 148
 149     if (usePixelShader) {
 150
 151         /* Load pixel shader samplers */
 152         shader_glsl_load_psamplers(gl_info, iface);
 153
 154         /* Load DirectX 9 float constants/uniforms for pixel shader */
 155         shader_glsl_load_constantsF(gl_info, programId, WINED3D_PSHADER_MAX_CONSTANTS,
 156                                     stateBlock->pixelShaderConstantF,
 157                                     stateBlock->set.pixelShaderConstantsF, 1);
 158
 159         /* TODO: Load boolean & integer constants for pixel shader */
 160     }
 161 }
 162
 163 /** Generate the variable & register declarations for the GLSL output target */
 164 void shader_generate_glsl_declarations(
 165     IWineD3DBaseShader *iface,
 166     shader_reg_maps* reg_maps,
 167     SHADER_BUFFER* buffer) {
 168
 169     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 170     int i;
 171
 172     /* There are some minor differences between pixel and vertex shaders */
 173     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 174     char prefix = pshader ? 'P' : 'V';
 175
 176     /* Declare the constants (aka uniforms) */
 177     if (This->baseShader.limits.constant_float > 0)
 178         shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, This->baseShader.limits.constant_float);
 179
 180     if (This->baseShader.limits.constant_int > 0)
 181         shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, This->baseShader.limits.constant_int);
 182
 183     if (This->baseShader.limits.constant_bool > 0)
 184         shader_addline(buffer, "uniform bool %cB[%u];\n", prefix, This->baseShader.limits.constant_bool);
 185
 186     /* Declare texture samplers */
 187     for (i = 0; i < This->baseShader.limits.sampler; i++) {
 188         if (reg_maps->samplers[i]) {
 189
 190             DWORD stype = reg_maps->samplers[i] & D3DSP_TEXTURETYPE_MASK;
 191             switch (stype) {
 192
 193                 case D3DSTT_2D:
 194                     shader_addline(buffer, "uniform sampler2D %csampler%lu;\n", prefix, i);
 195                     break;
 196                 case D3DSTT_CUBE:
 197                     shader_addline(buffer, "uniform samplerCube %csampler%lu;\n", prefix, i);
 198                     break;
 199                 case D3DSTT_VOLUME:
 200                     shader_addline(buffer, "uniform sampler3D %csampler%lu;\n", prefix, i);
 201                     break;
 202                 default:
 203                     shader_addline(buffer, "uniform unsupported_sampler %csampler%lu;\n", prefix, i);
 204                     FIXME("Unrecognized sampler type: %#lx\n", stype);
 205                     break;
 206             }
 207         }
 208     }
 209
 210     /* Declare address variables */
 211     for (i = 0; i < This->baseShader.limits.address; i++) {
 212         if (reg_maps->address[i])
 213             shader_addline(buffer, "ivec4 A%ld;\n", i);
 214     }
 215
 216     /* Declare texture coordinate temporaries and initialize them */
 217     for (i = 0; i < This->baseShader.limits.texcoord; i++) {
 218         if (reg_maps->texcoord[i])
 219             shader_addline(buffer, "vec4 T%lu = gl_TexCoord[%lu];\n", i, i);
 220     }
 221
 222     /* Declare input register temporaries */
 223     for (i=0; i < This->baseShader.limits.packed_input; i++) {
 224         if (reg_maps->packed_input[i])
 225             shader_addline(buffer, "vec4 IN%lu;\n", i);
 226     }
 227
 228     /* Declare output register temporaries */
 229     for (i = 0; i < This->baseShader.limits.packed_output; i++) {
 230         if (reg_maps->packed_output[i])
 231             shader_addline(buffer, "vec4 OUT%lu;\n", i);
 232     }
 233
 234     /* Declare temporary variables */
 235     for(i = 0; i < This->baseShader.limits.temporary; i++) {
 236         if (reg_maps->temporary[i])
 237             shader_addline(buffer, "vec4 R%lu;\n", i);
 238     }
 239
 240     /* Declare attributes */
 241     for (i = 0; i < This->baseShader.limits.attributes; i++) {
 242         if (reg_maps->attributes[i])
 243             shader_addline(buffer, "attribute vec4 attrib%i;\n", i);
 244     }
 245
 246     /* Declare loop register aL */
 247     if (reg_maps->loop)
 248         shader_addline(buffer, "int aL;\n");
 249
 250     /* Temporary variables for matrix operations */
 251     shader_addline(buffer, "vec4 tmp0;\n");
 252     shader_addline(buffer, "vec4 tmp1;\n");
 253
 254     /* Start the main program */
 255     shader_addline(buffer, "void main() {\n");
 256 }
 257
 258 /*****************************************************************************
 259  * Functions to generate GLSL strings from DirectX Shader bytecode begin here.
 260  *
 261  * For more information, see http://wiki.winehq.org/DirectX-Shaders
 262  ****************************************************************************/
 263
 264 /* Prototypes */
 265 static void shader_glsl_add_param(
 266     SHADER_OPCODE_ARG* arg,
 267     const DWORD param,
 268     const DWORD addr_token,
 269     BOOL is_input,
 270     char *reg_name,
 271     char *reg_mask,
 272     char *out_str);
 273
 274 /** Used for opcode modifiers - They multiply the result by the specified amount */
 275 static const char* shift_glsl_tab[] = {
 276     "",           /*  0 (none) */
 277     "2.0 * ",     /*  1 (x2)   */
 278     "4.0 * ",     /*  2 (x4)   */
 279     "8.0 * ",     /*  3 (x8)   */
 280     "16.0 * ",    /*  4 (x16)  */
 281     "32.0 * ",    /*  5 (x32)  */
 282     "",           /*  6 (x64)  */
 283     "",           /*  7 (x128) */
 284     "",           /*  8 (d256) */
 285     "",           /*  9 (d128) */
 286     "",           /* 10 (d64)  */
 287     "",           /* 11 (d32)  */
 288     "0.0625 * ",  /* 12 (d16)  */
 289     "0.125 * ",   /* 13 (d8)   */
 290     "0.25 * ",    /* 14 (d4)   */
 291     "0.5 * "      /* 15 (d2)   */
 292 };
 293
 294 /** Print the beginning of the generated GLSL string. example: "reg_name.xyzw = vec4("  */
 295 static void shader_glsl_add_dst(DWORD param, const char* reg_name, const char* reg_mask, char* outStr) {
 296
 297     int shift = (param & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
 298
 299     /* TODO: determine if destination is anything other than a float vector and accommodate*/
 300     if (reg_name[0] == 'A')
 301             sprintf(outStr, "%s%s = %sivec4(", reg_name, reg_mask, shift_glsl_tab[shift]);
 302     else
 303     sprintf(outStr, "%s%s = %svec4(", reg_name, reg_mask, shift_glsl_tab[shift]);
 304
 305 }
 306
 307 /* Generate a GLSL parameter that does the input modifier computation and return the input register/mask to use */
 308 static void shader_glsl_gen_modifier (
 309     const DWORD instr,
 310     const char *in_reg,
 311     const char *in_regswizzle,
 312     char *out_str) {
 313
 314     out_str[0] = 0;
 315
 316     switch (instr & D3DSP_SRCMOD_MASK) {
 317     case D3DSPSM_NONE:
 318         sprintf(out_str, "%s%s", in_reg, in_regswizzle);
 319         break;
 320     case D3DSPSM_NEG:
 321         sprintf(out_str, "-%s%s", in_reg, in_regswizzle);
 322         break;
 323     case D3DSPSM_BIAS:
 324         sprintf(out_str, "(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
 325         break;
 326     case D3DSPSM_BIASNEG:
 327         sprintf(out_str, "-(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
 328         break;
 329     case D3DSPSM_SIGN:
 330         sprintf(out_str, "(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
 331         break;
 332     case D3DSPSM_SIGNNEG:
 333         sprintf(out_str, "-(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
 334         break;
 335     case D3DSPSM_COMP:
 336         sprintf(out_str, "(1.0 - %s%s)", in_reg, in_regswizzle);
 337         break;
 338     case D3DSPSM_X2:
 339         sprintf(out_str, "(2.0 * %s%s)", in_reg, in_regswizzle);
 340         break;
 341     case D3DSPSM_X2NEG:
 342         sprintf(out_str, "-(2.0 * %s%s)", in_reg, in_regswizzle);
 343         break;
 344     case D3DSPSM_DZ:    /* reg1_db = { reg1.r/b, reg1.g/b, ...}  The g & a components are undefined, so we'll leave them alone */
 345         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);
 346         break;
 347     case D3DSPSM_DW:
 348         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);
 349         break;
 350     case D3DSPSM_ABS:
 351         sprintf(out_str, "abs(%s%s)", in_reg, in_regswizzle);
 352         break;
 353     case D3DSPSM_ABSNEG:
 354         sprintf(out_str, "-abs(%s%s)", in_reg, in_regswizzle);
 355         break;
 356     default:
 357         FIXME("Unhandled modifier %lu\n", (instr & D3DSP_SRCMOD_MASK));
 358         sprintf(out_str, "%s%s", in_reg, in_regswizzle);
 359     }
 360 }
 361
 362 /** Writes the GLSL variable name that corresponds to the register that the
 363  * DX opcode parameter is trying to access */
 364 static void shader_glsl_get_register_name(
 365     const DWORD param,
 366     const DWORD addr_token,
 367     char* regstr,
 368     BOOL* is_color,
 369     SHADER_OPCODE_ARG* arg) {
 370
 371     /* oPos, oFog and oPts in D3D */
 372     const char* hwrastout_reg_names[] = { "gl_Position", "gl_FogFragCoord", "gl_PointSize" };
 373
 374     DWORD reg = param & D3DSP_REGNUM_MASK;
 375     DWORD regtype = shader_get_regtype(param);
 376     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) arg->shader;
 377     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 378     char tmpStr[50];
 379
 380     *is_color = FALSE;
 381
 382     switch (regtype) {
 383     case D3DSPR_TEMP:
 384         sprintf(tmpStr, "R%lu", reg);
 385     break;
 386     case D3DSPR_INPUT:
 387         if (pshader) {
 388             /* Pixel shaders >= 3.0 */
 389             if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3)
 390                 sprintf(tmpStr, "IN%lu", reg);
 391              else {
 392                 if (reg==0)
 393                     strcpy(tmpStr, "gl_Color");
 394                 else
 395                     strcpy(tmpStr, "gl_SecondaryColor");
 396             }
 397         } else {
 398             IWineD3DVertexShaderImpl *vshader = (IWineD3DVertexShaderImpl*) arg->shader;
 399
 400             if (vshader->arrayUsageMap[WINED3DSHADERDECLUSAGE_DIFFUSE] &&
 401                 reg == (vshader->arrayUsageMap[WINED3DSHADERDECLUSAGE_DIFFUSE] & D3DSP_REGNUM_MASK))
 402                 *is_color = TRUE;
 403
 404             if (vshader->arrayUsageMap[WINED3DSHADERDECLUSAGE_SPECULAR] &&
 405                 reg == (vshader->arrayUsageMap[WINED3DSHADERDECLUSAGE_SPECULAR] & D3DSP_REGNUM_MASK))
 406                 *is_color = TRUE;
 407
 408             /* FIXME: Shaders in 8.1 appear to not require a dcl statement - use
 409              * the reg value from the vertex declaration. However, arrayUsageMap is not initialized
 410               * in that case - how can we know if an input contains color data or not? */
 411
 412             sprintf(tmpStr, "attrib%lu", reg);
 413         }
 414         break;
 415     case D3DSPR_CONST:
 416     {
 417         const char* prefix = pshader? "PC":"VC";
 418
 419         if (arg->reg_maps->constantsF[reg]) {
 420             /* Use a local constant declared by "def" */
 421
 422             if (param & D3DVS_ADDRMODE_RELATIVE) {
 423                  /* FIXME: Copy all constants (local & global) into a single array
 424                   * to handle this case where we want a relative address from a
 425                   * local constant. */
 426                 FIXME("Relative addressing not yet supported on named constants\n");
 427             } else {
 428                 sprintf(tmpStr, "%s%lu", prefix, reg);
 429             }
 430         } else {
 431             /* Use a global constant declared in Set____ShaderConstantF() */
 432             if (param & D3DVS_ADDRMODE_RELATIVE) {
 433                 /* Relative addressing on shaders 2.0+ have a relative address token,
 434                  * prior to that, it was hard-coded as "A0.x" because there's only 1 register */
 435                 if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2)  {
 436                     char relStr[100], relReg[50], relMask[6];
 437                     shader_glsl_add_param(arg, addr_token, 0, TRUE, relReg, relMask, relStr);
 438                     sprintf(tmpStr, "%s[%s + %lu]", prefix, relStr, reg);
 439                 } else {
 440                     sprintf(tmpStr, "%s[A0.x + %lu]", prefix, reg);
 441                 }
 442             } else {
 443                 /* Just a normal global constant - no relative addressing */
 444                 sprintf(tmpStr, "%s[%lu]", prefix, reg);
 445             }
 446         }
 447         break;
 448     }
 449     case D3DSPR_CONSTINT:
 450         if (arg->reg_maps->constantsI[reg]) {
 451             /* Integer vector was defined locally using "defi" */
 452             sprintf(tmpStr, "I%lu", reg);
 453         } else {
 454             /* Uniform integer value - pixel or vertex specific */
 455             if (pshader) {
 456                 sprintf(tmpStr, "PI[%lu]", reg);
 457             } else {
 458                 sprintf(tmpStr, "VI[%lu]", reg);
 459             }
 460         }
 461         break;
 462     case D3DSPR_CONSTBOOL:
 463         if (arg->reg_maps->constantsB[reg]) {
 464             /* Boolean was defined locally using "defb" */
 465             sprintf(tmpStr, "B%lu", reg);
 466         } else {
 467             /* Uniform boolean value - pixel or vertex specific */
 468             if (pshader) {
 469                 sprintf(tmpStr, "PB[%lu]", reg);
 470             } else {
 471                 sprintf(tmpStr, "VB[%lu]", reg);
 472             }
 473         }
 474         break;
 475     case D3DSPR_TEXTURE: /* case D3DSPR_ADDR: */
 476         if (pshader) {
 477             sprintf(tmpStr, "T%lu", reg);
 478         } else {
 479             sprintf(tmpStr, "A%lu", reg);
 480         }
 481     break;
 482     case D3DSPR_LOOP:
 483         sprintf(tmpStr, "aL");
 484     break;
 485     case D3DSPR_SAMPLER:
 486         if (pshader)
 487             sprintf(tmpStr, "Psampler%lu", reg);
 488         else
 489             sprintf(tmpStr, "Vsampler%lu", reg);
 490     break;
 491     case D3DSPR_COLOROUT:
 492         if (reg == 0)
 493             sprintf(tmpStr, "gl_FragColor");
 494         else {
 495             /* TODO: See GL_ARB_draw_buffers */
 496             FIXME("Unsupported write to render target %lu\n", reg);
 497             sprintf(tmpStr, "unsupported_register");
 498         }
 499     break;
 500     case D3DSPR_RASTOUT:
 501         sprintf(tmpStr, "%s", hwrastout_reg_names[reg]);
 502     break;
 503     case D3DSPR_DEPTHOUT:
 504         sprintf(tmpStr, "gl_FragDepth");
 505     break;
 506     case D3DSPR_ATTROUT:
 507         if (reg == 0) {
 508             sprintf(tmpStr, "gl_FrontColor");
 509         } else {
 510             sprintf(tmpStr, "gl_FrontSecondaryColor");
 511         }
 512     break;
 513     case D3DSPR_TEXCRDOUT:
 514         /* Vertex shaders >= 3.0: D3DSPR_OUTPUT */
 515         if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3)
 516             sprintf(tmpStr, "OUT%lu", reg);
 517         else
 518             sprintf(tmpStr, "gl_TexCoord[%lu]", reg);
 519     break;
 520     default:
 521         FIXME("Unhandled register name Type(%ld)\n", regtype);
 522         sprintf(tmpStr, "unrecognized_register");
 523     break;
 524     }
 525
 526     strcat(regstr, tmpStr);
 527 }
 528
 529 /* Writes the GLSL writemask for the destination register */
 530 static void shader_glsl_get_output_register_swizzle(
 531     const DWORD param,
 532     char *write_mask) {
 533
 534     *write_mask = 0;
 535     if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 536         strcat(write_mask, ".");
 537         if (param & D3DSP_WRITEMASK_0) strcat(write_mask, "x");
 538         if (param & D3DSP_WRITEMASK_1) strcat(write_mask, "y");
 539         if (param & D3DSP_WRITEMASK_2) strcat(write_mask, "z");
 540         if (param & D3DSP_WRITEMASK_3) strcat(write_mask, "w");
 541     }
 542 }
 543
 544 static void shader_glsl_get_input_register_swizzle(
 545     const DWORD param,
 546     BOOL is_color,
 547     char *reg_mask) {
 548
 549     const char swizzle_reg_chars_color_fix[] = "zyxw";
 550     const char swizzle_reg_chars[] = "xyzw";
 551     const char* swizzle_regs = NULL;
 552
 553     /** operand input */
 554     DWORD swizzle = (param & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
 555     DWORD swizzle_x = swizzle & 0x03;
 556     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 557     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 558     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 559
 560     if (is_color) {
 561       swizzle_regs = swizzle_reg_chars_color_fix;
 562     } else {
 563       swizzle_regs = swizzle_reg_chars;
 564     }
 565
 566     /**
 567      * swizzle bits fields:
 568      *  WWZZYYXX
 569      */
 570     if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) { /* D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 571       if (is_color) {
 572             sprintf(reg_mask, ".%c%c%c%c",
 573                 swizzle_regs[swizzle_x],
 574                 swizzle_regs[swizzle_y],
 575                 swizzle_regs[swizzle_z],
 576                 swizzle_regs[swizzle_w]);
 577       }
 578       return ;
 579     }
 580     if (swizzle_x == swizzle_y &&
 581         swizzle_x == swizzle_z &&
 582         swizzle_x == swizzle_w)
 583     {
 584       sprintf(reg_mask, ".%c", swizzle_regs[swizzle_x]);
 585     } else {
 586       sprintf(reg_mask, ".%c%c%c%c",
 587               swizzle_regs[swizzle_x],
 588               swizzle_regs[swizzle_y],
 589               swizzle_regs[swizzle_z],
 590               swizzle_regs[swizzle_w]);
 591     }
 592 }
 593
 594 /** From a given parameter token, generate the corresponding GLSL string.
 595  * Also, return the actual register name and swizzle in case the
 596  * caller needs this information as well. */
 597 static void shader_glsl_add_param(
 598     SHADER_OPCODE_ARG* arg,
 599     const DWORD param,
 600     const DWORD addr_token,
 601     BOOL is_input,
 602     char *reg_name,
 603     char *reg_mask,
 604     char *out_str) {
 605
 606     BOOL is_color = FALSE;
 607     reg_mask[0] = reg_name[0] = out_str[0] = 0;
 608
 609     shader_glsl_get_register_name(param, addr_token, reg_name, &is_color, arg);
 610
 611     if (is_input) {
 612         shader_glsl_get_input_register_swizzle(param, is_color, reg_mask);
 613         shader_glsl_gen_modifier(param, reg_name, reg_mask, out_str);
 614     } else {
 615         shader_glsl_get_output_register_swizzle(param, reg_mask);
 616         sprintf(out_str, "%s%s", reg_name, reg_mask);
 617     }
 618 }
 619
 620 /** Process GLSL instruction modifiers */
 621 void shader_glsl_add_instruction_modifiers(SHADER_OPCODE_ARG* arg) {
 622
 623     if (0 != (arg->dst & D3DSP_DSTMOD_MASK)) {
 624         DWORD mask = arg->dst & D3DSP_DSTMOD_MASK;
 625         char dst_reg[50];
 626         char dst_mask[6];
 627         char dst_str[100];
 628
 629         shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 630
 631         if (mask & D3DSPDM_SATURATE) {
 632             /* _SAT means to clamp the value of the register to between 0 and 1 */
 633             shader_addline(arg->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_reg, dst_mask, dst_reg, dst_mask);
 634         }
 635         if (mask & D3DSPDM_MSAMPCENTROID) {
 636             FIXME("_centroid modifier not handled\n");
 637         }
 638         if (mask & D3DSPDM_PARTIALPRECISION) {
 639             /* MSDN says this modifier can be safely ignored, so that's what we'll do. */
 640         }
 641     }
 642 }
 643
 644 /*****************************************************************************
 645  *
 646  * Begin processing individual instruction opcodes
 647  *
 648  ****************************************************************************/
 649
 650 /* Generate GLSL arithmetic functions (dst = src1 + src2) */
 651 void shader_glsl_arith(SHADER_OPCODE_ARG* arg) {
 652
 653     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 654     SHADER_BUFFER* buffer = arg->buffer;
 655     char tmpLine[256];
 656     char dst_reg[50], src0_reg[50], src1_reg[50];
 657     char dst_mask[6], src0_mask[6], src1_mask[6];
 658     char dst_str[100], src0_str[100], src1_str[100];
 659
 660     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 661     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
 662     shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str);
 663     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpLine);
 664     strcat(tmpLine, "vec4(");
 665     strcat(tmpLine, src0_str);
 666     strcat(tmpLine, ")");
 667
 668     /* Determine the GLSL operator to use based on the opcode */
 669     switch (curOpcode->opcode) {
 670         case D3DSIO_MUL:    strcat(tmpLine, " * "); break;
 671         case D3DSIO_ADD:    strcat(tmpLine, " + "); break;
 672         case D3DSIO_SUB:    strcat(tmpLine, " - "); break;
 673         default:
 674             FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
 675             break;
 676     }
 677     shader_addline(buffer, "%svec4(%s))%s;\n", tmpLine, src1_str, dst_mask);
 678 }
 679
 680 /* Process the D3DSIO_MOV opcode using GLSL (dst = src) */
 681 void shader_glsl_mov(SHADER_OPCODE_ARG* arg) {
 682
 683     SHADER_BUFFER* buffer = arg->buffer;
 684     char tmpLine[256];
 685     char dst_str[100], src0_str[100];
 686     char dst_reg[50], src0_reg[50];
 687     char dst_mask[6], src0_mask[6];
 688
 689     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 690     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
 691     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpLine);
 692     shader_addline(buffer, "%s%s)%s;\n", tmpLine, src0_str, dst_mask);
 693 }
 694
 695 /* Process the dot product operators DP3 and DP4 in GLSL (dst = dot(src0, src1)) */
 696 void shader_glsl_dot(SHADER_OPCODE_ARG* arg) {
 697
 698     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 699     SHADER_BUFFER* buffer = arg->buffer;
 700     char tmpDest[100];
 701     char dst_str[100], src0_str[100], src1_str[100];
 702     char dst_reg[50], src0_reg[50], src1_reg[50];
 703     char dst_mask[6], src0_mask[6], src1_mask[6];
 704     char cast[6];
 705
 706     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 707     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
 708     shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str);
 709
 710     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpDest);
 711
 712     /* Need to cast the src vectors to vec3 for dp3, and vec4 for dp4 */
 713     if (curOpcode->opcode == D3DSIO_DP4)
 714         strcpy(cast, "vec4(");
 715     else
 716         strcpy(cast, "vec3(");
 717
 718     shader_addline(buffer, "%sdot(%s%s), %s%s)))%s;\n",
 719                    tmpDest, cast, src0_str, cast, src1_str, dst_mask);
 720 }
 721
 722 /* Map the opcode 1-to-1 to the GL code (arg->dst = instruction(src0, src1, ...) */
 723 void shader_glsl_map2gl(SHADER_OPCODE_ARG* arg) {
 724
 725     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 726     SHADER_BUFFER* buffer = arg->buffer;
 727     char tmpLine[256];
 728     char dst_str[100], src_str[100];
 729     char dst_reg[50], src_reg[50];
 730     char dst_mask[6], src_mask[6];
 731     unsigned i;
 732
 733     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 734
 735     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpLine);
 736
 737     /* Determine the GLSL function to use based on the opcode */
 738     /* TODO: Possibly make this a table for faster lookups */
 739     switch (curOpcode->opcode) {
 740             case D3DSIO_MIN:    strcat(tmpLine, "min"); break;
 741             case D3DSIO_MAX:    strcat(tmpLine, "max"); break;
 742             case D3DSIO_RSQ:    strcat(tmpLine, "inversesqrt"); break;
 743             case D3DSIO_ABS:    strcat(tmpLine, "abs"); break;
 744             case D3DSIO_FRC:    strcat(tmpLine, "fract"); break;
 745             case D3DSIO_POW:    strcat(tmpLine, "pow"); break;
 746             case D3DSIO_CRS:    strcat(tmpLine, "cross"); break;
 747             case D3DSIO_NRM:    strcat(tmpLine, "normalize"); break;
 748             case D3DSIO_LOGP:
 749             case D3DSIO_LOG:    strcat(tmpLine, "log2"); break;
 750             case D3DSIO_EXPP:
 751             case D3DSIO_EXP:    strcat(tmpLine, "exp2"); break;
 752             case D3DSIO_SGE:    strcat(tmpLine, "greaterThanEqual"); break;
 753             case D3DSIO_SLT:    strcat(tmpLine, "lessThan"); break;
 754             case D3DSIO_SGN:    strcat(tmpLine, "sign"); break;
 755         default:
 756             FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
 757             break;
 758     }
 759
 760     strcat(tmpLine, "(");
 761
 762     if (curOpcode->num_params > 0) {
 763         strcat(tmpLine, "vec4(");
 764         shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src_reg, src_mask, src_str);
 765         strcat(tmpLine, src_str);
 766         strcat(tmpLine, ")");
 767         for (i = 2; i < curOpcode->num_params; ++i) {
 768             strcat(tmpLine, ", vec4(");
 769             shader_glsl_add_param(arg, arg->src[i-1], arg->src_addr[i-1], TRUE, src_reg, src_mask, src_str);
 770             strcat(tmpLine, src_str);
 771             strcat(tmpLine, ")");
 772         }
 773     }
 774     shader_addline(buffer, "%s))%s;\n", tmpLine, dst_mask);
 775
 776 }
 777
 778 /** Process the RCP (reciprocal or inverse) opcode in GLSL (dst = 1 / src) */
 779 void shader_glsl_rcp(SHADER_OPCODE_ARG* arg) {
 780
 781     char tmpLine[256];
 782     char dst_str[100], src_str[100];
 783     char dst_reg[50], src_reg[50];
 784     char dst_mask[6], src_mask[6];
 785
 786     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 787     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src_reg, src_mask, src_str);
 788     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpLine);
 789     strcat(tmpLine, "1.0 / ");
 790     shader_addline(arg->buffer, "%s%s)%s;\n", tmpLine, src_str, dst_mask);
 791 }
 792
 793 /** Process signed comparison opcodes in GLSL. */
 794 void shader_glsl_compare(SHADER_OPCODE_ARG* arg) {
 795
 796     char tmpLine[256];
 797     char dst_str[100], src0_str[100], src1_str[100];
 798     char dst_reg[50], src0_reg[50], src1_reg[50];
 799     char dst_mask[6], src0_mask[6], src1_mask[6];
 800
 801     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 802     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
 803     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpLine);
 804
 805     /* If we are comparing vectors and not scalars, we should process this through map2gl using the GLSL functions. */
 806     if (strlen(src0_mask) != 2) {
 807         shader_glsl_map2gl(arg);
 808     } else {
 809         char compareStr[3];
 810         compareStr[0] = 0;
 811         shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str);
 812
 813         switch (arg->opcode->opcode) {
 814             case D3DSIO_SLT:    strcpy(compareStr, "<"); break;
 815             case D3DSIO_SGE:    strcpy(compareStr, ">="); break;
 816             default:
 817                 FIXME("Can't handle opcode %s\n", arg->opcode->name);
 818         }
 819         shader_addline(arg->buffer, "%s(float(%s) %s float(%s)) ? 1.0 : 0.0)%s;\n",
 820                        tmpLine, src0_str, compareStr, src1_str, dst_mask);
 821     }
 822 }
 823
 824 /** Process CMP instruction in GLSL (dst = src0.x > 0.0 ? src1.x : src2.x), per channel */
 825 void shader_glsl_cmp(SHADER_OPCODE_ARG* arg) {
 826
 827     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
 828     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
 829     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
 830
 831     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 832     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
 833     shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str);
 834     shader_glsl_add_param(arg, arg->src[2], arg->src_addr[2], TRUE, src2_reg, src2_mask, src2_str);
 835
 836     /* FIXME: This isn't correct - doesn't take the dst's swizzle into account. */
 837     shader_addline(arg->buffer, "%s.x = (%s.x > 0.0) ? %s.x : %s.x;\n", dst_reg, src0_reg, src1_reg, src2_reg);
 838     shader_addline(arg->buffer, "%s.y = (%s.y > 0.0) ? %s.y : %s.y;\n", dst_reg, src0_reg, src1_reg, src2_reg);
 839     shader_addline(arg->buffer, "%s.z = (%s.z > 0.0) ? %s.z : %s.z;\n", dst_reg, src0_reg, src1_reg, src2_reg);
 840     shader_addline(arg->buffer, "%s.w = (%s.w > 0.0) ? %s.w : %s.w;\n", dst_reg, src0_reg, src1_reg, src2_reg);
 841 }
 842
 843 /** Process the CND opcode in GLSL (dst = (src0 < 0.5) ? src1 : src2) */
 844 void shader_glsl_cnd(SHADER_OPCODE_ARG* arg) {
 845
 846     char tmpLine[256];
 847     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
 848     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
 849     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
 850
 851     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 852     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
 853     shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str);
 854     shader_glsl_add_param(arg, arg->src[2], arg->src_addr[2], TRUE, src2_reg, src2_mask, src2_str);
 855     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpLine);
 856     shader_addline(arg->buffer, "%s(%s < 0.5) ? %s : %s)%s;\n",
 857                    tmpLine, src0_str, src1_str, src2_str, dst_mask);
 858 }
 859
 860 /** GLSL code generation for D3DSIO_MAD: Multiply the first 2 opcodes, then add the last */
 861 void shader_glsl_mad(SHADER_OPCODE_ARG* arg) {
 862
 863     char tmpLine[256];
 864     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
 865     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
 866     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
 867
 868     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 869     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
 870     shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str);
 871     shader_glsl_add_param(arg, arg->src[2], arg->src_addr[2], TRUE, src2_reg, src2_mask, src2_str);
 872     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpLine);
 873
 874     shader_addline(arg->buffer, "%s(vec4(%s) * vec4(%s)) + vec4(%s))%s;\n",
 875                    tmpLine, src0_str, src1_str, src2_str, dst_mask);
 876 }
 877
 878 /** Handles transforming all D3DSIO_M?x? opcodes for
 879     Vertex shaders to GLSL codes */
 880 void shader_glsl_mnxn(SHADER_OPCODE_ARG* arg) {
 881     int i;
 882     int nComponents = 0;
 883     SHADER_OPCODE_ARG tmpArg;
 884
 885     memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
 886
 887     /* Set constants for the temporary argument */
 888     tmpArg.shader      = arg->shader;
 889     tmpArg.buffer      = arg->buffer;
 890     tmpArg.src[0]      = arg->src[0];
 891     tmpArg.src_addr[0] = arg->src_addr[0];
 892     tmpArg.reg_maps = arg->reg_maps;
 893
 894     switch(arg->opcode->opcode) {
 895         case D3DSIO_M4x4:
 896             nComponents = 4;
 897             tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP4];
 898             break;
 899         case D3DSIO_M4x3:
 900             nComponents = 3;
 901             tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP4];
 902             break;
 903         case D3DSIO_M3x4:
 904             nComponents = 4;
 905             tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP3];
 906             break;
 907         case D3DSIO_M3x3:
 908             nComponents = 3;
 909             tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP3];
 910             break;
 911         case D3DSIO_M3x2:
 912             nComponents = 2;
 913             tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP3];
 914             break;
 915         default:
 916             break;
 917     }
 918
 919     for (i = 0; i < nComponents; i++) {
 920         tmpArg.dst = ((arg->dst) & ~D3DSP_WRITEMASK_ALL)|(D3DSP_WRITEMASK_0<<i);
 921         tmpArg.src[1]      = arg->src[1]+i;
 922         tmpArg.src_addr[1] = arg->src[1]+i;
 923         shader_glsl_dot(&tmpArg);
 924     }
 925 }
 926
 927 /**
 928     The LRP instruction performs a component-wise linear interpolation
 929     between the second and third operands using the first operand as the
 930     blend factor.  Equation:  (dst = src2 * (src1 - src0) + src0)
 931 */
 932 void shader_glsl_lrp(SHADER_OPCODE_ARG* arg) {
 933
 934     char tmpLine[256];
 935     char dst_str[100], src0_str[100], src1_str[100], src2_str[100];
 936     char dst_reg[50], src0_reg[50], src1_reg[50], src2_reg[50];
 937     char dst_mask[6], src0_mask[6], src1_mask[6], src2_mask[6];
 938
 939     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
 940     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
 941     shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str);
 942     shader_glsl_add_param(arg, arg->src[2], arg->src_addr[2], TRUE, src2_reg, src2_mask, src2_str);
 943
 944     shader_glsl_add_dst(arg->dst, dst_reg, dst_mask, tmpLine);
 945
 946     shader_addline(arg->buffer, "%s(%s * (%s - %s) + %s))%s;\n",
 947                    tmpLine, src2_str, src1_str, src0_str, src0_str, dst_mask);
 948 }
 949
 950 /** Process the D3DSIO_DEF opcode into a GLSL string - creates a local vec4
 951  * float constant, and stores it's usage on the regmaps. */
 952 void shader_glsl_def(SHADER_OPCODE_ARG* arg) {
 953
 954     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 955
 956     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) arg->shader;
 957     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 958     const char* prefix = pshader? "PC":"VC";
 959
 960     shader_addline(arg->buffer,
 961                    "const vec4 %s%lu = { %f, %f, %f, %f };\n", prefix, reg,
 962                    *((const float *)(arg->src + 0)),
 963                    *((const float *)(arg->src + 1)),
 964                    *((const float *)(arg->src + 2)),
 965                    *((const float *)(arg->src + 3)) );
 966
 967     arg->reg_maps->constantsF[reg] = 1;
 968 }
 969
 970 /** Process the D3DSIO_DEFI opcode into a GLSL string - creates a local ivec4
 971  * integer constant, and stores it's usage on the regmaps. */
 972 void shader_glsl_defi(SHADER_OPCODE_ARG* arg) {
 973
 974     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 975
 976     shader_addline(arg->buffer,
 977                    "const ivec4 I%lu = { %ld, %ld, %ld, %ld };\n", reg,
 978                    (long)arg->src[0], (long)arg->src[1],
 979                    (long)arg->src[2], (long)arg->src[3]);
 980
 981     arg->reg_maps->constantsI[reg] = 1;
 982 }
 983
 984 /** Process the D3DSIO_DEFB opcode into a GLSL string - creates a local boolean
 985  * constant, and stores it's usage on the regmaps. */
 986 void shader_glsl_defb(SHADER_OPCODE_ARG* arg) {
 987
 988     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 989
 990     shader_addline(arg->buffer, "const bool B%lu = %s;\n", reg, (arg->src[0]) ? "true" : "false");
 991
 992     arg->reg_maps->constantsB[reg] = 1;
 993 }
 994
 995 /** Process the D3DSIO_LIT instruction in GLSL:
 996  * dst.x = dst.w = 1.0
 997  * dst.y = (src0.x > 0) ? src0.x
 998  * dst.z = (src0.x > 0) ? ((src0.y > 0) ? pow(src0.y, src.w) : 0) : 0
 999  *                                        where src.w is clamped at +- 128
1000  */
1001 void shader_glsl_lit(SHADER_OPCODE_ARG* arg) {
1002
1003     char dst_str[100], src0_str[100];
1004     char dst_reg[50], src0_reg[50];
1005     char dst_mask[6], src0_mask[6];
1006
1007     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
1008     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
1009
1010     shader_addline(arg->buffer,
1011         "%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",
1012         dst_str, src0_reg, src0_reg, src0_reg, src0_reg, src0_reg, src0_reg, dst_mask);
1013 }
1014
1015 /** Process the D3DSIO_DST instruction in GLSL:
1016  * dst.x = 1.0
1017  * dst.y = src0.x * src0.y
1018  * dst.z = src0.z
1019  * dst.w = src1.w
1020  */
1021 void shader_glsl_dst(SHADER_OPCODE_ARG* arg) {
1022
1023     char dst_str[100], src0_str[100], src1_str[100];
1024     char dst_reg[50], src0_reg[50], src1_reg[50];
1025     char dst_mask[6], src0_mask[6], src1_mask[6];
1026
1027     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
1028     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
1029     shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str);
1030
1031     shader_addline(arg->buffer, "%s = vec4(1.0, %s.x * %s.y, %s.z, %s.w)%s;\n",
1032                    dst_str, src0_reg, src1_reg, src0_reg, src1_reg, dst_mask);
1033 }
1034
1035 /** Process the D3DSIO_SINCOS instruction in GLSL:
1036  * VS 2.0 requires that specific cosine and sine constants be passed to this instruction so the hardware
1037  * can handle it.  But, these functions are built-in for GLSL, so we can just ignore the last 2 params.
1038  *
1039  * dst.x = cos(src0.?)
1040  * dst.y = sin(src0.?)
1041  * dst.z = dst.z
1042  * dst.w = dst.w
1043  */
1044 void shader_glsl_sincos(SHADER_OPCODE_ARG* arg) {
1045
1046     char dst_str[100], src0_str[100];
1047     char dst_reg[50], src0_reg[50];
1048     char dst_mask[6], src0_mask[6];
1049
1050     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
1051     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
1052
1053     shader_addline(arg->buffer, "%s = vec4(cos(%s), sin(%s), %s.z, %s.w)%s;\n",
1054                    dst_str, src0_str, src0_str, dst_reg, dst_reg, dst_mask);
1055 }
1056
1057 /** Process the D3DSIO_LOOP instruction in GLSL:
1058  * Start a for() loop where src0.y is the initial value of aL,
1059  *  increment aL by src0.z while (aL < src0.x).
1060  */
1061 void shader_glsl_loop(SHADER_OPCODE_ARG* arg) {
1062
1063     char src0_str[100];
1064     char src0_reg[50];
1065     char src0_mask[6];
1066
1067     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str);
1068
1069     shader_addline(arg->buffer, "for (aL = %s.y; aL < %s.x; aL += %s.z) {\n",
1070             src0_reg, src0_reg, src0_reg);
1071 }
1072
1073 /** Process the D3DSIO_ENDLOOP instruction in GLSL:
1074  * End the for() loop
1075  */
1076 void shader_glsl_endloop(SHADER_OPCODE_ARG* arg) {
1077
1078     shader_addline(arg->buffer, "}\n");
1079 }
1080
1081
1082 /*********************************************
1083  * Pixel Shader Specific Code begins here
1084  ********************************************/
1085 void pshader_glsl_tex(SHADER_OPCODE_ARG* arg) {
1086
1087     /* FIXME: Make this work for more than just 2D textures */
1088
1089     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
1090     SHADER_BUFFER* buffer = arg->buffer;
1091     DWORD hex_version = This->baseShader.hex_version;
1092
1093     char dst_str[100],   dst_reg[50],  dst_mask[6];
1094     char coord_str[100], coord_reg[50], coord_mask[6];
1095     char sampler_str[100], sampler_reg[50], sampler_mask[6];
1096     DWORD reg_dest_code = arg->dst & D3DSP_REGNUM_MASK;
1097     DWORD sampler_code, sampler_type;
1098
1099     /* All versions have a destination register */
1100     shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str);
1101
1102     /* 1.0-1.3: Use destination register as coordinate source.
1103        1.4+: Use provided coordinate source register. */
1104     if (hex_version < D3DPS_VERSION(1,4))
1105        strcpy(coord_reg, dst_reg);
1106     else
1107        shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, coord_reg, coord_mask, coord_str);
1108
1109     /* 1.0-1.4: Use destination register as coordinate source.
1110      * 2.0+: Use provided coordinate source register. */
1111     if (hex_version < D3DPS_VERSION(2,0)) {
1112         sprintf(sampler_str, "Psampler%lu", reg_dest_code);
1113         sampler_code = reg_dest_code;
1114     }
1115     else {
1116         shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, sampler_reg, sampler_mask, sampler_str);
1117         sampler_code = arg->src[1] & D3DSP_REGNUM_MASK;
1118     }
1119
1120     sampler_type = arg->reg_maps->samplers[sampler_code] & D3DSP_TEXTURETYPE_MASK;
1121     switch(sampler_type) {
1122
1123         case D3DSTT_2D:
1124             shader_addline(buffer, "%s = texture2D(%s, %s.st);\n", dst_str, sampler_str, coord_reg);
1125             break;
1126         case D3DSTT_CUBE:
1127             shader_addline(buffer, "%s = textureCube(%s, %s.stp);\n", dst_str, sampler_str, coord_reg);
1128             break;
1129         case D3DSTT_VOLUME:
1130             shader_addline(buffer, "%s = texture3D(%s, %s.stp);\n", dst_str, sampler_str, coord_reg);
1131             break;
1132         default:
1133             shader_addline(buffer, "%s = unrecognized_stype(%s, %s.stp);\n", dst_str, sampler_str, coord_reg);
1134             FIXME("Unrecognized sampler type: %#lx;\n", sampler_type);
1135             break;
1136     }
1137 }
1138
1139 void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg) {
1140
1141     /* FIXME: Make this work for more than just 2D textures */
1142
1143     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
1144     SHADER_BUFFER* buffer = arg->buffer;
1145     DWORD hex_version = This->baseShader.hex_version;
1146
1147     char tmpStr[100];
1148     char tmpReg[50];
1149     char tmpMask[6];
1150     tmpReg[0] = 0;
1151
1152     shader_glsl_add_param(arg, arg->dst, 0, FALSE, tmpReg, tmpMask, tmpStr);
1153
1154     if (hex_version != D3DPS_VERSION(1,4)) {
1155         DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
1156         shader_addline(buffer, "%s = gl_TexCoord[%lu];\n", tmpReg, reg);
1157     } else {
1158         DWORD reg2 = arg->src[0] & D3DSP_REGNUM_MASK;
1159         shader_addline(buffer, "%s = gl_TexCoord[%lu]%s;\n", tmpStr, reg2, tmpMask);
1160    }
1161 }
1162
1163 void pshader_glsl_texm3x2pad(SHADER_OPCODE_ARG* arg) {
1164
1165     /* FIXME: Make this work for more than just 2D textures */
1166
1167     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
1168     SHADER_BUFFER* buffer = arg->buffer;
1169     char src0_str[100];
1170     char src0_name[50];
1171     char src0_mask[6];
1172
1173     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_name, src0_mask, src0_str);
1174     shader_addline(buffer, "tmp0.x = dot(vec3(T%lu), vec3(%s));\n", reg, src0_name, src0_mask, src0_str);
1175 }
1176
1177 void pshader_glsl_texm3x2tex(SHADER_OPCODE_ARG* arg) {
1178
1179     /* FIXME: Make this work for more than just 2D textures */
1180
1181     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
1182     SHADER_BUFFER* buffer = arg->buffer;
1183     char src0_str[100];
1184     char src0_name[50];
1185     char src0_mask[6];
1186
1187     shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_name, src0_mask, src0_str);
1188     shader_addline(buffer, "tmp0.y = dot(vec3(T%lu), vec3(%s));\n", reg, src0_str);
1189     shader_addline(buffer, "T%lu = texture2D(Psampler%lu, tmp0.st);\n", reg, reg);
1190 }
1191
1192 void pshader_glsl_input_pack(
1193    SHADER_BUFFER* buffer,
1194    DWORD* semantics_in) {
1195
1196    unsigned int i;
1197
1198    for (i = 0; i < WINED3DSHADERDECLUSAGE_MAX_USAGE; i++) {
1199
1200        DWORD reg = semantics_in[i];
1201        unsigned int regnum = reg & D3DSP_REGNUM_MASK;
1202        char reg_mask[6];
1203
1204        /* Uninitialized */
1205        if (!reg) continue;
1206
1207        shader_glsl_get_output_register_swizzle(reg, reg_mask);
1208
1209        switch(i) {
1210
1211            case WINED3DSHADERDECLUSAGE_DIFFUSE:
1212                shader_addline(buffer, "IN%lu%s = vec4(gl_Color)%s;\n",
1213                    regnum, reg_mask, reg_mask);
1214                break;
1215
1216            case WINED3DSHADERDECLUSAGE_SPECULAR:
1217                shader_addline(buffer, "IN%lu%s = vec4(gl_SecondaryColor)%s;\n",
1218                    regnum, reg_mask, reg_mask);
1219                break;
1220
1221            case WINED3DSHADERDECLUSAGE_TEXCOORD0:
1222            case WINED3DSHADERDECLUSAGE_TEXCOORD1:
1223            case WINED3DSHADERDECLUSAGE_TEXCOORD2:
1224            case WINED3DSHADERDECLUSAGE_TEXCOORD3:
1225            case WINED3DSHADERDECLUSAGE_TEXCOORD4:
1226            case WINED3DSHADERDECLUSAGE_TEXCOORD5:
1227            case WINED3DSHADERDECLUSAGE_TEXCOORD6:
1228            case WINED3DSHADERDECLUSAGE_TEXCOORD7:
1229                shader_addline(buffer, "IN%lu%s = vec4(gl_TexCoord[%lu])%s;\n",
1230                    regnum, reg_mask, i - WINED3DSHADERDECLUSAGE_TEXCOORD0, reg_mask );
1231                break;
1232
1233            case WINED3DSHADERDECLUSAGE_FOG:
1234                shader_addline(buffer, "IN%lu%s = vec4(gl_FogFragCoord)%s;\n",
1235                    regnum, reg_mask, reg_mask);
1236                break;
1237
1238            default:
1239                shader_addline(buffer, "IN%lu%s = vec4(unsupported_input)%s;\n",
1240                    regnum, reg_mask, reg_mask);
1241         }
1242     }
1243 }
1244
1245 /*********************************************
1246  * Vertex Shader Specific Code begins here
1247  ********************************************/
1248
1249 void vshader_glsl_output_unpack(
1250    SHADER_BUFFER* buffer,
1251    DWORD* semantics_out) {
1252
1253    unsigned int i;
1254
1255    for (i = 0; i < WINED3DSHADERDECLUSAGE_MAX_USAGE; i++) {
1256
1257        DWORD reg = semantics_out[i];
1258        unsigned int regnum = reg & D3DSP_REGNUM_MASK;
1259        char reg_mask[6];
1260
1261        /* Uninitialized */
1262        if (!reg) continue;
1263
1264        shader_glsl_get_output_register_swizzle(reg, reg_mask);
1265
1266        switch(i) {
1267
1268            case WINED3DSHADERDECLUSAGE_DIFFUSE:
1269                shader_addline(buffer, "gl_FrontColor%s = OUT%lu%s;\n", reg_mask, regnum, reg_mask);
1270                break;
1271
1272            case WINED3DSHADERDECLUSAGE_SPECULAR:
1273                shader_addline(buffer, "gl_FrontSecondaryColor%s = OUT%lu%s;\n", reg_mask, regnum, reg_mask);
1274                break;
1275
1276            case WINED3DSHADERDECLUSAGE_POSITION:
1277                shader_addline(buffer, "gl_Position%s = OUT%lu%s;\n", reg_mask, regnum, reg_mask);
1278                break;
1279
1280            case WINED3DSHADERDECLUSAGE_TEXCOORD0:
1281            case WINED3DSHADERDECLUSAGE_TEXCOORD1:
1282            case WINED3DSHADERDECLUSAGE_TEXCOORD2:
1283            case WINED3DSHADERDECLUSAGE_TEXCOORD3:
1284            case WINED3DSHADERDECLUSAGE_TEXCOORD4:
1285            case WINED3DSHADERDECLUSAGE_TEXCOORD5:
1286            case WINED3DSHADERDECLUSAGE_TEXCOORD6:
1287            case WINED3DSHADERDECLUSAGE_TEXCOORD7:
1288                shader_addline(buffer, "gl_TexCoord[%lu]%s = OUT%lu%s;\n",
1289                    i - WINED3DSHADERDECLUSAGE_TEXCOORD0, reg_mask, regnum, reg_mask);
1290                break;
1291
1292            case WINED3DSHADERDECLUSAGE_PSIZE:
1293                shader_addline(buffer, "gl_PointSize = OUT%lu.x;\n", regnum);
1294                break;
1295
1296            case WINED3DSHADERDECLUSAGE_FOG:
1297                shader_addline(buffer, "gl_FogFragCoord%s = OUT%lu%s;\n", reg_mask, regnum, reg_mask);
1298                break;
1299
1300            default:
1301                shader_addline(buffer, "unsupported_output%s = OUT%lu%s;\n", reg_mask, regnum, reg_mask);
1302       }
1303    }
1304 }