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