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