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