wined3d: Split context_apply_state() into separate functions for each usage.
[wine] / dlls / wined3d / shader_sm1.c
1 /*
2  * Copyright 2002-2003 Jason Edmeades
3  * Copyright 2002-2003 Raphael Junqueira
4  * Copyright 2004 Christian Costa
5  * Copyright 2005 Oliver Stieber
6  * Copyright 2006 Ivan Gyurdiev
7  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
8  * Copyright 2009 Henri Verbeet for CodeWeavers
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23  */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include "wined3d_private.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
31
32 /* DCL usage masks */
33 #define WINED3DSP_DCL_USAGE_SHIFT               0
34 #define WINED3DSP_DCL_USAGE_MASK                (0xf << WINED3DSP_DCL_USAGE_SHIFT)
35 #define WINED3DSP_DCL_USAGEINDEX_SHIFT          16
36 #define WINED3DSP_DCL_USAGEINDEX_MASK           (0xf << WINED3DSP_DCL_USAGEINDEX_SHIFT)
37
38 /* DCL sampler type */
39 #define WINED3DSP_TEXTURETYPE_SHIFT             27
40 #define WINED3DSP_TEXTURETYPE_MASK              (0xf << WINED3DSP_TEXTURETYPE_SHIFT)
41
42 /* Opcode-related masks */
43 #define WINED3DSI_OPCODE_MASK                   0x0000ffff
44
45 #define WINED3D_OPCODESPECIFICCONTROL_SHIFT     16
46 #define WINED3D_OPCODESPECIFICCONTROL_MASK      (0xff << WINED3D_OPCODESPECIFICCONTROL_SHIFT)
47
48 #define WINED3DSI_INSTLENGTH_SHIFT              24
49 #define WINED3DSI_INSTLENGTH_MASK               (0xf << WINED3DSI_INSTLENGTH_SHIFT)
50
51 #define WINED3DSI_COISSUE                       (1 << 30)
52
53 #define WINED3DSI_COMMENTSIZE_SHIFT             16
54 #define WINED3DSI_COMMENTSIZE_MASK              (0x7fff << WINED3DSI_COMMENTSIZE_SHIFT)
55
56 #define WINED3DSHADER_INSTRUCTION_PREDICATED    (1 << 28)
57
58 /* Register number mask */
59 #define WINED3DSP_REGNUM_MASK                   0x000007ff
60
61 /* Register type masks  */
62 #define WINED3DSP_REGTYPE_SHIFT                 28
63 #define WINED3DSP_REGTYPE_MASK                  (0x7 << WINED3DSP_REGTYPE_SHIFT)
64 #define WINED3DSP_REGTYPE_SHIFT2                8
65 #define WINED3DSP_REGTYPE_MASK2                 (0x18 << WINED3DSP_REGTYPE_SHIFT2)
66
67 /* Relative addressing mask */
68 #define WINED3DSHADER_ADDRESSMODE_SHIFT         13
69 #define WINED3DSHADER_ADDRESSMODE_MASK          (1 << WINED3DSHADER_ADDRESSMODE_SHIFT)
70
71 /* Destination modifier mask */
72 #define WINED3DSP_DSTMOD_SHIFT                  20
73 #define WINED3DSP_DSTMOD_MASK                   (0xf << WINED3DSP_DSTMOD_SHIFT)
74
75 /* Destination shift mask */
76 #define WINED3DSP_DSTSHIFT_SHIFT                24
77 #define WINED3DSP_DSTSHIFT_MASK                 (0xf << WINED3DSP_DSTSHIFT_SHIFT)
78
79 /* Write mask */
80 #define WINED3D_SM1_WRITEMASK_SHIFT             16
81 #define WINED3D_SM1_WRITEMASK_MASK              (0xf << WINED3D_SM1_WRITEMASK_SHIFT)
82
83 /* Swizzle mask */
84 #define WINED3DSP_SWIZZLE_SHIFT                 16
85 #define WINED3DSP_SWIZZLE_MASK                  (0xff << WINED3DSP_SWIZZLE_SHIFT)
86
87 /* Source modifier mask */
88 #define WINED3DSP_SRCMOD_SHIFT                  24
89 #define WINED3DSP_SRCMOD_MASK                   (0xf << WINED3DSP_SRCMOD_SHIFT)
90
91 #define WINED3DSP_END                           0x0000ffff
92
93 #define WINED3D_SM1_VERSION_MAJOR(version)      (((version) >> 8) & 0xff)
94 #define WINED3D_SM1_VERSION_MINOR(version)      (((version) >> 0) & 0xff)
95
96 enum WINED3DSHADER_ADDRESSMODE_TYPE
97 {
98     WINED3DSHADER_ADDRMODE_ABSOLUTE = 0 << WINED3DSHADER_ADDRESSMODE_SHIFT,
99     WINED3DSHADER_ADDRMODE_RELATIVE = 1 << WINED3DSHADER_ADDRESSMODE_SHIFT,
100 };
101
102 enum wined3d_sm1_opcode
103 {
104     WINED3D_SM1_OP_NOP          = 0x00,
105     WINED3D_SM1_OP_MOV          = 0x01,
106     WINED3D_SM1_OP_ADD          = 0x02,
107     WINED3D_SM1_OP_SUB          = 0x03,
108     WINED3D_SM1_OP_MAD          = 0x04,
109     WINED3D_SM1_OP_MUL          = 0x05,
110     WINED3D_SM1_OP_RCP          = 0x06,
111     WINED3D_SM1_OP_RSQ          = 0x07,
112     WINED3D_SM1_OP_DP3          = 0x08,
113     WINED3D_SM1_OP_DP4          = 0x09,
114     WINED3D_SM1_OP_MIN          = 0x0a,
115     WINED3D_SM1_OP_MAX          = 0x0b,
116     WINED3D_SM1_OP_SLT          = 0x0c,
117     WINED3D_SM1_OP_SGE          = 0x0d,
118     WINED3D_SM1_OP_EXP          = 0x0e,
119     WINED3D_SM1_OP_LOG          = 0x0f,
120     WINED3D_SM1_OP_LIT          = 0x10,
121     WINED3D_SM1_OP_DST          = 0x11,
122     WINED3D_SM1_OP_LRP          = 0x12,
123     WINED3D_SM1_OP_FRC          = 0x13,
124     WINED3D_SM1_OP_M4x4         = 0x14,
125     WINED3D_SM1_OP_M4x3         = 0x15,
126     WINED3D_SM1_OP_M3x4         = 0x16,
127     WINED3D_SM1_OP_M3x3         = 0x17,
128     WINED3D_SM1_OP_M3x2         = 0x18,
129     WINED3D_SM1_OP_CALL         = 0x19,
130     WINED3D_SM1_OP_CALLNZ       = 0x1a,
131     WINED3D_SM1_OP_LOOP         = 0x1b,
132     WINED3D_SM1_OP_RET          = 0x1c,
133     WINED3D_SM1_OP_ENDLOOP      = 0x1d,
134     WINED3D_SM1_OP_LABEL        = 0x1e,
135     WINED3D_SM1_OP_DCL          = 0x1f,
136     WINED3D_SM1_OP_POW          = 0x20,
137     WINED3D_SM1_OP_CRS          = 0x21,
138     WINED3D_SM1_OP_SGN          = 0x22,
139     WINED3D_SM1_OP_ABS          = 0x23,
140     WINED3D_SM1_OP_NRM          = 0x24,
141     WINED3D_SM1_OP_SINCOS       = 0x25,
142     WINED3D_SM1_OP_REP          = 0x26,
143     WINED3D_SM1_OP_ENDREP       = 0x27,
144     WINED3D_SM1_OP_IF           = 0x28,
145     WINED3D_SM1_OP_IFC          = 0x29,
146     WINED3D_SM1_OP_ELSE         = 0x2a,
147     WINED3D_SM1_OP_ENDIF        = 0x2b,
148     WINED3D_SM1_OP_BREAK        = 0x2c,
149     WINED3D_SM1_OP_BREAKC       = 0x2d,
150     WINED3D_SM1_OP_MOVA         = 0x2e,
151     WINED3D_SM1_OP_DEFB         = 0x2f,
152     WINED3D_SM1_OP_DEFI         = 0x30,
153
154     WINED3D_SM1_OP_TEXCOORD     = 0x40,
155     WINED3D_SM1_OP_TEXKILL      = 0x41,
156     WINED3D_SM1_OP_TEX          = 0x42,
157     WINED3D_SM1_OP_TEXBEM       = 0x43,
158     WINED3D_SM1_OP_TEXBEML      = 0x44,
159     WINED3D_SM1_OP_TEXREG2AR    = 0x45,
160     WINED3D_SM1_OP_TEXREG2GB    = 0x46,
161     WINED3D_SM1_OP_TEXM3x2PAD   = 0x47,
162     WINED3D_SM1_OP_TEXM3x2TEX   = 0x48,
163     WINED3D_SM1_OP_TEXM3x3PAD   = 0x49,
164     WINED3D_SM1_OP_TEXM3x3TEX   = 0x4a,
165     WINED3D_SM1_OP_TEXM3x3DIFF  = 0x4b,
166     WINED3D_SM1_OP_TEXM3x3SPEC  = 0x4c,
167     WINED3D_SM1_OP_TEXM3x3VSPEC = 0x4d,
168     WINED3D_SM1_OP_EXPP         = 0x4e,
169     WINED3D_SM1_OP_LOGP         = 0x4f,
170     WINED3D_SM1_OP_CND          = 0x50,
171     WINED3D_SM1_OP_DEF          = 0x51,
172     WINED3D_SM1_OP_TEXREG2RGB   = 0x52,
173     WINED3D_SM1_OP_TEXDP3TEX    = 0x53,
174     WINED3D_SM1_OP_TEXM3x2DEPTH = 0x54,
175     WINED3D_SM1_OP_TEXDP3       = 0x55,
176     WINED3D_SM1_OP_TEXM3x3      = 0x56,
177     WINED3D_SM1_OP_TEXDEPTH     = 0x57,
178     WINED3D_SM1_OP_CMP          = 0x58,
179     WINED3D_SM1_OP_BEM          = 0x59,
180     WINED3D_SM1_OP_DP2ADD       = 0x5a,
181     WINED3D_SM1_OP_DSX          = 0x5b,
182     WINED3D_SM1_OP_DSY          = 0x5c,
183     WINED3D_SM1_OP_TEXLDD       = 0x5d,
184     WINED3D_SM1_OP_SETP         = 0x5e,
185     WINED3D_SM1_OP_TEXLDL       = 0x5f,
186     WINED3D_SM1_OP_BREAKP       = 0x60,
187
188     WINED3D_SM1_OP_PHASE        = 0xfffd,
189     WINED3D_SM1_OP_COMMENT      = 0xfffe,
190     WINED3D_SM1_OP_END          = 0Xffff,
191 };
192
193 struct wined3d_sm1_opcode_info
194 {
195     enum wined3d_sm1_opcode opcode;
196     UINT dst_count;
197     UINT param_count;
198     enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx;
199     DWORD min_version;
200     DWORD max_version;
201 };
202
203 struct wined3d_sm1_data
204 {
205     struct wined3d_shader_version shader_version;
206     const struct wined3d_sm1_opcode_info *opcode_table;
207 };
208
209 /* This table is not order or position dependent. */
210 static const struct wined3d_sm1_opcode_info vs_opcode_table[] =
211 {
212     /* Arithmetic */
213     {WINED3D_SM1_OP_NOP,      0, 0, WINED3DSIH_NOP,          0,                           0                          },
214     {WINED3D_SM1_OP_MOV,      1, 2, WINED3DSIH_MOV,          0,                           0                          },
215     {WINED3D_SM1_OP_MOVA,     1, 2, WINED3DSIH_MOVA,         WINED3D_SHADER_VERSION(2,0), -1                         },
216     {WINED3D_SM1_OP_ADD,      1, 3, WINED3DSIH_ADD,          0,                           0                          },
217     {WINED3D_SM1_OP_SUB,      1, 3, WINED3DSIH_SUB,          0,                           0                          },
218     {WINED3D_SM1_OP_MAD,      1, 4, WINED3DSIH_MAD,          0,                           0                          },
219     {WINED3D_SM1_OP_MUL,      1, 3, WINED3DSIH_MUL,          0,                           0                          },
220     {WINED3D_SM1_OP_RCP,      1, 2, WINED3DSIH_RCP,          0,                           0                          },
221     {WINED3D_SM1_OP_RSQ,      1, 2, WINED3DSIH_RSQ,          0,                           0                          },
222     {WINED3D_SM1_OP_DP3,      1, 3, WINED3DSIH_DP3,          0,                           0                          },
223     {WINED3D_SM1_OP_DP4,      1, 3, WINED3DSIH_DP4,          0,                           0                          },
224     {WINED3D_SM1_OP_MIN,      1, 3, WINED3DSIH_MIN,          0,                           0                          },
225     {WINED3D_SM1_OP_MAX,      1, 3, WINED3DSIH_MAX,          0,                           0                          },
226     {WINED3D_SM1_OP_SLT,      1, 3, WINED3DSIH_SLT,          0,                           0                          },
227     {WINED3D_SM1_OP_SGE,      1, 3, WINED3DSIH_SGE,          0,                           0                          },
228     {WINED3D_SM1_OP_ABS,      1, 2, WINED3DSIH_ABS,          0,                           0                          },
229     {WINED3D_SM1_OP_EXP,      1, 2, WINED3DSIH_EXP,          0,                           0                          },
230     {WINED3D_SM1_OP_LOG,      1, 2, WINED3DSIH_LOG,          0,                           0                          },
231     {WINED3D_SM1_OP_EXPP,     1, 2, WINED3DSIH_EXPP,         0,                           0                          },
232     {WINED3D_SM1_OP_LOGP,     1, 2, WINED3DSIH_LOGP,         0,                           0                          },
233     {WINED3D_SM1_OP_LIT,      1, 2, WINED3DSIH_LIT,          0,                           0                          },
234     {WINED3D_SM1_OP_DST,      1, 3, WINED3DSIH_DST,          0,                           0                          },
235     {WINED3D_SM1_OP_LRP,      1, 4, WINED3DSIH_LRP,          0,                           0                          },
236     {WINED3D_SM1_OP_FRC,      1, 2, WINED3DSIH_FRC,          0,                           0                          },
237     {WINED3D_SM1_OP_POW,      1, 3, WINED3DSIH_POW,          0,                           0                          },
238     {WINED3D_SM1_OP_CRS,      1, 3, WINED3DSIH_CRS,          0,                           0                          },
239     {WINED3D_SM1_OP_SGN,      1, 4, WINED3DSIH_SGN,          WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
240     {WINED3D_SM1_OP_SGN,      1, 2, WINED3DSIH_SGN,          WINED3D_SHADER_VERSION(3,0), -1                         },
241     {WINED3D_SM1_OP_NRM,      1, 2, WINED3DSIH_NRM,          0,                           0                          },
242     {WINED3D_SM1_OP_SINCOS,   1, 4, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
243     {WINED3D_SM1_OP_SINCOS,   1, 2, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(3,0), -1                         },
244     /* Matrix */
245     {WINED3D_SM1_OP_M4x4,     1, 3, WINED3DSIH_M4x4,         0,                           0                          },
246     {WINED3D_SM1_OP_M4x3,     1, 3, WINED3DSIH_M4x3,         0,                           0                          },
247     {WINED3D_SM1_OP_M3x4,     1, 3, WINED3DSIH_M3x4,         0,                           0                          },
248     {WINED3D_SM1_OP_M3x3,     1, 3, WINED3DSIH_M3x3,         0,                           0                          },
249     {WINED3D_SM1_OP_M3x2,     1, 3, WINED3DSIH_M3x2,         0,                           0                          },
250     /* Declare registers */
251     {WINED3D_SM1_OP_DCL,      0, 2, WINED3DSIH_DCL,          0,                           0                          },
252     /* Constant definitions */
253     {WINED3D_SM1_OP_DEF,      1, 5, WINED3DSIH_DEF,          0,                           0                          },
254     {WINED3D_SM1_OP_DEFB,     1, 2, WINED3DSIH_DEFB,         0,                           0                          },
255     {WINED3D_SM1_OP_DEFI,     1, 5, WINED3DSIH_DEFI,         0,                           0                          },
256     /* Flow control */
257     {WINED3D_SM1_OP_REP,      0, 1, WINED3DSIH_REP,          WINED3D_SHADER_VERSION(2,0), -1                         },
258     {WINED3D_SM1_OP_ENDREP,   0, 0, WINED3DSIH_ENDREP,       WINED3D_SHADER_VERSION(2,0), -1                         },
259     {WINED3D_SM1_OP_IF,       0, 1, WINED3DSIH_IF,           WINED3D_SHADER_VERSION(2,0), -1                         },
260     {WINED3D_SM1_OP_IFC,      0, 2, WINED3DSIH_IFC,          WINED3D_SHADER_VERSION(2,1), -1                         },
261     {WINED3D_SM1_OP_ELSE,     0, 0, WINED3DSIH_ELSE,         WINED3D_SHADER_VERSION(2,0), -1                         },
262     {WINED3D_SM1_OP_ENDIF,    0, 0, WINED3DSIH_ENDIF,        WINED3D_SHADER_VERSION(2,0), -1                         },
263     {WINED3D_SM1_OP_BREAK,    0, 0, WINED3DSIH_BREAK,        WINED3D_SHADER_VERSION(2,1), -1                         },
264     {WINED3D_SM1_OP_BREAKC,   0, 2, WINED3DSIH_BREAKC,       WINED3D_SHADER_VERSION(2,1), -1                         },
265     {WINED3D_SM1_OP_BREAKP,   0, 1, WINED3DSIH_BREAKP,       0,                           0                          },
266     {WINED3D_SM1_OP_CALL,     0, 1, WINED3DSIH_CALL,         WINED3D_SHADER_VERSION(2,0), -1                         },
267     {WINED3D_SM1_OP_CALLNZ,   0, 2, WINED3DSIH_CALLNZ,       WINED3D_SHADER_VERSION(2,0), -1                         },
268     {WINED3D_SM1_OP_LOOP,     0, 2, WINED3DSIH_LOOP,         WINED3D_SHADER_VERSION(2,0), -1                         },
269     {WINED3D_SM1_OP_RET,      0, 0, WINED3DSIH_RET,          WINED3D_SHADER_VERSION(2,0), -1                         },
270     {WINED3D_SM1_OP_ENDLOOP,  0, 0, WINED3DSIH_ENDLOOP,      WINED3D_SHADER_VERSION(2,0), -1                         },
271     {WINED3D_SM1_OP_LABEL,    0, 1, WINED3DSIH_LABEL,        WINED3D_SHADER_VERSION(2,0), -1                         },
272
273     {WINED3D_SM1_OP_SETP,     1, 3, WINED3DSIH_SETP,         0,                           0                          },
274     {WINED3D_SM1_OP_TEXLDL,   1, 3, WINED3DSIH_TEXLDL,       WINED3D_SHADER_VERSION(3,0), -1                         },
275     {0,                       0, 0, WINED3DSIH_TABLE_SIZE,   0,                           0                          },
276 };
277
278 static const struct wined3d_sm1_opcode_info ps_opcode_table[] =
279 {
280     /* Arithmetic */
281     {WINED3D_SM1_OP_NOP,      0, 0, WINED3DSIH_NOP,          0,                           0                          },
282     {WINED3D_SM1_OP_MOV,      1, 2, WINED3DSIH_MOV,          0,                           0                          },
283     {WINED3D_SM1_OP_ADD,      1, 3, WINED3DSIH_ADD,          0,                           0                          },
284     {WINED3D_SM1_OP_SUB,      1, 3, WINED3DSIH_SUB,          0,                           0                          },
285     {WINED3D_SM1_OP_MAD,      1, 4, WINED3DSIH_MAD,          0,                           0                          },
286     {WINED3D_SM1_OP_MUL,      1, 3, WINED3DSIH_MUL,          0,                           0                          },
287     {WINED3D_SM1_OP_RCP,      1, 2, WINED3DSIH_RCP,          0,                           0                          },
288     {WINED3D_SM1_OP_RSQ,      1, 2, WINED3DSIH_RSQ,          0,                           0                          },
289     {WINED3D_SM1_OP_DP3,      1, 3, WINED3DSIH_DP3,          0,                           0                          },
290     {WINED3D_SM1_OP_DP4,      1, 3, WINED3DSIH_DP4,          0,                           0                          },
291     {WINED3D_SM1_OP_MIN,      1, 3, WINED3DSIH_MIN,          0,                           0                          },
292     {WINED3D_SM1_OP_MAX,      1, 3, WINED3DSIH_MAX,          0,                           0                          },
293     {WINED3D_SM1_OP_SLT,      1, 3, WINED3DSIH_SLT,          0,                           0                          },
294     {WINED3D_SM1_OP_SGE,      1, 3, WINED3DSIH_SGE,          0,                           0                          },
295     {WINED3D_SM1_OP_ABS,      1, 2, WINED3DSIH_ABS,          0,                           0                          },
296     {WINED3D_SM1_OP_EXP,      1, 2, WINED3DSIH_EXP,          0,                           0                          },
297     {WINED3D_SM1_OP_LOG,      1, 2, WINED3DSIH_LOG,          0,                           0                          },
298     {WINED3D_SM1_OP_EXPP,     1, 2, WINED3DSIH_EXPP,         0,                           0                          },
299     {WINED3D_SM1_OP_LOGP,     1, 2, WINED3DSIH_LOGP,         0,                           0                          },
300     {WINED3D_SM1_OP_DST,      1, 3, WINED3DSIH_DST,          0,                           0                          },
301     {WINED3D_SM1_OP_LRP,      1, 4, WINED3DSIH_LRP,          0,                           0                          },
302     {WINED3D_SM1_OP_FRC,      1, 2, WINED3DSIH_FRC,          0,                           0                          },
303     {WINED3D_SM1_OP_CND,      1, 4, WINED3DSIH_CND,          WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,4)},
304     {WINED3D_SM1_OP_CMP,      1, 4, WINED3DSIH_CMP,          WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(3,0)},
305     {WINED3D_SM1_OP_POW,      1, 3, WINED3DSIH_POW,          0,                           0                          },
306     {WINED3D_SM1_OP_CRS,      1, 3, WINED3DSIH_CRS,          0,                           0                          },
307     {WINED3D_SM1_OP_NRM,      1, 2, WINED3DSIH_NRM,          0,                           0                          },
308     {WINED3D_SM1_OP_SINCOS,   1, 4, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
309     {WINED3D_SM1_OP_SINCOS,   1, 2, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(3,0), -1                         },
310     {WINED3D_SM1_OP_DP2ADD,   1, 4, WINED3DSIH_DP2ADD,       WINED3D_SHADER_VERSION(2,0), -1                         },
311     /* Matrix */
312     {WINED3D_SM1_OP_M4x4,     1, 3, WINED3DSIH_M4x4,         0,                           0                          },
313     {WINED3D_SM1_OP_M4x3,     1, 3, WINED3DSIH_M4x3,         0,                           0                          },
314     {WINED3D_SM1_OP_M3x4,     1, 3, WINED3DSIH_M3x4,         0,                           0                          },
315     {WINED3D_SM1_OP_M3x3,     1, 3, WINED3DSIH_M3x3,         0,                           0                          },
316     {WINED3D_SM1_OP_M3x2,     1, 3, WINED3DSIH_M3x2,         0,                           0                          },
317     /* Register declarations */
318     {WINED3D_SM1_OP_DCL,      0, 2, WINED3DSIH_DCL,          0,                           0                          },
319     /* Flow control */
320     {WINED3D_SM1_OP_REP,      0, 1, WINED3DSIH_REP,          WINED3D_SHADER_VERSION(2,1), -1                         },
321     {WINED3D_SM1_OP_ENDREP,   0, 0, WINED3DSIH_ENDREP,       WINED3D_SHADER_VERSION(2,1), -1                         },
322     {WINED3D_SM1_OP_IF,       0, 1, WINED3DSIH_IF,           WINED3D_SHADER_VERSION(2,1), -1                         },
323     {WINED3D_SM1_OP_IFC,      0, 2, WINED3DSIH_IFC,          WINED3D_SHADER_VERSION(2,1), -1                         },
324     {WINED3D_SM1_OP_ELSE,     0, 0, WINED3DSIH_ELSE,         WINED3D_SHADER_VERSION(2,1), -1                         },
325     {WINED3D_SM1_OP_ENDIF,    0, 0, WINED3DSIH_ENDIF,        WINED3D_SHADER_VERSION(2,1), -1                         },
326     {WINED3D_SM1_OP_BREAK,    0, 0, WINED3DSIH_BREAK,        WINED3D_SHADER_VERSION(2,1), -1                         },
327     {WINED3D_SM1_OP_BREAKC,   0, 2, WINED3DSIH_BREAKC,       WINED3D_SHADER_VERSION(2,1), -1                         },
328     {WINED3D_SM1_OP_BREAKP,   0, 1, WINED3DSIH_BREAKP,       0,                           0                          },
329     {WINED3D_SM1_OP_CALL,     0, 1, WINED3DSIH_CALL,         WINED3D_SHADER_VERSION(2,1), -1                         },
330     {WINED3D_SM1_OP_CALLNZ,   0, 2, WINED3DSIH_CALLNZ,       WINED3D_SHADER_VERSION(2,1), -1                         },
331     {WINED3D_SM1_OP_LOOP,     0, 2, WINED3DSIH_LOOP,         WINED3D_SHADER_VERSION(3,0), -1                         },
332     {WINED3D_SM1_OP_RET,      0, 0, WINED3DSIH_RET,          WINED3D_SHADER_VERSION(2,1), -1                         },
333     {WINED3D_SM1_OP_ENDLOOP,  0, 0, WINED3DSIH_ENDLOOP,      WINED3D_SHADER_VERSION(3,0), -1                         },
334     {WINED3D_SM1_OP_LABEL,    0, 1, WINED3DSIH_LABEL,        WINED3D_SHADER_VERSION(2,1), -1                         },
335     /* Constant definitions */
336     {WINED3D_SM1_OP_DEF,      1, 5, WINED3DSIH_DEF,          0,                           0                          },
337     {WINED3D_SM1_OP_DEFB,     1, 2, WINED3DSIH_DEFB,         0,                           0                          },
338     {WINED3D_SM1_OP_DEFI,     1, 5, WINED3DSIH_DEFI,         0,                           0                          },
339     /* Texture */
340     {WINED3D_SM1_OP_TEXCOORD, 1, 1, WINED3DSIH_TEXCOORD,     0,                           WINED3D_SHADER_VERSION(1,3)},
341     {WINED3D_SM1_OP_TEXCOORD, 1, 2, WINED3DSIH_TEXCOORD,     WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
342     {WINED3D_SM1_OP_TEXKILL,  1, 1, WINED3DSIH_TEXKILL,      WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(3,0)},
343     {WINED3D_SM1_OP_TEX,      1, 1, WINED3DSIH_TEX,          0,                           WINED3D_SHADER_VERSION(1,3)},
344     {WINED3D_SM1_OP_TEX,      1, 2, WINED3DSIH_TEX,          WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
345     {WINED3D_SM1_OP_TEX,      1, 3, WINED3DSIH_TEX,          WINED3D_SHADER_VERSION(2,0), -1                         },
346     {WINED3D_SM1_OP_TEXBEM,   1, 2, WINED3DSIH_TEXBEM,       0,                           WINED3D_SHADER_VERSION(1,3)},
347     {WINED3D_SM1_OP_TEXBEML,  1, 2, WINED3DSIH_TEXBEML,      WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
348     {WINED3D_SM1_OP_TEXREG2AR,      1, 2, WINED3DSIH_TEXREG2AR,    WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
349     {WINED3D_SM1_OP_TEXREG2GB,      1, 2, WINED3DSIH_TEXREG2GB,    WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
350     {WINED3D_SM1_OP_TEXREG2RGB,     1, 2, WINED3DSIH_TEXREG2RGB,   WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
351     {WINED3D_SM1_OP_TEXM3x2PAD,     1, 2, WINED3DSIH_TEXM3x2PAD,   WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
352     {WINED3D_SM1_OP_TEXM3x2TEX,     1, 2, WINED3DSIH_TEXM3x2TEX,   WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
353     {WINED3D_SM1_OP_TEXM3x3PAD,     1, 2, WINED3DSIH_TEXM3x3PAD,   WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
354     {WINED3D_SM1_OP_TEXM3x3DIFF,    1, 2, WINED3DSIH_TEXM3x3DIFF,  WINED3D_SHADER_VERSION(0,0), WINED3D_SHADER_VERSION(0,0)},
355     {WINED3D_SM1_OP_TEXM3x3SPEC,    1, 3, WINED3DSIH_TEXM3x3SPEC,  WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
356     {WINED3D_SM1_OP_TEXM3x3VSPEC,   1, 2, WINED3DSIH_TEXM3x3VSPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
357     {WINED3D_SM1_OP_TEXM3x3TEX,     1, 2, WINED3DSIH_TEXM3x3TEX,   WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
358     {WINED3D_SM1_OP_TEXDP3TEX,      1, 2, WINED3DSIH_TEXDP3TEX,    WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
359     {WINED3D_SM1_OP_TEXM3x2DEPTH,   1, 2, WINED3DSIH_TEXM3x2DEPTH, WINED3D_SHADER_VERSION(1,3), WINED3D_SHADER_VERSION(1,3)},
360     {WINED3D_SM1_OP_TEXDP3,   1, 2, WINED3DSIH_TEXDP3,       WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
361     {WINED3D_SM1_OP_TEXM3x3,  1, 2, WINED3DSIH_TEXM3x3,      WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
362     {WINED3D_SM1_OP_TEXDEPTH, 1, 1, WINED3DSIH_TEXDEPTH,     WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
363     {WINED3D_SM1_OP_BEM,      1, 3, WINED3DSIH_BEM,          WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
364     {WINED3D_SM1_OP_DSX,      1, 2, WINED3DSIH_DSX,          WINED3D_SHADER_VERSION(2,1), -1                         },
365     {WINED3D_SM1_OP_DSY,      1, 2, WINED3DSIH_DSY,          WINED3D_SHADER_VERSION(2,1), -1                         },
366     {WINED3D_SM1_OP_TEXLDD,   1, 5, WINED3DSIH_TEXLDD,       WINED3D_SHADER_VERSION(2,1), -1                         },
367     {WINED3D_SM1_OP_SETP,     1, 3, WINED3DSIH_SETP,         0,                           0                          },
368     {WINED3D_SM1_OP_TEXLDL,   1, 3, WINED3DSIH_TEXLDL,       WINED3D_SHADER_VERSION(3,0), -1                         },
369     {WINED3D_SM1_OP_PHASE,    0, 0, WINED3DSIH_PHASE,        0,                           0                          },
370     {0,                       0, 0, WINED3DSIH_TABLE_SIZE,   0,                           0                          },
371 };
372
373 /* Read a parameter opcode from the input stream,
374  * and possibly a relative addressing token.
375  * Return the number of tokens read */
376 static int shader_get_param(const struct wined3d_sm1_data *priv, const DWORD *ptr, DWORD *token, DWORD *addr_token)
377 {
378     UINT count = 1;
379
380     *token = *ptr;
381
382     /* PS >= 3.0 have relative addressing (with token)
383      * VS >= 2.0 have relative addressing (with token)
384      * VS >= 1.0 < 2.0 have relative addressing (without token)
385      * The version check below should work in general */
386     if (*ptr & WINED3DSHADER_ADDRMODE_RELATIVE)
387     {
388         if (priv->shader_version.major < 2)
389         {
390             *addr_token = (1 << 31)
391                     | ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT2) & WINED3DSP_REGTYPE_MASK2)
392                     | ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT) & WINED3DSP_REGTYPE_MASK)
393                     | (WINED3DSP_NOSWIZZLE << WINED3DSP_SWIZZLE_SHIFT);
394         }
395         else
396         {
397             *addr_token = *(ptr + 1);
398             ++count;
399         }
400     }
401
402     return count;
403 }
404
405 static const struct wined3d_sm1_opcode_info *shader_get_opcode(const struct wined3d_sm1_data *priv, DWORD code)
406 {
407     DWORD shader_version = WINED3D_SHADER_VERSION(priv->shader_version.major, priv->shader_version.minor);
408     const struct wined3d_sm1_opcode_info *opcode_table = priv->opcode_table;
409     DWORD i = 0;
410
411     while (opcode_table[i].handler_idx != WINED3DSIH_TABLE_SIZE)
412     {
413         if ((code & WINED3DSI_OPCODE_MASK) == opcode_table[i].opcode
414                 && shader_version >= opcode_table[i].min_version
415                 && (!opcode_table[i].max_version || shader_version <= opcode_table[i].max_version))
416         {
417             return &opcode_table[i];
418         }
419         ++i;
420     }
421
422     FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
423             code, code, code & WINED3DSI_OPCODE_MASK, shader_version);
424
425     return NULL;
426 }
427
428 /* Return the number of parameters to skip for an opcode */
429 static int shader_skip_opcode(const struct wined3d_sm1_data *priv,
430         const struct wined3d_sm1_opcode_info *opcode_info, DWORD opcode_token)
431 {
432    /* Shaders >= 2.0 may contain address tokens, but fortunately they
433     * have a useful length mask - use it here. Shaders 1.0 contain no such tokens */
434     return (priv->shader_version.major >= 2)
435             ? ((opcode_token & WINED3DSI_INSTLENGTH_MASK) >> WINED3DSI_INSTLENGTH_SHIFT) : opcode_info->param_count;
436 }
437
438 static void shader_parse_src_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
439         struct wined3d_shader_src_param *src)
440 {
441     src->reg.type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
442             | ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
443     src->reg.idx = param & WINED3DSP_REGNUM_MASK;
444     src->reg.array_idx = ~0U;
445     src->swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
446     src->modifiers = (param & WINED3DSP_SRCMOD_MASK) >> WINED3DSP_SRCMOD_SHIFT;
447     src->reg.rel_addr = rel_addr;
448 }
449
450 static void shader_parse_dst_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
451         struct wined3d_shader_dst_param *dst)
452 {
453     dst->reg.type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
454             | ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
455     dst->reg.idx = param & WINED3DSP_REGNUM_MASK;
456     dst->reg.array_idx = ~0U;
457     dst->write_mask = (param & WINED3D_SM1_WRITEMASK_MASK) >> WINED3D_SM1_WRITEMASK_SHIFT;
458     dst->modifiers = (param & WINED3DSP_DSTMOD_MASK) >> WINED3DSP_DSTMOD_SHIFT;
459     dst->shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
460     dst->reg.rel_addr = rel_addr;
461 }
462
463 /* Read the parameters of an unrecognized opcode from the input stream
464  * Return the number of tokens read.
465  *
466  * Note: This function assumes source or destination token format.
467  * It will not work with specially-formatted tokens like DEF or DCL,
468  * but hopefully those would be recognized */
469 static int shader_skip_unrecognized(const struct wined3d_sm1_data *priv, const DWORD *ptr)
470 {
471     int tokens_read = 0;
472     int i = 0;
473
474     /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
475     while (*ptr & 0x80000000)
476     {
477         DWORD token, addr_token = 0;
478         struct wined3d_shader_src_param rel_addr;
479
480         tokens_read += shader_get_param(priv, ptr, &token, &addr_token);
481         ptr += tokens_read;
482
483         FIXME("Unrecognized opcode param: token=0x%08x addr_token=0x%08x name=", token, addr_token);
484
485         if (token & WINED3DSHADER_ADDRMODE_RELATIVE) shader_parse_src_param(addr_token, NULL, &rel_addr);
486
487         if (!i)
488         {
489             struct wined3d_shader_dst_param dst;
490
491             shader_parse_dst_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &dst);
492             shader_dump_dst_param(&dst, &priv->shader_version);
493         }
494         else
495         {
496             struct wined3d_shader_src_param src;
497
498             shader_parse_src_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &src);
499             shader_dump_src_param(&src, &priv->shader_version);
500         }
501         FIXME("\n");
502         ++i;
503     }
504     return tokens_read;
505 }
506
507 static void *shader_sm1_init(const DWORD *byte_code, const struct wined3d_shader_signature *output_signature)
508 {
509     struct wined3d_sm1_data *priv;
510     BYTE major, minor;
511
512     major = WINED3D_SM1_VERSION_MAJOR(*byte_code);
513     minor = WINED3D_SM1_VERSION_MINOR(*byte_code);
514     if (WINED3D_SHADER_VERSION(major, minor) > WINED3D_SHADER_VERSION(3, 0))
515     {
516         WARN("Invalid shader version %u.%u (%#x).\n", major, minor, *byte_code);
517         return NULL;
518     }
519
520     priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv));
521     if (!priv)
522     {
523         ERR("Failed to allocate private data\n");
524         return NULL;
525     }
526
527     if (output_signature)
528     {
529         FIXME("SM 1-3 shader shouldn't have output signatures.\n");
530     }
531
532     switch (*byte_code >> 16)
533     {
534         case WINED3D_SM1_VS:
535             priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX;
536             priv->opcode_table = vs_opcode_table;
537             break;
538
539         case WINED3D_SM1_PS:
540             priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL;
541             priv->opcode_table = ps_opcode_table;
542             break;
543
544         default:
545             FIXME("Unrecognized shader type %#x\n", *byte_code >> 16);
546             HeapFree(GetProcessHeap(), 0, priv);
547             return NULL;
548     }
549
550     return priv;
551 }
552
553 static void shader_sm1_free(void *data)
554 {
555     HeapFree(GetProcessHeap(), 0, data);
556 }
557
558 static void shader_sm1_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
559 {
560     struct wined3d_sm1_data *priv = data;
561     DWORD version_token;
562
563     version_token = *(*ptr)++;
564     TRACE("version: 0x%08x\n", version_token);
565
566     priv->shader_version.major = WINED3D_SM1_VERSION_MAJOR(version_token);
567     priv->shader_version.minor = WINED3D_SM1_VERSION_MINOR(version_token);
568     *shader_version = priv->shader_version;
569 }
570
571 static void shader_sm1_read_opcode(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins,
572         UINT *param_size)
573 {
574     struct wined3d_sm1_data *priv = data;
575     const struct wined3d_sm1_opcode_info *opcode_info;
576     DWORD opcode_token;
577
578     opcode_token = *(*ptr)++;
579     opcode_info = shader_get_opcode(priv, opcode_token);
580     if (!opcode_info)
581     {
582         FIXME("Unrecognized opcode: token=0x%08x\n", opcode_token);
583         ins->handler_idx = WINED3DSIH_TABLE_SIZE;
584         *param_size = shader_skip_unrecognized(priv, *ptr);
585         return;
586     }
587
588     ins->handler_idx = opcode_info->handler_idx;
589     ins->flags = (opcode_token & WINED3D_OPCODESPECIFICCONTROL_MASK) >> WINED3D_OPCODESPECIFICCONTROL_SHIFT;
590     ins->coissue = opcode_token & WINED3DSI_COISSUE;
591     ins->predicate = opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED;
592     ins->dst_count = opcode_info->dst_count ? 1 : 0;
593     ins->src_count = opcode_info->param_count - opcode_info->dst_count;
594     *param_size = shader_skip_opcode(priv, opcode_info, opcode_token);
595 }
596
597 static void shader_sm1_read_src_param(void *data, const DWORD **ptr, struct wined3d_shader_src_param *src_param,
598         struct wined3d_shader_src_param *src_rel_addr)
599 {
600     struct wined3d_sm1_data *priv = data;
601     DWORD token, addr_token;
602
603     *ptr += shader_get_param(priv, *ptr, &token, &addr_token);
604     if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
605     {
606         shader_parse_src_param(addr_token, NULL, src_rel_addr);
607         shader_parse_src_param(token, src_rel_addr, src_param);
608     }
609     else
610     {
611         shader_parse_src_param(token, NULL, src_param);
612     }
613 }
614
615 static void shader_sm1_read_dst_param(void *data, const DWORD **ptr, struct wined3d_shader_dst_param *dst_param,
616         struct wined3d_shader_src_param *dst_rel_addr)
617 {
618     struct wined3d_sm1_data *priv = data;
619     DWORD token, addr_token;
620
621     *ptr += shader_get_param(priv, *ptr, &token, &addr_token);
622     if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
623     {
624         shader_parse_src_param(addr_token, NULL, dst_rel_addr);
625         shader_parse_dst_param(token, dst_rel_addr, dst_param);
626     }
627     else
628     {
629         shader_parse_dst_param(token, NULL, dst_param);
630     }
631 }
632
633 static void shader_sm1_read_semantic(const DWORD **ptr, struct wined3d_shader_semantic *semantic)
634 {
635     DWORD usage_token = *(*ptr)++;
636     DWORD dst_token = *(*ptr)++;
637
638     semantic->usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
639     semantic->usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
640     semantic->sampler_type = (usage_token & WINED3DSP_TEXTURETYPE_MASK) >> WINED3DSP_TEXTURETYPE_SHIFT;
641     shader_parse_dst_param(dst_token, NULL, &semantic->reg);
642 }
643
644 static void shader_sm1_read_comment(const DWORD **ptr, const char **comment, UINT *comment_size)
645 {
646     DWORD token = **ptr;
647     UINT size;
648
649     if ((token & WINED3DSI_OPCODE_MASK) != WINED3D_SM1_OP_COMMENT)
650     {
651         *comment = NULL;
652         return;
653     }
654
655     size = (token & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
656     *comment = (const char *)++(*ptr);
657     *comment_size = size * sizeof(DWORD);
658     *ptr += size;
659 }
660
661 static BOOL shader_sm1_is_end(void *data, const DWORD **ptr)
662 {
663     if (**ptr == WINED3DSP_END)
664     {
665         ++(*ptr);
666         return TRUE;
667     }
668
669     return FALSE;
670 }
671
672 const struct wined3d_shader_frontend sm1_shader_frontend =
673 {
674     shader_sm1_init,
675     shader_sm1_free,
676     shader_sm1_read_header,
677     shader_sm1_read_opcode,
678     shader_sm1_read_src_param,
679     shader_sm1_read_dst_param,
680     shader_sm1_read_semantic,
681     shader_sm1_read_comment,
682     shader_sm1_is_end,
683 };