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