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_register(DWORD bwriter_register) {
  72     if(bwriter_register == BWRITERSPR_TEMP)         return D3DSPR_TEMP;
  73     if(bwriter_register == BWRITERSPR_CONST)        return D3DSPR_CONST;
  74
  75     FIXME("Unexpected BWRITERSPR %u\n", bwriter_register);
  76     return -1;
  77 }
  78
  79 DWORD d3d9_opcode(DWORD bwriter_opcode) {
  80     switch(bwriter_opcode) {
  81         case BWRITERSIO_MOV:         return D3DSIO_MOV;
  82
  83         case BWRITERSIO_COMMENT:     return D3DSIO_COMMENT;
  84         case BWRITERSIO_END:         return D3DSIO_END;
  85
  86         default:
  87             FIXME("Unhandled BWRITERSIO token %u\n", bwriter_opcode);
  88             return -1;
  89     }
  90 }
  91
  92 static const char *get_regname(const struct shader_reg *reg, shader_type st) {
  93     switch(reg->type) {
  94         case BWRITERSPR_TEMP:
  95             return wine_dbg_sprintf("r%u", reg->regnum);
  96         case BWRITERSPR_CONST:
  97             return wine_dbg_sprintf("c%u", reg->regnum);
  98         default: return "unknown regname";
  99     }
 100 }
 101
 102 const char *debug_print_writemask(DWORD mask) {
 103     char ret[6];
 104     unsigned char pos = 1;
 105
 106     if(mask == BWRITERSP_WRITEMASK_ALL) return "";
 107     ret[0] = '.';
 108     if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
 109     if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
 110     if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
 111     if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
 112     ret[pos] = 0;
 113     return wine_dbg_sprintf("%s", ret);
 114 }
 115
 116 const char *debug_print_dstreg(const struct shader_reg *reg, shader_type st) {
 117     return wine_dbg_sprintf("%s%s", get_regname(reg, st),
 118                             debug_print_writemask(reg->writemask));
 119 }
 120
 121 const char *debug_print_swizzle(DWORD arg) {
 122     char ret[6];
 123     unsigned int i;
 124     DWORD swizzle[4];
 125
 126     switch(arg) {
 127         case BWRITERVS_NOSWIZZLE:
 128             return "";
 129         case BWRITERVS_SWIZZLE_X:
 130             return ".x";
 131         case BWRITERVS_SWIZZLE_Y:
 132             return ".y";
 133         case BWRITERVS_SWIZZLE_Z:
 134             return ".z";
 135         case BWRITERVS_SWIZZLE_W:
 136             return ".w";
 137     }
 138
 139     swizzle[0] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 0)) & 0x03;
 140     swizzle[1] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 2)) & 0x03;
 141     swizzle[2] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 4)) & 0x03;
 142     swizzle[3] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 6)) & 0x03;
 143
 144     ret[0] = '.';
 145     for(i = 0; i < 4; i++) {
 146         switch(swizzle[i]) {
 147             case 0: ret[1 + i] = 'x'; break;
 148             case 1: ret[1 + i] = 'y'; break;
 149             case 2: ret[1 + i] = 'z'; break;
 150             case 3: ret[1 + i] = 'w'; break;
 151         }
 152     }
 153     ret[5] = '\0';
 154     return wine_dbg_sprintf("%s", ret);
 155 }
 156
 157 const char *debug_print_srcreg(const struct shader_reg *reg, shader_type st) {
 158     switch(reg->srcmod) {
 159         case BWRITERSPSM_NONE:
 160             return wine_dbg_sprintf("%s%s", get_regname(reg, st),
 161                                     debug_print_swizzle(reg->swizzle));
 162     }
 163     return "Unknown modifier";
 164 }
 165
 166 const char *debug_print_opcode(DWORD opcode) {
 167     switch(opcode){
 168         case BWRITERSIO_MOV:          return "mov";
 169
 170         default:                      return "unknown";
 171     }
 172 }