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