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