?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Use wined3d_mask_from_size() in shader_glsl_gather4().
[wine.git] / dlls / wined3d / shader_sm1.c
blob6dedc83684ce6c4430a0bcb9a30c1e0d435e0f15
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
27 #include "wined3d_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
30
31 /* DCL usage masks */
32 #define WINED3D_SM1_DCL_USAGE_SHIFT 0
33 #define WINED3D_SM1_DCL_USAGE_MASK (0xfu << WINED3D_SM1_DCL_USAGE_SHIFT)
34 #define WINED3D_SM1_DCL_USAGE_INDEX_SHIFT 16
35 #define WINED3D_SM1_DCL_USAGE_INDEX_MASK (0xfu << WINED3D_SM1_DCL_USAGE_INDEX_SHIFT)
36
37 /* DCL sampler type */
38 #define WINED3D_SM1_RESOURCE_TYPE_SHIFT 27
39 #define WINED3D_SM1_RESOURCE_TYPE_MASK (0xfu << WINED3D_SM1_RESOURCE_TYPE_SHIFT)
40
41 /* Opcode-related masks */
42 #define WINED3D_SM1_OPCODE_MASK 0x0000ffff
43
44 #define WINED3D_SM1_INSTRUCTION_FLAGS_SHIFT 16
45 #define WINED3D_SM1_INSTRUCTION_FLAGS_MASK (0xffu << WINED3D_SM1_INSTRUCTION_FLAGS_SHIFT)
46
47 #define WINED3D_SM1_INSTRUCTION_LENGTH_SHIFT 24
48 #define WINED3D_SM1_INSTRUCTION_LENGTH_MASK (0xfu << WINED3D_SM1_INSTRUCTION_LENGTH_SHIFT)
49
50 #define WINED3D_SM1_COISSUE (0x1u << 30)
51
52 #define WINED3D_SM1_COMMENT_SIZE_SHIFT 16
53 #define WINED3D_SM1_COMMENT_SIZE_MASK (0x7fffu << WINED3D_SM1_COMMENT_SIZE_SHIFT)
54
55 #define WINED3D_SM1_INSTRUCTION_PREDICATED (0x1u << 28)
56
57 /* Register number mask */
58 #define WINED3D_SM1_REGISTER_NUMBER_MASK 0x000007ff
59
60 /* Register type masks */
61 #define WINED3D_SM1_REGISTER_TYPE_SHIFT 28
62 #define WINED3D_SM1_REGISTER_TYPE_MASK (0x7u << WINED3D_SM1_REGISTER_TYPE_SHIFT)
63 #define WINED3D_SM1_REGISTER_TYPE_SHIFT2 8
64 #define WINED3D_SM1_REGISTER_TYPE_MASK2 (0x18u << WINED3D_SM1_REGISTER_TYPE_SHIFT2)
65
66 /* Relative addressing mask */
67 #define WINED3D_SM1_ADDRESS_MODE_SHIFT 13
68 #define WINED3D_SM1_ADDRESS_MODE_MASK (0x1u << WINED3D_SM1_ADDRESS_MODE_SHIFT)
69
70 /* Destination modifier mask */
71 #define WINED3D_SM1_DST_MODIFIER_SHIFT 20
72 #define WINED3D_SM1_DST_MODIFIER_MASK (0xfu << WINED3D_SM1_DST_MODIFIER_SHIFT)
73
74 /* Destination shift mask */
75 #define WINED3D_SM1_DSTSHIFT_SHIFT 24
76 #define WINED3D_SM1_DSTSHIFT_MASK (0xfu << WINED3D_SM1_DSTSHIFT_SHIFT)
77
78 /* Write mask */
79 #define WINED3D_SM1_WRITEMASK_SHIFT 16
80 #define WINED3D_SM1_WRITEMASK_MASK (0xfu << WINED3D_SM1_WRITEMASK_SHIFT)
81
82 /* Swizzle mask */
83 #define WINED3D_SM1_SWIZZLE_SHIFT 16
84 #define WINED3D_SM1_SWIZZLE_MASK (0xffu << WINED3D_SM1_SWIZZLE_SHIFT)
85
86 /* Source modifier mask */
87 #define WINED3D_SM1_SRC_MODIFIER_SHIFT 24
88 #define WINED3D_SM1_SRC_MODIFIER_MASK (0xfu << WINED3D_SM1_SRC_MODIFIER_SHIFT)
89
90 #define WINED3D_SM1_END 0x0000ffff
91
92 #define WINED3D_SM1_VERSION_MAJOR(version) (((version) >> 8) & 0xff)
93 #define WINED3D_SM1_VERSION_MINOR(version) (((version) >> 0) & 0xff)
94
95 enum wined3d_sm1_address_mode_type
96 {
97 WINED3D_SM1_ADDRESS_MODE_ABSOLUTE = 0u << WINED3D_SM1_ADDRESS_MODE_SHIFT,
98 WINED3D_SM1_ADDRESS_MODE_RELATIVE = 1u << WINED3D_SM1_ADDRESS_MODE_SHIFT,
99 };
100
101 enum wined3d_sm1_resource_type
102 {
103 WINED3D_SM1_RESOURCE_UNKNOWN = 0x0,
104 WINED3D_SM1_RESOURCE_TEXTURE_1D = 0x1,
105 WINED3D_SM1_RESOURCE_TEXTURE_2D = 0x2,
106 WINED3D_SM1_RESOURCE_TEXTURE_CUBE = 0x3,
107 WINED3D_SM1_RESOURCE_TEXTURE_3D = 0x4,
108 };
109
110 enum wined3d_sm1_opcode
111 {
112 WINED3D_SM1_OP_NOP = 0x00,
113 WINED3D_SM1_OP_MOV = 0x01,
114 WINED3D_SM1_OP_ADD = 0x02,
115 WINED3D_SM1_OP_SUB = 0x03,
116 WINED3D_SM1_OP_MAD = 0x04,
117 WINED3D_SM1_OP_MUL = 0x05,
118 WINED3D_SM1_OP_RCP = 0x06,
119 WINED3D_SM1_OP_RSQ = 0x07,
120 WINED3D_SM1_OP_DP3 = 0x08,
121 WINED3D_SM1_OP_DP4 = 0x09,
122 WINED3D_SM1_OP_MIN = 0x0a,
123 WINED3D_SM1_OP_MAX = 0x0b,
124 WINED3D_SM1_OP_SLT = 0x0c,
125 WINED3D_SM1_OP_SGE = 0x0d,
126 WINED3D_SM1_OP_EXP = 0x0e,
127 WINED3D_SM1_OP_LOG = 0x0f,
128 WINED3D_SM1_OP_LIT = 0x10,
129 WINED3D_SM1_OP_DST = 0x11,
130 WINED3D_SM1_OP_LRP = 0x12,
131 WINED3D_SM1_OP_FRC = 0x13,
132 WINED3D_SM1_OP_M4x4 = 0x14,
133 WINED3D_SM1_OP_M4x3 = 0x15,
134 WINED3D_SM1_OP_M3x4 = 0x16,
135 WINED3D_SM1_OP_M3x3 = 0x17,
136 WINED3D_SM1_OP_M3x2 = 0x18,
137 WINED3D_SM1_OP_CALL = 0x19,
138 WINED3D_SM1_OP_CALLNZ = 0x1a,
139 WINED3D_SM1_OP_LOOP = 0x1b,
140 WINED3D_SM1_OP_RET = 0x1c,
141 WINED3D_SM1_OP_ENDLOOP = 0x1d,
142 WINED3D_SM1_OP_LABEL = 0x1e,
143 WINED3D_SM1_OP_DCL = 0x1f,
144 WINED3D_SM1_OP_POW = 0x20,
145 WINED3D_SM1_OP_CRS = 0x21,
146 WINED3D_SM1_OP_SGN = 0x22,
147 WINED3D_SM1_OP_ABS = 0x23,
148 WINED3D_SM1_OP_NRM = 0x24,
149 WINED3D_SM1_OP_SINCOS = 0x25,
150 WINED3D_SM1_OP_REP = 0x26,
151 WINED3D_SM1_OP_ENDREP = 0x27,
152 WINED3D_SM1_OP_IF = 0x28,
153 WINED3D_SM1_OP_IFC = 0x29,
154 WINED3D_SM1_OP_ELSE = 0x2a,
155 WINED3D_SM1_OP_ENDIF = 0x2b,
156 WINED3D_SM1_OP_BREAK = 0x2c,
157 WINED3D_SM1_OP_BREAKC = 0x2d,
158 WINED3D_SM1_OP_MOVA = 0x2e,
159 WINED3D_SM1_OP_DEFB = 0x2f,
160 WINED3D_SM1_OP_DEFI = 0x30,
161
162 WINED3D_SM1_OP_TEXCOORD = 0x40,
163 WINED3D_SM1_OP_TEXKILL = 0x41,
164 WINED3D_SM1_OP_TEX = 0x42,
165 WINED3D_SM1_OP_TEXBEM = 0x43,
166 WINED3D_SM1_OP_TEXBEML = 0x44,
167 WINED3D_SM1_OP_TEXREG2AR = 0x45,
168 WINED3D_SM1_OP_TEXREG2GB = 0x46,
169 WINED3D_SM1_OP_TEXM3x2PAD = 0x47,
170 WINED3D_SM1_OP_TEXM3x2TEX = 0x48,
171 WINED3D_SM1_OP_TEXM3x3PAD = 0x49,
172 WINED3D_SM1_OP_TEXM3x3TEX = 0x4a,
173 WINED3D_SM1_OP_TEXM3x3DIFF = 0x4b,
174 WINED3D_SM1_OP_TEXM3x3SPEC = 0x4c,
175 WINED3D_SM1_OP_TEXM3x3VSPEC = 0x4d,
176 WINED3D_SM1_OP_EXPP = 0x4e,
177 WINED3D_SM1_OP_LOGP = 0x4f,
178 WINED3D_SM1_OP_CND = 0x50,
179 WINED3D_SM1_OP_DEF = 0x51,
180 WINED3D_SM1_OP_TEXREG2RGB = 0x52,
181 WINED3D_SM1_OP_TEXDP3TEX = 0x53,
182 WINED3D_SM1_OP_TEXM3x2DEPTH = 0x54,
183 WINED3D_SM1_OP_TEXDP3 = 0x55,
184 WINED3D_SM1_OP_TEXM3x3 = 0x56,
185 WINED3D_SM1_OP_TEXDEPTH = 0x57,
186 WINED3D_SM1_OP_CMP = 0x58,
187 WINED3D_SM1_OP_BEM = 0x59,
188 WINED3D_SM1_OP_DP2ADD = 0x5a,
189 WINED3D_SM1_OP_DSX = 0x5b,
190 WINED3D_SM1_OP_DSY = 0x5c,
191 WINED3D_SM1_OP_TEXLDD = 0x5d,
192 WINED3D_SM1_OP_SETP = 0x5e,
193 WINED3D_SM1_OP_TEXLDL = 0x5f,
194 WINED3D_SM1_OP_BREAKP = 0x60,
195
196 WINED3D_SM1_OP_PHASE = 0xfffd,
197 WINED3D_SM1_OP_COMMENT = 0xfffe,
198 WINED3D_SM1_OP_END = 0Xffff,
199 };
200
201 struct wined3d_sm1_opcode_info
202 {
203 enum wined3d_sm1_opcode opcode;
204 unsigned int dst_count;
205 unsigned int param_count;
206 enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx;
207 DWORD min_version;
208 DWORD max_version;
209 };
210
211 struct wined3d_sm1_data
212 {
213 struct wined3d_shader_version shader_version;
214 const struct wined3d_sm1_opcode_info *opcode_table;
215 const DWORD *start;
216
217 struct wined3d_shader_src_param src_rel_addr[4];
218 struct wined3d_shader_src_param pred_rel_addr;
219 struct wined3d_shader_src_param dst_rel_addr;
220 struct wined3d_shader_src_param src_param[4];
221 struct wined3d_shader_src_param pred_param;
222 struct wined3d_shader_dst_param dst_param;
223 };
224
225 /* This table is not order or position dependent. */
226 static const struct wined3d_sm1_opcode_info vs_opcode_table[] =
227 {
228 /* Arithmetic */
229 {WINED3D_SM1_OP_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 },
230 {WINED3D_SM1_OP_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 },
231 {WINED3D_SM1_OP_MOVA, 1, 2, WINED3DSIH_MOVA, WINED3D_SHADER_VERSION(2,0), -1 },
232 {WINED3D_SM1_OP_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 },
233 {WINED3D_SM1_OP_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 },
234 {WINED3D_SM1_OP_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 },
235 {WINED3D_SM1_OP_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 },
236 {WINED3D_SM1_OP_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 },
237 {WINED3D_SM1_OP_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 },
238 {WINED3D_SM1_OP_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 },
239 {WINED3D_SM1_OP_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 },
240 {WINED3D_SM1_OP_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 },
241 {WINED3D_SM1_OP_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 },
242 {WINED3D_SM1_OP_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 },
243 {WINED3D_SM1_OP_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 },
244 {WINED3D_SM1_OP_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 },
245 {WINED3D_SM1_OP_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 },
246 {WINED3D_SM1_OP_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 },
247 {WINED3D_SM1_OP_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 },
248 {WINED3D_SM1_OP_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 },
249 {WINED3D_SM1_OP_LIT, 1, 2, WINED3DSIH_LIT, 0, 0 },
250 {WINED3D_SM1_OP_DST, 1, 3, WINED3DSIH_DST, 0, 0 },
251 {WINED3D_SM1_OP_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 },
252 {WINED3D_SM1_OP_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 },
253 {WINED3D_SM1_OP_POW, 1, 3, WINED3DSIH_POW, 0, 0 },
254 {WINED3D_SM1_OP_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 },
255 {WINED3D_SM1_OP_SGN, 1, 4, WINED3DSIH_SGN, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
256 {WINED3D_SM1_OP_SGN, 1, 2, WINED3DSIH_SGN, WINED3D_SHADER_VERSION(3,0), -1 },
257 {WINED3D_SM1_OP_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 },
258 {WINED3D_SM1_OP_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
259 {WINED3D_SM1_OP_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(3,0), -1 },
260 /* Matrix */
261 {WINED3D_SM1_OP_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 },
262 {WINED3D_SM1_OP_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 },
263 {WINED3D_SM1_OP_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 },
264 {WINED3D_SM1_OP_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 },
265 {WINED3D_SM1_OP_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 },
266 /* Declare registers */
267 {WINED3D_SM1_OP_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 },
268 /* Constant definitions */
269 {WINED3D_SM1_OP_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 },
270 {WINED3D_SM1_OP_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 },
271 {WINED3D_SM1_OP_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 },
272 /* Flow control */
273 {WINED3D_SM1_OP_REP, 0, 1, WINED3DSIH_REP, WINED3D_SHADER_VERSION(2,0), -1 },
274 {WINED3D_SM1_OP_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3D_SHADER_VERSION(2,0), -1 },
275 {WINED3D_SM1_OP_IF, 0, 1, WINED3DSIH_IF, WINED3D_SHADER_VERSION(2,0), -1 },
276 {WINED3D_SM1_OP_IFC, 0, 2, WINED3DSIH_IFC, WINED3D_SHADER_VERSION(2,1), -1 },
277 {WINED3D_SM1_OP_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3D_SHADER_VERSION(2,0), -1 },
278 {WINED3D_SM1_OP_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3D_SHADER_VERSION(2,0), -1 },
279 {WINED3D_SM1_OP_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3D_SHADER_VERSION(2,1), -1 },
280 {WINED3D_SM1_OP_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3D_SHADER_VERSION(2,1), -1 },
281 {WINED3D_SM1_OP_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 },
282 {WINED3D_SM1_OP_CALL, 0, 1, WINED3DSIH_CALL, WINED3D_SHADER_VERSION(2,0), -1 },
283 {WINED3D_SM1_OP_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3D_SHADER_VERSION(2,0), -1 },
284 {WINED3D_SM1_OP_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3D_SHADER_VERSION(2,0), -1 },
285 {WINED3D_SM1_OP_RET, 0, 0, WINED3DSIH_RET, WINED3D_SHADER_VERSION(2,0), -1 },
286 {WINED3D_SM1_OP_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3D_SHADER_VERSION(2,0), -1 },
287 {WINED3D_SM1_OP_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3D_SHADER_VERSION(2,0), -1 },
288
289 {WINED3D_SM1_OP_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 },
290 {WINED3D_SM1_OP_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3D_SHADER_VERSION(3,0), -1 },
291 {0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 },
292 };
293
294 static const struct wined3d_sm1_opcode_info ps_opcode_table[] =
295 {
296 /* Arithmetic */
297 {WINED3D_SM1_OP_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 },
298 {WINED3D_SM1_OP_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 },
299 {WINED3D_SM1_OP_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 },
300 {WINED3D_SM1_OP_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 },
301 {WINED3D_SM1_OP_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 },
302 {WINED3D_SM1_OP_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 },
303 {WINED3D_SM1_OP_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 },
304 {WINED3D_SM1_OP_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 },
305 {WINED3D_SM1_OP_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 },
306 {WINED3D_SM1_OP_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 },
307 {WINED3D_SM1_OP_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 },
308 {WINED3D_SM1_OP_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 },
309 {WINED3D_SM1_OP_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 },
310 {WINED3D_SM1_OP_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 },
311 {WINED3D_SM1_OP_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 },
312 {WINED3D_SM1_OP_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 },
313 {WINED3D_SM1_OP_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 },
314 {WINED3D_SM1_OP_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 },
315 {WINED3D_SM1_OP_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 },
316 {WINED3D_SM1_OP_DST, 1, 3, WINED3DSIH_DST, 0, 0 },
317 {WINED3D_SM1_OP_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 },
318 {WINED3D_SM1_OP_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 },
319 {WINED3D_SM1_OP_CND, 1, 4, WINED3DSIH_CND, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,4)},
320 {WINED3D_SM1_OP_CMP, 1, 4, WINED3DSIH_CMP, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(3,0)},
321 {WINED3D_SM1_OP_POW, 1, 3, WINED3DSIH_POW, 0, 0 },
322 {WINED3D_SM1_OP_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 },
323 {WINED3D_SM1_OP_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 },
324 {WINED3D_SM1_OP_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
325 {WINED3D_SM1_OP_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(3,0), -1 },
326 {WINED3D_SM1_OP_DP2ADD, 1, 4, WINED3DSIH_DP2ADD, WINED3D_SHADER_VERSION(2,0), -1 },
327 /* Matrix */
328 {WINED3D_SM1_OP_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 },
329 {WINED3D_SM1_OP_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 },
330 {WINED3D_SM1_OP_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 },
331 {WINED3D_SM1_OP_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 },
332 {WINED3D_SM1_OP_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 },
333 /* Register declarations */
334 {WINED3D_SM1_OP_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 },
335 /* Flow control */
336 {WINED3D_SM1_OP_REP, 0, 1, WINED3DSIH_REP, WINED3D_SHADER_VERSION(2,1), -1 },
337 {WINED3D_SM1_OP_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3D_SHADER_VERSION(2,1), -1 },
338 {WINED3D_SM1_OP_IF, 0, 1, WINED3DSIH_IF, WINED3D_SHADER_VERSION(2,1), -1 },
339 {WINED3D_SM1_OP_IFC, 0, 2, WINED3DSIH_IFC, WINED3D_SHADER_VERSION(2,1), -1 },
340 {WINED3D_SM1_OP_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3D_SHADER_VERSION(2,1), -1 },
341 {WINED3D_SM1_OP_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3D_SHADER_VERSION(2,1), -1 },
342 {WINED3D_SM1_OP_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3D_SHADER_VERSION(2,1), -1 },
343 {WINED3D_SM1_OP_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3D_SHADER_VERSION(2,1), -1 },
344 {WINED3D_SM1_OP_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 },
345 {WINED3D_SM1_OP_CALL, 0, 1, WINED3DSIH_CALL, WINED3D_SHADER_VERSION(2,1), -1 },
346 {WINED3D_SM1_OP_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3D_SHADER_VERSION(2,1), -1 },
347 {WINED3D_SM1_OP_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3D_SHADER_VERSION(3,0), -1 },
348 {WINED3D_SM1_OP_RET, 0, 0, WINED3DSIH_RET, WINED3D_SHADER_VERSION(2,1), -1 },
349 {WINED3D_SM1_OP_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3D_SHADER_VERSION(3,0), -1 },
350 {WINED3D_SM1_OP_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3D_SHADER_VERSION(2,1), -1 },
351 /* Constant definitions */
352 {WINED3D_SM1_OP_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 },
353 {WINED3D_SM1_OP_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 },
354 {WINED3D_SM1_OP_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 },
355 /* Texture */
356 {WINED3D_SM1_OP_TEXCOORD, 1, 1, WINED3DSIH_TEXCOORD, 0, WINED3D_SHADER_VERSION(1,3)},
357 {WINED3D_SM1_OP_TEXCOORD, 1, 2, WINED3DSIH_TEXCOORD, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
358 {WINED3D_SM1_OP_TEXKILL, 1, 1, WINED3DSIH_TEXKILL, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(3,0)},
359 {WINED3D_SM1_OP_TEX, 1, 1, WINED3DSIH_TEX, 0, WINED3D_SHADER_VERSION(1,3)},
360 {WINED3D_SM1_OP_TEX, 1, 2, WINED3DSIH_TEX, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
361 {WINED3D_SM1_OP_TEX, 1, 3, WINED3DSIH_TEX, WINED3D_SHADER_VERSION(2,0), -1 },
362 {WINED3D_SM1_OP_TEXBEM, 1, 2, WINED3DSIH_TEXBEM, 0, WINED3D_SHADER_VERSION(1,3)},
363 {WINED3D_SM1_OP_TEXBEML, 1, 2, WINED3DSIH_TEXBEML, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
364 {WINED3D_SM1_OP_TEXREG2AR, 1, 2, WINED3DSIH_TEXREG2AR, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
365 {WINED3D_SM1_OP_TEXREG2GB, 1, 2, WINED3DSIH_TEXREG2GB, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
366 {WINED3D_SM1_OP_TEXREG2RGB, 1, 2, WINED3DSIH_TEXREG2RGB, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
367 {WINED3D_SM1_OP_TEXM3x2PAD, 1, 2, WINED3DSIH_TEXM3x2PAD, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
368 {WINED3D_SM1_OP_TEXM3x2TEX, 1, 2, WINED3DSIH_TEXM3x2TEX, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
369 {WINED3D_SM1_OP_TEXM3x3PAD, 1, 2, WINED3DSIH_TEXM3x3PAD, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
370 {WINED3D_SM1_OP_TEXM3x3DIFF, 1, 2, WINED3DSIH_TEXM3x3DIFF, WINED3D_SHADER_VERSION(0,0), WINED3D_SHADER_VERSION(0,0)},
371 {WINED3D_SM1_OP_TEXM3x3SPEC, 1, 3, WINED3DSIH_TEXM3x3SPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
372 {WINED3D_SM1_OP_TEXM3x3VSPEC, 1, 2, WINED3DSIH_TEXM3x3VSPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
373 {WINED3D_SM1_OP_TEXM3x3TEX, 1, 2, WINED3DSIH_TEXM3x3TEX, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
374 {WINED3D_SM1_OP_TEXDP3TEX, 1, 2, WINED3DSIH_TEXDP3TEX, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
375 {WINED3D_SM1_OP_TEXM3x2DEPTH, 1, 2, WINED3DSIH_TEXM3x2DEPTH, WINED3D_SHADER_VERSION(1,3), WINED3D_SHADER_VERSION(1,3)},
376 {WINED3D_SM1_OP_TEXDP3, 1, 2, WINED3DSIH_TEXDP3, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
377 {WINED3D_SM1_OP_TEXM3x3, 1, 2, WINED3DSIH_TEXM3x3, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
378 {WINED3D_SM1_OP_TEXDEPTH, 1, 1, WINED3DSIH_TEXDEPTH, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
379 {WINED3D_SM1_OP_BEM, 1, 3, WINED3DSIH_BEM, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
380 {WINED3D_SM1_OP_DSX, 1, 2, WINED3DSIH_DSX, WINED3D_SHADER_VERSION(2,1), -1 },
381 {WINED3D_SM1_OP_DSY, 1, 2, WINED3DSIH_DSY, WINED3D_SHADER_VERSION(2,1), -1 },
382 {WINED3D_SM1_OP_TEXLDD, 1, 5, WINED3DSIH_TEXLDD, WINED3D_SHADER_VERSION(2,1), -1 },
383 {WINED3D_SM1_OP_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 },
384 {WINED3D_SM1_OP_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3D_SHADER_VERSION(3,0), -1 },
385 {WINED3D_SM1_OP_PHASE, 0, 0, WINED3DSIH_PHASE, 0, 0 },
386 {0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 },
387 };
388
389 static const enum wined3d_shader_resource_type resource_type_table[] =
390 {
391 /* WINED3D_SM1_RESOURCE_UNKNOWN */ WINED3D_SHADER_RESOURCE_NONE,
392 /* WINED3D_SM1_RESOURCE_TEXTURE_1D */ WINED3D_SHADER_RESOURCE_TEXTURE_1D,
393 /* WINED3D_SM1_RESOURCE_TEXTURE_2D */ WINED3D_SHADER_RESOURCE_TEXTURE_2D,
394 /* WINED3D_SM1_RESOURCE_TEXTURE_CUBE */ WINED3D_SHADER_RESOURCE_TEXTURE_CUBE,
395 /* WINED3D_SM1_RESOURCE_TEXTURE_3D */ WINED3D_SHADER_RESOURCE_TEXTURE_3D,
396 };
397
398 /* Read a parameter opcode from the input stream,
399 * and possibly a relative addressing token.
400 * Return the number of tokens read */
401 static unsigned int shader_get_param(const struct wined3d_sm1_data *priv, const DWORD *ptr,
402 DWORD *token, DWORD *addr_token)
403 {
404 unsigned int count = 1;
405
406 *token = *ptr;
407
408 /* PS >= 3.0 have relative addressing (with token)
409 * VS >= 2.0 have relative addressing (with token)
410 * VS >= 1.0 < 2.0 have relative addressing (without token)
411 * The version check below should work in general */
412 if (*ptr & WINED3D_SM1_ADDRESS_MODE_RELATIVE)
413 {
414 if (priv->shader_version.major < 2)
415 {
416 *addr_token = (1u << 31)
417 | ((WINED3DSPR_ADDR << WINED3D_SM1_REGISTER_TYPE_SHIFT2) & WINED3D_SM1_REGISTER_TYPE_MASK2)
418 | ((WINED3DSPR_ADDR << WINED3D_SM1_REGISTER_TYPE_SHIFT) & WINED3D_SM1_REGISTER_TYPE_MASK)
419 | (WINED3DSP_NOSWIZZLE << WINED3D_SM1_SWIZZLE_SHIFT);
420 }
421 else
422 {
423 *addr_token = *(ptr + 1);
424 ++count;
425 }
426 }
427
428 return count;
429 }
430
431 static const struct wined3d_sm1_opcode_info *shader_get_opcode(const struct wined3d_sm1_data *priv, DWORD token)
432 {
433 DWORD shader_version = WINED3D_SHADER_VERSION(priv->shader_version.major, priv->shader_version.minor);
434 const struct wined3d_sm1_opcode_info *opcode_table = priv->opcode_table;
435 unsigned int i = 0;
436
437 while (opcode_table[i].handler_idx != WINED3DSIH_TABLE_SIZE)
438 {
439 if ((token & WINED3D_SM1_OPCODE_MASK) == opcode_table[i].opcode
440 && shader_version >= opcode_table[i].min_version
441 && (!opcode_table[i].max_version || shader_version <= opcode_table[i].max_version))
442 {
443 return &opcode_table[i];
444 }
445 ++i;
446 }
447
448 FIXME("Unsupported opcode %#x, token 0x%08x, shader version %#x.\n",
449 token & WINED3D_SM1_OPCODE_MASK, token, shader_version);
450
451 return NULL;
452 }
453
454 /* Return the number of parameters to skip for an opcode */
455 static unsigned int shader_skip_opcode(const struct wined3d_sm1_data *priv,
456 const struct wined3d_sm1_opcode_info *opcode_info, DWORD opcode_token)
457 {
458 unsigned int length;
459 /* Shaders >= 2.0 may contain address tokens, but fortunately they
460 * have a useful length mask - use it here. Shaders 1.0 contain no such tokens */
461 length = (opcode_token & WINED3D_SM1_INSTRUCTION_LENGTH_MASK) >> WINED3D_SM1_INSTRUCTION_LENGTH_SHIFT;
462 return (priv->shader_version.major >= 2) ? length : opcode_info->param_count;
463 }
464
465 static void shader_parse_src_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
466 struct wined3d_shader_src_param *src)
467 {
468 src->reg.type = ((param & WINED3D_SM1_REGISTER_TYPE_MASK) >> WINED3D_SM1_REGISTER_TYPE_SHIFT)
469 | ((param & WINED3D_SM1_REGISTER_TYPE_MASK2) >> WINED3D_SM1_REGISTER_TYPE_SHIFT2);
470 src->reg.data_type = WINED3D_DATA_FLOAT;
471 src->reg.idx[0].offset = param & WINED3D_SM1_REGISTER_NUMBER_MASK;
472 src->reg.idx[0].rel_addr = rel_addr;
473 src->reg.idx[1].offset = ~0U;
474 src->reg.idx[1].rel_addr = NULL;
475 src->swizzle = (param & WINED3D_SM1_SWIZZLE_MASK) >> WINED3D_SM1_SWIZZLE_SHIFT;
476 src->modifiers = (param & WINED3D_SM1_SRC_MODIFIER_MASK) >> WINED3D_SM1_SRC_MODIFIER_SHIFT;
477 }
478
479 static void shader_parse_dst_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
480 struct wined3d_shader_dst_param *dst)
481 {
482 dst->reg.type = ((param & WINED3D_SM1_REGISTER_TYPE_MASK) >> WINED3D_SM1_REGISTER_TYPE_SHIFT)
483 | ((param & WINED3D_SM1_REGISTER_TYPE_MASK2) >> WINED3D_SM1_REGISTER_TYPE_SHIFT2);
484 dst->reg.data_type = WINED3D_DATA_FLOAT;
485 dst->reg.idx[0].offset = param & WINED3D_SM1_REGISTER_NUMBER_MASK;
486 dst->reg.idx[0].rel_addr = rel_addr;
487 dst->reg.idx[1].offset = ~0U;
488 dst->reg.idx[1].rel_addr = NULL;
489 dst->write_mask = (param & WINED3D_SM1_WRITEMASK_MASK) >> WINED3D_SM1_WRITEMASK_SHIFT;
490 dst->modifiers = (param & WINED3D_SM1_DST_MODIFIER_MASK) >> WINED3D_SM1_DST_MODIFIER_SHIFT;
491 dst->shift = (param & WINED3D_SM1_DSTSHIFT_MASK) >> WINED3D_SM1_DSTSHIFT_SHIFT;
492 }
493
494 /* Read the parameters of an unrecognized opcode from the input stream
495 * Return the number of tokens read.
496 *
497 * Note: This function assumes source or destination token format.
498 * It will not work with specially-formatted tokens like DEF or DCL,
499 * but hopefully those would be recognized */
500 static unsigned int shader_skip_unrecognized(const struct wined3d_sm1_data *priv, const DWORD *ptr)
501 {
502 unsigned int tokens_read = 0, i = 0;
503
504 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
505 while (*ptr & 0x80000000)
506 {
507 DWORD token, addr_token = 0;
508 struct wined3d_shader_src_param rel_addr;
509
510 tokens_read += shader_get_param(priv, ptr, &token, &addr_token);
511 ptr += tokens_read;
512
513 FIXME("Unrecognized opcode param: token=0x%08x addr_token=0x%08x.\n", token, addr_token);
514
515 if (token & WINED3D_SM1_ADDRESS_MODE_RELATIVE)
516 shader_parse_src_param(addr_token, NULL, &rel_addr);
517
518 if (!i)
519 {
520 struct wined3d_shader_dst_param dst;
521
522 shader_parse_dst_param(token, token & WINED3D_SM1_ADDRESS_MODE_RELATIVE ? &rel_addr : NULL, &dst);
523 }
524 else
525 {
526 struct wined3d_shader_src_param src;
527
528 shader_parse_src_param(token, token & WINED3D_SM1_ADDRESS_MODE_RELATIVE ? &rel_addr : NULL, &src);
529 }
530 ++i;
531 }
532 return tokens_read;
533 }
534
535 static void *shader_sm1_init(const DWORD *byte_code, size_t byte_code_size,
536 const struct wined3d_shader_signature *output_signature)
537 {
538 struct wined3d_sm1_data *priv;
539 BYTE major, minor;
540
541 TRACE("Version: 0x%08x.\n", *byte_code);
542
543 major = WINED3D_SM1_VERSION_MAJOR(*byte_code);
544 minor = WINED3D_SM1_VERSION_MINOR(*byte_code);
545 if (WINED3D_SHADER_VERSION(major, minor) > WINED3D_SHADER_VERSION(3, 0))
546 {
547 WARN("Invalid shader version %u.%u (%#x).\n", major, minor, *byte_code);
548 return NULL;
549 }
550
551 if (!(priv = heap_alloc(sizeof(*priv))))
552 return NULL;
553
554 if (output_signature->element_count)
555 FIXME("SM 1-3 shader shouldn't have output signatures.\n");
556
557 switch (*byte_code >> 16)
558 {
559 case WINED3D_SM1_VS:
560 priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX;
561 priv->opcode_table = vs_opcode_table;
562 break;
563
564 case WINED3D_SM1_PS:
565 priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL;
566 priv->opcode_table = ps_opcode_table;
567 break;
568
569 default:
570 FIXME("Unrecognized shader type %#x.\n", *byte_code >> 16);
571 heap_free(priv);
572 return NULL;
573 }
574 priv->shader_version.major = WINED3D_SM1_VERSION_MAJOR(*byte_code);
575 priv->shader_version.minor = WINED3D_SM1_VERSION_MINOR(*byte_code);
576
577 priv->start = &byte_code[1];
578
579 return priv;
580 }
581
582 static void shader_sm1_free(void *data)
583 {
584 heap_free(data);
585 }
586
587 static void shader_sm1_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
588 {
589 struct wined3d_sm1_data *priv = data;
590
591 *ptr = priv->start;
592 *shader_version = priv->shader_version;
593 }
594
595 static void shader_sm1_read_src_param(struct wined3d_sm1_data *priv, const DWORD **ptr,
596 struct wined3d_shader_src_param *src_param, struct wined3d_shader_src_param *src_rel_addr)
597 {
598 DWORD token, addr_token;
599
600 *ptr += shader_get_param(priv, *ptr, &token, &addr_token);
601 if (token & WINED3D_SM1_ADDRESS_MODE_RELATIVE)
602 {
603 shader_parse_src_param(addr_token, NULL, src_rel_addr);
604 shader_parse_src_param(token, src_rel_addr, src_param);
605 }
606 else
607 {
608 shader_parse_src_param(token, NULL, src_param);
609 }
610 }
611
612 static void shader_sm1_read_dst_param(struct wined3d_sm1_data *priv, const DWORD **ptr,
613 struct wined3d_shader_dst_param *dst_param, struct wined3d_shader_src_param *dst_rel_addr)
614 {
615 DWORD token, addr_token;
616
617 *ptr += shader_get_param(priv, *ptr, &token, &addr_token);
618 if (token & WINED3D_SM1_ADDRESS_MODE_RELATIVE)
619 {
620 shader_parse_src_param(addr_token, NULL, dst_rel_addr);
621 shader_parse_dst_param(token, dst_rel_addr, dst_param);
622 }
623 else
624 {
625 shader_parse_dst_param(token, NULL, dst_param);
626 }
627 }
628
629 static void shader_sm1_read_semantic(const DWORD **ptr, struct wined3d_shader_semantic *semantic)
630 {
631 enum wined3d_sm1_resource_type resource_type;
632 DWORD usage_token = *(*ptr)++;
633 DWORD dst_token = *(*ptr)++;
634
635 semantic->usage = (usage_token & WINED3D_SM1_DCL_USAGE_MASK) >> WINED3D_SM1_DCL_USAGE_SHIFT;
636 semantic->usage_idx = (usage_token & WINED3D_SM1_DCL_USAGE_INDEX_MASK) >> WINED3D_SM1_DCL_USAGE_INDEX_SHIFT;
637 resource_type = (usage_token & WINED3D_SM1_RESOURCE_TYPE_MASK) >> WINED3D_SM1_RESOURCE_TYPE_SHIFT;
638 if (resource_type >= ARRAY_SIZE(resource_type_table))
639 {
640 FIXME("Unhandled resource type %#x.\n", resource_type);
641 semantic->resource_type = WINED3D_SHADER_RESOURCE_NONE;
642 }
643 else
644 {
645 semantic->resource_type = resource_type_table[resource_type];
646 }
647 semantic->resource_data_type = WINED3D_DATA_FLOAT;
648 shader_parse_dst_param(dst_token, NULL, &semantic->reg);
649 }
650
651 static void shader_sm1_read_immconst(const DWORD **ptr, struct wined3d_shader_src_param *src_param,
652 enum wined3d_immconst_type type, enum wined3d_data_type data_type)
653 {
654 unsigned int count = type == WINED3D_IMMCONST_VEC4 ? 4 : 1;
655 src_param->reg.type = WINED3DSPR_IMMCONST;
656 src_param->reg.data_type = data_type;
657 src_param->reg.idx[0].offset = ~0U;
658 src_param->reg.idx[0].rel_addr = NULL;
659 src_param->reg.idx[1].offset = ~0U;
660 src_param->reg.idx[1].rel_addr = NULL;
661 src_param->reg.immconst_type = type;
662 memcpy(src_param->reg.u.immconst_data, *ptr, count * sizeof(DWORD));
663 src_param->swizzle = WINED3DSP_NOSWIZZLE;
664 src_param->modifiers = 0;
665
666 *ptr += count;
667 }
668
669 static void shader_sm1_read_comment(const DWORD **ptr)
670 {
671 DWORD token = **ptr;
672 const char *comment;
673 UINT size;
674
675 while ((token & WINED3D_SM1_OPCODE_MASK) == WINED3D_SM1_OP_COMMENT)
676 {
677 size = (token & WINED3D_SM1_COMMENT_SIZE_MASK) >> WINED3D_SM1_COMMENT_SIZE_SHIFT;
678 comment = (const char *)++(*ptr);
679 *ptr += size;
680
681 if (size > 1 && *(const DWORD *)comment == WINEMAKEFOURCC('T', 'E', 'X', 'T'))
682 {
683 const char *end = comment + size * sizeof(token);
684 const char *p = comment + sizeof(token);
685 const char *line = p;
686
687 TRACE("// TEXT\n");
688 while (p != end)
689 {
690 if (*p == '\n')
691 {
692 UINT len = p - line;
693 if (len && *(p - 1) == '\r') --len;
694 TRACE("// %s\n", debugstr_an(line, len));
695 line = ++p;
696 }
697 else ++p;
698 }
699 if (line != p)
700 TRACE("// %s\n", debugstr_an(line, p - line));
701 }
702 else if (size)
703 TRACE("// %s\n", debugstr_an(comment, size * sizeof(token)));
704 else
705 break;
706
707 token = **ptr;
708 }
709 }
710
711 static void shader_sm1_validate_instruction(struct wined3d_shader_instruction *ins)
712 {
713 if (ins->handler_idx == WINED3DSIH_BREAKP || ins->handler_idx == WINED3DSIH_IF)
714 {
715 if (ins->flags)
716 {
717 FIXME("Ignoring unexpected instruction flags %#x for %s.\n",
718 ins->flags, debug_d3dshaderinstructionhandler(ins->handler_idx));
719 ins->flags = 0;
720 }
721 }
722 }
723
724 static void shader_sm1_read_instruction(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins)
725 {
726 const struct wined3d_sm1_opcode_info *opcode_info;
727 struct wined3d_sm1_data *priv = data;
728 DWORD opcode_token;
729 unsigned int i;
730 const DWORD *p;
731
732 shader_sm1_read_comment(ptr);
733
734 opcode_token = *(*ptr)++;
735 if (!(opcode_info = shader_get_opcode(priv, opcode_token)))
736 {
737 FIXME("Unrecognized opcode: token=0x%08x.\n", opcode_token);
738 ins->handler_idx = WINED3DSIH_TABLE_SIZE;
739 *ptr += shader_skip_unrecognized(priv, *ptr);
740 return;
741 }
742
743 ins->handler_idx = opcode_info->handler_idx;
744 ins->flags = (opcode_token & WINED3D_SM1_INSTRUCTION_FLAGS_MASK) >> WINED3D_SM1_INSTRUCTION_FLAGS_SHIFT;
745 ins->coissue = opcode_token & WINED3D_SM1_COISSUE;
746 ins->predicate = opcode_token & WINED3D_SM1_INSTRUCTION_PREDICATED ? &priv->pred_param : NULL;
747 ins->dst_count = opcode_info->dst_count ? 1 : 0;
748 ins->dst = &priv->dst_param;
749 ins->src_count = opcode_info->param_count - opcode_info->dst_count;
750 ins->src = priv->src_param;
751 memset(&ins->texel_offset, 0, sizeof(ins->texel_offset));
752
753 p = *ptr;
754 *ptr += shader_skip_opcode(priv, opcode_info, opcode_token);
755
756 if (ins->handler_idx == WINED3DSIH_DCL)
757 {
758 shader_sm1_read_semantic(&p, &ins->declaration.semantic);
759 }
760 else if (ins->handler_idx == WINED3DSIH_DEF)
761 {
762 shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
763 shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_DATA_FLOAT);
764 }
765 else if (ins->handler_idx == WINED3DSIH_DEFB)
766 {
767 shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
768 shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_SCALAR, WINED3D_DATA_UINT);
769 }
770 else if (ins->handler_idx == WINED3DSIH_DEFI)
771 {
772 shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
773 shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_DATA_INT);
774 }
775 else
776 {
777 /* Destination token */
778 if (ins->dst_count)
779 shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
780
781 /* Predication token */
782 if (ins->predicate)
783 shader_sm1_read_src_param(priv, &p, &priv->pred_param, &priv->pred_rel_addr);
784
785 /* Other source tokens */
786 for (i = 0; i < ins->src_count; ++i)
787 shader_sm1_read_src_param(priv, &p, &priv->src_param[i], &priv->src_rel_addr[i]);
788 }
789
790 shader_sm1_validate_instruction(ins);
791 }
792
793 static BOOL shader_sm1_is_end(void *data, const DWORD **ptr)
794 {
795 shader_sm1_read_comment(ptr);
796
797 if (**ptr == WINED3D_SM1_END)
798 {
799 ++(*ptr);
800 return TRUE;
801 }
802
803 return FALSE;
804 }
805
806 const struct wined3d_shader_frontend sm1_shader_frontend =
807 {
808 shader_sm1_init,
809 shader_sm1_free,
810 shader_sm1_read_header,
811 shader_sm1_read_instruction,
812 shader_sm1_is_end,
813 };
Windows API implementation