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