utils.c@ 20817

Last change on this file since 20817 was 20612, checked in by vboxsync, 16 years ago
crOpenGL: update wine to 1.1.23
Property svn:eol-style set to `native`
File size: 111.7 KB

Line
1	/*
2	* Utility functions for the WineD3D Library
3	*
4	* Copyright 2002-2004 Jason Edmeades
5	* Copyright 2003-2004 Raphael Junqueira
6	* Copyright 2004 Christian Costa
7	* Copyright 2005 Oliver Stieber
8	* Copyright 2006-2008 Henri Verbeet
9	* Copyright 2007-2008 Stefan Dösinger for CodeWeavers
10	*
11	* This library is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU Lesser General Public
13	* License as published by the Free Software Foundation; either
14	* version 2.1 of the License, or (at your option) any later version.
15	*
16	* This library is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19	* Lesser General Public License for more details.
20	*
21	* You should have received a copy of the GNU Lesser General Public
22	* License along with this library; if not, write to the Free Software
23	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24	*/
25
26	/*
27	* Sun LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
28	* other than GPL or LGPL is available it will apply instead, Sun elects to use only
29	* the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
30	* a choice of LGPL license versions is made available with the language indicating
31	* that LGPLv2 or any later version may be used, or where a choice of which version
32	* of the LGPL is applied is otherwise unspecified.
33	*/
34
35	#include "config.h"
36	#include "wined3d_private.h"
37
38	WINE_DEFAULT_DEBUG_CHANNEL(d3d);
39
40	struct StaticPixelFormatDesc
41	{
42	WINED3DFORMAT format;
43	DWORD alphaMask, redMask, greenMask, blueMask;
44	UINT bpp;
45	short depthSize, stencilSize;
46	BOOL isFourcc;
47	};
48
49	/*****************************************************************************
50	* Pixel format array
51	*
52	* For the formats WINED3DFMT_A32B32G32R32F, WINED3DFMT_A16B16G16R16F,
53	* and WINED3DFMT_A16B16G16R16 do not have correct alpha masks, because the
54	* high masks do not fit into the 32 bit values needed for ddraw. It is only
55	* used for ddraw mostly, and to figure out if the format has alpha at all, so
56	* setting a mask like 0x1 for those surfaces is correct. The 64 and 128 bit
57	* formats are not usable in 2D rendering because ddraw doesn't support them.
58	*/
59	static const struct StaticPixelFormatDesc formats[] =
60	{
61	/* WINED3DFORMAT alphamask redmask greenmask bluemask bpp depth stencil isFourcc */
62	{WINED3DFMT_UNKNOWN, 0x0, 0x0, 0x0, 0x0, 0, 0, 0, FALSE},
63	/* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
64	{WINED3DFMT_UYVY, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, TRUE },
65	{WINED3DFMT_YUY2, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, TRUE },
66	{WINED3DFMT_YV12, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, TRUE },
67	{WINED3DFMT_DXT1, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, TRUE },
68	{WINED3DFMT_DXT2, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, TRUE },
69	{WINED3DFMT_DXT3, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, TRUE },
70	{WINED3DFMT_DXT4, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, TRUE },
71	{WINED3DFMT_DXT5, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, TRUE },
72	{WINED3DFMT_MULTI2_ARGB8, 0x0, 0x0, 0x0, 0x0, 1/?/, 0, 0, TRUE },
73	{WINED3DFMT_G8R8_G8B8, 0x0, 0x0, 0x0, 0x0, 1/?/, 0, 0, TRUE },
74	{WINED3DFMT_R8G8_B8G8, 0x0, 0x0, 0x0, 0x0, 1/?/, 0, 0, TRUE },
75	/* IEEE formats */
76	{WINED3DFMT_R32_FLOAT, 0x0, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
77	{WINED3DFMT_R32G32_FLOAT, 0x0, 0x0, 0x0, 0x0, 8, 0, 0, FALSE},
78	{WINED3DFMT_R32G32B32_FLOAT, 0x0, 0x0, 0x0, 0x0, 12, 0, 0, FALSE},
79	{WINED3DFMT_R32G32B32A32_FLOAT, 0x1, 0x0, 0x0, 0x0, 16, 0, 0, FALSE},
80	/* Hmm? */
81	{WINED3DFMT_CxV8U8, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, FALSE},
82	/* Float */
83	{WINED3DFMT_R16_FLOAT, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, FALSE},
84	{WINED3DFMT_R16G16_FLOAT, 0x0, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
85	{WINED3DFMT_R16G16_SINT, 0x0, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
86	{WINED3DFMT_R16G16B16A16_FLOAT, 0x1, 0x0, 0x0, 0x0, 8, 0, 0, FALSE},
87	{WINED3DFMT_R16G16B16A16_SINT, 0x1, 0x0, 0x0, 0x0, 8, 0, 0, FALSE},
88	/* Palettized formats */
89	{WINED3DFMT_A8P8, 0x0000ff00, 0x0, 0x0, 0x0, 2, 0, 0, FALSE},
90	{WINED3DFMT_P8, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, FALSE},
91	/* Standard ARGB formats. */
92	{WINED3DFMT_R8G8B8, 0x0, 0x00ff0000, 0x0000ff00, 0x000000ff, 3, 0, 0, FALSE},
93	{WINED3DFMT_A8R8G8B8, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 4, 0, 0, FALSE},
94	{WINED3DFMT_X8R8G8B8, 0x0, 0x00ff0000, 0x0000ff00, 0x000000ff, 4, 0, 0, FALSE},
95	{WINED3DFMT_R5G6B5, 0x0, 0x0000f800, 0x000007e0, 0x0000001f, 2, 0, 0, FALSE},
96	{WINED3DFMT_X1R5G5B5, 0x0, 0x00007c00, 0x000003e0, 0x0000001f, 2, 0, 0, FALSE},
97	{WINED3DFMT_A1R5G5B5, 0x00008000, 0x00007c00, 0x000003e0, 0x0000001f, 2, 0, 0, FALSE},
98	{WINED3DFMT_A4R4G4B4, 0x0000f000, 0x00000f00, 0x000000f0, 0x0000000f, 2, 0, 0, FALSE},
99	{WINED3DFMT_R3G3B2, 0x0, 0x000000e0, 0x0000001c, 0x00000003, 1, 0, 0, FALSE},
100	{WINED3DFMT_A8_UNORM, 0x000000ff, 0x0, 0x0, 0x0, 1, 0, 0, FALSE},
101	{WINED3DFMT_A8R3G3B2, 0x0000ff00, 0x000000e0, 0x0000001c, 0x00000003, 2, 0, 0, FALSE},
102	{WINED3DFMT_X4R4G4B4, 0x0, 0x00000f00, 0x000000f0, 0x0000000f, 2, 0, 0, FALSE},
103	{WINED3DFMT_R10G10B10A2_UNORM, 0xb0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4, 0, 0, FALSE},
104	{WINED3DFMT_R10G10B10A2_UINT, 0xb0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4, 0, 0, FALSE},
105	{WINED3DFMT_R10G10B10A2_SNORM, 0xb0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4, 0, 0, FALSE},
106	{WINED3DFMT_R8G8B8A8_UNORM, 0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4, 0, 0, FALSE},
107	{WINED3DFMT_R8G8B8A8_UINT, 0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4, 0, 0, FALSE},
108	{WINED3DFMT_X8B8G8R8, 0x0, 0x000000ff, 0x0000ff00, 0x00ff0000, 4, 0, 0, FALSE},
109	{WINED3DFMT_R16G16_UNORM, 0x0, 0x0000ffff, 0xffff0000, 0x0, 4, 0, 0, FALSE},
110	{WINED3DFMT_A2R10G10B10, 0xb0000000, 0x3ff00000, 0x000ffc00, 0x000003ff, 4, 0, 0, FALSE},
111	{WINED3DFMT_R16G16B16A16_UNORM, 0x1, 0x0000ffff, 0xffff0000, 0x0, 8, 0, 0, FALSE},
112	/* Luminance */
113	{WINED3DFMT_L8, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, FALSE},
114	{WINED3DFMT_A8L8, 0x0000ff00, 0x0, 0x0, 0x0, 2, 0, 0, FALSE},
115	{WINED3DFMT_A4L4, 0x000000f0, 0x0, 0x0, 0x0, 1, 0, 0, FALSE},
116	/* Bump mapping stuff */
117	{WINED3DFMT_R8G8_SNORM, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, FALSE},
118	{WINED3DFMT_L6V5U5, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, FALSE},
119	{WINED3DFMT_X8L8V8U8, 0x0, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
120	{WINED3DFMT_R8G8B8A8_SNORM, 0x0, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
121	{WINED3DFMT_R16G16_SNORM, 0x0, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
122	{WINED3DFMT_W11V11U10, 0x0, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
123	{WINED3DFMT_A2W10V10U10, 0xb0000000, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
124	/* Depth stencil formats */
125	{WINED3DFMT_D16_LOCKABLE, 0x0, 0x0, 0x0, 0x0, 2, 16, 0, FALSE},
126	{WINED3DFMT_D32, 0x0, 0x0, 0x0, 0x0, 4, 32, 0, FALSE},
127	{WINED3DFMT_D15S1, 0x0, 0x0, 0x0, 0x0, 2, 15, 1, FALSE},
128	{WINED3DFMT_D24S8, 0x0, 0x0, 0x0, 0x0, 4, 24, 8, FALSE},
129	{WINED3DFMT_D24X8, 0x0, 0x0, 0x0, 0x0, 4, 24, 0, FALSE},
130	{WINED3DFMT_D24X4S4, 0x0, 0x0, 0x0, 0x0, 4, 24, 4, FALSE},
131	{WINED3DFMT_D16_UNORM, 0x0, 0x0, 0x0, 0x0, 2, 16, 0, FALSE},
132	{WINED3DFMT_L16, 0x0, 0x0, 0x0, 0x0, 2, 16, 0, FALSE},
133	{WINED3DFMT_D32F_LOCKABLE, 0x0, 0x0, 0x0, 0x0, 4, 32, 0, FALSE},
134	{WINED3DFMT_D24FS8, 0x0, 0x0, 0x0, 0x0, 4, 24, 8, FALSE},
135	/* Is this a vertex buffer? */
136	{WINED3DFMT_VERTEXDATA, 0x0, 0x0, 0x0, 0x0, 0, 0, 0, FALSE},
137	{WINED3DFMT_R16_UINT, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, FALSE},
138	{WINED3DFMT_R32_UINT, 0x0, 0x0, 0x0, 0x0, 4, 0, 0, FALSE},
139	{WINED3DFMT_R16G16B16A16_SNORM, 0x0, 0x0, 0x0, 0x0, 8, 0, 0, FALSE},
140	/* Vendor-specific formats */
141	{WINED3DFMT_ATI2N, 0x0, 0x0, 0x0, 0x0, 1, 0, 0, TRUE },
142	{WINED3DFMT_NVHU, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, TRUE },
143	{WINED3DFMT_NVHS, 0x0, 0x0, 0x0, 0x0, 2, 0, 0, TRUE },
144	};
145
146	struct wined3d_format_vertex_info
147	{
148	WINED3DFORMAT format;
149	enum wined3d_ffp_emit_idx emit_idx;
150	GLint component_count;
151	GLenum gl_vtx_type;
152	GLint gl_vtx_format;
153	GLboolean gl_normalized;
154	unsigned int component_size;
155	};
156
157	static const struct wined3d_format_vertex_info format_vertex_info[] =
158	{
159	{WINED3DFMT_R32_FLOAT, WINED3D_FFP_EMIT_FLOAT1, 1, GL_FLOAT, 1, GL_FALSE, sizeof(float)},
160	{WINED3DFMT_R32G32_FLOAT, WINED3D_FFP_EMIT_FLOAT2, 2, GL_FLOAT, 2, GL_FALSE, sizeof(float)},
161	{WINED3DFMT_R32G32B32_FLOAT, WINED3D_FFP_EMIT_FLOAT3, 3, GL_FLOAT, 3, GL_FALSE, sizeof(float)},
162	{WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_FFP_EMIT_FLOAT4, 4, GL_FLOAT, 4, GL_FALSE, sizeof(float)},
163	{WINED3DFMT_A8R8G8B8, WINED3D_FFP_EMIT_D3DCOLOR, 4, GL_UNSIGNED_BYTE, 4, GL_TRUE, sizeof(BYTE)},
164	{WINED3DFMT_R8G8B8A8_UINT, WINED3D_FFP_EMIT_UBYTE4, 4, GL_UNSIGNED_BYTE, 4, GL_FALSE, sizeof(BYTE)},
165	{WINED3DFMT_R16G16_SINT, WINED3D_FFP_EMIT_SHORT2, 2, GL_SHORT, 2, GL_FALSE, sizeof(short int)},
166	{WINED3DFMT_R16G16B16A16_SINT, WINED3D_FFP_EMIT_SHORT4, 4, GL_SHORT, 4, GL_FALSE, sizeof(short int)},
167	{WINED3DFMT_R8G8B8A8_UNORM, WINED3D_FFP_EMIT_UBYTE4N, 4, GL_UNSIGNED_BYTE, 4, GL_TRUE, sizeof(BYTE)},
168	{WINED3DFMT_R16G16_SNORM, WINED3D_FFP_EMIT_SHORT2N, 2, GL_SHORT, 2, GL_TRUE, sizeof(short int)},
169	{WINED3DFMT_R16G16B16A16_SNORM, WINED3D_FFP_EMIT_SHORT4N, 4, GL_SHORT, 4, GL_TRUE, sizeof(short int)},
170	{WINED3DFMT_R16G16_UNORM, WINED3D_FFP_EMIT_USHORT2N, 2, GL_UNSIGNED_SHORT, 2, GL_TRUE, sizeof(short int)},
171	{WINED3DFMT_R16G16B16A16_UNORM, WINED3D_FFP_EMIT_USHORT4N, 4, GL_UNSIGNED_SHORT, 4, GL_TRUE, sizeof(short int)},
172	{WINED3DFMT_R10G10B10A2_UINT, WINED3D_FFP_EMIT_UDEC3, 3, GL_UNSIGNED_SHORT, 3, GL_FALSE, sizeof(short int)},
173	{WINED3DFMT_R10G10B10A2_SNORM, WINED3D_FFP_EMIT_DEC3N, 3, GL_SHORT, 3, GL_TRUE, sizeof(short int)},
174	{WINED3DFMT_R16G16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_2, 2, GL_FLOAT, 2, GL_FALSE, sizeof(GLhalfNV)},
175	{WINED3DFMT_R16G16B16A16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_4, 4, GL_FLOAT, 4, GL_FALSE, sizeof(GLhalfNV)}
176	};
177
178	typedef struct {
179	WINED3DFORMAT fmt;
180	GLint glInternal, glGammaInternal, rtInternal, glFormat, glType;
181	unsigned int Flags;
182	GL_SupportedExt extension;
183	} GlPixelFormatDescTemplate;
184
185	/*****************************************************************************
186	* OpenGL format template. Contains unexciting formats which do not need
187	* extension checks. The order in this table is independent of the order in
188	* the table StaticPixelFormatDesc above. Not all formats have to be in this
189	* table.
190	*/
191	static const GlPixelFormatDescTemplate gl_formats_template[] = {
192	/* WINED3DFORMAT internal srgbInternal rtInternal
193	format type
194	flags
195	extension */
196	/* FourCC formats */
197	/* GL_APPLE_ycbcr_422 claims that its '2YUV' format, which is supported via the UNSIGNED_SHORT_8_8_REV_APPLE type
198	* is equivalent to 'UYVY' format on Windows, and the 'YUVS' via UNSIGNED_SHORT_8_8_APPLE equates to 'YUY2'. The
199	* d3d9 test however shows that the opposite is true. Since the extension is from 2002, it predates the x86 based
200	* Macs, so probably the endianess differs. This could be tested as soon as we have a Windows and MacOS on a big
201	* endian machine
202	*/
203	{WINED3DFMT_UYVY, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, 0,
204	GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
205	WINED3DFMT_FLAG_FILTERING,
206	WINED3D_GL_EXT_NONE},
207	{WINED3DFMT_UYVY, GL_RGB, GL_RGB, 0,
208	GL_YCBCR_422_APPLE, UNSIGNED_SHORT_8_8_APPLE,
209	WINED3DFMT_FLAG_FILTERING,
210	APPLE_YCBCR_422},
211	{WINED3DFMT_YUY2, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, 0,
212	GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
213	WINED3DFMT_FLAG_FILTERING,
214	WINED3D_GL_EXT_NONE},
215	{WINED3DFMT_YUY2, GL_RGB, GL_RGB, 0,
216	GL_YCBCR_422_APPLE, UNSIGNED_SHORT_8_8_REV_APPLE,
217	WINED3DFMT_FLAG_FILTERING,
218	APPLE_YCBCR_422},
219	{WINED3DFMT_YV12, GL_ALPHA, GL_ALPHA, 0,
220	GL_ALPHA, GL_UNSIGNED_BYTE,
221	WINED3DFMT_FLAG_FILTERING,
222	WINED3D_GL_EXT_NONE},
223	{WINED3DFMT_DXT1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0,
224	GL_RGBA, GL_UNSIGNED_BYTE,
225	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
226	EXT_TEXTURE_COMPRESSION_S3TC},
227	{WINED3DFMT_DXT2, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
228	GL_RGBA, GL_UNSIGNED_BYTE,
229	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
230	EXT_TEXTURE_COMPRESSION_S3TC},
231	{WINED3DFMT_DXT3, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
232	GL_RGBA, GL_UNSIGNED_BYTE,
233	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
234	EXT_TEXTURE_COMPRESSION_S3TC},
235	{WINED3DFMT_DXT4, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
236	GL_RGBA, GL_UNSIGNED_BYTE,
237	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
238	EXT_TEXTURE_COMPRESSION_S3TC},
239	{WINED3DFMT_DXT5, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
240	GL_RGBA, GL_UNSIGNED_BYTE,
241	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
242	EXT_TEXTURE_COMPRESSION_S3TC},
243	/* IEEE formats */
244	{WINED3DFMT_R32_FLOAT, GL_RGB32F_ARB, GL_RGB32F_ARB, 0,
245	GL_RED, GL_FLOAT,
246	WINED3DFMT_FLAG_RENDERTARGET,
247	ARB_TEXTURE_FLOAT},
248	{WINED3DFMT_R32_FLOAT, GL_R32F, GL_R32F, 0,
249	GL_RED, GL_FLOAT,
250	WINED3DFMT_FLAG_RENDERTARGET,
251	ARB_TEXTURE_RG},
252	{WINED3DFMT_R32G32_FLOAT, GL_RGB32F_ARB, GL_RGB32F_ARB, 0,
253	GL_RGB, GL_FLOAT,
254	WINED3DFMT_FLAG_RENDERTARGET,
255	ARB_TEXTURE_FLOAT},
256	{WINED3DFMT_R32G32_FLOAT, GL_RG32F, GL_RG32F, 0,
257	GL_RG, GL_FLOAT,
258	WINED3DFMT_FLAG_RENDERTARGET,
259	ARB_TEXTURE_RG},
260	{WINED3DFMT_R32G32B32A32_FLOAT, GL_RGBA32F_ARB, GL_RGBA32F_ARB, 0,
261	GL_RGBA, GL_FLOAT,
262	WINED3DFMT_FLAG_RENDERTARGET,
263	ARB_TEXTURE_FLOAT},
264	/* Float */
265	{WINED3DFMT_R16_FLOAT, GL_RGB16F_ARB, GL_RGB16F_ARB, 0,
266	GL_RED, GL_HALF_FLOAT_ARB,
267	WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
268	ARB_TEXTURE_FLOAT},
269	{WINED3DFMT_R16_FLOAT, GL_R16F, GL_R16F, 0,
270	GL_RED, GL_HALF_FLOAT_ARB,
271	WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
272	ARB_TEXTURE_RG},
273	{WINED3DFMT_R16G16_FLOAT, GL_RGB16F_ARB, GL_RGB16F_ARB, 0,
274	GL_RGB, GL_HALF_FLOAT_ARB,
275	WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
276	ARB_TEXTURE_FLOAT},
277	{WINED3DFMT_R16G16_FLOAT, GL_RG16F, GL_RG16F, 0,
278	GL_RG, GL_HALF_FLOAT_ARB,
279	WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
280	ARB_TEXTURE_RG},
281	{WINED3DFMT_R16G16B16A16_FLOAT, GL_RGBA16F_ARB, GL_RGBA16F_ARB, 0,
282	GL_RGBA, GL_HALF_FLOAT_ARB,
283	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
284	ARB_TEXTURE_FLOAT},
285	/* Palettized formats */
286	{WINED3DFMT_P8, GL_RGBA, GL_RGBA, 0,
287	GL_RGBA, GL_UNSIGNED_BYTE,
288	0,
289	ARB_FRAGMENT_PROGRAM},
290	{WINED3DFMT_P8, GL_COLOR_INDEX8_EXT, GL_COLOR_INDEX8_EXT, 0,
291	GL_COLOR_INDEX, GL_UNSIGNED_BYTE,
292	0,
293	EXT_PALETTED_TEXTURE},
294	/* Standard ARGB formats */
295	{WINED3DFMT_R8G8B8, GL_RGB8, GL_RGB8, 0,
296	GL_BGR, GL_UNSIGNED_BYTE,
297	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
298	WINED3D_GL_EXT_NONE},
299	{WINED3DFMT_A8R8G8B8, GL_RGBA8, GL_SRGB8_ALPHA8_EXT, 0,
300	GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
301	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
302	WINED3D_GL_EXT_NONE},
303	{WINED3DFMT_X8R8G8B8, GL_RGB8, GL_SRGB8_EXT, 0,
304	GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
305	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
306	WINED3D_GL_EXT_NONE},
307	{WINED3DFMT_R5G6B5, GL_RGB5, GL_RGB5, GL_RGB8,
308	GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
309	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
310	WINED3D_GL_EXT_NONE},
311	{WINED3DFMT_X1R5G5B5, GL_RGB5, GL_RGB5_A1, 0,
312	GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV,
313	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
314	WINED3D_GL_EXT_NONE},
315	{WINED3DFMT_A1R5G5B5, GL_RGB5_A1, GL_RGB5_A1, 0,
316	GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV,
317	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
318	WINED3D_GL_EXT_NONE},
319	{WINED3DFMT_A4R4G4B4, GL_RGBA4, GL_SRGB8_ALPHA8_EXT, 0,
320	GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV,
321	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
322	WINED3D_GL_EXT_NONE},
323	{WINED3DFMT_R3G3B2, GL_R3_G3_B2, GL_R3_G3_B2, 0,
324	GL_RGB, GL_UNSIGNED_BYTE_3_3_2,
325	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING,
326	WINED3D_GL_EXT_NONE},
327	{WINED3DFMT_A8_UNORM, GL_ALPHA8, GL_ALPHA8, 0,
328	GL_ALPHA, GL_UNSIGNED_BYTE,
329	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING,
330	WINED3D_GL_EXT_NONE},
331	{WINED3DFMT_X4R4G4B4, GL_RGB4, GL_RGB4, 0,
332	GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV,
333	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
334	WINED3D_GL_EXT_NONE},
335	{WINED3DFMT_R10G10B10A2_UNORM, GL_RGB10_A2, GL_RGB10_A2, 0,
336	GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV,
337	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
338	WINED3D_GL_EXT_NONE},
339	{WINED3DFMT_R8G8B8A8_UNORM, GL_RGBA8, GL_RGBA8, 0,
340	GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV,
341	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
342	WINED3D_GL_EXT_NONE},
343	{WINED3DFMT_X8B8G8R8, GL_RGB8, GL_RGB8, 0,
344	GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV,
345	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
346	WINED3D_GL_EXT_NONE},
347	{WINED3DFMT_R16G16_UNORM, GL_RGB16_EXT, GL_RGB16_EXT, 0,
348	GL_RGB, GL_UNSIGNED_SHORT,
349	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
350	WINED3D_GL_EXT_NONE},
351	{WINED3DFMT_A2R10G10B10, GL_RGB10_A2, GL_RGB10_A2, 0,
352	GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV,
353	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
354	WINED3D_GL_EXT_NONE},
355	{WINED3DFMT_R16G16B16A16_UNORM, GL_RGBA16_EXT, GL_RGBA16_EXT, 0,
356	GL_RGBA, GL_UNSIGNED_SHORT,
357	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_RENDERTARGET,
358	WINED3D_GL_EXT_NONE},
359	/* Luminance */
360	{WINED3DFMT_L8, GL_LUMINANCE8, GL_SLUMINANCE8_EXT, 0,
361	GL_LUMINANCE, GL_UNSIGNED_BYTE,
362	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
363	WINED3D_GL_EXT_NONE},
364	{WINED3DFMT_A8L8, GL_LUMINANCE8_ALPHA8, GL_SLUMINANCE8_ALPHA8_EXT, 0,
365	GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
366	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
367	WINED3D_GL_EXT_NONE},
368	{WINED3DFMT_A4L4, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE4_ALPHA4, 0,
369	GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
370	0,
371	WINED3D_GL_EXT_NONE},
372	/* Bump mapping stuff */
373	{WINED3DFMT_R8G8_SNORM, GL_RGB8, GL_RGB8, 0,
374	GL_BGR, GL_UNSIGNED_BYTE,
375	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
376	WINED3D_GL_EXT_NONE},
377	{WINED3DFMT_R8G8_SNORM, GL_DSDT8_NV, GL_DSDT8_NV, 0,
378	GL_DSDT_NV, GL_BYTE,
379	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
380	NV_TEXTURE_SHADER},
381	{WINED3DFMT_L6V5U5, GL_RGB5, GL_RGB5, 0,
382	GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
383	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
384	WINED3D_GL_EXT_NONE},
385	{WINED3DFMT_L6V5U5, GL_DSDT8_MAG8_NV, GL_DSDT8_MAG8_NV, 0,
386	GL_DSDT_MAG_NV, GL_BYTE,
387	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
388	NV_TEXTURE_SHADER},
389	{WINED3DFMT_X8L8V8U8, GL_RGB8, GL_RGB8, 0,
390	GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
391	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
392	WINED3D_GL_EXT_NONE},
393	{WINED3DFMT_X8L8V8U8, GL_DSDT8_MAG8_INTENSITY8_NV, GL_DSDT8_MAG8_INTENSITY8_NV, 0,
394	GL_DSDT_MAG_VIB_NV, GL_UNSIGNED_INT_8_8_S8_S8_REV_NV,
395	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
396	NV_TEXTURE_SHADER},
397	{WINED3DFMT_R8G8B8A8_SNORM, GL_RGBA8, GL_RGBA8, 0,
398	GL_BGRA, GL_UNSIGNED_BYTE,
399	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
400	WINED3D_GL_EXT_NONE},
401	{WINED3DFMT_R8G8B8A8_SNORM, GL_SIGNED_RGBA8_NV, GL_SIGNED_RGBA8_NV, 0,
402	GL_RGBA, GL_BYTE,
403	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
404	NV_TEXTURE_SHADER},
405	{WINED3DFMT_R16G16_SNORM, GL_RGB16_EXT, GL_RGB16_EXT, 0,
406	GL_BGR, GL_UNSIGNED_SHORT,
407	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
408	WINED3D_GL_EXT_NONE},
409	{WINED3DFMT_R16G16_SNORM, GL_SIGNED_HILO16_NV, GL_SIGNED_HILO16_NV, 0,
410	GL_HILO_NV, GL_SHORT,
411	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
412	NV_TEXTURE_SHADER},
413	/* Depth stencil formats */
414	{WINED3DFMT_D16_LOCKABLE, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
415	GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,
416	WINED3DFMT_FLAG_DEPTH,
417	ARB_DEPTH_TEXTURE},
418	{WINED3DFMT_D32, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT32_ARB, 0,
419	GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
420	WINED3DFMT_FLAG_DEPTH,
421	ARB_DEPTH_TEXTURE},
422	{WINED3DFMT_D15S1, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
423	GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,
424	WINED3DFMT_FLAG_DEPTH,
425	ARB_DEPTH_TEXTURE},
426	{WINED3DFMT_D15S1, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
427	GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
428	WINED3DFMT_FLAG_DEPTH \| WINED3DFMT_FLAG_STENCIL,
429	EXT_PACKED_DEPTH_STENCIL},
430	{WINED3DFMT_D24S8, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
431	GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
432	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_DEPTH,
433	ARB_DEPTH_TEXTURE},
434	{WINED3DFMT_D24S8, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
435	GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
436	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_DEPTH \| WINED3DFMT_FLAG_STENCIL,
437	EXT_PACKED_DEPTH_STENCIL},
438	{WINED3DFMT_D24X8, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
439	GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
440	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_DEPTH,
441	ARB_DEPTH_TEXTURE},
442	{WINED3DFMT_D24X4S4, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
443	GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
444	WINED3DFMT_FLAG_DEPTH,
445	ARB_DEPTH_TEXTURE},
446	{WINED3DFMT_D24X4S4, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
447	GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
448	WINED3DFMT_FLAG_DEPTH \| WINED3DFMT_FLAG_STENCIL,
449	EXT_PACKED_DEPTH_STENCIL},
450	{WINED3DFMT_D16_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
451	GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,
452	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING \| WINED3DFMT_FLAG_DEPTH,
453	ARB_DEPTH_TEXTURE},
454	{WINED3DFMT_L16, GL_LUMINANCE16_EXT, GL_LUMINANCE16_EXT, 0,
455	GL_LUMINANCE, GL_UNSIGNED_SHORT,
456	WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING \| WINED3DFMT_FLAG_FILTERING,
457	WINED3D_GL_EXT_NONE},
458	{WINED3DFMT_D32F_LOCKABLE, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT32_ARB, 0,
459	GL_DEPTH_COMPONENT, GL_FLOAT,
460	WINED3DFMT_FLAG_DEPTH,
461	ARB_DEPTH_TEXTURE},
462	{WINED3DFMT_D24FS8, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
463	GL_DEPTH_COMPONENT, GL_FLOAT,
464	WINED3DFMT_FLAG_DEPTH,
465	ARB_DEPTH_TEXTURE},
466	{WINED3DFMT_D24FS8, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
467	GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
468	WINED3DFMT_FLAG_DEPTH \| WINED3DFMT_FLAG_STENCIL,
469	EXT_PACKED_DEPTH_STENCIL},
470	/* Vendor-specific formats */
471	{WINED3DFMT_ATI2N, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0,
472	GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
473	0,
474	ATI_TEXTURE_COMPRESSION_3DC},
475	{WINED3DFMT_ATI2N, GL_COMPRESSED_RED_GREEN_RGTC2_EXT, GL_COMPRESSED_RED_GREEN_RGTC2_EXT, 0,
476	GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
477	0,
478	EXT_TEXTURE_COMPRESSION_RGTC},
479	};
480
481	static inline int getFmtIdx(WINED3DFORMAT fmt) {
482	/* First check if the format is at the position of its value.
483	* This will catch the argb formats before the loop is entered
484	*/
485	if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
486	return fmt;
487	} else {
488	unsigned int i;
489	for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
490	if(formats[i].format == fmt) {
491	return i;
492	}
493	}
494	}
495	return -1;
496	}
497
498	static BOOL init_format_base_info(WineD3D_GL_Info *gl_info)
499	{
500	UINT format_count = sizeof(formats) / sizeof(*formats);
501	UINT i;
502
503	gl_info->gl_formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, format_count * sizeof(*gl_info->gl_formats));
504	if (!gl_info->gl_formats)
505	{
506	ERR("Failed to allocate memory.\n");
507	return FALSE;
508	}
509
510	for (i = 0; i < format_count; ++i)
511	{
512	struct GlPixelFormatDesc *desc = &gl_info->gl_formats[i];
513	desc->format = formats[i].format;
514	desc->red_mask = formats[i].redMask;
515	desc->green_mask = formats[i].greenMask;
516	desc->blue_mask = formats[i].blueMask;
517	desc->alpha_mask = formats[i].alphaMask;
518	desc->byte_count = formats[i].bpp;
519	desc->depth_size = formats[i].depthSize;
520	desc->stencil_size = formats[i].stencilSize;
521	if (formats[i].isFourcc) desc->Flags \|= WINED3DFMT_FLAG_FOURCC;
522	}
523
524	return TRUE;
525	}
526
527	#define GLINFO_LOCATION (*gl_info)
528
529	static BOOL check_fbo_compat(const WineD3D_GL_Info *gl_info, GLint internal_format, GLenum format, GLenum type)
530	{
531	GLuint tex, fb;
532	GLenum status;
533
534	ENTER_GL();
535
536	while(glGetError());
537	glGenTextures(1, &tex);
538	glBindTexture(GL_TEXTURE_2D, tex);
539	glTexImage2D(GL_TEXTURE_2D, 0, internal_format, 16, 16, 0, format, type, NULL);
540	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
541	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
542
543	GL_EXTCALL(glGenFramebuffersEXT(1, &fb));
544	GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb));
545	GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, tex, 0));
546
547	status = GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
548	GL_EXTCALL(glDeleteFramebuffersEXT(1, &fb));
549	glDeleteTextures(1, &tex);
550
551	checkGLcall("Framebuffer format check");
552
553	LEAVE_GL();
554
555	return status == GL_FRAMEBUFFER_COMPLETE_EXT;
556	}
557
558	static void init_format_fbo_compat_info(WineD3D_GL_Info *gl_info)
559	{
560	unsigned int i;
561
562	for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i)
563	{
564	struct GlPixelFormatDesc *desc = &gl_info->gl_formats[i];
565
566	if (!desc->glInternal) continue;
567
568	if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
569	{
570	/* Check if the default internal format is supported as a frame buffer target, otherwise
571	* fall back to the render target internal.
572	*
573	* Try to stick to the standard format if possible, this limits precision differences. */
574	if (check_fbo_compat(gl_info, desc->glInternal, desc->glFormat, desc->glType))
575	{
576	TRACE("Format %s is supported as fbo target\n", debug_d3dformat(desc->format));
577	desc->Flags \|= WINED3DFMT_FLAG_FBO_ATTACHABLE;
578	desc->rtInternal = desc->glInternal;
579	}
580	else
581	{
582	if (!desc->rtInternal)
583	{
584	if (desc->Flags & WINED3DFMT_FLAG_RENDERTARGET)
585	{
586	FIXME("Internal format of %s not supported as FBO target, and no fallback specified.\n",
587	debug_d3dformat(desc->format));
588	desc->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
589	}
590	desc->rtInternal = desc->glInternal;
591	}
592	else
593	{
594	TRACE("Internal format of %s not supported as FBO target, using render target internal instead.\n",
595	debug_d3dformat(desc->format));
596	}
597	}
598	}
599	else
600	{
601	desc->rtInternal = desc->glInternal;
602	}
603	}
604	}
605
606	static BOOL init_format_texture_info(WineD3D_GL_Info *gl_info)
607	{
608	unsigned int i;
609
610	for (i = 0; i < sizeof(gl_formats_template) / sizeof(gl_formats_template[0]); ++i)
611	{
612	int fmt_idx = getFmtIdx(gl_formats_template[i].fmt);
613	struct GlPixelFormatDesc *desc;
614
615	if (fmt_idx == -1)
616	{
617	ERR("Format %s (%#x) not found.\n",
618	debug_d3dformat(gl_formats_template[i].fmt), gl_formats_template[i].fmt);
619	return FALSE;
620	}
621
622	if (!GL_SUPPORT(gl_formats_template[i].extension)) continue;
623
624	desc = &gl_info->gl_formats[fmt_idx];
625	desc->glInternal = gl_formats_template[i].glInternal;
626	desc->glGammaInternal = gl_formats_template[i].glGammaInternal;
627	desc->rtInternal = gl_formats_template[i].rtInternal;
628	desc->glFormat = gl_formats_template[i].glFormat;
629	desc->glType = gl_formats_template[i].glType;
630	desc->color_fixup = COLOR_FIXUP_IDENTITY;
631	desc->Flags \|= gl_formats_template[i].Flags;
632	desc->heightscale = 1.0;
633	}
634
635	return TRUE;
636	}
637
638	static void apply_format_fixups(WineD3D_GL_Info *gl_info)
639	{
640	int idx;
641
642	idx = getFmtIdx(WINED3DFMT_R16_FLOAT);
643	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
644	0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
645
646	idx = getFmtIdx(WINED3DFMT_R32_FLOAT);
647	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
648	0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
649
650	idx = getFmtIdx(WINED3DFMT_R16G16_UNORM);
651	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
652	0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
653
654	idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
655	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
656	0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
657
658	idx = getFmtIdx(WINED3DFMT_R32G32_FLOAT);
659	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
660	0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
661
662	/* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
663	* V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
664	* their extensions are not available. GL_ATI_envmap_bumpmap is not used because
665	* the only driver that implements it(fglrx) has a buggy implementation.
666	*
667	* V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
668	* returns 0.0 when sampling from it, DirectX 1.0. So we always have in-shader
669	* conversion for this format.
670	*/
671	if (!GL_SUPPORT(NV_TEXTURE_SHADER))
672	{
673	idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
674	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
675	1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
676	idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
677	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
678	1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
679	}
680	else
681	{
682	idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
683	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
684	0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
685	idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
686	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
687	0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
688	}
689
690	if (!GL_SUPPORT(NV_TEXTURE_SHADER))
691	{
692	/* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
693	* with each other
694	*/
695	idx = getFmtIdx(WINED3DFMT_L6V5U5);
696	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
697	1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
698	idx = getFmtIdx(WINED3DFMT_X8L8V8U8);
699	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
700	1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
701	idx = getFmtIdx(WINED3DFMT_R8G8B8A8_SNORM);
702	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
703	1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
704	}
705	else
706	{
707	/* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
708	* are converted at surface loading time, but they do not need any modification in
709	* the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
710	* WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
711	*/
712	}
713
714	if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC))
715	{
716	idx = getFmtIdx(WINED3DFMT_ATI2N);
717	gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
718	0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
719	}
720	else if (GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC))
721	{
722	idx = getFmtIdx(WINED3DFMT_ATI2N);
723	gl_info->gl_formats[idx].color_fixup= create_color_fixup_desc(
724	0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
725	}
726
727	if (!GL_SUPPORT(APPLE_YCBCR_422))
728	{
729	idx = getFmtIdx(WINED3DFMT_YUY2);
730	gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_YUY2);
731
732	idx = getFmtIdx(WINED3DFMT_UYVY);
733	gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_UYVY);
734	}
735
736	idx = getFmtIdx(WINED3DFMT_YV12);
737	gl_info->gl_formats[idx].heightscale = 1.5;
738	gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_YV12);
739
740	if (GL_SUPPORT(EXT_VERTEX_ARRAY_BGRA))
741	{
742	idx = getFmtIdx(WINED3DFMT_A8R8G8B8);
743	gl_info->gl_formats[idx].gl_vtx_format = GL_BGRA;
744	}
745
746	if (GL_SUPPORT(ARB_HALF_FLOAT_VERTEX))
747	{
748	/* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
749	* It is the job of the vertex buffer code to make sure that the vbos have the right format */
750	idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
751	gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT; /* == GL_HALF_FLOAT_NV */
752
753	idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
754	gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT;
755	}
756	}
757
758	static BOOL init_format_vertex_info(WineD3D_GL_Info *gl_info)
759	{
760	unsigned int i;
761
762	for (i = 0; i < (sizeof(format_vertex_info) / sizeof(*format_vertex_info)); ++i)
763	{
764	struct GlPixelFormatDesc *format_desc;
765	int fmt_idx = getFmtIdx(format_vertex_info[i].format);
766
767	if (fmt_idx == -1)
768	{
769	ERR("Format %s (%#x) not found.\n",
770	debug_d3dformat(format_vertex_info[i].format), format_vertex_info[i].format);
771	return FALSE;
772	}
773
774	format_desc = &gl_info->gl_formats[fmt_idx];
775	format_desc->emit_idx = format_vertex_info[i].emit_idx;
776	format_desc->component_count = format_vertex_info[i].component_count;
777	format_desc->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
778	format_desc->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
779	format_desc->gl_normalized = format_vertex_info[i].gl_normalized;
780	format_desc->component_size = format_vertex_info[i].component_size;
781	}
782
783	return TRUE;
784	}
785
786	BOOL initPixelFormatsNoGL(WineD3D_GL_Info *gl_info)
787	{
788	return init_format_base_info(gl_info);
789	}
790
791	BOOL initPixelFormats(WineD3D_GL_Info *gl_info)
792	{
793	if (!init_format_base_info(gl_info)) return FALSE;
794
795	if (!init_format_texture_info(gl_info))
796	{
797	HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
798	return FALSE;
799	}
800
801	if (!init_format_vertex_info(gl_info))
802	{
803	HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
804	return FALSE;
805	}
806
807	apply_format_fixups(gl_info);
808	init_format_fbo_compat_info(gl_info);
809
810	return TRUE;
811	}
812
813	#undef GLINFO_LOCATION
814
815	#define GLINFO_LOCATION This->adapter->gl_info
816
817	const struct GlPixelFormatDesc getFormatDescEntry(WINED3DFORMAT fmt, const WineD3D_GL_Info gl_info)
818	{
819	int idx = getFmtIdx(fmt);
820
821	if(idx == -1) {
822	FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
823	/* Get the caller a valid pointer */
824	idx = getFmtIdx(WINED3DFMT_UNKNOWN);
825	}
826
827	return &gl_info->gl_formats[idx];
828	}
829
830	/*****************************************************************************
831	* Trace formatting of useful values
832	*/
833	const char* debug_d3dformat(WINED3DFORMAT fmt) {
834	switch (fmt) {
835	#define FMT_TO_STR(fmt) case fmt: return #fmt
836	FMT_TO_STR(WINED3DFMT_UNKNOWN);
837	FMT_TO_STR(WINED3DFMT_R8G8B8);
838	FMT_TO_STR(WINED3DFMT_A8R8G8B8);
839	FMT_TO_STR(WINED3DFMT_X8R8G8B8);
840	FMT_TO_STR(WINED3DFMT_R5G6B5);
841	FMT_TO_STR(WINED3DFMT_X1R5G5B5);
842	FMT_TO_STR(WINED3DFMT_A1R5G5B5);
843	FMT_TO_STR(WINED3DFMT_A4R4G4B4);
844	FMT_TO_STR(WINED3DFMT_R3G3B2);
845	FMT_TO_STR(WINED3DFMT_A8R3G3B2);
846	FMT_TO_STR(WINED3DFMT_X4R4G4B4);
847	FMT_TO_STR(WINED3DFMT_X8B8G8R8);
848	FMT_TO_STR(WINED3DFMT_A2R10G10B10);
849	FMT_TO_STR(WINED3DFMT_A8P8);
850	FMT_TO_STR(WINED3DFMT_P8);
851	FMT_TO_STR(WINED3DFMT_L8);
852	FMT_TO_STR(WINED3DFMT_A8L8);
853	FMT_TO_STR(WINED3DFMT_A4L4);
854	FMT_TO_STR(WINED3DFMT_L6V5U5);
855	FMT_TO_STR(WINED3DFMT_X8L8V8U8);
856	FMT_TO_STR(WINED3DFMT_W11V11U10);
857	FMT_TO_STR(WINED3DFMT_A2W10V10U10);
858	FMT_TO_STR(WINED3DFMT_UYVY);
859	FMT_TO_STR(WINED3DFMT_YUY2);
860	FMT_TO_STR(WINED3DFMT_YV12);
861	FMT_TO_STR(WINED3DFMT_DXT1);
862	FMT_TO_STR(WINED3DFMT_DXT2);
863	FMT_TO_STR(WINED3DFMT_DXT3);
864	FMT_TO_STR(WINED3DFMT_DXT4);
865	FMT_TO_STR(WINED3DFMT_DXT5);
866	FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
867	FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
868	FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
869	FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
870	FMT_TO_STR(WINED3DFMT_D32);
871	FMT_TO_STR(WINED3DFMT_D15S1);
872	FMT_TO_STR(WINED3DFMT_D24S8);
873	FMT_TO_STR(WINED3DFMT_D24X8);
874	FMT_TO_STR(WINED3DFMT_D24X4S4);
875	FMT_TO_STR(WINED3DFMT_L16);
876	FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE);
877	FMT_TO_STR(WINED3DFMT_D24FS8);
878	FMT_TO_STR(WINED3DFMT_VERTEXDATA);
879	FMT_TO_STR(WINED3DFMT_CxV8U8);
880	FMT_TO_STR(WINED3DFMT_ATI2N);
881	FMT_TO_STR(WINED3DFMT_NVHU);
882	FMT_TO_STR(WINED3DFMT_NVHS);
883	FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS);
884	FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT);
885	FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT);
886	FMT_TO_STR(WINED3DFMT_R32G32B32A32_SINT);
887	FMT_TO_STR(WINED3DFMT_R32G32B32_TYPELESS);
888	FMT_TO_STR(WINED3DFMT_R32G32B32_FLOAT);
889	FMT_TO_STR(WINED3DFMT_R32G32B32_UINT);
890	FMT_TO_STR(WINED3DFMT_R32G32B32_SINT);
891	FMT_TO_STR(WINED3DFMT_R16G16B16A16_TYPELESS);
892	FMT_TO_STR(WINED3DFMT_R16G16B16A16_FLOAT);
893	FMT_TO_STR(WINED3DFMT_R16G16B16A16_UNORM);
894	FMT_TO_STR(WINED3DFMT_R16G16B16A16_UINT);
895	FMT_TO_STR(WINED3DFMT_R16G16B16A16_SNORM);
896	FMT_TO_STR(WINED3DFMT_R16G16B16A16_SINT);
897	FMT_TO_STR(WINED3DFMT_R32G32_TYPELESS);
898	FMT_TO_STR(WINED3DFMT_R32G32_FLOAT);
899	FMT_TO_STR(WINED3DFMT_R32G32_UINT);
900	FMT_TO_STR(WINED3DFMT_R32G32_SINT);
901	FMT_TO_STR(WINED3DFMT_R32G8X24_TYPELESS);
902	FMT_TO_STR(WINED3DFMT_D32_FLOAT_S8X24_UINT);
903	FMT_TO_STR(WINED3DFMT_R32_FLOAT_X8X24_TYPELESS);
904	FMT_TO_STR(WINED3DFMT_X32_TYPELESS_G8X24_UINT);
905	FMT_TO_STR(WINED3DFMT_R10G10B10A2_TYPELESS);
906	FMT_TO_STR(WINED3DFMT_R10G10B10A2_UNORM);
907	FMT_TO_STR(WINED3DFMT_R10G10B10A2_UINT);
908	FMT_TO_STR(WINED3DFMT_R10G10B10A2_SNORM);
909	FMT_TO_STR(WINED3DFMT_R11G11B10_FLOAT);
910	FMT_TO_STR(WINED3DFMT_R8G8B8A8_TYPELESS);
911	FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM);
912	FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM_SRGB);
913	FMT_TO_STR(WINED3DFMT_R8G8B8A8_UINT);
914	FMT_TO_STR(WINED3DFMT_R8G8B8A8_SNORM);
915	FMT_TO_STR(WINED3DFMT_R8G8B8A8_SINT);
916	FMT_TO_STR(WINED3DFMT_R16G16_TYPELESS);
917	FMT_TO_STR(WINED3DFMT_R16G16_FLOAT);
918	FMT_TO_STR(WINED3DFMT_R16G16_UNORM);
919	FMT_TO_STR(WINED3DFMT_R16G16_UINT);
920	FMT_TO_STR(WINED3DFMT_R16G16_SNORM);
921	FMT_TO_STR(WINED3DFMT_R16G16_SINT);
922	FMT_TO_STR(WINED3DFMT_R32_TYPELESS);
923	FMT_TO_STR(WINED3DFMT_D32_FLOAT);
924	FMT_TO_STR(WINED3DFMT_R32_FLOAT);
925	FMT_TO_STR(WINED3DFMT_R32_UINT);
926	FMT_TO_STR(WINED3DFMT_R32_SINT);
927	FMT_TO_STR(WINED3DFMT_R24G8_TYPELESS);
928	FMT_TO_STR(WINED3DFMT_D24_UNORM_S8_UINT);
929	FMT_TO_STR(WINED3DFMT_R24_UNORM_X8_TYPELESS);
930	FMT_TO_STR(WINED3DFMT_X24_TYPELESS_G8_UINT);
931	FMT_TO_STR(WINED3DFMT_R8G8_TYPELESS);
932	FMT_TO_STR(WINED3DFMT_R8G8_UNORM);
933	FMT_TO_STR(WINED3DFMT_R8G8_UINT);
934	FMT_TO_STR(WINED3DFMT_R8G8_SNORM);
935	FMT_TO_STR(WINED3DFMT_R8G8_SINT);
936	FMT_TO_STR(WINED3DFMT_R16_TYPELESS);
937	FMT_TO_STR(WINED3DFMT_R16_FLOAT);
938	FMT_TO_STR(WINED3DFMT_D16_UNORM);
939	FMT_TO_STR(WINED3DFMT_R16_UNORM);
940	FMT_TO_STR(WINED3DFMT_R16_UINT);
941	FMT_TO_STR(WINED3DFMT_R16_SNORM);
942	FMT_TO_STR(WINED3DFMT_R16_SINT);
943	FMT_TO_STR(WINED3DFMT_R8_TYPELESS);
944	FMT_TO_STR(WINED3DFMT_R8_UNORM);
945	FMT_TO_STR(WINED3DFMT_R8_UINT);
946	FMT_TO_STR(WINED3DFMT_R8_SNORM);
947	FMT_TO_STR(WINED3DFMT_R8_SINT);
948	FMT_TO_STR(WINED3DFMT_A8_UNORM);
949	FMT_TO_STR(WINED3DFMT_R1_UNORM);
950	FMT_TO_STR(WINED3DFMT_R9G9B9E5_SHAREDEXP);
951	FMT_TO_STR(WINED3DFMT_R8G8_B8G8_UNORM);
952	FMT_TO_STR(WINED3DFMT_G8R8_G8B8_UNORM);
953	FMT_TO_STR(WINED3DFMT_BC1_TYPELESS);
954	FMT_TO_STR(WINED3DFMT_BC1_UNORM);
955	FMT_TO_STR(WINED3DFMT_BC1_UNORM_SRGB);
956	FMT_TO_STR(WINED3DFMT_BC2_TYPELESS);
957	FMT_TO_STR(WINED3DFMT_BC2_UNORM);
958	FMT_TO_STR(WINED3DFMT_BC2_UNORM_SRGB);
959	FMT_TO_STR(WINED3DFMT_BC3_TYPELESS);
960	FMT_TO_STR(WINED3DFMT_BC3_UNORM);
961	FMT_TO_STR(WINED3DFMT_BC3_UNORM_SRGB);
962	FMT_TO_STR(WINED3DFMT_BC4_TYPELESS);
963	FMT_TO_STR(WINED3DFMT_BC4_UNORM);
964	FMT_TO_STR(WINED3DFMT_BC4_SNORM);
965	FMT_TO_STR(WINED3DFMT_BC5_TYPELESS);
966	FMT_TO_STR(WINED3DFMT_BC5_UNORM);
967	FMT_TO_STR(WINED3DFMT_BC5_SNORM);
968	FMT_TO_STR(WINED3DFMT_B5G6R5_UNORM);
969	FMT_TO_STR(WINED3DFMT_B5G5R5A1_UNORM);
970	FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM);
971	FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM);
972	#undef FMT_TO_STR
973	default:
974	{
975	char fourcc[5];
976	fourcc[0] = (char)(fmt);
977	fourcc[1] = (char)(fmt >> 8);
978	fourcc[2] = (char)(fmt >> 16);
979	fourcc[3] = (char)(fmt >> 24);
980	fourcc[4] = 0;
981	if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
982	FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
983	else
984	FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
985	}
986	return "unrecognized";
987	}
988	}
989
990	const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
991	switch (devtype) {
992	#define DEVTYPE_TO_STR(dev) case dev: return #dev
993	DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
994	DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
995	DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
996	#undef DEVTYPE_TO_STR
997	default:
998	FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
999	return "unrecognized";
1000	}
1001	}
1002
1003	const char *debug_d3dusage(DWORD usage)
1004	{
1005	char buf[284];
1006
1007	buf[0] = '\0';
1008	#define WINED3DUSAGE_TO_STR(u) if (usage & u) { strcat(buf, " \| "#u); usage &= ~u; }
1009	WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
1010	WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
1011	WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
1012	WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
1013	WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
1014	WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
1015	WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
1016	WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
1017	WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
1018	WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
1019	WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
1020	#undef WINED3DUSAGE_TO_STR
1021	if (usage) FIXME("Unrecognized usage flag(s) %#x\n", usage);
1022
1023	return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1024	}
1025
1026	const char *debug_d3dusagequery(DWORD usagequery)
1027	{
1028	char buf[238];
1029
1030	buf[0] = '\0';
1031	#define WINED3DUSAGEQUERY_TO_STR(u) if (usagequery & u) { strcat(buf, " \| "#u); usagequery &= ~u; }
1032	WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
1033	WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
1034	WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
1035	WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
1036	WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
1037	WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
1038	WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
1039	#undef WINED3DUSAGEQUERY_TO_STR
1040	if (usagequery) FIXME("Unrecognized usage query flag(s) %#x\n", usagequery);
1041
1042	return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1043	}
1044
1045	const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
1046	switch (method) {
1047	#define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
1048	WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
1049	WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
1050	WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
1051	WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
1052	WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
1053	WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
1054	WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
1055	#undef WINED3DDECLMETHOD_TO_STR
1056	default:
1057	FIXME("Unrecognized %u declaration method!\n", method);
1058	return "unrecognized";
1059	}
1060	}
1061
1062	const char* debug_d3ddeclusage(BYTE usage) {
1063	switch (usage) {
1064	#define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
1065	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
1066	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
1067	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
1068	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
1069	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
1070	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
1071	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
1072	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
1073	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
1074	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
1075	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
1076	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
1077	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
1078	WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
1079	#undef WINED3DDECLUSAGE_TO_STR
1080	default:
1081	FIXME("Unrecognized %u declaration usage!\n", usage);
1082	return "unrecognized";
1083	}
1084	}
1085
1086	const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
1087	switch (res) {
1088	#define RES_TO_STR(res) case res: return #res
1089	RES_TO_STR(WINED3DRTYPE_SURFACE);
1090	RES_TO_STR(WINED3DRTYPE_VOLUME);
1091	RES_TO_STR(WINED3DRTYPE_TEXTURE);
1092	RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
1093	RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
1094	RES_TO_STR(WINED3DRTYPE_BUFFER);
1095	#undef RES_TO_STR
1096	default:
1097	FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
1098	return "unrecognized";
1099	}
1100	}
1101
1102	const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
1103	switch (PrimitiveType) {
1104	#define PRIM_TO_STR(prim) case prim: return #prim
1105	PRIM_TO_STR(WINED3DPT_UNDEFINED);
1106	PRIM_TO_STR(WINED3DPT_POINTLIST);
1107	PRIM_TO_STR(WINED3DPT_LINELIST);
1108	PRIM_TO_STR(WINED3DPT_LINESTRIP);
1109	PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
1110	PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
1111	PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
1112	PRIM_TO_STR(WINED3DPT_LINELIST_ADJ);
1113	PRIM_TO_STR(WINED3DPT_LINESTRIP_ADJ);
1114	PRIM_TO_STR(WINED3DPT_TRIANGLELIST_ADJ);
1115	PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP_ADJ);
1116	#undef PRIM_TO_STR
1117	default:
1118	FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
1119	return "unrecognized";
1120	}
1121	}
1122
1123	const char* debug_d3drenderstate(DWORD state) {
1124	switch (state) {
1125	#define D3DSTATE_TO_STR(u) case u: return #u
1126	D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE );
1127	D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS );
1128	D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS );
1129	D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE );
1130	D3DSTATE_TO_STR(WINED3DRS_WRAPU );
1131	D3DSTATE_TO_STR(WINED3DRS_WRAPV );
1132	D3DSTATE_TO_STR(WINED3DRS_ZENABLE );
1133	D3DSTATE_TO_STR(WINED3DRS_FILLMODE );
1134	D3DSTATE_TO_STR(WINED3DRS_SHADEMODE );
1135	D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN );
1136	D3DSTATE_TO_STR(WINED3DRS_MONOENABLE );
1137	D3DSTATE_TO_STR(WINED3DRS_ROP2 );
1138	D3DSTATE_TO_STR(WINED3DRS_PLANEMASK );
1139	D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE );
1140	D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE );
1141	D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL );
1142	D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG );
1143	D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN );
1144	D3DSTATE_TO_STR(WINED3DRS_SRCBLEND );
1145	D3DSTATE_TO_STR(WINED3DRS_DESTBLEND );
1146	D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND );
1147	D3DSTATE_TO_STR(WINED3DRS_CULLMODE );
1148	D3DSTATE_TO_STR(WINED3DRS_ZFUNC );
1149	D3DSTATE_TO_STR(WINED3DRS_ALPHAREF );
1150	D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC );
1151	D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE );
1152	D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE );
1153	D3DSTATE_TO_STR(WINED3DRS_FOGENABLE );
1154	D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE );
1155	D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE );
1156	D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL );
1157	D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX );
1158	D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA );
1159	D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR );
1160	D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE );
1161	D3DSTATE_TO_STR(WINED3DRS_FOGSTART );
1162	D3DSTATE_TO_STR(WINED3DRS_FOGEND );
1163	D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY );
1164	D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE );
1165	D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS );
1166	D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE );
1167	D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR );
1168	D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU );
1169	D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV );
1170	D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS );
1171	D3DSTATE_TO_STR(WINED3DRS_ZBIAS );
1172	D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE );
1173	D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY );
1174	D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH );
1175	D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
1176	D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE );
1177	D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL );
1178	D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL );
1179	D3DSTATE_TO_STR(WINED3DRS_STENCILPASS );
1180	D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC );
1181	D3DSTATE_TO_STR(WINED3DRS_STENCILREF );
1182	D3DSTATE_TO_STR(WINED3DRS_STENCILMASK );
1183	D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK );
1184	D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR );
1185	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00 );
1186	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01 );
1187	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02 );
1188	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03 );
1189	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04 );
1190	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05 );
1191	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06 );
1192	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07 );
1193	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08 );
1194	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09 );
1195	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10 );
1196	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11 );
1197	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12 );
1198	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13 );
1199	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14 );
1200	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15 );
1201	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16 );
1202	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17 );
1203	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18 );
1204	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19 );
1205	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20 );
1206	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21 );
1207	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22 );
1208	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23 );
1209	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24 );
1210	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25 );
1211	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26 );
1212	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27 );
1213	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28 );
1214	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29 );
1215	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30 );
1216	D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31 );
1217	D3DSTATE_TO_STR(WINED3DRS_WRAP0 );
1218	D3DSTATE_TO_STR(WINED3DRS_WRAP1 );
1219	D3DSTATE_TO_STR(WINED3DRS_WRAP2 );
1220	D3DSTATE_TO_STR(WINED3DRS_WRAP3 );
1221	D3DSTATE_TO_STR(WINED3DRS_WRAP4 );
1222	D3DSTATE_TO_STR(WINED3DRS_WRAP5 );
1223	D3DSTATE_TO_STR(WINED3DRS_WRAP6 );
1224	D3DSTATE_TO_STR(WINED3DRS_WRAP7 );
1225	D3DSTATE_TO_STR(WINED3DRS_CLIPPING );
1226	D3DSTATE_TO_STR(WINED3DRS_LIGHTING );
1227	D3DSTATE_TO_STR(WINED3DRS_EXTENTS );
1228	D3DSTATE_TO_STR(WINED3DRS_AMBIENT );
1229	D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE );
1230	D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX );
1231	D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER );
1232	D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS );
1233	D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE );
1234	D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE );
1235	D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE );
1236	D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE );
1237	D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE );
1238	D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND );
1239	D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE );
1240	D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING );
1241	D3DSTATE_TO_STR(WINED3DRS_POINTSIZE );
1242	D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN );
1243	D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE );
1244	D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE );
1245	D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A );
1246	D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B );
1247	D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C );
1248	D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS );
1249	D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK );
1250	D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE );
1251	D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS );
1252	D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN );
1253	D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX );
1254	D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE );
1255	D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE );
1256	D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR );
1257	D3DSTATE_TO_STR(WINED3DRS_BLENDOP );
1258	D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE );
1259	D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE );
1260	D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE );
1261	D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS );
1262	D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE );
1263	D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL );
1264	D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL );
1265	D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X );
1266	D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y );
1267	D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z );
1268	D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W );
1269	D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
1270	D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE );
1271	D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL );
1272	D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL );
1273	D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS );
1274	D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC );
1275	D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1 );
1276	D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2 );
1277	D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3 );
1278	D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR );
1279	D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE );
1280	D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS );
1281	D3DSTATE_TO_STR(WINED3DRS_WRAP8 );
1282	D3DSTATE_TO_STR(WINED3DRS_WRAP9 );
1283	D3DSTATE_TO_STR(WINED3DRS_WRAP10 );
1284	D3DSTATE_TO_STR(WINED3DRS_WRAP11 );
1285	D3DSTATE_TO_STR(WINED3DRS_WRAP12 );
1286	D3DSTATE_TO_STR(WINED3DRS_WRAP13 );
1287	D3DSTATE_TO_STR(WINED3DRS_WRAP14 );
1288	D3DSTATE_TO_STR(WINED3DRS_WRAP15 );
1289	D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE );
1290	D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA );
1291	D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA );
1292	D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA );
1293	#undef D3DSTATE_TO_STR
1294	default:
1295	FIXME("Unrecognized %u render state!\n", state);
1296	return "unrecognized";
1297	}
1298	}
1299
1300	const char* debug_d3dsamplerstate(DWORD state) {
1301	switch (state) {
1302	#define D3DSTATE_TO_STR(u) case u: return #u
1303	D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR );
1304	D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU );
1305	D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV );
1306	D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW );
1307	D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER );
1308	D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER );
1309	D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER );
1310	D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
1311	D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL );
1312	D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
1313	D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE );
1314	D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
1315	D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET );
1316	#undef D3DSTATE_TO_STR
1317	default:
1318	FIXME("Unrecognized %u sampler state!\n", state);
1319	return "unrecognized";
1320	}
1321	}
1322
1323	const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
1324	switch (filter_type) {
1325	#define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
1326	D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
1327	D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
1328	D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
1329	D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
1330	D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
1331	D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
1332	D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
1333	D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
1334	#undef D3DTEXTUREFILTERTYPE_TO_STR
1335	default:
1336	FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
1337	return "unrecognized";
1338	}
1339	}
1340
1341	const char* debug_d3dtexturestate(DWORD state) {
1342	switch (state) {
1343	#define D3DSTATE_TO_STR(u) case u: return #u
1344	D3DSTATE_TO_STR(WINED3DTSS_COLOROP );
1345	D3DSTATE_TO_STR(WINED3DTSS_COLORARG1 );
1346	D3DSTATE_TO_STR(WINED3DTSS_COLORARG2 );
1347	D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP );
1348	D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1 );
1349	D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2 );
1350	D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00 );
1351	D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01 );
1352	D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10 );
1353	D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11 );
1354	D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX );
1355	D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE );
1356	D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET );
1357	D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
1358	D3DSTATE_TO_STR(WINED3DTSS_COLORARG0 );
1359	D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0 );
1360	D3DSTATE_TO_STR(WINED3DTSS_RESULTARG );
1361	D3DSTATE_TO_STR(WINED3DTSS_CONSTANT );
1362	#undef D3DSTATE_TO_STR
1363	default:
1364	FIXME("Unrecognized %u texture state!\n", state);
1365	return "unrecognized";
1366	}
1367	}
1368
1369	const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
1370	switch (d3dtop) {
1371	#define D3DTOP_TO_STR(u) case u: return #u
1372	D3DTOP_TO_STR(WINED3DTOP_DISABLE);
1373	D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
1374	D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
1375	D3DTOP_TO_STR(WINED3DTOP_MODULATE);
1376	D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
1377	D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
1378	D3DTOP_TO_STR(WINED3DTOP_ADD);
1379	D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
1380	D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
1381	D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
1382	D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
1383	D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
1384	D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
1385	D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
1386	D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
1387	D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
1388	D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
1389	D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
1390	D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
1391	D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
1392	D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
1393	D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
1394	D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
1395	D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
1396	D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
1397	D3DTOP_TO_STR(WINED3DTOP_LERP);
1398	#undef D3DTOP_TO_STR
1399	default:
1400	FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
1401	return "unrecognized";
1402	}
1403	}
1404
1405	const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
1406	switch (tstype) {
1407	#define TSTYPE_TO_STR(tstype) case tstype: return #tstype
1408	TSTYPE_TO_STR(WINED3DTS_VIEW);
1409	TSTYPE_TO_STR(WINED3DTS_PROJECTION);
1410	TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
1411	TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
1412	TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
1413	TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
1414	TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
1415	TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
1416	TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
1417	TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
1418	TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
1419	#undef TSTYPE_TO_STR
1420	default:
1421	if (tstype > 256 && tstype < 512) {
1422	FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
1423	return ("WINED3DTS_WORLDMATRIX > 0");
1424	}
1425	FIXME("Unrecognized %u WINED3DTS\n", tstype);
1426	return "unrecognized";
1427	}
1428	}
1429
1430	const char* debug_d3dpool(WINED3DPOOL Pool) {
1431	switch (Pool) {
1432	#define POOL_TO_STR(p) case p: return #p
1433	POOL_TO_STR(WINED3DPOOL_DEFAULT);
1434	POOL_TO_STR(WINED3DPOOL_MANAGED);
1435	POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
1436	POOL_TO_STR(WINED3DPOOL_SCRATCH);
1437	#undef POOL_TO_STR
1438	default:
1439	FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
1440	return "unrecognized";
1441	}
1442	}
1443
1444	const char *debug_fbostatus(GLenum status) {
1445	switch(status) {
1446	#define FBOSTATUS_TO_STR(u) case u: return #u
1447	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT);
1448	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT);
1449	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT);
1450	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
1451	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
1452	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT);
1453	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT);
1454	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT);
1455	FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT);
1456	#undef FBOSTATUS_TO_STR
1457	default:
1458	FIXME("Unrecognied FBO status 0x%08x\n", status);
1459	return "unrecognized";
1460	}
1461	}
1462
1463	const char *debug_glerror(GLenum error) {
1464	switch(error) {
1465	#define GLERROR_TO_STR(u) case u: return #u
1466	GLERROR_TO_STR(GL_NO_ERROR);
1467	GLERROR_TO_STR(GL_INVALID_ENUM);
1468	GLERROR_TO_STR(GL_INVALID_VALUE);
1469	GLERROR_TO_STR(GL_INVALID_OPERATION);
1470	GLERROR_TO_STR(GL_STACK_OVERFLOW);
1471	GLERROR_TO_STR(GL_STACK_UNDERFLOW);
1472	GLERROR_TO_STR(GL_OUT_OF_MEMORY);
1473	GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT);
1474	#undef GLERROR_TO_STR
1475	default:
1476	FIXME("Unrecognied GL error 0x%08x\n", error);
1477	return "unrecognized";
1478	}
1479	}
1480
1481	const char *debug_d3dbasis(WINED3DBASISTYPE basis) {
1482	switch(basis) {
1483	case WINED3DBASIS_BEZIER: return "WINED3DBASIS_BEZIER";
1484	case WINED3DBASIS_BSPLINE: return "WINED3DBASIS_BSPLINE";
1485	case WINED3DBASIS_INTERPOLATE: return "WINED3DBASIS_INTERPOLATE";
1486	default: return "unrecognized";
1487	}
1488	}
1489
1490	const char *debug_d3ddegree(WINED3DDEGREETYPE degree) {
1491	switch(degree) {
1492	case WINED3DDEGREE_LINEAR: return "WINED3DDEGREE_LINEAR";
1493	case WINED3DDEGREE_QUADRATIC: return "WINED3DDEGREE_QUADRATIC";
1494	case WINED3DDEGREE_CUBIC: return "WINED3DDEGREE_CUBIC";
1495	case WINED3DDEGREE_QUINTIC: return "WINED3DDEGREE_QUINTIC";
1496	default: return "unrecognized";
1497	}
1498	}
1499
1500	static const char *debug_fixup_channel_source(enum fixup_channel_source source)
1501	{
1502	switch(source)
1503	{
1504	#define WINED3D_TO_STR(x) case x: return #x
1505	WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
1506	WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
1507	WINED3D_TO_STR(CHANNEL_SOURCE_X);
1508	WINED3D_TO_STR(CHANNEL_SOURCE_Y);
1509	WINED3D_TO_STR(CHANNEL_SOURCE_Z);
1510	WINED3D_TO_STR(CHANNEL_SOURCE_W);
1511	WINED3D_TO_STR(CHANNEL_SOURCE_YUV0);
1512	WINED3D_TO_STR(CHANNEL_SOURCE_YUV1);
1513	#undef WINED3D_TO_STR
1514	default:
1515	FIXME("Unrecognized fixup_channel_source %#x\n", source);
1516	return "unrecognized";
1517	}
1518	}
1519
1520	static const char *debug_yuv_fixup(enum yuv_fixup yuv_fixup)
1521	{
1522	switch(yuv_fixup)
1523	{
1524	#define WINED3D_TO_STR(x) case x: return #x
1525	WINED3D_TO_STR(YUV_FIXUP_YUY2);
1526	WINED3D_TO_STR(YUV_FIXUP_UYVY);
1527	WINED3D_TO_STR(YUV_FIXUP_YV12);
1528	#undef WINED3D_TO_STR
1529	default:
1530	FIXME("Unrecognized YUV fixup %#x\n", yuv_fixup);
1531	return "unrecognized";
1532	}
1533	}
1534
1535	void dump_color_fixup_desc(struct color_fixup_desc fixup)
1536	{
1537	if (is_yuv_fixup(fixup))
1538	{
1539	TRACE("\tYUV: %s\n", debug_yuv_fixup(get_yuv_fixup(fixup)));
1540	return;
1541	}
1542
1543	TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
1544	TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
1545	TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
1546	TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
1547	}
1548
1549	const char *debug_surflocation(DWORD flag) {
1550	char buf[128];
1551
1552	buf[0] = 0;
1553	if(flag & SFLAG_INSYSMEM) strcat(buf, " \| SFLAG_INSYSMEM");
1554	if(flag & SFLAG_INDRAWABLE) strcat(buf, " \| SFLAG_INDRAWABLE");
1555	if(flag & SFLAG_INTEXTURE) strcat(buf, " \| SFLAG_INTEXTURE");
1556	if(flag & SFLAG_INSRGBTEX) strcat(buf, " \| SFLAG_INSRGBTEX");
1557	return wine_dbg_sprintf("%s", buf[0] ? buf + 3 : "0");
1558	}
1559
1560	/*****************************************************************************
1561	* Useful functions mapping GL <-> D3D values
1562	*/
1563	GLenum StencilOp(DWORD op) {
1564	switch(op) {
1565	case WINED3DSTENCILOP_KEEP : return GL_KEEP;
1566	case WINED3DSTENCILOP_ZERO : return GL_ZERO;
1567	case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
1568	case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
1569	case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
1570	case WINED3DSTENCILOP_INVERT : return GL_INVERT;
1571	case WINED3DSTENCILOP_INCR : return GL_INCR_WRAP_EXT;
1572	case WINED3DSTENCILOP_DECR : return GL_DECR_WRAP_EXT;
1573	default:
1574	FIXME("Unrecognized stencil op %d\n", op);
1575	return GL_KEEP;
1576	}
1577	}
1578
1579	GLenum CompareFunc(DWORD func) {
1580	switch ((WINED3DCMPFUNC)func) {
1581	case WINED3DCMP_NEVER : return GL_NEVER;
1582	case WINED3DCMP_LESS : return GL_LESS;
1583	case WINED3DCMP_EQUAL : return GL_EQUAL;
1584	case WINED3DCMP_LESSEQUAL : return GL_LEQUAL;
1585	case WINED3DCMP_GREATER : return GL_GREATER;
1586	case WINED3DCMP_NOTEQUAL : return GL_NOTEQUAL;
1587	case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
1588	case WINED3DCMP_ALWAYS : return GL_ALWAYS;
1589	default:
1590	FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
1591	return 0;
1592	}
1593	}
1594
1595	BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
1596	if (op == WINED3DTOP_DISABLE) return FALSE;
1597	if (This->stateBlock->textures[stage]) return FALSE;
1598
1599	if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1600	&& op != WINED3DTOP_SELECTARG2) return TRUE;
1601	if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1602	&& op != WINED3DTOP_SELECTARG1) return TRUE;
1603	if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1604	&& (op == WINED3DTOP_MULTIPLYADD \|\| op == WINED3DTOP_LERP)) return TRUE;
1605
1606	return FALSE;
1607	}
1608
1609	/* Setup this textures matrix according to the texture flags*/
1610	/* GL locking is done by the caller (state handler) */
1611	void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed,
1612	WINED3DFORMAT vtx_fmt, BOOL ffp_proj_control)
1613	{
1614	float mat[16];
1615
1616	glMatrixMode(GL_TEXTURE);
1617	checkGLcall("glMatrixMode(GL_TEXTURE)");
1618
1619	if (flags == WINED3DTTFF_DISABLE \|\| flags == WINED3DTTFF_COUNT1 \|\| transformed) {
1620	glLoadIdentity();
1621	checkGLcall("glLoadIdentity()");
1622	return;
1623	}
1624
1625	if (flags == (WINED3DTTFF_COUNT1\|WINED3DTTFF_PROJECTED)) {
1626	ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1\|WINED3DTTFF_PROJECTED\n");
1627	return;
1628	}
1629
1630	memcpy(mat, smat, 16 * sizeof(float));
1631
1632	if (flags & WINED3DTTFF_PROJECTED) {
1633	if(!ffp_proj_control) {
1634	switch (flags & ~WINED3DTTFF_PROJECTED) {
1635	case WINED3DTTFF_COUNT2:
1636	mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
1637	mat[1] = mat[5] = mat[9] = mat[13] = 0;
1638	break;
1639	case WINED3DTTFF_COUNT3:
1640	mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
1641	mat[2] = mat[6] = mat[10] = mat[14] = 0;
1642	break;
1643	}
1644	}
1645	} else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1646	if(!calculatedCoords) {
1647	switch(vtx_fmt)
1648	{
1649	case WINED3DFMT_R32_FLOAT:
1650	/* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
1651	* swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
1652	* the input value to the transformation will be 0, so the matrix value is irrelevant
1653	*/
1654	mat[12] = mat[4];
1655	mat[13] = mat[5];
1656	mat[14] = mat[6];
1657	mat[15] = mat[7];
1658	break;
1659	case WINED3DFMT_R32G32_FLOAT:
1660	/* See above, just 3rd and 4th coord
1661	*/
1662	mat[12] = mat[8];
1663	mat[13] = mat[9];
1664	mat[14] = mat[10];
1665	mat[15] = mat[11];
1666	break;
1667	case WINED3DFMT_R32G32B32_FLOAT: /* Opengl defaults match dx defaults */
1668	case WINED3DFMT_R32G32B32A32_FLOAT: /* No defaults apply, all app defined */
1669
1670	/* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
1671	* into a bad place. The division elimination below will apply to make sure the
1672	* 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
1673	*/
1674	case WINED3DFMT_UNKNOWN: /* No texture coords, 0/0/0/1 defaults are passed */
1675	break;
1676	default:
1677	FIXME("Unexpected fixed function texture coord input\n");
1678	}
1679	}
1680	if(!ffp_proj_control) {
1681	switch (flags & ~WINED3DTTFF_PROJECTED) {
1682	/* case WINED3DTTFF_COUNT1: Won't ever get here */
1683	case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
1684	/* OpenGL divides the first 3 vertex coord by the 4th by default,
1685	* which is essentially the same as D3DTTFF_PROJECTED. Make sure that
1686	* the 4th coord evaluates to 1.0 to eliminate that.
1687	*
1688	* If the fixed function pipeline is used, the 4th value remains unused,
1689	* so there is no danger in doing this. With vertex shaders we have a
1690	* problem. Should an app hit that problem, the code here would have to
1691	* check for pixel shaders, and the shader has to undo the default gl divide.
1692	*
1693	* A more serious problem occurs if the app passes 4 coordinates in, and the
1694	* 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
1695	* or a replacement shader
1696	*/
1697	default: mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
1698	}
1699	}
1700	}
1701
1702	glLoadMatrixf(mat);
1703	checkGLcall("glLoadMatrixf(mat)");
1704	}
1705	#undef GLINFO_LOCATION
1706
1707	/* This small helper function is used to convert a bitmask into the number of masked bits */
1708	unsigned int count_bits(unsigned int mask)
1709	{
1710	unsigned int count;
1711	for (count = 0; mask; ++count)
1712	{
1713	mask &= mask - 1;
1714	}
1715	return count;
1716	}
1717
1718	/* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
1719	* The later function requires individual color components. */
1720	BOOL getColorBits(const struct GlPixelFormatDesc *format_desc,
1721	short redSize, short greenSize, short blueSize, short alphaSize, short *totalSize)
1722	{
1723	TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
1724	switch(format_desc->format)
1725	{
1726	case WINED3DFMT_X8R8G8B8:
1727	case WINED3DFMT_R8G8B8:
1728	case WINED3DFMT_A8R8G8B8:
1729	case WINED3DFMT_R8G8B8A8_UNORM:
1730	case WINED3DFMT_A2R10G10B10:
1731	case WINED3DFMT_X1R5G5B5:
1732	case WINED3DFMT_A1R5G5B5:
1733	case WINED3DFMT_R5G6B5:
1734	case WINED3DFMT_X4R4G4B4:
1735	case WINED3DFMT_A4R4G4B4:
1736	case WINED3DFMT_R3G3B2:
1737	case WINED3DFMT_A8P8:
1738	case WINED3DFMT_P8:
1739	break;
1740	default:
1741	ERR("Unsupported format: %s\n", debug_d3dformat(format_desc->format));
1742	return FALSE;
1743	}
1744
1745	*redSize = count_bits(format_desc->red_mask);
1746	*greenSize = count_bits(format_desc->green_mask);
1747	*blueSize = count_bits(format_desc->blue_mask);
1748	*alphaSize = count_bits(format_desc->alpha_mask);
1749	totalSize = redSize + greenSize + blueSize + *alphaSize;
1750
1751	TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n",
1752	redSize, greenSize, blueSize, alphaSize, *totalSize, debug_d3dformat(format_desc->format));
1753	return TRUE;
1754	}
1755
1756	/* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
1757	BOOL getDepthStencilBits(const struct GlPixelFormatDesc format_desc, short depthSize, short *stencilSize)
1758	{
1759	TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
1760	switch(format_desc->format)
1761	{
1762	case WINED3DFMT_D16_LOCKABLE:
1763	case WINED3DFMT_D16_UNORM:
1764	case WINED3DFMT_D15S1:
1765	case WINED3DFMT_D24X8:
1766	case WINED3DFMT_D24X4S4:
1767	case WINED3DFMT_D24S8:
1768	case WINED3DFMT_D24FS8:
1769	case WINED3DFMT_D32:
1770	case WINED3DFMT_D32F_LOCKABLE:
1771	break;
1772	default:
1773	FIXME("Unsupported stencil format: %s\n", debug_d3dformat(format_desc->format));
1774	return FALSE;
1775	}
1776
1777	*depthSize = format_desc->depth_size;
1778	*stencilSize = format_desc->stencil_size;
1779
1780	TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n",
1781	depthSize, stencilSize, debug_d3dformat(format_desc->format));
1782	return TRUE;
1783	}
1784
1785	/* DirectDraw stuff */
1786	WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
1787	switch(depth) {
1788	case 8: return WINED3DFMT_P8;
1789	case 15: return WINED3DFMT_X1R5G5B5;
1790	case 16: return WINED3DFMT_R5G6B5;
1791	case 24: return WINED3DFMT_X8R8G8B8; /* Robots needs 24bit to be X8R8G8B8 */
1792	case 32: return WINED3DFMT_X8R8G8B8; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return X8R8G8B8 */
1793	default: return WINED3DFMT_UNKNOWN;
1794	}
1795	}
1796
1797	void multiply_matrix(WINED3DMATRIX dest, const WINED3DMATRIX src1, const WINED3DMATRIX *src2) {
1798	WINED3DMATRIX temp;
1799
1800	/* Now do the multiplication 'by hand'.
1801	I know that all this could be optimised, but this will be done later :-) */
1802	temp.u.s._11 = (src1->u.s._11 * src2->u.s._11) + (src1->u.s._21 * src2->u.s._12) + (src1->u.s._31 * src2->u.s._13) + (src1->u.s._41 * src2->u.s._14);
1803	temp.u.s._21 = (src1->u.s._11 * src2->u.s._21) + (src1->u.s._21 * src2->u.s._22) + (src1->u.s._31 * src2->u.s._23) + (src1->u.s._41 * src2->u.s._24);
1804	temp.u.s._31 = (src1->u.s._11 * src2->u.s._31) + (src1->u.s._21 * src2->u.s._32) + (src1->u.s._31 * src2->u.s._33) + (src1->u.s._41 * src2->u.s._34);
1805	temp.u.s._41 = (src1->u.s._11 * src2->u.s._41) + (src1->u.s._21 * src2->u.s._42) + (src1->u.s._31 * src2->u.s._43) + (src1->u.s._41 * src2->u.s._44);
1806
1807	temp.u.s._12 = (src1->u.s._12 * src2->u.s._11) + (src1->u.s._22 * src2->u.s._12) + (src1->u.s._32 * src2->u.s._13) + (src1->u.s._42 * src2->u.s._14);
1808	temp.u.s._22 = (src1->u.s._12 * src2->u.s._21) + (src1->u.s._22 * src2->u.s._22) + (src1->u.s._32 * src2->u.s._23) + (src1->u.s._42 * src2->u.s._24);
1809	temp.u.s._32 = (src1->u.s._12 * src2->u.s._31) + (src1->u.s._22 * src2->u.s._32) + (src1->u.s._32 * src2->u.s._33) + (src1->u.s._42 * src2->u.s._34);
1810	temp.u.s._42 = (src1->u.s._12 * src2->u.s._41) + (src1->u.s._22 * src2->u.s._42) + (src1->u.s._32 * src2->u.s._43) + (src1->u.s._42 * src2->u.s._44);
1811
1812	temp.u.s._13 = (src1->u.s._13 * src2->u.s._11) + (src1->u.s._23 * src2->u.s._12) + (src1->u.s._33 * src2->u.s._13) + (src1->u.s._43 * src2->u.s._14);
1813	temp.u.s._23 = (src1->u.s._13 * src2->u.s._21) + (src1->u.s._23 * src2->u.s._22) + (src1->u.s._33 * src2->u.s._23) + (src1->u.s._43 * src2->u.s._24);
1814	temp.u.s._33 = (src1->u.s._13 * src2->u.s._31) + (src1->u.s._23 * src2->u.s._32) + (src1->u.s._33 * src2->u.s._33) + (src1->u.s._43 * src2->u.s._34);
1815	temp.u.s._43 = (src1->u.s._13 * src2->u.s._41) + (src1->u.s._23 * src2->u.s._42) + (src1->u.s._33 * src2->u.s._43) + (src1->u.s._43 * src2->u.s._44);
1816
1817	temp.u.s._14 = (src1->u.s._14 * src2->u.s._11) + (src1->u.s._24 * src2->u.s._12) + (src1->u.s._34 * src2->u.s._13) + (src1->u.s._44 * src2->u.s._14);
1818	temp.u.s._24 = (src1->u.s._14 * src2->u.s._21) + (src1->u.s._24 * src2->u.s._22) + (src1->u.s._34 * src2->u.s._23) + (src1->u.s._44 * src2->u.s._24);
1819	temp.u.s._34 = (src1->u.s._14 * src2->u.s._31) + (src1->u.s._24 * src2->u.s._32) + (src1->u.s._34 * src2->u.s._33) + (src1->u.s._44 * src2->u.s._34);
1820	temp.u.s._44 = (src1->u.s._14 * src2->u.s._41) + (src1->u.s._24 * src2->u.s._42) + (src1->u.s._34 * src2->u.s._43) + (src1->u.s._44 * src2->u.s._44);
1821
1822	/* And copy the new matrix in the good storage.. */
1823	memcpy(dest, &temp, 16 * sizeof(float));
1824	}
1825
1826	DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
1827	DWORD size = 0;
1828	int i;
1829	int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
1830
1831	if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
1832	if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
1833	if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
1834	if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
1835	switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
1836	case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
1837	case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
1838	case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break;
1839	case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break;
1840	case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break;
1841	case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break;
1842	case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break;
1843	case WINED3DFVF_XYZW: size += 4 * sizeof(float); break;
1844	default: ERR("Unexpected position mask\n");
1845	}
1846	for (i = 0; i < numTextures; i++) {
1847	size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
1848	}
1849
1850	return size;
1851	}
1852
1853	/***********************************************************************
1854	* CalculateTexRect
1855	*
1856	* Calculates the dimensions of the opengl texture used for blits.
1857	* Handled oversized opengl textures and updates the source rectangle
1858	* accordingly
1859	*
1860	* Params:
1861	* This: Surface to operate on
1862	* Rect: Requested rectangle
1863	*
1864	* Returns:
1865	* TRUE if the texture part can be loaded,
1866	* FALSE otherwise
1867	*
1868	*********************************************************************/
1869	#define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
1870
1871	BOOL CalculateTexRect(IWineD3DSurfaceImpl This, RECT Rect, float glTexCoord[4]) {
1872	int x1 = Rect->left, x2 = Rect->right;
1873	int y1 = Rect->top, y2 = Rect->bottom;
1874	GLint maxSize = GL_LIMITS(texture_size);
1875
1876	TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
1877	Rect->left, Rect->top, Rect->right, Rect->bottom);
1878
1879	/* The sizes might be reversed */
1880	if(Rect->left > Rect->right) {
1881	x1 = Rect->right;
1882	x2 = Rect->left;
1883	}
1884	if(Rect->top > Rect->bottom) {
1885	y1 = Rect->bottom;
1886	y2 = Rect->top;
1887	}
1888
1889	/* No oversized texture? This is easy */
1890	if(!(This->Flags & SFLAG_OVERSIZE)) {
1891	/* Which rect from the texture do I need? */
1892	if(This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB) {
1893	glTexCoord[0] = (float) Rect->left;
1894	glTexCoord[2] = (float) Rect->top;
1895	glTexCoord[1] = (float) Rect->right;
1896	glTexCoord[3] = (float) Rect->bottom;
1897	} else {
1898	glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
1899	glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
1900	glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
1901	glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
1902	}
1903
1904	return TRUE;
1905	} else {
1906	/* Check if we can succeed at all */
1907	if( (x2 - x1) > maxSize \|\|
1908	(y2 - y1) > maxSize ) {
1909	TRACE("Requested rectangle is too large for gl\n");
1910	return FALSE;
1911	}
1912
1913	/* A part of the texture has to be picked. First, check if
1914	* some texture part is loaded already, if yes try to re-use it.
1915	* If the texture is dirty, or the part can't be used,
1916	* re-position the part to load
1917	*/
1918	if(This->Flags & SFLAG_INTEXTURE) {
1919	if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
1920	This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
1921	/* Ok, the rectangle is ok, re-use it */
1922	TRACE("Using existing gl Texture\n");
1923	} else {
1924	/* Rectangle is not ok, dirtify the texture to reload it */
1925	TRACE("Dirtifying texture to force reload\n");
1926	This->Flags &= ~SFLAG_INTEXTURE;
1927	}
1928	}
1929
1930	/* Now if we are dirty(no else if!) */
1931	if(!(This->Flags & SFLAG_INTEXTURE)) {
1932	/* Set the new rectangle. Use the following strategy:
1933	* 1) Use as big textures as possible.
1934	* 2) Place the texture part in the way that the requested
1935	* part is in the middle of the texture(well, almost)
1936	* 3) If the texture is moved over the edges of the
1937	* surface, replace it nicely
1938	* 4) If the coord is not limiting the texture size,
1939	* use the whole size
1940	*/
1941	if((This->pow2Width) > maxSize) {
1942	This->glRect.left = x1 - maxSize / 2;
1943	if(This->glRect.left < 0) {
1944	This->glRect.left = 0;
1945	}
1946	This->glRect.right = This->glRect.left + maxSize;
1947	if(This->glRect.right > This->currentDesc.Width) {
1948	This->glRect.right = This->currentDesc.Width;
1949	This->glRect.left = This->glRect.right - maxSize;
1950	}
1951	} else {
1952	This->glRect.left = 0;
1953	This->glRect.right = This->pow2Width;
1954	}
1955
1956	if(This->pow2Height > maxSize) {
1957	This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
1958	if(This->glRect.top < 0) This->glRect.top = 0;
1959	This->glRect.bottom = This->glRect.left + maxSize;
1960	if(This->glRect.bottom > This->currentDesc.Height) {
1961	This->glRect.bottom = This->currentDesc.Height;
1962	This->glRect.top = This->glRect.bottom - maxSize;
1963	}
1964	} else {
1965	This->glRect.top = 0;
1966	This->glRect.bottom = This->pow2Height;
1967	}
1968	TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
1969	This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
1970	}
1971
1972	/* Re-calculate the rect to draw */
1973	Rect->left -= This->glRect.left;
1974	Rect->right -= This->glRect.left;
1975	Rect->top -= This->glRect.top;
1976	Rect->bottom -= This->glRect.top;
1977
1978	/* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
1979	* or the pow2Width / pow2Height of the surface.
1980	*
1981	* Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
1982	* as regular GL_TEXTURE_2D.
1983	*/
1984	glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
1985	glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
1986	glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
1987	glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
1988	}
1989	return TRUE;
1990	}
1991	#undef GLINFO_LOCATION
1992
1993	#define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
1994	void gen_ffp_frag_op(IWineD3DStateBlockImpl stateblock, struct ffp_frag_settings settings, BOOL ignore_textype) {
1995	#define ARG1 0x01
1996	#define ARG2 0x02
1997	#define ARG0 0x04
1998	static const unsigned char args[WINED3DTOP_LERP + 1] = {
1999	/* undefined */ 0,
2000	/* D3DTOP_DISABLE */ 0,
2001	/* D3DTOP_SELECTARG1 */ ARG1,
2002	/* D3DTOP_SELECTARG2 */ ARG2,
2003	/* D3DTOP_MODULATE */ ARG1 \| ARG2,
2004	/* D3DTOP_MODULATE2X */ ARG1 \| ARG2,
2005	/* D3DTOP_MODULATE4X */ ARG1 \| ARG2,
2006	/* D3DTOP_ADD */ ARG1 \| ARG2,
2007	/* D3DTOP_ADDSIGNED */ ARG1 \| ARG2,
2008	/* D3DTOP_ADDSIGNED2X */ ARG1 \| ARG2,
2009	/* D3DTOP_SUBTRACT */ ARG1 \| ARG2,
2010	/* D3DTOP_ADDSMOOTH */ ARG1 \| ARG2,
2011	/* D3DTOP_BLENDDIFFUSEALPHA */ ARG1 \| ARG2,
2012	/* D3DTOP_BLENDTEXTUREALPHA */ ARG1 \| ARG2,
2013	/* D3DTOP_BLENDFACTORALPHA */ ARG1 \| ARG2,
2014	/* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1 \| ARG2,
2015	/* D3DTOP_BLENDCURRENTALPHA */ ARG1 \| ARG2,
2016	/* D3DTOP_PREMODULATE */ ARG1 \| ARG2,
2017	/* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1 \| ARG2,
2018	/* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1 \| ARG2,
2019	/* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1 \| ARG2,
2020	/* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1 \| ARG2,
2021	/* D3DTOP_BUMPENVMAP */ ARG1 \| ARG2,
2022	/* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1 \| ARG2,
2023	/* D3DTOP_DOTPRODUCT3 */ ARG1 \| ARG2,
2024	/* D3DTOP_MULTIPLYADD */ ARG1 \| ARG2 \| ARG0,
2025	/* D3DTOP_LERP */ ARG1 \| ARG2 \| ARG0
2026	};
2027	unsigned int i;
2028	DWORD ttff;
2029	DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
2030
2031	for(i = 0; i < GL_LIMITS(texture_stages); i++) {
2032	IWineD3DBaseTextureImpl *texture;
2033	settings->op[i].padding = 0;
2034	if(stateblock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
2035	settings->op[i].cop = WINED3DTOP_DISABLE;
2036	settings->op[i].aop = WINED3DTOP_DISABLE;
2037	settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
2038	settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
2039	settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2040	settings->op[i].dst = resultreg;
2041	settings->op[i].tex_type = tex_1d;
2042	settings->op[i].projected = proj_none;
2043	i++;
2044	break;
2045	}
2046
2047	texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
2048	if(texture) {
2049	settings->op[i].color_fixup = texture->resource.format_desc->color_fixup;
2050	if(ignore_textype) {
2051	settings->op[i].tex_type = tex_1d;
2052	} else {
2053	switch (IWineD3DBaseTexture_GetTextureDimensions((IWineD3DBaseTexture *)texture)) {
2054	case GL_TEXTURE_1D:
2055	settings->op[i].tex_type = tex_1d;
2056	break;
2057	case GL_TEXTURE_2D:
2058	settings->op[i].tex_type = tex_2d;
2059	break;
2060	case GL_TEXTURE_3D:
2061	settings->op[i].tex_type = tex_3d;
2062	break;
2063	case GL_TEXTURE_CUBE_MAP_ARB:
2064	settings->op[i].tex_type = tex_cube;
2065	break;
2066	case GL_TEXTURE_RECTANGLE_ARB:
2067	settings->op[i].tex_type = tex_rect;
2068	break;
2069	}
2070	}
2071	} else {
2072	settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2073	settings->op[i].tex_type = tex_1d;
2074	}
2075
2076	cop = stateblock->textureState[i][WINED3DTSS_COLOROP];
2077	aop = stateblock->textureState[i][WINED3DTSS_ALPHAOP];
2078
2079	carg1 = (args[cop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_COLORARG1] : ARG_UNUSED;
2080	carg2 = (args[cop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_COLORARG2] : ARG_UNUSED;
2081	carg0 = (args[cop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_COLORARG0] : ARG_UNUSED;
2082
2083	if(is_invalid_op(stateblock->wineD3DDevice, i, cop,
2084	carg1, carg2, carg0)) {
2085	carg0 = ARG_UNUSED;
2086	carg2 = ARG_UNUSED;
2087	carg1 = WINED3DTA_CURRENT;
2088	cop = WINED3DTOP_SELECTARG1;
2089	}
2090
2091	if(cop == WINED3DTOP_DOTPRODUCT3) {
2092	/* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
2093	* the color result to the alpha component of the destination
2094	*/
2095	aop = cop;
2096	aarg1 = carg1;
2097	aarg2 = carg2;
2098	aarg0 = carg0;
2099	} else {
2100	aarg1 = (args[aop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG1] : ARG_UNUSED;
2101	aarg2 = (args[aop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG2] : ARG_UNUSED;
2102	aarg0 = (args[aop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG0] : ARG_UNUSED;
2103	}
2104
2105	if (i == 0 && stateblock->textures[0] && stateblock->renderState[WINED3DRS_COLORKEYENABLE])
2106	{
2107	UINT texture_dimensions = IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[0]);
2108
2109	if (texture_dimensions == GL_TEXTURE_2D \|\| texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
2110	{
2111	IWineD3DSurfaceImpl *surf;
2112	surf = (IWineD3DSurfaceImpl ) ((IWineD3DTextureImpl ) stateblock->textures[0])->surfaces[0];
2113
2114	if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format_desc->alpha_mask)
2115	{
2116	if (aop == WINED3DTOP_DISABLE)
2117	{
2118	aarg1 = WINED3DTA_TEXTURE;
2119	aop = WINED3DTOP_SELECTARG1;
2120	}
2121	else if (aop == WINED3DTOP_SELECTARG1 && aarg1 != WINED3DTA_TEXTURE)
2122	{
2123	if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2124	{
2125	aarg2 = WINED3DTA_TEXTURE;
2126	aop = WINED3DTOP_MODULATE;
2127	}
2128	else aarg1 = WINED3DTA_TEXTURE;
2129	}
2130	else if (aop == WINED3DTOP_SELECTARG2 && aarg2 != WINED3DTA_TEXTURE)
2131	{
2132	if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2133	{
2134	aarg1 = WINED3DTA_TEXTURE;
2135	aop = WINED3DTOP_MODULATE;
2136	}
2137	else aarg2 = WINED3DTA_TEXTURE;
2138	}
2139	}
2140	}
2141	}
2142
2143	if(is_invalid_op(stateblock->wineD3DDevice, i, aop,
2144	aarg1, aarg2, aarg0)) {
2145	aarg0 = ARG_UNUSED;
2146	aarg2 = ARG_UNUSED;
2147	aarg1 = WINED3DTA_CURRENT;
2148	aop = WINED3DTOP_SELECTARG1;
2149	}
2150
2151	if(carg1 == WINED3DTA_TEXTURE \|\| carg2 == WINED3DTA_TEXTURE \|\| carg0 == WINED3DTA_TEXTURE \|\|
2152	aarg1 == WINED3DTA_TEXTURE \|\| aarg2 == WINED3DTA_TEXTURE \|\| aarg0 == WINED3DTA_TEXTURE) {
2153	ttff = stateblock->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2154	if(ttff == (WINED3DTTFF_PROJECTED \| WINED3DTTFF_COUNT3)) {
2155	settings->op[i].projected = proj_count3;
2156	} else if(ttff == (WINED3DTTFF_PROJECTED \| WINED3DTTFF_COUNT4)) {
2157	settings->op[i].projected = proj_count4;
2158	} else {
2159	settings->op[i].projected = proj_none;
2160	}
2161	} else {
2162	settings->op[i].projected = proj_none;
2163	}
2164
2165	settings->op[i].cop = cop;
2166	settings->op[i].aop = aop;
2167	settings->op[i].carg0 = carg0;
2168	settings->op[i].carg1 = carg1;
2169	settings->op[i].carg2 = carg2;
2170	settings->op[i].aarg0 = aarg0;
2171	settings->op[i].aarg1 = aarg1;
2172	settings->op[i].aarg2 = aarg2;
2173
2174	if(stateblock->textureState[i][WINED3DTSS_RESULTARG] == WINED3DTA_TEMP) {
2175	settings->op[i].dst = tempreg;
2176	} else {
2177	settings->op[i].dst = resultreg;
2178	}
2179	}
2180
2181	/* Clear unsupported stages */
2182	for(; i < MAX_TEXTURES; i++) {
2183	memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
2184	}
2185
2186	if(stateblock->renderState[WINED3DRS_FOGENABLE] == FALSE) {
2187	settings->fog = FOG_OFF;
2188	} else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
2189	if(use_vs(stateblock) \|\| ((IWineD3DVertexDeclarationImpl *) stateblock->vertexDecl)->position_transformed) {
2190	settings->fog = FOG_LINEAR;
2191	} else {
2192	switch(stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
2193	case WINED3DFOG_NONE:
2194	case WINED3DFOG_LINEAR:
2195	settings->fog = FOG_LINEAR;
2196	break;
2197	case WINED3DFOG_EXP:
2198	settings->fog = FOG_EXP;
2199	break;
2200	case WINED3DFOG_EXP2:
2201	settings->fog = FOG_EXP2;
2202	break;
2203	}
2204	}
2205	} else {
2206	switch(stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
2207	case WINED3DFOG_LINEAR:
2208	settings->fog = FOG_LINEAR;
2209	break;
2210	case WINED3DFOG_EXP:
2211	settings->fog = FOG_EXP;
2212	break;
2213	case WINED3DFOG_EXP2:
2214	settings->fog = FOG_EXP2;
2215	break;
2216	}
2217	}
2218	if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
2219	settings->sRGB_write = 1;
2220	} else {
2221	settings->sRGB_write = 0;
2222	}
2223	}
2224	#undef GLINFO_LOCATION
2225
2226	const struct ffp_frag_desc find_ffp_frag_shader(const struct wine_rb_tree fragment_shaders,
2227	const struct ffp_frag_settings *settings)
2228	{
2229	struct wine_rb_entry *entry = wine_rb_get(fragment_shaders, settings);
2230	return entry ? WINE_RB_ENTRY_VALUE(entry, struct ffp_frag_desc, entry) : NULL;
2231	}
2232
2233	void add_ffp_frag_shader(struct wine_rb_tree shaders, struct ffp_frag_desc desc)
2234	{
2235	/* Note that the key is the implementation independent part of the ffp_frag_desc structure,
2236	* whereas desc points to an extended structure with implementation specific parts. */
2237	if (wine_rb_put(shaders, &desc->settings, &desc->entry) == -1)
2238	{
2239	ERR("Failed to insert ffp frag shader.\n");
2240	}
2241	}
2242
2243	/* Activates the texture dimension according to the bound D3D texture.
2244	* Does not care for the colorop or correct gl texture unit(when using nvrc)
2245	* Requires the caller to activate the correct unit before
2246	*/
2247	#define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
2248	/* GL locking is done by the caller (state handler) */
2249	void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
2250	if(stateblock->textures[stage]) {
2251	switch (IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[stage])) {
2252	case GL_TEXTURE_2D:
2253	glDisable(GL_TEXTURE_3D);
2254	checkGLcall("glDisable(GL_TEXTURE_3D)");
2255	if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2256	glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2257	checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2258	}
2259	if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2260	glDisable(GL_TEXTURE_RECTANGLE_ARB);
2261	checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2262	}
2263	glEnable(GL_TEXTURE_2D);
2264	checkGLcall("glEnable(GL_TEXTURE_2D)");
2265	break;
2266	case GL_TEXTURE_RECTANGLE_ARB:
2267	glDisable(GL_TEXTURE_2D);
2268	checkGLcall("glDisable(GL_TEXTURE_2D)");
2269	glDisable(GL_TEXTURE_3D);
2270	checkGLcall("glDisable(GL_TEXTURE_3D)");
2271	if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2272	glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2273	checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2274	}
2275	glEnable(GL_TEXTURE_RECTANGLE_ARB);
2276	checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2277	break;
2278	case GL_TEXTURE_3D:
2279	if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2280	glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2281	checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2282	}
2283	if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2284	glDisable(GL_TEXTURE_RECTANGLE_ARB);
2285	checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2286	}
2287	glDisable(GL_TEXTURE_2D);
2288	checkGLcall("glDisable(GL_TEXTURE_2D)");
2289	glEnable(GL_TEXTURE_3D);
2290	checkGLcall("glEnable(GL_TEXTURE_3D)");
2291	break;
2292	case GL_TEXTURE_CUBE_MAP_ARB:
2293	glDisable(GL_TEXTURE_2D);
2294	checkGLcall("glDisable(GL_TEXTURE_2D)");
2295	glDisable(GL_TEXTURE_3D);
2296	checkGLcall("glDisable(GL_TEXTURE_3D)");
2297	if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2298	glDisable(GL_TEXTURE_RECTANGLE_ARB);
2299	checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2300	}
2301	glEnable(GL_TEXTURE_CUBE_MAP_ARB);
2302	checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2303	break;
2304	}
2305	} else {
2306	glEnable(GL_TEXTURE_2D);
2307	checkGLcall("glEnable(GL_TEXTURE_2D)");
2308	glDisable(GL_TEXTURE_3D);
2309	checkGLcall("glDisable(GL_TEXTURE_3D)");
2310	if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2311	glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2312	checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2313	}
2314	if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2315	glDisable(GL_TEXTURE_RECTANGLE_ARB);
2316	checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2317	}
2318	/* Binding textures is done by samplers. A dummy texture will be bound */
2319	}
2320	}
2321
2322	/* GL locking is done by the caller (state handler) */
2323	void sampler_texdim(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
2324	DWORD sampler = state - STATE_SAMPLER(0);
2325	DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
2326
2327	/* No need to enable / disable anything here for unused samplers. The tex_colorop
2328	* handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
2329	* will take care of this business
2330	*/
2331	if(mapped_stage == WINED3D_UNMAPPED_STAGE \|\| mapped_stage >= GL_LIMITS(textures)) return;
2332	if(sampler >= stateblock->lowest_disabled_stage) return;
2333	if(isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) return;
2334
2335	texture_activate_dimensions(sampler, stateblock, context);
2336	}
2337	#undef GLINFO_LOCATION
2338
2339	void *wined3d_rb_alloc(size_t size)
2340	{
2341	return HeapAlloc(GetProcessHeap(), 0, size);
2342	}
2343
2344	void wined3d_rb_realloc(void ptr, size_t size)
2345	{
2346	return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
2347	}
2348
2349	void wined3d_rb_free(void *ptr)
2350	{
2351	HeapFree(GetProcessHeap(), 0, ptr);
2352	}
2353
2354	static int ffp_frag_program_key_compare(const void key, const struct wine_rb_entry entry)
2355	{
2356	const struct ffp_frag_settings *ka = key;
2357	const struct ffp_frag_settings *kb = &WINE_RB_ENTRY_VALUE(entry, const struct ffp_frag_desc, entry)->settings;
2358
2359	return memcmp(ka, kb, sizeof(*ka));
2360	}
2361
2362	const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions =
2363	{
2364	wined3d_rb_alloc,
2365	wined3d_rb_realloc,
2366	wined3d_rb_free,
2367	ffp_frag_program_key_compare,
2368	};
2369
2370	UINT wined3d_log2i(UINT32 x)
2371	{
2372	static const BYTE l[] =
2373	{
2374	0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
2375	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2376	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2377	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2378	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2379	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2380	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2381	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2382	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2383	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2384	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2385	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2386	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2387	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2388	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2389	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2390	};
2391	UINT32 i;
2392
2393	return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
2394	}

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

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/utils.c@ 20817

Download in other formats: