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