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