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

   1 /*
   2  * Pixel and vertex shaders implementation using ARB_vertex_program
   3  * and ARB_fragment_program GL extensions.
   4  *
   5  * Copyright 2002-2003 Jason Edmeades
   6  * Copyright 2002-2003 Raphael Junqueira
   7  * Copyright 2005 Oliver Stieber
   8  * Copyright 2006 Ivan Gyurdiev
   9  * Copyright 2006 Jason Green
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include "config.h"
  27
  28 #include <math.h>
  29 #include <stdio.h>
  30
  31 #include "wined3d_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  34
  35 #define GLINFO_LOCATION      (*gl_info)
  36
  37 /********************************************************
  38  * ARB_[vertex/fragment]_program helper functions follow
  39  ********************************************************/
  40
  41 /**
  42  * Loads floating point constants into the currently set ARB_vertex/fragment_program.
  43  * When @constants_set == NULL, it will load all the constants.
  44  *
  45  * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders)
  46  *  or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
  47  */
  48 void shader_arb_load_constantsF(
  49     WineD3D_GL_Info *gl_info,
  50     GLuint target_type,
  51     unsigned max_constants,
  52     float* constants,
  53     BOOL* constants_set) {
  54
  55     int i;
  56
  57     for (i=0; i<max_constants; ++i) {
  58         if (NULL == constants_set || constants_set[i]) {
  59             TRACE("Loading constants %i: %f, %f, %f, %f\n", i,
  60                   constants[i * sizeof(float) + 0], constants[i * sizeof(float) + 1],
  61                   constants[i * sizeof(float) + 2], constants[i * sizeof(float) + 3]);
  62
  63             GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, &constants[i * sizeof(float)]));
  64             checkGLcall("glProgramEnvParameter4fvARB");
  65         }
  66     }
  67 }
  68
  69 /**
  70  * Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs.
  71  *
  72  * We only support float constants in ARB at the moment, so don't
  73  * worry about the Integers or Booleans
  74  */
  75 void shader_arb_load_constants(
  76     IWineD3DStateBlock* iface,
  77     char usePixelShader,
  78     char useVertexShader) {
  79
  80     IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
  81     WineD3D_GL_Info *gl_info = &((IWineD3DImpl*)stateBlock->wineD3DDevice->wineD3D)->gl_info;
  82
  83     if (useVertexShader) {
  84         IWineD3DVertexShaderImpl* vshader = (IWineD3DVertexShaderImpl*) stateBlock->vertexShader;
  85         IWineD3DVertexDeclarationImpl* vertexDeclaration =
  86             (IWineD3DVertexDeclarationImpl*) vshader->vertexDeclaration;
  87
  88         if (NULL != vertexDeclaration && NULL != vertexDeclaration->constants) {
  89             /* Load DirectX 8 float constants for vertex shader */
  90             shader_arb_load_constantsF(gl_info, GL_VERTEX_PROGRAM_ARB,
  91                                        WINED3D_VSHADER_MAX_CONSTANTS,
  92                                        vertexDeclaration->constants, NULL);
  93         }
  94
  95         /* Load DirectX 9 float constants for vertex shader */
  96         shader_arb_load_constantsF(gl_info, GL_VERTEX_PROGRAM_ARB,
  97                                    WINED3D_VSHADER_MAX_CONSTANTS,
  98                                    stateBlock->vertexShaderConstantF,
  99                                    stateBlock->set.vertexShaderConstantsF);
 100     }
 101
 102     if (usePixelShader) {
 103
 104         /* Load DirectX 9 float constants for pixel shader */
 105         shader_arb_load_constantsF(gl_info, GL_FRAGMENT_PROGRAM_ARB, WINED3D_PSHADER_MAX_CONSTANTS,
 106                                    stateBlock->pixelShaderConstantF,
 107                                    stateBlock->set.pixelShaderConstantsF);
 108     }
 109 }
 110
 111 /* Generate the variable & register declarations for the ARB_vertex_program output target */
 112 void shader_generate_arb_declarations(
 113     IWineD3DBaseShader *iface,
 114     shader_reg_maps* reg_maps,
 115     SHADER_BUFFER* buffer) {
 116
 117     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 118     DWORD i;
 119
 120     for(i = 0; i < This->baseShader.limits.temporary; i++) {
 121         if (reg_maps->temporary[i])
 122             shader_addline(buffer, "TEMP R%lu;\n", i);
 123     }
 124
 125     for (i = 0; i < This->baseShader.limits.address; i++) {
 126         if (reg_maps->address[i])
 127             shader_addline(buffer, "ADDRESS A%ld;\n", i);
 128     }
 129
 130     for(i = 0; i < This->baseShader.limits.texcoord; i++) {
 131         if (reg_maps->texcoord[i])
 132             shader_addline(buffer,"TEMP T%lu;\n", i);
 133     }
 134
 135     /* Texture coordinate registers must be pre-loaded */
 136     for (i = 0; i < This->baseShader.limits.texcoord; i++) {
 137         if (reg_maps->texcoord[i])
 138             shader_addline(buffer, "MOV T%lu, fragment.texcoord[%lu];\n", i, i);
 139     }
 140
 141     /* Need to PARAM the environment parameters (constants) so we can use relative addressing */
 142     shader_addline(buffer, "PARAM C[%d] = { program.env[0..%d] };\n",
 143                    This->baseShader.limits.constant_float,
 144                    This->baseShader.limits.constant_float - 1);
 145 }
 146
 147 static const char* shift_tab[] = {
 148     "dummy",     /*  0 (none) */
 149     "coefmul.x", /*  1 (x2)   */
 150     "coefmul.y", /*  2 (x4)   */
 151     "coefmul.z", /*  3 (x8)   */
 152     "coefmul.w", /*  4 (x16)  */
 153     "dummy",     /*  5 (x32)  */
 154     "dummy",     /*  6 (x64)  */
 155     "dummy",     /*  7 (x128) */
 156     "dummy",     /*  8 (d256) */
 157     "dummy",     /*  9 (d128) */
 158     "dummy",     /* 10 (d64)  */
 159     "dummy",     /* 11 (d32)  */
 160     "coefdiv.w", /* 12 (d16)  */
 161     "coefdiv.z", /* 13 (d8)   */
 162     "coefdiv.y", /* 14 (d4)   */
 163     "coefdiv.x"  /* 15 (d2)   */
 164 };
 165
 166 static void pshader_get_write_mask(const DWORD output_reg, char *write_mask) {
 167     *write_mask = 0;
 168     if ((output_reg & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 169         strcat(write_mask, ".");
 170         if (output_reg & D3DSP_WRITEMASK_0) strcat(write_mask, "r");
 171         if (output_reg & D3DSP_WRITEMASK_1) strcat(write_mask, "g");
 172         if (output_reg & D3DSP_WRITEMASK_2) strcat(write_mask, "b");
 173         if (output_reg & D3DSP_WRITEMASK_3) strcat(write_mask, "a");
 174     }
 175 }
 176
 177 /* TODO: merge with pixel shader */
 178 static void vshader_program_add_output_param_swizzle(const DWORD param, int is_color, char *hwLine) {
 179     /** operand output */
 180     if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 181       strcat(hwLine, ".");
 182       if (param & D3DSP_WRITEMASK_0) { strcat(hwLine, "x"); }
 183       if (param & D3DSP_WRITEMASK_1) { strcat(hwLine, "y"); }
 184       if (param & D3DSP_WRITEMASK_2) { strcat(hwLine, "z"); }
 185       if (param & D3DSP_WRITEMASK_3) { strcat(hwLine, "w"); }
 186     }
 187 }
 188
 189 static void pshader_get_input_register_swizzle(const DWORD instr, char *swzstring) {
 190     static const char swizzle_reg_chars[] = "rgba";
 191     DWORD swizzle = (instr & D3DSP_SWIZZLE_MASK) >> D3DSP_SWIZZLE_SHIFT;
 192     DWORD swizzle_x = swizzle & 0x03;
 193     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 194     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 195     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 196     /**
 197      * swizzle bits fields:
 198      *  WWZZYYXX
 199      */
 200     *swzstring = 0;
 201     if ((D3DSP_NOSWIZZLE >> D3DSP_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 202         if (swizzle_x == swizzle_y &&
 203         swizzle_x == swizzle_z &&
 204         swizzle_x == swizzle_w) {
 205             sprintf(swzstring, ".%c", swizzle_reg_chars[swizzle_x]);
 206         } else {
 207             sprintf(swzstring, ".%c%c%c%c",
 208                 swizzle_reg_chars[swizzle_x],
 209                 swizzle_reg_chars[swizzle_y],
 210                 swizzle_reg_chars[swizzle_z],
 211                 swizzle_reg_chars[swizzle_w]);
 212         }
 213     }
 214 }
 215
 216 /* TODO: merge with pixel shader */
 217 static void vshader_program_add_input_param_swizzle(const DWORD param, int is_color, char *hwLine) {
 218     static const char swizzle_reg_chars_color_fix[] = "zyxw";
 219     static const char swizzle_reg_chars[] = "xyzw";
 220     const char* swizzle_regs = NULL;
 221     char  tmpReg[255];
 222
 223     /** operand input */
 224     DWORD swizzle = (param & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
 225     DWORD swizzle_x = swizzle & 0x03;
 226     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 227     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 228     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 229
 230     if (is_color) {
 231       swizzle_regs = swizzle_reg_chars_color_fix;
 232     } else {
 233       swizzle_regs = swizzle_reg_chars;
 234     }
 235
 236     /**
 237      * swizzle bits fields:
 238      *  WWZZYYXX
 239      */
 240     if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) { /* D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 241       if (is_color) {
 242         sprintf(tmpReg, ".%c%c%c%c",
 243                 swizzle_regs[swizzle_x],
 244                 swizzle_regs[swizzle_y],
 245                 swizzle_regs[swizzle_z],
 246                 swizzle_regs[swizzle_w]);
 247         strcat(hwLine, tmpReg);
 248       }
 249       return ;
 250     }
 251     if (swizzle_x == swizzle_y &&
 252         swizzle_x == swizzle_z &&
 253         swizzle_x == swizzle_w)
 254     {
 255       sprintf(tmpReg, ".%c", swizzle_regs[swizzle_x]);
 256       strcat(hwLine, tmpReg);
 257     } else {
 258       sprintf(tmpReg, ".%c%c%c%c",
 259               swizzle_regs[swizzle_x],
 260               swizzle_regs[swizzle_y],
 261               swizzle_regs[swizzle_z],
 262               swizzle_regs[swizzle_w]);
 263       strcat(hwLine, tmpReg);
 264     }
 265 }
 266
 267 static void pshader_get_register_name(const DWORD param, char* regstr, CHAR *constants) {
 268
 269     DWORD reg = param & D3DSP_REGNUM_MASK;
 270     DWORD regtype = shader_get_regtype(param);
 271
 272     switch (regtype) {
 273     case D3DSPR_TEMP:
 274         sprintf(regstr, "R%lu", reg);
 275     break;
 276     case D3DSPR_INPUT:
 277         if (reg==0) {
 278             strcpy(regstr, "fragment.color.primary");
 279         } else {
 280             strcpy(regstr, "fragment.color.secondary");
 281         }
 282     break;
 283     case D3DSPR_CONST:
 284         if (constants[reg])
 285             sprintf(regstr, "C%lu", reg);
 286         else
 287             sprintf(regstr, "C[%lu]", reg);
 288     break;
 289     case D3DSPR_TEXTURE: /* case D3DSPR_ADDR: */
 290         sprintf(regstr,"T%lu", reg);
 291     break;
 292     case D3DSPR_COLOROUT:
 293         if (reg == 0)
 294             sprintf(regstr, "result.color");
 295         else {
 296             /* TODO: See GL_ARB_draw_buffers */
 297             FIXME("Unsupported write to render target %lu\n", reg);
 298             sprintf(regstr, "unsupported_register");
 299         }
 300     break;
 301     case D3DSPR_DEPTHOUT:
 302         sprintf(regstr, "result.depth");
 303     break;
 304     case D3DSPR_ATTROUT:
 305         sprintf(regstr, "oD[%lu]", reg);
 306     break;
 307     case D3DSPR_TEXCRDOUT:
 308         sprintf(regstr, "oT[%lu]", reg);
 309     break;
 310     default:
 311         FIXME("Unhandled register name Type(%ld)\n", regtype);
 312         sprintf(regstr, "unrecognized_register");
 313     break;
 314     }
 315 }
 316
 317 /* TODO: merge with pixel shader */
 318 static void vshader_program_add_param(SHADER_OPCODE_ARG *arg, const DWORD param, BOOL is_input, char *hwLine) {
 319
 320   /* oPos, oFog and oPts in D3D */
 321   static const char* hwrastout_reg_names[] = { "result.position", "result.fogcoord", "result.pointsize" };
 322
 323   DWORD reg = param & D3DSP_REGNUM_MASK;
 324   DWORD regtype = shader_get_regtype(param);
 325   char  tmpReg[255];
 326   BOOL is_color = FALSE;
 327
 328   if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) {
 329       strcat(hwLine, " -");
 330   } else {
 331       strcat(hwLine, " ");
 332   }
 333
 334   switch (regtype) {
 335   case D3DSPR_TEMP:
 336     sprintf(tmpReg, "R%lu", reg);
 337     strcat(hwLine, tmpReg);
 338     break;
 339   case D3DSPR_INPUT:
 340
 341     if (arg->reg_maps->semantics_in[WINED3DSHADERDECLUSAGE_DIFFUSE] &&
 342         reg == (arg->reg_maps->semantics_in[WINED3DSHADERDECLUSAGE_DIFFUSE] & D3DSP_REGNUM_MASK))
 343         is_color = TRUE;
 344
 345     if (arg->reg_maps->semantics_in[WINED3DSHADERDECLUSAGE_SPECULAR] &&
 346         reg == (arg->reg_maps->semantics_in[WINED3DSHADERDECLUSAGE_SPECULAR] & D3DSP_REGNUM_MASK))
 347         is_color = TRUE;
 348
 349     /* FIXME: Shaders in 8.1 appear to not require a dcl statement - use
 350      * the reg value from the vertex declaration. However, usage map is not initialized
 351      * in that case - how can we know if an input contains color data or not? */
 352
 353     sprintf(tmpReg, "vertex.attrib[%lu]", reg);
 354     strcat(hwLine, tmpReg);
 355     break;
 356   case D3DSPR_CONST:
 357     /* FIXME: some constants are named so we need a constants map*/
 358     if (arg->reg_maps->constantsF[reg]) {
 359         if (param & D3DVS_ADDRMODE_RELATIVE) {
 360             FIXME("Relative addressing not expected for a named constant %lu\n", reg);
 361         }
 362         sprintf(tmpReg, "C%lu", reg);
 363     } else {
 364         sprintf(tmpReg, "C[%s%lu]", (param & D3DVS_ADDRMODE_RELATIVE) ? "A0.x + " : "", reg);
 365     }
 366     strcat(hwLine, tmpReg);
 367     break;
 368   case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 369     sprintf(tmpReg, "A%lu", reg);
 370     strcat(hwLine, tmpReg);
 371     break;
 372   case D3DSPR_RASTOUT:
 373     sprintf(tmpReg, "%s", hwrastout_reg_names[reg]);
 374     strcat(hwLine, tmpReg);
 375     break;
 376   case D3DSPR_ATTROUT:
 377     if (reg==0) {
 378        strcat(hwLine, "result.color.primary");
 379     } else {
 380        strcat(hwLine, "result.color.secondary");
 381     }
 382     break;
 383   case D3DSPR_TEXCRDOUT:
 384     sprintf(tmpReg, "result.texcoord[%lu]", reg);
 385     strcat(hwLine, tmpReg);
 386     break;
 387   default:
 388     FIXME("Unknown reg type %ld %ld\n", regtype, reg);
 389     strcat(hwLine, "unrecognized_register");
 390     break;
 391   }
 392
 393   if (!is_input) {
 394     vshader_program_add_output_param_swizzle(param, is_color, hwLine);
 395   } else {
 396     vshader_program_add_input_param_swizzle(param, is_color, hwLine);
 397   }
 398 }
 399
 400 static void pshader_gen_input_modifier_line (
 401     SHADER_BUFFER* buffer,
 402     const DWORD instr,
 403     int tmpreg,
 404     char *outregstr,
 405     CHAR *constants) {
 406
 407     /* Generate a line that does the input modifier computation and return the input register to use */
 408     char regstr[256];
 409     char swzstr[20];
 410     int insert_line;
 411
 412     /* Assume a new line will be added */
 413     insert_line = 1;
 414
 415     /* Get register name */
 416     pshader_get_register_name(instr, regstr, constants);
 417     pshader_get_input_register_swizzle(instr, swzstr);
 418
 419     switch (instr & D3DSP_SRCMOD_MASK) {
 420     case D3DSPSM_NONE:
 421         sprintf(outregstr, "%s%s", regstr, swzstr);
 422         insert_line = 0;
 423         break;
 424     case D3DSPSM_NEG:
 425         sprintf(outregstr, "-%s%s", regstr, swzstr);
 426         insert_line = 0;
 427         break;
 428     case D3DSPSM_BIAS:
 429         shader_addline(buffer, "ADD T%c, %s, -coefdiv.x;\n", 'A' + tmpreg, regstr);
 430         break;
 431     case D3DSPSM_BIASNEG:
 432         shader_addline(buffer, "ADD T%c, -%s, coefdiv.x;\n", 'A' + tmpreg, regstr);
 433         break;
 434     case D3DSPSM_SIGN:
 435         shader_addline(buffer, "MAD T%c, %s, coefmul.x, -one.x;\n", 'A' + tmpreg, regstr);
 436         break;
 437     case D3DSPSM_SIGNNEG:
 438         shader_addline(buffer, "MAD T%c, %s, -coefmul.x, one.x;\n", 'A' + tmpreg, regstr);
 439         break;
 440     case D3DSPSM_COMP:
 441         shader_addline(buffer, "SUB T%c, one.x, %s;\n", 'A' + tmpreg, regstr);
 442         break;
 443     case D3DSPSM_X2:
 444         shader_addline(buffer, "ADD T%c, %s, %s;\n", 'A' + tmpreg, regstr, regstr);
 445         break;
 446     case D3DSPSM_X2NEG:
 447         shader_addline(buffer, "ADD T%c, -%s, -%s;\n", 'A' + tmpreg, regstr, regstr);
 448         break;
 449     case D3DSPSM_DZ:
 450         shader_addline(buffer, "RCP T%c, %s.z;\n", 'A' + tmpreg, regstr);
 451         shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
 452         break;
 453     case D3DSPSM_DW:
 454         shader_addline(buffer, "RCP T%c, %s.w;\n", 'A' + tmpreg, regstr);
 455         shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
 456         break;
 457     default:
 458         sprintf(outregstr, "%s%s", regstr, swzstr);
 459         insert_line = 0;
 460     }
 461
 462     /* Return modified or original register, with swizzle */
 463     if (insert_line)
 464         sprintf(outregstr, "T%c%s", 'A' + tmpreg, swzstr);
 465 }
 466
 467 inline static void pshader_gen_output_modifier_line(
 468     SHADER_BUFFER* buffer,
 469     int saturate,
 470     char *write_mask,
 471     int shift,
 472     char *regstr) {
 473
 474     /* Generate a line that does the output modifier computation */
 475     shader_addline(buffer, "MUL%s %s%s, %s, %s;\n", saturate ? "_SAT" : "",
 476         regstr, write_mask, regstr, shift_tab[shift]);
 477 }
 478
 479 /** Process the D3DSIO_DEF opcode into an ARB string - creates a local vec4
 480  * float constant, and stores it's usage on the regmaps. */
 481 void shader_hw_def(SHADER_OPCODE_ARG* arg) {
 482
 483     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 484
 485     shader_addline(arg->buffer,
 486                    "PARAM C%lu = { %f, %f, %f, %f };\n", reg,
 487                    *((const float *)(arg->src + 0)),
 488                    *((const float *)(arg->src + 1)),
 489                    *((const float *)(arg->src + 2)),
 490                    *((const float *)(arg->src + 3)) );
 491
 492     arg->reg_maps->constantsF[reg] = 1;
 493 }
 494
 495 void pshader_hw_cnd(SHADER_OPCODE_ARG* arg) {
 496
 497     SHADER_BUFFER* buffer = arg->buffer;
 498     char dst_wmask[20];
 499     char dst_name[50];
 500     char src_name[3][50];
 501
 502     /* FIXME: support output modifiers */
 503
 504     /* Handle output register */
 505     pshader_get_register_name(arg->dst, dst_name, arg->reg_maps->constantsF);
 506     pshader_get_write_mask(arg->dst, dst_wmask);
 507     strcat(dst_name, dst_wmask);
 508
 509     /* Generate input register names (with modifiers) */
 510     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src_name[0], arg->reg_maps->constantsF);
 511     pshader_gen_input_modifier_line(buffer, arg->src[1], 1, src_name[1], arg->reg_maps->constantsF);
 512     pshader_gen_input_modifier_line(buffer, arg->src[2], 2, src_name[2], arg->reg_maps->constantsF);
 513
 514     shader_addline(buffer, "ADD TMP, -%s, coefdiv.x;\n", src_name[0]);
 515     shader_addline(buffer, "CMP %s, TMP, %s, %s;\n", dst_name, src_name[1], src_name[2]);
 516 }
 517
 518 void pshader_hw_cmp(SHADER_OPCODE_ARG* arg) {
 519
 520     SHADER_BUFFER* buffer = arg->buffer;
 521     char dst_wmask[20];
 522     char dst_name[50];
 523     char src_name[3][50];
 524
 525     /* FIXME: support output modifiers */
 526
 527     /* Handle output register */
 528     pshader_get_register_name(arg->dst, dst_name, arg->reg_maps->constantsF);
 529     pshader_get_write_mask(arg->dst, dst_wmask);
 530     strcat(dst_name, dst_wmask);
 531
 532     /* Generate input register names (with modifiers) */
 533     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src_name[0], arg->reg_maps->constantsF);
 534     pshader_gen_input_modifier_line(buffer, arg->src[1], 1, src_name[1], arg->reg_maps->constantsF);
 535     pshader_gen_input_modifier_line(buffer, arg->src[2], 2, src_name[2], arg->reg_maps->constantsF);
 536
 537     shader_addline(buffer, "CMP %s, %s, %s, %s;\n", dst_name,
 538         src_name[0], src_name[2], src_name[1]);
 539 }
 540
 541 /* Map the opcode 1-to-1 to the GL code */
 542 void pshader_hw_map2gl(SHADER_OPCODE_ARG* arg) {
 543
 544      CONST SHADER_OPCODE* curOpcode = arg->opcode;
 545      SHADER_BUFFER* buffer = arg->buffer;
 546      DWORD dst = arg->dst;
 547      DWORD* src = arg->src;
 548
 549      unsigned int i;
 550      char tmpLine[256];
 551
 552      /* Output token related */
 553      char output_rname[256];
 554      char output_wmask[20];
 555      BOOL saturate = FALSE;
 556      BOOL centroid = FALSE;
 557      BOOL partialprecision = FALSE;
 558      DWORD shift;
 559
 560      strcpy(tmpLine, curOpcode->glname);
 561
 562      /* Process modifiers */
 563      if (0 != (dst & D3DSP_DSTMOD_MASK)) {
 564          DWORD mask = dst & D3DSP_DSTMOD_MASK;
 565
 566          saturate = mask & D3DSPDM_SATURATE;
 567          centroid = mask & D3DSPDM_MSAMPCENTROID;
 568          partialprecision = mask & D3DSPDM_PARTIALPRECISION;
 569          mask &= ~(D3DSPDM_MSAMPCENTROID | D3DSPDM_PARTIALPRECISION | D3DSPDM_SATURATE);
 570          if (mask)
 571             FIXME("Unrecognized modifier(0x%#lx)\n", mask >> D3DSP_DSTMOD_SHIFT);
 572
 573          if (centroid)
 574              FIXME("Unhandled modifier(0x%#lx)\n", mask >> D3DSP_DSTMOD_SHIFT);
 575      }
 576      shift = (dst & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
 577
 578       /* Generate input and output registers */
 579       if (curOpcode->num_params > 0) {
 580           char operands[4][100];
 581
 582           /* Generate input register names (with modifiers) */
 583           for (i = 1; i < curOpcode->num_params; ++i)
 584               pshader_gen_input_modifier_line(buffer, src[i-1], i-1, operands[i], arg->reg_maps->constantsF);
 585
 586           /* Handle output register */
 587           pshader_get_register_name(dst, output_rname, arg->reg_maps->constantsF);
 588           strcpy(operands[0], output_rname);
 589           pshader_get_write_mask(dst, output_wmask);
 590           strcat(operands[0], output_wmask);
 591
 592           if (saturate && (shift == 0))
 593              strcat(tmpLine, "_SAT");
 594           strcat(tmpLine, " ");
 595           strcat(tmpLine, operands[0]);
 596           for (i = 1; i < curOpcode->num_params; i++) {
 597               strcat(tmpLine, ", ");
 598               strcat(tmpLine, operands[i]);
 599           }
 600           strcat(tmpLine,";\n");
 601           shader_addline(buffer, tmpLine);
 602
 603           /* A shift requires another line. */
 604           if (shift != 0)
 605               pshader_gen_output_modifier_line(buffer, saturate, output_wmask, shift, output_rname);
 606       }
 607 }
 608
 609 void pshader_hw_tex(SHADER_OPCODE_ARG* arg) {
 610
 611     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 612     DWORD dst = arg->dst;
 613     DWORD* src = arg->src;
 614     SHADER_BUFFER* buffer = arg->buffer;
 615     DWORD hex_version = This->baseShader.hex_version;
 616
 617     char reg_dest[40];
 618     char reg_coord[40];
 619     DWORD reg_dest_code;
 620     DWORD reg_sampler_code;
 621
 622     /* All versions have a destination register */
 623     reg_dest_code = dst & D3DSP_REGNUM_MASK;
 624     pshader_get_register_name(dst, reg_dest, arg->reg_maps->constantsF);
 625
 626     /* 1.0-1.3: Use destination register as coordinate source.
 627        1.4+: Use provided coordinate source register. */
 628    if (hex_version < D3DPS_VERSION(1,4))
 629       strcpy(reg_coord, reg_dest);
 630    else
 631       pshader_gen_input_modifier_line(buffer, src[0], 0, reg_coord, arg->reg_maps->constantsF);
 632
 633   /* 1.0-1.4: Use destination register number as texture code.
 634      2.0+: Use provided sampler number as texure code. */
 635   if (hex_version < D3DPS_VERSION(2,0))
 636      reg_sampler_code = reg_dest_code;
 637   else
 638      reg_sampler_code = src[1] & D3DSP_REGNUM_MASK;
 639
 640   shader_addline(buffer, "TEX %s, %s, texture[%lu], 2D;\n",
 641       reg_dest, reg_coord, reg_sampler_code);
 642 }
 643
 644 void pshader_hw_texcoord(SHADER_OPCODE_ARG* arg) {
 645
 646     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 647     DWORD dst = arg->dst;
 648     DWORD* src = arg->src;
 649     SHADER_BUFFER* buffer = arg->buffer;
 650     DWORD hex_version = This->baseShader.hex_version;
 651
 652     char tmp[20];
 653     pshader_get_write_mask(dst, tmp);
 654     if (hex_version != D3DPS_VERSION(1,4)) {
 655         DWORD reg = dst & D3DSP_REGNUM_MASK;
 656         shader_addline(buffer, "MOV T%lu%s, fragment.texcoord[%lu];\n", reg, tmp, reg);
 657     } else {
 658         DWORD reg1 = dst & D3DSP_REGNUM_MASK;
 659         DWORD reg2 = src[0] & D3DSP_REGNUM_MASK;
 660         shader_addline(buffer, "MOV R%lu%s, fragment.texcoord[%lu];\n", reg1, tmp, reg2);
 661    }
 662 }
 663
 664 void pshader_hw_texreg2ar(SHADER_OPCODE_ARG* arg) {
 665
 666      SHADER_BUFFER* buffer = arg->buffer;
 667
 668      DWORD reg1 = arg->dst & D3DSP_REGNUM_MASK;
 669      DWORD reg2 = arg->src[0] & D3DSP_REGNUM_MASK;
 670      shader_addline(buffer, "MOV TMP.r, T%lu.a;\n", reg2);
 671      shader_addline(buffer, "MOV TMP.g, T%lu.r;\n", reg2);
 672      shader_addline(buffer, "TEX T%lu, TMP, texture[%lu], 2D;\n", reg1, reg1);
 673 }
 674
 675 void pshader_hw_texreg2gb(SHADER_OPCODE_ARG* arg) {
 676
 677      SHADER_BUFFER* buffer = arg->buffer;
 678
 679      DWORD reg1 = arg->dst & D3DSP_REGNUM_MASK;
 680      DWORD reg2 = arg->src[0] & D3DSP_REGNUM_MASK;
 681      shader_addline(buffer, "MOV TMP.r, T%lu.g;\n", reg2);
 682      shader_addline(buffer, "MOV TMP.g, T%lu.b;\n", reg2);
 683      shader_addline(buffer, "TEX T%lu, TMP, texture[%lu], 2D;\n", reg1, reg1);
 684 }
 685
 686 void pshader_hw_texbem(SHADER_OPCODE_ARG* arg) {
 687
 688      SHADER_BUFFER* buffer = arg->buffer;
 689      DWORD reg1 = arg->dst  & D3DSP_REGNUM_MASK;
 690      DWORD reg2 = arg->src[0] & D3DSP_REGNUM_MASK;
 691
 692      /* FIXME: Should apply the BUMPMAPENV matrix */
 693      shader_addline(buffer, "ADD TMP.rg, fragment.texcoord[%lu], T%lu;\n", reg1, reg2);
 694      shader_addline(buffer, "TEX T%lu, TMP, texture[%lu], 2D;\n", reg1, reg1);
 695 }
 696
 697 void pshader_hw_texm3x2pad(SHADER_OPCODE_ARG* arg) {
 698
 699     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 700     SHADER_BUFFER* buffer = arg->buffer;
 701     char src0_name[50];
 702
 703     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name, arg->reg_maps->constantsF);
 704     shader_addline(buffer, "DP3 TMP.x, T%lu, %s;\n", reg, src0_name);
 705 }
 706
 707 void pshader_hw_texm3x2tex(SHADER_OPCODE_ARG* arg) {
 708
 709     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 710     SHADER_BUFFER* buffer = arg->buffer;
 711     char src0_name[50];
 712
 713     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name, arg->reg_maps->constantsF);
 714     shader_addline(buffer, "DP3 TMP.y, T%lu, %s;\n", reg, src0_name);
 715     shader_addline(buffer, "TEX T%lu, TMP, texture[%lu], 2D;\n", reg, reg);
 716 }
 717
 718 void pshader_hw_texm3x3pad(SHADER_OPCODE_ARG* arg) {
 719
 720     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 721     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 722     SHADER_BUFFER* buffer = arg->buffer;
 723     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 724     char src0_name[50];
 725
 726     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name, arg->reg_maps->constantsF);
 727     shader_addline(buffer, "DP3 TMP.%c, T%lu, %s;\n", 'x' + current_state->current_row, reg, src0_name);
 728     current_state->texcoord_w[current_state->current_row++] = reg;
 729 }
 730
 731 void pshader_hw_texm3x3tex(SHADER_OPCODE_ARG* arg) {
 732
 733     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 734     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 735     SHADER_BUFFER* buffer = arg->buffer;
 736     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 737     char src0_name[50];
 738
 739     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name, arg->reg_maps->constantsF);
 740     shader_addline(buffer, "DP3 TMP.z, T%lu, %s;\n", reg, src0_name);
 741
 742     /* Cubemap textures will be more used than 3D ones. */
 743     shader_addline(buffer, "TEX T%lu, TMP, texture[%lu], CUBE;\n", reg, reg);
 744     current_state->current_row = 0;
 745 }
 746
 747 void pshader_hw_texm3x3vspec(SHADER_OPCODE_ARG* arg) {
 748
 749     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 750     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 751     SHADER_BUFFER* buffer = arg->buffer;
 752     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 753     char src0_name[50];
 754
 755     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name, arg->reg_maps->constantsF);
 756     shader_addline(buffer, "DP3 TMP.z, T%lu, %s;\n", reg, src0_name);
 757
 758     /* Construct the eye-ray vector from w coordinates */
 759     shader_addline(buffer, "MOV TMP2.x, fragment.texcoord[%lu].w;\n", current_state->texcoord_w[0]);
 760     shader_addline(buffer, "MOV TMP2.y, fragment.texcoord[%lu].w;\n", current_state->texcoord_w[1]);
 761     shader_addline(buffer, "MOV TMP2.z, fragment.texcoord[%lu].w;\n", reg);
 762
 763     /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
 764     shader_addline(buffer, "DP3 TMP.w, TMP, TMP2;\n");
 765     shader_addline(buffer, "MUL TMP, TMP.w, TMP;\n");
 766     shader_addline(buffer, "MAD TMP, coefmul.x, TMP, -TMP2;\n");
 767
 768     /* Cubemap textures will be more used than 3D ones. */
 769     shader_addline(buffer, "TEX T%lu, TMP, texture[%lu], CUBE;\n", reg, reg);
 770     current_state->current_row = 0;
 771 }
 772
 773 void pshader_hw_texm3x3spec(SHADER_OPCODE_ARG* arg) {
 774
 775     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 776     DWORD reg = arg->dst & D3DSP_REGNUM_MASK;
 777     DWORD reg3 = arg->src[1] & D3DSP_REGNUM_MASK;
 778     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 779     SHADER_BUFFER* buffer = arg->buffer;
 780     char src0_name[50];
 781
 782     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name, arg->reg_maps->constantsF);
 783     shader_addline(buffer, "DP3 TMP.z, T%lu, %s;\n", reg, src0_name);
 784
 785     /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
 786     shader_addline(buffer, "DP3 TMP.w, TMP, C[%lu];\n", reg3);
 787     shader_addline(buffer, "MUL TMP, TMP.w, TMP;\n");
 788     shader_addline(buffer, "MAD TMP, coefmul.x, TMP, -C[%lu];\n", reg3);
 789
 790     /* Cubemap textures will be more used than 3D ones. */
 791     shader_addline(buffer, "TEX T%lu, TMP, texture[%lu], CUBE;\n", reg, reg);
 792     current_state->current_row = 0;
 793 }
 794
 795 /** Handles transforming all D3DSIO_M?x? opcodes for
 796     Vertex shaders to ARB_vertex_program codes */
 797 void vshader_hw_mnxn(SHADER_OPCODE_ARG* arg) {
 798
 799     int i;
 800     int nComponents = 0;
 801     SHADER_OPCODE_ARG tmpArg;
 802
 803     /* Set constants for the temporary argument */
 804     tmpArg.shader   = arg->shader;
 805     tmpArg.buffer   = arg->buffer;
 806     tmpArg.src[0]   = arg->src[0];
 807
 808     switch(arg->opcode->opcode) {
 809     case D3DSIO_M4x4:
 810         nComponents = 4;
 811         tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP4];
 812         break;
 813     case D3DSIO_M4x3:
 814         nComponents = 3;
 815         tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP4];
 816         break;
 817     case D3DSIO_M3x4:
 818         nComponents = 4;
 819         tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP3];
 820         break;
 821     case D3DSIO_M3x3:
 822         nComponents = 3;
 823         tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP3];
 824         break;
 825     case D3DSIO_M3x2:
 826         nComponents = 2;
 827         tmpArg.opcode = &IWineD3DVertexShaderImpl_shader_ins[D3DSIO_DP3];
 828         break;
 829     default:
 830         break;
 831     }
 832
 833     for (i = 0; i < nComponents; i++) {
 834         tmpArg.dst = ((arg->dst) & ~D3DSP_WRITEMASK_ALL)|(D3DSP_WRITEMASK_0<<i);
 835         tmpArg.src[1] = arg->src[1]+i;
 836         vshader_hw_map2gl(&tmpArg);
 837     }
 838 }
 839
 840 /* TODO: merge with pixel shader */
 841 /* Map the opcode 1-to-1 to the GL code */
 842 void vshader_hw_map2gl(SHADER_OPCODE_ARG* arg) {
 843
 844     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 845     SHADER_BUFFER* buffer = arg->buffer;
 846     DWORD dst = arg->dst;
 847     DWORD* src = arg->src;
 848
 849     DWORD dst_regtype = shader_get_regtype(dst);
 850     char tmpLine[256];
 851     unsigned int i;
 852
 853     if (curOpcode->opcode == D3DSIO_MOV && dst_regtype == D3DSPR_ADDR)
 854         strcpy(tmpLine, "ARL");
 855     else
 856         strcpy(tmpLine, curOpcode->glname);
 857
 858     if (curOpcode->num_params > 0) {
 859         vshader_program_add_param(arg, dst, FALSE, tmpLine);
 860         for (i = 1; i < curOpcode->num_params; ++i) {
 861            strcat(tmpLine, ",");
 862            vshader_program_add_param(arg, src[i-1], TRUE, tmpLine);
 863         }
 864     }
 865    shader_addline(buffer, "%s;\n", tmpLine);
 866 }