shader_sm1.c@ 82718

最後變更在這個檔案從82718是 82718,由 vboxsync 提交於 5 年前
3D: Check last shader bytecode token, bugref:9613
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 36.2 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/Graphics/shaderlib/shader_sm1.c@ 82718

以其他格式下載: