?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 6e61d6ca5bcaf95ac09a664b4ba4f88238c927be
[wine/hacks.git] / dlls / wined3d / utils.c
blob2ff16752c33509f19e94d23bf660edc014b9c272
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, GL_RGB16, GL_RGBA16,
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, GL_RGBA16, 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, GL_RGB16, 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, GL_LUMINANCE16, 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 == HW_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_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
1092
1093 idx = getFmtIdx(WINED3DFMT_UYVY);
1094 gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_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_complex_fixup_desc(COMPLEX_FIXUP_YV12);
1100
1101 idx = getFmtIdx(WINED3DFMT_P8_UINT);
1102 gl_info->gl_formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
1103
1104 if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
1105 {
1106 idx = getFmtIdx(WINED3DFMT_B8G8R8A8_UNORM);
1107 gl_info->gl_formats[idx].gl_vtx_format = GL_BGRA;
1108 }
1109
1110 if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
1111 {
1112 /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
1113 * It is the job of the vertex buffer code to make sure that the vbos have the right format */
1114 idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1115 gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT; /* == GL_HALF_FLOAT_NV */
1116
1117 idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
1118 gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT;
1119 }
1120 }
1121
1122 static BOOL init_format_vertex_info(struct wined3d_gl_info *gl_info)
1123 {
1124 unsigned int i;
1125
1126 for (i = 0; i < (sizeof(format_vertex_info) / sizeof(*format_vertex_info)); ++i)
1127 {
1128 struct GlPixelFormatDesc *format_desc;
1129 int fmt_idx = getFmtIdx(format_vertex_info[i].format);
1130
1131 if (fmt_idx == -1)
1132 {
1133 ERR("Format %s (%#x) not found.\n",
1134 debug_d3dformat(format_vertex_info[i].format), format_vertex_info[i].format);
1135 return FALSE;
1136 }
1137
1138 format_desc = &gl_info->gl_formats[fmt_idx];
1139 format_desc->emit_idx = format_vertex_info[i].emit_idx;
1140 format_desc->component_count = format_vertex_info[i].component_count;
1141 format_desc->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
1142 format_desc->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
1143 format_desc->gl_normalized = format_vertex_info[i].gl_normalized;
1144 format_desc->component_size = format_vertex_info[i].component_size;
1145 }
1146
1147 return TRUE;
1148 }
1149
1150 BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info)
1151 {
1152 if (!init_format_base_info(gl_info)) return FALSE;
1153
1154 if (!init_format_compression_info(gl_info))
1155 {
1156 HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
1157 gl_info->gl_formats = NULL;
1158 return FALSE;
1159 }
1160
1161 return TRUE;
1162 }
1163
1164 /* Context activation is done by the caller. */
1165 BOOL initPixelFormats(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
1166 {
1167 if (!init_format_base_info(gl_info)) return FALSE;
1168
1169 if (!init_format_compression_info(gl_info)) goto fail;
1170 if (!init_format_texture_info(gl_info)) goto fail;
1171 if (!init_format_vertex_info(gl_info)) goto fail;
1172
1173 apply_format_fixups(gl_info);
1174 init_format_fbo_compat_info(gl_info);
1175 init_format_filter_info(gl_info, vendor);
1176
1177 return TRUE;
1178
1179 fail:
1180 HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
1181 gl_info->gl_formats = NULL;
1182 return FALSE;
1183 }
1184
1185 const struct GlPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, const struct wined3d_gl_info *gl_info)
1186 {
1187 int idx = getFmtIdx(fmt);
1188
1189 if(idx == -1) {
1190 FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
1191 /* Get the caller a valid pointer */
1192 idx = getFmtIdx(WINED3DFMT_UNKNOWN);
1193 }
1194
1195 return &gl_info->gl_formats[idx];
1196 }
1197
1198 /*****************************************************************************
1199 * Trace formatting of useful values
1200 */
1201 const char* debug_d3dformat(WINED3DFORMAT fmt) {
1202 switch (fmt) {
1203 #define FMT_TO_STR(fmt) case fmt: return #fmt
1204 FMT_TO_STR(WINED3DFMT_UNKNOWN);
1205 FMT_TO_STR(WINED3DFMT_B8G8R8_UNORM);
1206 FMT_TO_STR(WINED3DFMT_B5G5R5X1_UNORM);
1207 FMT_TO_STR(WINED3DFMT_B4G4R4A4_UNORM);
1208 FMT_TO_STR(WINED3DFMT_B2G3R3_UNORM);
1209 FMT_TO_STR(WINED3DFMT_B2G3R3A8_UNORM);
1210 FMT_TO_STR(WINED3DFMT_B4G4R4X4_UNORM);
1211 FMT_TO_STR(WINED3DFMT_R8G8B8X8_UNORM);
1212 FMT_TO_STR(WINED3DFMT_B10G10R10A2_UNORM);
1213 FMT_TO_STR(WINED3DFMT_P8_UINT_A8_UNORM);
1214 FMT_TO_STR(WINED3DFMT_P8_UINT);
1215 FMT_TO_STR(WINED3DFMT_L8_UNORM);
1216 FMT_TO_STR(WINED3DFMT_L8A8_UNORM);
1217 FMT_TO_STR(WINED3DFMT_L4A4_UNORM);
1218 FMT_TO_STR(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1219 FMT_TO_STR(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1220 FMT_TO_STR(WINED3DFMT_R10G11B11_SNORM);
1221 FMT_TO_STR(WINED3DFMT_R10G10B10_SNORM_A2_UNORM);
1222 FMT_TO_STR(WINED3DFMT_UYVY);
1223 FMT_TO_STR(WINED3DFMT_YUY2);
1224 FMT_TO_STR(WINED3DFMT_YV12);
1225 FMT_TO_STR(WINED3DFMT_DXT1);
1226 FMT_TO_STR(WINED3DFMT_DXT2);
1227 FMT_TO_STR(WINED3DFMT_DXT3);
1228 FMT_TO_STR(WINED3DFMT_DXT4);
1229 FMT_TO_STR(WINED3DFMT_DXT5);
1230 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
1231 FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
1232 FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
1233 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
1234 FMT_TO_STR(WINED3DFMT_D32_UNORM);
1235 FMT_TO_STR(WINED3DFMT_S1_UINT_D15_UNORM);
1236 FMT_TO_STR(WINED3DFMT_X8D24_UNORM);
1237 FMT_TO_STR(WINED3DFMT_S4X4_UINT_D24_UNORM);
1238 FMT_TO_STR(WINED3DFMT_L16_UNORM);
1239 FMT_TO_STR(WINED3DFMT_S8_UINT_D24_FLOAT);
1240 FMT_TO_STR(WINED3DFMT_VERTEXDATA);
1241 FMT_TO_STR(WINED3DFMT_R8G8_SNORM_Cx);
1242 FMT_TO_STR(WINED3DFMT_ATI2N);
1243 FMT_TO_STR(WINED3DFMT_NVHU);
1244 FMT_TO_STR(WINED3DFMT_NVHS);
1245 FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS);
1246 FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT);
1247 FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT);
1248 FMT_TO_STR(WINED3DFMT_R32G32B32A32_SINT);
1249 FMT_TO_STR(WINED3DFMT_R32G32B32_TYPELESS);
1250 FMT_TO_STR(WINED3DFMT_R32G32B32_FLOAT);
1251 FMT_TO_STR(WINED3DFMT_R32G32B32_UINT);
1252 FMT_TO_STR(WINED3DFMT_R32G32B32_SINT);
1253 FMT_TO_STR(WINED3DFMT_R16G16B16A16_TYPELESS);
1254 FMT_TO_STR(WINED3DFMT_R16G16B16A16_FLOAT);
1255 FMT_TO_STR(WINED3DFMT_R16G16B16A16_UNORM);
1256 FMT_TO_STR(WINED3DFMT_R16G16B16A16_UINT);
1257 FMT_TO_STR(WINED3DFMT_R16G16B16A16_SNORM);
1258 FMT_TO_STR(WINED3DFMT_R16G16B16A16_SINT);
1259 FMT_TO_STR(WINED3DFMT_R32G32_TYPELESS);
1260 FMT_TO_STR(WINED3DFMT_R32G32_FLOAT);
1261 FMT_TO_STR(WINED3DFMT_R32G32_UINT);
1262 FMT_TO_STR(WINED3DFMT_R32G32_SINT);
1263 FMT_TO_STR(WINED3DFMT_R32G8X24_TYPELESS);
1264 FMT_TO_STR(WINED3DFMT_D32_FLOAT_S8X24_UINT);
1265 FMT_TO_STR(WINED3DFMT_R32_FLOAT_X8X24_TYPELESS);
1266 FMT_TO_STR(WINED3DFMT_X32_TYPELESS_G8X24_UINT);
1267 FMT_TO_STR(WINED3DFMT_R10G10B10A2_TYPELESS);
1268 FMT_TO_STR(WINED3DFMT_R10G10B10A2_UNORM);
1269 FMT_TO_STR(WINED3DFMT_R10G10B10A2_UINT);
1270 FMT_TO_STR(WINED3DFMT_R10G10B10A2_SNORM);
1271 FMT_TO_STR(WINED3DFMT_R11G11B10_FLOAT);
1272 FMT_TO_STR(WINED3DFMT_R8G8B8A8_TYPELESS);
1273 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM);
1274 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM_SRGB);
1275 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UINT);
1276 FMT_TO_STR(WINED3DFMT_R8G8B8A8_SNORM);
1277 FMT_TO_STR(WINED3DFMT_R8G8B8A8_SINT);
1278 FMT_TO_STR(WINED3DFMT_R16G16_TYPELESS);
1279 FMT_TO_STR(WINED3DFMT_R16G16_FLOAT);
1280 FMT_TO_STR(WINED3DFMT_R16G16_UNORM);
1281 FMT_TO_STR(WINED3DFMT_R16G16_UINT);
1282 FMT_TO_STR(WINED3DFMT_R16G16_SNORM);
1283 FMT_TO_STR(WINED3DFMT_R16G16_SINT);
1284 FMT_TO_STR(WINED3DFMT_R32_TYPELESS);
1285 FMT_TO_STR(WINED3DFMT_D32_FLOAT);
1286 FMT_TO_STR(WINED3DFMT_R32_FLOAT);
1287 FMT_TO_STR(WINED3DFMT_R32_UINT);
1288 FMT_TO_STR(WINED3DFMT_R32_SINT);
1289 FMT_TO_STR(WINED3DFMT_R24G8_TYPELESS);
1290 FMT_TO_STR(WINED3DFMT_D24_UNORM_S8_UINT);
1291 FMT_TO_STR(WINED3DFMT_R24_UNORM_X8_TYPELESS);
1292 FMT_TO_STR(WINED3DFMT_X24_TYPELESS_G8_UINT);
1293 FMT_TO_STR(WINED3DFMT_R8G8_TYPELESS);
1294 FMT_TO_STR(WINED3DFMT_R8G8_UNORM);
1295 FMT_TO_STR(WINED3DFMT_R8G8_UINT);
1296 FMT_TO_STR(WINED3DFMT_R8G8_SNORM);
1297 FMT_TO_STR(WINED3DFMT_R8G8_SINT);
1298 FMT_TO_STR(WINED3DFMT_R16_TYPELESS);
1299 FMT_TO_STR(WINED3DFMT_R16_FLOAT);
1300 FMT_TO_STR(WINED3DFMT_D16_UNORM);
1301 FMT_TO_STR(WINED3DFMT_R16_UNORM);
1302 FMT_TO_STR(WINED3DFMT_R16_UINT);
1303 FMT_TO_STR(WINED3DFMT_R16_SNORM);
1304 FMT_TO_STR(WINED3DFMT_R16_SINT);
1305 FMT_TO_STR(WINED3DFMT_R8_TYPELESS);
1306 FMT_TO_STR(WINED3DFMT_R8_UNORM);
1307 FMT_TO_STR(WINED3DFMT_R8_UINT);
1308 FMT_TO_STR(WINED3DFMT_R8_SNORM);
1309 FMT_TO_STR(WINED3DFMT_R8_SINT);
1310 FMT_TO_STR(WINED3DFMT_A8_UNORM);
1311 FMT_TO_STR(WINED3DFMT_R1_UNORM);
1312 FMT_TO_STR(WINED3DFMT_R9G9B9E5_SHAREDEXP);
1313 FMT_TO_STR(WINED3DFMT_R8G8_B8G8_UNORM);
1314 FMT_TO_STR(WINED3DFMT_G8R8_G8B8_UNORM);
1315 FMT_TO_STR(WINED3DFMT_BC1_TYPELESS);
1316 FMT_TO_STR(WINED3DFMT_BC1_UNORM);
1317 FMT_TO_STR(WINED3DFMT_BC1_UNORM_SRGB);
1318 FMT_TO_STR(WINED3DFMT_BC2_TYPELESS);
1319 FMT_TO_STR(WINED3DFMT_BC2_UNORM);
1320 FMT_TO_STR(WINED3DFMT_BC2_UNORM_SRGB);
1321 FMT_TO_STR(WINED3DFMT_BC3_TYPELESS);
1322 FMT_TO_STR(WINED3DFMT_BC3_UNORM);
1323 FMT_TO_STR(WINED3DFMT_BC3_UNORM_SRGB);
1324 FMT_TO_STR(WINED3DFMT_BC4_TYPELESS);
1325 FMT_TO_STR(WINED3DFMT_BC4_UNORM);
1326 FMT_TO_STR(WINED3DFMT_BC4_SNORM);
1327 FMT_TO_STR(WINED3DFMT_BC5_TYPELESS);
1328 FMT_TO_STR(WINED3DFMT_BC5_UNORM);
1329 FMT_TO_STR(WINED3DFMT_BC5_SNORM);
1330 FMT_TO_STR(WINED3DFMT_B5G6R5_UNORM);
1331 FMT_TO_STR(WINED3DFMT_B5G5R5A1_UNORM);
1332 FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM);
1333 FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM);
1334 #undef FMT_TO_STR
1335 default:
1336 {
1337 char fourcc[5];
1338 fourcc[0] = (char)(fmt);
1339 fourcc[1] = (char)(fmt >> 8);
1340 fourcc[2] = (char)(fmt >> 16);
1341 fourcc[3] = (char)(fmt >> 24);
1342 fourcc[4] = 0;
1343 if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
1344 FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
1345 else
1346 FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
1347 }
1348 return "unrecognized";
1349 }
1350 }
1351
1352 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
1353 switch (devtype) {
1354 #define DEVTYPE_TO_STR(dev) case dev: return #dev
1355 DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
1356 DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
1357 DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
1358 #undef DEVTYPE_TO_STR
1359 default:
1360 FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
1361 return "unrecognized";
1362 }
1363 }
1364
1365 const char *debug_d3dusage(DWORD usage)
1366 {
1367 char buf[284];
1368
1369 buf[0] = '\0';
1370 #define WINED3DUSAGE_TO_STR(u) if (usage & u) { strcat(buf, " | "#u); usage &= ~u; }
1371 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
1372 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
1373 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
1374 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
1375 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
1376 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
1377 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
1378 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
1379 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
1380 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
1381 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
1382 #undef WINED3DUSAGE_TO_STR
1383 if (usage) FIXME("Unrecognized usage flag(s) %#x\n", usage);
1384
1385 return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1386 }
1387
1388 const char *debug_d3dusagequery(DWORD usagequery)
1389 {
1390 char buf[238];
1391
1392 buf[0] = '\0';
1393 #define WINED3DUSAGEQUERY_TO_STR(u) if (usagequery & u) { strcat(buf, " | "#u); usagequery &= ~u; }
1394 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
1395 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
1396 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
1397 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
1398 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
1399 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
1400 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
1401 #undef WINED3DUSAGEQUERY_TO_STR
1402 if (usagequery) FIXME("Unrecognized usage query flag(s) %#x\n", usagequery);
1403
1404 return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1405 }
1406
1407 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
1408 switch (method) {
1409 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
1410 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
1411 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
1412 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
1413 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
1414 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
1415 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
1416 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
1417 #undef WINED3DDECLMETHOD_TO_STR
1418 default:
1419 FIXME("Unrecognized %u declaration method!\n", method);
1420 return "unrecognized";
1421 }
1422 }
1423
1424 const char* debug_d3ddeclusage(BYTE usage) {
1425 switch (usage) {
1426 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
1427 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
1428 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
1429 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
1430 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
1431 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
1432 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
1433 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
1434 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
1435 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
1436 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
1437 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
1438 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
1439 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
1440 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
1441 #undef WINED3DDECLUSAGE_TO_STR
1442 default:
1443 FIXME("Unrecognized %u declaration usage!\n", usage);
1444 return "unrecognized";
1445 }
1446 }
1447
1448 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
1449 switch (res) {
1450 #define RES_TO_STR(res) case res: return #res
1451 RES_TO_STR(WINED3DRTYPE_SURFACE);
1452 RES_TO_STR(WINED3DRTYPE_VOLUME);
1453 RES_TO_STR(WINED3DRTYPE_TEXTURE);
1454 RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
1455 RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
1456 RES_TO_STR(WINED3DRTYPE_BUFFER);
1457 #undef RES_TO_STR
1458 default:
1459 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
1460 return "unrecognized";
1461 }
1462 }
1463
1464 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
1465 switch (PrimitiveType) {
1466 #define PRIM_TO_STR(prim) case prim: return #prim
1467 PRIM_TO_STR(WINED3DPT_UNDEFINED);
1468 PRIM_TO_STR(WINED3DPT_POINTLIST);
1469 PRIM_TO_STR(WINED3DPT_LINELIST);
1470 PRIM_TO_STR(WINED3DPT_LINESTRIP);
1471 PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
1472 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
1473 PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
1474 PRIM_TO_STR(WINED3DPT_LINELIST_ADJ);
1475 PRIM_TO_STR(WINED3DPT_LINESTRIP_ADJ);
1476 PRIM_TO_STR(WINED3DPT_TRIANGLELIST_ADJ);
1477 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP_ADJ);
1478 #undef PRIM_TO_STR
1479 default:
1480 FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
1481 return "unrecognized";
1482 }
1483 }
1484
1485 const char* debug_d3drenderstate(DWORD state) {
1486 switch (state) {
1487 #define D3DSTATE_TO_STR(u) case u: return #u
1488 D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE );
1489 D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS );
1490 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS );
1491 D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE );
1492 D3DSTATE_TO_STR(WINED3DRS_WRAPU );
1493 D3DSTATE_TO_STR(WINED3DRS_WRAPV );
1494 D3DSTATE_TO_STR(WINED3DRS_ZENABLE );
1495 D3DSTATE_TO_STR(WINED3DRS_FILLMODE );
1496 D3DSTATE_TO_STR(WINED3DRS_SHADEMODE );
1497 D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN );
1498 D3DSTATE_TO_STR(WINED3DRS_MONOENABLE );
1499 D3DSTATE_TO_STR(WINED3DRS_ROP2 );
1500 D3DSTATE_TO_STR(WINED3DRS_PLANEMASK );
1501 D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE );
1502 D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE );
1503 D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL );
1504 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG );
1505 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN );
1506 D3DSTATE_TO_STR(WINED3DRS_SRCBLEND );
1507 D3DSTATE_TO_STR(WINED3DRS_DESTBLEND );
1508 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND );
1509 D3DSTATE_TO_STR(WINED3DRS_CULLMODE );
1510 D3DSTATE_TO_STR(WINED3DRS_ZFUNC );
1511 D3DSTATE_TO_STR(WINED3DRS_ALPHAREF );
1512 D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC );
1513 D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE );
1514 D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE );
1515 D3DSTATE_TO_STR(WINED3DRS_FOGENABLE );
1516 D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE );
1517 D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE );
1518 D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL );
1519 D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX );
1520 D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA );
1521 D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR );
1522 D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE );
1523 D3DSTATE_TO_STR(WINED3DRS_FOGSTART );
1524 D3DSTATE_TO_STR(WINED3DRS_FOGEND );
1525 D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY );
1526 D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE );
1527 D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS );
1528 D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE );
1529 D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR );
1530 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU );
1531 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV );
1532 D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS );
1533 D3DSTATE_TO_STR(WINED3DRS_ZBIAS );
1534 D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE );
1535 D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY );
1536 D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH );
1537 D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
1538 D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE );
1539 D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL );
1540 D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL );
1541 D3DSTATE_TO_STR(WINED3DRS_STENCILPASS );
1542 D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC );
1543 D3DSTATE_TO_STR(WINED3DRS_STENCILREF );
1544 D3DSTATE_TO_STR(WINED3DRS_STENCILMASK );
1545 D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK );
1546 D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR );
1547 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00 );
1548 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01 );
1549 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02 );
1550 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03 );
1551 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04 );
1552 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05 );
1553 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06 );
1554 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07 );
1555 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08 );
1556 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09 );
1557 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10 );
1558 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11 );
1559 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12 );
1560 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13 );
1561 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14 );
1562 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15 );
1563 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16 );
1564 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17 );
1565 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18 );
1566 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19 );
1567 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20 );
1568 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21 );
1569 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22 );
1570 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23 );
1571 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24 );
1572 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25 );
1573 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26 );
1574 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27 );
1575 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28 );
1576 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29 );
1577 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30 );
1578 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31 );
1579 D3DSTATE_TO_STR(WINED3DRS_WRAP0 );
1580 D3DSTATE_TO_STR(WINED3DRS_WRAP1 );
1581 D3DSTATE_TO_STR(WINED3DRS_WRAP2 );
1582 D3DSTATE_TO_STR(WINED3DRS_WRAP3 );
1583 D3DSTATE_TO_STR(WINED3DRS_WRAP4 );
1584 D3DSTATE_TO_STR(WINED3DRS_WRAP5 );
1585 D3DSTATE_TO_STR(WINED3DRS_WRAP6 );
1586 D3DSTATE_TO_STR(WINED3DRS_WRAP7 );
1587 D3DSTATE_TO_STR(WINED3DRS_CLIPPING );
1588 D3DSTATE_TO_STR(WINED3DRS_LIGHTING );
1589 D3DSTATE_TO_STR(WINED3DRS_EXTENTS );
1590 D3DSTATE_TO_STR(WINED3DRS_AMBIENT );
1591 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE );
1592 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX );
1593 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER );
1594 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS );
1595 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE );
1596 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE );
1597 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE );
1598 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE );
1599 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE );
1600 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND );
1601 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE );
1602 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING );
1603 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE );
1604 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN );
1605 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE );
1606 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE );
1607 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A );
1608 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B );
1609 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C );
1610 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS );
1611 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK );
1612 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE );
1613 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS );
1614 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN );
1615 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX );
1616 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE );
1617 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE );
1618 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR );
1619 D3DSTATE_TO_STR(WINED3DRS_BLENDOP );
1620 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE );
1621 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE );
1622 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE );
1623 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS );
1624 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE );
1625 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL );
1626 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL );
1627 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X );
1628 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y );
1629 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z );
1630 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W );
1631 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
1632 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE );
1633 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL );
1634 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL );
1635 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS );
1636 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC );
1637 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1 );
1638 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2 );
1639 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3 );
1640 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR );
1641 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE );
1642 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS );
1643 D3DSTATE_TO_STR(WINED3DRS_WRAP8 );
1644 D3DSTATE_TO_STR(WINED3DRS_WRAP9 );
1645 D3DSTATE_TO_STR(WINED3DRS_WRAP10 );
1646 D3DSTATE_TO_STR(WINED3DRS_WRAP11 );
1647 D3DSTATE_TO_STR(WINED3DRS_WRAP12 );
1648 D3DSTATE_TO_STR(WINED3DRS_WRAP13 );
1649 D3DSTATE_TO_STR(WINED3DRS_WRAP14 );
1650 D3DSTATE_TO_STR(WINED3DRS_WRAP15 );
1651 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE );
1652 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA );
1653 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA );
1654 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA );
1655 #undef D3DSTATE_TO_STR
1656 default:
1657 FIXME("Unrecognized %u render state!\n", state);
1658 return "unrecognized";
1659 }
1660 }
1661
1662 const char* debug_d3dsamplerstate(DWORD state) {
1663 switch (state) {
1664 #define D3DSTATE_TO_STR(u) case u: return #u
1665 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR );
1666 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU );
1667 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV );
1668 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW );
1669 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER );
1670 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER );
1671 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER );
1672 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
1673 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL );
1674 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
1675 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE );
1676 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
1677 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET );
1678 #undef D3DSTATE_TO_STR
1679 default:
1680 FIXME("Unrecognized %u sampler state!\n", state);
1681 return "unrecognized";
1682 }
1683 }
1684
1685 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
1686 switch (filter_type) {
1687 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
1688 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
1689 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
1690 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
1691 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
1692 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
1693 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
1694 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
1695 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
1696 #undef D3DTEXTUREFILTERTYPE_TO_STR
1697 default:
1698 FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
1699 return "unrecognized";
1700 }
1701 }
1702
1703 const char* debug_d3dtexturestate(DWORD state) {
1704 switch (state) {
1705 #define D3DSTATE_TO_STR(u) case u: return #u
1706 D3DSTATE_TO_STR(WINED3DTSS_COLOROP );
1707 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1 );
1708 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2 );
1709 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP );
1710 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1 );
1711 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2 );
1712 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00 );
1713 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01 );
1714 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10 );
1715 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11 );
1716 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX );
1717 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE );
1718 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET );
1719 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
1720 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0 );
1721 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0 );
1722 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG );
1723 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT );
1724 #undef D3DSTATE_TO_STR
1725 default:
1726 FIXME("Unrecognized %u texture state!\n", state);
1727 return "unrecognized";
1728 }
1729 }
1730
1731 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
1732 switch (d3dtop) {
1733 #define D3DTOP_TO_STR(u) case u: return #u
1734 D3DTOP_TO_STR(WINED3DTOP_DISABLE);
1735 D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
1736 D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
1737 D3DTOP_TO_STR(WINED3DTOP_MODULATE);
1738 D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
1739 D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
1740 D3DTOP_TO_STR(WINED3DTOP_ADD);
1741 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
1742 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
1743 D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
1744 D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
1745 D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
1746 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
1747 D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
1748 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
1749 D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
1750 D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
1751 D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
1752 D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
1753 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
1754 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
1755 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
1756 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
1757 D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
1758 D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
1759 D3DTOP_TO_STR(WINED3DTOP_LERP);
1760 #undef D3DTOP_TO_STR
1761 default:
1762 FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
1763 return "unrecognized";
1764 }
1765 }
1766
1767 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
1768 switch (tstype) {
1769 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
1770 TSTYPE_TO_STR(WINED3DTS_VIEW);
1771 TSTYPE_TO_STR(WINED3DTS_PROJECTION);
1772 TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
1773 TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
1774 TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
1775 TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
1776 TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
1777 TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
1778 TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
1779 TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
1780 TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
1781 #undef TSTYPE_TO_STR
1782 default:
1783 if (tstype > 256 && tstype < 512) {
1784 FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
1785 return ("WINED3DTS_WORLDMATRIX > 0");
1786 }
1787 FIXME("Unrecognized %u WINED3DTS\n", tstype);
1788 return "unrecognized";
1789 }
1790 }
1791
1792 const char *debug_d3dstate(DWORD state)
1793 {
1794 if (STATE_IS_RENDER(state))
1795 return wine_dbg_sprintf("STATE_RENDER(%s)", debug_d3drenderstate(state - STATE_RENDER(0)));
1796 if (STATE_IS_TEXTURESTAGE(state))
1797 {
1798 DWORD texture_stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
1799 DWORD texture_state = state - STATE_TEXTURESTAGE(texture_stage, 0);
1800 return wine_dbg_sprintf("STATE_TEXTURESTAGE(%#x, %s)",
1801 texture_stage, debug_d3dtexturestate(texture_state));
1802 }
1803 if (STATE_IS_SAMPLER(state))
1804 return wine_dbg_sprintf("STATE_SAMPLER(%#x)", state - STATE_SAMPLER(0));
1805 if (STATE_IS_PIXELSHADER(state))
1806 return "STATE_PIXELSHADER";
1807 if (STATE_IS_TRANSFORM(state))
1808 return wine_dbg_sprintf("STATE_TRANSFORM(%s)", debug_d3dtstype(state - STATE_TRANSFORM(0)));
1809 if (STATE_IS_STREAMSRC(state))
1810 return "STATE_STREAMSRC";
1811 if (STATE_IS_INDEXBUFFER(state))
1812 return "STATE_INDEXBUFFER";
1813 if (STATE_IS_VDECL(state))
1814 return "STATE_VDECL";
1815 if (STATE_IS_VSHADER(state))
1816 return "STATE_VSHADER";
1817 if (STATE_IS_VIEWPORT(state))
1818 return "STATE_VIEWPORT";
1819 if (STATE_IS_VERTEXSHADERCONSTANT(state))
1820 return "STATE_VERTEXSHADERCONSTANT";
1821 if (STATE_IS_PIXELSHADERCONSTANT(state))
1822 return "STATE_PIXELSHADERCONSTANT";
1823 if (STATE_IS_ACTIVELIGHT(state))
1824 return wine_dbg_sprintf("STATE_ACTIVELIGHT(%#x)", state - STATE_ACTIVELIGHT(0));
1825 if (STATE_IS_SCISSORRECT(state))
1826 return "STATE_SCISSORRECT";
1827 if (STATE_IS_CLIPPLANE(state))
1828 return wine_dbg_sprintf("STATE_CLIPPLANE(%#x)", state - STATE_CLIPPLANE(0));
1829 if (STATE_IS_MATERIAL(state))
1830 return "STATE_MATERIAL";
1831 if (STATE_IS_FRONTFACE(state))
1832 return "STATE_FRONTFACE";
1833
1834 return wine_dbg_sprintf("UNKNOWN_STATE(%#x)", state);
1835 }
1836
1837 const char* debug_d3dpool(WINED3DPOOL Pool) {
1838 switch (Pool) {
1839 #define POOL_TO_STR(p) case p: return #p
1840 POOL_TO_STR(WINED3DPOOL_DEFAULT);
1841 POOL_TO_STR(WINED3DPOOL_MANAGED);
1842 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
1843 POOL_TO_STR(WINED3DPOOL_SCRATCH);
1844 #undef POOL_TO_STR
1845 default:
1846 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
1847 return "unrecognized";
1848 }
1849 }
1850
1851 const char *debug_fbostatus(GLenum status) {
1852 switch(status) {
1853 #define FBOSTATUS_TO_STR(u) case u: return #u
1854 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE);
1855 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
1856 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
1857 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
1858 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
1859 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
1860 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
1861 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
1862 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED);
1863 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNDEFINED);
1864 #undef FBOSTATUS_TO_STR
1865 default:
1866 FIXME("Unrecognied FBO status 0x%08x\n", status);
1867 return "unrecognized";
1868 }
1869 }
1870
1871 const char *debug_glerror(GLenum error) {
1872 switch(error) {
1873 #define GLERROR_TO_STR(u) case u: return #u
1874 GLERROR_TO_STR(GL_NO_ERROR);
1875 GLERROR_TO_STR(GL_INVALID_ENUM);
1876 GLERROR_TO_STR(GL_INVALID_VALUE);
1877 GLERROR_TO_STR(GL_INVALID_OPERATION);
1878 GLERROR_TO_STR(GL_STACK_OVERFLOW);
1879 GLERROR_TO_STR(GL_STACK_UNDERFLOW);
1880 GLERROR_TO_STR(GL_OUT_OF_MEMORY);
1881 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION);
1882 #undef GLERROR_TO_STR
1883 default:
1884 FIXME("Unrecognied GL error 0x%08x\n", error);
1885 return "unrecognized";
1886 }
1887 }
1888
1889 const char *debug_d3dbasis(WINED3DBASISTYPE basis) {
1890 switch(basis) {
1891 case WINED3DBASIS_BEZIER: return "WINED3DBASIS_BEZIER";
1892 case WINED3DBASIS_BSPLINE: return "WINED3DBASIS_BSPLINE";
1893 case WINED3DBASIS_INTERPOLATE: return "WINED3DBASIS_INTERPOLATE";
1894 default: return "unrecognized";
1895 }
1896 }
1897
1898 const char *debug_d3ddegree(WINED3DDEGREETYPE degree) {
1899 switch(degree) {
1900 case WINED3DDEGREE_LINEAR: return "WINED3DDEGREE_LINEAR";
1901 case WINED3DDEGREE_QUADRATIC: return "WINED3DDEGREE_QUADRATIC";
1902 case WINED3DDEGREE_CUBIC: return "WINED3DDEGREE_CUBIC";
1903 case WINED3DDEGREE_QUINTIC: return "WINED3DDEGREE_QUINTIC";
1904 default: return "unrecognized";
1905 }
1906 }
1907
1908 static const char *debug_fixup_channel_source(enum fixup_channel_source source)
1909 {
1910 switch(source)
1911 {
1912 #define WINED3D_TO_STR(x) case x: return #x
1913 WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
1914 WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
1915 WINED3D_TO_STR(CHANNEL_SOURCE_X);
1916 WINED3D_TO_STR(CHANNEL_SOURCE_Y);
1917 WINED3D_TO_STR(CHANNEL_SOURCE_Z);
1918 WINED3D_TO_STR(CHANNEL_SOURCE_W);
1919 WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX0);
1920 WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX1);
1921 #undef WINED3D_TO_STR
1922 default:
1923 FIXME("Unrecognized fixup_channel_source %#x\n", source);
1924 return "unrecognized";
1925 }
1926 }
1927
1928 static const char *debug_complex_fixup(enum complex_fixup fixup)
1929 {
1930 switch(fixup)
1931 {
1932 #define WINED3D_TO_STR(x) case x: return #x
1933 WINED3D_TO_STR(COMPLEX_FIXUP_YUY2);
1934 WINED3D_TO_STR(COMPLEX_FIXUP_UYVY);
1935 WINED3D_TO_STR(COMPLEX_FIXUP_YV12);
1936 WINED3D_TO_STR(COMPLEX_FIXUP_P8);
1937 #undef WINED3D_TO_STR
1938 default:
1939 FIXME("Unrecognized complex fixup %#x\n", fixup);
1940 return "unrecognized";
1941 }
1942 }
1943
1944 void dump_color_fixup_desc(struct color_fixup_desc fixup)
1945 {
1946 if (is_complex_fixup(fixup))
1947 {
1948 TRACE("\tComplex: %s\n", debug_complex_fixup(get_complex_fixup(fixup)));
1949 return;
1950 }
1951
1952 TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
1953 TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
1954 TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
1955 TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
1956 }
1957
1958 const char *debug_surflocation(DWORD flag) {
1959 char buf[128];
1960
1961 buf[0] = 0;
1962 if(flag & SFLAG_INSYSMEM) strcat(buf, " | SFLAG_INSYSMEM");
1963 if(flag & SFLAG_INDRAWABLE) strcat(buf, " | SFLAG_INDRAWABLE");
1964 if(flag & SFLAG_INTEXTURE) strcat(buf, " | SFLAG_INTEXTURE");
1965 if(flag & SFLAG_INSRGBTEX) strcat(buf, " | SFLAG_INSRGBTEX");
1966 return wine_dbg_sprintf("%s", buf[0] ? buf + 3 : "0");
1967 }
1968
1969 /*****************************************************************************
1970 * Useful functions mapping GL <-> D3D values
1971 */
1972 GLenum StencilOp(DWORD op) {
1973 switch(op) {
1974 case WINED3DSTENCILOP_KEEP : return GL_KEEP;
1975 case WINED3DSTENCILOP_ZERO : return GL_ZERO;
1976 case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
1977 case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
1978 case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
1979 case WINED3DSTENCILOP_INVERT : return GL_INVERT;
1980 case WINED3DSTENCILOP_INCR : return GL_INCR_WRAP_EXT;
1981 case WINED3DSTENCILOP_DECR : return GL_DECR_WRAP_EXT;
1982 default:
1983 FIXME("Unrecognized stencil op %d\n", op);
1984 return GL_KEEP;
1985 }
1986 }
1987
1988 GLenum CompareFunc(DWORD func) {
1989 switch ((WINED3DCMPFUNC)func) {
1990 case WINED3DCMP_NEVER : return GL_NEVER;
1991 case WINED3DCMP_LESS : return GL_LESS;
1992 case WINED3DCMP_EQUAL : return GL_EQUAL;
1993 case WINED3DCMP_LESSEQUAL : return GL_LEQUAL;
1994 case WINED3DCMP_GREATER : return GL_GREATER;
1995 case WINED3DCMP_NOTEQUAL : return GL_NOTEQUAL;
1996 case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
1997 case WINED3DCMP_ALWAYS : return GL_ALWAYS;
1998 default:
1999 FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
2000 return 0;
2001 }
2002 }
2003
2004 BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
2005 if (op == WINED3DTOP_DISABLE) return FALSE;
2006 if (This->stateBlock->textures[stage]) return FALSE;
2007
2008 if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2009 && op != WINED3DTOP_SELECTARG2) return TRUE;
2010 if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2011 && op != WINED3DTOP_SELECTARG1) return TRUE;
2012 if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2013 && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
2014
2015 return FALSE;
2016 }
2017
2018 /* Setup this textures matrix according to the texture flags*/
2019 /* GL locking is done by the caller (state handler) */
2020 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed,
2021 WINED3DFORMAT vtx_fmt, BOOL ffp_proj_control)
2022 {
2023 float mat[16];
2024
2025 glMatrixMode(GL_TEXTURE);
2026 checkGLcall("glMatrixMode(GL_TEXTURE)");
2027
2028 if (flags == WINED3DTTFF_DISABLE || flags == WINED3DTTFF_COUNT1 || transformed) {
2029 glLoadIdentity();
2030 checkGLcall("glLoadIdentity()");
2031 return;
2032 }
2033
2034 if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
2035 ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
2036 return;
2037 }
2038
2039 memcpy(mat, smat, 16 * sizeof(float));
2040
2041 if (flags & WINED3DTTFF_PROJECTED) {
2042 if(!ffp_proj_control) {
2043 switch (flags & ~WINED3DTTFF_PROJECTED) {
2044 case WINED3DTTFF_COUNT2:
2045 mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
2046 mat[1] = mat[5] = mat[9] = mat[13] = 0;
2047 break;
2048 case WINED3DTTFF_COUNT3:
2049 mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
2050 mat[2] = mat[6] = mat[10] = mat[14] = 0;
2051 break;
2052 }
2053 }
2054 } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2055 if(!calculatedCoords) {
2056 switch(vtx_fmt)
2057 {
2058 case WINED3DFMT_R32_FLOAT:
2059 /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
2060 * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
2061 * the input value to the transformation will be 0, so the matrix value is irrelevant
2062 */
2063 mat[12] = mat[4];
2064 mat[13] = mat[5];
2065 mat[14] = mat[6];
2066 mat[15] = mat[7];
2067 break;
2068 case WINED3DFMT_R32G32_FLOAT:
2069 /* See above, just 3rd and 4th coord
2070 */
2071 mat[12] = mat[8];
2072 mat[13] = mat[9];
2073 mat[14] = mat[10];
2074 mat[15] = mat[11];
2075 break;
2076 case WINED3DFMT_R32G32B32_FLOAT: /* Opengl defaults match dx defaults */
2077 case WINED3DFMT_R32G32B32A32_FLOAT: /* No defaults apply, all app defined */
2078
2079 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
2080 * into a bad place. The division elimination below will apply to make sure the
2081 * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
2082 */
2083 case WINED3DFMT_UNKNOWN: /* No texture coords, 0/0/0/1 defaults are passed */
2084 break;
2085 default:
2086 FIXME("Unexpected fixed function texture coord input\n");
2087 }
2088 }
2089 if(!ffp_proj_control) {
2090 switch (flags & ~WINED3DTTFF_PROJECTED) {
2091 /* case WINED3DTTFF_COUNT1: Won't ever get here */
2092 case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
2093 /* OpenGL divides the first 3 vertex coord by the 4th by default,
2094 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
2095 * the 4th coord evaluates to 1.0 to eliminate that.
2096 *
2097 * If the fixed function pipeline is used, the 4th value remains unused,
2098 * so there is no danger in doing this. With vertex shaders we have a
2099 * problem. Should an app hit that problem, the code here would have to
2100 * check for pixel shaders, and the shader has to undo the default gl divide.
2101 *
2102 * A more serious problem occurs if the app passes 4 coordinates in, and the
2103 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
2104 * or a replacement shader
2105 */
2106 default: mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
2107 }
2108 }
2109 }
2110
2111 glLoadMatrixf(mat);
2112 checkGLcall("glLoadMatrixf(mat)");
2113 }
2114
2115 /* This small helper function is used to convert a bitmask into the number of masked bits */
2116 unsigned int count_bits(unsigned int mask)
2117 {
2118 unsigned int count;
2119 for (count = 0; mask; ++count)
2120 {
2121 mask &= mask - 1;
2122 }
2123 return count;
2124 }
2125
2126 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
2127 * The later function requires individual color components. */
2128 BOOL getColorBits(const struct GlPixelFormatDesc *format_desc,
2129 short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize)
2130 {
2131 TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
2132 switch(format_desc->format)
2133 {
2134 case WINED3DFMT_B8G8R8X8_UNORM:
2135 case WINED3DFMT_B8G8R8_UNORM:
2136 case WINED3DFMT_B8G8R8A8_UNORM:
2137 case WINED3DFMT_R8G8B8A8_UNORM:
2138 case WINED3DFMT_B10G10R10A2_UNORM:
2139 case WINED3DFMT_B5G5R5X1_UNORM:
2140 case WINED3DFMT_B5G5R5A1_UNORM:
2141 case WINED3DFMT_B5G6R5_UNORM:
2142 case WINED3DFMT_B4G4R4X4_UNORM:
2143 case WINED3DFMT_B4G4R4A4_UNORM:
2144 case WINED3DFMT_B2G3R3_UNORM:
2145 case WINED3DFMT_P8_UINT_A8_UNORM:
2146 case WINED3DFMT_P8_UINT:
2147 break;
2148 default:
2149 ERR("Unsupported format: %s\n", debug_d3dformat(format_desc->format));
2150 return FALSE;
2151 }
2152
2153 *redSize = count_bits(format_desc->red_mask);
2154 *greenSize = count_bits(format_desc->green_mask);
2155 *blueSize = count_bits(format_desc->blue_mask);
2156 *alphaSize = count_bits(format_desc->alpha_mask);
2157 *totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
2158
2159 TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n",
2160 *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(format_desc->format));
2161 return TRUE;
2162 }
2163
2164 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
2165 BOOL getDepthStencilBits(const struct GlPixelFormatDesc *format_desc, short *depthSize, short *stencilSize)
2166 {
2167 TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
2168 switch(format_desc->format)
2169 {
2170 case WINED3DFMT_D16_LOCKABLE:
2171 case WINED3DFMT_D16_UNORM:
2172 case WINED3DFMT_S1_UINT_D15_UNORM:
2173 case WINED3DFMT_X8D24_UNORM:
2174 case WINED3DFMT_S4X4_UINT_D24_UNORM:
2175 case WINED3DFMT_D24_UNORM_S8_UINT:
2176 case WINED3DFMT_S8_UINT_D24_FLOAT:
2177 case WINED3DFMT_D32_UNORM:
2178 case WINED3DFMT_D32_FLOAT:
2179 break;
2180 default:
2181 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(format_desc->format));
2182 return FALSE;
2183 }
2184
2185 *depthSize = format_desc->depth_size;
2186 *stencilSize = format_desc->stencil_size;
2187
2188 TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n",
2189 *depthSize, *stencilSize, debug_d3dformat(format_desc->format));
2190 return TRUE;
2191 }
2192
2193 /* DirectDraw stuff */
2194 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
2195 switch(depth) {
2196 case 8: return WINED3DFMT_P8_UINT;
2197 case 15: return WINED3DFMT_B5G5R5X1_UNORM;
2198 case 16: return WINED3DFMT_B5G6R5_UNORM;
2199 case 24: return WINED3DFMT_B8G8R8X8_UNORM; /* Robots needs 24bit to be WINED3DFMT_B8G8R8X8_UNORM */
2200 case 32: return WINED3DFMT_B8G8R8X8_UNORM; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return WINED3DFMT_B8G8R8X8_UNORM */
2201 default: return WINED3DFMT_UNKNOWN;
2202 }
2203 }
2204
2205 void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
2206 WINED3DMATRIX temp;
2207
2208 /* Now do the multiplication 'by hand'.
2209 I know that all this could be optimised, but this will be done later :-) */
2210 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);
2211 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);
2212 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);
2213 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);
2214
2215 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);
2216 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);
2217 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);
2218 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);
2219
2220 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);
2221 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);
2222 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);
2223 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);
2224
2225 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);
2226 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);
2227 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);
2228 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);
2229
2230 /* And copy the new matrix in the good storage.. */
2231 memcpy(dest, &temp, 16 * sizeof(float));
2232 }
2233
2234 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
2235 DWORD size = 0;
2236 int i;
2237 int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
2238
2239 if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
2240 if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
2241 if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
2242 if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
2243 switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
2244 case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
2245 case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
2246 case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break;
2247 case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break;
2248 case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break;
2249 case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break;
2250 case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break;
2251 case WINED3DFVF_XYZW: size += 4 * sizeof(float); break;
2252 default: ERR("Unexpected position mask\n");
2253 }
2254 for (i = 0; i < numTextures; i++) {
2255 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
2256 }
2257
2258 return size;
2259 }
2260
2261 /***********************************************************************
2262 * CalculateTexRect
2263 *
2264 * Calculates the dimensions of the opengl texture used for blits.
2265 * Handled oversized opengl textures and updates the source rectangle
2266 * accordingly
2267 *
2268 * Params:
2269 * This: Surface to operate on
2270 * Rect: Requested rectangle
2271 *
2272 * Returns:
2273 * TRUE if the texture part can be loaded,
2274 * FALSE otherwise
2275 *
2276 *********************************************************************/
2277 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4])
2278 {
2279 const struct wined3d_gl_info *gl_info = &This->resource.device->adapter->gl_info;
2280 int x1 = Rect->left, x2 = Rect->right;
2281 int y1 = Rect->top, y2 = Rect->bottom;
2282 GLint maxSize = gl_info->limits.texture_size;
2283
2284 TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
2285 Rect->left, Rect->top, Rect->right, Rect->bottom);
2286
2287 /* The sizes might be reversed */
2288 if(Rect->left > Rect->right) {
2289 x1 = Rect->right;
2290 x2 = Rect->left;
2291 }
2292 if(Rect->top > Rect->bottom) {
2293 y1 = Rect->bottom;
2294 y2 = Rect->top;
2295 }
2296
2297 /* No oversized texture? This is easy */
2298 if(!(This->Flags & SFLAG_OVERSIZE)) {
2299 /* Which rect from the texture do I need? */
2300 if (This->texture_target == GL_TEXTURE_RECTANGLE_ARB)
2301 {
2302 glTexCoord[0] = (float) Rect->left;
2303 glTexCoord[2] = (float) Rect->top;
2304 glTexCoord[1] = (float) Rect->right;
2305 glTexCoord[3] = (float) Rect->bottom;
2306 } else {
2307 glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
2308 glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
2309 glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
2310 glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
2311 }
2312
2313 return TRUE;
2314 } else {
2315 /* Check if we can succeed at all */
2316 if( (x2 - x1) > maxSize ||
2317 (y2 - y1) > maxSize ) {
2318 TRACE("Requested rectangle is too large for gl\n");
2319 return FALSE;
2320 }
2321
2322 /* A part of the texture has to be picked. First, check if
2323 * some texture part is loaded already, if yes try to re-use it.
2324 * If the texture is dirty, or the part can't be used,
2325 * re-position the part to load
2326 */
2327 if(This->Flags & SFLAG_INTEXTURE) {
2328 if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
2329 This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
2330 /* Ok, the rectangle is ok, re-use it */
2331 TRACE("Using existing gl Texture\n");
2332 } else {
2333 /* Rectangle is not ok, dirtify the texture to reload it */
2334 TRACE("Dirtifying texture to force reload\n");
2335 This->Flags &= ~SFLAG_INTEXTURE;
2336 }
2337 }
2338
2339 /* Now if we are dirty(no else if!) */
2340 if(!(This->Flags & SFLAG_INTEXTURE)) {
2341 /* Set the new rectangle. Use the following strategy:
2342 * 1) Use as big textures as possible.
2343 * 2) Place the texture part in the way that the requested
2344 * part is in the middle of the texture(well, almost)
2345 * 3) If the texture is moved over the edges of the
2346 * surface, replace it nicely
2347 * 4) If the coord is not limiting the texture size,
2348 * use the whole size
2349 */
2350 if((This->pow2Width) > maxSize) {
2351 This->glRect.left = x1 - maxSize / 2;
2352 if(This->glRect.left < 0) {
2353 This->glRect.left = 0;
2354 }
2355 This->glRect.right = This->glRect.left + maxSize;
2356 if(This->glRect.right > This->currentDesc.Width) {
2357 This->glRect.right = This->currentDesc.Width;
2358 This->glRect.left = This->glRect.right - maxSize;
2359 }
2360 } else {
2361 This->glRect.left = 0;
2362 This->glRect.right = This->pow2Width;
2363 }
2364
2365 if (This->pow2Height > maxSize)
2366 {
2367 This->glRect.top = x1 - gl_info->limits.texture_size / 2;
2368 if(This->glRect.top < 0) This->glRect.top = 0;
2369 This->glRect.bottom = This->glRect.left + maxSize;
2370 if(This->glRect.bottom > This->currentDesc.Height) {
2371 This->glRect.bottom = This->currentDesc.Height;
2372 This->glRect.top = This->glRect.bottom - maxSize;
2373 }
2374 } else {
2375 This->glRect.top = 0;
2376 This->glRect.bottom = This->pow2Height;
2377 }
2378 TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
2379 This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
2380 }
2381
2382 /* Re-calculate the rect to draw */
2383 Rect->left -= This->glRect.left;
2384 Rect->right -= This->glRect.left;
2385 Rect->top -= This->glRect.top;
2386 Rect->bottom -= This->glRect.top;
2387
2388 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
2389 * or the pow2Width / pow2Height of the surface.
2390 *
2391 * Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
2392 * as regular GL_TEXTURE_2D.
2393 */
2394 glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
2395 glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
2396 glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
2397 glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
2398 }
2399 return TRUE;
2400 }
2401
2402 void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_settings *settings, BOOL ignore_textype) {
2403 #define ARG1 0x01
2404 #define ARG2 0x02
2405 #define ARG0 0x04
2406 static const unsigned char args[WINED3DTOP_LERP + 1] = {
2407 /* undefined */ 0,
2408 /* D3DTOP_DISABLE */ 0,
2409 /* D3DTOP_SELECTARG1 */ ARG1,
2410 /* D3DTOP_SELECTARG2 */ ARG2,
2411 /* D3DTOP_MODULATE */ ARG1 | ARG2,
2412 /* D3DTOP_MODULATE2X */ ARG1 | ARG2,
2413 /* D3DTOP_MODULATE4X */ ARG1 | ARG2,
2414 /* D3DTOP_ADD */ ARG1 | ARG2,
2415 /* D3DTOP_ADDSIGNED */ ARG1 | ARG2,
2416 /* D3DTOP_ADDSIGNED2X */ ARG1 | ARG2,
2417 /* D3DTOP_SUBTRACT */ ARG1 | ARG2,
2418 /* D3DTOP_ADDSMOOTH */ ARG1 | ARG2,
2419 /* D3DTOP_BLENDDIFFUSEALPHA */ ARG1 | ARG2,
2420 /* D3DTOP_BLENDTEXTUREALPHA */ ARG1 | ARG2,
2421 /* D3DTOP_BLENDFACTORALPHA */ ARG1 | ARG2,
2422 /* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1 | ARG2,
2423 /* D3DTOP_BLENDCURRENTALPHA */ ARG1 | ARG2,
2424 /* D3DTOP_PREMODULATE */ ARG1 | ARG2,
2425 /* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1 | ARG2,
2426 /* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1 | ARG2,
2427 /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1 | ARG2,
2428 /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1 | ARG2,
2429 /* D3DTOP_BUMPENVMAP */ ARG1 | ARG2,
2430 /* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1 | ARG2,
2431 /* D3DTOP_DOTPRODUCT3 */ ARG1 | ARG2,
2432 /* D3DTOP_MULTIPLYADD */ ARG1 | ARG2 | ARG0,
2433 /* D3DTOP_LERP */ ARG1 | ARG2 | ARG0
2434 };
2435 unsigned int i;
2436 DWORD ttff;
2437 DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
2438 IWineD3DDeviceImpl *device = stateblock->device;
2439 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2440
2441 for (i = 0; i < gl_info->limits.texture_stages; ++i)
2442 {
2443 IWineD3DBaseTextureImpl *texture;
2444 settings->op[i].padding = 0;
2445 if(stateblock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
2446 settings->op[i].cop = WINED3DTOP_DISABLE;
2447 settings->op[i].aop = WINED3DTOP_DISABLE;
2448 settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
2449 settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
2450 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2451 settings->op[i].dst = resultreg;
2452 settings->op[i].tex_type = tex_1d;
2453 settings->op[i].projected = proj_none;
2454 i++;
2455 break;
2456 }
2457
2458 texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
2459 if(texture) {
2460 settings->op[i].color_fixup = texture->resource.format_desc->color_fixup;
2461 if(ignore_textype) {
2462 settings->op[i].tex_type = tex_1d;
2463 } else {
2464 switch (IWineD3DBaseTexture_GetTextureDimensions((IWineD3DBaseTexture *)texture)) {
2465 case GL_TEXTURE_1D:
2466 settings->op[i].tex_type = tex_1d;
2467 break;
2468 case GL_TEXTURE_2D:
2469 settings->op[i].tex_type = tex_2d;
2470 break;
2471 case GL_TEXTURE_3D:
2472 settings->op[i].tex_type = tex_3d;
2473 break;
2474 case GL_TEXTURE_CUBE_MAP_ARB:
2475 settings->op[i].tex_type = tex_cube;
2476 break;
2477 case GL_TEXTURE_RECTANGLE_ARB:
2478 settings->op[i].tex_type = tex_rect;
2479 break;
2480 }
2481 }
2482 } else {
2483 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2484 settings->op[i].tex_type = tex_1d;
2485 }
2486
2487 cop = stateblock->textureState[i][WINED3DTSS_COLOROP];
2488 aop = stateblock->textureState[i][WINED3DTSS_ALPHAOP];
2489
2490 carg1 = (args[cop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_COLORARG1] : ARG_UNUSED;
2491 carg2 = (args[cop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_COLORARG2] : ARG_UNUSED;
2492 carg0 = (args[cop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_COLORARG0] : ARG_UNUSED;
2493
2494 if(is_invalid_op(device, i, cop, carg1, carg2, carg0)) {
2495 carg0 = ARG_UNUSED;
2496 carg2 = ARG_UNUSED;
2497 carg1 = WINED3DTA_CURRENT;
2498 cop = WINED3DTOP_SELECTARG1;
2499 }
2500
2501 if(cop == WINED3DTOP_DOTPRODUCT3) {
2502 /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
2503 * the color result to the alpha component of the destination
2504 */
2505 aop = cop;
2506 aarg1 = carg1;
2507 aarg2 = carg2;
2508 aarg0 = carg0;
2509 } else {
2510 aarg1 = (args[aop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG1] : ARG_UNUSED;
2511 aarg2 = (args[aop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG2] : ARG_UNUSED;
2512 aarg0 = (args[aop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG0] : ARG_UNUSED;
2513 }
2514
2515 if (i == 0 && stateblock->textures[0] && stateblock->renderState[WINED3DRS_COLORKEYENABLE])
2516 {
2517 UINT texture_dimensions = IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[0]);
2518
2519 if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
2520 {
2521 IWineD3DSurfaceImpl *surf;
2522 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
2523
2524 if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format_desc->alpha_mask)
2525 {
2526 if (aop == WINED3DTOP_DISABLE)
2527 {
2528 aarg1 = WINED3DTA_TEXTURE;
2529 aop = WINED3DTOP_SELECTARG1;
2530 }
2531 else if (aop == WINED3DTOP_SELECTARG1 && aarg1 != WINED3DTA_TEXTURE)
2532 {
2533 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2534 {
2535 aarg2 = WINED3DTA_TEXTURE;
2536 aop = WINED3DTOP_MODULATE;
2537 }
2538 else aarg1 = WINED3DTA_TEXTURE;
2539 }
2540 else if (aop == WINED3DTOP_SELECTARG2 && aarg2 != WINED3DTA_TEXTURE)
2541 {
2542 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2543 {
2544 aarg1 = WINED3DTA_TEXTURE;
2545 aop = WINED3DTOP_MODULATE;
2546 }
2547 else aarg2 = WINED3DTA_TEXTURE;
2548 }
2549 }
2550 }
2551 }
2552
2553 if(is_invalid_op(device, i, aop, aarg1, aarg2, aarg0)) {
2554 aarg0 = ARG_UNUSED;
2555 aarg2 = ARG_UNUSED;
2556 aarg1 = WINED3DTA_CURRENT;
2557 aop = WINED3DTOP_SELECTARG1;
2558 }
2559
2560 if(carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE ||
2561 aarg1 == WINED3DTA_TEXTURE || aarg2 == WINED3DTA_TEXTURE || aarg0 == WINED3DTA_TEXTURE) {
2562 ttff = stateblock->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2563 if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT3)) {
2564 settings->op[i].projected = proj_count3;
2565 } else if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT4)) {
2566 settings->op[i].projected = proj_count4;
2567 } else {
2568 settings->op[i].projected = proj_none;
2569 }
2570 } else {
2571 settings->op[i].projected = proj_none;
2572 }
2573
2574 settings->op[i].cop = cop;
2575 settings->op[i].aop = aop;
2576 settings->op[i].carg0 = carg0;
2577 settings->op[i].carg1 = carg1;
2578 settings->op[i].carg2 = carg2;
2579 settings->op[i].aarg0 = aarg0;
2580 settings->op[i].aarg1 = aarg1;
2581 settings->op[i].aarg2 = aarg2;
2582
2583 if(stateblock->textureState[i][WINED3DTSS_RESULTARG] == WINED3DTA_TEMP) {
2584 settings->op[i].dst = tempreg;
2585 } else {
2586 settings->op[i].dst = resultreg;
2587 }
2588 }
2589
2590 /* Clear unsupported stages */
2591 for(; i < MAX_TEXTURES; i++) {
2592 memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
2593 }
2594
2595 if(stateblock->renderState[WINED3DRS_FOGENABLE] == FALSE) {
2596 settings->fog = FOG_OFF;
2597 } else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
2598 if(use_vs(stateblock) || ((IWineD3DVertexDeclarationImpl *) stateblock->vertexDecl)->position_transformed) {
2599 settings->fog = FOG_LINEAR;
2600 } else {
2601 switch(stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
2602 case WINED3DFOG_NONE:
2603 case WINED3DFOG_LINEAR:
2604 settings->fog = FOG_LINEAR;
2605 break;
2606 case WINED3DFOG_EXP:
2607 settings->fog = FOG_EXP;
2608 break;
2609 case WINED3DFOG_EXP2:
2610 settings->fog = FOG_EXP2;
2611 break;
2612 }
2613 }
2614 } else {
2615 switch(stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
2616 case WINED3DFOG_LINEAR:
2617 settings->fog = FOG_LINEAR;
2618 break;
2619 case WINED3DFOG_EXP:
2620 settings->fog = FOG_EXP;
2621 break;
2622 case WINED3DFOG_EXP2:
2623 settings->fog = FOG_EXP2;
2624 break;
2625 }
2626 }
2627 if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
2628 settings->sRGB_write = 1;
2629 } else {
2630 settings->sRGB_write = 0;
2631 }
2632 if(device->vs_clipping || !use_vs(stateblock) || !stateblock->renderState[WINED3DRS_CLIPPING] ||
2633 !stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
2634 /* No need to emulate clipplanes if GL supports native vertex shader clipping or if
2635 * the fixed function vertex pipeline is used(which always supports clipplanes), or
2636 * if no clipplane is enabled
2637 */
2638 settings->emul_clipplanes = 0;
2639 } else {
2640 settings->emul_clipplanes = 1;
2641 }
2642 }
2643
2644 const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
2645 const struct ffp_frag_settings *settings)
2646 {
2647 struct wine_rb_entry *entry = wine_rb_get(fragment_shaders, settings);
2648 return entry ? WINE_RB_ENTRY_VALUE(entry, struct ffp_frag_desc, entry) : NULL;
2649 }
2650
2651 void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc)
2652 {
2653 /* Note that the key is the implementation independent part of the ffp_frag_desc structure,
2654 * whereas desc points to an extended structure with implementation specific parts. */
2655 if (wine_rb_put(shaders, &desc->settings, &desc->entry) == -1)
2656 {
2657 ERR("Failed to insert ffp frag shader.\n");
2658 }
2659 }
2660
2661 /* Activates the texture dimension according to the bound D3D texture.
2662 * Does not care for the colorop or correct gl texture unit(when using nvrc)
2663 * Requires the caller to activate the correct unit before
2664 */
2665 /* GL locking is done by the caller (state handler) */
2666 void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context)
2667 {
2668 const struct wined3d_gl_info *gl_info = context->gl_info;
2669
2670 if (stateblock->textures[stage])
2671 {
2672 switch (IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[stage])) {
2673 case GL_TEXTURE_2D:
2674 glDisable(GL_TEXTURE_3D);
2675 checkGLcall("glDisable(GL_TEXTURE_3D)");
2676 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2677 {
2678 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2679 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2680 }
2681 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2682 {
2683 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2684 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2685 }
2686 glEnable(GL_TEXTURE_2D);
2687 checkGLcall("glEnable(GL_TEXTURE_2D)");
2688 break;
2689 case GL_TEXTURE_RECTANGLE_ARB:
2690 glDisable(GL_TEXTURE_2D);
2691 checkGLcall("glDisable(GL_TEXTURE_2D)");
2692 glDisable(GL_TEXTURE_3D);
2693 checkGLcall("glDisable(GL_TEXTURE_3D)");
2694 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2695 {
2696 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2697 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2698 }
2699 glEnable(GL_TEXTURE_RECTANGLE_ARB);
2700 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2701 break;
2702 case GL_TEXTURE_3D:
2703 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2704 {
2705 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2706 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2707 }
2708 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2709 {
2710 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2711 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2712 }
2713 glDisable(GL_TEXTURE_2D);
2714 checkGLcall("glDisable(GL_TEXTURE_2D)");
2715 glEnable(GL_TEXTURE_3D);
2716 checkGLcall("glEnable(GL_TEXTURE_3D)");
2717 break;
2718 case GL_TEXTURE_CUBE_MAP_ARB:
2719 glDisable(GL_TEXTURE_2D);
2720 checkGLcall("glDisable(GL_TEXTURE_2D)");
2721 glDisable(GL_TEXTURE_3D);
2722 checkGLcall("glDisable(GL_TEXTURE_3D)");
2723 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2724 {
2725 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2726 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2727 }
2728 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
2729 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2730 break;
2731 }
2732 } else {
2733 glEnable(GL_TEXTURE_2D);
2734 checkGLcall("glEnable(GL_TEXTURE_2D)");
2735 glDisable(GL_TEXTURE_3D);
2736 checkGLcall("glDisable(GL_TEXTURE_3D)");
2737 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2738 {
2739 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2740 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2741 }
2742 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2743 {
2744 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2745 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2746 }
2747 /* Binding textures is done by samplers. A dummy texture will be bound */
2748 }
2749 }
2750
2751 /* GL locking is done by the caller (state handler) */
2752 void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context)
2753 {
2754 DWORD sampler = state - STATE_SAMPLER(0);
2755 DWORD mapped_stage = stateblock->device->texUnitMap[sampler];
2756
2757 /* No need to enable / disable anything here for unused samplers. The tex_colorop
2758 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
2759 * will take care of this business
2760 */
2761 if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures) return;
2762 if(sampler >= stateblock->lowest_disabled_stage) return;
2763 if(isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) return;
2764
2765 texture_activate_dimensions(sampler, stateblock, context);
2766 }
2767
2768 void *wined3d_rb_alloc(size_t size)
2769 {
2770 return HeapAlloc(GetProcessHeap(), 0, size);
2771 }
2772
2773 void *wined3d_rb_realloc(void *ptr, size_t size)
2774 {
2775 return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
2776 }
2777
2778 void wined3d_rb_free(void *ptr)
2779 {
2780 HeapFree(GetProcessHeap(), 0, ptr);
2781 }
2782
2783 static int ffp_frag_program_key_compare(const void *key, const struct wine_rb_entry *entry)
2784 {
2785 const struct ffp_frag_settings *ka = key;
2786 const struct ffp_frag_settings *kb = &WINE_RB_ENTRY_VALUE(entry, const struct ffp_frag_desc, entry)->settings;
2787
2788 return memcmp(ka, kb, sizeof(*ka));
2789 }
2790
2791 const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions =
2792 {
2793 wined3d_rb_alloc,
2794 wined3d_rb_realloc,
2795 wined3d_rb_free,
2796 ffp_frag_program_key_compare,
2797 };
2798
2799 UINT wined3d_log2i(UINT32 x)
2800 {
2801 static const UINT l[] =
2802 {
2803 ~0U, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
2804 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2805 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2806 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2807 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2808 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2809 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2810 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2811 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2812 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2813 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2814 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2815 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2816 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2817 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2818 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2819 };
2820 UINT32 i;
2821
2822 return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
2823 }
2824
2825 /* Set the shader type for this device, depending on the given capabilities
2826 * and the user preferences in wined3d_settings. */
2827 void select_shader_mode(const struct wined3d_gl_info *gl_info, int *ps_selected, int *vs_selected)
2828 {
2829 if (wined3d_settings.vs_mode == VS_NONE) *vs_selected = SHADER_NONE;
2830 else if (gl_info->supported[ARB_VERTEX_SHADER] && wined3d_settings.glslRequested)
2831 {
2832 /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
2833 * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
2834 * shaders only on this card. */
2835 if (gl_info->supported[NV_VERTEX_PROGRAM] && !gl_info->supported[NV_VERTEX_PROGRAM2]) *vs_selected = SHADER_ARB;
2836 else *vs_selected = SHADER_GLSL;
2837 }
2838 else if (gl_info->supported[ARB_VERTEX_PROGRAM]) *vs_selected = SHADER_ARB;
2839 else *vs_selected = SHADER_NONE;
2840
2841 if (wined3d_settings.ps_mode == PS_NONE) *ps_selected = SHADER_NONE;
2842 else if (gl_info->supported[ARB_FRAGMENT_SHADER] && wined3d_settings.glslRequested) *ps_selected = SHADER_GLSL;
2843 else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) *ps_selected = SHADER_ARB;
2844 else if (gl_info->supported[ATI_FRAGMENT_SHADER]) *ps_selected = SHADER_ATI;
2845 else *ps_selected = SHADER_NONE;
2846 }
useful hacks and other patches not (yet) suitable for mainline