shader_sm1.c@ 54765

Last change on this file since 54765 was 54765, checked in by vboxsync, 10 years ago
VMSVGA3d: Applied patches from trivirt that among other things makes Chrome work on OpenGL hosts.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.0 KB

Line
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 struct wined3d_sm1_opcode_info *opcode_table;
216	};
217
218	/* This table is not order or position dependent. */
219	static const struct wined3d_sm1_opcode_info vs_opcode_table[] =
220	{
221	/* Arithmetic */
222	{WINED3D_SM1_OP_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 },
223	{WINED3D_SM1_OP_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 },
224	{WINED3D_SM1_OP_MOVA, 1, 2, WINED3DSIH_MOVA, WINED3D_SHADER_VERSION(2,0), -1 },
225	{WINED3D_SM1_OP_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 },
226	{WINED3D_SM1_OP_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 },
227	{WINED3D_SM1_OP_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 },
228	{WINED3D_SM1_OP_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 },
229	{WINED3D_SM1_OP_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 },
230	{WINED3D_SM1_OP_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 },
231	{WINED3D_SM1_OP_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 },
232	{WINED3D_SM1_OP_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 },
233	{WINED3D_SM1_OP_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 },
234	{WINED3D_SM1_OP_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 },
235	{WINED3D_SM1_OP_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 },
236	{WINED3D_SM1_OP_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 },
237	{WINED3D_SM1_OP_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 },
238	{WINED3D_SM1_OP_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 },
239	{WINED3D_SM1_OP_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 },
240	{WINED3D_SM1_OP_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 },
241	{WINED3D_SM1_OP_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 },
242	{WINED3D_SM1_OP_LIT, 1, 2, WINED3DSIH_LIT, 0, 0 },
243	{WINED3D_SM1_OP_DST, 1, 3, WINED3DSIH_DST, 0, 0 },
244	{WINED3D_SM1_OP_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 },
245	{WINED3D_SM1_OP_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 },
246	{WINED3D_SM1_OP_POW, 1, 3, WINED3DSIH_POW, 0, 0 },
247	{WINED3D_SM1_OP_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 },
248	#ifdef VBOX_WITH_VMSVGA /* appears incorrect */
249	{WINED3D_SM1_OP_SGN, 1, 4, WINED3DSIH_SGN, 0, 0 },
250	#else
251	{WINED3D_SM1_OP_SGN, 1, 4, WINED3DSIH_SGN, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
252	{WINED3D_SM1_OP_SGN, 1, 2, WINED3DSIH_SGN, WINED3D_SHADER_VERSION(3,0), -1 },
253	#endif
254	{WINED3D_SM1_OP_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 },
255	{WINED3D_SM1_OP_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
256	{WINED3D_SM1_OP_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(3,0), -1 },
257	/* Matrix */
258	{WINED3D_SM1_OP_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 },
259	{WINED3D_SM1_OP_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 },
260	{WINED3D_SM1_OP_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 },
261	{WINED3D_SM1_OP_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 },
262	{WINED3D_SM1_OP_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 },
263	/* Declare registers */
264	{WINED3D_SM1_OP_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 },
265	/* Constant definitions */
266	{WINED3D_SM1_OP_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 },
267	{WINED3D_SM1_OP_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 },
268	{WINED3D_SM1_OP_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 },
269	/* Flow control */
270	{WINED3D_SM1_OP_REP, 0, 1, WINED3DSIH_REP, WINED3D_SHADER_VERSION(2,0), -1 },
271	{WINED3D_SM1_OP_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3D_SHADER_VERSION(2,0), -1 },
272	{WINED3D_SM1_OP_IF, 0, 1, WINED3DSIH_IF, WINED3D_SHADER_VERSION(2,0), -1 },
273	{WINED3D_SM1_OP_IFC, 0, 2, WINED3DSIH_IFC, WINED3D_SHADER_VERSION(2,0), -1 },
274	{WINED3D_SM1_OP_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3D_SHADER_VERSION(2,0), -1 },
275	{WINED3D_SM1_OP_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3D_SHADER_VERSION(2,0), -1 },
276	{WINED3D_SM1_OP_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3D_SHADER_VERSION(2,1), -1 },
277	{WINED3D_SM1_OP_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3D_SHADER_VERSION(2,1), -1 },
278	{WINED3D_SM1_OP_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 },
279	{WINED3D_SM1_OP_CALL, 0, 1, WINED3DSIH_CALL, WINED3D_SHADER_VERSION(2,0), -1 },
280	{WINED3D_SM1_OP_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3D_SHADER_VERSION(2,0), -1 },
281	{WINED3D_SM1_OP_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3D_SHADER_VERSION(2,0), -1 },
282	{WINED3D_SM1_OP_RET, 0, 0, WINED3DSIH_RET, WINED3D_SHADER_VERSION(2,0), -1 },
283	{WINED3D_SM1_OP_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3D_SHADER_VERSION(2,0), -1 },
284	{WINED3D_SM1_OP_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3D_SHADER_VERSION(2,0), -1 },
285
286	{WINED3D_SM1_OP_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 },
287	{WINED3D_SM1_OP_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3D_SHADER_VERSION(3,0), -1 },
288	{0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 },
289	};
290
291	static const struct wined3d_sm1_opcode_info ps_opcode_table[] =
292	{
293	/* Arithmetic */
294	{WINED3D_SM1_OP_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 },
295	{WINED3D_SM1_OP_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 },
296	{WINED3D_SM1_OP_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 },
297	{WINED3D_SM1_OP_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 },
298	{WINED3D_SM1_OP_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 },
299	{WINED3D_SM1_OP_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 },
300	{WINED3D_SM1_OP_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 },
301	{WINED3D_SM1_OP_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 },
302	{WINED3D_SM1_OP_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 },
303	{WINED3D_SM1_OP_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 },
304	{WINED3D_SM1_OP_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 },
305	{WINED3D_SM1_OP_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 },
306	{WINED3D_SM1_OP_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 },
307	{WINED3D_SM1_OP_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 },
308	{WINED3D_SM1_OP_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 },
309	{WINED3D_SM1_OP_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 },
310	{WINED3D_SM1_OP_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 },
311	{WINED3D_SM1_OP_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 },
312	{WINED3D_SM1_OP_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 },
313	{WINED3D_SM1_OP_DST, 1, 3, WINED3DSIH_DST, 0, 0 },
314	{WINED3D_SM1_OP_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 },
315	{WINED3D_SM1_OP_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 },
316	{WINED3D_SM1_OP_CND, 1, 4, WINED3DSIH_CND, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,4)},
317	{WINED3D_SM1_OP_CMP, 1, 4, WINED3DSIH_CMP, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(3,0)},
318	{WINED3D_SM1_OP_POW, 1, 3, WINED3DSIH_POW, 0, 0 },
319	{WINED3D_SM1_OP_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 },
320	{WINED3D_SM1_OP_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 },
321	{WINED3D_SM1_OP_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
322	{WINED3D_SM1_OP_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(3,0), -1 },
323	{WINED3D_SM1_OP_DP2ADD, 1, 4, WINED3DSIH_DP2ADD, WINED3D_SHADER_VERSION(2,0), -1 },
324	/* Matrix */
325	{WINED3D_SM1_OP_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 },
326	{WINED3D_SM1_OP_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 },
327	{WINED3D_SM1_OP_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 },
328	{WINED3D_SM1_OP_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 },
329	{WINED3D_SM1_OP_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 },
330	/* Register declarations */
331	{WINED3D_SM1_OP_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 },
332	/* Flow control */
333	{WINED3D_SM1_OP_REP, 0, 1, WINED3DSIH_REP, WINED3D_SHADER_VERSION(2,1), -1 },
334	{WINED3D_SM1_OP_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3D_SHADER_VERSION(2,1), -1 },
335	{WINED3D_SM1_OP_IF, 0, 1, WINED3DSIH_IF, WINED3D_SHADER_VERSION(2,1), -1 },
336	{WINED3D_SM1_OP_IFC, 0, 2, WINED3DSIH_IFC, WINED3D_SHADER_VERSION(2,1), -1 },
337	{WINED3D_SM1_OP_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3D_SHADER_VERSION(2,1), -1 },
338	{WINED3D_SM1_OP_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3D_SHADER_VERSION(2,1), -1 },
339	{WINED3D_SM1_OP_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3D_SHADER_VERSION(2,1), -1 },
340	{WINED3D_SM1_OP_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3D_SHADER_VERSION(2,1), -1 },
341	{WINED3D_SM1_OP_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 },
342	{WINED3D_SM1_OP_CALL, 0, 1, WINED3DSIH_CALL, WINED3D_SHADER_VERSION(2,1), -1 },
343	{WINED3D_SM1_OP_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3D_SHADER_VERSION(2,1), -1 },
344	{WINED3D_SM1_OP_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3D_SHADER_VERSION(3,0), -1 },
345	{WINED3D_SM1_OP_RET, 0, 0, WINED3DSIH_RET, WINED3D_SHADER_VERSION(2,1), -1 },
346	{WINED3D_SM1_OP_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3D_SHADER_VERSION(3,0), -1 },
347	{WINED3D_SM1_OP_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3D_SHADER_VERSION(2,1), -1 },
348	/* Constant definitions */
349	{WINED3D_SM1_OP_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 },
350	{WINED3D_SM1_OP_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 },
351	{WINED3D_SM1_OP_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 },
352	/* Texture */
353	{WINED3D_SM1_OP_TEXCOORD, 1, 1, WINED3DSIH_TEXCOORD, 0, WINED3D_SHADER_VERSION(1,3)},
354	{WINED3D_SM1_OP_TEXCOORD, 1, 2, WINED3DSIH_TEXCOORD, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
355	{WINED3D_SM1_OP_TEXKILL, 1, 1, WINED3DSIH_TEXKILL, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(3,0)},
356	{WINED3D_SM1_OP_TEX, 1, 1, WINED3DSIH_TEX, 0, WINED3D_SHADER_VERSION(1,3)},
357	{WINED3D_SM1_OP_TEX, 1, 2, WINED3DSIH_TEX, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
358	{WINED3D_SM1_OP_TEX, 1, 3, WINED3DSIH_TEX, WINED3D_SHADER_VERSION(2,0), -1 },
359	{WINED3D_SM1_OP_TEXBEM, 1, 2, WINED3DSIH_TEXBEM, 0, WINED3D_SHADER_VERSION(1,3)},
360	{WINED3D_SM1_OP_TEXBEML, 1, 2, WINED3DSIH_TEXBEML, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
361	{WINED3D_SM1_OP_TEXREG2AR, 1, 2, WINED3DSIH_TEXREG2AR, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
362	{WINED3D_SM1_OP_TEXREG2GB, 1, 2, WINED3DSIH_TEXREG2GB, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
363	{WINED3D_SM1_OP_TEXREG2RGB, 1, 2, WINED3DSIH_TEXREG2RGB, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
364	{WINED3D_SM1_OP_TEXM3x2PAD, 1, 2, WINED3DSIH_TEXM3x2PAD, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
365	{WINED3D_SM1_OP_TEXM3x2TEX, 1, 2, WINED3DSIH_TEXM3x2TEX, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
366	{WINED3D_SM1_OP_TEXM3x3PAD, 1, 2, WINED3DSIH_TEXM3x3PAD, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
367	{WINED3D_SM1_OP_TEXM3x3DIFF, 1, 2, WINED3DSIH_TEXM3x3DIFF, WINED3D_SHADER_VERSION(0,0), WINED3D_SHADER_VERSION(0,0)},
368	{WINED3D_SM1_OP_TEXM3x3SPEC, 1, 3, WINED3DSIH_TEXM3x3SPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
369	{WINED3D_SM1_OP_TEXM3x3VSPEC, 1, 2, WINED3DSIH_TEXM3x3VSPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
370	{WINED3D_SM1_OP_TEXM3x3TEX, 1, 2, WINED3DSIH_TEXM3x3TEX, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
371	{WINED3D_SM1_OP_TEXDP3TEX, 1, 2, WINED3DSIH_TEXDP3TEX, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
372	{WINED3D_SM1_OP_TEXM3x2DEPTH, 1, 2, WINED3DSIH_TEXM3x2DEPTH, WINED3D_SHADER_VERSION(1,3), WINED3D_SHADER_VERSION(1,3)},
373	{WINED3D_SM1_OP_TEXDP3, 1, 2, WINED3DSIH_TEXDP3, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
374	{WINED3D_SM1_OP_TEXM3x3, 1, 2, WINED3DSIH_TEXM3x3, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
375	{WINED3D_SM1_OP_TEXDEPTH, 1, 1, WINED3DSIH_TEXDEPTH, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
376	{WINED3D_SM1_OP_BEM, 1, 3, WINED3DSIH_BEM, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
377	{WINED3D_SM1_OP_DSX, 1, 2, WINED3DSIH_DSX, WINED3D_SHADER_VERSION(2,1), -1 },
378	{WINED3D_SM1_OP_DSY, 1, 2, WINED3DSIH_DSY, WINED3D_SHADER_VERSION(2,1), -1 },
379	{WINED3D_SM1_OP_TEXLDD, 1, 5, WINED3DSIH_TEXLDD, WINED3D_SHADER_VERSION(2,1), -1 },
380	{WINED3D_SM1_OP_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 },
381	{WINED3D_SM1_OP_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3D_SHADER_VERSION(3,0), -1 },
382	{WINED3D_SM1_OP_PHASE, 0, 0, WINED3DSIH_PHASE, 0, 0 },
383	{0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 },
384	};
385
386	/* Read a parameter opcode from the input stream,
387	* and possibly a relative addressing token.
388	* Return the number of tokens read */
389	static int shader_get_param(const struct wined3d_sm1_data priv, const DWORD ptr, DWORD token, DWORD addr_token)
390	{
391	UINT count = 1;
392
393	token = ptr;
394
395	/* PS >= 3.0 have relative addressing (with token)
396	* VS >= 2.0 have relative addressing (with token)
397	* VS >= 1.0 < 2.0 have relative addressing (without token)
398	* The version check below should work in general */
399	if (*ptr & WINED3DSHADER_ADDRMODE_RELATIVE)
400	{
401	if (priv->shader_version.major < 2)
402	{
403	*addr_token = (1 << 31)
404	\| ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT2) & WINED3DSP_REGTYPE_MASK2)
405	\| ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT) & WINED3DSP_REGTYPE_MASK)
406	\| (WINED3DSP_NOSWIZZLE << WINED3DSP_SWIZZLE_SHIFT);
407	}
408	else
409	{
410	addr_token = (ptr + 1);
411	++count;
412	}
413	}
414
415	return count;
416	}
417
418	static const struct wined3d_sm1_opcode_info shader_get_opcode(const struct wined3d_sm1_data priv, DWORD code)
419	{
420	DWORD shader_version = WINED3D_SHADER_VERSION(priv->shader_version.major, priv->shader_version.minor);
421	const struct wined3d_sm1_opcode_info *opcode_table = priv->opcode_table;
422	DWORD i = 0;
423
424	while (opcode_table[i].handler_idx != WINED3DSIH_TABLE_SIZE)
425	{
426	if ((code & WINED3DSI_OPCODE_MASK) == opcode_table[i].opcode
427	&& shader_version >= opcode_table[i].min_version
428	&& (!opcode_table[i].max_version \|\| shader_version <= opcode_table[i].max_version))
429	{
430	return &opcode_table[i];
431	}
432	++i;
433	}
434
435	FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
436	code, code, code & WINED3DSI_OPCODE_MASK, shader_version);
437
438	return NULL;
439	}
440
441	/* Return the number of parameters to skip for an opcode */
442	static int shader_skip_opcode(const struct wined3d_sm1_data *priv,
443	const struct wined3d_sm1_opcode_info *opcode_info, DWORD opcode_token)
444	{
445	/* Shaders >= 2.0 may contain address tokens, but fortunately they
446	* have a useful length mask - use it here. Shaders 1.0 contain no such tokens */
447	return (priv->shader_version.major >= 2)
448	? ((opcode_token & WINED3DSI_INSTLENGTH_MASK) >> WINED3DSI_INSTLENGTH_SHIFT) : opcode_info->param_count;
449	}
450
451	static void shader_parse_src_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
452	struct wined3d_shader_src_param *src)
453	{
454	src->reg.type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
455	\| ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
456	src->reg.idx = param & WINED3DSP_REGNUM_MASK;
457	src->reg.array_idx = ~0U;
458	src->swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
459	src->modifiers = (param & WINED3DSP_SRCMOD_MASK) >> WINED3DSP_SRCMOD_SHIFT;
460	src->reg.rel_addr = rel_addr;
461	}
462
463	static void shader_parse_dst_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
464	struct wined3d_shader_dst_param *dst)
465	{
466	dst->reg.type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
467	\| ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
468	dst->reg.idx = param & WINED3DSP_REGNUM_MASK;
469	dst->reg.array_idx = ~0U;
470	dst->write_mask = (param & WINED3D_SM1_WRITEMASK_MASK) >> WINED3D_SM1_WRITEMASK_SHIFT;
471	dst->modifiers = (param & WINED3DSP_DSTMOD_MASK) >> WINED3DSP_DSTMOD_SHIFT;
472	dst->shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
473	dst->reg.rel_addr = rel_addr;
474	}
475
476	/* Read the parameters of an unrecognized opcode from the input stream
477	* Return the number of tokens read.
478	*
479	* Note: This function assumes source or destination token format.
480	* It will not work with specially-formatted tokens like DEF or DCL,
481	* but hopefully those would be recognized */
482	static int shader_skip_unrecognized(const struct wined3d_sm1_data priv, const DWORD ptr)
483	{
484	int tokens_read = 0;
485	int i = 0;
486
487	/* TODO: Think of a good name for 0x80000000 and replace it with a constant */
488	while (*ptr & 0x80000000)
489	{
490	DWORD token, addr_token = 0;
491	struct wined3d_shader_src_param rel_addr;
492
493	tokens_read += shader_get_param(priv, ptr, &token, &addr_token);
494	ptr += tokens_read;
495
496	FIXME("Unrecognized opcode param: token=0x%08x addr_token=0x%08x name=", token, addr_token);
497
498	if (token & WINED3DSHADER_ADDRMODE_RELATIVE) shader_parse_src_param(addr_token, NULL, &rel_addr);
499
500	if (!i)
501	{
502	struct wined3d_shader_dst_param dst;
503
504	shader_parse_dst_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &dst);
505	shader_dump_dst_param(&dst, &priv->shader_version);
506	}
507	else
508	{
509	struct wined3d_shader_src_param src;
510
511	shader_parse_src_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &src);
512	shader_dump_src_param(&src, &priv->shader_version);
513	}
514	FIXME("\n");
515	++i;
516	}
517	return tokens_read;
518	}
519
520	static void shader_sm1_init(const DWORD byte_code, const struct wined3d_shader_signature *output_signature)
521	{
522	struct wined3d_sm1_data *priv;
523	BYTE major, minor;
524
525	major = WINED3D_SM1_VERSION_MAJOR(*byte_code);
526	minor = WINED3D_SM1_VERSION_MINOR(*byte_code);
527	if (WINED3D_SHADER_VERSION(major, minor) > WINED3D_SHADER_VERSION(3, 0))
528	{
529	WARN("Invalid shader version %u.%u (%#x).\n", major, minor, *byte_code);
530	return NULL;
531	}
532
533	priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv));
534	if (!priv)
535	{
536	ERR("Failed to allocate private data\n");
537	return NULL;
538	}
539
540	if (output_signature)
541	{
542	FIXME("SM 1-3 shader shouldn't have output signatures.\n");
543	}
544
545	switch (*byte_code >> 16)
546	{
547	case WINED3D_SM1_VS:
548	priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX;
549	priv->opcode_table = vs_opcode_table;
550	break;
551
552	case WINED3D_SM1_PS:
553	priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL;
554	priv->opcode_table = ps_opcode_table;
555	break;
556
557	default:
558	FIXME("Unrecognized shader type %#x\n", *byte_code >> 16);
559	HeapFree(GetProcessHeap(), 0, priv);
560	return NULL;
561	}
562
563	return priv;
564	}
565
566	static void shader_sm1_free(void *data)
567	{
568	HeapFree(GetProcessHeap(), 0, data);
569	}
570
571	static void shader_sm1_read_header(void data, const DWORD ptr, struct wined3d_shader_version shader_version)
572	{
573	struct wined3d_sm1_data *priv = data;
574	DWORD version_token;
575
576	version_token = (ptr)++;
577	TRACE("version: 0x%08x\n", version_token);
578
579	priv->shader_version.major = WINED3D_SM1_VERSION_MAJOR(version_token);
580	priv->shader_version.minor = WINED3D_SM1_VERSION_MINOR(version_token);
581	*shader_version = priv->shader_version;
582	}
583
584	static void shader_sm1_read_opcode(void data, const DWORD ptr, struct wined3d_shader_instruction ins,
585	UINT *param_size)
586	{
587	struct wined3d_sm1_data *priv = data;
588	const struct wined3d_sm1_opcode_info *opcode_info;
589	DWORD opcode_token;
590
591	opcode_token = (ptr)++;
592	opcode_info = shader_get_opcode(priv, opcode_token);
593	if (!opcode_info)
594	{
595	FIXME("Unrecognized opcode: token=0x%08x\n", opcode_token);
596	ins->handler_idx = WINED3DSIH_TABLE_SIZE;
597	param_size = shader_skip_unrecognized(priv, ptr);
598	return;
599	}
600
601	ins->handler_idx = opcode_info->handler_idx;
602	ins->flags = (opcode_token & WINED3D_OPCODESPECIFICCONTROL_MASK) >> WINED3D_OPCODESPECIFICCONTROL_SHIFT;
603	ins->coissue = opcode_token & WINED3DSI_COISSUE;
604	ins->predicate = opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED;
605	ins->dst_count = opcode_info->dst_count ? 1 : 0;
606	ins->src_count = opcode_info->param_count - opcode_info->dst_count;
607	*param_size = shader_skip_opcode(priv, opcode_info, opcode_token);
608	}
609
610	static void shader_sm1_read_src_param(void data, const DWORD ptr, struct wined3d_shader_src_param src_param,
611	struct wined3d_shader_src_param *src_rel_addr)
612	{
613	struct wined3d_sm1_data *priv = data;
614	DWORD token, addr_token;
615
616	ptr += shader_get_param(priv, ptr, &token, &addr_token);
617	if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
618	{
619	shader_parse_src_param(addr_token, NULL, src_rel_addr);
620	shader_parse_src_param(token, src_rel_addr, src_param);
621	}
622	else
623	{
624	shader_parse_src_param(token, NULL, src_param);
625	}
626	}
627
628	static void shader_sm1_read_dst_param(void data, const DWORD ptr, struct wined3d_shader_dst_param dst_param,
629	struct wined3d_shader_src_param *dst_rel_addr)
630	{
631	struct wined3d_sm1_data *priv = data;
632	DWORD token, addr_token;
633
634	ptr += shader_get_param(priv, ptr, &token, &addr_token);
635	if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
636	{
637	shader_parse_src_param(addr_token, NULL, dst_rel_addr);
638	shader_parse_dst_param(token, dst_rel_addr, dst_param);
639	}
640	else
641	{
642	shader_parse_dst_param(token, NULL, dst_param);
643	}
644	}
645
646	static void shader_sm1_read_semantic(const DWORD *ptr, struct wined3d_shader_semantic semantic)
647	{
648	DWORD usage_token = (ptr)++;
649	DWORD dst_token = (ptr)++;
650
651	semantic->usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
652	semantic->usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
653	semantic->sampler_type = (usage_token & WINED3DSP_TEXTURETYPE_MASK) >> WINED3DSP_TEXTURETYPE_SHIFT;
654	shader_parse_dst_param(dst_token, NULL, &semantic->reg);
655	}
656
657	static void shader_sm1_read_comment(const DWORD ptr, const char comment, UINT *comment_size)
658	{
659	DWORD token = **ptr;
660	UINT size;
661
662	if ((token & WINED3DSI_OPCODE_MASK) != WINED3D_SM1_OP_COMMENT)
663	{
664	*comment = NULL;
665	return;
666	}
667
668	size = (token & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
669	comment = (const char )++(*ptr);
670	comment_size = size sizeof(DWORD);
671	*ptr += size;
672	}
673
674	static BOOL shader_sm1_is_end(void data, const DWORD *ptr)
675	{
676	if (**ptr == WINED3DSP_END)
677	{
678	++(*ptr);
679	return TRUE;
680	}
681
682	return FALSE;
683	}
684
685	const struct wined3d_shader_frontend sm1_shader_frontend =
686	{
687	shader_sm1_init,
688	shader_sm1_free,
689	shader_sm1_read_header,
690	shader_sm1_read_opcode,
691	shader_sm1_read_src_param,
692	shader_sm1_read_dst_param,
693	shader_sm1_read_semantic,
694	shader_sm1_read_comment,
695	shader_sm1_is_end,
696	};

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: