dlls/d3dx9_36/asmutils.c

   1 /*
   2  * Direct3D shader library utility routines
   3  *
   4  * Copyright 2008 Stefan Dösinger
   5  * Copyright 2009 Matteo Bruni
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "wine/debug.h"
  25
  26 #include "d3dx9_36_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(asmshader);
  29
  30 /* bwriter -> d3d9 conversion functions */
  31 DWORD d3d9_swizzle(DWORD bwriter_swizzle) {
  32     /* Currently a NOP, but this allows changing the internal definitions
  33      * without side effects
  34      */
  35     DWORD ret = 0;
  36
  37     if((bwriter_swizzle & BWRITERVS_X_X) == BWRITERVS_X_X) ret |= D3DVS_X_X;
  38     if((bwriter_swizzle & BWRITERVS_X_Y) == BWRITERVS_X_Y) ret |= D3DVS_X_Y;
  39     if((bwriter_swizzle & BWRITERVS_X_Z) == BWRITERVS_X_Z) ret |= D3DVS_X_Z;
  40     if((bwriter_swizzle & BWRITERVS_X_W) == BWRITERVS_X_W) ret |= D3DVS_X_W;
  41
  42     if((bwriter_swizzle & BWRITERVS_Y_X) == BWRITERVS_Y_X) ret |= D3DVS_Y_X;
  43     if((bwriter_swizzle & BWRITERVS_Y_Y) == BWRITERVS_Y_Y) ret |= D3DVS_Y_Y;
  44     if((bwriter_swizzle & BWRITERVS_Y_Z) == BWRITERVS_Y_Z) ret |= D3DVS_Y_Z;
  45     if((bwriter_swizzle & BWRITERVS_Y_W) == BWRITERVS_Y_W) ret |= D3DVS_Y_W;
  46
  47     if((bwriter_swizzle & BWRITERVS_Z_X) == BWRITERVS_Z_X) ret |= D3DVS_Z_X;
  48     if((bwriter_swizzle & BWRITERVS_Z_Y) == BWRITERVS_Z_Y) ret |= D3DVS_Z_Y;
  49     if((bwriter_swizzle & BWRITERVS_Z_Z) == BWRITERVS_Z_Z) ret |= D3DVS_Z_Z;
  50     if((bwriter_swizzle & BWRITERVS_Z_W) == BWRITERVS_Z_W) ret |= D3DVS_Z_W;
  51
  52     if((bwriter_swizzle & BWRITERVS_W_X) == BWRITERVS_W_X) ret |= D3DVS_W_X;
  53     if((bwriter_swizzle & BWRITERVS_W_Y) == BWRITERVS_W_Y) ret |= D3DVS_W_Y;
  54     if((bwriter_swizzle & BWRITERVS_W_Z) == BWRITERVS_W_Z) ret |= D3DVS_W_Z;
  55     if((bwriter_swizzle & BWRITERVS_W_W) == BWRITERVS_W_W) ret |= D3DVS_W_W;
  56
  57     return ret;
  58 }
  59
  60 DWORD d3d9_writemask(DWORD bwriter_writemask) {
  61     DWORD ret = 0;
  62
  63     if(bwriter_writemask & BWRITERSP_WRITEMASK_0) ret |= D3DSP_WRITEMASK_0;
  64     if(bwriter_writemask & BWRITERSP_WRITEMASK_1) ret |= D3DSP_WRITEMASK_1;
  65     if(bwriter_writemask & BWRITERSP_WRITEMASK_2) ret |= D3DSP_WRITEMASK_2;
  66     if(bwriter_writemask & BWRITERSP_WRITEMASK_3) ret |= D3DSP_WRITEMASK_3;
  67
  68     return ret;
  69 }
  70
  71 DWORD d3d9_srcmod(DWORD bwriter_srcmod) {
  72     switch(bwriter_srcmod) {
  73         case BWRITERSPSM_NONE:       return D3DSPSM_NONE;
  74         case BWRITERSPSM_NEG:        return D3DSPSM_NEG;
  75         case BWRITERSPSM_ABS:        return D3DSPSM_ABS;
  76         case BWRITERSPSM_ABSNEG:     return D3DSPSM_ABSNEG;
  77         default:
  78             FIXME("Unhandled BWRITERSPSM token %u\n", bwriter_srcmod);
  79             return 0;
  80     }
  81 }
  82
  83 DWORD d3d9_dstmod(DWORD bwriter_mod) {
  84     DWORD ret = 0;
  85
  86     if(bwriter_mod & BWRITERSPDM_SATURATE)          ret |= D3DSPDM_SATURATE;
  87     if(bwriter_mod & BWRITERSPDM_PARTIALPRECISION)  ret |= D3DSPDM_PARTIALPRECISION;
  88     if(bwriter_mod & BWRITERSPDM_MSAMPCENTROID)     ret |= D3DSPDM_MSAMPCENTROID;
  89
  90     return ret;
  91 }
  92
  93 DWORD d3d9_register(DWORD bwriter_register) {
  94     if(bwriter_register == BWRITERSPR_TEMP)         return D3DSPR_TEMP;
  95     if(bwriter_register == BWRITERSPR_INPUT)        return D3DSPR_INPUT;
  96     if(bwriter_register == BWRITERSPR_CONST)        return D3DSPR_CONST;
  97     if(bwriter_register == BWRITERSPR_ADDR)         return D3DSPR_ADDR;
  98     if(bwriter_register == BWRITERSPR_TEXTURE)      return D3DSPR_TEXTURE;
  99     if(bwriter_register == BWRITERSPR_RASTOUT)      return D3DSPR_RASTOUT;
 100     if(bwriter_register == BWRITERSPR_ATTROUT)      return D3DSPR_ATTROUT;
 101     if(bwriter_register == BWRITERSPR_TEXCRDOUT)    return D3DSPR_TEXCRDOUT;
 102     if(bwriter_register == BWRITERSPR_OUTPUT)       return D3DSPR_OUTPUT;
 103     if(bwriter_register == BWRITERSPR_CONSTINT)     return D3DSPR_CONSTINT;
 104     if(bwriter_register == BWRITERSPR_COLOROUT)     return D3DSPR_COLOROUT;
 105     if(bwriter_register == BWRITERSPR_DEPTHOUT)     return D3DSPR_DEPTHOUT;
 106     if(bwriter_register == BWRITERSPR_SAMPLER)      return D3DSPR_SAMPLER;
 107     if(bwriter_register == BWRITERSPR_CONSTBOOL)    return D3DSPR_CONSTBOOL;
 108     if(bwriter_register == BWRITERSPR_LOOP)         return D3DSPR_LOOP;
 109     if(bwriter_register == BWRITERSPR_MISCTYPE)     return D3DSPR_MISCTYPE;
 110     if(bwriter_register == BWRITERSPR_LABEL)        return D3DSPR_LABEL;
 111     if(bwriter_register == BWRITERSPR_PREDICATE)    return D3DSPR_PREDICATE;
 112
 113     FIXME("Unexpected BWRITERSPR %u\n", bwriter_register);
 114     return -1;
 115 }
 116
 117 DWORD d3d9_opcode(DWORD bwriter_opcode) {
 118     switch(bwriter_opcode) {
 119         case BWRITERSIO_MOV:         return D3DSIO_MOV;
 120
 121         case BWRITERSIO_COMMENT:     return D3DSIO_COMMENT;
 122         case BWRITERSIO_END:         return D3DSIO_END;
 123
 124         default:
 125             FIXME("Unhandled BWRITERSIO token %u\n", bwriter_opcode);
 126             return -1;
 127     }
 128 }
 129
 130 /* Debug print functions */
 131 const char *debug_print_srcmod(DWORD mod) {
 132     switch(mod) {
 133         case BWRITERSPSM_NEG:       return "D3DSPSM_NEG";
 134         case BWRITERSPSM_ABS:       return "D3DSPSM_ABS";
 135         case BWRITERSPSM_ABSNEG:    return "D3DSPSM_ABSNEG";
 136         default:                    return "Unknown source modifier\n";
 137     }
 138 }
 139
 140 const char *debug_print_dstmod(DWORD mod) {
 141     switch(mod) {
 142         case 0:
 143             return "";
 144
 145         case BWRITERSPDM_SATURATE:
 146             return "_sat";
 147         case BWRITERSPDM_PARTIALPRECISION:
 148             return "_pp";
 149         case BWRITERSPDM_MSAMPCENTROID:
 150             return "_centroid";
 151
 152         case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION:
 153             return "_sat_pp";
 154         case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID:
 155             return "_sat_centroid";
 156         case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
 157             return "_pp_centroid";
 158
 159         case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
 160             return "_sat_pp_centroid";
 161
 162         default:
 163             return "Unexpected modifier\n";
 164     }
 165 }
 166
 167 static const char *get_regname(const struct shader_reg *reg, shader_type st) {
 168     switch(reg->type) {
 169         case BWRITERSPR_TEMP:
 170             return wine_dbg_sprintf("r%u", reg->regnum);
 171         case BWRITERSPR_INPUT:
 172             return wine_dbg_sprintf("v%u", reg->regnum);
 173         case BWRITERSPR_CONST:
 174             return wine_dbg_sprintf("c%u", reg->regnum);
 175         /* case BWRITERSPR_ADDR: */
 176         case BWRITERSPR_TEXTURE:
 177             if(st == ST_VERTEX) {
 178                 return wine_dbg_sprintf("a%u", reg->regnum);
 179             } else {
 180                 return wine_dbg_sprintf("t%u", reg->regnum);
 181             }
 182         case BWRITERSPR_RASTOUT:
 183             switch(reg->regnum) {
 184                 case BWRITERSRO_POSITION:   return "oPos";
 185                 case BWRITERSRO_FOG:        return "oFog";
 186                 case BWRITERSRO_POINT_SIZE: return "oPts";
 187                 default: return "Unexpected RASTOUT";
 188             }
 189         case BWRITERSPR_ATTROUT:
 190             return wine_dbg_sprintf("oD%u", reg->regnum);
 191         /* case BWRITERSPR_TEXCRDOUT: */
 192         case BWRITERSPR_OUTPUT:
 193             return wine_dbg_sprintf("o[T]%u", reg->regnum);
 194         case BWRITERSPR_CONSTINT:
 195             return wine_dbg_sprintf("i%u", reg->regnum);
 196         case BWRITERSPR_COLOROUT:
 197             return wine_dbg_sprintf("oC%u", reg->regnum);
 198         case BWRITERSPR_DEPTHOUT:
 199             return "oDepth";
 200         case BWRITERSPR_SAMPLER:
 201             return wine_dbg_sprintf("s%u", reg->regnum);
 202         case BWRITERSPR_CONSTBOOL:
 203             return wine_dbg_sprintf("b%u", reg->regnum);
 204         case BWRITERSPR_LOOP:
 205             return "aL";
 206         case BWRITERSPR_MISCTYPE:
 207             switch(reg->regnum) {
 208                 case 0: return "vPos";
 209                 case 1: return "vFace";
 210                 case 2: return "unexpected misctype";
 211             }
 212         case BWRITERSPR_LABEL:
 213             return wine_dbg_sprintf("l%u", reg->regnum);
 214         case BWRITERSPR_PREDICATE:
 215             return wine_dbg_sprintf("p%u", reg->regnum);
 216         default: return "unknown regname";
 217     }
 218 }
 219
 220 const char *debug_print_writemask(DWORD mask) {
 221     char ret[6];
 222     unsigned char pos = 1;
 223
 224     if(mask == BWRITERSP_WRITEMASK_ALL) return "";
 225     ret[0] = '.';
 226     if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
 227     if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
 228     if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
 229     if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
 230     ret[pos] = 0;
 231     return wine_dbg_sprintf("%s", ret);
 232 }
 233
 234 const char *debug_print_relarg(const struct shader_reg *reg) {
 235     const char *short_swizzle;
 236     if(!reg->rel_reg) return "";
 237
 238     short_swizzle = debug_print_swizzle(reg->rel_reg->swizzle);
 239
 240     if(reg->rel_reg->type == BWRITERSPR_ADDR) {
 241         return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle);
 242     } else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0) {
 243         return wine_dbg_sprintf("[aL%s]", short_swizzle);
 244     } else {
 245         return "Unexpected relative addressing argument";
 246     }
 247 }
 248
 249 const char *debug_print_dstreg(const struct shader_reg *reg, shader_type st) {
 250     return wine_dbg_sprintf("%s%s%s", get_regname(reg, st),
 251                             debug_print_relarg(reg),
 252                             debug_print_writemask(reg->writemask));
 253 }
 254
 255 const char *debug_print_swizzle(DWORD arg) {
 256     char ret[6];
 257     unsigned int i;
 258     DWORD swizzle[4];
 259
 260     switch(arg) {
 261         case BWRITERVS_NOSWIZZLE:
 262             return "";
 263         case BWRITERVS_SWIZZLE_X:
 264             return ".x";
 265         case BWRITERVS_SWIZZLE_Y:
 266             return ".y";
 267         case BWRITERVS_SWIZZLE_Z:
 268             return ".z";
 269         case BWRITERVS_SWIZZLE_W:
 270             return ".w";
 271     }
 272
 273     swizzle[0] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 0)) & 0x03;
 274     swizzle[1] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 2)) & 0x03;
 275     swizzle[2] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 4)) & 0x03;
 276     swizzle[3] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 6)) & 0x03;
 277
 278     ret[0] = '.';
 279     for(i = 0; i < 4; i++) {
 280         switch(swizzle[i]) {
 281             case 0: ret[1 + i] = 'x'; break;
 282             case 1: ret[1 + i] = 'y'; break;
 283             case 2: ret[1 + i] = 'z'; break;
 284             case 3: ret[1 + i] = 'w'; break;
 285         }
 286     }
 287     ret[5] = '\0';
 288     return wine_dbg_sprintf("%s", ret);
 289 }
 290
 291 const char *debug_print_srcreg(const struct shader_reg *reg, shader_type st) {
 292     switch(reg->srcmod) {
 293         case BWRITERSPSM_NONE:
 294             return wine_dbg_sprintf("%s%s%s", get_regname(reg, st),
 295                                     debug_print_relarg(reg),
 296                                     debug_print_swizzle(reg->swizzle));
 297         case BWRITERSPSM_NEG:
 298             return wine_dbg_sprintf("-%s%s%s", get_regname(reg, st),
 299                                     debug_print_relarg(reg),
 300                                     debug_print_swizzle(reg->swizzle));
 301         case BWRITERSPSM_ABS:
 302             return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg, st),
 303                                     debug_print_relarg(reg),
 304                                     debug_print_swizzle(reg->swizzle));
 305         case BWRITERSPSM_ABSNEG:
 306             return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg, st),
 307                                     debug_print_relarg(reg),
 308                                     debug_print_swizzle(reg->swizzle));
 309     }
 310     return "Unknown modifier";
 311 }
 312
 313 const char *debug_print_opcode(DWORD opcode) {
 314     switch(opcode){
 315         case BWRITERSIO_MOV:          return "mov";
 316
 317         default:                      return "unknown";
 318     }
 319 }