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