?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wininet: Use separate function for setting global options.
[wine/multimedia.git] / dlls / wined3d / utils.c
blob847366e4d886359e6f2d6ca66fa4d9dfb423b2ec
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-2010 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 enum wined3d_format_id id;
35 DWORD alphaMask, redMask, greenMask, blueMask;
36 UINT bpp;
37 BYTE 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 /* format id 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_NVDB, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
133 {WINED3DFMT_INTZ, 0x0, 0x0, 0x0, 0x0, 4, 24, 8},
134 {WINED3DFMT_NVHU, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
135 {WINED3DFMT_NVHS, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
136 {WINED3DFMT_NULL, 0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4, 0, 0},
137 /* Unsure about them, could not find a Windows driver that supports them */
138 {WINED3DFMT_R16, 0x0, 0x0000ffff, 0x0, 0x0, 2, 0, 0},
139 {WINED3DFMT_AL16, 0xffff0000, 0x0, 0x0, 0x0, 4, 0, 0},
140 };
141
142 struct wined3d_format_base_flags
143 {
144 enum wined3d_format_id id;
145 DWORD flags;
146 };
147
148 /* The ATI2N format behaves like an uncompressed format in LockRect(), but
149 * still needs to use the correct block based calculation for e.g. the
150 * resource size. */
151 static const struct wined3d_format_base_flags format_base_flags[] =
152 {
153 {WINED3DFMT_UYVY, WINED3DFMT_FLAG_FOURCC},
154 {WINED3DFMT_YUY2, WINED3DFMT_FLAG_FOURCC},
155 {WINED3DFMT_YV12, WINED3DFMT_FLAG_FOURCC},
156 {WINED3DFMT_DXT1, WINED3DFMT_FLAG_FOURCC},
157 {WINED3DFMT_DXT2, WINED3DFMT_FLAG_FOURCC},
158 {WINED3DFMT_DXT3, WINED3DFMT_FLAG_FOURCC},
159 {WINED3DFMT_DXT4, WINED3DFMT_FLAG_FOURCC},
160 {WINED3DFMT_DXT5, WINED3DFMT_FLAG_FOURCC},
161 {WINED3DFMT_MULTI2_ARGB8, WINED3DFMT_FLAG_FOURCC},
162 {WINED3DFMT_G8R8_G8B8, WINED3DFMT_FLAG_FOURCC},
163 {WINED3DFMT_R8G8_B8G8, WINED3DFMT_FLAG_FOURCC},
164 {WINED3DFMT_INTZ, WINED3DFMT_FLAG_FOURCC},
165 {WINED3DFMT_NULL, WINED3DFMT_FLAG_FOURCC},
166 {WINED3DFMT_P8_UINT, WINED3DFMT_FLAG_GETDC},
167 {WINED3DFMT_B8G8R8_UNORM, WINED3DFMT_FLAG_GETDC},
168 {WINED3DFMT_B8G8R8A8_UNORM, WINED3DFMT_FLAG_GETDC},
169 {WINED3DFMT_B8G8R8X8_UNORM, WINED3DFMT_FLAG_GETDC},
170 {WINED3DFMT_B5G6R5_UNORM, WINED3DFMT_FLAG_GETDC},
171 {WINED3DFMT_B5G5R5X1_UNORM, WINED3DFMT_FLAG_GETDC},
172 {WINED3DFMT_B5G5R5A1_UNORM, WINED3DFMT_FLAG_GETDC},
173 {WINED3DFMT_B4G4R4A4_UNORM, WINED3DFMT_FLAG_GETDC},
174 {WINED3DFMT_B4G4R4X4_UNORM, WINED3DFMT_FLAG_GETDC},
175 {WINED3DFMT_R8G8B8A8_UNORM, WINED3DFMT_FLAG_GETDC},
176 {WINED3DFMT_R8G8B8X8_UNORM, WINED3DFMT_FLAG_GETDC},
177 {WINED3DFMT_ATI2N, WINED3DFMT_FLAG_FOURCC | WINED3DFMT_FLAG_BROKEN_PITCH},
178 {WINED3DFMT_NVDB, WINED3DFMT_FLAG_FOURCC},
179 {WINED3DFMT_NVHU, WINED3DFMT_FLAG_FOURCC},
180 {WINED3DFMT_NVHS, WINED3DFMT_FLAG_FOURCC},
181 {WINED3DFMT_R32_FLOAT, WINED3DFMT_FLAG_FLOAT},
182 {WINED3DFMT_R32G32_FLOAT, WINED3DFMT_FLAG_FLOAT},
183 {WINED3DFMT_R32G32B32_FLOAT, WINED3DFMT_FLAG_FLOAT},
184 {WINED3DFMT_R32G32B32A32_FLOAT, WINED3DFMT_FLAG_FLOAT},
185 {WINED3DFMT_R16_FLOAT, WINED3DFMT_FLAG_FLOAT},
186 {WINED3DFMT_R16G16_FLOAT, WINED3DFMT_FLAG_FLOAT},
187 {WINED3DFMT_R16G16B16A16_FLOAT, WINED3DFMT_FLAG_FLOAT},
188 {WINED3DFMT_D32_FLOAT, WINED3DFMT_FLAG_FLOAT},
189 {WINED3DFMT_S8_UINT_D24_FLOAT, WINED3DFMT_FLAG_FLOAT},
190 };
191
192 struct wined3d_format_block_info
193 {
194 enum wined3d_format_id id;
195 UINT block_width;
196 UINT block_height;
197 UINT block_byte_count;
198 };
199
200 static const struct wined3d_format_block_info format_block_info[] =
201 {
202 {WINED3DFMT_DXT1, 4, 4, 8},
203 {WINED3DFMT_DXT2, 4, 4, 16},
204 {WINED3DFMT_DXT3, 4, 4, 16},
205 {WINED3DFMT_DXT4, 4, 4, 16},
206 {WINED3DFMT_DXT5, 4, 4, 16},
207 {WINED3DFMT_ATI2N, 4, 4, 16},
208 {WINED3DFMT_YUY2, 2, 1, 4},
209 {WINED3DFMT_UYVY, 2, 1, 4},
210 };
211
212 struct wined3d_format_vertex_info
213 {
214 enum wined3d_format_id id;
215 enum wined3d_ffp_emit_idx emit_idx;
216 GLint component_count;
217 GLenum gl_vtx_type;
218 GLint gl_vtx_format;
219 GLboolean gl_normalized;
220 unsigned int component_size;
221 };
222
223 static const struct wined3d_format_vertex_info format_vertex_info[] =
224 {
225 {WINED3DFMT_R32_FLOAT, WINED3D_FFP_EMIT_FLOAT1, 1, GL_FLOAT, 1, GL_FALSE, sizeof(float)},
226 {WINED3DFMT_R32G32_FLOAT, WINED3D_FFP_EMIT_FLOAT2, 2, GL_FLOAT, 2, GL_FALSE, sizeof(float)},
227 {WINED3DFMT_R32G32B32_FLOAT, WINED3D_FFP_EMIT_FLOAT3, 3, GL_FLOAT, 3, GL_FALSE, sizeof(float)},
228 {WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_FFP_EMIT_FLOAT4, 4, GL_FLOAT, 4, GL_FALSE, sizeof(float)},
229 {WINED3DFMT_B8G8R8A8_UNORM, WINED3D_FFP_EMIT_D3DCOLOR, 4, GL_UNSIGNED_BYTE, 4, GL_TRUE, sizeof(BYTE)},
230 {WINED3DFMT_R8G8B8A8_UINT, WINED3D_FFP_EMIT_UBYTE4, 4, GL_UNSIGNED_BYTE, 4, GL_FALSE, sizeof(BYTE)},
231 {WINED3DFMT_R16G16_SINT, WINED3D_FFP_EMIT_SHORT2, 2, GL_SHORT, 2, GL_FALSE, sizeof(short int)},
232 {WINED3DFMT_R16G16B16A16_SINT, WINED3D_FFP_EMIT_SHORT4, 4, GL_SHORT, 4, GL_FALSE, sizeof(short int)},
233 {WINED3DFMT_R8G8B8A8_UNORM, WINED3D_FFP_EMIT_UBYTE4N, 4, GL_UNSIGNED_BYTE, 4, GL_TRUE, sizeof(BYTE)},
234 {WINED3DFMT_R16G16_SNORM, WINED3D_FFP_EMIT_SHORT2N, 2, GL_SHORT, 2, GL_TRUE, sizeof(short int)},
235 {WINED3DFMT_R16G16B16A16_SNORM, WINED3D_FFP_EMIT_SHORT4N, 4, GL_SHORT, 4, GL_TRUE, sizeof(short int)},
236 {WINED3DFMT_R16G16_UNORM, WINED3D_FFP_EMIT_USHORT2N, 2, GL_UNSIGNED_SHORT, 2, GL_TRUE, sizeof(short int)},
237 {WINED3DFMT_R16G16B16A16_UNORM, WINED3D_FFP_EMIT_USHORT4N, 4, GL_UNSIGNED_SHORT, 4, GL_TRUE, sizeof(short int)},
238 {WINED3DFMT_R10G10B10A2_UINT, WINED3D_FFP_EMIT_UDEC3, 3, GL_UNSIGNED_SHORT, 3, GL_FALSE, sizeof(short int)},
239 {WINED3DFMT_R10G10B10A2_SNORM, WINED3D_FFP_EMIT_DEC3N, 3, GL_SHORT, 3, GL_TRUE, sizeof(short int)},
240 {WINED3DFMT_R16G16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_2, 2, GL_FLOAT, 2, GL_FALSE, sizeof(GLhalfNV)},
241 {WINED3DFMT_R16G16B16A16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_4, 4, GL_FLOAT, 4, GL_FALSE, sizeof(GLhalfNV)}
242 };
243
244 struct wined3d_format_texture_info
245 {
246 enum wined3d_format_id id;
247 GLint gl_internal;
248 GLint gl_srgb_internal;
249 GLint gl_rt_internal;
250 GLint gl_format;
251 GLint gl_type;
252 unsigned int conv_byte_count;
253 unsigned int flags;
254 enum wined3d_gl_extension extension;
255 void (*convert)(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height);
256 };
257
258 static void convert_l4a4_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
259 {
260 /* WINED3DFMT_L4A4_UNORM exists as an internal gl format, but for some reason there is not
261 * format+type combination to load it. Thus convert it to A8L8, then load it
262 * with A4L4 internal, but A8L8 format+type
263 */
264 unsigned int x, y;
265 const unsigned char *Source;
266 unsigned char *Dest;
267 UINT outpitch = pitch * 2;
268
269 for(y = 0; y < height; y++) {
270 Source = src + y * pitch;
271 Dest = dst + y * outpitch;
272 for (x = 0; x < width; x++ ) {
273 unsigned char color = (*Source++);
274 /* A */ Dest[1] = (color & 0xf0) << 0;
275 /* L */ Dest[0] = (color & 0x0f) << 4;
276 Dest += 2;
277 }
278 }
279 }
280
281 static void convert_r5g5_snorm_l6_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
282 {
283 unsigned int x, y;
284 const WORD *Source;
285
286 for(y = 0; y < height; y++)
287 {
288 unsigned short *Dest_s = (unsigned short *) (dst + y * pitch);
289 Source = (const WORD *)(src + y * pitch);
290 for (x = 0; x < width; x++ )
291 {
292 short color = (*Source++);
293 unsigned char l = ((color >> 10) & 0xfc);
294 short v = ((color >> 5) & 0x3e);
295 short u = ((color ) & 0x1f);
296 short v_conv = v + 16;
297 short u_conv = u + 16;
298
299 *Dest_s = ((v_conv << 11) & 0xf800) | ((l << 5) & 0x7e0) | (u_conv & 0x1f);
300 Dest_s += 1;
301 }
302 }
303 }
304
305 static void convert_r5g5_snorm_l6_unorm_nv(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
306 {
307 unsigned int x, y;
308 const WORD *Source;
309 unsigned char *Dest;
310 UINT outpitch = (pitch * 3)/2;
311
312 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
313 * fixed function and shaders without further conversion once the surface is
314 * loaded
315 */
316 for(y = 0; y < height; y++) {
317 Source = (const WORD *)(src + y * pitch);
318 Dest = dst + y * outpitch;
319 for (x = 0; x < width; x++ ) {
320 short color = (*Source++);
321 unsigned char l = ((color >> 10) & 0xfc);
322 char v = ((color >> 5) & 0x3e);
323 char u = ((color ) & 0x1f);
324
325 /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
326 * and doubles the positive range. Thus shift left only once, gl does the 2nd
327 * shift. GL reads a signed value and converts it into an unsigned value.
328 */
329 /* M */ Dest[2] = l << 1;
330
331 /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
332 * from 5 bit values to 8 bit values.
333 */
334 /* V */ Dest[1] = v << 3;
335 /* U */ Dest[0] = u << 3;
336 Dest += 3;
337 }
338 }
339 }
340
341 static void convert_r8g8_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
342 {
343 unsigned int x, y;
344 const short *Source;
345 unsigned char *Dest;
346 UINT outpitch = (pitch * 3)/2;
347
348 for(y = 0; y < height; y++)
349 {
350 Source = (const short *)(src + y * pitch);
351 Dest = dst + y * outpitch;
352 for (x = 0; x < width; x++ )
353 {
354 const short color = (*Source++);
355 /* B */ Dest[0] = 0xff;
356 /* G */ Dest[1] = (color >> 8) + 128; /* V */
357 /* R */ Dest[2] = (color & 0xff) + 128; /* U */
358 Dest += 3;
359 }
360 }
361 }
362
363 static void convert_r8g8_snorm_l8x8_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
364 {
365 unsigned int x, y;
366 const DWORD *Source;
367 unsigned char *Dest;
368
369 /* Doesn't work correctly with the fixed function pipeline, but can work in
370 * shaders if the shader is adjusted. (There's no use for this format in gl's
371 * standard fixed function pipeline anyway).
372 */
373 for(y = 0; y < height; y++)
374 {
375 Source = (const DWORD *)(src + y * pitch);
376 Dest = dst + y * pitch;
377 for (x = 0; x < width; x++ )
378 {
379 LONG color = (*Source++);
380 /* B */ Dest[0] = ((color >> 16) & 0xff); /* L */
381 /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
382 /* R */ Dest[2] = (color & 0xff) + 128; /* U */
383 Dest += 4;
384 }
385 }
386 }
387
388 static void convert_r8g8_snorm_l8x8_unorm_nv(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
389 {
390 unsigned int x, y;
391 const DWORD *Source;
392 unsigned char *Dest;
393
394 /* This implementation works with the fixed function pipeline and shaders
395 * without further modification after converting the surface.
396 */
397 for(y = 0; y < height; y++)
398 {
399 Source = (const DWORD *)(src + y * pitch);
400 Dest = dst + y * pitch;
401 for (x = 0; x < width; x++ )
402 {
403 LONG color = (*Source++);
404 /* L */ Dest[2] = ((color >> 16) & 0xff); /* L */
405 /* V */ Dest[1] = ((color >> 8 ) & 0xff); /* V */
406 /* U */ Dest[0] = (color & 0xff); /* U */
407 /* I */ Dest[3] = 255; /* X */
408 Dest += 4;
409 }
410 }
411 }
412
413 static void convert_r8g8b8a8_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
414 {
415 unsigned int x, y;
416 const DWORD *Source;
417 unsigned char *Dest;
418
419 for(y = 0; y < height; y++)
420 {
421 Source = (const DWORD *)(src + y * pitch);
422 Dest = dst + y * pitch;
423 for (x = 0; x < width; x++ )
424 {
425 LONG color = (*Source++);
426 /* B */ Dest[0] = ((color >> 16) & 0xff) + 128; /* W */
427 /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
428 /* R */ Dest[2] = (color & 0xff) + 128; /* U */
429 /* A */ Dest[3] = ((color >> 24) & 0xff) + 128; /* Q */
430 Dest += 4;
431 }
432 }
433 }
434
435 static void convert_r16g16_snorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
436 {
437 unsigned int x, y;
438 const DWORD *Source;
439 unsigned short *Dest;
440 UINT outpitch = (pitch * 3)/2;
441
442 for(y = 0; y < height; y++)
443 {
444 Source = (const DWORD *)(src + y * pitch);
445 Dest = (unsigned short *) (dst + y * outpitch);
446 for (x = 0; x < width; x++ )
447 {
448 const DWORD color = (*Source++);
449 /* B */ Dest[0] = 0xffff;
450 /* G */ Dest[1] = (color >> 16) + 32768; /* V */
451 /* R */ Dest[2] = (color & 0xffff) + 32768; /* U */
452 Dest += 3;
453 }
454 }
455 }
456
457 static void convert_r16g16(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
458 {
459 unsigned int x, y;
460 const WORD *Source;
461 WORD *Dest;
462 UINT outpitch = (pitch * 3)/2;
463
464 for(y = 0; y < height; y++)
465 {
466 Source = (const WORD *)(src + y * pitch);
467 Dest = (WORD *) (dst + y * outpitch);
468 for (x = 0; x < width; x++ )
469 {
470 WORD green = (*Source++);
471 WORD red = (*Source++);
472 Dest[0] = green;
473 Dest[1] = red;
474 /* Strictly speaking not correct for R16G16F, but it doesn't matter because the
475 * shader overwrites it anyway
476 */
477 Dest[2] = 0xffff;
478 Dest += 3;
479 }
480 }
481 }
482
483 static void convert_r32g32_float(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
484 {
485 unsigned int x, y;
486 const float *Source;
487 float *Dest;
488 UINT outpitch = (pitch * 3)/2;
489
490 for(y = 0; y < height; y++)
491 {
492 Source = (const float *)(src + y * pitch);
493 Dest = (float *) (dst + y * outpitch);
494 for (x = 0; x < width; x++ )
495 {
496 float green = (*Source++);
497 float red = (*Source++);
498 Dest[0] = green;
499 Dest[1] = red;
500 Dest[2] = 1.0f;
501 Dest += 3;
502 }
503 }
504 }
505
506 static void convert_s1_uint_d15_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
507 {
508 unsigned int x, y;
509 UINT outpitch = pitch * 2;
510
511 for (y = 0; y < height; ++y)
512 {
513 const WORD *source = (const WORD *)(src + y * pitch);
514 DWORD *dest = (DWORD *)(dst + y * outpitch);
515
516 for (x = 0; x < width; ++x)
517 {
518 /* The depth data is normalized, so needs to be scaled,
519 * the stencil data isn't. Scale depth data by
520 * (2^24-1)/(2^15-1) ~~ (2^9 + 2^-6). */
521 WORD d15 = source[x] >> 1;
522 DWORD d24 = (d15 << 9) + (d15 >> 6);
523 dest[x] = (d24 << 8) | (source[x] & 0x1);
524 }
525 }
526 }
527
528 static void convert_s4x4_uint_d24_unorm(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
529 {
530 unsigned int x, y;
531
532 for (y = 0; y < height; ++y)
533 {
534 const DWORD *source = (const DWORD *)(src + y * pitch);
535 DWORD *dest = (DWORD *)(dst + y * pitch);
536
537 for (x = 0; x < width; ++x)
538 {
539 /* Just need to clear out the X4 part. */
540 dest[x] = source[x] & ~0xf0;
541 }
542 }
543 }
544
545 static void convert_s8_uint_d24_float(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height)
546 {
547 unsigned int x, y;
548 UINT outpitch = pitch * 2;
549
550 for (y = 0; y < height; ++y)
551 {
552 const DWORD *source = (const DWORD *)(src + y * pitch);
553 float *dest_f = (float *)(dst + y * outpitch);
554 DWORD *dest_s = (DWORD *)(dst + y * outpitch);
555
556 for (x = 0; x < width; ++x)
557 {
558 dest_f[x * 2] = float_24_to_32((source[x] & 0xffffff00) >> 8);
559 dest_s[x * 2 + 1] = source[x] & 0xff;
560 }
561 }
562 }
563
564 static const struct wined3d_format_texture_info format_texture_info[] =
565 {
566 /* format id internal srgbInternal rtInternal
567 format type
568 flags
569 extension */
570 /* FourCC formats */
571 /* GL_APPLE_ycbcr_422 claims that its '2YUV' format, which is supported via the UNSIGNED_SHORT_8_8_REV_APPLE type
572 * is equivalent to 'UYVY' format on Windows, and the 'YUVS' via UNSIGNED_SHORT_8_8_APPLE equates to 'YUY2'. The
573 * d3d9 test however shows that the opposite is true. Since the extension is from 2002, it predates the x86 based
574 * Macs, so probably the endianness differs. This could be tested as soon as we have a Windows and MacOS on a big
575 * endian machine
576 */
577 {WINED3DFMT_UYVY, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, 0,
578 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
579 WINED3DFMT_FLAG_FILTERING,
580 WINED3D_GL_EXT_NONE, NULL},
581 {WINED3DFMT_UYVY, GL_RGB, GL_RGB, 0,
582 GL_YCBCR_422_APPLE, UNSIGNED_SHORT_8_8_APPLE, 0,
583 WINED3DFMT_FLAG_FILTERING,
584 APPLE_YCBCR_422, NULL},
585 {WINED3DFMT_YUY2, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, 0,
586 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
587 WINED3DFMT_FLAG_FILTERING,
588 WINED3D_GL_EXT_NONE, NULL},
589 {WINED3DFMT_YUY2, GL_RGB, GL_RGB, 0,
590 GL_YCBCR_422_APPLE, UNSIGNED_SHORT_8_8_REV_APPLE, 0,
591 WINED3DFMT_FLAG_FILTERING,
592 APPLE_YCBCR_422, NULL},
593 {WINED3DFMT_YV12, GL_ALPHA, GL_ALPHA, 0,
594 GL_ALPHA, GL_UNSIGNED_BYTE, 0,
595 WINED3DFMT_FLAG_FILTERING,
596 WINED3D_GL_EXT_NONE, NULL},
597 {WINED3DFMT_DXT1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0,
598 GL_RGBA, GL_UNSIGNED_BYTE, 0,
599 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_SRGB_READ
600 | WINED3DFMT_FLAG_COMPRESSED,
601 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
602 {WINED3DFMT_DXT2, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
603 GL_RGBA, GL_UNSIGNED_BYTE, 0,
604 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_SRGB_READ
605 | WINED3DFMT_FLAG_COMPRESSED,
606 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
607 {WINED3DFMT_DXT3, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
608 GL_RGBA, GL_UNSIGNED_BYTE, 0,
609 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_SRGB_READ
610 | WINED3DFMT_FLAG_COMPRESSED,
611 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
612 {WINED3DFMT_DXT4, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
613 GL_RGBA, GL_UNSIGNED_BYTE, 0,
614 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_SRGB_READ
615 | WINED3DFMT_FLAG_COMPRESSED,
616 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
617 {WINED3DFMT_DXT5, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
618 GL_RGBA, GL_UNSIGNED_BYTE, 0,
619 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_SRGB_READ
620 | WINED3DFMT_FLAG_COMPRESSED,
621 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
622 /* IEEE formats */
623 {WINED3DFMT_R32_FLOAT, GL_RGB32F_ARB, GL_RGB32F_ARB, 0,
624 GL_RED, GL_FLOAT, 0,
625 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
626 ARB_TEXTURE_FLOAT, NULL},
627 {WINED3DFMT_R32_FLOAT, GL_R32F, GL_R32F, 0,
628 GL_RED, GL_FLOAT, 0,
629 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
630 ARB_TEXTURE_RG, NULL},
631 {WINED3DFMT_R32G32_FLOAT, GL_RGB32F_ARB, GL_RGB32F_ARB, 0,
632 GL_RGB, GL_FLOAT, 12,
633 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
634 ARB_TEXTURE_FLOAT, convert_r32g32_float},
635 {WINED3DFMT_R32G32_FLOAT, GL_RG32F, GL_RG32F, 0,
636 GL_RG, GL_FLOAT, 0,
637 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
638 ARB_TEXTURE_RG, NULL},
639 {WINED3DFMT_R32G32B32A32_FLOAT, GL_RGBA32F_ARB, GL_RGBA32F_ARB, 0,
640 GL_RGBA, GL_FLOAT, 0,
641 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
642 ARB_TEXTURE_FLOAT, NULL},
643 /* Float */
644 {WINED3DFMT_R16_FLOAT, GL_RGB16F_ARB, GL_RGB16F_ARB, 0,
645 GL_RED, GL_HALF_FLOAT_ARB, 0,
646 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
647 ARB_TEXTURE_FLOAT, NULL},
648 {WINED3DFMT_R16_FLOAT, GL_R16F, GL_R16F, 0,
649 GL_RED, GL_HALF_FLOAT_ARB, 0,
650 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
651 ARB_TEXTURE_RG, NULL},
652 {WINED3DFMT_R16G16_FLOAT, GL_RGB16F_ARB, GL_RGB16F_ARB, 0,
653 GL_RGB, GL_HALF_FLOAT_ARB, 6,
654 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
655 ARB_TEXTURE_FLOAT, convert_r16g16},
656 {WINED3DFMT_R16G16_FLOAT, GL_RG16F, GL_RG16F, 0,
657 GL_RG, GL_HALF_FLOAT_ARB, 0,
658 WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
659 ARB_TEXTURE_RG, NULL},
660 {WINED3DFMT_R16G16B16A16_FLOAT, GL_RGBA16F_ARB, GL_RGBA16F_ARB, 0,
661 GL_RGBA, GL_HALF_FLOAT_ARB, 0,
662 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
663 ARB_TEXTURE_FLOAT, NULL},
664 /* Palettized formats */
665 {WINED3DFMT_P8_UINT, GL_RGBA, GL_RGBA, 0,
666 GL_ALPHA, GL_UNSIGNED_BYTE, 0,
667 0,
668 ARB_FRAGMENT_PROGRAM, NULL},
669 {WINED3DFMT_P8_UINT, GL_COLOR_INDEX8_EXT, GL_COLOR_INDEX8_EXT, 0,
670 GL_COLOR_INDEX, GL_UNSIGNED_BYTE, 0,
671 0,
672 EXT_PALETTED_TEXTURE, NULL},
673 /* Standard ARGB formats */
674 {WINED3DFMT_B8G8R8_UNORM, GL_RGB8, GL_RGB8, 0,
675 GL_BGR, GL_UNSIGNED_BYTE, 0,
676 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
677 WINED3D_GL_EXT_NONE, NULL},
678 {WINED3DFMT_B8G8R8A8_UNORM, GL_RGBA8, GL_SRGB8_ALPHA8_EXT, 0,
679 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
680 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET
681 | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE | WINED3DFMT_FLAG_VTF,
682 WINED3D_GL_EXT_NONE, NULL},
683 {WINED3DFMT_B8G8R8X8_UNORM, GL_RGB8, GL_SRGB8_EXT, 0,
684 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
685 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET
686 | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE,
687 WINED3D_GL_EXT_NONE, NULL},
688 {WINED3DFMT_B5G6R5_UNORM, GL_RGB5, GL_RGB5, GL_RGB8,
689 GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0,
690 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
691 WINED3D_GL_EXT_NONE, NULL},
692 {WINED3DFMT_B5G5R5X1_UNORM, GL_RGB5, GL_RGB5_A1, 0,
693 GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 0,
694 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
695 WINED3D_GL_EXT_NONE, NULL},
696 {WINED3DFMT_B5G5R5A1_UNORM, GL_RGB5_A1, GL_RGB5_A1, 0,
697 GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 0,
698 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
699 WINED3D_GL_EXT_NONE, NULL},
700 {WINED3DFMT_B4G4R4A4_UNORM, GL_RGBA4, GL_SRGB8_ALPHA8_EXT, 0,
701 GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 0,
702 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_SRGB_READ,
703 WINED3D_GL_EXT_NONE, NULL},
704 {WINED3DFMT_B2G3R3_UNORM, GL_R3_G3_B2, GL_R3_G3_B2, 0,
705 GL_RGB, GL_UNSIGNED_BYTE_3_3_2, 0,
706 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
707 WINED3D_GL_EXT_NONE, NULL},
708 {WINED3DFMT_A8_UNORM, GL_ALPHA8, GL_ALPHA8, 0,
709 GL_ALPHA, GL_UNSIGNED_BYTE, 0,
710 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
711 WINED3D_GL_EXT_NONE, NULL},
712 {WINED3DFMT_B4G4R4X4_UNORM, GL_RGB4, GL_RGB4, 0,
713 GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 0,
714 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
715 WINED3D_GL_EXT_NONE, NULL},
716 {WINED3DFMT_R10G10B10A2_UNORM, GL_RGB10_A2, GL_RGB10_A2, 0,
717 GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, 0,
718 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
719 WINED3D_GL_EXT_NONE, NULL},
720 {WINED3DFMT_R8G8B8A8_UNORM, GL_RGBA8, GL_RGBA8, 0,
721 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
722 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
723 WINED3D_GL_EXT_NONE, NULL},
724 {WINED3DFMT_R8G8B8X8_UNORM, GL_RGB8, GL_RGB8, 0,
725 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
726 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
727 WINED3D_GL_EXT_NONE, NULL},
728 {WINED3DFMT_R16G16_UNORM, GL_RGB16, GL_RGB16, GL_RGBA16,
729 GL_RGB, GL_UNSIGNED_SHORT, 6,
730 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
731 WINED3D_GL_EXT_NONE, convert_r16g16},
732 {WINED3DFMT_B10G10R10A2_UNORM, GL_RGB10_A2, GL_RGB10_A2, 0,
733 GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV, 0,
734 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
735 WINED3D_GL_EXT_NONE, NULL},
736 {WINED3DFMT_R16G16B16A16_UNORM, GL_RGBA16, GL_RGBA16, 0,
737 GL_RGBA, GL_UNSIGNED_SHORT, 0,
738 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
739 WINED3D_GL_EXT_NONE, NULL},
740 /* Luminance */
741 {WINED3DFMT_L8_UNORM, GL_LUMINANCE8, GL_SLUMINANCE8_EXT, 0,
742 GL_LUMINANCE, GL_UNSIGNED_BYTE, 0,
743 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_SRGB_READ,
744 WINED3D_GL_EXT_NONE, NULL},
745 {WINED3DFMT_L8A8_UNORM, GL_LUMINANCE8_ALPHA8, GL_SLUMINANCE8_ALPHA8_EXT, 0,
746 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
747 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_SRGB_READ,
748 WINED3D_GL_EXT_NONE, NULL},
749 {WINED3DFMT_L4A4_UNORM, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE4_ALPHA4, 0,
750 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 2,
751 WINED3DFMT_FLAG_FILTERING,
752 WINED3D_GL_EXT_NONE, convert_l4a4_unorm},
753 /* Bump mapping stuff */
754 {WINED3DFMT_R8G8_SNORM, GL_RGB8, GL_RGB8, 0,
755 GL_BGR, GL_UNSIGNED_BYTE, 3,
756 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
757 WINED3D_GL_EXT_NONE, convert_r8g8_snorm},
758 {WINED3DFMT_R8G8_SNORM, GL_DSDT8_NV, GL_DSDT8_NV, 0,
759 GL_DSDT_NV, GL_BYTE, 0,
760 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
761 NV_TEXTURE_SHADER, NULL},
762 {WINED3DFMT_R5G5_SNORM_L6_UNORM, GL_RGB5, GL_RGB5, 0,
763 GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 2,
764 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
765 WINED3D_GL_EXT_NONE, convert_r5g5_snorm_l6_unorm},
766 {WINED3DFMT_R5G5_SNORM_L6_UNORM, GL_DSDT8_MAG8_NV, GL_DSDT8_MAG8_NV, 0,
767 GL_DSDT_MAG_NV, GL_BYTE, 3,
768 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
769 NV_TEXTURE_SHADER, convert_r5g5_snorm_l6_unorm_nv},
770 {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, GL_RGB8, GL_RGB8, 0,
771 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 4,
772 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
773 WINED3D_GL_EXT_NONE, convert_r8g8_snorm_l8x8_unorm},
774 {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, GL_DSDT8_MAG8_INTENSITY8_NV, GL_DSDT8_MAG8_INTENSITY8_NV, 0,
775 GL_DSDT_MAG_VIB_NV, GL_UNSIGNED_INT_8_8_S8_S8_REV_NV, 4,
776 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
777 NV_TEXTURE_SHADER, convert_r8g8_snorm_l8x8_unorm_nv},
778 {WINED3DFMT_R8G8B8A8_SNORM, GL_RGBA8, GL_RGBA8, 0,
779 GL_BGRA, GL_UNSIGNED_BYTE, 4,
780 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
781 WINED3D_GL_EXT_NONE, convert_r8g8b8a8_snorm},
782 {WINED3DFMT_R8G8B8A8_SNORM, GL_SIGNED_RGBA8_NV, GL_SIGNED_RGBA8_NV, 0,
783 GL_RGBA, GL_BYTE, 0,
784 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
785 NV_TEXTURE_SHADER, NULL},
786 {WINED3DFMT_R16G16_SNORM, GL_RGB16, GL_RGB16, 0,
787 GL_BGR, GL_UNSIGNED_SHORT, 6,
788 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
789 WINED3D_GL_EXT_NONE, convert_r16g16_snorm},
790 {WINED3DFMT_R16G16_SNORM, GL_SIGNED_HILO16_NV, GL_SIGNED_HILO16_NV, 0,
791 GL_HILO_NV, GL_SHORT, 0,
792 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_BUMPMAP,
793 NV_TEXTURE_SHADER, NULL},
794 /* Depth stencil formats */
795 {WINED3DFMT_D16_LOCKABLE, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
796 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 0,
797 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
798 ARB_DEPTH_TEXTURE, NULL},
799 {WINED3DFMT_D32_UNORM, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT32_ARB, 0,
800 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
801 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
802 ARB_DEPTH_TEXTURE, NULL},
803 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
804 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 0,
805 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
806 ARB_DEPTH_TEXTURE, NULL},
807 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
808 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 4,
809 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
810 EXT_PACKED_DEPTH_STENCIL, convert_s1_uint_d15_unorm},
811 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
812 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 4,
813 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
814 ARB_FRAMEBUFFER_OBJECT, convert_s1_uint_d15_unorm},
815 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
816 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
817 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH
818 | WINED3DFMT_FLAG_SHADOW,
819 ARB_DEPTH_TEXTURE, NULL},
820 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
821 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 0,
822 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH
823 | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
824 EXT_PACKED_DEPTH_STENCIL, NULL},
825 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
826 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0,
827 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH
828 | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
829 ARB_FRAMEBUFFER_OBJECT, NULL},
830 {WINED3DFMT_X8D24_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
831 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
832 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH
833 | WINED3DFMT_FLAG_SHADOW,
834 ARB_DEPTH_TEXTURE, NULL},
835 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
836 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
837 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
838 ARB_DEPTH_TEXTURE, NULL},
839 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
840 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 4,
841 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
842 EXT_PACKED_DEPTH_STENCIL, convert_s4x4_uint_d24_unorm},
843 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
844 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 4,
845 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
846 ARB_FRAMEBUFFER_OBJECT, convert_s4x4_uint_d24_unorm},
847 {WINED3DFMT_D16_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
848 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 0,
849 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH
850 | WINED3DFMT_FLAG_SHADOW,
851 ARB_DEPTH_TEXTURE, NULL},
852 {WINED3DFMT_L16_UNORM, GL_LUMINANCE16, GL_LUMINANCE16, 0,
853 GL_LUMINANCE, GL_UNSIGNED_SHORT, 0,
854 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
855 WINED3D_GL_EXT_NONE, NULL},
856 {WINED3DFMT_D32_FLOAT, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT32F, 0,
857 GL_DEPTH_COMPONENT, GL_FLOAT, 0,
858 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
859 ARB_DEPTH_BUFFER_FLOAT, NULL},
860 {WINED3DFMT_S8_UINT_D24_FLOAT, GL_DEPTH32F_STENCIL8, GL_DEPTH32F_STENCIL8, 0,
861 GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, 8,
862 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
863 ARB_DEPTH_BUFFER_FLOAT, convert_s8_uint_d24_float},
864 /* Vendor-specific formats */
865 {WINED3DFMT_ATI2N, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0,
866 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
867 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_COMPRESSED,
868 ATI_TEXTURE_COMPRESSION_3DC, NULL},
869 {WINED3DFMT_ATI2N, GL_COMPRESSED_RED_GREEN_RGTC2, GL_COMPRESSED_RED_GREEN_RGTC2, 0,
870 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
871 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_COMPRESSED,
872 ARB_TEXTURE_COMPRESSION_RGTC, NULL},
873 {WINED3DFMT_INTZ, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
874 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 0,
875 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH
876 | WINED3DFMT_FLAG_STENCIL,
877 EXT_PACKED_DEPTH_STENCIL, NULL},
878 {WINED3DFMT_INTZ, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
879 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0,
880 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH
881 | WINED3DFMT_FLAG_STENCIL,
882 ARB_FRAMEBUFFER_OBJECT, NULL},
883 {WINED3DFMT_NULL, GL_RGBA8, GL_RGBA8, 0,
884 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
885 WINED3DFMT_FLAG_RENDERTARGET,
886 ARB_FRAMEBUFFER_OBJECT, NULL},
887 };
888
889 static inline int getFmtIdx(enum wined3d_format_id format_id)
890 {
891 /* First check if the format is at the position of its value.
892 * This will catch the argb formats before the loop is entered. */
893 if (format_id < (sizeof(formats) / sizeof(*formats))
894 && formats[format_id].id == format_id)
895 {
896 return format_id;
897 }
898 else
899 {
900 unsigned int i;
901
902 for (i = 0; i < (sizeof(formats) / sizeof(*formats)); ++i)
903 {
904 if (formats[i].id == format_id) return i;
905 }
906 }
907 return -1;
908 }
909
910 static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
911 {
912 UINT format_count = sizeof(formats) / sizeof(*formats);
913 UINT i;
914
915 gl_info->formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, format_count * sizeof(*gl_info->formats));
916 if (!gl_info->formats)
917 {
918 ERR("Failed to allocate memory.\n");
919 return FALSE;
920 }
921
922 for (i = 0; i < format_count; ++i)
923 {
924 struct wined3d_format *format = &gl_info->formats[i];
925 format->id = formats[i].id;
926 format->red_mask = formats[i].redMask;
927 format->green_mask = formats[i].greenMask;
928 format->blue_mask = formats[i].blueMask;
929 format->alpha_mask = formats[i].alphaMask;
930 format->byte_count = formats[i].bpp;
931 format->depth_size = formats[i].depthSize;
932 format->stencil_size = formats[i].stencilSize;
933 format->block_width = 1;
934 format->block_height = 1;
935 format->block_byte_count = formats[i].bpp;
936 }
937
938 for (i = 0; i < (sizeof(format_base_flags) / sizeof(*format_base_flags)); ++i)
939 {
940 int fmt_idx = getFmtIdx(format_base_flags[i].id);
941
942 if (fmt_idx == -1)
943 {
944 ERR("Format %s (%#x) not found.\n",
945 debug_d3dformat(format_base_flags[i].id), format_base_flags[i].id);
946 HeapFree(GetProcessHeap(), 0, gl_info->formats);
947 return FALSE;
948 }
949
950 gl_info->formats[fmt_idx].flags |= format_base_flags[i].flags;
951 }
952
953 return TRUE;
954 }
955
956 static BOOL init_format_block_info(struct wined3d_gl_info *gl_info)
957 {
958 unsigned int i;
959
960 for (i = 0; i < (sizeof(format_block_info) / sizeof(*format_block_info)); ++i)
961 {
962 struct wined3d_format *format;
963 int fmt_idx = getFmtIdx(format_block_info[i].id);
964
965 if (fmt_idx == -1)
966 {
967 ERR("Format %s (%#x) not found.\n",
968 debug_d3dformat(format_block_info[i].id), format_block_info[i].id);
969 return FALSE;
970 }
971
972 format = &gl_info->formats[fmt_idx];
973 format->block_width = format_block_info[i].block_width;
974 format->block_height = format_block_info[i].block_height;
975 format->block_byte_count = format_block_info[i].block_byte_count;
976 format->flags |= WINED3DFMT_FLAG_BLOCKS;
977 }
978
979 return TRUE;
980 }
981
982 /* Context activation is done by the caller. */
983 static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct wined3d_format *format)
984 {
985 /* Check if the default internal format is supported as a frame buffer
986 * target, otherwise fall back to the render target internal.
987 *
988 * Try to stick to the standard format if possible, this limits precision differences. */
989 GLenum status;
990 GLuint tex;
991
992 ENTER_GL();
993
994 while(glGetError());
995 glDisable(GL_BLEND);
996
997 glGenTextures(1, &tex);
998 glBindTexture(GL_TEXTURE_2D, tex);
999
1000 glTexImage2D(GL_TEXTURE_2D, 0, format->glInternal, 16, 16, 0, format->glFormat, format->glType, NULL);
1001 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1002 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1003
1004 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
1005
1006 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1007 checkGLcall("Framebuffer format check");
1008
1009 if (status == GL_FRAMEBUFFER_COMPLETE)
1010 {
1011 TRACE("Format %s is supported as FBO color attachment.\n", debug_d3dformat(format->id));
1012 format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
1013 format->rtInternal = format->glInternal;
1014 }
1015 else
1016 {
1017 if (!format->rtInternal)
1018 {
1019 if (format->flags & WINED3DFMT_FLAG_RENDERTARGET)
1020 {
1021 FIXME("Format %s with rendertarget flag is not supported as FBO color attachment,"
1022 " and no fallback specified.\n", debug_d3dformat(format->id));
1023 format->flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
1024 }
1025 else
1026 {
1027 TRACE("Format %s is not supported as FBO color attachment.\n", debug_d3dformat(format->id));
1028 }
1029 format->rtInternal = format->glInternal;
1030 }
1031 else
1032 {
1033 TRACE("Format %s is not supported as FBO color attachment, trying rtInternal format as fallback.\n",
1034 debug_d3dformat(format->id));
1035
1036 while(glGetError());
1037
1038 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
1039
1040 glTexImage2D(GL_TEXTURE_2D, 0, format->rtInternal, 16, 16, 0, format->glFormat, format->glType, NULL);
1041 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1042 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1043
1044 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
1045
1046 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1047 checkGLcall("Framebuffer format check");
1048
1049 if (status == GL_FRAMEBUFFER_COMPLETE)
1050 {
1051 TRACE("Format %s rtInternal format is supported as FBO color attachment.\n",
1052 debug_d3dformat(format->id));
1053 }
1054 else
1055 {
1056 FIXME("Format %s rtInternal format is not supported as FBO color attachment.\n",
1057 debug_d3dformat(format->id));
1058 format->flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
1059 }
1060 }
1061 }
1062
1063 if (status == GL_FRAMEBUFFER_COMPLETE && ((format->flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
1064 || !(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING))
1065 && format->id != WINED3DFMT_NULL && format->id != WINED3DFMT_P8_UINT
1066 && format->glFormat != GL_LUMINANCE && format->glFormat != GL_LUMINANCE_ALPHA)
1067 {
1068 GLuint rb, tex2;
1069 DWORD readback[16 * 16], color;
1070 BYTE r, a;
1071 BOOL match = TRUE;
1072
1073 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
1074 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
1075 {
1076 gl_info->fbo_ops.glGenRenderbuffers(1, &rb);
1077 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, rb);
1078 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 16, 16);
1079 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb);
1080 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rb);
1081 checkGLcall("RB attachment");
1082 }
1083
1084 glEnable(GL_BLEND);
1085 glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
1086 glClear(GL_COLOR_BUFFER_BIT);
1087 if (glGetError() == GL_INVALID_FRAMEBUFFER_OPERATION)
1088 {
1089 while(glGetError());
1090 TRACE("Format doesn't support post-pixelshader blending.\n");
1091 format->flags &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
1092 }
1093 else
1094 {
1095 glViewport(0, 0, 16, 16);
1096 glDisable(GL_LIGHTING);
1097 glMatrixMode(GL_MODELVIEW);
1098 glLoadIdentity();
1099 glMatrixMode(GL_PROJECTION);
1100 glLoadIdentity();
1101
1102 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1103
1104 /* Draw a full-black quad */
1105 glBegin(GL_TRIANGLE_STRIP);
1106 glColor4ub(0x00, 0x00, 0x00, 0xff);
1107 glVertex3f(-1.0f, -1.0f, 0.0f);
1108 glColor4ub(0x00, 0x00, 0x00, 0xff);
1109 glVertex3f(1.0f, -1.0f, 0.0f);
1110 glColor4ub(0x00, 0x00, 0x00, 0xff);
1111 glVertex3f(-1.0f, 1.0f, 0.0f);
1112 glColor4ub(0x00, 0x00, 0x00, 0xff);
1113 glVertex3f(1.0f, 1.0f, 0.0f);
1114 glEnd();
1115
1116 /* Draw a half-transparent red quad */
1117 glBegin(GL_TRIANGLE_STRIP);
1118 glColor4ub(0xff, 0x00, 0x00, 0x80);
1119 glVertex3f(-1.0f, -1.0f, 0.0f);
1120 glColor4ub(0xff, 0x00, 0x00, 0x80);
1121 glVertex3f(1.0f, -1.0f, 0.0f);
1122 glColor4ub(0xff, 0x00, 0x00, 0x80);
1123 glVertex3f(-1.0f, 1.0f, 0.0f);
1124 glColor4ub(0xff, 0x00, 0x00, 0x80);
1125 glVertex3f(1.0f, 1.0f, 0.0f);
1126 glEnd();
1127
1128 glGenTextures(1, &tex2);
1129 glBindTexture(GL_TEXTURE_2D, tex2);
1130
1131 glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, 16, 16, 0);
1132 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
1133 checkGLcall("Post-pixelshader blending check");
1134
1135 color = readback[7 * 16 + 7];
1136 a = color >> 24;
1137 r = (color & 0x00ff0000) >> 16;
1138
1139 if (format->red_mask && (r < 0x7b || r > 0x84))
1140 match = FALSE;
1141 /* If the alpha component is more than 1 bit */
1142 else if ((format->alpha_mask & (format->alpha_mask - 1)) && (a < 0x9f || a > 0xdf))
1143 match = FALSE;
1144 if (!match)
1145 {
1146 TRACE("Format doesn't support post-pixelshader blending.\n");
1147 TRACE("Color output: %#x\n", color);
1148 format->flags &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
1149 }
1150 else
1151 {
1152 TRACE("Format supports post-pixelshader blending.\n");
1153 format->flags |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
1154 }
1155
1156 glBindTexture(GL_TEXTURE_2D, tex);
1157 glDeleteTextures(1, &tex2);
1158 }
1159
1160 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
1161 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
1162 {
1163 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
1164 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
1165 gl_info->fbo_ops.glDeleteRenderbuffers(1, &rb);
1166 checkGLcall("RB cleanup");
1167 }
1168 }
1169
1170 if (format->glInternal != format->glGammaInternal)
1171 {
1172 glTexImage2D(GL_TEXTURE_2D, 0, format->glGammaInternal, 16, 16, 0, format->glFormat, format->glType, NULL);
1173 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
1174
1175 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
1176 checkGLcall("Framebuffer format check");
1177
1178 if (status == GL_FRAMEBUFFER_COMPLETE)
1179 {
1180 TRACE("Format %s's sRGB format is FBO attachable.\n", debug_d3dformat(format->id));
1181 format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
1182 }
1183 else
1184 {
1185 WARN("Format %s's sRGB format is not FBO attachable.\n", debug_d3dformat(format->id));
1186 }
1187 }
1188 else if (status == GL_FRAMEBUFFER_COMPLETE)
1189 format->flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
1190
1191 glDeleteTextures(1, &tex);
1192
1193 LEAVE_GL();
1194 }
1195
1196 /* Context activation is done by the caller. */
1197 static void init_format_fbo_compat_info(struct wined3d_gl_info *gl_info)
1198 {
1199 unsigned int i;
1200 GLuint fbo;
1201
1202 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1203 {
1204 ENTER_GL();
1205
1206 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
1207 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1208 glDrawBuffer(GL_COLOR_ATTACHMENT0);
1209 glReadBuffer(GL_COLOR_ATTACHMENT0);
1210
1211 LEAVE_GL();
1212 }
1213
1214 for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i)
1215 {
1216 struct wined3d_format *format = &gl_info->formats[i];
1217
1218 if (!format->glInternal) continue;
1219
1220 if (format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
1221 {
1222 TRACE("Skipping format %s because it's a depth/stencil format.\n",
1223 debug_d3dformat(format->id));
1224 continue;
1225 }
1226
1227 if (format->flags & WINED3DFMT_FLAG_COMPRESSED)
1228 {
1229 TRACE("Skipping format %s because it's a compressed format.\n",
1230 debug_d3dformat(format->id));
1231 continue;
1232 }
1233
1234 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1235 {
1236 TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(format->id));
1237 check_fbo_compat(gl_info, format);
1238 }
1239 else
1240 {
1241 format->rtInternal = format->glInternal;
1242 }
1243 }
1244
1245 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1246 {
1247 ENTER_GL();
1248
1249 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
1250
1251 LEAVE_GL();
1252 }
1253 }
1254
1255 static BOOL init_format_texture_info(struct wined3d_gl_info *gl_info)
1256 {
1257 unsigned int i;
1258
1259 for (i = 0; i < sizeof(format_texture_info) / sizeof(*format_texture_info); ++i)
1260 {
1261 int fmt_idx = getFmtIdx(format_texture_info[i].id);
1262 struct wined3d_format *format;
1263
1264 if (fmt_idx == -1)
1265 {
1266 ERR("Format %s (%#x) not found.\n",
1267 debug_d3dformat(format_texture_info[i].id), format_texture_info[i].id);
1268 return FALSE;
1269 }
1270
1271 if (!gl_info->supported[format_texture_info[i].extension]) continue;
1272
1273 format = &gl_info->formats[fmt_idx];
1274
1275 /* ARB_texture_rg defines floating point formats, but only if
1276 * ARB_texture_float is also supported. */
1277 if (!gl_info->supported[ARB_TEXTURE_FLOAT]
1278 && (format->flags & WINED3DFMT_FLAG_FLOAT))
1279 continue;
1280
1281 format->glInternal = format_texture_info[i].gl_internal;
1282 format->glGammaInternal = format_texture_info[i].gl_srgb_internal;
1283 format->rtInternal = format_texture_info[i].gl_rt_internal;
1284 format->glFormat = format_texture_info[i].gl_format;
1285 format->glType = format_texture_info[i].gl_type;
1286 format->color_fixup = COLOR_FIXUP_IDENTITY;
1287 format->flags |= format_texture_info[i].flags;
1288 format->height_scale.numerator = 1;
1289 format->height_scale.denominator = 1;
1290
1291 if (format->glGammaInternal != format->glInternal)
1292 {
1293 /* Filter sRGB capabilities if EXT_texture_sRGB is not supported. */
1294 if (!gl_info->supported[EXT_TEXTURE_SRGB])
1295 {
1296 format->glGammaInternal = format->glInternal;
1297 format->flags &= ~(WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
1298 }
1299 else if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
1300 {
1301 format->glInternal = format->glGammaInternal;
1302 }
1303 }
1304
1305 /* Texture conversion stuff */
1306 format->convert = format_texture_info[i].convert;
1307 format->conv_byte_count = format_texture_info[i].conv_byte_count;
1308 }
1309
1310 return TRUE;
1311 }
1312
1313 static BOOL color_match(DWORD c1, DWORD c2, BYTE max_diff)
1314 {
1315 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1316 c1 >>= 8; c2 >>= 8;
1317 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1318 c1 >>= 8; c2 >>= 8;
1319 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1320 c1 >>= 8; c2 >>= 8;
1321 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
1322 return TRUE;
1323 }
1324
1325 /* A context is provided by the caller */
1326 static BOOL check_filter(const struct wined3d_gl_info *gl_info, GLenum internal)
1327 {
1328 static const DWORD data[] = {0x00000000, 0xffffffff};
1329 GLuint tex, fbo, buffer;
1330 DWORD readback[16 * 1];
1331 BOOL ret = FALSE;
1332
1333 /* Render a filtered texture and see what happens. This is intended to detect the lack of
1334 * float16 filtering on ATI X1000 class cards. The drivers disable filtering instead of
1335 * falling back to software. If this changes in the future this code will get fooled and
1336 * apps might hit the software path due to incorrectly advertised caps.
1337 *
1338 * Its unlikely that this changes however. GL Games like Mass Effect depend on the filter
1339 * disable fallback, if Apple or ATI ever change the driver behavior they will break more
1340 * than Wine. The Linux binary <= r500 driver is not maintained any more anyway
1341 */
1342
1343 ENTER_GL();
1344 while(glGetError());
1345
1346 glGenTextures(1, &buffer);
1347 glBindTexture(GL_TEXTURE_2D, buffer);
1348 memset(readback, 0x7e, sizeof(readback));
1349 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, readback);
1350 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1351 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1352 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1353 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1354 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
1355
1356 glGenTextures(1, &tex);
1357 glBindTexture(GL_TEXTURE_2D, tex);
1358 glTexImage2D(GL_TEXTURE_2D, 0, internal, 2, 1, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
1359 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1360 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1361 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1362 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1363 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
1364 glEnable(GL_TEXTURE_2D);
1365
1366 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
1367 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1368 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer, 0);
1369 glDrawBuffer(GL_COLOR_ATTACHMENT0);
1370
1371 glViewport(0, 0, 16, 1);
1372 glDisable(GL_LIGHTING);
1373 glMatrixMode(GL_MODELVIEW);
1374 glLoadIdentity();
1375 glMatrixMode(GL_PROJECTION);
1376 glLoadIdentity();
1377
1378 glClearColor(0, 1, 0, 0);
1379 glClear(GL_COLOR_BUFFER_BIT);
1380
1381 glBegin(GL_TRIANGLE_STRIP);
1382 glTexCoord2f(0.0, 0.0);
1383 glVertex2f(-1.0f, -1.0f);
1384 glTexCoord2f(1.0, 0.0);
1385 glVertex2f(1.0f, -1.0f);
1386 glTexCoord2f(0.0, 1.0);
1387 glVertex2f(-1.0f, 1.0f);
1388 glTexCoord2f(1.0, 1.0);
1389 glVertex2f(1.0f, 1.0f);
1390 glEnd();
1391
1392 glBindTexture(GL_TEXTURE_2D, buffer);
1393 memset(readback, 0x7f, sizeof(readback));
1394 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
1395 if(color_match(readback[6], 0xffffffff, 5) || color_match(readback[6], 0x00000000, 5) ||
1396 color_match(readback[9], 0xffffffff, 5) || color_match(readback[9], 0x00000000, 5))
1397 {
1398 TRACE("Read back colors 0x%08x and 0x%08x close to unfiltered color, asuming no filtering\n",
1399 readback[6], readback[9]);
1400 ret = FALSE;
1401 }
1402 else
1403 {
1404 TRACE("Read back colors are 0x%08x and 0x%08x, assuming texture is filtered\n",
1405 readback[6], readback[9]);
1406 ret = TRUE;
1407 }
1408
1409 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1410 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
1411 glDeleteTextures(1, &tex);
1412 glDeleteTextures(1, &buffer);
1413
1414 if(glGetError())
1415 {
1416 FIXME("Error during filtering test for format %x, returning no filtering\n", internal);
1417 ret = FALSE;
1418 }
1419 LEAVE_GL();
1420 return ret;
1421 }
1422
1423 static void init_format_filter_info(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
1424 {
1425 struct wined3d_format *format;
1426 unsigned int fmt_idx, i;
1427 static const enum wined3d_format_id fmts16[] =
1428 {
1429 WINED3DFMT_R16_FLOAT,
1430 WINED3DFMT_R16G16_FLOAT,
1431 WINED3DFMT_R16G16B16A16_FLOAT,
1432 };
1433 BOOL filtered;
1434
1435 if(wined3d_settings.offscreen_rendering_mode != ORM_FBO)
1436 {
1437 WARN("No FBO support, or no FBO ORM, guessing filter info from GL caps\n");
1438 if (vendor == HW_VENDOR_NVIDIA && gl_info->supported[ARB_TEXTURE_FLOAT])
1439 {
1440 TRACE("Nvidia card with texture_float support: Assuming float16 blending\n");
1441 filtered = TRUE;
1442 }
1443 else if (gl_info->limits.glsl_varyings > 44)
1444 {
1445 TRACE("More than 44 GLSL varyings - assuming d3d10 card with float16 blending\n");
1446 filtered = TRUE;
1447 }
1448 else
1449 {
1450 TRACE("Assuming no float16 blending\n");
1451 filtered = FALSE;
1452 }
1453
1454 if(filtered)
1455 {
1456 for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
1457 {
1458 fmt_idx = getFmtIdx(fmts16[i]);
1459 gl_info->formats[fmt_idx].flags |= WINED3DFMT_FLAG_FILTERING;
1460 }
1461 }
1462 return;
1463 }
1464
1465 for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
1466 {
1467 fmt_idx = getFmtIdx(fmts16[i]);
1468 format = &gl_info->formats[fmt_idx];
1469 if (!format->glInternal) continue; /* Not supported by GL */
1470
1471 filtered = check_filter(gl_info, gl_info->formats[fmt_idx].glInternal);
1472 if(filtered)
1473 {
1474 TRACE("Format %s supports filtering\n", debug_d3dformat(fmts16[i]));
1475 format->flags |= WINED3DFMT_FLAG_FILTERING;
1476 }
1477 else
1478 {
1479 TRACE("Format %s does not support filtering\n", debug_d3dformat(fmts16[i]));
1480 }
1481 }
1482 }
1483
1484 static void apply_format_fixups(struct wined3d_gl_info *gl_info)
1485 {
1486 int idx;
1487
1488 idx = getFmtIdx(WINED3DFMT_R16_FLOAT);
1489 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1490 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1491
1492 idx = getFmtIdx(WINED3DFMT_R32_FLOAT);
1493 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1494 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1495
1496 idx = getFmtIdx(WINED3DFMT_R16G16_UNORM);
1497 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1498 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1499
1500 idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1501 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1502 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1503
1504 idx = getFmtIdx(WINED3DFMT_R32G32_FLOAT);
1505 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1506 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1507
1508 /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
1509 * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
1510 * their extensions are not available. GL_ATI_envmap_bumpmap is not used because
1511 * the only driver that implements it(fglrx) has a buggy implementation.
1512 *
1513 * V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
1514 * returns 0.0 when sampling from it, DirectX 1.0. So we always have in-shader
1515 * conversion for this format.
1516 */
1517 if (!gl_info->supported[NV_TEXTURE_SHADER])
1518 {
1519 idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
1520 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1521 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1522 idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
1523 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1524 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1525 }
1526 else
1527 {
1528 idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
1529 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1530 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1531
1532 idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
1533 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1534 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1535 }
1536
1537 if (!gl_info->supported[NV_TEXTURE_SHADER])
1538 {
1539 /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
1540 * with each other
1541 */
1542 idx = getFmtIdx(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1543 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1544 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
1545 idx = getFmtIdx(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1546 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1547 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
1548 idx = getFmtIdx(WINED3DFMT_R8G8B8A8_SNORM);
1549 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1550 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
1551 }
1552 else
1553 {
1554 /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
1555 * are converted at surface loading time, but they do not need any modification in
1556 * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
1557 * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
1558 */
1559 }
1560
1561 if (gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
1562 {
1563 idx = getFmtIdx(WINED3DFMT_ATI2N);
1564 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
1565 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1566 }
1567 else if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC])
1568 {
1569 idx = getFmtIdx(WINED3DFMT_ATI2N);
1570 gl_info->formats[idx].color_fixup= create_color_fixup_desc(
1571 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1572 }
1573
1574 if (!gl_info->supported[APPLE_YCBCR_422])
1575 {
1576 idx = getFmtIdx(WINED3DFMT_YUY2);
1577 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
1578
1579 idx = getFmtIdx(WINED3DFMT_UYVY);
1580 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY);
1581 }
1582
1583 idx = getFmtIdx(WINED3DFMT_YV12);
1584 gl_info->formats[idx].flags |= WINED3DFMT_FLAG_HEIGHT_SCALE;
1585 gl_info->formats[idx].height_scale.numerator = 3;
1586 gl_info->formats[idx].height_scale.denominator = 2;
1587 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12);
1588
1589 if (gl_info->supported[EXT_PALETTED_TEXTURE] || gl_info->supported[ARB_FRAGMENT_PROGRAM])
1590 {
1591 idx = getFmtIdx(WINED3DFMT_P8_UINT);
1592 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
1593 }
1594
1595 if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
1596 {
1597 idx = getFmtIdx(WINED3DFMT_B8G8R8A8_UNORM);
1598 gl_info->formats[idx].gl_vtx_format = GL_BGRA;
1599 }
1600
1601 if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
1602 {
1603 /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
1604 * It is the job of the vertex buffer code to make sure that the vbos have the right format */
1605 idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1606 gl_info->formats[idx].gl_vtx_type = GL_HALF_FLOAT; /* == GL_HALF_FLOAT_NV */
1607
1608 idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
1609 gl_info->formats[idx].gl_vtx_type = GL_HALF_FLOAT;
1610 }
1611 }
1612
1613 static BOOL init_format_vertex_info(struct wined3d_gl_info *gl_info)
1614 {
1615 unsigned int i;
1616
1617 for (i = 0; i < (sizeof(format_vertex_info) / sizeof(*format_vertex_info)); ++i)
1618 {
1619 struct wined3d_format *format;
1620 int fmt_idx = getFmtIdx(format_vertex_info[i].id);
1621
1622 if (fmt_idx == -1)
1623 {
1624 ERR("Format %s (%#x) not found.\n",
1625 debug_d3dformat(format_vertex_info[i].id), format_vertex_info[i].id);
1626 return FALSE;
1627 }
1628
1629 format = &gl_info->formats[fmt_idx];
1630 format->emit_idx = format_vertex_info[i].emit_idx;
1631 format->component_count = format_vertex_info[i].component_count;
1632 format->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
1633 format->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
1634 format->gl_normalized = format_vertex_info[i].gl_normalized;
1635 format->component_size = format_vertex_info[i].component_size;
1636 }
1637
1638 return TRUE;
1639 }
1640
1641 BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info)
1642 {
1643 if (!init_format_base_info(gl_info)) return FALSE;
1644
1645 if (!init_format_block_info(gl_info))
1646 {
1647 HeapFree(GetProcessHeap(), 0, gl_info->formats);
1648 gl_info->formats = NULL;
1649 return FALSE;
1650 }
1651
1652 return TRUE;
1653 }
1654
1655 /* Context activation is done by the caller. */
1656 BOOL initPixelFormats(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
1657 {
1658 if (!init_format_base_info(gl_info)) return FALSE;
1659
1660 if (!init_format_block_info(gl_info)) goto fail;
1661 if (!init_format_texture_info(gl_info)) goto fail;
1662 if (!init_format_vertex_info(gl_info)) goto fail;
1663
1664 apply_format_fixups(gl_info);
1665 init_format_fbo_compat_info(gl_info);
1666 init_format_filter_info(gl_info, vendor);
1667
1668 return TRUE;
1669
1670 fail:
1671 HeapFree(GetProcessHeap(), 0, gl_info->formats);
1672 gl_info->formats = NULL;
1673 return FALSE;
1674 }
1675
1676 const struct wined3d_format *wined3d_get_format(const struct wined3d_gl_info *gl_info,
1677 enum wined3d_format_id format_id)
1678 {
1679 int idx = getFmtIdx(format_id);
1680
1681 if (idx == -1)
1682 {
1683 FIXME("Can't find format %s (%#x) in the format lookup table\n",
1684 debug_d3dformat(format_id), format_id);
1685 /* Get the caller a valid pointer */
1686 idx = getFmtIdx(WINED3DFMT_UNKNOWN);
1687 }
1688
1689 return &gl_info->formats[idx];
1690 }
1691
1692 UINT wined3d_format_calculate_size(const struct wined3d_format *format, UINT alignment, UINT width, UINT height)
1693 {
1694 UINT size;
1695
1696 if (format->id == WINED3DFMT_UNKNOWN)
1697 {
1698 size = 0;
1699 }
1700 else if (format->flags & WINED3DFMT_FLAG_BLOCKS)
1701 {
1702 UINT row_block_count = (width + format->block_width - 1) / format->block_width;
1703 UINT row_count = (height + format->block_height - 1) / format->block_height;
1704 size = row_count * (((row_block_count * format->block_byte_count) + alignment - 1) & ~(alignment - 1));
1705 }
1706 else
1707 {
1708 size = height * (((width * format->byte_count) + alignment - 1) & ~(alignment - 1));
1709 }
1710
1711 if (format->flags & WINED3DFMT_FLAG_HEIGHT_SCALE)
1712 {
1713 /* The D3D format requirements make sure that the resulting format is an integer again */
1714 size *= format->height_scale.numerator;
1715 size /= format->height_scale.denominator;
1716 }
1717
1718 return size;
1719 }
1720
1721 /*****************************************************************************
1722 * Trace formatting of useful values
1723 */
1724 const char *debug_d3dformat(enum wined3d_format_id format_id)
1725 {
1726 switch (format_id)
1727 {
1728 #define FMT_TO_STR(format_id) case format_id: return #format_id
1729 FMT_TO_STR(WINED3DFMT_UNKNOWN);
1730 FMT_TO_STR(WINED3DFMT_B8G8R8_UNORM);
1731 FMT_TO_STR(WINED3DFMT_B5G5R5X1_UNORM);
1732 FMT_TO_STR(WINED3DFMT_B4G4R4A4_UNORM);
1733 FMT_TO_STR(WINED3DFMT_B2G3R3_UNORM);
1734 FMT_TO_STR(WINED3DFMT_B2G3R3A8_UNORM);
1735 FMT_TO_STR(WINED3DFMT_B4G4R4X4_UNORM);
1736 FMT_TO_STR(WINED3DFMT_R8G8B8X8_UNORM);
1737 FMT_TO_STR(WINED3DFMT_B10G10R10A2_UNORM);
1738 FMT_TO_STR(WINED3DFMT_P8_UINT_A8_UNORM);
1739 FMT_TO_STR(WINED3DFMT_P8_UINT);
1740 FMT_TO_STR(WINED3DFMT_L8_UNORM);
1741 FMT_TO_STR(WINED3DFMT_L8A8_UNORM);
1742 FMT_TO_STR(WINED3DFMT_L4A4_UNORM);
1743 FMT_TO_STR(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1744 FMT_TO_STR(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1745 FMT_TO_STR(WINED3DFMT_R10G11B11_SNORM);
1746 FMT_TO_STR(WINED3DFMT_R10G10B10_SNORM_A2_UNORM);
1747 FMT_TO_STR(WINED3DFMT_UYVY);
1748 FMT_TO_STR(WINED3DFMT_YUY2);
1749 FMT_TO_STR(WINED3DFMT_YV12);
1750 FMT_TO_STR(WINED3DFMT_DXT1);
1751 FMT_TO_STR(WINED3DFMT_DXT2);
1752 FMT_TO_STR(WINED3DFMT_DXT3);
1753 FMT_TO_STR(WINED3DFMT_DXT4);
1754 FMT_TO_STR(WINED3DFMT_DXT5);
1755 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
1756 FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
1757 FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
1758 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
1759 FMT_TO_STR(WINED3DFMT_D32_UNORM);
1760 FMT_TO_STR(WINED3DFMT_S1_UINT_D15_UNORM);
1761 FMT_TO_STR(WINED3DFMT_X8D24_UNORM);
1762 FMT_TO_STR(WINED3DFMT_S4X4_UINT_D24_UNORM);
1763 FMT_TO_STR(WINED3DFMT_L16_UNORM);
1764 FMT_TO_STR(WINED3DFMT_S8_UINT_D24_FLOAT);
1765 FMT_TO_STR(WINED3DFMT_VERTEXDATA);
1766 FMT_TO_STR(WINED3DFMT_R8G8_SNORM_Cx);
1767 FMT_TO_STR(WINED3DFMT_ATI2N);
1768 FMT_TO_STR(WINED3DFMT_NVDB);
1769 FMT_TO_STR(WINED3DFMT_NVHU);
1770 FMT_TO_STR(WINED3DFMT_NVHS);
1771 FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS);
1772 FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT);
1773 FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT);
1774 FMT_TO_STR(WINED3DFMT_R32G32B32A32_SINT);
1775 FMT_TO_STR(WINED3DFMT_R32G32B32_TYPELESS);
1776 FMT_TO_STR(WINED3DFMT_R32G32B32_FLOAT);
1777 FMT_TO_STR(WINED3DFMT_R32G32B32_UINT);
1778 FMT_TO_STR(WINED3DFMT_R32G32B32_SINT);
1779 FMT_TO_STR(WINED3DFMT_R16G16B16A16_TYPELESS);
1780 FMT_TO_STR(WINED3DFMT_R16G16B16A16_FLOAT);
1781 FMT_TO_STR(WINED3DFMT_R16G16B16A16_UNORM);
1782 FMT_TO_STR(WINED3DFMT_R16G16B16A16_UINT);
1783 FMT_TO_STR(WINED3DFMT_R16G16B16A16_SNORM);
1784 FMT_TO_STR(WINED3DFMT_R16G16B16A16_SINT);
1785 FMT_TO_STR(WINED3DFMT_R32G32_TYPELESS);
1786 FMT_TO_STR(WINED3DFMT_R32G32_FLOAT);
1787 FMT_TO_STR(WINED3DFMT_R32G32_UINT);
1788 FMT_TO_STR(WINED3DFMT_R32G32_SINT);
1789 FMT_TO_STR(WINED3DFMT_R32G8X24_TYPELESS);
1790 FMT_TO_STR(WINED3DFMT_D32_FLOAT_S8X24_UINT);
1791 FMT_TO_STR(WINED3DFMT_R32_FLOAT_X8X24_TYPELESS);
1792 FMT_TO_STR(WINED3DFMT_X32_TYPELESS_G8X24_UINT);
1793 FMT_TO_STR(WINED3DFMT_R10G10B10A2_TYPELESS);
1794 FMT_TO_STR(WINED3DFMT_R10G10B10A2_UNORM);
1795 FMT_TO_STR(WINED3DFMT_R10G10B10A2_UINT);
1796 FMT_TO_STR(WINED3DFMT_R10G10B10A2_SNORM);
1797 FMT_TO_STR(WINED3DFMT_R11G11B10_FLOAT);
1798 FMT_TO_STR(WINED3DFMT_R8G8B8A8_TYPELESS);
1799 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM);
1800 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM_SRGB);
1801 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UINT);
1802 FMT_TO_STR(WINED3DFMT_R8G8B8A8_SNORM);
1803 FMT_TO_STR(WINED3DFMT_R8G8B8A8_SINT);
1804 FMT_TO_STR(WINED3DFMT_R16G16_TYPELESS);
1805 FMT_TO_STR(WINED3DFMT_R16G16_FLOAT);
1806 FMT_TO_STR(WINED3DFMT_R16G16_UNORM);
1807 FMT_TO_STR(WINED3DFMT_R16G16_UINT);
1808 FMT_TO_STR(WINED3DFMT_R16G16_SNORM);
1809 FMT_TO_STR(WINED3DFMT_R16G16_SINT);
1810 FMT_TO_STR(WINED3DFMT_R32_TYPELESS);
1811 FMT_TO_STR(WINED3DFMT_D32_FLOAT);
1812 FMT_TO_STR(WINED3DFMT_R32_FLOAT);
1813 FMT_TO_STR(WINED3DFMT_R32_UINT);
1814 FMT_TO_STR(WINED3DFMT_R32_SINT);
1815 FMT_TO_STR(WINED3DFMT_R24G8_TYPELESS);
1816 FMT_TO_STR(WINED3DFMT_D24_UNORM_S8_UINT);
1817 FMT_TO_STR(WINED3DFMT_R24_UNORM_X8_TYPELESS);
1818 FMT_TO_STR(WINED3DFMT_X24_TYPELESS_G8_UINT);
1819 FMT_TO_STR(WINED3DFMT_R8G8_TYPELESS);
1820 FMT_TO_STR(WINED3DFMT_R8G8_UNORM);
1821 FMT_TO_STR(WINED3DFMT_R8G8_UINT);
1822 FMT_TO_STR(WINED3DFMT_R8G8_SNORM);
1823 FMT_TO_STR(WINED3DFMT_R8G8_SINT);
1824 FMT_TO_STR(WINED3DFMT_R16_TYPELESS);
1825 FMT_TO_STR(WINED3DFMT_R16_FLOAT);
1826 FMT_TO_STR(WINED3DFMT_D16_UNORM);
1827 FMT_TO_STR(WINED3DFMT_R16_UNORM);
1828 FMT_TO_STR(WINED3DFMT_R16_UINT);
1829 FMT_TO_STR(WINED3DFMT_R16_SNORM);
1830 FMT_TO_STR(WINED3DFMT_R16_SINT);
1831 FMT_TO_STR(WINED3DFMT_R8_TYPELESS);
1832 FMT_TO_STR(WINED3DFMT_R8_UNORM);
1833 FMT_TO_STR(WINED3DFMT_R8_UINT);
1834 FMT_TO_STR(WINED3DFMT_R8_SNORM);
1835 FMT_TO_STR(WINED3DFMT_R8_SINT);
1836 FMT_TO_STR(WINED3DFMT_A8_UNORM);
1837 FMT_TO_STR(WINED3DFMT_R1_UNORM);
1838 FMT_TO_STR(WINED3DFMT_R9G9B9E5_SHAREDEXP);
1839 FMT_TO_STR(WINED3DFMT_R8G8_B8G8_UNORM);
1840 FMT_TO_STR(WINED3DFMT_G8R8_G8B8_UNORM);
1841 FMT_TO_STR(WINED3DFMT_BC1_TYPELESS);
1842 FMT_TO_STR(WINED3DFMT_BC1_UNORM);
1843 FMT_TO_STR(WINED3DFMT_BC1_UNORM_SRGB);
1844 FMT_TO_STR(WINED3DFMT_BC2_TYPELESS);
1845 FMT_TO_STR(WINED3DFMT_BC2_UNORM);
1846 FMT_TO_STR(WINED3DFMT_BC2_UNORM_SRGB);
1847 FMT_TO_STR(WINED3DFMT_BC3_TYPELESS);
1848 FMT_TO_STR(WINED3DFMT_BC3_UNORM);
1849 FMT_TO_STR(WINED3DFMT_BC3_UNORM_SRGB);
1850 FMT_TO_STR(WINED3DFMT_BC4_TYPELESS);
1851 FMT_TO_STR(WINED3DFMT_BC4_UNORM);
1852 FMT_TO_STR(WINED3DFMT_BC4_SNORM);
1853 FMT_TO_STR(WINED3DFMT_BC5_TYPELESS);
1854 FMT_TO_STR(WINED3DFMT_BC5_UNORM);
1855 FMT_TO_STR(WINED3DFMT_BC5_SNORM);
1856 FMT_TO_STR(WINED3DFMT_B5G6R5_UNORM);
1857 FMT_TO_STR(WINED3DFMT_B5G5R5A1_UNORM);
1858 FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM);
1859 FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM);
1860 FMT_TO_STR(WINED3DFMT_INTZ);
1861 FMT_TO_STR(WINED3DFMT_NULL);
1862 FMT_TO_STR(WINED3DFMT_R16);
1863 FMT_TO_STR(WINED3DFMT_AL16);
1864 #undef FMT_TO_STR
1865 default:
1866 {
1867 char fourcc[5];
1868 fourcc[0] = (char)(format_id);
1869 fourcc[1] = (char)(format_id >> 8);
1870 fourcc[2] = (char)(format_id >> 16);
1871 fourcc[3] = (char)(format_id >> 24);
1872 fourcc[4] = 0;
1873 if (isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]))
1874 FIXME("Unrecognized %#x (as fourcc: %s) WINED3DFORMAT!\n", format_id, fourcc);
1875 else
1876 FIXME("Unrecognized %#x WINED3DFORMAT!\n", format_id);
1877 }
1878 return "unrecognized";
1879 }
1880 }
1881
1882 const char *debug_d3ddevicetype(enum wined3d_device_type device_type)
1883 {
1884 switch (device_type)
1885 {
1886 #define DEVTYPE_TO_STR(dev) case dev: return #dev
1887 DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_HAL);
1888 DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_REF);
1889 DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_SW);
1890 #undef DEVTYPE_TO_STR
1891 default:
1892 FIXME("Unrecognized device type %#x.\n", device_type);
1893 return "unrecognized";
1894 }
1895 }
1896
1897 const char *debug_d3dusage(DWORD usage)
1898 {
1899 char buf[333];
1900
1901 buf[0] = '\0';
1902 #define WINED3DUSAGE_TO_STR(u) if (usage & u) { strcat(buf, " | "#u); usage &= ~u; }
1903 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
1904 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
1905 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
1906 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
1907 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
1908 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
1909 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
1910 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
1911 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
1912 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
1913 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
1914 WINED3DUSAGE_TO_STR(WINED3DUSAGE_STATICDECL);
1915 WINED3DUSAGE_TO_STR(WINED3DUSAGE_OVERLAY);
1916 #undef WINED3DUSAGE_TO_STR
1917 if (usage) FIXME("Unrecognized usage flag(s) %#x\n", usage);
1918
1919 return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1920 }
1921
1922 const char *debug_d3dusagequery(DWORD usagequery)
1923 {
1924 char buf[238];
1925
1926 buf[0] = '\0';
1927 #define WINED3DUSAGEQUERY_TO_STR(u) if (usagequery & u) { strcat(buf, " | "#u); usagequery &= ~u; }
1928 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
1929 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
1930 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
1931 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
1932 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
1933 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
1934 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
1935 #undef WINED3DUSAGEQUERY_TO_STR
1936 if (usagequery) FIXME("Unrecognized usage query flag(s) %#x\n", usagequery);
1937
1938 return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1939 }
1940
1941 const char *debug_d3ddeclmethod(enum wined3d_decl_method method)
1942 {
1943 switch (method)
1944 {
1945 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
1946 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_DEFAULT);
1947 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_PARTIAL_U);
1948 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_PARTIAL_V);
1949 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_CROSS_UV);
1950 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_UV);
1951 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_LOOKUP);
1952 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_LOOKUP_PRESAMPLED);
1953 #undef WINED3DDECLMETHOD_TO_STR
1954 default:
1955 FIXME("Unrecognized declaration method %#x.\n", method);
1956 return "unrecognized";
1957 }
1958 }
1959
1960 const char *debug_d3ddeclusage(enum wined3d_decl_usage usage)
1961 {
1962 switch (usage)
1963 {
1964 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
1965 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_POSITION);
1966 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BLEND_WEIGHT);
1967 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BLEND_INDICES);
1968 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_NORMAL);
1969 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_PSIZE);
1970 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TEXCOORD);
1971 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TANGENT);
1972 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BINORMAL);
1973 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TESS_FACTOR);
1974 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_POSITIONT);
1975 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_COLOR);
1976 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_FOG);
1977 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_DEPTH);
1978 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_SAMPLE);
1979 #undef WINED3DDECLUSAGE_TO_STR
1980 default:
1981 FIXME("Unrecognized %u declaration usage!\n", usage);
1982 return "unrecognized";
1983 }
1984 }
1985
1986 const char *debug_d3dresourcetype(enum wined3d_resource_type resource_type)
1987 {
1988 switch (resource_type)
1989 {
1990 #define RES_TO_STR(res) case res: return #res
1991 RES_TO_STR(WINED3D_RTYPE_SURFACE);
1992 RES_TO_STR(WINED3D_RTYPE_VOLUME);
1993 RES_TO_STR(WINED3D_RTYPE_TEXTURE);
1994 RES_TO_STR(WINED3D_RTYPE_VOLUME_TEXTURE);
1995 RES_TO_STR(WINED3D_RTYPE_CUBE_TEXTURE);
1996 RES_TO_STR(WINED3D_RTYPE_BUFFER);
1997 #undef RES_TO_STR
1998 default:
1999 FIXME("Unrecognized resource type %#x.\n", resource_type);
2000 return "unrecognized";
2001 }
2002 }
2003
2004 const char *debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type)
2005 {
2006 switch (primitive_type)
2007 {
2008 #define PRIM_TO_STR(prim) case prim: return #prim
2009 PRIM_TO_STR(WINED3D_PT_UNDEFINED);
2010 PRIM_TO_STR(WINED3D_PT_POINTLIST);
2011 PRIM_TO_STR(WINED3D_PT_LINELIST);
2012 PRIM_TO_STR(WINED3D_PT_LINESTRIP);
2013 PRIM_TO_STR(WINED3D_PT_TRIANGLELIST);
2014 PRIM_TO_STR(WINED3D_PT_TRIANGLESTRIP);
2015 PRIM_TO_STR(WINED3D_PT_TRIANGLEFAN);
2016 PRIM_TO_STR(WINED3D_PT_LINELIST_ADJ);
2017 PRIM_TO_STR(WINED3D_PT_LINESTRIP_ADJ);
2018 PRIM_TO_STR(WINED3D_PT_TRIANGLELIST_ADJ);
2019 PRIM_TO_STR(WINED3D_PT_TRIANGLESTRIP_ADJ);
2020 #undef PRIM_TO_STR
2021 default:
2022 FIXME("Unrecognized %u primitive type!\n", primitive_type);
2023 return "unrecognized";
2024 }
2025 }
2026
2027 const char *debug_d3drenderstate(enum wined3d_render_state state)
2028 {
2029 switch (state)
2030 {
2031 #define D3DSTATE_TO_STR(u) case u: return #u
2032 D3DSTATE_TO_STR(WINED3D_RS_ANTIALIAS);
2033 D3DSTATE_TO_STR(WINED3D_RS_TEXTUREPERSPECTIVE);
2034 D3DSTATE_TO_STR(WINED3D_RS_WRAPU);
2035 D3DSTATE_TO_STR(WINED3D_RS_WRAPV);
2036 D3DSTATE_TO_STR(WINED3D_RS_ZENABLE);
2037 D3DSTATE_TO_STR(WINED3D_RS_FILLMODE);
2038 D3DSTATE_TO_STR(WINED3D_RS_SHADEMODE);
2039 D3DSTATE_TO_STR(WINED3D_RS_LINEPATTERN);
2040 D3DSTATE_TO_STR(WINED3D_RS_MONOENABLE);
2041 D3DSTATE_TO_STR(WINED3D_RS_ROP2);
2042 D3DSTATE_TO_STR(WINED3D_RS_PLANEMASK);
2043 D3DSTATE_TO_STR(WINED3D_RS_ZWRITEENABLE);
2044 D3DSTATE_TO_STR(WINED3D_RS_ALPHATESTENABLE);
2045 D3DSTATE_TO_STR(WINED3D_RS_LASTPIXEL);
2046 D3DSTATE_TO_STR(WINED3D_RS_SRCBLEND);
2047 D3DSTATE_TO_STR(WINED3D_RS_DESTBLEND);
2048 D3DSTATE_TO_STR(WINED3D_RS_CULLMODE);
2049 D3DSTATE_TO_STR(WINED3D_RS_ZFUNC);
2050 D3DSTATE_TO_STR(WINED3D_RS_ALPHAREF);
2051 D3DSTATE_TO_STR(WINED3D_RS_ALPHAFUNC);
2052 D3DSTATE_TO_STR(WINED3D_RS_DITHERENABLE);
2053 D3DSTATE_TO_STR(WINED3D_RS_ALPHABLENDENABLE);
2054 D3DSTATE_TO_STR(WINED3D_RS_FOGENABLE);
2055 D3DSTATE_TO_STR(WINED3D_RS_SPECULARENABLE);
2056 D3DSTATE_TO_STR(WINED3D_RS_ZVISIBLE);
2057 D3DSTATE_TO_STR(WINED3D_RS_SUBPIXEL);
2058 D3DSTATE_TO_STR(WINED3D_RS_SUBPIXELX);
2059 D3DSTATE_TO_STR(WINED3D_RS_STIPPLEDALPHA);
2060 D3DSTATE_TO_STR(WINED3D_RS_FOGCOLOR);
2061 D3DSTATE_TO_STR(WINED3D_RS_FOGTABLEMODE);
2062 D3DSTATE_TO_STR(WINED3D_RS_FOGSTART);
2063 D3DSTATE_TO_STR(WINED3D_RS_FOGEND);
2064 D3DSTATE_TO_STR(WINED3D_RS_FOGDENSITY);
2065 D3DSTATE_TO_STR(WINED3D_RS_STIPPLEENABLE);
2066 D3DSTATE_TO_STR(WINED3D_RS_EDGEANTIALIAS);
2067 D3DSTATE_TO_STR(WINED3D_RS_COLORKEYENABLE);
2068 D3DSTATE_TO_STR(WINED3D_RS_MIPMAPLODBIAS);
2069 D3DSTATE_TO_STR(WINED3D_RS_RANGEFOGENABLE);
2070 D3DSTATE_TO_STR(WINED3D_RS_ANISOTROPY);
2071 D3DSTATE_TO_STR(WINED3D_RS_FLUSHBATCH);
2072 D3DSTATE_TO_STR(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT);
2073 D3DSTATE_TO_STR(WINED3D_RS_STENCILENABLE);
2074 D3DSTATE_TO_STR(WINED3D_RS_STENCILFAIL);
2075 D3DSTATE_TO_STR(WINED3D_RS_STENCILZFAIL);
2076 D3DSTATE_TO_STR(WINED3D_RS_STENCILPASS);
2077 D3DSTATE_TO_STR(WINED3D_RS_STENCILFUNC);
2078 D3DSTATE_TO_STR(WINED3D_RS_STENCILREF);
2079 D3DSTATE_TO_STR(WINED3D_RS_STENCILMASK);
2080 D3DSTATE_TO_STR(WINED3D_RS_STENCILWRITEMASK);
2081 D3DSTATE_TO_STR(WINED3D_RS_TEXTUREFACTOR);
2082 D3DSTATE_TO_STR(WINED3D_RS_WRAP0);
2083 D3DSTATE_TO_STR(WINED3D_RS_WRAP1);
2084 D3DSTATE_TO_STR(WINED3D_RS_WRAP2);
2085 D3DSTATE_TO_STR(WINED3D_RS_WRAP3);
2086 D3DSTATE_TO_STR(WINED3D_RS_WRAP4);
2087 D3DSTATE_TO_STR(WINED3D_RS_WRAP5);
2088 D3DSTATE_TO_STR(WINED3D_RS_WRAP6);
2089 D3DSTATE_TO_STR(WINED3D_RS_WRAP7);
2090 D3DSTATE_TO_STR(WINED3D_RS_CLIPPING);
2091 D3DSTATE_TO_STR(WINED3D_RS_LIGHTING);
2092 D3DSTATE_TO_STR(WINED3D_RS_EXTENTS);
2093 D3DSTATE_TO_STR(WINED3D_RS_AMBIENT);
2094 D3DSTATE_TO_STR(WINED3D_RS_FOGVERTEXMODE);
2095 D3DSTATE_TO_STR(WINED3D_RS_COLORVERTEX);
2096 D3DSTATE_TO_STR(WINED3D_RS_LOCALVIEWER);
2097 D3DSTATE_TO_STR(WINED3D_RS_NORMALIZENORMALS);
2098 D3DSTATE_TO_STR(WINED3D_RS_COLORKEYBLENDENABLE);
2099 D3DSTATE_TO_STR(WINED3D_RS_DIFFUSEMATERIALSOURCE);
2100 D3DSTATE_TO_STR(WINED3D_RS_SPECULARMATERIALSOURCE);
2101 D3DSTATE_TO_STR(WINED3D_RS_AMBIENTMATERIALSOURCE);
2102 D3DSTATE_TO_STR(WINED3D_RS_EMISSIVEMATERIALSOURCE);
2103 D3DSTATE_TO_STR(WINED3D_RS_VERTEXBLEND);
2104 D3DSTATE_TO_STR(WINED3D_RS_CLIPPLANEENABLE);
2105 D3DSTATE_TO_STR(WINED3D_RS_SOFTWAREVERTEXPROCESSING);
2106 D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE);
2107 D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE_MIN);
2108 D3DSTATE_TO_STR(WINED3D_RS_POINTSPRITEENABLE);
2109 D3DSTATE_TO_STR(WINED3D_RS_POINTSCALEENABLE);
2110 D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_A);
2111 D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_B);
2112 D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_C);
2113 D3DSTATE_TO_STR(WINED3D_RS_MULTISAMPLEANTIALIAS);
2114 D3DSTATE_TO_STR(WINED3D_RS_MULTISAMPLEMASK);
2115 D3DSTATE_TO_STR(WINED3D_RS_PATCHEDGESTYLE);
2116 D3DSTATE_TO_STR(WINED3D_RS_PATCHSEGMENTS);
2117 D3DSTATE_TO_STR(WINED3D_RS_DEBUGMONITORTOKEN);
2118 D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE_MAX);
2119 D3DSTATE_TO_STR(WINED3D_RS_INDEXEDVERTEXBLENDENABLE);
2120 D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE);
2121 D3DSTATE_TO_STR(WINED3D_RS_TWEENFACTOR);
2122 D3DSTATE_TO_STR(WINED3D_RS_BLENDOP);
2123 D3DSTATE_TO_STR(WINED3D_RS_POSITIONDEGREE);
2124 D3DSTATE_TO_STR(WINED3D_RS_NORMALDEGREE);
2125 D3DSTATE_TO_STR(WINED3D_RS_SCISSORTESTENABLE);
2126 D3DSTATE_TO_STR(WINED3D_RS_SLOPESCALEDEPTHBIAS);
2127 D3DSTATE_TO_STR(WINED3D_RS_ANTIALIASEDLINEENABLE);
2128 D3DSTATE_TO_STR(WINED3D_RS_MINTESSELLATIONLEVEL);
2129 D3DSTATE_TO_STR(WINED3D_RS_MAXTESSELLATIONLEVEL);
2130 D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_X);
2131 D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_Y);
2132 D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_Z);
2133 D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_W);
2134 D3DSTATE_TO_STR(WINED3D_RS_ENABLEADAPTIVETESSELLATION);
2135 D3DSTATE_TO_STR(WINED3D_RS_TWOSIDEDSTENCILMODE);
2136 D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILFAIL);
2137 D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILZFAIL);
2138 D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILPASS);
2139 D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILFUNC);
2140 D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE1);
2141 D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE2);
2142 D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE3);
2143 D3DSTATE_TO_STR(WINED3D_RS_BLENDFACTOR);
2144 D3DSTATE_TO_STR(WINED3D_RS_SRGBWRITEENABLE);
2145 D3DSTATE_TO_STR(WINED3D_RS_DEPTHBIAS);
2146 D3DSTATE_TO_STR(WINED3D_RS_WRAP8);
2147 D3DSTATE_TO_STR(WINED3D_RS_WRAP9);
2148 D3DSTATE_TO_STR(WINED3D_RS_WRAP10);
2149 D3DSTATE_TO_STR(WINED3D_RS_WRAP11);
2150 D3DSTATE_TO_STR(WINED3D_RS_WRAP12);
2151 D3DSTATE_TO_STR(WINED3D_RS_WRAP13);
2152 D3DSTATE_TO_STR(WINED3D_RS_WRAP14);
2153 D3DSTATE_TO_STR(WINED3D_RS_WRAP15);
2154 D3DSTATE_TO_STR(WINED3D_RS_SEPARATEALPHABLENDENABLE);
2155 D3DSTATE_TO_STR(WINED3D_RS_SRCBLENDALPHA);
2156 D3DSTATE_TO_STR(WINED3D_RS_DESTBLENDALPHA);
2157 D3DSTATE_TO_STR(WINED3D_RS_BLENDOPALPHA);
2158 #undef D3DSTATE_TO_STR
2159 default:
2160 FIXME("Unrecognized %u render state!\n", state);
2161 return "unrecognized";
2162 }
2163 }
2164
2165 const char *debug_d3dsamplerstate(enum wined3d_sampler_state state)
2166 {
2167 switch (state)
2168 {
2169 #define D3DSTATE_TO_STR(u) case u: return #u
2170 D3DSTATE_TO_STR(WINED3D_SAMP_BORDER_COLOR);
2171 D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_U);
2172 D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_V);
2173 D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_W);
2174 D3DSTATE_TO_STR(WINED3D_SAMP_MAG_FILTER);
2175 D3DSTATE_TO_STR(WINED3D_SAMP_MIN_FILTER);
2176 D3DSTATE_TO_STR(WINED3D_SAMP_MIP_FILTER);
2177 D3DSTATE_TO_STR(WINED3D_SAMP_MIPMAP_LOD_BIAS);
2178 D3DSTATE_TO_STR(WINED3D_SAMP_MAX_MIP_LEVEL);
2179 D3DSTATE_TO_STR(WINED3D_SAMP_MAX_ANISOTROPY);
2180 D3DSTATE_TO_STR(WINED3D_SAMP_SRGB_TEXTURE);
2181 D3DSTATE_TO_STR(WINED3D_SAMP_ELEMENT_INDEX);
2182 D3DSTATE_TO_STR(WINED3D_SAMP_DMAP_OFFSET);
2183 #undef D3DSTATE_TO_STR
2184 default:
2185 FIXME("Unrecognized %u sampler state!\n", state);
2186 return "unrecognized";
2187 }
2188 }
2189
2190 const char *debug_d3dtexturefiltertype(enum wined3d_texture_filter_type filter_type)
2191 {
2192 switch (filter_type)
2193 {
2194 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
2195 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_NONE);
2196 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_POINT);
2197 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_LINEAR);
2198 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_ANISOTROPIC);
2199 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_FLAT_CUBIC);
2200 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_GAUSSIAN_CUBIC);
2201 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_PYRAMIDAL_QUAD);
2202 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_GAUSSIAN_QUAD);
2203 #undef D3DTEXTUREFILTERTYPE_TO_STR
2204 default:
2205 FIXME("Unrecognied texture filter type 0x%08x.\n", filter_type);
2206 return "unrecognized";
2207 }
2208 }
2209
2210 const char *debug_d3dtexturestate(enum wined3d_texture_stage_state state)
2211 {
2212 switch (state)
2213 {
2214 #define D3DSTATE_TO_STR(u) case u: return #u
2215 D3DSTATE_TO_STR(WINED3D_TSS_COLOR_OP);
2216 D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG1);
2217 D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG2);
2218 D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_OP);
2219 D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG1);
2220 D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG2);
2221 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT00);
2222 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT01);
2223 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT10);
2224 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT11);
2225 D3DSTATE_TO_STR(WINED3D_TSS_TEXCOORD_INDEX);
2226 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_LSCALE);
2227 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_LOFFSET);
2228 D3DSTATE_TO_STR(WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS);
2229 D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG0);
2230 D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG0);
2231 D3DSTATE_TO_STR(WINED3D_TSS_RESULT_ARG);
2232 D3DSTATE_TO_STR(WINED3D_TSS_CONSTANT);
2233 #undef D3DSTATE_TO_STR
2234 default:
2235 FIXME("Unrecognized %u texture state!\n", state);
2236 return "unrecognized";
2237 }
2238 }
2239
2240 const char *debug_d3dtop(enum wined3d_texture_op d3dtop)
2241 {
2242 switch (d3dtop)
2243 {
2244 #define D3DTOP_TO_STR(u) case u: return #u
2245 D3DTOP_TO_STR(WINED3D_TOP_DISABLE);
2246 D3DTOP_TO_STR(WINED3D_TOP_SELECT_ARG1);
2247 D3DTOP_TO_STR(WINED3D_TOP_SELECT_ARG2);
2248 D3DTOP_TO_STR(WINED3D_TOP_MODULATE);
2249 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_2X);
2250 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_4X);
2251 D3DTOP_TO_STR(WINED3D_TOP_ADD);
2252 D3DTOP_TO_STR(WINED3D_TOP_ADD_SIGNED);
2253 D3DTOP_TO_STR(WINED3D_TOP_ADD_SIGNED_2X);
2254 D3DTOP_TO_STR(WINED3D_TOP_SUBTRACT);
2255 D3DTOP_TO_STR(WINED3D_TOP_ADD_SMOOTH);
2256 D3DTOP_TO_STR(WINED3D_TOP_BLEND_DIFFUSE_ALPHA);
2257 D3DTOP_TO_STR(WINED3D_TOP_BLEND_TEXTURE_ALPHA);
2258 D3DTOP_TO_STR(WINED3D_TOP_BLEND_FACTOR_ALPHA);
2259 D3DTOP_TO_STR(WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM);
2260 D3DTOP_TO_STR(WINED3D_TOP_BLEND_CURRENT_ALPHA);
2261 D3DTOP_TO_STR(WINED3D_TOP_PREMODULATE);
2262 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR);
2263 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA);
2264 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR);
2265 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA);
2266 D3DTOP_TO_STR(WINED3D_TOP_BUMPENVMAP);
2267 D3DTOP_TO_STR(WINED3D_TOP_BUMPENVMAP_LUMINANCE);
2268 D3DTOP_TO_STR(WINED3D_TOP_DOTPRODUCT3);
2269 D3DTOP_TO_STR(WINED3D_TOP_MULTIPLY_ADD);
2270 D3DTOP_TO_STR(WINED3D_TOP_LERP);
2271 #undef D3DTOP_TO_STR
2272 default:
2273 FIXME("Unrecognized texture op %#x.\n", d3dtop);
2274 return "unrecognized";
2275 }
2276 }
2277
2278 const char *debug_d3dtstype(enum wined3d_transform_state tstype)
2279 {
2280 switch (tstype)
2281 {
2282 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
2283 TSTYPE_TO_STR(WINED3D_TS_VIEW);
2284 TSTYPE_TO_STR(WINED3D_TS_PROJECTION);
2285 TSTYPE_TO_STR(WINED3D_TS_TEXTURE0);
2286 TSTYPE_TO_STR(WINED3D_TS_TEXTURE1);
2287 TSTYPE_TO_STR(WINED3D_TS_TEXTURE2);
2288 TSTYPE_TO_STR(WINED3D_TS_TEXTURE3);
2289 TSTYPE_TO_STR(WINED3D_TS_TEXTURE4);
2290 TSTYPE_TO_STR(WINED3D_TS_TEXTURE5);
2291 TSTYPE_TO_STR(WINED3D_TS_TEXTURE6);
2292 TSTYPE_TO_STR(WINED3D_TS_TEXTURE7);
2293 TSTYPE_TO_STR(WINED3D_TS_WORLD_MATRIX(0));
2294 #undef TSTYPE_TO_STR
2295 default:
2296 if (tstype > 256 && tstype < 512)
2297 {
2298 FIXME("WINED3D_TS_WORLD_MATRIX(%u). 1..255 not currently supported.\n", tstype);
2299 return ("WINED3D_TS_WORLD_MATRIX > 0");
2300 }
2301 FIXME("Unrecognized transform state %#x.\n", tstype);
2302 return "unrecognized";
2303 }
2304 }
2305
2306 const char *debug_d3dstate(DWORD state)
2307 {
2308 if (STATE_IS_RENDER(state))
2309 return wine_dbg_sprintf("STATE_RENDER(%s)", debug_d3drenderstate(state - STATE_RENDER(0)));
2310 if (STATE_IS_TEXTURESTAGE(state))
2311 {
2312 DWORD texture_stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
2313 DWORD texture_state = state - STATE_TEXTURESTAGE(texture_stage, 0);
2314 return wine_dbg_sprintf("STATE_TEXTURESTAGE(%#x, %s)",
2315 texture_stage, debug_d3dtexturestate(texture_state));
2316 }
2317 if (STATE_IS_SAMPLER(state))
2318 return wine_dbg_sprintf("STATE_SAMPLER(%#x)", state - STATE_SAMPLER(0));
2319 if (STATE_IS_PIXELSHADER(state))
2320 return "STATE_PIXELSHADER";
2321 if (STATE_IS_TRANSFORM(state))
2322 return wine_dbg_sprintf("STATE_TRANSFORM(%s)", debug_d3dtstype(state - STATE_TRANSFORM(0)));
2323 if (STATE_IS_STREAMSRC(state))
2324 return "STATE_STREAMSRC";
2325 if (STATE_IS_INDEXBUFFER(state))
2326 return "STATE_INDEXBUFFER";
2327 if (STATE_IS_VDECL(state))
2328 return "STATE_VDECL";
2329 if (STATE_IS_VSHADER(state))
2330 return "STATE_VSHADER";
2331 if (STATE_IS_VIEWPORT(state))
2332 return "STATE_VIEWPORT";
2333 if (STATE_IS_VERTEXSHADERCONSTANT(state))
2334 return "STATE_VERTEXSHADERCONSTANT";
2335 if (STATE_IS_PIXELSHADERCONSTANT(state))
2336 return "STATE_PIXELSHADERCONSTANT";
2337 if (STATE_IS_ACTIVELIGHT(state))
2338 return wine_dbg_sprintf("STATE_ACTIVELIGHT(%#x)", state - STATE_ACTIVELIGHT(0));
2339 if (STATE_IS_SCISSORRECT(state))
2340 return "STATE_SCISSORRECT";
2341 if (STATE_IS_CLIPPLANE(state))
2342 return wine_dbg_sprintf("STATE_CLIPPLANE(%#x)", state - STATE_CLIPPLANE(0));
2343 if (STATE_IS_MATERIAL(state))
2344 return "STATE_MATERIAL";
2345 if (STATE_IS_FRONTFACE(state))
2346 return "STATE_FRONTFACE";
2347 if (STATE_IS_POINTSPRITECOORDORIGIN(state))
2348 return "STATE_POINTSPRITECOORDORIGIN";
2349 if (STATE_IS_BASEVERTEXINDEX(state))
2350 return "STATE_BASEVERTEXINDEX";
2351 if (STATE_IS_FRAMEBUFFER(state))
2352 return "STATE_FRAMEBUFFER";
2353
2354 return wine_dbg_sprintf("UNKNOWN_STATE(%#x)", state);
2355 }
2356
2357 const char *debug_d3dpool(enum wined3d_pool pool)
2358 {
2359 switch (pool)
2360 {
2361 #define POOL_TO_STR(p) case p: return #p
2362 POOL_TO_STR(WINED3D_POOL_DEFAULT);
2363 POOL_TO_STR(WINED3D_POOL_MANAGED);
2364 POOL_TO_STR(WINED3D_POOL_SYSTEM_MEM);
2365 POOL_TO_STR(WINED3D_POOL_SCRATCH);
2366 #undef POOL_TO_STR
2367 default:
2368 FIXME("Unrecognized pool %#x.\n", pool);
2369 return "unrecognized";
2370 }
2371 }
2372
2373 const char *debug_fbostatus(GLenum status) {
2374 switch(status) {
2375 #define FBOSTATUS_TO_STR(u) case u: return #u
2376 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE);
2377 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
2378 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
2379 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
2380 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
2381 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
2382 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
2383 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
2384 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED);
2385 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNDEFINED);
2386 #undef FBOSTATUS_TO_STR
2387 default:
2388 FIXME("Unrecognied FBO status 0x%08x\n", status);
2389 return "unrecognized";
2390 }
2391 }
2392
2393 const char *debug_glerror(GLenum error) {
2394 switch(error) {
2395 #define GLERROR_TO_STR(u) case u: return #u
2396 GLERROR_TO_STR(GL_NO_ERROR);
2397 GLERROR_TO_STR(GL_INVALID_ENUM);
2398 GLERROR_TO_STR(GL_INVALID_VALUE);
2399 GLERROR_TO_STR(GL_INVALID_OPERATION);
2400 GLERROR_TO_STR(GL_STACK_OVERFLOW);
2401 GLERROR_TO_STR(GL_STACK_UNDERFLOW);
2402 GLERROR_TO_STR(GL_OUT_OF_MEMORY);
2403 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION);
2404 #undef GLERROR_TO_STR
2405 default:
2406 FIXME("Unrecognied GL error 0x%08x\n", error);
2407 return "unrecognized";
2408 }
2409 }
2410
2411 const char *debug_d3dbasis(enum wined3d_basis_type basis)
2412 {
2413 switch (basis)
2414 {
2415 case WINED3D_BASIS_BEZIER: return "WINED3D_BASIS_BEZIER";
2416 case WINED3D_BASIS_BSPLINE: return "WINED3D_BASIS_BSPLINE";
2417 case WINED3D_BASIS_INTERPOLATE: return "WINED3D_BASIS_INTERPOLATE";
2418 default: return "unrecognized";
2419 }
2420 }
2421
2422 const char *debug_d3ddegree(enum wined3d_degree_type degree)
2423 {
2424 switch (degree)
2425 {
2426 case WINED3D_DEGREE_LINEAR: return "WINED3D_DEGREE_LINEAR";
2427 case WINED3D_DEGREE_QUADRATIC: return "WINED3D_DEGREE_QUADRATIC";
2428 case WINED3D_DEGREE_CUBIC: return "WINED3D_DEGREE_CUBIC";
2429 case WINED3D_DEGREE_QUINTIC: return "WINED3D_DEGREE_QUINTIC";
2430 default: return "unrecognized";
2431 }
2432 }
2433
2434 static const char *debug_fixup_channel_source(enum fixup_channel_source source)
2435 {
2436 switch(source)
2437 {
2438 #define WINED3D_TO_STR(x) case x: return #x
2439 WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
2440 WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
2441 WINED3D_TO_STR(CHANNEL_SOURCE_X);
2442 WINED3D_TO_STR(CHANNEL_SOURCE_Y);
2443 WINED3D_TO_STR(CHANNEL_SOURCE_Z);
2444 WINED3D_TO_STR(CHANNEL_SOURCE_W);
2445 WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX0);
2446 WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX1);
2447 #undef WINED3D_TO_STR
2448 default:
2449 FIXME("Unrecognized fixup_channel_source %#x\n", source);
2450 return "unrecognized";
2451 }
2452 }
2453
2454 static const char *debug_complex_fixup(enum complex_fixup fixup)
2455 {
2456 switch(fixup)
2457 {
2458 #define WINED3D_TO_STR(x) case x: return #x
2459 WINED3D_TO_STR(COMPLEX_FIXUP_YUY2);
2460 WINED3D_TO_STR(COMPLEX_FIXUP_UYVY);
2461 WINED3D_TO_STR(COMPLEX_FIXUP_YV12);
2462 WINED3D_TO_STR(COMPLEX_FIXUP_P8);
2463 #undef WINED3D_TO_STR
2464 default:
2465 FIXME("Unrecognized complex fixup %#x\n", fixup);
2466 return "unrecognized";
2467 }
2468 }
2469
2470 void dump_color_fixup_desc(struct color_fixup_desc fixup)
2471 {
2472 if (is_complex_fixup(fixup))
2473 {
2474 TRACE("\tComplex: %s\n", debug_complex_fixup(get_complex_fixup(fixup)));
2475 return;
2476 }
2477
2478 TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
2479 TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
2480 TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
2481 TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
2482 }
2483
2484 const char *debug_surflocation(DWORD flag) {
2485 char buf[128];
2486
2487 buf[0] = 0;
2488 if (flag & SFLAG_INSYSMEM) strcat(buf, " | SFLAG_INSYSMEM"); /* 17 */
2489 if (flag & SFLAG_INDRAWABLE) strcat(buf, " | SFLAG_INDRAWABLE"); /* 19 */
2490 if (flag & SFLAG_INTEXTURE) strcat(buf, " | SFLAG_INTEXTURE"); /* 18 */
2491 if (flag & SFLAG_INSRGBTEX) strcat(buf, " | SFLAG_INSRGBTEX"); /* 18 */
2492 if (flag & SFLAG_INRB_MULTISAMPLE) strcat(buf, " | SFLAG_INRB_MULTISAMPLE"); /* 25 */
2493 if (flag & SFLAG_INRB_RESOLVED) strcat(buf, " | SFLAG_INRB_RESOLVED"); /* 22 */
2494 return wine_dbg_sprintf("%s", buf[0] ? buf + 3 : "0");
2495 }
2496
2497 BOOL is_invalid_op(const struct wined3d_state *state, int stage,
2498 enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3)
2499 {
2500 if (op == WINED3D_TOP_DISABLE)
2501 return FALSE;
2502 if (state->textures[stage])
2503 return FALSE;
2504
2505 if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2506 && op != WINED3D_TOP_SELECT_ARG2)
2507 return TRUE;
2508 if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2509 && op != WINED3D_TOP_SELECT_ARG1)
2510 return TRUE;
2511 if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
2512 && (op == WINED3D_TOP_MULTIPLY_ADD || op == WINED3D_TOP_LERP))
2513 return TRUE;
2514
2515 return FALSE;
2516 }
2517
2518 /* Setup this textures matrix according to the texture flags*/
2519 /* GL locking is done by the caller (state handler) */
2520 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed,
2521 enum wined3d_format_id vtx_fmt, BOOL ffp_proj_control)
2522 {
2523 float mat[16];
2524
2525 glMatrixMode(GL_TEXTURE);
2526 checkGLcall("glMatrixMode(GL_TEXTURE)");
2527
2528 if (flags == WINED3D_TTFF_DISABLE || flags == WINED3D_TTFF_COUNT1 || transformed)
2529 {
2530 glLoadIdentity();
2531 checkGLcall("glLoadIdentity()");
2532 return;
2533 }
2534
2535 if (flags == (WINED3D_TTFF_COUNT1 | WINED3D_TTFF_PROJECTED))
2536 {
2537 ERR("Invalid texture transform flags: WINED3D_TTFF_COUNT1 | WINED3D_TTFF_PROJECTED.\n");
2538 return;
2539 }
2540
2541 memcpy(mat, smat, 16 * sizeof(float));
2542
2543 if (flags & WINED3D_TTFF_PROJECTED)
2544 {
2545 if (!ffp_proj_control)
2546 {
2547 switch (flags & ~WINED3D_TTFF_PROJECTED)
2548 {
2549 case WINED3D_TTFF_COUNT2:
2550 mat[ 3] = mat[ 1];
2551 mat[ 7] = mat[ 5];
2552 mat[11] = mat[ 9];
2553 mat[15] = mat[13];
2554 mat[ 1] = mat[ 5] = mat[ 9] = mat[13] = 0.0f;
2555 break;
2556 case WINED3D_TTFF_COUNT3:
2557 mat[ 3] = mat[ 2];
2558 mat[ 7] = mat[ 6];
2559 mat[11] = mat[10];
2560 mat[15] = mat[14];
2561 mat[ 2] = mat[ 6] = mat[10] = mat[14] = 0.0f;
2562 break;
2563 }
2564 }
2565 } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2566 if(!calculatedCoords) {
2567 switch(vtx_fmt)
2568 {
2569 case WINED3DFMT_R32_FLOAT:
2570 /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
2571 * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
2572 * the input value to the transformation will be 0, so the matrix value is irrelevant
2573 */
2574 mat[12] = mat[4];
2575 mat[13] = mat[5];
2576 mat[14] = mat[6];
2577 mat[15] = mat[7];
2578 break;
2579 case WINED3DFMT_R32G32_FLOAT:
2580 /* See above, just 3rd and 4th coord
2581 */
2582 mat[12] = mat[8];
2583 mat[13] = mat[9];
2584 mat[14] = mat[10];
2585 mat[15] = mat[11];
2586 break;
2587 case WINED3DFMT_R32G32B32_FLOAT: /* Opengl defaults match dx defaults */
2588 case WINED3DFMT_R32G32B32A32_FLOAT: /* No defaults apply, all app defined */
2589
2590 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
2591 * into a bad place. The division elimination below will apply to make sure the
2592 * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
2593 */
2594 case WINED3DFMT_UNKNOWN: /* No texture coords, 0/0/0/1 defaults are passed */
2595 break;
2596 default:
2597 FIXME("Unexpected fixed function texture coord input\n");
2598 }
2599 }
2600 if (!ffp_proj_control)
2601 {
2602 switch (flags & ~WINED3D_TTFF_PROJECTED)
2603 {
2604 /* case WINED3D_TTFF_COUNT1: Won't ever get here. */
2605 case WINED3D_TTFF_COUNT2:
2606 mat[2] = mat[6] = mat[10] = mat[14] = 0;
2607 /* OpenGL divides the first 3 vertex coord by the 4th by default,
2608 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
2609 * the 4th coord evaluates to 1.0 to eliminate that.
2610 *
2611 * If the fixed function pipeline is used, the 4th value remains unused,
2612 * so there is no danger in doing this. With vertex shaders we have a
2613 * problem. Should an app hit that problem, the code here would have to
2614 * check for pixel shaders, and the shader has to undo the default gl divide.
2615 *
2616 * A more serious problem occurs if the app passes 4 coordinates in, and the
2617 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
2618 * or a replacement shader. */
2619 default:
2620 mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
2621 }
2622 }
2623 }
2624
2625 glLoadMatrixf(mat);
2626 checkGLcall("glLoadMatrixf(mat)");
2627 }
2628
2629 /* This small helper function is used to convert a bitmask into the number of masked bits */
2630 unsigned int count_bits(unsigned int mask)
2631 {
2632 unsigned int count;
2633 for (count = 0; mask; ++count)
2634 {
2635 mask &= mask - 1;
2636 }
2637 return count;
2638 }
2639
2640 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
2641 * The later function requires individual color components. */
2642 BOOL getColorBits(const struct wined3d_format *format,
2643 BYTE *redSize, BYTE *greenSize, BYTE *blueSize, BYTE *alphaSize, BYTE *totalSize)
2644 {
2645 TRACE("format %s.\n", debug_d3dformat(format->id));
2646
2647 switch (format->id)
2648 {
2649 case WINED3DFMT_B10G10R10A2_UNORM:
2650 case WINED3DFMT_R10G10B10A2_UNORM:
2651 case WINED3DFMT_B8G8R8X8_UNORM:
2652 case WINED3DFMT_B8G8R8_UNORM:
2653 case WINED3DFMT_B8G8R8A8_UNORM:
2654 case WINED3DFMT_R8G8B8A8_UNORM:
2655 case WINED3DFMT_B5G5R5X1_UNORM:
2656 case WINED3DFMT_B5G5R5A1_UNORM:
2657 case WINED3DFMT_B5G6R5_UNORM:
2658 case WINED3DFMT_B4G4R4X4_UNORM:
2659 case WINED3DFMT_B4G4R4A4_UNORM:
2660 case WINED3DFMT_B2G3R3_UNORM:
2661 case WINED3DFMT_P8_UINT_A8_UNORM:
2662 case WINED3DFMT_P8_UINT:
2663 break;
2664 default:
2665 FIXME("Unsupported format %s.\n", debug_d3dformat(format->id));
2666 return FALSE;
2667 }
2668
2669 *redSize = count_bits(format->red_mask);
2670 *greenSize = count_bits(format->green_mask);
2671 *blueSize = count_bits(format->blue_mask);
2672 *alphaSize = count_bits(format->alpha_mask);
2673 *totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
2674
2675 TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for format %s.\n",
2676 *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(format->id));
2677 return TRUE;
2678 }
2679
2680 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
2681 BOOL getDepthStencilBits(const struct wined3d_format *format, BYTE *depthSize, BYTE *stencilSize)
2682 {
2683 TRACE("format %s.\n", debug_d3dformat(format->id));
2684
2685 switch (format->id)
2686 {
2687 case WINED3DFMT_D16_LOCKABLE:
2688 case WINED3DFMT_D16_UNORM:
2689 case WINED3DFMT_S1_UINT_D15_UNORM:
2690 case WINED3DFMT_X8D24_UNORM:
2691 case WINED3DFMT_S4X4_UINT_D24_UNORM:
2692 case WINED3DFMT_D24_UNORM_S8_UINT:
2693 case WINED3DFMT_S8_UINT_D24_FLOAT:
2694 case WINED3DFMT_D32_UNORM:
2695 case WINED3DFMT_D32_FLOAT:
2696 case WINED3DFMT_INTZ:
2697 break;
2698 default:
2699 FIXME("Unsupported depth/stencil format %s.\n", debug_d3dformat(format->id));
2700 return FALSE;
2701 }
2702
2703 *depthSize = format->depth_size;
2704 *stencilSize = format->stencil_size;
2705
2706 TRACE("Returning depthSize: %d and stencilSize: %d for format %s.\n",
2707 *depthSize, *stencilSize, debug_d3dformat(format->id));
2708 return TRUE;
2709 }
2710
2711 /* Note: It's the caller's responsibility to ensure values can be expressed
2712 * in the requested format. UNORM formats for example can only express values
2713 * in the range 0.0f -> 1.0f. */
2714 DWORD wined3d_format_convert_from_float(const struct wined3d_surface *surface, const struct wined3d_color *color)
2715 {
2716 static const struct
2717 {
2718 enum wined3d_format_id format_id;
2719 float r_mul;
2720 float g_mul;
2721 float b_mul;
2722 float a_mul;
2723 BYTE r_shift;
2724 BYTE g_shift;
2725 BYTE b_shift;
2726 BYTE a_shift;
2727 }
2728 conv[] =
2729 {
2730 {WINED3DFMT_B8G8R8A8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 16, 8, 0, 24},
2731 {WINED3DFMT_B8G8R8X8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 16, 8, 0, 24},
2732 {WINED3DFMT_B8G8R8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 16, 8, 0, 24},
2733 {WINED3DFMT_B5G6R5_UNORM, 31.0f, 63.0f, 31.0f, 0.0f, 11, 5, 0, 0},
2734 {WINED3DFMT_B5G5R5A1_UNORM, 31.0f, 31.0f, 31.0f, 1.0f, 10, 5, 0, 15},
2735 {WINED3DFMT_B5G5R5X1_UNORM, 31.0f, 31.0f, 31.0f, 1.0f, 10, 5, 0, 15},
2736 {WINED3DFMT_A8_UNORM, 0.0f, 0.0f, 0.0f, 255.0f, 0, 0, 0, 0},
2737 {WINED3DFMT_B4G4R4A4_UNORM, 15.0f, 15.0f, 15.0f, 15.0f, 8, 4, 0, 12},
2738 {WINED3DFMT_B4G4R4X4_UNORM, 15.0f, 15.0f, 15.0f, 15.0f, 8, 4, 0, 12},
2739 {WINED3DFMT_B2G3R3_UNORM, 7.0f, 7.0f, 3.0f, 0.0f, 5, 2, 0, 0},
2740 {WINED3DFMT_R8G8B8A8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 0, 8, 16, 24},
2741 {WINED3DFMT_R8G8B8X8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 0, 8, 16, 24},
2742 {WINED3DFMT_B10G10R10A2_UNORM, 1023.0f, 1023.0f, 1023.0f, 3.0f, 20, 10, 0, 30},
2743 {WINED3DFMT_R10G10B10A2_UNORM, 1023.0f, 1023.0f, 1023.0f, 3.0f, 0, 10, 20, 30},
2744 };
2745 const struct wined3d_format *format = surface->resource.format;
2746 unsigned int i;
2747
2748 TRACE("Converting color {%.8e %.8e %.8e %.8e} to format %s.\n",
2749 color->r, color->g, color->b, color->a, debug_d3dformat(format->id));
2750
2751 for (i = 0; i < sizeof(conv) / sizeof(*conv); ++i)
2752 {
2753 DWORD ret;
2754
2755 if (format->id != conv[i].format_id) continue;
2756
2757 ret = ((DWORD)((color->r * conv[i].r_mul) + 0.5f)) << conv[i].r_shift;
2758 ret |= ((DWORD)((color->g * conv[i].g_mul) + 0.5f)) << conv[i].g_shift;
2759 ret |= ((DWORD)((color->b * conv[i].b_mul) + 0.5f)) << conv[i].b_shift;
2760 ret |= ((DWORD)((color->a * conv[i].a_mul) + 0.5f)) << conv[i].a_shift;
2761
2762 TRACE("Returning 0x%08x.\n", ret);
2763
2764 return ret;
2765 }
2766
2767 if (format->id == WINED3DFMT_P8_UINT)
2768 {
2769 PALETTEENTRY *e;
2770 BYTE r, g, b, a;
2771
2772 if (!surface->palette)
2773 {
2774 WARN("Surface doesn't have a palette, returning 0.\n");
2775 return 0;
2776 }
2777
2778 r = (BYTE)((color->r * 255.0f) + 0.5f);
2779 g = (BYTE)((color->g * 255.0f) + 0.5f);
2780 b = (BYTE)((color->b * 255.0f) + 0.5f);
2781 a = (BYTE)((color->a * 255.0f) + 0.5f);
2782
2783 e = &surface->palette->palents[a];
2784 if (e->peRed == r && e->peGreen == g && e->peBlue == b)
2785 return a;
2786
2787 WARN("Alpha didn't match index, searching full palette.\n");
2788
2789 for (i = 0; i < 256; ++i)
2790 {
2791 e = &surface->palette->palents[i];
2792 if (e->peRed == r && e->peGreen == g && e->peBlue == b)
2793 return i;
2794 }
2795
2796 FIXME("Unable to convert color to palette index.\n");
2797
2798 return 0;
2799 }
2800
2801 FIXME("Conversion for format %s not implemented.\n", debug_d3dformat(format->id));
2802
2803 return 0;
2804 }
2805
2806 /* DirectDraw stuff */
2807 enum wined3d_format_id pixelformat_for_depth(DWORD depth)
2808 {
2809 switch (depth)
2810 {
2811 case 8: return WINED3DFMT_P8_UINT;
2812 case 15: return WINED3DFMT_B5G5R5X1_UNORM;
2813 case 16: return WINED3DFMT_B5G6R5_UNORM;
2814 case 24: return WINED3DFMT_B8G8R8X8_UNORM; /* Robots needs 24bit to be WINED3DFMT_B8G8R8X8_UNORM */
2815 case 32: return WINED3DFMT_B8G8R8X8_UNORM; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return WINED3DFMT_B8G8R8X8_UNORM */
2816 default: return WINED3DFMT_UNKNOWN;
2817 }
2818 }
2819
2820 void multiply_matrix(struct wined3d_matrix *dest, const struct wined3d_matrix *src1,
2821 const struct wined3d_matrix *src2)
2822 {
2823 struct wined3d_matrix temp;
2824
2825 /* Now do the multiplication 'by hand'.
2826 I know that all this could be optimised, but this will be done later :-) */
2827 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);
2828 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);
2829 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);
2830 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);
2831
2832 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);
2833 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);
2834 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);
2835 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);
2836
2837 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);
2838 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);
2839 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);
2840 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);
2841
2842 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);
2843 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);
2844 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);
2845 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);
2846
2847 /* And copy the new matrix in the good storage.. */
2848 memcpy(dest, &temp, 16 * sizeof(float));
2849 }
2850
2851 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
2852 DWORD size = 0;
2853 int i;
2854 int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
2855
2856 if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
2857 if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
2858 if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
2859 if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
2860 switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
2861 case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
2862 case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
2863 case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break;
2864 case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break;
2865 case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break;
2866 case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break;
2867 case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break;
2868 case WINED3DFVF_XYZW: size += 4 * sizeof(float); break;
2869 default: ERR("Unexpected position mask\n");
2870 }
2871 for (i = 0; i < numTextures; i++) {
2872 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
2873 }
2874
2875 return size;
2876 }
2877
2878 void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_state *state,
2879 struct ffp_frag_settings *settings, BOOL ignore_textype)
2880 {
2881 #define ARG1 0x01
2882 #define ARG2 0x02
2883 #define ARG0 0x04
2884 static const unsigned char args[WINED3D_TOP_LERP + 1] =
2885 {
2886 /* undefined */ 0,
2887 /* D3DTOP_DISABLE */ 0,
2888 /* D3DTOP_SELECTARG1 */ ARG1,
2889 /* D3DTOP_SELECTARG2 */ ARG2,
2890 /* D3DTOP_MODULATE */ ARG1 | ARG2,
2891 /* D3DTOP_MODULATE2X */ ARG1 | ARG2,
2892 /* D3DTOP_MODULATE4X */ ARG1 | ARG2,
2893 /* D3DTOP_ADD */ ARG1 | ARG2,
2894 /* D3DTOP_ADDSIGNED */ ARG1 | ARG2,
2895 /* D3DTOP_ADDSIGNED2X */ ARG1 | ARG2,
2896 /* D3DTOP_SUBTRACT */ ARG1 | ARG2,
2897 /* D3DTOP_ADDSMOOTH */ ARG1 | ARG2,
2898 /* D3DTOP_BLENDDIFFUSEALPHA */ ARG1 | ARG2,
2899 /* D3DTOP_BLENDTEXTUREALPHA */ ARG1 | ARG2,
2900 /* D3DTOP_BLENDFACTORALPHA */ ARG1 | ARG2,
2901 /* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1 | ARG2,
2902 /* D3DTOP_BLENDCURRENTALPHA */ ARG1 | ARG2,
2903 /* D3DTOP_PREMODULATE */ ARG1 | ARG2,
2904 /* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1 | ARG2,
2905 /* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1 | ARG2,
2906 /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1 | ARG2,
2907 /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1 | ARG2,
2908 /* D3DTOP_BUMPENVMAP */ ARG1 | ARG2,
2909 /* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1 | ARG2,
2910 /* D3DTOP_DOTPRODUCT3 */ ARG1 | ARG2,
2911 /* D3DTOP_MULTIPLYADD */ ARG1 | ARG2 | ARG0,
2912 /* D3DTOP_LERP */ ARG1 | ARG2 | ARG0
2913 };
2914 unsigned int i;
2915 DWORD ttff;
2916 DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
2917 const struct wined3d_surface *rt = state->fb->render_targets[0];
2918 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2919
2920 for (i = 0; i < gl_info->limits.texture_stages; ++i)
2921 {
2922 const struct wined3d_texture *texture;
2923
2924 settings->op[i].padding = 0;
2925 if (state->texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_DISABLE)
2926 {
2927 settings->op[i].cop = WINED3D_TOP_DISABLE;
2928 settings->op[i].aop = WINED3D_TOP_DISABLE;
2929 settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
2930 settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
2931 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2932 settings->op[i].dst = resultreg;
2933 settings->op[i].tex_type = tex_1d;
2934 settings->op[i].projected = proj_none;
2935 i++;
2936 break;
2937 }
2938
2939 if ((texture = state->textures[i]))
2940 {
2941 settings->op[i].color_fixup = texture->resource.format->color_fixup;
2942 if (ignore_textype)
2943 {
2944 settings->op[i].tex_type = tex_1d;
2945 }
2946 else
2947 {
2948 switch (texture->target)
2949 {
2950 case GL_TEXTURE_1D:
2951 settings->op[i].tex_type = tex_1d;
2952 break;
2953 case GL_TEXTURE_2D:
2954 settings->op[i].tex_type = tex_2d;
2955 break;
2956 case GL_TEXTURE_3D:
2957 settings->op[i].tex_type = tex_3d;
2958 break;
2959 case GL_TEXTURE_CUBE_MAP_ARB:
2960 settings->op[i].tex_type = tex_cube;
2961 break;
2962 case GL_TEXTURE_RECTANGLE_ARB:
2963 settings->op[i].tex_type = tex_rect;
2964 break;
2965 }
2966 }
2967 } else {
2968 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2969 settings->op[i].tex_type = tex_1d;
2970 }
2971
2972 cop = state->texture_states[i][WINED3D_TSS_COLOR_OP];
2973 aop = state->texture_states[i][WINED3D_TSS_ALPHA_OP];
2974
2975 carg1 = (args[cop] & ARG1) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG1] : ARG_UNUSED;
2976 carg2 = (args[cop] & ARG2) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG2] : ARG_UNUSED;
2977 carg0 = (args[cop] & ARG0) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG0] : ARG_UNUSED;
2978
2979 if (is_invalid_op(state, i, cop, carg1, carg2, carg0))
2980 {
2981 carg0 = ARG_UNUSED;
2982 carg2 = ARG_UNUSED;
2983 carg1 = WINED3DTA_CURRENT;
2984 cop = WINED3D_TOP_SELECT_ARG1;
2985 }
2986
2987 if (cop == WINED3D_TOP_DOTPRODUCT3)
2988 {
2989 /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
2990 * the color result to the alpha component of the destination
2991 */
2992 aop = cop;
2993 aarg1 = carg1;
2994 aarg2 = carg2;
2995 aarg0 = carg0;
2996 }
2997 else
2998 {
2999 aarg1 = (args[aop] & ARG1) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG1] : ARG_UNUSED;
3000 aarg2 = (args[aop] & ARG2) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG2] : ARG_UNUSED;
3001 aarg0 = (args[aop] & ARG0) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG0] : ARG_UNUSED;
3002 }
3003
3004 if (!i && state->textures[0] && state->render_states[WINED3D_RS_COLORKEYENABLE])
3005 {
3006 GLenum texture_dimensions;
3007
3008 texture = state->textures[0];
3009 texture_dimensions = texture->target;
3010
3011 if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
3012 {
3013 struct wined3d_surface *surf = surface_from_resource(texture->sub_resources[0]);
3014
3015 if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask)
3016 {
3017 if (aop == WINED3D_TOP_DISABLE)
3018 {
3019 aarg1 = WINED3DTA_TEXTURE;
3020 aop = WINED3D_TOP_SELECT_ARG1;
3021 }
3022 else if (aop == WINED3D_TOP_SELECT_ARG1 && aarg1 != WINED3DTA_TEXTURE)
3023 {
3024 if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
3025 {
3026 aarg2 = WINED3DTA_TEXTURE;
3027 aop = WINED3D_TOP_MODULATE;
3028 }
3029 else aarg1 = WINED3DTA_TEXTURE;
3030 }
3031 else if (aop == WINED3D_TOP_SELECT_ARG2 && aarg2 != WINED3DTA_TEXTURE)
3032 {
3033 if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
3034 {
3035 aarg1 = WINED3DTA_TEXTURE;
3036 aop = WINED3D_TOP_MODULATE;
3037 }
3038 else aarg2 = WINED3DTA_TEXTURE;
3039 }
3040 }
3041 }
3042 }
3043
3044 if (is_invalid_op(state, i, aop, aarg1, aarg2, aarg0))
3045 {
3046 aarg0 = ARG_UNUSED;
3047 aarg2 = ARG_UNUSED;
3048 aarg1 = WINED3DTA_CURRENT;
3049 aop = WINED3D_TOP_SELECT_ARG1;
3050 }
3051
3052 if (carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE
3053 || aarg1 == WINED3DTA_TEXTURE || aarg2 == WINED3DTA_TEXTURE || aarg0 == WINED3DTA_TEXTURE)
3054 {
3055 ttff = state->texture_states[i][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS];
3056 if (ttff == (WINED3D_TTFF_PROJECTED | WINED3D_TTFF_COUNT3))
3057 settings->op[i].projected = proj_count3;
3058 else if (ttff & WINED3D_TTFF_PROJECTED)
3059 settings->op[i].projected = proj_count4;
3060 else
3061 settings->op[i].projected = proj_none;
3062 }
3063 else
3064 {
3065 settings->op[i].projected = proj_none;
3066 }
3067
3068 settings->op[i].cop = cop;
3069 settings->op[i].aop = aop;
3070 settings->op[i].carg0 = carg0;
3071 settings->op[i].carg1 = carg1;
3072 settings->op[i].carg2 = carg2;
3073 settings->op[i].aarg0 = aarg0;
3074 settings->op[i].aarg1 = aarg1;
3075 settings->op[i].aarg2 = aarg2;
3076
3077 if (state->texture_states[i][WINED3D_TSS_RESULT_ARG] == WINED3DTA_TEMP)
3078 settings->op[i].dst = tempreg;
3079 else
3080 settings->op[i].dst = resultreg;
3081 }
3082
3083 /* Clear unsupported stages */
3084 for(; i < MAX_TEXTURES; i++) {
3085 memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
3086 }
3087
3088 if (!state->render_states[WINED3D_RS_FOGENABLE])
3089 {
3090 settings->fog = FOG_OFF;
3091 }
3092 else if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3D_FOG_NONE)
3093 {
3094 if (use_vs(state) || state->vertex_declaration->position_transformed)
3095 {
3096 settings->fog = FOG_LINEAR;
3097 }
3098 else
3099 {
3100 switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
3101 {
3102 case WINED3D_FOG_NONE:
3103 case WINED3D_FOG_LINEAR:
3104 settings->fog = FOG_LINEAR;
3105 break;
3106 case WINED3D_FOG_EXP:
3107 settings->fog = FOG_EXP;
3108 break;
3109 case WINED3D_FOG_EXP2:
3110 settings->fog = FOG_EXP2;
3111 break;
3112 }
3113 }
3114 }
3115 else
3116 {
3117 switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
3118 {
3119 case WINED3D_FOG_LINEAR:
3120 settings->fog = FOG_LINEAR;
3121 break;
3122 case WINED3D_FOG_EXP:
3123 settings->fog = FOG_EXP;
3124 break;
3125 case WINED3D_FOG_EXP2:
3126 settings->fog = FOG_EXP2;
3127 break;
3128 }
3129 }
3130 if (state->render_states[WINED3D_RS_SRGBWRITEENABLE]
3131 && rt->resource.format->flags & WINED3DFMT_FLAG_SRGB_WRITE)
3132 {
3133 settings->sRGB_write = 1;
3134 } else {
3135 settings->sRGB_write = 0;
3136 }
3137 if (device->vs_clipping || !use_vs(state) || !state->render_states[WINED3D_RS_CLIPPING]
3138 || !state->render_states[WINED3D_RS_CLIPPLANEENABLE])
3139 {
3140 /* No need to emulate clipplanes if GL supports native vertex shader clipping or if
3141 * the fixed function vertex pipeline is used(which always supports clipplanes), or
3142 * if no clipplane is enabled
3143 */
3144 settings->emul_clipplanes = 0;
3145 } else {
3146 settings->emul_clipplanes = 1;
3147 }
3148 }
3149
3150 const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
3151 const struct ffp_frag_settings *settings)
3152 {
3153 struct wine_rb_entry *entry = wine_rb_get(fragment_shaders, settings);
3154 return entry ? WINE_RB_ENTRY_VALUE(entry, struct ffp_frag_desc, entry) : NULL;
3155 }
3156
3157 void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc)
3158 {
3159 /* Note that the key is the implementation independent part of the ffp_frag_desc structure,
3160 * whereas desc points to an extended structure with implementation specific parts. */
3161 if (wine_rb_put(shaders, &desc->settings, &desc->entry) == -1)
3162 {
3163 ERR("Failed to insert ffp frag shader.\n");
3164 }
3165 }
3166
3167 /* Activates the texture dimension according to the bound D3D texture.
3168 * Does not care for the colorop or correct gl texture unit(when using nvrc)
3169 * Requires the caller to activate the correct unit before
3170 */
3171 /* GL locking is done by the caller (state handler) */
3172 void texture_activate_dimensions(const struct wined3d_texture *texture, const struct wined3d_gl_info *gl_info)
3173 {
3174 if (texture)
3175 {
3176 switch (texture->target)
3177 {
3178 case GL_TEXTURE_2D:
3179 glDisable(GL_TEXTURE_3D);
3180 checkGLcall("glDisable(GL_TEXTURE_3D)");
3181 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3182 {
3183 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
3184 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3185 }
3186 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
3187 {
3188 glDisable(GL_TEXTURE_RECTANGLE_ARB);
3189 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3190 }
3191 glEnable(GL_TEXTURE_2D);
3192 checkGLcall("glEnable(GL_TEXTURE_2D)");
3193 break;
3194 case GL_TEXTURE_RECTANGLE_ARB:
3195 glDisable(GL_TEXTURE_2D);
3196 checkGLcall("glDisable(GL_TEXTURE_2D)");
3197 glDisable(GL_TEXTURE_3D);
3198 checkGLcall("glDisable(GL_TEXTURE_3D)");
3199 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3200 {
3201 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
3202 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3203 }
3204 glEnable(GL_TEXTURE_RECTANGLE_ARB);
3205 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
3206 break;
3207 case GL_TEXTURE_3D:
3208 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3209 {
3210 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
3211 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3212 }
3213 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
3214 {
3215 glDisable(GL_TEXTURE_RECTANGLE_ARB);
3216 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3217 }
3218 glDisable(GL_TEXTURE_2D);
3219 checkGLcall("glDisable(GL_TEXTURE_2D)");
3220 glEnable(GL_TEXTURE_3D);
3221 checkGLcall("glEnable(GL_TEXTURE_3D)");
3222 break;
3223 case GL_TEXTURE_CUBE_MAP_ARB:
3224 glDisable(GL_TEXTURE_2D);
3225 checkGLcall("glDisable(GL_TEXTURE_2D)");
3226 glDisable(GL_TEXTURE_3D);
3227 checkGLcall("glDisable(GL_TEXTURE_3D)");
3228 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
3229 {
3230 glDisable(GL_TEXTURE_RECTANGLE_ARB);
3231 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3232 }
3233 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
3234 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
3235 break;
3236 }
3237 } else {
3238 glEnable(GL_TEXTURE_2D);
3239 checkGLcall("glEnable(GL_TEXTURE_2D)");
3240 glDisable(GL_TEXTURE_3D);
3241 checkGLcall("glDisable(GL_TEXTURE_3D)");
3242 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3243 {
3244 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
3245 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3246 }
3247 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
3248 {
3249 glDisable(GL_TEXTURE_RECTANGLE_ARB);
3250 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3251 }
3252 /* Binding textures is done by samplers. A dummy texture will be bound */
3253 }
3254 }
3255
3256 /* GL locking is done by the caller (state handler) */
3257 void sampler_texdim(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
3258 {
3259 DWORD sampler = state_id - STATE_SAMPLER(0);
3260 DWORD mapped_stage = context->swapchain->device->texUnitMap[sampler];
3261
3262 /* No need to enable / disable anything here for unused samplers. The
3263 * tex_colorop handler takes care. Also no action is needed with pixel
3264 * shaders, or if tex_colorop will take care of this business. */
3265 if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures)
3266 return;
3267 if (sampler >= state->lowest_disabled_stage)
3268 return;
3269 if (isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3D_TSS_COLOR_OP)))
3270 return;
3271
3272 texture_activate_dimensions(state->textures[sampler], context->gl_info);
3273 }
3274
3275 void *wined3d_rb_alloc(size_t size)
3276 {
3277 return HeapAlloc(GetProcessHeap(), 0, size);
3278 }
3279
3280 void *wined3d_rb_realloc(void *ptr, size_t size)
3281 {
3282 return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
3283 }
3284
3285 void wined3d_rb_free(void *ptr)
3286 {
3287 HeapFree(GetProcessHeap(), 0, ptr);
3288 }
3289
3290 static int ffp_frag_program_key_compare(const void *key, const struct wine_rb_entry *entry)
3291 {
3292 const struct ffp_frag_settings *ka = key;
3293 const struct ffp_frag_settings *kb = &WINE_RB_ENTRY_VALUE(entry, const struct ffp_frag_desc, entry)->settings;
3294
3295 return memcmp(ka, kb, sizeof(*ka));
3296 }
3297
3298 const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions =
3299 {
3300 wined3d_rb_alloc,
3301 wined3d_rb_realloc,
3302 wined3d_rb_free,
3303 ffp_frag_program_key_compare,
3304 };
3305
3306 UINT wined3d_log2i(UINT32 x)
3307 {
3308 static const UINT l[] =
3309 {
3310 ~0U, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
3311 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3312 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
3313 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
3314 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3315 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3316 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3317 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3318 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3319 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3320 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3321 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3322 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3323 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3324 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3325 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3326 };
3327 UINT32 i;
3328
3329 return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
3330 }
3331
3332 /* Set the shader type for this device, depending on the given capabilities
3333 * and the user preferences in wined3d_settings. */
3334 void select_shader_mode(const struct wined3d_gl_info *gl_info, int *ps_selected, int *vs_selected)
3335 {
3336 BOOL glsl = wined3d_settings.glslRequested && gl_info->glsl_version >= MAKEDWORD_VERSION(1, 20);
3337
3338 if (wined3d_settings.vs_mode == VS_NONE) *vs_selected = SHADER_NONE;
3339 else if (gl_info->supported[ARB_VERTEX_SHADER] && glsl)
3340 {
3341 /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
3342 * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
3343 * shaders only on this card. */
3344 if (gl_info->supported[NV_VERTEX_PROGRAM] && !gl_info->supported[NV_VERTEX_PROGRAM2]) *vs_selected = SHADER_ARB;
3345 else *vs_selected = SHADER_GLSL;
3346 }
3347 else if (gl_info->supported[ARB_VERTEX_PROGRAM]) *vs_selected = SHADER_ARB;
3348 else *vs_selected = SHADER_NONE;
3349
3350 if (wined3d_settings.ps_mode == PS_NONE) *ps_selected = SHADER_NONE;
3351 else if (gl_info->supported[ARB_FRAGMENT_SHADER] && glsl) *ps_selected = SHADER_GLSL;
3352 else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) *ps_selected = SHADER_ARB;
3353 else if (gl_info->supported[ATI_FRAGMENT_SHADER]) *ps_selected = SHADER_ATI;
3354 else *ps_selected = SHADER_NONE;
3355 }
3356
3357 const struct blit_shader *wined3d_select_blitter(const struct wined3d_gl_info *gl_info, enum wined3d_blit_op blit_op,
3358 const RECT *src_rect, DWORD src_usage, enum wined3d_pool src_pool, const struct wined3d_format *src_format,
3359 const RECT *dst_rect, DWORD dst_usage, enum wined3d_pool dst_pool, const struct wined3d_format *dst_format)
3360 {
3361 static const struct blit_shader * const blitters[] =
3362 {
3363 &arbfp_blit,
3364 &ffp_blit,
3365 &cpu_blit,
3366 };
3367 unsigned int i;
3368
3369 for (i = 0; i < sizeof(blitters) / sizeof(*blitters); ++i)
3370 {
3371 if (blitters[i]->blit_supported(gl_info, blit_op,
3372 src_rect, src_usage, src_pool, src_format,
3373 dst_rect, dst_usage, dst_pool, dst_format))
3374 return blitters[i];
3375 }
3376
3377 return NULL;
3378 }
3379
3380 void wined3d_get_draw_rect(const struct wined3d_state *state, RECT *rect)
3381 {
3382 const struct wined3d_viewport *vp = &state->viewport;
3383
3384 SetRect(rect, vp->x, vp->y, vp->x + vp->width, vp->y + vp->height);
3385
3386 if (state->render_states[WINED3D_RS_SCISSORTESTENABLE])
3387 IntersectRect(rect, rect, &state->scissor_rect);
3388 }
Maarten's multimedia branch