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