?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11.drv: Correct sizes in COMPOSITIONSTRING structure when updating fields.
[wine.git] / dlls / wined3d / utils.c
blobabe52dd6503ac64118fd5694436d61d5428d38d3
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 #define WINED3D_FORMAT_FOURCC_BASE (WINED3DFMT_BC7_UNORM_SRGB + 1)
37
38 static const struct
39 {
40 enum wined3d_format_id id;
41 unsigned int idx;
42 }
43 format_index_remap[] =
44 {
45 {WINED3DFMT_UYVY, WINED3D_FORMAT_FOURCC_BASE},
46 {WINED3DFMT_YUY2, WINED3D_FORMAT_FOURCC_BASE + 1},
47 {WINED3DFMT_YV12, WINED3D_FORMAT_FOURCC_BASE + 2},
48 {WINED3DFMT_DXT1, WINED3D_FORMAT_FOURCC_BASE + 3},
49 {WINED3DFMT_DXT2, WINED3D_FORMAT_FOURCC_BASE + 4},
50 {WINED3DFMT_DXT3, WINED3D_FORMAT_FOURCC_BASE + 5},
51 {WINED3DFMT_DXT4, WINED3D_FORMAT_FOURCC_BASE + 6},
52 {WINED3DFMT_DXT5, WINED3D_FORMAT_FOURCC_BASE + 7},
53 {WINED3DFMT_MULTI2_ARGB8, WINED3D_FORMAT_FOURCC_BASE + 8},
54 {WINED3DFMT_G8R8_G8B8, WINED3D_FORMAT_FOURCC_BASE + 9},
55 {WINED3DFMT_R8G8_B8G8, WINED3D_FORMAT_FOURCC_BASE + 10},
56 {WINED3DFMT_ATI1N, WINED3D_FORMAT_FOURCC_BASE + 11},
57 {WINED3DFMT_ATI2N, WINED3D_FORMAT_FOURCC_BASE + 12},
58 {WINED3DFMT_INST, WINED3D_FORMAT_FOURCC_BASE + 13},
59 {WINED3DFMT_NVDB, WINED3D_FORMAT_FOURCC_BASE + 14},
60 {WINED3DFMT_NVHU, WINED3D_FORMAT_FOURCC_BASE + 15},
61 {WINED3DFMT_NVHS, WINED3D_FORMAT_FOURCC_BASE + 16},
62 {WINED3DFMT_INTZ, WINED3D_FORMAT_FOURCC_BASE + 17},
63 {WINED3DFMT_RESZ, WINED3D_FORMAT_FOURCC_BASE + 18},
64 {WINED3DFMT_NULL, WINED3D_FORMAT_FOURCC_BASE + 19},
65 {WINED3DFMT_R16, WINED3D_FORMAT_FOURCC_BASE + 20},
66 {WINED3DFMT_AL16, WINED3D_FORMAT_FOURCC_BASE + 21},
67 {WINED3DFMT_NV12, WINED3D_FORMAT_FOURCC_BASE + 22},
68 };
69
70 #define WINED3D_FORMAT_COUNT (WINED3D_FORMAT_FOURCC_BASE + ARRAY_SIZE(format_index_remap))
71
72 struct wined3d_format_channels
73 {
74 enum wined3d_format_id id;
75 DWORD red_size, green_size, blue_size, alpha_size;
76 DWORD red_offset, green_offset, blue_offset, alpha_offset;
77 UINT bpp;
78 BYTE depth_size, stencil_size;
79 };
80
81 static const struct wined3d_format_channels formats[] =
82 {
83 /* size offset
84 * format id r g b a r g b a bpp depth stencil */
85 {WINED3DFMT_UNKNOWN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
86 /* FourCC formats */
87 {WINED3DFMT_UYVY, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
88 {WINED3DFMT_YUY2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
89 {WINED3DFMT_YV12, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
90 {WINED3DFMT_NV12, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
91 {WINED3DFMT_DXT1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
92 {WINED3DFMT_DXT2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
93 {WINED3DFMT_DXT3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
94 {WINED3DFMT_DXT4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
95 {WINED3DFMT_DXT5, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
96 {WINED3DFMT_MULTI2_ARGB8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
97 {WINED3DFMT_G8R8_G8B8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
98 {WINED3DFMT_R8G8_B8G8, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
99 /* Hmm? */
100 {WINED3DFMT_R8G8_SNORM_Cx, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
101 {WINED3DFMT_R11G11B10_FLOAT, 11, 11, 10, 0, 0, 11, 22, 0, 4, 0, 0},
102 /* Palettized formats */
103 {WINED3DFMT_P8_UINT_A8_UNORM, 0, 0, 0, 8, 0, 0, 0, 8, 2, 0, 0},
104 {WINED3DFMT_P8_UINT, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
105 /* Standard ARGB formats. */
106 {WINED3DFMT_B8G8R8_UNORM, 8, 8, 8, 0, 16, 8, 0, 0, 3, 0, 0},
107 {WINED3DFMT_B5G6R5_UNORM, 5, 6, 5, 0, 11, 5, 0, 0, 2, 0, 0},
108 {WINED3DFMT_B5G5R5X1_UNORM, 5, 5, 5, 0, 10, 5, 0, 0, 2, 0, 0},
109 {WINED3DFMT_B5G5R5A1_UNORM, 5, 5, 5, 1, 10, 5, 0, 15, 2, 0, 0},
110 {WINED3DFMT_B4G4R4A4_UNORM, 4, 4, 4, 4, 8, 4, 0, 12, 2, 0, 0},
111 {WINED3DFMT_B2G3R3_UNORM, 3, 3, 2, 0, 5, 2, 0, 0, 1, 0, 0},
112 {WINED3DFMT_A8_UNORM, 0, 0, 0, 8, 0, 0, 0, 0, 1, 0, 0},
113 {WINED3DFMT_B2G3R3A8_UNORM, 3, 3, 2, 8, 5, 2, 0, 8, 2, 0, 0},
114 {WINED3DFMT_B4G4R4X4_UNORM, 4, 4, 4, 0, 8, 4, 0, 0, 2, 0, 0},
115 {WINED3DFMT_R8G8B8X8_UNORM, 8, 8, 8, 0, 0, 8, 16, 0, 4, 0, 0},
116 {WINED3DFMT_B10G10R10A2_UNORM, 10, 10, 10, 2, 20, 10, 0, 30, 4, 0, 0},
117 /* Luminance */
118 {WINED3DFMT_L8_UNORM, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
119 {WINED3DFMT_L8A8_UNORM, 0, 0, 0, 8, 0, 0, 0, 8, 2, 0, 0},
120 {WINED3DFMT_L4A4_UNORM, 0, 0, 0, 4, 0, 0, 0, 4, 1, 0, 0},
121 {WINED3DFMT_L16_UNORM, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
122 /* Bump mapping stuff */
123 {WINED3DFMT_R5G5_SNORM_L6_UNORM, 5, 5, 0, 0, 0, 5, 0, 0, 2, 0, 0},
124 {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, 8, 8, 0, 0, 0, 8, 0, 0, 4, 0, 0},
125 {WINED3DFMT_R8G8B8A8_SNORM, 8, 8, 8, 8, 0, 8, 16, 24, 4, 0, 0},
126 {WINED3DFMT_R10G11B11_SNORM, 10, 11, 11, 0, 0, 10, 21, 0, 4, 0, 0},
127 {WINED3DFMT_R10G10B10_SNORM_A2_UNORM, 10, 10, 10, 2, 0, 10, 20, 30, 4, 0, 0},
128 /* Depth stencil formats */
129 {WINED3DFMT_D16_LOCKABLE, 0, 0, 0, 0, 0, 0, 0, 0, 2, 16, 0},
130 {WINED3DFMT_D32_UNORM, 0, 0, 0, 0, 0, 0, 0, 0, 4, 32, 0},
131 {WINED3DFMT_S1_UINT_D15_UNORM, 0, 0, 0, 0, 0, 0, 0, 0, 2, 15, 1},
132 {WINED3DFMT_X8D24_UNORM, 0, 0, 0, 0, 0, 0, 0, 0, 4, 24, 0},
133 {WINED3DFMT_S4X4_UINT_D24_UNORM, 0, 0, 0, 0, 0, 0, 0, 0, 4, 24, 4},
134 {WINED3DFMT_D16_UNORM, 0, 0, 0, 0, 0, 0, 0, 0, 2, 16, 0},
135 {WINED3DFMT_D32_FLOAT, 0, 0, 0, 0, 0, 0, 0, 0, 4, 32, 0},
136 {WINED3DFMT_S8_UINT_D24_FLOAT, 0, 0, 0, 0, 0, 0, 0, 0, 4, 24, 8},
137 {WINED3DFMT_VERTEXDATA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
138 /* Vendor-specific formats */
139 {WINED3DFMT_ATI1N, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
140 {WINED3DFMT_ATI2N, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
141 {WINED3DFMT_NVDB, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
142 {WINED3DFMT_INST, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
143 {WINED3DFMT_INTZ, 0, 0, 0, 0, 0, 0, 0, 0, 4, 24, 8},
144 {WINED3DFMT_RESZ, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
145 {WINED3DFMT_NVHU, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
146 {WINED3DFMT_NVHS, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
147 {WINED3DFMT_NULL, 8, 8, 8, 8, 0, 8, 16, 24, 4, 0, 0},
148 /* Unsure about them, could not find a Windows driver that supports them */
149 {WINED3DFMT_R16, 16, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
150 {WINED3DFMT_AL16, 0, 0, 0, 16, 0, 0, 0, 16, 4, 0, 0},
151 /* Typeless */
152 {WINED3DFMT_R32G32B32A32_TYPELESS, 32, 32, 32, 32, 0, 32, 64, 96, 16, 0, 0},
153 {WINED3DFMT_R32G32B32_TYPELESS, 32, 32, 32, 0, 0, 32, 64, 0, 12, 0, 0},
154 {WINED3DFMT_R16G16B16A16_TYPELESS, 16, 16, 16, 16, 0, 16, 32, 48, 8, 0, 0},
155 {WINED3DFMT_R32G32_TYPELESS, 32, 32, 0, 0, 0, 32, 0, 0, 8, 0, 0},
156 {WINED3DFMT_R32G8X24_TYPELESS, 0, 0, 0, 0, 0, 0, 0, 0, 8, 32, 8},
157 {WINED3DFMT_R10G10B10A2_TYPELESS, 10, 10, 10, 2, 0, 10, 20, 30, 4, 0, 0},
158 {WINED3DFMT_R8G8B8A8_TYPELESS, 8, 8, 8, 8, 0, 8, 16, 24, 4, 0, 0},
159 {WINED3DFMT_R16G16_TYPELESS, 16, 16, 0, 0, 0, 16, 0, 0, 4, 0, 0},
160 {WINED3DFMT_R32_TYPELESS, 32, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0},
161 {WINED3DFMT_R24G8_TYPELESS, 0, 0, 0, 0, 0, 0, 0, 0, 4, 24, 8},
162 {WINED3DFMT_R8G8_TYPELESS, 8, 8, 0, 0, 0, 8, 0, 0, 2, 0, 0},
163 {WINED3DFMT_R16_TYPELESS, 16, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
164 {WINED3DFMT_R8_TYPELESS, 8, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
165 {WINED3DFMT_BC1_TYPELESS, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
166 {WINED3DFMT_BC2_TYPELESS, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
167 {WINED3DFMT_BC3_TYPELESS, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
168 {WINED3DFMT_BC4_TYPELESS, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
169 {WINED3DFMT_BC5_TYPELESS, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
170 {WINED3DFMT_B8G8R8A8_TYPELESS, 8, 8, 8, 8, 16, 8, 0, 24, 4, 0, 0},
171 {WINED3DFMT_B8G8R8X8_TYPELESS, 8, 8, 8, 0, 16, 8, 0, 0, 4, 0, 0},
172 };
173
174 enum wined3d_channel_type
175 {
176 WINED3D_CHANNEL_TYPE_NONE,
177 WINED3D_CHANNEL_TYPE_UNORM,
178 WINED3D_CHANNEL_TYPE_SNORM,
179 WINED3D_CHANNEL_TYPE_UINT,
180 WINED3D_CHANNEL_TYPE_SINT,
181 WINED3D_CHANNEL_TYPE_FLOAT,
182 WINED3D_CHANNEL_TYPE_DEPTH,
183 WINED3D_CHANNEL_TYPE_STENCIL,
184 };
185
186 struct wined3d_typed_format_info
187 {
188 enum wined3d_format_id id;
189 enum wined3d_format_id typeless_id;
190 const char *channels;
191 };
192
193 /**
194 * The last entry for a given typeless format defines its internal format.
195 *
196 * u - WINED3D_CHANNEL_TYPE_UNORM
197 * i - WINED3D_CHANNEL_TYPE_SNORM
198 * U - WINED3D_CHANNEL_TYPE_UINT
199 * I - WINED3D_CHANNEL_TYPE_SINT
200 * F - WINED3D_CHANNEL_TYPE_FLOAT
201 * D - WINED3D_CHANNEL_TYPE_DEPTH
202 * S - WINED3D_CHANNEL_TYPE_STENCIL
203 */
204 static const struct wined3d_typed_format_info typed_formats[] =
205 {
206 {WINED3DFMT_R32G32B32A32_UINT, WINED3DFMT_R32G32B32A32_TYPELESS, "UUUU"},
207 {WINED3DFMT_R32G32B32A32_SINT, WINED3DFMT_R32G32B32A32_TYPELESS, "IIII"},
208 {WINED3DFMT_R32G32B32A32_FLOAT, WINED3DFMT_R32G32B32A32_TYPELESS, "FFFF"},
209 {WINED3DFMT_R32G32B32_UINT, WINED3DFMT_R32G32B32_TYPELESS, "UUU"},
210 {WINED3DFMT_R32G32B32_SINT, WINED3DFMT_R32G32B32_TYPELESS, "III"},
211 {WINED3DFMT_R32G32B32_FLOAT, WINED3DFMT_R32G32B32_TYPELESS, "FFF"},
212 {WINED3DFMT_R16G16B16A16_UNORM, WINED3DFMT_R16G16B16A16_TYPELESS, "uuuu"},
213 {WINED3DFMT_R16G16B16A16_SNORM, WINED3DFMT_R16G16B16A16_TYPELESS, "iiii"},
214 {WINED3DFMT_R16G16B16A16_UINT, WINED3DFMT_R16G16B16A16_TYPELESS, "UUUU"},
215 {WINED3DFMT_R16G16B16A16_SINT, WINED3DFMT_R16G16B16A16_TYPELESS, "IIII"},
216 {WINED3DFMT_R16G16B16A16_FLOAT, WINED3DFMT_R16G16B16A16_TYPELESS, "FFFF"},
217 {WINED3DFMT_R32G32_UINT, WINED3DFMT_R32G32_TYPELESS, "UU"},
218 {WINED3DFMT_R32G32_SINT, WINED3DFMT_R32G32_TYPELESS, "II"},
219 {WINED3DFMT_R32G32_FLOAT, WINED3DFMT_R32G32_TYPELESS, "FF"},
220 {WINED3DFMT_R10G10B10A2_SNORM, WINED3DFMT_R10G10B10A2_TYPELESS, "iiii"},
221 {WINED3DFMT_R10G10B10A2_UINT, WINED3DFMT_R10G10B10A2_TYPELESS, "UUUU"},
222 {WINED3DFMT_R10G10B10A2_UNORM, WINED3DFMT_R10G10B10A2_TYPELESS, "uuuu"},
223 {WINED3DFMT_R8G8B8A8_UINT, WINED3DFMT_R8G8B8A8_TYPELESS, "UUUU"},
224 {WINED3DFMT_R8G8B8A8_SINT, WINED3DFMT_R8G8B8A8_TYPELESS, "IIII"},
225 {WINED3DFMT_R8G8B8A8_UNORM_SRGB, WINED3DFMT_R8G8B8A8_TYPELESS, "uuuu"},
226 {WINED3DFMT_R8G8B8A8_UNORM, WINED3DFMT_R8G8B8A8_TYPELESS, "uuuu"},
227 {WINED3DFMT_R16G16_UNORM, WINED3DFMT_R16G16_TYPELESS, "uu"},
228 {WINED3DFMT_R16G16_SNORM, WINED3DFMT_R16G16_TYPELESS, "ii"},
229 {WINED3DFMT_R16G16_UINT, WINED3DFMT_R16G16_TYPELESS, "UU"},
230 {WINED3DFMT_R16G16_SINT, WINED3DFMT_R16G16_TYPELESS, "II"},
231 {WINED3DFMT_R16G16_FLOAT, WINED3DFMT_R16G16_TYPELESS, "FF"},
232 {WINED3DFMT_R32_UINT, WINED3DFMT_R32_TYPELESS, "U"},
233 {WINED3DFMT_R32_SINT, WINED3DFMT_R32_TYPELESS, "I"},
234 {WINED3DFMT_R32_FLOAT, WINED3DFMT_R32_TYPELESS, "F"},
235 {WINED3DFMT_D24_UNORM_S8_UINT, WINED3DFMT_R24G8_TYPELESS, "DS"},
236 {WINED3DFMT_R8G8_SNORM, WINED3DFMT_R8G8_TYPELESS, "ii"},
237 {WINED3DFMT_R8G8_UNORM, WINED3DFMT_R8G8_TYPELESS, "uu"},
238 {WINED3DFMT_R16_UNORM, WINED3DFMT_R16_TYPELESS, "u"},
239 {WINED3DFMT_R16_UINT, WINED3DFMT_R16_TYPELESS, "U"},
240 {WINED3DFMT_R16_SINT, WINED3DFMT_R16_TYPELESS, "I"},
241 {WINED3DFMT_R16_FLOAT, WINED3DFMT_R16_TYPELESS, "F"},
242 {WINED3DFMT_R8_UNORM, WINED3DFMT_R8_TYPELESS, "u"},
243 {WINED3DFMT_BC1_UNORM_SRGB, WINED3DFMT_BC1_TYPELESS, ""},
244 {WINED3DFMT_BC1_UNORM, WINED3DFMT_BC1_TYPELESS, ""},
245 {WINED3DFMT_BC2_UNORM_SRGB, WINED3DFMT_BC2_TYPELESS, ""},
246 {WINED3DFMT_BC2_UNORM, WINED3DFMT_BC2_TYPELESS, ""},
247 {WINED3DFMT_BC3_UNORM_SRGB, WINED3DFMT_BC3_TYPELESS, ""},
248 {WINED3DFMT_BC3_UNORM, WINED3DFMT_BC3_TYPELESS, ""},
249 {WINED3DFMT_BC4_UNORM, WINED3DFMT_BC4_TYPELESS, ""},
250 {WINED3DFMT_BC5_UNORM, WINED3DFMT_BC5_TYPELESS, ""},
251 {WINED3DFMT_B8G8R8A8_UNORM_SRGB, WINED3DFMT_B8G8R8A8_TYPELESS, "uuuu"},
252 {WINED3DFMT_B8G8R8A8_UNORM, WINED3DFMT_B8G8R8A8_TYPELESS, "uuuu"},
253 {WINED3DFMT_B8G8R8X8_UNORM_SRGB, WINED3DFMT_B8G8R8X8_TYPELESS, "uuu"},
254 {WINED3DFMT_B8G8R8X8_UNORM, WINED3DFMT_B8G8R8X8_TYPELESS, "uuu"},
255 };
256
257 struct wined3d_format_ddi_info
258 {
259 enum wined3d_format_id id;
260 D3DDDIFORMAT ddi_format;
261 };
262
263 static const struct wined3d_format_ddi_info ddi_formats[] =
264 {
265 {WINED3DFMT_B8G8R8_UNORM, D3DDDIFMT_R8G8B8},
266 {WINED3DFMT_B8G8R8A8_UNORM, D3DDDIFMT_A8R8G8B8},
267 {WINED3DFMT_B8G8R8X8_UNORM, D3DDDIFMT_X8R8G8B8},
268 {WINED3DFMT_B5G6R5_UNORM, D3DDDIFMT_R5G6B5},
269 {WINED3DFMT_B5G5R5X1_UNORM, D3DDDIFMT_X1R5G5B5},
270 {WINED3DFMT_B5G5R5A1_UNORM, D3DDDIFMT_A1R5G5B5},
271 {WINED3DFMT_P8_UINT, D3DDDIFMT_P8},
272 };
273
274 struct wined3d_format_base_flags
275 {
276 enum wined3d_format_id id;
277 DWORD flags;
278 };
279
280 /* The ATI2N format behaves like an uncompressed format in LockRect(), but
281 * still needs to use the correct block based calculation for e.g. the
282 * resource size. */
283 static const struct wined3d_format_base_flags format_base_flags[] =
284 {
285 {WINED3DFMT_ATI1N, WINED3DFMT_FLAG_BROKEN_PITCH},
286 {WINED3DFMT_ATI2N, WINED3DFMT_FLAG_BROKEN_PITCH},
287 {WINED3DFMT_R11G11B10_FLOAT, WINED3DFMT_FLAG_FLOAT},
288 {WINED3DFMT_D32_FLOAT, WINED3DFMT_FLAG_FLOAT},
289 {WINED3DFMT_S8_UINT_D24_FLOAT, WINED3DFMT_FLAG_FLOAT},
290 };
291
292 struct wined3d_format_block_info
293 {
294 enum wined3d_format_id id;
295 UINT block_width;
296 UINT block_height;
297 UINT block_byte_count;
298 BOOL verify;
299 };
300
301 static const struct wined3d_format_block_info format_block_info[] =
302 {
303 {WINED3DFMT_DXT1, 4, 4, 8, TRUE},
304 {WINED3DFMT_DXT2, 4, 4, 16, TRUE},
305 {WINED3DFMT_DXT3, 4, 4, 16, TRUE},
306 {WINED3DFMT_DXT4, 4, 4, 16, TRUE},
307 {WINED3DFMT_DXT5, 4, 4, 16, TRUE},
308 {WINED3DFMT_BC1_UNORM, 4, 4, 8, TRUE},
309 {WINED3DFMT_BC2_UNORM, 4, 4, 16, TRUE},
310 {WINED3DFMT_BC3_UNORM, 4, 4, 16, TRUE},
311 {WINED3DFMT_BC4_UNORM, 4, 4, 8, TRUE},
312 {WINED3DFMT_BC5_UNORM, 4, 4, 16, TRUE},
313 {WINED3DFMT_ATI1N, 4, 4, 8, FALSE},
314 {WINED3DFMT_ATI2N, 4, 4, 16, FALSE},
315 {WINED3DFMT_YUY2, 2, 1, 4, FALSE},
316 {WINED3DFMT_UYVY, 2, 1, 4, FALSE},
317 };
318
319 struct wined3d_format_vertex_info
320 {
321 enum wined3d_format_id id;
322 enum wined3d_ffp_emit_idx emit_idx;
323 unsigned int component_count;
324 GLenum gl_vtx_type;
325 GLboolean gl_normalized;
326 };
327
328 static const struct wined3d_format_vertex_info format_vertex_info[] =
329 {
330 {WINED3DFMT_R32_FLOAT, WINED3D_FFP_EMIT_FLOAT1, 1, GL_FLOAT, GL_FALSE},
331 {WINED3DFMT_R32G32_FLOAT, WINED3D_FFP_EMIT_FLOAT2, 2, GL_FLOAT, GL_FALSE},
332 {WINED3DFMT_R32G32B32_FLOAT, WINED3D_FFP_EMIT_FLOAT3, 3, GL_FLOAT, GL_FALSE},
333 {WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_FFP_EMIT_FLOAT4, 4, GL_FLOAT, GL_FALSE},
334 {WINED3DFMT_B8G8R8A8_UNORM, WINED3D_FFP_EMIT_D3DCOLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE },
335 {WINED3DFMT_R8G8B8A8_UINT, WINED3D_FFP_EMIT_UBYTE4, 4, GL_UNSIGNED_BYTE, GL_FALSE},
336 {WINED3DFMT_R16G16_SINT, WINED3D_FFP_EMIT_SHORT2, 2, GL_SHORT, GL_FALSE},
337 {WINED3DFMT_R16G16B16A16_SINT, WINED3D_FFP_EMIT_SHORT4, 4, GL_SHORT, GL_FALSE},
338 {WINED3DFMT_R8G8B8A8_UNORM, WINED3D_FFP_EMIT_UBYTE4N, 4, GL_UNSIGNED_BYTE, GL_TRUE },
339 {WINED3DFMT_R16G16_SNORM, WINED3D_FFP_EMIT_SHORT2N, 2, GL_SHORT, GL_TRUE },
340 {WINED3DFMT_R16G16B16A16_SNORM, WINED3D_FFP_EMIT_SHORT4N, 4, GL_SHORT, GL_TRUE },
341 {WINED3DFMT_R16G16_UNORM, WINED3D_FFP_EMIT_USHORT2N, 2, GL_UNSIGNED_SHORT, GL_TRUE },
342 {WINED3DFMT_R16G16B16A16_UNORM, WINED3D_FFP_EMIT_USHORT4N, 4, GL_UNSIGNED_SHORT, GL_TRUE },
343 {WINED3DFMT_R10G10B10A2_UINT, WINED3D_FFP_EMIT_UDEC3, 3, GL_UNSIGNED_SHORT, GL_FALSE},
344 {WINED3DFMT_R10G10B10A2_SNORM, WINED3D_FFP_EMIT_DEC3N, 3, GL_SHORT, GL_TRUE },
345 {WINED3DFMT_R16G16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_2, 2, GL_HALF_FLOAT, GL_FALSE},
346 {WINED3DFMT_R16G16B16A16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_4, 4, GL_HALF_FLOAT, GL_FALSE},
347 {WINED3DFMT_R8G8B8A8_SNORM, WINED3D_FFP_EMIT_INVALID, 4, GL_BYTE, GL_TRUE },
348 {WINED3DFMT_R8G8B8A8_SINT, WINED3D_FFP_EMIT_INVALID, 4, GL_BYTE, GL_FALSE},
349 {WINED3DFMT_R16G16B16A16_UINT, WINED3D_FFP_EMIT_INVALID, 4, GL_UNSIGNED_SHORT, GL_FALSE},
350 {WINED3DFMT_R32_UINT, WINED3D_FFP_EMIT_INVALID, 1, GL_UNSIGNED_INT, GL_FALSE},
351 {WINED3DFMT_R32G32_UINT, WINED3D_FFP_EMIT_INVALID, 2, GL_UNSIGNED_INT, GL_FALSE},
352 {WINED3DFMT_R32G32B32_UINT, WINED3D_FFP_EMIT_INVALID, 3, GL_UNSIGNED_INT, GL_FALSE},
353 {WINED3DFMT_R32G32B32A32_UINT, WINED3D_FFP_EMIT_INVALID, 4, GL_UNSIGNED_INT, GL_FALSE},
354 };
355
356 struct wined3d_format_texture_info
357 {
358 enum wined3d_format_id id;
359 GLint gl_internal;
360 GLint gl_srgb_internal;
361 GLint gl_rt_internal;
362 GLint gl_format;
363 GLint gl_type;
364 unsigned int conv_byte_count;
365 unsigned int flags;
366 enum wined3d_gl_extension extension;
367 void (*convert)(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
368 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth);
369 };
370
371 static void convert_l4a4_unorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
372 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
373 {
374 /* WINED3DFMT_L4A4_UNORM exists as an internal gl format, but for some reason there is not
375 * format+type combination to load it. Thus convert it to A8L8, then load it
376 * with A4L4 internal, but A8L8 format+type
377 */
378 unsigned int x, y, z;
379 const unsigned char *Source;
380 unsigned char *Dest;
381
382 for (z = 0; z < depth; z++)
383 {
384 for (y = 0; y < height; y++)
385 {
386 Source = src + z * src_slice_pitch + y * src_row_pitch;
387 Dest = dst + z * dst_slice_pitch + y * dst_row_pitch;
388 for (x = 0; x < width; x++ )
389 {
390 unsigned char color = (*Source++);
391 /* A */ Dest[1] = (color & 0xf0u) << 0;
392 /* L */ Dest[0] = (color & 0x0fu) << 4;
393 Dest += 2;
394 }
395 }
396 }
397 }
398
399 static void convert_r5g5_snorm_l6_unorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
400 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
401 {
402 unsigned int x, y, z;
403 unsigned char r_in, g_in, l_in;
404 const unsigned short *texel_in;
405 unsigned short *texel_out;
406
407 /* Emulating signed 5 bit values with unsigned 5 bit values has some precision problems by design:
408 * E.g. the signed input value 0 becomes 16. GL normalizes it to 16 / 31 = 0.516. We convert it
409 * back to a signed value by subtracting 0.5 and multiplying by 2.0. The resulting value is
410 * ((16 / 31) - 0.5) * 2.0 = 0.032, which is quite different from the intended result 0.000. */
411 for (z = 0; z < depth; z++)
412 {
413 for (y = 0; y < height; y++)
414 {
415 texel_out = (unsigned short *) (dst + z * dst_slice_pitch + y * dst_row_pitch);
416 texel_in = (const unsigned short *)(src + z * src_slice_pitch + y * src_row_pitch);
417 for (x = 0; x < width; x++ )
418 {
419 l_in = (*texel_in & 0xfc00u) >> 10;
420 g_in = (*texel_in & 0x03e0u) >> 5;
421 r_in = *texel_in & 0x001fu;
422
423 *texel_out = ((r_in + 16) << 11) | (l_in << 5) | (g_in + 16);
424 texel_out++;
425 texel_in++;
426 }
427 }
428 }
429 }
430
431 static void convert_r5g5_snorm_l6_unorm_ext(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
432 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
433 {
434 unsigned int x, y, z;
435 unsigned char *texel_out, r_out, g_out, r_in, g_in, l_in;
436 const unsigned short *texel_in;
437
438 for (z = 0; z < depth; z++)
439 {
440 for (y = 0; y < height; y++)
441 {
442 texel_in = (const unsigned short *)(src + z * src_slice_pitch + y * src_row_pitch);
443 texel_out = dst + z * dst_slice_pitch + y * dst_row_pitch;
444 for (x = 0; x < width; x++ )
445 {
446 l_in = (*texel_in & 0xfc00u) >> 10;
447 g_in = (*texel_in & 0x03e0u) >> 5;
448 r_in = *texel_in & 0x001fu;
449
450 r_out = r_in << 3;
451 if (!(r_in & 0x10)) /* r > 0 */
452 r_out |= r_in >> 1;
453
454 g_out = g_in << 3;
455 if (!(g_in & 0x10)) /* g > 0 */
456 g_out |= g_in >> 1;
457
458 texel_out[0] = r_out;
459 texel_out[1] = g_out;
460 texel_out[2] = l_in << 1 | l_in >> 5;
461 texel_out[3] = 0;
462
463 texel_out += 4;
464 texel_in++;
465 }
466 }
467 }
468 }
469
470 static void convert_r5g5_snorm_l6_unorm_nv(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
471 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
472 {
473 unsigned int x, y, z;
474 unsigned char *texel_out, ds_out, dt_out, r_in, g_in, l_in;
475 const unsigned short *texel_in;
476
477 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
478 * fixed function and shaders without further conversion once the surface is
479 * loaded.
480 *
481 * The difference between this function and convert_r5g5_snorm_l6_unorm_ext
482 * is that convert_r5g5_snorm_l6_unorm_ext creates a 32 bit XRGB texture and
483 * this function creates a 24 bit DSDT_MAG texture. Trying to load a DSDT_MAG
484 * internal with a 32 bit DSDT_MAG_INTENSITY or DSDT_MAG_VIB format fails. */
485 for (z = 0; z < depth; z++)
486 {
487 for (y = 0; y < height; y++)
488 {
489 texel_in = (const unsigned short *)(src + z * src_slice_pitch + y * src_row_pitch);
490 texel_out = dst + z * dst_slice_pitch + y * dst_row_pitch;
491 for (x = 0; x < width; x++ )
492 {
493 l_in = (*texel_in & 0xfc00u) >> 10;
494 g_in = (*texel_in & 0x03e0u) >> 5;
495 r_in = *texel_in & 0x001fu;
496
497 ds_out = r_in << 3;
498 if (!(r_in & 0x10)) /* r > 0 */
499 ds_out |= r_in >> 1;
500
501 dt_out = g_in << 3;
502 if (!(g_in & 0x10)) /* g > 0 */
503 dt_out |= g_in >> 1;
504
505 texel_out[0] = ds_out;
506 texel_out[1] = dt_out;
507 texel_out[2] = l_in << 1 | l_in >> 5;
508
509 texel_out += 3;
510 texel_in++;
511 }
512 }
513 }
514 }
515
516 static void convert_r8g8_snorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
517 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
518 {
519 unsigned int x, y, z;
520 const short *Source;
521 unsigned char *Dest;
522
523 for (z = 0; z < depth; z++)
524 {
525 for (y = 0; y < height; y++)
526 {
527 Source = (const short *)(src + z * src_slice_pitch + y * src_row_pitch);
528 Dest = dst + z * dst_slice_pitch + y * dst_row_pitch;
529 for (x = 0; x < width; x++ )
530 {
531 const short color = (*Source++);
532 /* B */ Dest[0] = 0xff;
533 /* G */ Dest[1] = (color >> 8) + 128; /* V */
534 /* R */ Dest[2] = (color & 0xff) + 128; /* U */
535 Dest += 3;
536 }
537 }
538 }
539 }
540
541 static void convert_r8g8_snorm_l8x8_unorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
542 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
543 {
544 unsigned int x, y, z;
545 const DWORD *Source;
546 unsigned char *Dest;
547
548 /* Doesn't work correctly with the fixed function pipeline, but can work in
549 * shaders if the shader is adjusted. (There's no use for this format in gl's
550 * standard fixed function pipeline anyway).
551 */
552 for (z = 0; z < depth; z++)
553 {
554 for (y = 0; y < height; y++)
555 {
556 Source = (const DWORD *)(src + z * src_slice_pitch + y * src_row_pitch);
557 Dest = dst + z * dst_slice_pitch + y * dst_row_pitch;
558 for (x = 0; x < width; x++ )
559 {
560 LONG color = (*Source++);
561 /* B */ Dest[0] = ((color >> 16) & 0xff); /* L */
562 /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
563 /* R */ Dest[2] = (color & 0xff) + 128; /* U */
564 Dest += 4;
565 }
566 }
567 }
568 }
569
570 static void convert_r8g8_snorm_l8x8_unorm_nv(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
571 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
572 {
573 unsigned int x, y, z;
574 const DWORD *Source;
575 unsigned char *Dest;
576
577 /* This implementation works with the fixed function pipeline and shaders
578 * without further modification after converting the surface.
579 */
580 for (z = 0; z < depth; z++)
581 {
582 for (y = 0; y < height; y++)
583 {
584 Source = (const DWORD *)(src + z * src_slice_pitch + y * src_row_pitch);
585 Dest = dst + z * dst_slice_pitch + y * dst_row_pitch;
586 for (x = 0; x < width; x++ )
587 {
588 LONG color = (*Source++);
589 /* L */ Dest[2] = ((color >> 16) & 0xff); /* L */
590 /* V */ Dest[1] = ((color >> 8 ) & 0xff); /* V */
591 /* U */ Dest[0] = (color & 0xff); /* U */
592 /* I */ Dest[3] = 255; /* X */
593 Dest += 4;
594 }
595 }
596 }
597 }
598
599 static void convert_r8g8b8a8_snorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
600 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
601 {
602 unsigned int x, y, z;
603 const DWORD *Source;
604 unsigned char *Dest;
605
606 for (z = 0; z < depth; z++)
607 {
608 for (y = 0; y < height; y++)
609 {
610 Source = (const DWORD *)(src + z * src_slice_pitch + y * src_row_pitch);
611 Dest = dst + z * dst_slice_pitch + y * dst_row_pitch;
612 for (x = 0; x < width; x++ )
613 {
614 LONG color = (*Source++);
615 /* B */ Dest[0] = ((color >> 16) & 0xff) + 128; /* W */
616 /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
617 /* R */ Dest[2] = (color & 0xff) + 128; /* U */
618 /* A */ Dest[3] = ((color >> 24) & 0xff) + 128; /* Q */
619 Dest += 4;
620 }
621 }
622 }
623 }
624
625 static void convert_r16g16_snorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
626 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
627 {
628 unsigned int x, y, z;
629 const DWORD *Source;
630 unsigned short *Dest;
631
632 for (z = 0; z < depth; z++)
633 {
634 for (y = 0; y < height; y++)
635 {
636 Source = (const DWORD *)(src + z * src_slice_pitch + y * src_row_pitch);
637 Dest = (unsigned short *) (dst + z * dst_slice_pitch + y * dst_row_pitch);
638 for (x = 0; x < width; x++ )
639 {
640 const DWORD color = (*Source++);
641 /* B */ Dest[0] = 0xffff;
642 /* G */ Dest[1] = (color >> 16) + 32768; /* V */
643 /* R */ Dest[2] = (color & 0xffff) + 32768; /* U */
644 Dest += 3;
645 }
646 }
647 }
648 }
649
650 static void convert_r16g16(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
651 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
652 {
653 unsigned int x, y, z;
654 const WORD *Source;
655 WORD *Dest;
656
657 for (z = 0; z < depth; z++)
658 {
659 for (y = 0; y < height; y++)
660 {
661 Source = (const WORD *)(src + z * src_slice_pitch + y * src_row_pitch);
662 Dest = (WORD *) (dst + z * dst_slice_pitch + y * dst_row_pitch);
663 for (x = 0; x < width; x++ )
664 {
665 WORD green = (*Source++);
666 WORD red = (*Source++);
667 Dest[0] = green;
668 Dest[1] = red;
669 /* Strictly speaking not correct for R16G16F, but it doesn't matter because the
670 * shader overwrites it anyway */
671 Dest[2] = 0xffff;
672 Dest += 3;
673 }
674 }
675 }
676 }
677
678 static void convert_r32g32_float(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
679 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
680 {
681 unsigned int x, y, z;
682 const float *Source;
683 float *Dest;
684
685 for (z = 0; z < depth; z++)
686 {
687 for (y = 0; y < height; y++)
688 {
689 Source = (const float *)(src + z * src_slice_pitch + y * src_row_pitch);
690 Dest = (float *) (dst + z * dst_slice_pitch + y * dst_row_pitch);
691 for (x = 0; x < width; x++ )
692 {
693 float green = (*Source++);
694 float red = (*Source++);
695 Dest[0] = green;
696 Dest[1] = red;
697 Dest[2] = 1.0f;
698 Dest += 3;
699 }
700 }
701 }
702 }
703
704 static void convert_s1_uint_d15_unorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
705 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
706 {
707 unsigned int x, y, z;
708
709 for (z = 0; z < depth; z++)
710 {
711 for (y = 0; y < height; ++y)
712 {
713 const WORD *source = (const WORD *)(src + z * src_slice_pitch + y * src_row_pitch);
714 DWORD *dest = (DWORD *)(dst + z * dst_slice_pitch + y * dst_row_pitch);
715
716 for (x = 0; x < width; ++x)
717 {
718 /* The depth data is normalized, so needs to be scaled,
719 * the stencil data isn't. Scale depth data by
720 * (2^24-1)/(2^15-1) ~~ (2^9 + 2^-6). */
721 WORD d15 = source[x] >> 1;
722 DWORD d24 = (d15 << 9) + (d15 >> 6);
723 dest[x] = (d24 << 8) | (source[x] & 0x1);
724 }
725 }
726 }
727 }
728
729 static void convert_s4x4_uint_d24_unorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
730 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
731 {
732 unsigned int x, y, z;
733
734 for (z = 0; z < depth; z++)
735 {
736 for (y = 0; y < height; ++y)
737 {
738 const DWORD *source = (const DWORD *)(src + z * src_slice_pitch + y * src_row_pitch);
739 DWORD *dest = (DWORD *)(dst + z * dst_slice_pitch + y * dst_row_pitch);
740
741 for (x = 0; x < width; ++x)
742 {
743 /* Just need to clear out the X4 part. */
744 dest[x] = source[x] & ~0xf0;
745 }
746 }
747 }
748 }
749
750 static void convert_s8_uint_d24_float(const BYTE *src, BYTE *dst, UINT src_row_pitch, UINT src_slice_pitch,
751 UINT dst_row_pitch, UINT dst_slice_pitch, UINT width, UINT height, UINT depth)
752 {
753 unsigned int x, y, z;
754
755 for (z = 0; z < depth; z++)
756 {
757 for (y = 0; y < height; ++y)
758 {
759 const DWORD *source = (const DWORD *)(src + z * src_slice_pitch + y * src_row_pitch);
760 float *dest_f = (float *)(dst + z * dst_slice_pitch + y * dst_row_pitch);
761 DWORD *dest_s = (DWORD *)dest_f;
762
763 for (x = 0; x < width; ++x)
764 {
765 dest_f[x * 2] = float_24_to_32((source[x] & 0xffffff00u) >> 8);
766 dest_s[x * 2 + 1] = source[x] & 0xff;
767 }
768 }
769 }
770 }
771
772 static BOOL color_in_range(const struct wined3d_color_key *color_key, DWORD color)
773 {
774 /* FIXME: Is this really how color keys are supposed to work? I think it
775 * makes more sense to compare the individual channels. */
776 return color >= color_key->color_space_low_value
777 && color <= color_key->color_space_high_value;
778 }
779
780 static void convert_p8_uint_b8g8r8a8_unorm(const BYTE *src, unsigned int src_pitch,
781 BYTE *dst, unsigned int dst_pitch, unsigned int width, unsigned int height,
782 const struct wined3d_palette *palette, const struct wined3d_color_key *color_key)
783 {
784 const BYTE *src_row;
785 unsigned int x, y;
786 DWORD *dst_row;
787
788 if (!palette)
789 {
790 /* FIXME: This should probably use the system palette. */
791 FIXME("P8 surface loaded without a palette.\n");
792
793 for (y = 0; y < height; ++y)
794 {
795 memset(&dst[dst_pitch * y], 0, width * 4);
796 }
797
798 return;
799 }
800
801 for (y = 0; y < height; ++y)
802 {
803 src_row = &src[src_pitch * y];
804 dst_row = (DWORD *)&dst[dst_pitch * y];
805 for (x = 0; x < width; ++x)
806 {
807 BYTE src_color = src_row[x];
808 dst_row[x] = 0xff000000
809 | (palette->colors[src_color].rgbRed << 16)
810 | (palette->colors[src_color].rgbGreen << 8)
811 | palette->colors[src_color].rgbBlue;
812 }
813 }
814 }
815
816 static void convert_b5g6r5_unorm_b5g5r5a1_unorm_color_key(const BYTE *src, unsigned int src_pitch,
817 BYTE *dst, unsigned int dst_pitch, unsigned int width, unsigned int height,
818 const struct wined3d_palette *palette, const struct wined3d_color_key *color_key)
819 {
820 const WORD *src_row;
821 unsigned int x, y;
822 WORD *dst_row;
823
824 for (y = 0; y < height; ++y)
825 {
826 src_row = (WORD *)&src[src_pitch * y];
827 dst_row = (WORD *)&dst[dst_pitch * y];
828 for (x = 0; x < width; ++x)
829 {
830 WORD src_color = src_row[x];
831 if (!color_in_range(color_key, src_color))
832 dst_row[x] = 0x8000u | ((src_color & 0xffc0u) >> 1) | (src_color & 0x1fu);
833 else
834 dst_row[x] = ((src_color & 0xffc0u) >> 1) | (src_color & 0x1fu);
835 }
836 }
837 }
838
839 static void convert_b5g5r5x1_unorm_b5g5r5a1_unorm_color_key(const BYTE *src, unsigned int src_pitch,
840 BYTE *dst, unsigned int dst_pitch, unsigned int width, unsigned int height,
841 const struct wined3d_palette *palette, const struct wined3d_color_key *color_key)
842 {
843 const WORD *src_row;
844 unsigned int x, y;
845 WORD *dst_row;
846
847 for (y = 0; y < height; ++y)
848 {
849 src_row = (WORD *)&src[src_pitch * y];
850 dst_row = (WORD *)&dst[dst_pitch * y];
851 for (x = 0; x < width; ++x)
852 {
853 WORD src_color = src_row[x];
854 if (color_in_range(color_key, src_color))
855 dst_row[x] = src_color & ~0x8000;
856 else
857 dst_row[x] = src_color | 0x8000;
858 }
859 }
860 }
861
862 static void convert_b8g8r8_unorm_b8g8r8a8_unorm_color_key(const BYTE *src, unsigned int src_pitch,
863 BYTE *dst, unsigned int dst_pitch, unsigned int width, unsigned int height,
864 const struct wined3d_palette *palette, const struct wined3d_color_key *color_key)
865 {
866 const BYTE *src_row;
867 unsigned int x, y;
868 DWORD *dst_row;
869
870 for (y = 0; y < height; ++y)
871 {
872 src_row = &src[src_pitch * y];
873 dst_row = (DWORD *)&dst[dst_pitch * y];
874 for (x = 0; x < width; ++x)
875 {
876 DWORD src_color = (src_row[x * 3 + 2] << 16) | (src_row[x * 3 + 1] << 8) | src_row[x * 3];
877 if (!color_in_range(color_key, src_color))
878 dst_row[x] = src_color | 0xff000000;
879 }
880 }
881 }
882
883 static void convert_b8g8r8x8_unorm_b8g8r8a8_unorm_color_key(const BYTE *src, unsigned int src_pitch,
884 BYTE *dst, unsigned int dst_pitch, unsigned int width, unsigned int height,
885 const struct wined3d_palette *palette, const struct wined3d_color_key *color_key)
886 {
887 const DWORD *src_row;
888 unsigned int x, y;
889 DWORD *dst_row;
890
891 for (y = 0; y < height; ++y)
892 {
893 src_row = (DWORD *)&src[src_pitch * y];
894 dst_row = (DWORD *)&dst[dst_pitch * y];
895 for (x = 0; x < width; ++x)
896 {
897 DWORD src_color = src_row[x];
898 if (color_in_range(color_key, src_color))
899 dst_row[x] = src_color & ~0xff000000;
900 else
901 dst_row[x] = src_color | 0xff000000;
902 }
903 }
904 }
905
906 static void convert_b8g8r8a8_unorm_b8g8r8a8_unorm_color_key(const BYTE *src, unsigned int src_pitch,
907 BYTE *dst, unsigned int dst_pitch, unsigned int width, unsigned int height,
908 const struct wined3d_palette *palette, const struct wined3d_color_key *color_key)
909 {
910 const DWORD *src_row;
911 unsigned int x, y;
912 DWORD *dst_row;
913
914 for (y = 0; y < height; ++y)
915 {
916 src_row = (DWORD *)&src[src_pitch * y];
917 dst_row = (DWORD *)&dst[dst_pitch * y];
918 for (x = 0; x < width; ++x)
919 {
920 DWORD src_color = src_row[x];
921 if (color_in_range(color_key, src_color))
922 src_color &= ~0xff000000;
923 dst_row[x] = src_color;
924 }
925 }
926 }
927
928 const struct wined3d_color_key_conversion * wined3d_format_get_color_key_conversion(
929 const struct wined3d_texture *texture, BOOL need_alpha_ck)
930 {
931 const struct wined3d_format *format = texture->resource.format;
932 unsigned int i;
933
934 static const struct
935 {
936 enum wined3d_format_id src_format;
937 struct wined3d_color_key_conversion conversion;
938 }
939 color_key_info[] =
940 {
941 {WINED3DFMT_B5G6R5_UNORM, {WINED3DFMT_B5G5R5A1_UNORM, convert_b5g6r5_unorm_b5g5r5a1_unorm_color_key }},
942 {WINED3DFMT_B5G5R5X1_UNORM, {WINED3DFMT_B5G5R5A1_UNORM, convert_b5g5r5x1_unorm_b5g5r5a1_unorm_color_key }},
943 {WINED3DFMT_B8G8R8_UNORM, {WINED3DFMT_B8G8R8A8_UNORM, convert_b8g8r8_unorm_b8g8r8a8_unorm_color_key }},
944 {WINED3DFMT_B8G8R8X8_UNORM, {WINED3DFMT_B8G8R8A8_UNORM, convert_b8g8r8x8_unorm_b8g8r8a8_unorm_color_key }},
945 {WINED3DFMT_B8G8R8A8_UNORM, {WINED3DFMT_B8G8R8A8_UNORM, convert_b8g8r8a8_unorm_b8g8r8a8_unorm_color_key }},
946 };
947 static const struct wined3d_color_key_conversion convert_p8 =
948 {
949 WINED3DFMT_B8G8R8A8_UNORM, convert_p8_uint_b8g8r8a8_unorm
950 };
951
952 if (need_alpha_ck && (texture->async.flags & WINED3D_TEXTURE_ASYNC_COLOR_KEY))
953 {
954 for (i = 0; i < sizeof(color_key_info) / sizeof(*color_key_info); ++i)
955 {
956 if (color_key_info[i].src_format == format->id)
957 return &color_key_info[i].conversion;
958 }
959
960 FIXME("Color-keying not supported with format %s.\n", debug_d3dformat(format->id));
961 }
962
963 /* FIXME: This should check if the blitter backend can do P8 conversion,
964 * instead of checking for ARB_fragment_program. */
965 if (format->id == WINED3DFMT_P8_UINT
966 && !(texture->resource.device->adapter->gl_info.supported[ARB_FRAGMENT_PROGRAM]
967 && texture->swapchain && texture == texture->swapchain->front_buffer))
968 return &convert_p8;
969
970 return NULL;
971 }
972
973 /* The following formats explicitly don't have WINED3DFMT_FLAG_TEXTURE set:
974 *
975 * These are never supported on native.
976 * WINED3DFMT_B8G8R8_UNORM
977 * WINED3DFMT_B2G3R3_UNORM
978 * WINED3DFMT_L4A4_UNORM
979 * WINED3DFMT_S1_UINT_D15_UNORM
980 * WINED3DFMT_S4X4_UINT_D24_UNORM
981 *
982 * Only some Geforce/Voodoo3/G400 cards offer 8-bit textures in case of ddraw.
983 * Since it is not widely available, don't offer it. Further no Windows driver
984 * offers WINED3DFMT_P8_UINT_A8_NORM, so don't offer it either.
985 * WINED3DFMT_P8_UINT
986 * WINED3DFMT_P8_UINT_A8_UNORM
987 *
988 * These formats seem to be similar to the HILO formats in
989 * GL_NV_texture_shader. NVHU is said to be GL_UNSIGNED_HILO16,
990 * NVHS GL_SIGNED_HILO16. Rumours say that D3D computes a 3rd channel
991 * similarly to D3DFMT_CxV8U8 (So NVHS could be called D3DFMT_CxV16U16). ATI
992 * refused to support formats which can easily be emulated with pixel shaders,
993 * so applications have to deal with not having NVHS and NVHU.
994 * WINED3DFMT_NVHU
995 * WINED3DFMT_NVHS */
996 static const struct wined3d_format_texture_info format_texture_info[] =
997 {
998 /* format id gl_internal gl_srgb_internal gl_rt_internal
999 gl_format gl_type conv_byte_count
1000 flags
1001 extension convert */
1002 /* FourCC formats */
1003 /* GL_APPLE_ycbcr_422 claims that its '2YUV' format, which is supported via the UNSIGNED_SHORT_8_8_REV_APPLE type
1004 * is equivalent to 'UYVY' format on Windows, and the 'YUVS' via UNSIGNED_SHORT_8_8_APPLE equates to 'YUY2'. The
1005 * d3d9 test however shows that the opposite is true. Since the extension is from 2002, it predates the x86 based
1006 * Macs, so probably the endianness differs. This could be tested as soon as we have a Windows and MacOS on a big
1007 * endian machine
1008 */
1009 {WINED3DFMT_UYVY, GL_RG8, GL_RG8, 0,
1010 GL_RG, GL_UNSIGNED_BYTE, 0,
1011 WINED3DFMT_FLAG_FILTERING,
1012 ARB_TEXTURE_RG, NULL},
1013 {WINED3DFMT_UYVY, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE8_ALPHA8, 0,
1014 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
1015 WINED3DFMT_FLAG_FILTERING,
1016 WINED3D_GL_LEGACY_CONTEXT, NULL},
1017 {WINED3DFMT_UYVY, GL_RGB, GL_RGB, 0,
1018 GL_YCBCR_422_APPLE, GL_UNSIGNED_SHORT_8_8_APPLE, 0,
1019 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_FILTERING,
1020 APPLE_YCBCR_422, NULL},
1021 {WINED3DFMT_YUY2, GL_RG8, GL_RG8, 0,
1022 GL_RG, GL_UNSIGNED_BYTE, 0,
1023 WINED3DFMT_FLAG_FILTERING,
1024 ARB_TEXTURE_RG, NULL},
1025 {WINED3DFMT_YUY2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE8_ALPHA8, 0,
1026 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
1027 WINED3DFMT_FLAG_FILTERING,
1028 WINED3D_GL_LEGACY_CONTEXT, NULL},
1029 {WINED3DFMT_YUY2, GL_RGB, GL_RGB, 0,
1030 GL_YCBCR_422_APPLE, GL_UNSIGNED_SHORT_8_8_REV_APPLE, 0,
1031 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_FILTERING,
1032 APPLE_YCBCR_422, NULL},
1033 {WINED3DFMT_YV12, GL_R8, GL_R8, 0,
1034 GL_RED, GL_UNSIGNED_BYTE, 0,
1035 WINED3DFMT_FLAG_FILTERING,
1036 ARB_TEXTURE_RG, NULL},
1037 {WINED3DFMT_YV12, GL_ALPHA8, GL_ALPHA8, 0,
1038 GL_ALPHA, GL_UNSIGNED_BYTE, 0,
1039 WINED3DFMT_FLAG_FILTERING,
1040 WINED3D_GL_LEGACY_CONTEXT, NULL},
1041 {WINED3DFMT_NV12, GL_R8, GL_R8, 0,
1042 GL_RED, GL_UNSIGNED_BYTE, 0,
1043 WINED3DFMT_FLAG_FILTERING,
1044 ARB_TEXTURE_RG, NULL},
1045 {WINED3DFMT_NV12, GL_ALPHA8, GL_ALPHA8, 0,
1046 GL_ALPHA, GL_UNSIGNED_BYTE, 0,
1047 WINED3DFMT_FLAG_FILTERING,
1048 WINED3D_GL_LEGACY_CONTEXT, NULL},
1049 {WINED3DFMT_DXT1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0,
1050 GL_RGBA, GL_UNSIGNED_BYTE, 0,
1051 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1052 | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
1053 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
1054 {WINED3DFMT_DXT2, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
1055 GL_RGBA, GL_UNSIGNED_BYTE, 0,
1056 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1057 | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
1058 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
1059 {WINED3DFMT_DXT3, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
1060 GL_RGBA, GL_UNSIGNED_BYTE, 0,
1061 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1062 | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
1063 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
1064 {WINED3DFMT_DXT4, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
1065 GL_RGBA, GL_UNSIGNED_BYTE, 0,
1066 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1067 | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
1068 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
1069 {WINED3DFMT_DXT5, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
1070 GL_RGBA, GL_UNSIGNED_BYTE, 0,
1071 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1072 | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_COMPRESSED,
1073 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
1074 {WINED3DFMT_BC1_UNORM, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0,
1075 GL_RGBA, GL_UNSIGNED_BYTE, 0,
1076 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1077 | WINED3DFMT_FLAG_COMPRESSED,
1078 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
1079 {WINED3DFMT_BC2_UNORM, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
1080 GL_RGBA, GL_UNSIGNED_BYTE, 0,
1081 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1082 | WINED3DFMT_FLAG_COMPRESSED,
1083 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
1084 {WINED3DFMT_BC3_UNORM, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
1085 GL_RGBA, GL_UNSIGNED_BYTE, 0,
1086 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1087 | WINED3DFMT_FLAG_COMPRESSED,
1088 EXT_TEXTURE_COMPRESSION_S3TC, NULL},
1089 {WINED3DFMT_BC4_UNORM, GL_COMPRESSED_RED_RGTC1, GL_COMPRESSED_RED_RGTC1, 0,
1090 GL_RED, GL_UNSIGNED_BYTE, 0,
1091 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1092 | WINED3DFMT_FLAG_COMPRESSED,
1093 ARB_TEXTURE_COMPRESSION_RGTC, NULL},
1094 {WINED3DFMT_BC5_UNORM, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_RG_RGTC2, 0,
1095 GL_RG, GL_UNSIGNED_BYTE, 0,
1096 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1097 | WINED3DFMT_FLAG_COMPRESSED,
1098 ARB_TEXTURE_COMPRESSION_RGTC, NULL},
1099 /* IEEE formats */
1100 {WINED3DFMT_R32_FLOAT, GL_RGB32F_ARB, GL_RGB32F_ARB, 0,
1101 GL_RED, GL_FLOAT, 0,
1102 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1103 ARB_TEXTURE_FLOAT, NULL},
1104 {WINED3DFMT_R32_FLOAT, GL_R32F, GL_R32F, 0,
1105 GL_RED, GL_FLOAT, 0,
1106 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1107 ARB_TEXTURE_RG, NULL},
1108 {WINED3DFMT_R32G32_FLOAT, GL_RGB32F_ARB, GL_RGB32F_ARB, 0,
1109 GL_RGB, GL_FLOAT, 12,
1110 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1111 ARB_TEXTURE_FLOAT, convert_r32g32_float},
1112 {WINED3DFMT_R32G32_FLOAT, GL_RG32F, GL_RG32F, 0,
1113 GL_RG, GL_FLOAT, 0,
1114 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1115 ARB_TEXTURE_RG, NULL},
1116 {WINED3DFMT_R32G32B32_FLOAT, GL_RGB32F, GL_RGB32F, 0,
1117 GL_RGB, GL_FLOAT, 0,
1118 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET,
1119 ARB_TEXTURE_FLOAT, NULL},
1120 {WINED3DFMT_R32G32B32A32_FLOAT, GL_RGBA32F_ARB, GL_RGBA32F_ARB, 0,
1121 GL_RGBA, GL_FLOAT, 0,
1122 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1123 ARB_TEXTURE_FLOAT, NULL},
1124 /* Float */
1125 {WINED3DFMT_R16_FLOAT, GL_RGB16F_ARB, GL_RGB16F_ARB, 0,
1126 GL_RED, GL_HALF_FLOAT_ARB, 0,
1127 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1128 ARB_TEXTURE_FLOAT, NULL},
1129 {WINED3DFMT_R16_FLOAT, GL_R16F, GL_R16F, 0,
1130 GL_RED, GL_HALF_FLOAT_ARB, 0,
1131 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1132 ARB_TEXTURE_RG, NULL},
1133 {WINED3DFMT_R16G16_FLOAT, GL_RGB16F_ARB, GL_RGB16F_ARB, 0,
1134 GL_RGB, GL_HALF_FLOAT_ARB, 6,
1135 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1136 ARB_TEXTURE_FLOAT, convert_r16g16},
1137 {WINED3DFMT_R16G16_FLOAT, GL_RG16F, GL_RG16F, 0,
1138 GL_RG, GL_HALF_FLOAT_ARB, 0,
1139 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1140 ARB_TEXTURE_RG, NULL},
1141 {WINED3DFMT_R16G16B16A16_FLOAT, GL_RGBA16F_ARB, GL_RGBA16F_ARB, 0,
1142 GL_RGBA, GL_HALF_FLOAT_ARB, 0,
1143 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_RENDERTARGET
1144 | WINED3DFMT_FLAG_VTF,
1145 ARB_TEXTURE_FLOAT, NULL},
1146 {WINED3DFMT_R11G11B10_FLOAT, GL_R11F_G11F_B10F, GL_R11F_G11F_B10F, 0,
1147 GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, 0,
1148 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_RENDERTARGET,
1149 EXT_PACKED_FLOAT},
1150 /* Palettized formats */
1151 {WINED3DFMT_P8_UINT, GL_R8, GL_R8, 0,
1152 GL_RED, GL_UNSIGNED_BYTE, 0,
1153 0,
1154 ARB_TEXTURE_RG, NULL},
1155 {WINED3DFMT_P8_UINT, GL_ALPHA8, GL_ALPHA8, 0,
1156 GL_ALPHA, GL_UNSIGNED_BYTE, 0,
1157 0,
1158 WINED3D_GL_LEGACY_CONTEXT, NULL},
1159 /* Standard ARGB formats */
1160 {WINED3DFMT_B8G8R8_UNORM, GL_RGB8, GL_RGB8, 0,
1161 GL_BGR, GL_UNSIGNED_BYTE, 0,
1162 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
1163 WINED3D_GL_EXT_NONE, NULL},
1164 {WINED3DFMT_B8G8R8A8_UNORM, GL_RGBA8, GL_SRGB8_ALPHA8_EXT, 0,
1165 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
1166 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1167 | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE
1168 | WINED3DFMT_FLAG_VTF,
1169 WINED3D_GL_EXT_NONE, NULL},
1170 {WINED3DFMT_B8G8R8X8_UNORM, GL_RGB8, GL_SRGB8_EXT, 0,
1171 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
1172 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1173 | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE,
1174 WINED3D_GL_EXT_NONE, NULL},
1175 {WINED3DFMT_B5G6R5_UNORM, GL_RGB5, GL_RGB5, GL_RGB8,
1176 GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0,
1177 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1178 | WINED3DFMT_FLAG_RENDERTARGET,
1179 WINED3D_GL_EXT_NONE, NULL},
1180 {WINED3DFMT_B5G6R5_UNORM, GL_RGB565, GL_RGB565, GL_RGB8,
1181 GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0,
1182 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1183 | WINED3DFMT_FLAG_RENDERTARGET,
1184 ARB_ES2_COMPATIBILITY, NULL},
1185 {WINED3DFMT_B5G5R5X1_UNORM, GL_RGB5, GL_RGB5, 0,
1186 GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 0,
1187 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1188 | WINED3DFMT_FLAG_RENDERTARGET,
1189 WINED3D_GL_EXT_NONE, NULL},
1190 {WINED3DFMT_B5G5R5A1_UNORM, GL_RGB5_A1, GL_RGB5_A1, 0,
1191 GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 0,
1192 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1193 WINED3D_GL_EXT_NONE, NULL},
1194 {WINED3DFMT_B4G4R4A4_UNORM, GL_RGBA4, GL_SRGB8_ALPHA8_EXT, 0,
1195 GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 0,
1196 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1197 | WINED3DFMT_FLAG_SRGB_READ,
1198 WINED3D_GL_EXT_NONE, NULL},
1199 {WINED3DFMT_B2G3R3_UNORM, GL_R3_G3_B2, GL_R3_G3_B2, 0,
1200 GL_RGB, GL_UNSIGNED_BYTE_3_3_2, 0,
1201 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1202 WINED3D_GL_EXT_NONE, NULL},
1203 {WINED3DFMT_R8_UNORM, GL_R8, GL_R8, 0,
1204 GL_RED, GL_UNSIGNED_BYTE, 0,
1205 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1206 | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_VTF,
1207 ARB_TEXTURE_RG, NULL},
1208 {WINED3DFMT_A8_UNORM, GL_R8, GL_R8, 0,
1209 GL_RED, GL_UNSIGNED_BYTE, 0,
1210 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1211 ARB_TEXTURE_RG, NULL},
1212 {WINED3DFMT_A8_UNORM, GL_ALPHA8, GL_ALPHA8, 0,
1213 GL_ALPHA, GL_UNSIGNED_BYTE, 0,
1214 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1215 WINED3D_GL_LEGACY_CONTEXT, NULL},
1216 {WINED3DFMT_B4G4R4X4_UNORM, GL_RGB4, GL_RGB4, 0,
1217 GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 0,
1218 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1219 WINED3D_GL_EXT_NONE, NULL},
1220 {WINED3DFMT_R10G10B10A2_UNORM, GL_RGB10_A2, GL_RGB10_A2, 0,
1221 GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, 0,
1222 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1223 | WINED3DFMT_FLAG_RENDERTARGET,
1224 WINED3D_GL_EXT_NONE, NULL},
1225 {WINED3DFMT_R8G8B8A8_UNORM, GL_RGBA8, GL_SRGB8_ALPHA8_EXT, 0,
1226 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
1227 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1228 | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE
1229 | WINED3DFMT_FLAG_VTF,
1230 WINED3D_GL_EXT_NONE, NULL},
1231 {WINED3DFMT_R8G8B8A8_UINT, GL_RGBA8UI, GL_RGBA8UI, 0,
1232 GL_RGBA_INTEGER, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
1233 WINED3DFMT_FLAG_TEXTURE,
1234 ARB_TEXTURE_RGB10_A2UI, NULL},
1235 {WINED3DFMT_R8G8B8A8_SINT, GL_RGBA8I, GL_RGBA8I, 0,
1236 GL_RGBA_INTEGER, GL_BYTE, 0,
1237 WINED3DFMT_FLAG_TEXTURE,
1238 EXT_TEXTURE_INTEGER, NULL},
1239 {WINED3DFMT_R8G8B8X8_UNORM, GL_RGB8, GL_RGB8, 0,
1240 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
1241 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1242 WINED3D_GL_EXT_NONE, NULL},
1243 {WINED3DFMT_R16G16_UNORM, GL_RGB16, GL_RGB16, GL_RGBA16,
1244 GL_RGB, GL_UNSIGNED_SHORT, 6,
1245 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1246 WINED3D_GL_EXT_NONE, convert_r16g16},
1247 {WINED3DFMT_R16G16_UNORM, GL_RG16, GL_RG16, 0,
1248 GL_RG, GL_UNSIGNED_SHORT, 0,
1249 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1250 | WINED3DFMT_FLAG_RENDERTARGET,
1251 ARB_TEXTURE_RG, NULL},
1252 {WINED3DFMT_B10G10R10A2_UNORM, GL_RGB10_A2, GL_RGB10_A2, 0,
1253 GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV, 0,
1254 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1255 | WINED3DFMT_FLAG_RENDERTARGET,
1256 WINED3D_GL_EXT_NONE, NULL},
1257 {WINED3DFMT_R16G16B16A16_UNORM, GL_RGBA16, GL_RGBA16, 0,
1258 GL_RGBA, GL_UNSIGNED_SHORT, 0,
1259 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1260 | WINED3DFMT_FLAG_RENDERTARGET,
1261 WINED3D_GL_EXT_NONE, NULL},
1262 {WINED3DFMT_R8G8_UNORM, GL_RG8, GL_RG8, 0,
1263 GL_RG, GL_UNSIGNED_BYTE, 0,
1264 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1265 ARB_TEXTURE_RG, NULL},
1266 {WINED3DFMT_R16_UNORM, GL_R16, GL_R16, 0,
1267 GL_RED, GL_UNSIGNED_SHORT, 0,
1268 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1269 | WINED3DFMT_FLAG_RENDERTARGET,
1270 ARB_TEXTURE_RG, NULL},
1271 {WINED3DFMT_R16_UINT, GL_R16UI, GL_R16UI, 0,
1272 GL_RED_INTEGER, GL_UNSIGNED_SHORT, 0,
1273 WINED3DFMT_FLAG_TEXTURE,
1274 ARB_TEXTURE_RG, NULL},
1275 /* Luminance */
1276 {WINED3DFMT_L8_UNORM, GL_LUMINANCE8, GL_SLUMINANCE8_EXT, 0,
1277 GL_LUMINANCE, GL_UNSIGNED_BYTE, 0,
1278 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1279 | WINED3DFMT_FLAG_SRGB_READ,
1280 WINED3D_GL_LEGACY_CONTEXT, NULL},
1281 {WINED3DFMT_L8_UNORM, GL_R8, GL_R8, 0,
1282 GL_RED, GL_UNSIGNED_BYTE, 0,
1283 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1284 | WINED3DFMT_FLAG_RENDERTARGET,
1285 ARB_TEXTURE_RG, NULL},
1286 {WINED3DFMT_L8A8_UNORM, GL_RG8, GL_RG8, 0,
1287 GL_RG, GL_UNSIGNED_BYTE, 0,
1288 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1289 ARB_TEXTURE_RG, NULL},
1290 {WINED3DFMT_L8A8_UNORM, GL_LUMINANCE8_ALPHA8, GL_SLUMINANCE8_ALPHA8_EXT, 0,
1291 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
1292 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1293 | WINED3DFMT_FLAG_SRGB_READ,
1294 WINED3D_GL_LEGACY_CONTEXT, NULL},
1295 {WINED3DFMT_L4A4_UNORM, GL_RG8, GL_RG8, 0,
1296 GL_RG, GL_UNSIGNED_BYTE, 2,
1297 WINED3DFMT_FLAG_FILTERING,
1298 ARB_TEXTURE_RG, convert_l4a4_unorm},
1299 {WINED3DFMT_L4A4_UNORM, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE4_ALPHA4, 0,
1300 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 2,
1301 WINED3DFMT_FLAG_FILTERING,
1302 WINED3D_GL_LEGACY_CONTEXT, convert_l4a4_unorm},
1303 {WINED3DFMT_L16_UNORM, GL_R16, GL_R16, 0,
1304 GL_RED, GL_UNSIGNED_SHORT, 0,
1305 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1306 ARB_TEXTURE_RG, NULL},
1307 {WINED3DFMT_L16_UNORM, GL_LUMINANCE16, GL_LUMINANCE16, 0,
1308 GL_LUMINANCE, GL_UNSIGNED_SHORT, 0,
1309 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
1310 WINED3D_GL_LEGACY_CONTEXT, NULL},
1311 /* Bump mapping stuff */
1312 {WINED3DFMT_R8G8_SNORM, GL_RGB8, GL_RGB8, 0,
1313 GL_BGR, GL_UNSIGNED_BYTE, 3,
1314 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1315 | WINED3DFMT_FLAG_BUMPMAP,
1316 WINED3D_GL_EXT_NONE, convert_r8g8_snorm},
1317 {WINED3DFMT_R8G8_SNORM, GL_DSDT8_NV, GL_DSDT8_NV, 0,
1318 GL_DSDT_NV, GL_BYTE, 0,
1319 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1320 | WINED3DFMT_FLAG_BUMPMAP,
1321 NV_TEXTURE_SHADER, NULL},
1322 {WINED3DFMT_R8G8_SNORM, GL_RG8_SNORM, GL_RG8_SNORM, 0,
1323 GL_RG, GL_BYTE, 0,
1324 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1325 | WINED3DFMT_FLAG_BUMPMAP,
1326 EXT_TEXTURE_SNORM, NULL},
1327 {WINED3DFMT_R5G5_SNORM_L6_UNORM, GL_RGB5, GL_RGB5, 0,
1328 GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 2,
1329 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1330 | WINED3DFMT_FLAG_BUMPMAP,
1331 WINED3D_GL_EXT_NONE, convert_r5g5_snorm_l6_unorm},
1332 {WINED3DFMT_R5G5_SNORM_L6_UNORM, GL_DSDT8_MAG8_NV, GL_DSDT8_MAG8_NV, 0,
1333 GL_DSDT_MAG_NV, GL_BYTE, 3,
1334 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1335 | WINED3DFMT_FLAG_BUMPMAP,
1336 NV_TEXTURE_SHADER, convert_r5g5_snorm_l6_unorm_nv},
1337 {WINED3DFMT_R5G5_SNORM_L6_UNORM, GL_RGB8_SNORM, GL_RGB8_SNORM, 0,
1338 GL_RGBA, GL_BYTE, 4,
1339 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1340 | WINED3DFMT_FLAG_BUMPMAP,
1341 EXT_TEXTURE_SNORM, convert_r5g5_snorm_l6_unorm_ext},
1342 {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, GL_RGB8, GL_RGB8, 0,
1343 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 4,
1344 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1345 | WINED3DFMT_FLAG_BUMPMAP,
1346 WINED3D_GL_EXT_NONE, convert_r8g8_snorm_l8x8_unorm},
1347 {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, GL_DSDT8_MAG8_INTENSITY8_NV, GL_DSDT8_MAG8_INTENSITY8_NV, 0,
1348 GL_DSDT_MAG_VIB_NV, GL_UNSIGNED_INT_8_8_S8_S8_REV_NV, 4,
1349 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1350 | WINED3DFMT_FLAG_BUMPMAP,
1351 NV_TEXTURE_SHADER, convert_r8g8_snorm_l8x8_unorm_nv},
1352 {WINED3DFMT_R8G8B8A8_SNORM, GL_RGBA8, GL_RGBA8, 0,
1353 GL_BGRA, GL_UNSIGNED_BYTE, 4,
1354 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1355 | WINED3DFMT_FLAG_BUMPMAP,
1356 WINED3D_GL_EXT_NONE, convert_r8g8b8a8_snorm},
1357 {WINED3DFMT_R8G8B8A8_SNORM, GL_SIGNED_RGBA8_NV, GL_SIGNED_RGBA8_NV, 0,
1358 GL_RGBA, GL_BYTE, 0,
1359 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1360 | WINED3DFMT_FLAG_BUMPMAP,
1361 NV_TEXTURE_SHADER, NULL},
1362 {WINED3DFMT_R8G8B8A8_SNORM, GL_RGBA8_SNORM, GL_RGBA8_SNORM, 0,
1363 GL_RGBA, GL_BYTE, 0,
1364 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1365 | WINED3DFMT_FLAG_BUMPMAP,
1366 EXT_TEXTURE_SNORM, NULL},
1367 {WINED3DFMT_R16G16_SNORM, GL_RGB16, GL_RGB16, 0,
1368 GL_BGR, GL_UNSIGNED_SHORT, 6,
1369 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1370 | WINED3DFMT_FLAG_BUMPMAP,
1371 WINED3D_GL_EXT_NONE, convert_r16g16_snorm},
1372 {WINED3DFMT_R16G16_SNORM, GL_SIGNED_HILO16_NV, GL_SIGNED_HILO16_NV, 0,
1373 GL_HILO_NV, GL_SHORT, 0,
1374 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1375 | WINED3DFMT_FLAG_BUMPMAP,
1376 NV_TEXTURE_SHADER, NULL},
1377 {WINED3DFMT_R16G16_SNORM, GL_RG16_SNORM, GL_RG16_SNORM, 0,
1378 GL_RG, GL_SHORT, 0,
1379 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1380 | WINED3DFMT_FLAG_BUMPMAP,
1381 EXT_TEXTURE_SNORM, NULL},
1382 /* Depth stencil formats */
1383 {WINED3DFMT_D16_LOCKABLE, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, 0,
1384 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 0,
1385 WINED3DFMT_FLAG_DEPTH,
1386 WINED3D_GL_EXT_NONE, NULL},
1387 {WINED3DFMT_D16_LOCKABLE, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
1388 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 0,
1389 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
1390 ARB_DEPTH_TEXTURE, NULL},
1391 {WINED3DFMT_D32_UNORM, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, 0,
1392 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
1393 WINED3DFMT_FLAG_DEPTH,
1394 WINED3D_GL_EXT_NONE, NULL},
1395 {WINED3DFMT_D32_UNORM, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT32_ARB, 0,
1396 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
1397 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
1398 ARB_DEPTH_TEXTURE, NULL},
1399 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
1400 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 0,
1401 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
1402 ARB_DEPTH_TEXTURE, NULL},
1403 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
1404 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 4,
1405 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
1406 EXT_PACKED_DEPTH_STENCIL, convert_s1_uint_d15_unorm},
1407 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
1408 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 4,
1409 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
1410 ARB_FRAMEBUFFER_OBJECT, convert_s1_uint_d15_unorm},
1411 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
1412 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
1413 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1414 | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
1415 ARB_DEPTH_TEXTURE, NULL},
1416 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
1417 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 0,
1418 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1419 | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
1420 EXT_PACKED_DEPTH_STENCIL, NULL},
1421 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
1422 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0,
1423 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1424 | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
1425 ARB_FRAMEBUFFER_OBJECT, NULL},
1426 {WINED3DFMT_X8D24_UNORM, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, 0,
1427 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
1428 WINED3DFMT_FLAG_DEPTH,
1429 WINED3D_GL_EXT_NONE, NULL},
1430 {WINED3DFMT_X8D24_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
1431 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
1432 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1433 | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
1434 ARB_DEPTH_TEXTURE, NULL},
1435 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
1436 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0,
1437 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
1438 ARB_DEPTH_TEXTURE, NULL},
1439 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
1440 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 4,
1441 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
1442 EXT_PACKED_DEPTH_STENCIL, convert_s4x4_uint_d24_unorm},
1443 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
1444 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 4,
1445 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
1446 ARB_FRAMEBUFFER_OBJECT, convert_s4x4_uint_d24_unorm},
1447 {WINED3DFMT_D16_UNORM, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, 0,
1448 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 0,
1449 WINED3DFMT_FLAG_DEPTH,
1450 WINED3D_GL_EXT_NONE, NULL},
1451 {WINED3DFMT_D16_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
1452 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 0,
1453 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1454 | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
1455 ARB_DEPTH_TEXTURE, NULL},
1456 {WINED3DFMT_D32_FLOAT, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT32F, 0,
1457 GL_DEPTH_COMPONENT, GL_FLOAT, 0,
1458 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_SHADOW,
1459 ARB_DEPTH_BUFFER_FLOAT, NULL},
1460 {WINED3DFMT_S8_UINT_D24_FLOAT, GL_DEPTH32F_STENCIL8, GL_DEPTH32F_STENCIL8, 0,
1461 GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, 8,
1462 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL | WINED3DFMT_FLAG_SHADOW,
1463 ARB_DEPTH_BUFFER_FLOAT, convert_s8_uint_d24_float},
1464 {WINED3DFMT_R32G32B32A32_UINT, GL_RGBA32UI, GL_RGBA32UI, 0,
1465 GL_RGBA_INTEGER, GL_UNSIGNED_INT, 0,
1466 WINED3DFMT_FLAG_TEXTURE,
1467 EXT_TEXTURE_INTEGER, NULL},
1468 {WINED3DFMT_R32G32B32A32_SINT, GL_RGBA32I, GL_RGBA32I, 0,
1469 GL_RGBA_INTEGER, GL_INT, 0,
1470 WINED3DFMT_FLAG_TEXTURE,
1471 EXT_TEXTURE_INTEGER, NULL},
1472 /* Vendor-specific formats */
1473 {WINED3DFMT_ATI1N, GL_COMPRESSED_RED_RGTC1, GL_COMPRESSED_RED_RGTC1, 0,
1474 GL_RED, GL_UNSIGNED_BYTE, 0,
1475 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1476 | WINED3DFMT_FLAG_COMPRESSED,
1477 ARB_TEXTURE_COMPRESSION_RGTC, NULL},
1478 {WINED3DFMT_ATI2N, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0,
1479 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
1480 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1481 | WINED3DFMT_FLAG_COMPRESSED,
1482 ATI_TEXTURE_COMPRESSION_3DC, NULL},
1483 {WINED3DFMT_ATI2N, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_RG_RGTC2, 0,
1484 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 0,
1485 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1486 | WINED3DFMT_FLAG_COMPRESSED,
1487 EXT_TEXTURE_COMPRESSION_RGTC, NULL},
1488 {WINED3DFMT_ATI2N, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_RG_RGTC2, 0,
1489 GL_RG, GL_UNSIGNED_BYTE, 0,
1490 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1491 | WINED3DFMT_FLAG_COMPRESSED,
1492 ARB_TEXTURE_COMPRESSION_RGTC, NULL},
1493 {WINED3DFMT_INTZ, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
1494 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, 0,
1495 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1496 | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
1497 EXT_PACKED_DEPTH_STENCIL, NULL},
1498 {WINED3DFMT_INTZ, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
1499 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0,
1500 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING
1501 | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
1502 ARB_FRAMEBUFFER_OBJECT, NULL},
1503 {WINED3DFMT_NULL, 0, 0, 0,
1504 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0,
1505 WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE,
1506 ARB_FRAMEBUFFER_OBJECT, NULL},
1507 };
1508
1509 struct wined3d_format_srgb_info
1510 {
1511 enum wined3d_format_id srgb_format_id;
1512 enum wined3d_format_id base_format_id;
1513 };
1514
1515 static const struct wined3d_format_srgb_info format_srgb_info[] =
1516 {
1517 {WINED3DFMT_R8G8B8A8_UNORM_SRGB, WINED3DFMT_R8G8B8A8_UNORM},
1518 {WINED3DFMT_BC1_UNORM_SRGB, WINED3DFMT_BC1_UNORM},
1519 {WINED3DFMT_BC2_UNORM_SRGB, WINED3DFMT_BC2_UNORM},
1520 {WINED3DFMT_BC3_UNORM_SRGB, WINED3DFMT_BC3_UNORM},
1521 {WINED3DFMT_B8G8R8A8_UNORM_SRGB, WINED3DFMT_B8G8R8A8_UNORM},
1522 {WINED3DFMT_B8G8R8X8_UNORM_SRGB, WINED3DFMT_B8G8R8X8_UNORM},
1523 {WINED3DFMT_BC7_UNORM_SRGB, WINED3DFMT_BC7_UNORM},
1524 };
1525
1526 static inline int get_format_idx(enum wined3d_format_id format_id)
1527 {
1528 unsigned int i;
1529
1530 if (format_id < WINED3D_FORMAT_FOURCC_BASE)
1531 return format_id;
1532
1533 for (i = 0; i < ARRAY_SIZE(format_index_remap); ++i)
1534 {
1535 if (format_index_remap[i].id == format_id)
1536 return format_index_remap[i].idx;
1537 }
1538
1539 return -1;
1540 }
1541
1542 static void format_set_flag(struct wined3d_format *format, unsigned int flag)
1543 {
1544 unsigned int i;
1545
1546 for (i = 0; i < ARRAY_SIZE(format->flags); ++i)
1547 format->flags[i] |= flag;
1548 }
1549
1550 static void format_clear_flag(struct wined3d_format *format, unsigned int flag)
1551 {
1552 unsigned int i;
1553
1554 for (i = 0; i < ARRAY_SIZE(format->flags); ++i)
1555 format->flags[i] &= ~flag;
1556 }
1557
1558 static enum wined3d_channel_type map_channel_type(char t)
1559 {
1560 switch (t)
1561 {
1562 case 'u':
1563 return WINED3D_CHANNEL_TYPE_UNORM;
1564 case 'i':
1565 return WINED3D_CHANNEL_TYPE_SNORM;
1566 case 'U':
1567 return WINED3D_CHANNEL_TYPE_UINT;
1568 case 'I':
1569 return WINED3D_CHANNEL_TYPE_SINT;
1570 case 'F':
1571 return WINED3D_CHANNEL_TYPE_FLOAT;
1572 case 'D':
1573 return WINED3D_CHANNEL_TYPE_DEPTH;
1574 case 'S':
1575 return WINED3D_CHANNEL_TYPE_STENCIL;
1576 default:
1577 ERR("Invalid channel type '%c'.\n", t);
1578 return WINED3D_CHANNEL_TYPE_NONE;
1579 }
1580 }
1581
1582 static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
1583 {
1584 unsigned int i, j;
1585
1586 gl_info->format_count = WINED3D_FORMAT_COUNT;
1587 if (!(gl_info->formats = wined3d_calloc(gl_info->format_count, sizeof(*gl_info->formats))))
1588 {
1589 ERR("Failed to allocate memory.\n");
1590 return FALSE;
1591 }
1592
1593 for (i = 0; i < ARRAY_SIZE(formats); ++i)
1594 {
1595 struct wined3d_format *format;
1596 int fmt_idx;
1597
1598 fmt_idx = get_format_idx(formats[i].id);
1599 if (fmt_idx == -1)
1600 {
1601 ERR("Could not allocate index for format %s %#x.\n",
1602 debug_d3dformat(formats[i].id), formats[i].id);
1603 goto fail;
1604 }
1605 format = &gl_info->formats[fmt_idx];
1606
1607 format->id = formats[i].id;
1608 format->red_size = formats[i].red_size;
1609 format->green_size = formats[i].green_size;
1610 format->blue_size = formats[i].blue_size;
1611 format->alpha_size = formats[i].alpha_size;
1612 format->red_offset = formats[i].red_offset;
1613 format->green_offset = formats[i].green_offset;
1614 format->blue_offset = formats[i].blue_offset;
1615 format->alpha_offset = formats[i].alpha_offset;
1616 format->byte_count = formats[i].bpp;
1617 format->depth_size = formats[i].depth_size;
1618 format->stencil_size = formats[i].stencil_size;
1619 format->block_width = 1;
1620 format->block_height = 1;
1621 format->block_byte_count = formats[i].bpp;
1622 }
1623
1624 for (i = 0; i < ARRAY_SIZE(typed_formats); ++i)
1625 {
1626 const struct wined3d_format *typeless_format;
1627 struct wined3d_format *format;
1628 DWORD flags = 0;
1629 int fmt_idx;
1630
1631 fmt_idx = get_format_idx(typed_formats[i].id);
1632 if (fmt_idx == -1)
1633 {
1634 ERR("Could not allocate index for format %s %#x.\n",
1635 debug_d3dformat(typed_formats[i].id), typed_formats[i].id);
1636 goto fail;
1637 }
1638 format = &gl_info->formats[fmt_idx];
1639
1640 typeless_format = wined3d_get_format(gl_info, typed_formats[i].typeless_id);
1641 if (typeless_format->id == WINED3DFMT_UNKNOWN)
1642 {
1643 ERR("Typeless format %s (%#x) not found.\n",
1644 debug_d3dformat(typed_formats[i].typeless_id), typed_formats[i].typeless_id);
1645 goto fail;
1646 }
1647
1648 format->id = typed_formats[i].id;
1649 format->red_size = typeless_format->red_size;
1650 format->green_size = typeless_format->green_size;
1651 format->blue_size = typeless_format->blue_size;
1652 format->alpha_size = typeless_format->alpha_size;
1653 format->red_offset = typeless_format->red_offset;
1654 format->green_offset = typeless_format->green_offset;
1655 format->blue_offset = typeless_format->blue_offset;
1656 format->alpha_offset = typeless_format->alpha_offset;
1657 format->byte_count = typeless_format->byte_count;
1658 format->depth_size = typeless_format->depth_size;
1659 format->stencil_size = typeless_format->stencil_size;
1660 format->block_width = typeless_format->block_width;
1661 format->block_height = typeless_format->block_height;
1662 format->block_byte_count = typeless_format->block_byte_count;
1663
1664 for (j = 0; j < strlen(typed_formats[i].channels); ++j)
1665 {
1666 enum wined3d_channel_type channel_type = map_channel_type(typed_formats[i].channels[j]);
1667 if (channel_type == WINED3D_CHANNEL_TYPE_UINT || channel_type == WINED3D_CHANNEL_TYPE_SINT)
1668 flags |= WINED3DFMT_FLAG_INTEGER;
1669 if (channel_type == WINED3D_CHANNEL_TYPE_FLOAT)
1670 flags |= WINED3DFMT_FLAG_FLOAT;
1671 }
1672
1673 format_set_flag(format, flags);
1674 }
1675
1676 for (i = 0; i < ARRAY_SIZE(ddi_formats); ++i)
1677 {
1678 int fmt_idx = get_format_idx(ddi_formats[i].id);
1679
1680 if (fmt_idx == -1)
1681 {
1682 ERR("Format %s (%#x) not found.\n", debug_d3dformat(ddi_formats[i].id), ddi_formats[i].id);
1683 goto fail;
1684 }
1685
1686 gl_info->formats[fmt_idx].ddi_format = ddi_formats[i].ddi_format;
1687 }
1688
1689 for (i = 0; i < ARRAY_SIZE(format_base_flags); ++i)
1690 {
1691 int fmt_idx = get_format_idx(format_base_flags[i].id);
1692
1693 if (fmt_idx == -1)
1694 {
1695 ERR("Format %s (%#x) not found.\n",
1696 debug_d3dformat(format_base_flags[i].id), format_base_flags[i].id);
1697 goto fail;
1698 }
1699
1700 format_set_flag(&gl_info->formats[fmt_idx], format_base_flags[i].flags);
1701 }
1702
1703 return TRUE;
1704
1705 fail:
1706 HeapFree(GetProcessHeap(), 0, gl_info->formats);
1707 return FALSE;
1708 }
1709
1710 static BOOL init_format_block_info(struct wined3d_gl_info *gl_info)
1711 {
1712 unsigned int i;
1713
1714 for (i = 0; i < (sizeof(format_block_info) / sizeof(*format_block_info)); ++i)
1715 {
1716 struct wined3d_format *format;
1717 int fmt_idx = get_format_idx(format_block_info[i].id);
1718
1719 if (fmt_idx == -1)
1720 {
1721 ERR("Format %s (%#x) not found.\n",
1722 debug_d3dformat(format_block_info[i].id), format_block_info[i].id);
1723 return FALSE;
1724 }
1725
1726 format = &gl_info->formats[fmt_idx];
1727 format->block_width = format_block_info[i].block_width;
1728 format->block_height = format_block_info[i].block_height;
1729 format->block_byte_count = format_block_info[i].block_byte_count;
1730 format_set_flag(&gl_info->formats[fmt_idx], WINED3DFMT_FLAG_BLOCKS);
1731 if (!format_block_info[i].verify)
1732 format_set_flag(&gl_info->formats[fmt_idx], WINED3DFMT_FLAG_BLOCKS_NO_VERIFY);
1733 }
1734
1735 return TRUE;
1736 }
1737
1738 static GLenum wined3d_gl_type_to_enum(enum wined3d_gl_resource_type type)
1739 {
1740 switch (type)
1741 {
1742 case WINED3D_GL_RES_TYPE_TEX_1D:
1743 return GL_TEXTURE_1D;
1744 case WINED3D_GL_RES_TYPE_TEX_2D:
1745 return GL_TEXTURE_2D;
1746 case WINED3D_GL_RES_TYPE_TEX_3D:
1747 return GL_TEXTURE_3D;
1748 case WINED3D_GL_RES_TYPE_TEX_CUBE:
1749 return GL_TEXTURE_CUBE_MAP_ARB;
1750 case WINED3D_GL_RES_TYPE_TEX_RECT:
1751 return GL_TEXTURE_RECTANGLE_ARB;
1752 case WINED3D_GL_RES_TYPE_BUFFER:
1753 return GL_TEXTURE_2D; /* TODO: GL_TEXTURE_BUFFER. */
1754 case WINED3D_GL_RES_TYPE_RB:
1755 return GL_RENDERBUFFER;
1756 case WINED3D_GL_RES_TYPE_COUNT:
1757 break;
1758 }
1759 ERR("Unexpected GL resource type %u.\n", type);
1760 return 0;
1761 }
1762
1763 static void delete_fbo_attachment(const struct wined3d_gl_info *gl_info,
1764 enum wined3d_gl_resource_type d3d_type, GLuint object)
1765 {
1766 switch (d3d_type)
1767 {
1768 case WINED3D_GL_RES_TYPE_TEX_1D:
1769 case WINED3D_GL_RES_TYPE_TEX_2D:
1770 case WINED3D_GL_RES_TYPE_TEX_RECT:
1771 case WINED3D_GL_RES_TYPE_TEX_3D:
1772 case WINED3D_GL_RES_TYPE_TEX_CUBE:
1773 gl_info->gl_ops.gl.p_glDeleteTextures(1, &object);
1774 break;
1775
1776 case WINED3D_GL_RES_TYPE_RB:
1777 gl_info->fbo_ops.glDeleteRenderbuffers(1, &object);
1778 break;
1779
1780 case WINED3D_GL_RES_TYPE_BUFFER:
1781 case WINED3D_GL_RES_TYPE_COUNT:
1782 break;
1783 }
1784 }
1785
1786 /* Context activation is done by the caller. */
1787 static void create_and_bind_fbo_attachment(const struct wined3d_gl_info *gl_info, unsigned int flags,
1788 enum wined3d_gl_resource_type d3d_type, GLuint *object, GLenum internal, GLenum format, GLenum type)
1789 {
1790 GLenum attach_type = flags & WINED3DFMT_FLAG_DEPTH ?
1791 GL_DEPTH_ATTACHMENT : GL_COLOR_ATTACHMENT0;
1792
1793 switch (d3d_type)
1794 {
1795 case WINED3D_GL_RES_TYPE_TEX_1D:
1796 gl_info->gl_ops.gl.p_glGenTextures(1, object);
1797 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D, *object);
1798 gl_info->gl_ops.gl.p_glTexImage1D(GL_TEXTURE_1D, 0, internal, 16, 0, format, type, NULL);
1799 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1800 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1801
1802 gl_info->fbo_ops.glFramebufferTexture1D(GL_FRAMEBUFFER, attach_type, GL_TEXTURE_1D,
1803 *object, 0);
1804 if (flags & WINED3DFMT_FLAG_STENCIL)
1805 gl_info->fbo_ops.glFramebufferTexture1D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_1D,
1806 *object, 0);
1807 break;
1808
1809 case WINED3D_GL_RES_TYPE_TEX_2D:
1810 case WINED3D_GL_RES_TYPE_TEX_RECT:
1811 gl_info->gl_ops.gl.p_glGenTextures(1, object);
1812 gl_info->gl_ops.gl.p_glBindTexture(wined3d_gl_type_to_enum(d3d_type), *object);
1813 gl_info->gl_ops.gl.p_glTexImage2D(wined3d_gl_type_to_enum(d3d_type), 0, internal, 16, 16, 0,
1814 format, type, NULL);
1815 gl_info->gl_ops.gl.p_glTexParameteri(wined3d_gl_type_to_enum(d3d_type), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1816 gl_info->gl_ops.gl.p_glTexParameteri(wined3d_gl_type_to_enum(d3d_type), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1817
1818 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, attach_type,
1819 wined3d_gl_type_to_enum(d3d_type), *object, 0);
1820 if (flags & WINED3DFMT_FLAG_STENCIL)
1821 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
1822 wined3d_gl_type_to_enum(d3d_type), *object, 0);
1823 break;
1824
1825 case WINED3D_GL_RES_TYPE_TEX_3D:
1826 gl_info->gl_ops.gl.p_glGenTextures(1, object);
1827 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_3D, *object);
1828 GL_EXTCALL(glTexImage3D)(GL_TEXTURE_3D, 0, internal, 16, 16, 16, 0,
1829 format, type, NULL);
1830 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1831 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1832
1833 gl_info->fbo_ops.glFramebufferTexture3D(GL_FRAMEBUFFER, attach_type,
1834 GL_TEXTURE_3D, *object, 0, 0);
1835 if (flags & WINED3DFMT_FLAG_STENCIL)
1836 gl_info->fbo_ops.glFramebufferTexture3D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
1837 GL_TEXTURE_3D, *object, 0, 0);
1838 break;
1839
1840 case WINED3D_GL_RES_TYPE_TEX_CUBE:
1841 gl_info->gl_ops.gl.p_glGenTextures(1, object);
1842 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, *object);
1843 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0, internal, 16, 16, 0,
1844 format, type, NULL);
1845 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 0, internal, 16, 16, 0,
1846 format, type, NULL);
1847 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0, internal, 16, 16, 0,
1848 format, type, NULL);
1849 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 0, internal, 16, 16, 0,
1850 format, type, NULL);
1851 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 0, internal, 16, 16, 0,
1852 format, type, NULL);
1853 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 0, internal, 16, 16, 0,
1854 format, type, NULL);
1855 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1856 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1857
1858 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, attach_type,
1859 GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, *object, 0);
1860 if (flags & WINED3DFMT_FLAG_STENCIL)
1861 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
1862 GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, *object, 0);
1863 break;
1864
1865 case WINED3D_GL_RES_TYPE_RB:
1866 gl_info->fbo_ops.glGenRenderbuffers(1, object);
1867 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, *object);
1868 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, internal, 16, 16);
1869 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, attach_type, GL_RENDERBUFFER,
1870 *object);
1871 if (flags & WINED3DFMT_FLAG_STENCIL)
1872 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
1873 *object);
1874 break;
1875
1876 case WINED3D_GL_RES_TYPE_BUFFER:
1877 case WINED3D_GL_RES_TYPE_COUNT:
1878 break;
1879 }
1880
1881 /* Ideally we'd skip all formats already known not to work on textures
1882 * by checking for WINED3DFMT_FLAG_TEXTURE here. However, we want to
1883 * know if we can attach WINED3DFMT_P8_UINT textures to FBOs, and this
1884 * format never has WINED3DFMT_FLAG_TEXTURE set. Instead, swallow GL
1885 * errors generated by invalid formats. */
1886 while (gl_info->gl_ops.gl.p_glGetError());
1887 }
1888
1889 static void draw_test_quad(struct wined3d_caps_gl_ctx *ctx, const struct wined3d_vec3 *geometry,
1890 const struct wined3d_color *color)
1891 {
1892 const struct wined3d_gl_info *gl_info = ctx->gl_info;
1893 static const struct wined3d_vec3 default_geometry[] =
1894 {
1895 {-1.0f, -1.0f, 0.0f},
1896 { 1.0f, -1.0f, 0.0f},
1897 {-1.0f, 1.0f, 0.0f},
1898 { 1.0f, 1.0f, 0.0f},
1899 };
1900 static const char vs_core_header[] =
1901 "#version 150\n"
1902 "in vec4 pos;\n"
1903 "in vec4 color;\n"
1904 "out vec4 out_color;\n"
1905 "\n";
1906 static const char vs_legacy_header[] =
1907 "#version 120\n"
1908 "attribute vec4 pos;\n"
1909 "attribute vec4 color;\n"
1910 "varying vec4 out_color;\n"
1911 "\n";
1912 static const char vs_body[] =
1913 "void main()\n"
1914 "{\n"
1915 " gl_Position = pos;\n"
1916 " out_color = color;\n"
1917 "}\n";
1918 static const char fs_core[] =
1919 "#version 150\n"
1920 "in vec4 out_color;\n"
1921 "out vec4 fragment_color;\n"
1922 "\n"
1923 "void main()\n"
1924 "{\n"
1925 " fragment_color = out_color;\n"
1926 "}\n";
1927 static const char fs_legacy[] =
1928 "#version 120\n"
1929 "varying vec4 out_color;\n"
1930 "\n"
1931 "void main()\n"
1932 "{\n"
1933 " gl_FragData[0] = out_color;\n"
1934 "}\n";
1935 const char *source[2];
1936 GLuint vs_id, fs_id;
1937 unsigned int i;
1938
1939 if (!geometry)
1940 geometry = default_geometry;
1941
1942 if (!gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] || !gl_info->supported[ARB_VERTEX_SHADER]
1943 || !gl_info->supported[ARB_FRAGMENT_SHADER])
1944 {
1945 gl_info->gl_ops.gl.p_glDisable(GL_LIGHTING);
1946 gl_info->gl_ops.gl.p_glMatrixMode(GL_MODELVIEW);
1947 gl_info->gl_ops.gl.p_glLoadIdentity();
1948 gl_info->gl_ops.gl.p_glMatrixMode(GL_PROJECTION);
1949 gl_info->gl_ops.gl.p_glLoadIdentity();
1950
1951 gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
1952 gl_info->gl_ops.gl.p_glColor4f(color->r, color->g, color->b, color->a);
1953 for (i = 0; i < 4; ++i)
1954 gl_info->gl_ops.gl.p_glVertex3fv(&geometry[i].x);
1955 gl_info->gl_ops.gl.p_glEnd();
1956 checkGLcall("Drawing a quad");
1957 return;
1958 }
1959
1960 if (!ctx->test_vbo)
1961 GL_EXTCALL(glGenBuffers(1, &ctx->test_vbo));
1962 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, ctx->test_vbo));
1963 GL_EXTCALL(glBufferData(GL_ARRAY_BUFFER, sizeof(struct wined3d_vec3) * 4, geometry, GL_STREAM_DRAW));
1964 GL_EXTCALL(glVertexAttribPointer(0, 3, GL_FLOAT, FALSE, 0, NULL));
1965 GL_EXTCALL(glVertexAttrib4f(1, color->r, color->g, color->b, color->a));
1966 GL_EXTCALL(glEnableVertexAttribArray(0));
1967 GL_EXTCALL(glDisableVertexAttribArray(1));
1968
1969 if (!ctx->test_program_id)
1970 {
1971 ctx->test_program_id = GL_EXTCALL(glCreateProgram());
1972
1973 vs_id = GL_EXTCALL(glCreateShader(GL_VERTEX_SHADER));
1974 source[0] = gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] ? vs_legacy_header : vs_core_header;
1975 source[1] = vs_body;
1976 GL_EXTCALL(glShaderSource(vs_id, 2, source, NULL));
1977 GL_EXTCALL(glAttachShader(ctx->test_program_id, vs_id));
1978 GL_EXTCALL(glDeleteShader(vs_id));
1979
1980 fs_id = GL_EXTCALL(glCreateShader(GL_FRAGMENT_SHADER));
1981 source[0] = gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] ? fs_legacy : fs_core;
1982 GL_EXTCALL(glShaderSource(fs_id, 1, source, NULL));
1983 GL_EXTCALL(glAttachShader(ctx->test_program_id, fs_id));
1984 GL_EXTCALL(glDeleteShader(fs_id));
1985
1986 GL_EXTCALL(glBindAttribLocation(ctx->test_program_id, 0, "pos"));
1987 GL_EXTCALL(glBindAttribLocation(ctx->test_program_id, 1, "color"));
1988
1989 GL_EXTCALL(glCompileShader(vs_id));
1990 print_glsl_info_log(gl_info, vs_id, FALSE);
1991 GL_EXTCALL(glCompileShader(fs_id));
1992 print_glsl_info_log(gl_info, fs_id, FALSE);
1993 GL_EXTCALL(glLinkProgram(ctx->test_program_id));
1994 shader_glsl_validate_link(gl_info, ctx->test_program_id);
1995 }
1996 GL_EXTCALL(glUseProgram(ctx->test_program_id));
1997
1998 gl_info->gl_ops.gl.p_glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
1999
2000 GL_EXTCALL(glUseProgram(0));
2001 GL_EXTCALL(glDisableVertexAttribArray(0));
2002 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, 0));
2003 checkGLcall("Drawing a quad");
2004 }
2005
2006 /* Context activation is done by the caller. */
2007 static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_format *format)
2008 {
2009 /* Check if the default internal format is supported as a frame buffer
2010 * target, otherwise fall back to the render target internal.
2011 *
2012 * Try to stick to the standard format if possible, this limits precision differences. */
2013 static const struct wined3d_color black = {0.0f, 0.0f, 0.0f, 1.0f};
2014 static const struct wined3d_color half_transparent_red = {1.0f, 0.0f, 0.0f, 0.5f};
2015 const struct wined3d_gl_info *gl_info = ctx->gl_info;
2016 GLenum status, rt_internal = format->rtInternal;
2017 GLuint object, color_rb;
2018 enum wined3d_gl_resource_type type;
2019 BOOL fallback_fmt_used = FALSE, regular_fmt_used = FALSE;
2020
2021 gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
2022
2023 for (type = 0; type < ARRAY_SIZE(format->flags); ++type)
2024 {
2025 const char *type_string = "color";
2026
2027 if (type == WINED3D_GL_RES_TYPE_BUFFER)
2028 continue;
2029
2030 create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->glInternal,
2031 format->glFormat, format->glType);
2032
2033 if (format->flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
2034 {
2035 gl_info->fbo_ops.glGenRenderbuffers(1, &color_rb);
2036 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, color_rb);
2037 if (type == WINED3D_GL_RES_TYPE_TEX_1D)
2038 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 16, 1);
2039 else
2040 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 16, 16);
2041
2042 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER,
2043 GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, color_rb);
2044 checkGLcall("Create and attach color rb attachment");
2045 type_string = "depth / stencil";
2046 }
2047
2048 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
2049 checkGLcall("Framebuffer format check");
2050
2051 if (status == GL_FRAMEBUFFER_COMPLETE)
2052 {
2053 TRACE("Format %s is supported as FBO %s attachment, type %u.\n",
2054 debug_d3dformat(format->id), type_string, type);
2055 format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
2056 format->rtInternal = format->glInternal;
2057 regular_fmt_used = TRUE;
2058 }
2059 else
2060 {
2061 if (!rt_internal)
2062 {
2063 if (format->flags[type] & WINED3DFMT_FLAG_RENDERTARGET)
2064 {
2065 WARN("Format %s with rendertarget flag is not supported as FBO color attachment (type %u),"
2066 " and no fallback specified.\n", debug_d3dformat(format->id), type);
2067 format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
2068 }
2069 else
2070 {
2071 TRACE("Format %s is not supported as FBO %s attachment, type %u.\n",
2072 debug_d3dformat(format->id), type_string, type);
2073 }
2074 format->rtInternal = format->glInternal;
2075 }
2076 else
2077 {
2078 TRACE("Format %s is not supported as FBO %s attachment (type %u),"
2079 " trying rtInternal format as fallback.\n",
2080 debug_d3dformat(format->id), type_string, type);
2081
2082 while (gl_info->gl_ops.gl.p_glGetError());
2083
2084 delete_fbo_attachment(gl_info, type, object);
2085 create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->rtInternal,
2086 format->glFormat, format->glType);
2087
2088 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
2089 checkGLcall("Framebuffer format check");
2090
2091 if (status == GL_FRAMEBUFFER_COMPLETE)
2092 {
2093 TRACE("Format %s rtInternal format is supported as FBO %s attachment, type %u.\n",
2094 debug_d3dformat(format->id), type_string, type);
2095 fallback_fmt_used = TRUE;
2096 }
2097 else
2098 {
2099 WARN("Format %s rtInternal format is not supported as FBO %s attachment, type %u.\n",
2100 debug_d3dformat(format->id), type_string, type);
2101 format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
2102 }
2103 }
2104 }
2105
2106 if (status == GL_FRAMEBUFFER_COMPLETE
2107 && ((format->flags[type] & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
2108 || !(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING))
2109 && !(format->flags[type] & WINED3DFMT_FLAG_INTEGER)
2110 && format->id != WINED3DFMT_NULL && format->id != WINED3DFMT_P8_UINT
2111 && format->glFormat != GL_LUMINANCE && format->glFormat != GL_LUMINANCE_ALPHA
2112 && (format->red_size || format->alpha_size))
2113 {
2114 DWORD readback[16 * 16 * 16], color, r_range, a_range;
2115 BYTE r, a;
2116 BOOL match = TRUE;
2117 GLuint rb;
2118
2119 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
2120 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
2121 {
2122 gl_info->fbo_ops.glGenRenderbuffers(1, &rb);
2123 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, rb);
2124 if (type == WINED3D_GL_RES_TYPE_TEX_1D)
2125 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 16, 1);
2126 else
2127 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 16, 16);
2128 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb);
2129 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rb);
2130 checkGLcall("RB attachment");
2131 }
2132
2133 gl_info->gl_ops.gl.p_glEnable(GL_BLEND);
2134 gl_info->gl_ops.gl.p_glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
2135 gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
2136 if (gl_info->gl_ops.gl.p_glGetError() == GL_INVALID_FRAMEBUFFER_OPERATION)
2137 {
2138 while (gl_info->gl_ops.gl.p_glGetError());
2139 TRACE("Format %s doesn't support post-pixelshader blending, type %u.\n",
2140 debug_d3dformat(format->id), type);
2141 format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
2142 }
2143 else
2144 {
2145 gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
2146 if (type == WINED3D_GL_RES_TYPE_TEX_1D)
2147 gl_info->gl_ops.gl.p_glViewport(0, 0, 16, 1);
2148 else
2149 gl_info->gl_ops.gl.p_glViewport(0, 0, 16, 16);
2150 gl_info->gl_ops.gl.p_glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2151
2152 draw_test_quad(ctx, NULL, &black);
2153
2154 gl_info->gl_ops.gl.p_glEnable(GL_BLEND);
2155
2156 draw_test_quad(ctx, NULL, &half_transparent_red);
2157
2158 gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
2159
2160 switch (type)
2161 {
2162 case WINED3D_GL_RES_TYPE_TEX_1D:
2163 /* Rebinding texture to workaround a fglrx bug. */
2164 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D, object);
2165 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_1D, 0, GL_BGRA,
2166 GL_UNSIGNED_INT_8_8_8_8_REV, readback);
2167 color = readback[7];
2168 break;
2169
2170 case WINED3D_GL_RES_TYPE_TEX_2D:
2171 case WINED3D_GL_RES_TYPE_TEX_3D:
2172 case WINED3D_GL_RES_TYPE_TEX_RECT:
2173 /* Rebinding texture to workaround a fglrx bug. */
2174 gl_info->gl_ops.gl.p_glBindTexture(wined3d_gl_type_to_enum(type), object);
2175 gl_info->gl_ops.gl.p_glGetTexImage(wined3d_gl_type_to_enum(type), 0, GL_BGRA,
2176 GL_UNSIGNED_INT_8_8_8_8_REV, readback);
2177 color = readback[7 * 16 + 7];
2178 break;
2179
2180 case WINED3D_GL_RES_TYPE_TEX_CUBE:
2181 /* Rebinding texture to workaround a fglrx bug. */
2182 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, object);
2183 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0, GL_BGRA,
2184 GL_UNSIGNED_INT_8_8_8_8_REV, readback);
2185 color = readback[7 * 16 + 7];
2186 break;
2187
2188 case WINED3D_GL_RES_TYPE_RB:
2189 gl_info->gl_ops.gl.p_glReadPixels(0, 0, 16, 16,
2190 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
2191 color = readback[7 * 16 + 7];
2192 break;
2193
2194 case WINED3D_GL_RES_TYPE_BUFFER:
2195 case WINED3D_GL_RES_TYPE_COUNT:
2196 color = 0;
2197 break;
2198 }
2199 checkGLcall("Post-pixelshader blending check");
2200
2201 a = color >> 24;
2202 r = (color & 0x00ff0000u) >> 16;
2203
2204 r_range = format->red_size < 8 ? 1u << (8 - format->red_size) : 1;
2205 a_range = format->alpha_size < 8 ? 1u << (8 - format->alpha_size) : 1;
2206 if (format->red_size && (r < 0x7f - r_range || r > 0x7f + r_range))
2207 match = FALSE;
2208 else if (format->alpha_size > 1 && (a < 0xbf - a_range || a > 0xbf + a_range))
2209 match = FALSE;
2210 if (!match)
2211 {
2212 TRACE("Format %s doesn't support post-pixelshader blending, type %u.\n",
2213 debug_d3dformat(format->id), type);
2214 TRACE("Color output: %#x\n", color);
2215 format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
2216 }
2217 else
2218 {
2219 TRACE("Format %s supports post-pixelshader blending, type %u.\n",
2220 debug_d3dformat(format->id), type);
2221 TRACE("Color output: %#x\n", color);
2222 format->flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
2223 }
2224 }
2225
2226 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
2227 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
2228 {
2229 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
2230 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
2231 gl_info->fbo_ops.glDeleteRenderbuffers(1, &rb);
2232 checkGLcall("RB cleanup");
2233 }
2234 }
2235
2236 if (format->glInternal != format->glGammaInternal)
2237 {
2238 delete_fbo_attachment(gl_info, type, object);
2239 create_and_bind_fbo_attachment(gl_info, format->flags[type], type, &object, format->glGammaInternal,
2240 format->glFormat, format->glType);
2241
2242 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
2243 checkGLcall("Framebuffer format check");
2244
2245 if (status == GL_FRAMEBUFFER_COMPLETE)
2246 {
2247 TRACE("Format %s's sRGB format is FBO attachable, type %u.\n",
2248 debug_d3dformat(format->id), type);
2249 format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
2250 }
2251 else
2252 {
2253 WARN("Format %s's sRGB format is not FBO attachable, type %u.\n",
2254 debug_d3dformat(format->id), type);
2255 }
2256 }
2257 else if (status == GL_FRAMEBUFFER_COMPLETE)
2258 format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
2259
2260 if (format->flags[type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
2261 {
2262 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0);
2263 gl_info->fbo_ops.glDeleteRenderbuffers(1, &color_rb);
2264 }
2265
2266 delete_fbo_attachment(gl_info, type, object);
2267 checkGLcall("Framebuffer format check cleaup");
2268 }
2269
2270 if (fallback_fmt_used && regular_fmt_used)
2271 {
2272 FIXME("Format %s needs different render target formats for different resource types.\n",
2273 debug_d3dformat(format->id));
2274 format_clear_flag(format, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE
2275 | WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING);
2276 }
2277 }
2278
2279 static void query_format_flag(struct wined3d_gl_info *gl_info, struct wined3d_format *format,
2280 GLint internal, GLenum pname, DWORD flag, const char *string)
2281 {
2282 GLint value;
2283 enum wined3d_gl_resource_type type;
2284
2285 for (type = 0; type < ARRAY_SIZE(format->flags); ++type)
2286 {
2287 gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type), internal, pname, 1, &value);
2288 if (value == GL_FULL_SUPPORT)
2289 {
2290 TRACE("Format %s supports %s, resource type %u.\n", debug_d3dformat(format->id), string, type);
2291 format->flags[type] |= flag;
2292 }
2293 else
2294 {
2295 TRACE("Format %s doesn't support %s, resource type %u.\n", debug_d3dformat(format->id), string, type);
2296 format->flags[type] &= ~flag;
2297 }
2298 }
2299 }
2300
2301 /* Context activation is done by the caller. */
2302 static void init_format_fbo_compat_info(struct wined3d_caps_gl_ctx *ctx)
2303 {
2304 const struct wined3d_gl_info *gl_info = ctx->gl_info;
2305 unsigned int i, type;
2306 GLuint fbo;
2307
2308 if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2])
2309 {
2310 for (i = 0; i < gl_info->format_count; ++i)
2311 {
2312 GLint value;
2313 struct wined3d_format *format = &gl_info->formats[i];
2314 BOOL fallback_fmt_used = FALSE, regular_fmt_used = FALSE;
2315 GLenum rt_internal = format->rtInternal;
2316
2317 if (!format->glInternal)
2318 continue;
2319
2320 for (type = 0; type < ARRAY_SIZE(format->flags); ++type)
2321 {
2322 gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type),
2323 format->glInternal, GL_FRAMEBUFFER_RENDERABLE, 1, &value);
2324 if (value == GL_FULL_SUPPORT)
2325 {
2326 TRACE("Format %s is supported as FBO color attachment, resource type %u.\n",
2327 debug_d3dformat(format->id), type);
2328 format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
2329 format->rtInternal = format->glInternal;
2330 regular_fmt_used = TRUE;
2331
2332 gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type),
2333 format->glInternal, GL_FRAMEBUFFER_BLEND, 1, &value);
2334 if (value == GL_FULL_SUPPORT)
2335 {
2336 TRACE("Format %s supports post-pixelshader blending, resource type %u.\n",
2337 debug_d3dformat(format->id), type);
2338 format->flags[type] |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
2339 }
2340 else
2341 {
2342 TRACE("Format %s doesn't support post-pixelshader blending, resource typed %u.\n",
2343 debug_d3dformat(format->id), type);
2344 format->flags[type] &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
2345 }
2346 }
2347 else
2348 {
2349 if (!rt_internal)
2350 {
2351 if (format->flags[type] & WINED3DFMT_FLAG_RENDERTARGET)
2352 {
2353 WARN("Format %s with rendertarget flag is not supported as FBO color attachment"
2354 " and no fallback specified, resource type %u.\n",
2355 debug_d3dformat(format->id), type);
2356 format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
2357 }
2358 else
2359 TRACE("Format %s is not supported as FBO color attachment,"
2360 " resource type %u.\n", debug_d3dformat(format->id), type);
2361 format->rtInternal = format->glInternal;
2362 }
2363 else
2364 {
2365 gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type),
2366 rt_internal, GL_FRAMEBUFFER_RENDERABLE, 1, &value);
2367 if (value == GL_FULL_SUPPORT)
2368 {
2369 TRACE("Format %s rtInternal format is supported as FBO color attachment,"
2370 " resource type %u.\n", debug_d3dformat(format->id), type);
2371 fallback_fmt_used = TRUE;
2372 }
2373 else
2374 {
2375 WARN("Format %s rtInternal format is not supported as FBO color attachment,"
2376 " resource type %u.\n", debug_d3dformat(format->id), type);
2377 format->flags[type] &= ~WINED3DFMT_FLAG_RENDERTARGET;
2378 }
2379 }
2380 }
2381
2382 if (format->glInternal != format->glGammaInternal)
2383 {
2384 gl_info->gl_ops.ext.p_glGetInternalformativ(wined3d_gl_type_to_enum(type),
2385 format->glGammaInternal, GL_FRAMEBUFFER_RENDERABLE, 1, &value);
2386 if (value == GL_FULL_SUPPORT)
2387 {
2388 TRACE("Format %s's sRGB format is FBO attachable, resource type %u.\n",
2389 debug_d3dformat(format->id), type);
2390 format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
2391 }
2392 else
2393 {
2394 WARN("Format %s's sRGB format is not FBO attachable, resource type %u.\n",
2395 debug_d3dformat(format->id), type);
2396 }
2397 }
2398 else if (format->flags[type] & WINED3DFMT_FLAG_FBO_ATTACHABLE)
2399 format->flags[type] |= WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
2400 }
2401
2402 if (fallback_fmt_used && regular_fmt_used)
2403 {
2404 FIXME("Format %s needs different render target formats for different resource types.\n",
2405 debug_d3dformat(format->id));
2406 format_clear_flag(format, WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_FBO_ATTACHABLE
2407 | WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB | WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING);
2408 }
2409 }
2410 return;
2411 }
2412
2413 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2414 {
2415 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
2416 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
2417 gl_info->gl_ops.gl.p_glDrawBuffer(GL_COLOR_ATTACHMENT0);
2418 gl_info->gl_ops.gl.p_glReadBuffer(GL_COLOR_ATTACHMENT0);
2419 }
2420
2421 for (i = 0; i < gl_info->format_count; ++i)
2422 {
2423 struct wined3d_format *format = &gl_info->formats[i];
2424
2425 if (!format->glInternal) continue;
2426
2427 if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED)
2428 {
2429 TRACE("Skipping format %s because it's a compressed format.\n",
2430 debug_d3dformat(format->id));
2431 continue;
2432 }
2433
2434 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2435 {
2436 TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(format->id));
2437 check_fbo_compat(ctx, format);
2438 }
2439 else
2440 {
2441 format->rtInternal = format->glInternal;
2442 }
2443 }
2444
2445 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2446 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
2447 }
2448
2449 static void query_internal_format(struct wined3d_adapter *adapter,
2450 struct wined3d_format *format, const struct wined3d_format_texture_info *texture_info,
2451 struct wined3d_gl_info *gl_info, BOOL srgb_write_supported, BOOL srgb_format)
2452 {
2453 GLint count, multisample_types[MAX_MULTISAMPLE_TYPES];
2454 unsigned int i, max_log2;
2455
2456 if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2])
2457 {
2458 query_format_flag(gl_info, format, format->glInternal, GL_VERTEX_TEXTURE,
2459 WINED3DFMT_FLAG_VTF, "vertex texture usage");
2460 query_format_flag(gl_info, format, format->glInternal, GL_FILTER,
2461 WINED3DFMT_FLAG_FILTERING, "filtering");
2462
2463 if (srgb_format || format->glGammaInternal != format->glInternal)
2464 {
2465 query_format_flag(gl_info, format, format->glGammaInternal, GL_SRGB_READ,
2466 WINED3DFMT_FLAG_SRGB_READ, "sRGB read");
2467
2468 if (srgb_write_supported)
2469 query_format_flag(gl_info, format, format->glGammaInternal, GL_SRGB_WRITE,
2470 WINED3DFMT_FLAG_SRGB_WRITE, "sRGB write");
2471 else
2472 format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE);
2473
2474 if (!(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & (WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE)))
2475 format->glGammaInternal = format->glInternal;
2476 else if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
2477 format->glInternal = format->glGammaInternal;
2478 }
2479 }
2480 else
2481 {
2482 if (!gl_info->limits.vertex_samplers)
2483 format_clear_flag(format, WINED3DFMT_FLAG_VTF);
2484
2485 if (!(gl_info->quirks & WINED3D_QUIRK_LIMITED_TEX_FILTERING))
2486 format_set_flag(format, WINED3DFMT_FLAG_FILTERING);
2487 else if (format->id != WINED3DFMT_R32G32B32A32_FLOAT && format->id != WINED3DFMT_R32_FLOAT)
2488 format_clear_flag(format, WINED3DFMT_FLAG_VTF);
2489
2490 if (srgb_format || format->glGammaInternal != format->glInternal)
2491 {
2492 /* Filter sRGB capabilities if EXT_texture_sRGB is not supported. */
2493 if (!gl_info->supported[EXT_TEXTURE_SRGB])
2494 {
2495 format->glGammaInternal = format->glInternal;
2496 format_clear_flag(format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
2497 }
2498 else if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
2499 {
2500 format->glInternal = format->glGammaInternal;
2501 }
2502 }
2503
2504 if ((format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_SRGB_WRITE) && !srgb_write_supported)
2505 format_clear_flag(format, WINED3DFMT_FLAG_SRGB_WRITE);
2506
2507 if (!gl_info->supported[ARB_DEPTH_TEXTURE]
2508 && texture_info->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
2509 {
2510 format->flags[WINED3D_GL_RES_TYPE_TEX_1D] &= ~WINED3DFMT_FLAG_TEXTURE;
2511 format->flags[WINED3D_GL_RES_TYPE_TEX_2D] &= ~WINED3DFMT_FLAG_TEXTURE;
2512 format->flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
2513 format->flags[WINED3D_GL_RES_TYPE_TEX_CUBE] &= ~WINED3DFMT_FLAG_TEXTURE;
2514 format->flags[WINED3D_GL_RES_TYPE_TEX_RECT] &= ~WINED3DFMT_FLAG_TEXTURE;
2515 }
2516 }
2517
2518 if (format->glInternal && format->flags[WINED3D_GL_RES_TYPE_RB]
2519 & (WINED3DFMT_FLAG_RENDERTARGET | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
2520 {
2521 if (gl_info->supported[ARB_INTERNALFORMAT_QUERY])
2522 {
2523 GL_EXTCALL(glGetInternalformativ(GL_RENDERBUFFER, format->glInternal,
2524 GL_NUM_SAMPLE_COUNTS, 1, &count));
2525 checkGLcall("glGetInternalformativ(GL_NUM_SAMPLE_COUNTS)");
2526 count = min(count, MAX_MULTISAMPLE_TYPES);
2527 GL_EXTCALL(glGetInternalformativ(GL_RENDERBUFFER, format->glInternal,
2528 GL_SAMPLES, count, multisample_types));
2529 checkGLcall("glGetInternalformativ(GL_SAMPLES)");
2530 for (i = 0; i < count; ++i)
2531 {
2532 if (multisample_types[i] > sizeof(format->multisample_types) * 8)
2533 continue;
2534 format->multisample_types |= 1u << (multisample_types[i] - 1);
2535 }
2536 }
2537 else
2538 {
2539 max_log2 = wined3d_log2i(min(gl_info->limits.samples,
2540 sizeof(format->multisample_types) * 8));
2541 for (i = 1; i <= max_log2; ++i)
2542 format->multisample_types |= 1u << ((1u << i) - 1);
2543 }
2544 }
2545 }
2546
2547 static BOOL init_format_texture_info(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info)
2548 {
2549 struct fragment_caps fragment_caps;
2550 struct shader_caps shader_caps;
2551 unsigned int i, j;
2552 BOOL srgb_write;
2553
2554 adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
2555 adapter->shader_backend->shader_get_caps(gl_info, &shader_caps);
2556 srgb_write = (fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_SRGB_WRITE)
2557 && (shader_caps.wined3d_caps & WINED3D_SHADER_CAP_SRGB_WRITE);
2558
2559 for (i = 0; i < sizeof(format_texture_info) / sizeof(*format_texture_info); ++i)
2560 {
2561 int srgb_fmt_idx = -1, fmt_idx = get_format_idx(format_texture_info[i].id);
2562 struct wined3d_format *format, *srgb_format;
2563
2564 if (fmt_idx == -1)
2565 {
2566 ERR("Format %s (%#x) not found.\n",
2567 debug_d3dformat(format_texture_info[i].id), format_texture_info[i].id);
2568 return FALSE;
2569 }
2570
2571 if (!gl_info->supported[format_texture_info[i].extension]) continue;
2572
2573 format = &gl_info->formats[fmt_idx];
2574
2575 /* ARB_texture_rg defines floating point formats, but only if
2576 * ARB_texture_float is also supported. */
2577 if (!gl_info->supported[ARB_TEXTURE_FLOAT]
2578 && (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT))
2579 continue;
2580
2581 /* ARB_texture_rg defines integer formats if EXT_texture_integer is also supported. */
2582 if (!gl_info->supported[EXT_TEXTURE_INTEGER]
2583 && (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_INTEGER))
2584 continue;
2585
2586 format->glInternal = format_texture_info[i].gl_internal;
2587 format->glGammaInternal = format_texture_info[i].gl_srgb_internal;
2588 format->rtInternal = format_texture_info[i].gl_rt_internal;
2589 format->glFormat = format_texture_info[i].gl_format;
2590 format->glType = format_texture_info[i].gl_type;
2591 format->color_fixup = COLOR_FIXUP_IDENTITY;
2592 format->height_scale.numerator = 1;
2593 format->height_scale.denominator = 1;
2594
2595 format->flags[WINED3D_GL_RES_TYPE_TEX_1D] |= format_texture_info[i].flags;
2596 format->flags[WINED3D_GL_RES_TYPE_TEX_2D] |= format_texture_info[i].flags;
2597 format->flags[WINED3D_GL_RES_TYPE_BUFFER] |= format_texture_info[i].flags;
2598
2599 /* GL_ARB_depth_texture does not support 3D textures. It also says "cube textures are
2600 * problematic", but doesn't explicitly mandate that an error is generated. */
2601 if (gl_info->supported[EXT_TEXTURE3D]
2602 && !(format_texture_info[i].flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
2603 format->flags[WINED3D_GL_RES_TYPE_TEX_3D] |= format_texture_info[i].flags;
2604
2605 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2606 format->flags[WINED3D_GL_RES_TYPE_TEX_CUBE] |= format_texture_info[i].flags;
2607
2608 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2609 format->flags[WINED3D_GL_RES_TYPE_TEX_RECT] |= format_texture_info[i].flags;
2610
2611 format->flags[WINED3D_GL_RES_TYPE_RB] |= format_texture_info[i].flags;
2612 format->flags[WINED3D_GL_RES_TYPE_RB] &= ~WINED3DFMT_FLAG_TEXTURE;
2613
2614 if (format->glGammaInternal != format->glInternal
2615 && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL))
2616 {
2617 format->glGammaInternal = format->glInternal;
2618 format_clear_flag(format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
2619 }
2620
2621 query_internal_format(adapter, format, &format_texture_info[i], gl_info, srgb_write, FALSE);
2622
2623 /* Texture conversion stuff */
2624 format->convert = format_texture_info[i].convert;
2625 format->conv_byte_count = format_texture_info[i].conv_byte_count;
2626
2627 for (j = 0; j < sizeof(format_srgb_info) / sizeof(*format_srgb_info); ++j)
2628 {
2629 if (format_srgb_info[j].base_format_id == format->id)
2630 {
2631 srgb_fmt_idx = get_format_idx(format_srgb_info[j].srgb_format_id);
2632 if (srgb_fmt_idx == -1)
2633 {
2634 ERR("Format %s (%#x) not found.\n",
2635 debug_d3dformat(format_srgb_info[j].srgb_format_id),
2636 format_srgb_info[j].srgb_format_id);
2637 return FALSE;
2638 }
2639 break;
2640 }
2641 }
2642
2643 if (srgb_fmt_idx == -1)
2644 continue;
2645
2646 srgb_format = &gl_info->formats[srgb_fmt_idx];
2647
2648 *srgb_format = *format;
2649 srgb_format->id = format_srgb_info[j].srgb_format_id;
2650
2651 if (gl_info->supported[EXT_TEXTURE_SRGB]
2652 && !(adapter->d3d_info.wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL))
2653 {
2654 srgb_format->glInternal = format_texture_info[i].gl_srgb_internal;
2655 srgb_format->glGammaInternal = format_texture_info[i].gl_srgb_internal;
2656 format_set_flag(srgb_format, WINED3DFMT_FLAG_SRGB_READ | WINED3DFMT_FLAG_SRGB_WRITE);
2657 query_internal_format(adapter, srgb_format, &format_texture_info[i], gl_info, srgb_write, TRUE);
2658 }
2659 }
2660
2661 return TRUE;
2662 }
2663
2664 static BOOL color_match(DWORD c1, DWORD c2, BYTE max_diff)
2665 {
2666 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
2667 c1 >>= 8; c2 >>= 8;
2668 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
2669 c1 >>= 8; c2 >>= 8;
2670 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
2671 c1 >>= 8; c2 >>= 8;
2672 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
2673 return TRUE;
2674 }
2675
2676 /* A context is provided by the caller */
2677 static BOOL check_filter(const struct wined3d_gl_info *gl_info, GLenum internal)
2678 {
2679 static const DWORD data[] = {0x00000000, 0xffffffff};
2680 GLuint tex, fbo, buffer;
2681 DWORD readback[16 * 1];
2682 BOOL ret = FALSE;
2683
2684 /* Render a filtered texture and see what happens. This is intended to detect the lack of
2685 * float16 filtering on ATI X1000 class cards. The drivers disable filtering instead of
2686 * falling back to software. If this changes in the future this code will get fooled and
2687 * apps might hit the software path due to incorrectly advertised caps.
2688 *
2689 * Its unlikely that this changes however. GL Games like Mass Effect depend on the filter
2690 * disable fallback, if Apple or ATI ever change the driver behavior they will break more
2691 * than Wine. The Linux binary <= r500 driver is not maintained any more anyway
2692 */
2693
2694 while (gl_info->gl_ops.gl.p_glGetError());
2695
2696 gl_info->gl_ops.gl.p_glGenTextures(1, &buffer);
2697 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, buffer);
2698 memset(readback, 0x7e, sizeof(readback));
2699 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 1, 0,
2700 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, readback);
2701 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2702 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2703 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2704 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2705 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
2706
2707 gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
2708 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
2709 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, internal, 2, 1, 0,
2710 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
2711 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
2712 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2713 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2714 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2715 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
2716 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_2D);
2717
2718 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
2719 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
2720 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer, 0);
2721 gl_info->gl_ops.gl.p_glDrawBuffer(GL_COLOR_ATTACHMENT0);
2722
2723 gl_info->gl_ops.gl.p_glViewport(0, 0, 16, 1);
2724 gl_info->gl_ops.gl.p_glDisable(GL_LIGHTING);
2725 gl_info->gl_ops.gl.p_glMatrixMode(GL_MODELVIEW);
2726 gl_info->gl_ops.gl.p_glLoadIdentity();
2727 gl_info->gl_ops.gl.p_glMatrixMode(GL_PROJECTION);
2728 gl_info->gl_ops.gl.p_glLoadIdentity();
2729
2730 gl_info->gl_ops.gl.p_glClearColor(0, 1, 0, 0);
2731 gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
2732
2733 gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
2734 gl_info->gl_ops.gl.p_glTexCoord2f(0.0, 0.0);
2735 gl_info->gl_ops.gl.p_glVertex2f(-1.0f, -1.0f);
2736 gl_info->gl_ops.gl.p_glTexCoord2f(1.0, 0.0);
2737 gl_info->gl_ops.gl.p_glVertex2f(1.0f, -1.0f);
2738 gl_info->gl_ops.gl.p_glTexCoord2f(0.0, 1.0);
2739 gl_info->gl_ops.gl.p_glVertex2f(-1.0f, 1.0f);
2740 gl_info->gl_ops.gl.p_glTexCoord2f(1.0, 1.0);
2741 gl_info->gl_ops.gl.p_glVertex2f(1.0f, 1.0f);
2742 gl_info->gl_ops.gl.p_glEnd();
2743
2744 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, buffer);
2745 memset(readback, 0x7f, sizeof(readback));
2746 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
2747 if (color_match(readback[6], 0xffffffff, 5) || color_match(readback[6], 0x00000000, 5)
2748 || color_match(readback[9], 0xffffffff, 5) || color_match(readback[9], 0x00000000, 5))
2749 {
2750 TRACE("Read back colors 0x%08x and 0x%08x close to unfiltered color, assuming no filtering\n",
2751 readback[6], readback[9]);
2752 ret = FALSE;
2753 }
2754 else
2755 {
2756 TRACE("Read back colors are 0x%08x and 0x%08x, assuming texture is filtered\n",
2757 readback[6], readback[9]);
2758 ret = TRUE;
2759 }
2760
2761 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
2762 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
2763 gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
2764 gl_info->gl_ops.gl.p_glDeleteTextures(1, &buffer);
2765
2766 if (gl_info->gl_ops.gl.p_glGetError())
2767 {
2768 FIXME("Error during filtering test for format %x, returning no filtering\n", internal);
2769 ret = FALSE;
2770 }
2771
2772 return ret;
2773 }
2774
2775 static void init_format_filter_info(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
2776 {
2777 struct wined3d_format *format;
2778 unsigned int fmt_idx, i;
2779 static const enum wined3d_format_id fmts16[] =
2780 {
2781 WINED3DFMT_R16_FLOAT,
2782 WINED3DFMT_R16G16_FLOAT,
2783 WINED3DFMT_R16G16B16A16_FLOAT,
2784 };
2785 BOOL filtered;
2786
2787 if (gl_info->supported[ARB_INTERNALFORMAT_QUERY2])
2788 /* This was already handled by init_format_texture_info(). */
2789 return;
2790
2791 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
2792 || !gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
2793 {
2794 WARN("No FBO support, or no FBO ORM, guessing filter info from GL caps\n");
2795 if (vendor == HW_VENDOR_NVIDIA && gl_info->supported[ARB_TEXTURE_FLOAT])
2796 {
2797 TRACE("Nvidia card with texture_float support: Assuming float16 blending\n");
2798 filtered = TRUE;
2799 }
2800 else if (gl_info->limits.glsl_varyings > 44)
2801 {
2802 TRACE("More than 44 GLSL varyings - assuming d3d10 card with float16 blending\n");
2803 filtered = TRUE;
2804 }
2805 else
2806 {
2807 TRACE("Assuming no float16 blending\n");
2808 filtered = FALSE;
2809 }
2810
2811 if(filtered)
2812 {
2813 for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
2814 {
2815 fmt_idx = get_format_idx(fmts16[i]);
2816 format_set_flag(&gl_info->formats[fmt_idx], WINED3DFMT_FLAG_FILTERING);
2817 }
2818 }
2819 return;
2820 }
2821
2822 for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
2823 {
2824 fmt_idx = get_format_idx(fmts16[i]);
2825 format = &gl_info->formats[fmt_idx];
2826 if (!format->glInternal) continue; /* Not supported by GL */
2827
2828 filtered = check_filter(gl_info, gl_info->formats[fmt_idx].glInternal);
2829 if(filtered)
2830 {
2831 TRACE("Format %s supports filtering\n", debug_d3dformat(fmts16[i]));
2832 format_set_flag(format, WINED3DFMT_FLAG_FILTERING);
2833 }
2834 else
2835 {
2836 TRACE("Format %s does not support filtering\n", debug_d3dformat(fmts16[i]));
2837 }
2838 }
2839 }
2840
2841 static void apply_format_fixups(struct wined3d_adapter *adapter, struct wined3d_gl_info *gl_info)
2842 {
2843 unsigned int i;
2844 int idx;
2845
2846 idx = get_format_idx(WINED3DFMT_R16_FLOAT);
2847 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2848 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
2849
2850 idx = get_format_idx(WINED3DFMT_R32_FLOAT);
2851 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2852 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
2853
2854 idx = get_format_idx(WINED3DFMT_R16G16_UNORM);
2855 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2856 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
2857
2858 idx = get_format_idx(WINED3DFMT_R16G16_FLOAT);
2859 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2860 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
2861
2862 idx = get_format_idx(WINED3DFMT_R32G32_FLOAT);
2863 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2864 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
2865
2866 /* GL_ATI_envmap_bumpmap in theory supports R8G8_SNORM but is no longer supported by
2867 * any driver. */
2868 if (gl_info->supported[NV_TEXTURE_SHADER] || gl_info->supported[EXT_TEXTURE_SNORM])
2869 {
2870 /* R8G8_SNORM and R16G16_SNORM need a fixup of the undefined blue channel. OpenGL
2871 * returns 0.0 when sampling from it, DirectX 1.0. So we always have in-shader
2872 * conversion for this format. */
2873 idx = get_format_idx(WINED3DFMT_R8G8_SNORM);
2874 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2875 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
2876 idx = get_format_idx(WINED3DFMT_R16G16_SNORM);
2877 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2878 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
2879 }
2880 else
2881 {
2882 /* Emulate using unsigned formats. This requires load-time conversion in addition to the
2883 * fixups here. */
2884 idx = get_format_idx(WINED3DFMT_R8G8_SNORM);
2885 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2886 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
2887 idx = get_format_idx(WINED3DFMT_R16G16_SNORM);
2888 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2889 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
2890 idx = get_format_idx(WINED3DFMT_R8G8B8A8_SNORM);
2891 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2892 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
2893 idx = get_format_idx(WINED3DFMT_R5G5_SNORM_L6_UNORM);
2894 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2895 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
2896 }
2897
2898 if (!gl_info->supported[NV_TEXTURE_SHADER])
2899 {
2900 idx = get_format_idx(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
2901 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2902 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
2903 }
2904
2905 if (gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] || gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
2906 {
2907 idx = get_format_idx(WINED3DFMT_ATI1N);
2908 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2909 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X);
2910
2911 idx = get_format_idx(WINED3DFMT_ATI2N);
2912 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2913 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
2914 }
2915 else if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC])
2916 {
2917 idx = get_format_idx(WINED3DFMT_ATI2N);
2918 gl_info->formats[idx].color_fixup= create_color_fixup_desc(
2919 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
2920 }
2921
2922 if (!gl_info->supported[APPLE_YCBCR_422])
2923 {
2924 idx = get_format_idx(WINED3DFMT_YUY2);
2925 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YUY2);
2926
2927 idx = get_format_idx(WINED3DFMT_UYVY);
2928 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_UYVY);
2929 }
2930
2931 idx = get_format_idx(WINED3DFMT_YV12);
2932 format_set_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_HEIGHT_SCALE);
2933 gl_info->formats[idx].height_scale.numerator = 3;
2934 gl_info->formats[idx].height_scale.denominator = 2;
2935 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_YV12);
2936
2937 idx = get_format_idx(WINED3DFMT_NV12);
2938 format_set_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_HEIGHT_SCALE);
2939 gl_info->formats[idx].height_scale.numerator = 3;
2940 gl_info->formats[idx].height_scale.denominator = 2;
2941 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_NV12);
2942
2943 if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
2944 {
2945 idx = get_format_idx(WINED3DFMT_A8_UNORM);
2946 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2947 0, CHANNEL_SOURCE_ZERO, 0, CHANNEL_SOURCE_ZERO, 0, CHANNEL_SOURCE_ZERO, 0, CHANNEL_SOURCE_X);
2948 idx = get_format_idx(WINED3DFMT_L8A8_UNORM);
2949 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2950 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y);
2951 idx = get_format_idx(WINED3DFMT_L4A4_UNORM);
2952 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2953 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y);
2954 idx = get_format_idx(WINED3DFMT_L16_UNORM);
2955 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2956 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE);
2957 idx = get_format_idx(WINED3DFMT_INTZ);
2958 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2959 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X);
2960 }
2961
2962 if (gl_info->supported[ARB_TEXTURE_RG])
2963 {
2964 idx = get_format_idx(WINED3DFMT_L8_UNORM);
2965 gl_info->formats[idx].color_fixup = create_color_fixup_desc(
2966 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE);
2967 }
2968
2969 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2970 {
2971 idx = get_format_idx(WINED3DFMT_P8_UINT);
2972 gl_info->formats[idx].color_fixup = create_complex_fixup_desc(COMPLEX_FIXUP_P8);
2973 }
2974
2975 if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
2976 {
2977 idx = get_format_idx(WINED3DFMT_B8G8R8A8_UNORM);
2978 gl_info->formats[idx].gl_vtx_format = GL_BGRA;
2979 }
2980
2981 if (!gl_info->supported[ARB_HALF_FLOAT_VERTEX])
2982 {
2983 /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
2984 * It is the job of the vertex buffer code to make sure that the vbos have the right format */
2985 idx = get_format_idx(WINED3DFMT_R16G16_FLOAT);
2986 gl_info->formats[idx].gl_vtx_type = GL_FLOAT;
2987
2988 idx = get_format_idx(WINED3DFMT_R16G16B16A16_FLOAT);
2989 gl_info->formats[idx].gl_vtx_type = GL_FLOAT;
2990 }
2991
2992 if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
2993 {
2994 idx = get_format_idx(WINED3DFMT_R16_FLOAT);
2995 format_clear_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_TEXTURE);
2996
2997 idx = get_format_idx(WINED3DFMT_R16G16_FLOAT);
2998 format_clear_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_TEXTURE);
2999
3000 idx = get_format_idx(WINED3DFMT_R16G16B16A16_FLOAT);
3001 format_clear_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_TEXTURE);
3002 }
3003
3004 if (gl_info->quirks & WINED3D_QUIRK_BROKEN_RGBA16)
3005 {
3006 idx = get_format_idx(WINED3DFMT_R16G16B16A16_UNORM);
3007 format_clear_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_TEXTURE);
3008 }
3009
3010 /* ATI instancing hack: Although ATI cards do not support Shader Model
3011 * 3.0, they support instancing. To query if the card supports instancing
3012 * CheckDeviceFormat() with the special format MAKEFOURCC('I','N','S','T')
3013 * is used. Should an application check for this, provide a proper return
3014 * value. We can do instancing with all shader versions, but we need
3015 * vertex shaders.
3016 *
3017 * Additionally applications have to set the D3DRS_POINTSIZE render state
3018 * to MAKEFOURCC('I','N','S','T') once to enable instancing. Wined3d
3019 * doesn't need that and just ignores it.
3020 *
3021 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows. */
3022 /* FIXME: This should just check the shader backend caps. */
3023 if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_VERTEX_SHADER])
3024 {
3025 idx = get_format_idx(WINED3DFMT_INST);
3026 format_set_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_TEXTURE);
3027 }
3028
3029 /* Depth bound test. To query if the card supports it CheckDeviceFormat()
3030 * with the special format MAKEFOURCC('N','V','D','B') is used. It is
3031 * enabled by setting D3DRS_ADAPTIVETESS_X render state to
3032 * MAKEFOURCC('N','V','D','B') and then controlled by setting
3033 * D3DRS_ADAPTIVETESS_Z (zMin) and D3DRS_ADAPTIVETESS_W (zMax) to test
3034 * value. */
3035 if (gl_info->supported[EXT_DEPTH_BOUNDS_TEST])
3036 {
3037 idx = get_format_idx(WINED3DFMT_NVDB);
3038 format_set_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_TEXTURE);
3039 }
3040
3041 /* RESZ aka AMD DX9-level hack for multisampled depth buffer resolve. You query for RESZ
3042 * support by checking for availability of MAKEFOURCC('R','E','S','Z') surfaces with
3043 * RENDERTARGET usage. */
3044 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
3045 {
3046 idx = get_format_idx(WINED3DFMT_RESZ);
3047 format_set_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_TEXTURE | WINED3DFMT_FLAG_RENDERTARGET);
3048 }
3049
3050 for (i = 0; i < gl_info->format_count; ++i)
3051 {
3052 struct wined3d_format *format = &gl_info->formats[i];
3053
3054 if (!(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_TEXTURE))
3055 continue;
3056
3057 if (!adapter->shader_backend->shader_color_fixup_supported(format->color_fixup)
3058 || !adapter->fragment_pipe->color_fixup_supported(format->color_fixup))
3059 format_clear_flag(&gl_info->formats[idx], WINED3DFMT_FLAG_TEXTURE);
3060 }
3061
3062 /* GL_EXT_texture_compression_s3tc does not support 3D textures. Some Windows drivers
3063 * for dx9 GPUs support it, some do not, so not supporting DXTn volumes is OK for d3d9.
3064 *
3065 * Note that GL_NV_texture_compression_vtc adds this functionality to OpenGL, but the
3066 * block layout is not compatible with the one used by d3d. See volume_dxt5_test. */
3067 idx = get_format_idx(WINED3DFMT_DXT1);
3068 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3069 idx = get_format_idx(WINED3DFMT_DXT2);
3070 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3071 idx = get_format_idx(WINED3DFMT_DXT3);
3072 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3073 idx = get_format_idx(WINED3DFMT_DXT4);
3074 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3075 idx = get_format_idx(WINED3DFMT_DXT5);
3076 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3077 idx = get_format_idx(WINED3DFMT_BC1_UNORM);
3078 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3079 idx = get_format_idx(WINED3DFMT_BC1_UNORM_SRGB);
3080 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3081 idx = get_format_idx(WINED3DFMT_BC2_UNORM);
3082 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3083 idx = get_format_idx(WINED3DFMT_BC2_UNORM_SRGB);
3084 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3085 idx = get_format_idx(WINED3DFMT_BC3_UNORM);
3086 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3087 idx = get_format_idx(WINED3DFMT_BC3_UNORM_SRGB);
3088 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3089 /* Similarly with ATI1N / ATI2N and GL_ARB_texture_compression_rgtc. */
3090 idx = get_format_idx(WINED3DFMT_ATI1N);
3091 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3092 idx = get_format_idx(WINED3DFMT_ATI2N);
3093 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3094 idx = get_format_idx(WINED3DFMT_BC4_UNORM);
3095 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3096 idx = get_format_idx(WINED3DFMT_BC5_UNORM);
3097 gl_info->formats[idx].flags[WINED3D_GL_RES_TYPE_TEX_3D] &= ~WINED3DFMT_FLAG_TEXTURE;
3098 }
3099
3100 static unsigned int gl_type_size(GLenum type)
3101 {
3102 switch (type)
3103 {
3104 case GL_HALF_FLOAT:
3105 return sizeof(GLhalfNV);
3106 case GL_FLOAT:
3107 return sizeof(GLfloat);
3108 case GL_BYTE:
3109 return sizeof(GLbyte);
3110 case GL_UNSIGNED_BYTE:
3111 return sizeof(GLubyte);
3112 case GL_SHORT:
3113 return sizeof(GLshort);
3114 case GL_UNSIGNED_SHORT:
3115 return sizeof(GLushort);
3116 case GL_INT:
3117 return sizeof(GLint);
3118 case GL_UNSIGNED_INT:
3119 return sizeof(GLuint);
3120 default:
3121 FIXME("Unhandled GL type %#x.\n", type);
3122 return 0;
3123 }
3124 }
3125
3126 static BOOL init_format_vertex_info(struct wined3d_gl_info *gl_info)
3127 {
3128 unsigned int i;
3129
3130 for (i = 0; i < ARRAY_SIZE(format_vertex_info); ++i)
3131 {
3132 struct wined3d_format *format;
3133 int fmt_idx = get_format_idx(format_vertex_info[i].id);
3134
3135 if (fmt_idx == -1)
3136 {
3137 ERR("Format %s (%#x) not found.\n",
3138 debug_d3dformat(format_vertex_info[i].id), format_vertex_info[i].id);
3139 return FALSE;
3140 }
3141
3142 format = &gl_info->formats[fmt_idx];
3143 format->emit_idx = format_vertex_info[i].emit_idx;
3144 format->component_count = format_vertex_info[i].component_count;
3145 format->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
3146 format->gl_vtx_format = format_vertex_info[i].component_count;
3147 format->gl_normalized = format_vertex_info[i].gl_normalized;
3148 if (!(format->component_size = gl_type_size(format_vertex_info[i].gl_vtx_type)))
3149 {
3150 ERR("Invalid component size for vertex format %s (%#x).\n",
3151 debug_d3dformat(format_vertex_info[i].id), format_vertex_info[i].id);
3152 return FALSE;
3153 }
3154 }
3155
3156 return TRUE;
3157 }
3158
3159 static BOOL init_typeless_formats(struct wined3d_gl_info *gl_info)
3160 {
3161 unsigned int flags[WINED3D_GL_RES_TYPE_COUNT];
3162 unsigned int i, j;
3163
3164 for (i = 0; i < ARRAY_SIZE(typed_formats); ++i)
3165 {
3166 struct wined3d_format *format, *typeless_format;
3167 int fmt_idx = get_format_idx(typed_formats[i].id);
3168 int typeless_fmt_idx = get_format_idx(typed_formats[i].typeless_id);
3169
3170 if (fmt_idx == -1)
3171 {
3172 ERR("Format %s (%#x) not found.\n",
3173 debug_d3dformat(typed_formats[i].id),
3174 typed_formats[i].id);
3175 return FALSE;
3176 }
3177 if (typeless_fmt_idx == -1)
3178 {
3179 ERR("Format %s (%#x) not found.\n",
3180 debug_d3dformat(typed_formats[i].typeless_id),
3181 typed_formats[i].typeless_id);
3182 return FALSE;
3183 }
3184
3185 format = &gl_info->formats[fmt_idx];
3186 typeless_format = &gl_info->formats[typeless_fmt_idx];
3187
3188 memcpy(flags, typeless_format->flags, sizeof(flags));
3189 *typeless_format = *format;
3190 typeless_format->id = typed_formats[i].typeless_id;
3191 for (j = 0; j < ARRAY_SIZE(typeless_format->flags); ++j)
3192 typeless_format->flags[j] |= flags[j];
3193 }
3194
3195 return TRUE;
3196 }
3197
3198 BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info)
3199 {
3200 if (!init_format_base_info(gl_info)) return FALSE;
3201
3202 if (!init_format_block_info(gl_info))
3203 {
3204 HeapFree(GetProcessHeap(), 0, gl_info->formats);
3205 gl_info->formats = NULL;
3206 return FALSE;
3207 }
3208
3209 return TRUE;
3210 }
3211
3212 /* Context activation is done by the caller. */
3213 BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx)
3214 {
3215 struct wined3d_gl_info *gl_info = &adapter->gl_info;
3216
3217 if (!init_format_base_info(gl_info)) return FALSE;
3218
3219 if (!init_format_block_info(gl_info)) goto fail;
3220 if (!init_format_texture_info(adapter, gl_info)) goto fail;
3221 if (!init_format_vertex_info(gl_info)) goto fail;
3222
3223 apply_format_fixups(adapter, gl_info);
3224 init_format_fbo_compat_info(ctx);
3225 init_format_filter_info(gl_info, adapter->driver_info.vendor);
3226 if (!init_typeless_formats(gl_info)) goto fail;
3227
3228 return TRUE;
3229
3230 fail:
3231 HeapFree(GetProcessHeap(), 0, gl_info->formats);
3232 gl_info->formats = NULL;
3233 return FALSE;
3234 }
3235
3236 float wined3d_adapter_find_polyoffset_scale(struct wined3d_caps_gl_ctx *ctx, GLenum format)
3237 {
3238 const struct wined3d_gl_info *gl_info = ctx->gl_info;
3239 static const struct wined3d_color blue = {0.0f, 0.0f, 1.0f, 1.0f};
3240 GLuint fbo, color, depth;
3241 unsigned int low = 0, high = 32, cur;
3242 DWORD readback[256];
3243 static const struct wined3d_vec3 geometry[] =
3244 {
3245 {-1.0f, -1.0f, -1.0f},
3246 { 1.0f, -1.0f, 0.0f},
3247 {-1.0f, 1.0f, -1.0f},
3248 { 1.0f, 1.0f, 0.0f},
3249 };
3250
3251 /* Most drivers want 2^23 for fixed point depth buffers, including r300g, r600g,
3252 * Nvidia. Use this as a fallback if the detection fails. */
3253 unsigned int fallback = 23;
3254
3255 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
3256 {
3257 FIXME("No FBOs, assuming polyoffset scale of 2^%u.\n", fallback);
3258 return (float)(1u << fallback);
3259 }
3260
3261 gl_info->gl_ops.gl.p_glGenTextures(1, &color);
3262 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, color);
3263 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
3264 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 256, 1, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
3265
3266 gl_info->fbo_ops.glGenRenderbuffers(1, &depth);
3267 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, depth);
3268 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, format, 256, 1);
3269
3270 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
3271 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
3272 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color, 0);
3273 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth);
3274 checkGLcall("Setup framebuffer");
3275
3276 gl_info->gl_ops.gl.p_glClearColor(0.0f, 0.0f, 0.5f, 0.0f);
3277 gl_info->gl_ops.gl.p_glClearDepth(0.5f);
3278 gl_info->gl_ops.gl.p_glEnable(GL_DEPTH_TEST);
3279 gl_info->gl_ops.gl.p_glEnable(GL_POLYGON_OFFSET_FILL);
3280 gl_info->gl_ops.gl.p_glViewport(0, 0, 256, 1);
3281 checkGLcall("Misc parameters");
3282
3283 for (;;)
3284 {
3285 if (high - low <= 1)
3286 {
3287 ERR("PolygonOffset scale factor detection failed, using fallback value 2^%u.\n", fallback);
3288 cur = fallback;
3289 break;
3290 }
3291 cur = (low + high) / 2;
3292
3293 gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
3294 /* The post viewport transform Z of the geometry runs from 0.0 to 0.5. We want to push it another
3295 * 0.25 so that the Z buffer content (0.5) cuts the quad off at half the screen. */
3296 gl_info->gl_ops.gl.p_glPolygonOffset(0.0f, (float)(1u << cur) * 0.25f);
3297 draw_test_quad(ctx, geometry, &blue);
3298 checkGLcall("Test draw");
3299
3300 /* Rebinding texture to workaround a fglrx bug. */
3301 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, color);
3302 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
3303 checkGLcall("readback");
3304
3305 TRACE("low %02u, high %02u, cur %2u, 0=0x%08x, 125=0x%08x, 131=0x%08x, 255=0x%08x\n",
3306 low, high, cur, readback[0], readback[125], readback[131], readback[255]);
3307
3308 if ((readback[125] & 0xff) < 0xa0)
3309 high = cur;
3310 else if ((readback[131] & 0xff) > 0xa0)
3311 low = cur;
3312 else
3313 {
3314 TRACE("Found scale factor 2^%u for format %x\n", cur, format);
3315 break;
3316 }
3317 }
3318
3319 gl_info->gl_ops.gl.p_glDeleteTextures(1, &color);
3320 gl_info->fbo_ops.glDeleteRenderbuffers(1, &depth);
3321 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
3322 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
3323 checkGLcall("Delete framebuffer");
3324
3325 gl_info->gl_ops.gl.p_glDisable(GL_DEPTH_TEST);
3326 gl_info->gl_ops.gl.p_glDisable(GL_POLYGON_OFFSET_FILL);
3327 return (float)(1u << cur);
3328 }
3329
3330 const struct wined3d_format *wined3d_get_format(const struct wined3d_gl_info *gl_info,
3331 enum wined3d_format_id format_id)
3332 {
3333 int idx = get_format_idx(format_id);
3334
3335 if (idx == -1)
3336 {
3337 FIXME("Can't find format %s (%#x) in the format lookup table\n",
3338 debug_d3dformat(format_id), format_id);
3339 /* Get the caller a valid pointer */
3340 idx = get_format_idx(WINED3DFMT_UNKNOWN);
3341 }
3342
3343 return &gl_info->formats[idx];
3344 }
3345
3346 void wined3d_format_calculate_pitch(const struct wined3d_format *format, unsigned int alignment,
3347 unsigned int width, unsigned int height, unsigned int *row_pitch, unsigned int *slice_pitch)
3348 {
3349 /* For block based formats, pitch means the amount of bytes to the next
3350 * row of blocks rather than the next row of pixels. */
3351 if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_BLOCKS)
3352 {
3353 unsigned int row_block_count = (width + format->block_width - 1) / format->block_width;
3354 unsigned int slice_block_count = (height + format->block_height - 1) / format->block_height;
3355 *row_pitch = row_block_count * format->block_byte_count;
3356 *row_pitch = (*row_pitch + alignment - 1) & ~(alignment - 1);
3357 *slice_pitch = *row_pitch * slice_block_count;
3358 }
3359 else
3360 {
3361 *row_pitch = format->byte_count * width; /* Bytes / row */
3362 *row_pitch = (*row_pitch + alignment - 1) & ~(alignment - 1);
3363 *slice_pitch = *row_pitch * height;
3364 }
3365
3366 if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_HEIGHT_SCALE)
3367 {
3368 /* The D3D format requirements make sure that the resulting format is an integer again */
3369 *slice_pitch *= format->height_scale.numerator;
3370 *slice_pitch /= format->height_scale.denominator;
3371 }
3372
3373 TRACE("Returning row pitch %u, slice pitch %u.\n", *row_pitch, *slice_pitch);
3374 }
3375
3376 UINT wined3d_format_calculate_size(const struct wined3d_format *format, UINT alignment,
3377 UINT width, UINT height, UINT depth)
3378 {
3379 unsigned int row_pitch, slice_pitch;
3380
3381 if (format->id == WINED3DFMT_UNKNOWN)
3382 return 0;
3383
3384 wined3d_format_calculate_pitch(format, alignment, width, height, &row_pitch, &slice_pitch);
3385
3386 return slice_pitch * depth;
3387 }
3388
3389 /*****************************************************************************
3390 * Trace formatting of useful values
3391 */
3392 const char *debug_box(const struct wined3d_box *box)
3393 {
3394 if (!box)
3395 return "(null)";
3396 return wine_dbg_sprintf("(%u, %u, %u)-(%u, %u, %u)",
3397 box->left, box->top, box->front,
3398 box->right, box->bottom, box->back);
3399 }
3400
3401 const char *debug_color(const struct wined3d_color *color)
3402 {
3403 if (!color)
3404 return "(null)";
3405 return wine_dbg_sprintf("{%.8e, %.8e, %.8e, %.8e}",
3406 color->r, color->g, color->b, color->a);
3407 }
3408
3409 const char *debug_ivec4(const struct wined3d_ivec4 *v)
3410 {
3411 if (!v)
3412 return "(null)";
3413 return wine_dbg_sprintf("{%d, %d, %d, %d}",
3414 v->x, v->y, v->z, v->w);
3415 }
3416
3417 const char *debug_vec4(const struct wined3d_vec4 *v)
3418 {
3419 if (!v)
3420 return "(null)";
3421 return wine_dbg_sprintf("{%.8e, %.8e, %.8e, %.8e}",
3422 v->x, v->y, v->z, v->w);
3423 }
3424
3425 const char *debug_d3dformat(enum wined3d_format_id format_id)
3426 {
3427 switch (format_id)
3428 {
3429 #define FMT_TO_STR(format_id) case format_id: return #format_id
3430 FMT_TO_STR(WINED3DFMT_UNKNOWN);
3431 FMT_TO_STR(WINED3DFMT_B8G8R8_UNORM);
3432 FMT_TO_STR(WINED3DFMT_B5G5R5X1_UNORM);
3433 FMT_TO_STR(WINED3DFMT_B4G4R4A4_UNORM);
3434 FMT_TO_STR(WINED3DFMT_B2G3R3_UNORM);
3435 FMT_TO_STR(WINED3DFMT_B2G3R3A8_UNORM);
3436 FMT_TO_STR(WINED3DFMT_B4G4R4X4_UNORM);
3437 FMT_TO_STR(WINED3DFMT_R8G8B8X8_UNORM);
3438 FMT_TO_STR(WINED3DFMT_B10G10R10A2_UNORM);
3439 FMT_TO_STR(WINED3DFMT_P8_UINT_A8_UNORM);
3440 FMT_TO_STR(WINED3DFMT_P8_UINT);
3441 FMT_TO_STR(WINED3DFMT_L8_UNORM);
3442 FMT_TO_STR(WINED3DFMT_L8A8_UNORM);
3443 FMT_TO_STR(WINED3DFMT_L4A4_UNORM);
3444 FMT_TO_STR(WINED3DFMT_R5G5_SNORM_L6_UNORM);
3445 FMT_TO_STR(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
3446 FMT_TO_STR(WINED3DFMT_R10G11B11_SNORM);
3447 FMT_TO_STR(WINED3DFMT_R10G10B10_SNORM_A2_UNORM);
3448 FMT_TO_STR(WINED3DFMT_UYVY);
3449 FMT_TO_STR(WINED3DFMT_YUY2);
3450 FMT_TO_STR(WINED3DFMT_YV12);
3451 FMT_TO_STR(WINED3DFMT_NV12);
3452 FMT_TO_STR(WINED3DFMT_DXT1);
3453 FMT_TO_STR(WINED3DFMT_DXT2);
3454 FMT_TO_STR(WINED3DFMT_DXT3);
3455 FMT_TO_STR(WINED3DFMT_DXT4);
3456 FMT_TO_STR(WINED3DFMT_DXT5);
3457 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
3458 FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
3459 FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
3460 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
3461 FMT_TO_STR(WINED3DFMT_D32_UNORM);
3462 FMT_TO_STR(WINED3DFMT_S1_UINT_D15_UNORM);
3463 FMT_TO_STR(WINED3DFMT_X8D24_UNORM);
3464 FMT_TO_STR(WINED3DFMT_S4X4_UINT_D24_UNORM);
3465 FMT_TO_STR(WINED3DFMT_L16_UNORM);
3466 FMT_TO_STR(WINED3DFMT_S8_UINT_D24_FLOAT);
3467 FMT_TO_STR(WINED3DFMT_VERTEXDATA);
3468 FMT_TO_STR(WINED3DFMT_R8G8_SNORM_Cx);
3469 FMT_TO_STR(WINED3DFMT_ATI1N);
3470 FMT_TO_STR(WINED3DFMT_ATI2N);
3471 FMT_TO_STR(WINED3DFMT_NVDB);
3472 FMT_TO_STR(WINED3DFMT_NVHU);
3473 FMT_TO_STR(WINED3DFMT_NVHS);
3474 FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS);
3475 FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT);
3476 FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT);
3477 FMT_TO_STR(WINED3DFMT_R32G32B32A32_SINT);
3478 FMT_TO_STR(WINED3DFMT_R32G32B32_TYPELESS);
3479 FMT_TO_STR(WINED3DFMT_R32G32B32_FLOAT);
3480 FMT_TO_STR(WINED3DFMT_R32G32B32_UINT);
3481 FMT_TO_STR(WINED3DFMT_R32G32B32_SINT);
3482 FMT_TO_STR(WINED3DFMT_R16G16B16A16_TYPELESS);
3483 FMT_TO_STR(WINED3DFMT_R16G16B16A16_FLOAT);
3484 FMT_TO_STR(WINED3DFMT_R16G16B16A16_UNORM);
3485 FMT_TO_STR(WINED3DFMT_R16G16B16A16_UINT);
3486 FMT_TO_STR(WINED3DFMT_R16G16B16A16_SNORM);
3487 FMT_TO_STR(WINED3DFMT_R16G16B16A16_SINT);
3488 FMT_TO_STR(WINED3DFMT_R32G32_TYPELESS);
3489 FMT_TO_STR(WINED3DFMT_R32G32_FLOAT);
3490 FMT_TO_STR(WINED3DFMT_R32G32_UINT);
3491 FMT_TO_STR(WINED3DFMT_R32G32_SINT);
3492 FMT_TO_STR(WINED3DFMT_R32G8X24_TYPELESS);
3493 FMT_TO_STR(WINED3DFMT_D32_FLOAT_S8X24_UINT);
3494 FMT_TO_STR(WINED3DFMT_R32_FLOAT_X8X24_TYPELESS);
3495 FMT_TO_STR(WINED3DFMT_X32_TYPELESS_G8X24_UINT);
3496 FMT_TO_STR(WINED3DFMT_R10G10B10A2_TYPELESS);
3497 FMT_TO_STR(WINED3DFMT_R10G10B10A2_UNORM);
3498 FMT_TO_STR(WINED3DFMT_R10G10B10A2_UINT);
3499 FMT_TO_STR(WINED3DFMT_R10G10B10A2_SNORM);
3500 FMT_TO_STR(WINED3DFMT_R11G11B10_FLOAT);
3501 FMT_TO_STR(WINED3DFMT_R8G8B8A8_TYPELESS);
3502 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM);
3503 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM_SRGB);
3504 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UINT);
3505 FMT_TO_STR(WINED3DFMT_R8G8B8A8_SNORM);
3506 FMT_TO_STR(WINED3DFMT_R8G8B8A8_SINT);
3507 FMT_TO_STR(WINED3DFMT_R16G16_TYPELESS);
3508 FMT_TO_STR(WINED3DFMT_R16G16_FLOAT);
3509 FMT_TO_STR(WINED3DFMT_R16G16_UNORM);
3510 FMT_TO_STR(WINED3DFMT_R16G16_UINT);
3511 FMT_TO_STR(WINED3DFMT_R16G16_SNORM);
3512 FMT_TO_STR(WINED3DFMT_R16G16_SINT);
3513 FMT_TO_STR(WINED3DFMT_R32_TYPELESS);
3514 FMT_TO_STR(WINED3DFMT_D32_FLOAT);
3515 FMT_TO_STR(WINED3DFMT_R32_FLOAT);
3516 FMT_TO_STR(WINED3DFMT_R32_UINT);
3517 FMT_TO_STR(WINED3DFMT_R32_SINT);
3518 FMT_TO_STR(WINED3DFMT_R24G8_TYPELESS);
3519 FMT_TO_STR(WINED3DFMT_D24_UNORM_S8_UINT);
3520 FMT_TO_STR(WINED3DFMT_R24_UNORM_X8_TYPELESS);
3521 FMT_TO_STR(WINED3DFMT_X24_TYPELESS_G8_UINT);
3522 FMT_TO_STR(WINED3DFMT_R8G8_TYPELESS);
3523 FMT_TO_STR(WINED3DFMT_R8G8_UNORM);
3524 FMT_TO_STR(WINED3DFMT_R8G8_UINT);
3525 FMT_TO_STR(WINED3DFMT_R8G8_SNORM);
3526 FMT_TO_STR(WINED3DFMT_R8G8_SINT);
3527 FMT_TO_STR(WINED3DFMT_R16_TYPELESS);
3528 FMT_TO_STR(WINED3DFMT_R16_FLOAT);
3529 FMT_TO_STR(WINED3DFMT_D16_UNORM);
3530 FMT_TO_STR(WINED3DFMT_R16_UNORM);
3531 FMT_TO_STR(WINED3DFMT_R16_UINT);
3532 FMT_TO_STR(WINED3DFMT_R16_SNORM);
3533 FMT_TO_STR(WINED3DFMT_R16_SINT);
3534 FMT_TO_STR(WINED3DFMT_R8_TYPELESS);
3535 FMT_TO_STR(WINED3DFMT_R8_UNORM);
3536 FMT_TO_STR(WINED3DFMT_R8_UINT);
3537 FMT_TO_STR(WINED3DFMT_R8_SNORM);
3538 FMT_TO_STR(WINED3DFMT_R8_SINT);
3539 FMT_TO_STR(WINED3DFMT_A8_UNORM);
3540 FMT_TO_STR(WINED3DFMT_R1_UNORM);
3541 FMT_TO_STR(WINED3DFMT_R9G9B9E5_SHAREDEXP);
3542 FMT_TO_STR(WINED3DFMT_R8G8_B8G8_UNORM);
3543 FMT_TO_STR(WINED3DFMT_G8R8_G8B8_UNORM);
3544 FMT_TO_STR(WINED3DFMT_BC1_TYPELESS);
3545 FMT_TO_STR(WINED3DFMT_BC1_UNORM);
3546 FMT_TO_STR(WINED3DFMT_BC1_UNORM_SRGB);
3547 FMT_TO_STR(WINED3DFMT_BC2_TYPELESS);
3548 FMT_TO_STR(WINED3DFMT_BC2_UNORM);
3549 FMT_TO_STR(WINED3DFMT_BC2_UNORM_SRGB);
3550 FMT_TO_STR(WINED3DFMT_BC3_TYPELESS);
3551 FMT_TO_STR(WINED3DFMT_BC3_UNORM);
3552 FMT_TO_STR(WINED3DFMT_BC3_UNORM_SRGB);
3553 FMT_TO_STR(WINED3DFMT_BC4_TYPELESS);
3554 FMT_TO_STR(WINED3DFMT_BC4_UNORM);
3555 FMT_TO_STR(WINED3DFMT_BC4_SNORM);
3556 FMT_TO_STR(WINED3DFMT_BC5_TYPELESS);
3557 FMT_TO_STR(WINED3DFMT_BC5_UNORM);
3558 FMT_TO_STR(WINED3DFMT_BC5_SNORM);
3559 FMT_TO_STR(WINED3DFMT_B5G6R5_UNORM);
3560 FMT_TO_STR(WINED3DFMT_B5G5R5A1_UNORM);
3561 FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM);
3562 FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM);
3563 FMT_TO_STR(WINED3DFMT_B8G8R8A8_TYPELESS);
3564 FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM_SRGB);
3565 FMT_TO_STR(WINED3DFMT_B8G8R8X8_TYPELESS);
3566 FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM_SRGB);
3567 FMT_TO_STR(WINED3DFMT_BC7_TYPELESS);
3568 FMT_TO_STR(WINED3DFMT_BC7_UNORM);
3569 FMT_TO_STR(WINED3DFMT_BC7_UNORM_SRGB);
3570 FMT_TO_STR(WINED3DFMT_INTZ);
3571 FMT_TO_STR(WINED3DFMT_RESZ);
3572 FMT_TO_STR(WINED3DFMT_NULL);
3573 FMT_TO_STR(WINED3DFMT_R16);
3574 FMT_TO_STR(WINED3DFMT_AL16);
3575 #undef FMT_TO_STR
3576 default:
3577 {
3578 char fourcc[5];
3579 fourcc[0] = (char)(format_id);
3580 fourcc[1] = (char)(format_id >> 8);
3581 fourcc[2] = (char)(format_id >> 16);
3582 fourcc[3] = (char)(format_id >> 24);
3583 fourcc[4] = 0;
3584 if (isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]))
3585 FIXME("Unrecognized %#x (as fourcc: %s) WINED3DFORMAT!\n", format_id, fourcc);
3586 else
3587 FIXME("Unrecognized %#x WINED3DFORMAT!\n", format_id);
3588 }
3589 return "unrecognized";
3590 }
3591 }
3592
3593 const char *debug_d3ddevicetype(enum wined3d_device_type device_type)
3594 {
3595 switch (device_type)
3596 {
3597 #define DEVTYPE_TO_STR(dev) case dev: return #dev
3598 DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_HAL);
3599 DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_REF);
3600 DEVTYPE_TO_STR(WINED3D_DEVICE_TYPE_SW);
3601 #undef DEVTYPE_TO_STR
3602 default:
3603 FIXME("Unrecognized device type %#x.\n", device_type);
3604 return "unrecognized";
3605 }
3606 }
3607
3608 const char *debug_d3dusage(DWORD usage)
3609 {
3610 char buf[552];
3611
3612 buf[0] = '\0';
3613 #define WINED3DUSAGE_TO_STR(u) if (usage & u) { strcat(buf, " | "#u); usage &= ~u; }
3614 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
3615 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
3616 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
3617 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
3618 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
3619 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
3620 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
3621 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
3622 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
3623 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
3624 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RESTRICTED_CONTENT);
3625 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RESTRICT_SHARED_RESOURCE_DRIVER);
3626 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RESTRICT_SHARED_RESOURCE);
3627 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
3628 WINED3DUSAGE_TO_STR(WINED3DUSAGE_TEXTAPI);
3629 WINED3DUSAGE_TO_STR(WINED3DUSAGE_LEGACY_CUBEMAP);
3630 WINED3DUSAGE_TO_STR(WINED3DUSAGE_TEXTURE);
3631 WINED3DUSAGE_TO_STR(WINED3DUSAGE_OWNDC);
3632 WINED3DUSAGE_TO_STR(WINED3DUSAGE_STATICDECL);
3633 WINED3DUSAGE_TO_STR(WINED3DUSAGE_OVERLAY);
3634 #undef WINED3DUSAGE_TO_STR
3635 if (usage) FIXME("Unrecognized usage flag(s) %#x\n", usage);
3636
3637 return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
3638 }
3639
3640 const char *debug_d3dusagequery(DWORD usagequery)
3641 {
3642 char buf[238];
3643
3644 buf[0] = '\0';
3645 #define WINED3DUSAGEQUERY_TO_STR(u) if (usagequery & u) { strcat(buf, " | "#u); usagequery &= ~u; }
3646 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
3647 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
3648 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
3649 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
3650 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
3651 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
3652 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
3653 #undef WINED3DUSAGEQUERY_TO_STR
3654 if (usagequery) FIXME("Unrecognized usage query flag(s) %#x\n", usagequery);
3655
3656 return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
3657 }
3658
3659 const char *debug_d3ddeclmethod(enum wined3d_decl_method method)
3660 {
3661 switch (method)
3662 {
3663 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
3664 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_DEFAULT);
3665 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_PARTIAL_U);
3666 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_PARTIAL_V);
3667 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_CROSS_UV);
3668 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_UV);
3669 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_LOOKUP);
3670 WINED3DDECLMETHOD_TO_STR(WINED3D_DECL_METHOD_LOOKUP_PRESAMPLED);
3671 #undef WINED3DDECLMETHOD_TO_STR
3672 default:
3673 FIXME("Unrecognized declaration method %#x.\n", method);
3674 return "unrecognized";
3675 }
3676 }
3677
3678 const char *debug_d3ddeclusage(enum wined3d_decl_usage usage)
3679 {
3680 switch (usage)
3681 {
3682 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
3683 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_POSITION);
3684 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BLEND_WEIGHT);
3685 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BLEND_INDICES);
3686 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_NORMAL);
3687 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_PSIZE);
3688 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TEXCOORD);
3689 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TANGENT);
3690 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_BINORMAL);
3691 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_TESS_FACTOR);
3692 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_POSITIONT);
3693 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_COLOR);
3694 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_FOG);
3695 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_DEPTH);
3696 WINED3DDECLUSAGE_TO_STR(WINED3D_DECL_USAGE_SAMPLE);
3697 #undef WINED3DDECLUSAGE_TO_STR
3698 default:
3699 FIXME("Unrecognized %u declaration usage!\n", usage);
3700 return "unrecognized";
3701 }
3702 }
3703
3704 const char *debug_d3dinput_classification(enum wined3d_input_classification classification)
3705 {
3706 switch (classification)
3707 {
3708 #define WINED3D_TO_STR(x) case x: return #x
3709 WINED3D_TO_STR(WINED3D_INPUT_PER_VERTEX_DATA);
3710 WINED3D_TO_STR(WINED3D_INPUT_PER_INSTANCE_DATA);
3711 #undef WINED3D_TO_STR
3712 default:
3713 FIXME("Unrecognized input classification %#x.\n", classification);
3714 return "unrecognized";
3715 }
3716 }
3717
3718 const char *debug_d3dresourcetype(enum wined3d_resource_type resource_type)
3719 {
3720 switch (resource_type)
3721 {
3722 #define WINED3D_TO_STR(x) case x: return #x
3723 WINED3D_TO_STR(WINED3D_RTYPE_BUFFER);
3724 WINED3D_TO_STR(WINED3D_RTYPE_TEXTURE_2D);
3725 WINED3D_TO_STR(WINED3D_RTYPE_TEXTURE_3D);
3726 #undef WINED3D_TO_STR
3727 default:
3728 FIXME("Unrecognized resource type %#x.\n", resource_type);
3729 return "unrecognized";
3730 }
3731 }
3732
3733 const char *debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type)
3734 {
3735 switch (primitive_type)
3736 {
3737 #define PRIM_TO_STR(prim) case prim: return #prim
3738 PRIM_TO_STR(WINED3D_PT_UNDEFINED);
3739 PRIM_TO_STR(WINED3D_PT_POINTLIST);
3740 PRIM_TO_STR(WINED3D_PT_LINELIST);
3741 PRIM_TO_STR(WINED3D_PT_LINESTRIP);
3742 PRIM_TO_STR(WINED3D_PT_TRIANGLELIST);
3743 PRIM_TO_STR(WINED3D_PT_TRIANGLESTRIP);
3744 PRIM_TO_STR(WINED3D_PT_TRIANGLEFAN);
3745 PRIM_TO_STR(WINED3D_PT_LINELIST_ADJ);
3746 PRIM_TO_STR(WINED3D_PT_LINESTRIP_ADJ);
3747 PRIM_TO_STR(WINED3D_PT_TRIANGLELIST_ADJ);
3748 PRIM_TO_STR(WINED3D_PT_TRIANGLESTRIP_ADJ);
3749 #undef PRIM_TO_STR
3750 default:
3751 FIXME("Unrecognized %u primitive type!\n", primitive_type);
3752 return "unrecognized";
3753 }
3754 }
3755
3756 const char *debug_d3drenderstate(enum wined3d_render_state state)
3757 {
3758 switch (state)
3759 {
3760 #define D3DSTATE_TO_STR(u) case u: return #u
3761 D3DSTATE_TO_STR(WINED3D_RS_ANTIALIAS);
3762 D3DSTATE_TO_STR(WINED3D_RS_TEXTUREPERSPECTIVE);
3763 D3DSTATE_TO_STR(WINED3D_RS_WRAPU);
3764 D3DSTATE_TO_STR(WINED3D_RS_WRAPV);
3765 D3DSTATE_TO_STR(WINED3D_RS_ZENABLE);
3766 D3DSTATE_TO_STR(WINED3D_RS_FILLMODE);
3767 D3DSTATE_TO_STR(WINED3D_RS_SHADEMODE);
3768 D3DSTATE_TO_STR(WINED3D_RS_LINEPATTERN);
3769 D3DSTATE_TO_STR(WINED3D_RS_MONOENABLE);
3770 D3DSTATE_TO_STR(WINED3D_RS_ROP2);
3771 D3DSTATE_TO_STR(WINED3D_RS_PLANEMASK);
3772 D3DSTATE_TO_STR(WINED3D_RS_ZWRITEENABLE);
3773 D3DSTATE_TO_STR(WINED3D_RS_ALPHATESTENABLE);
3774 D3DSTATE_TO_STR(WINED3D_RS_LASTPIXEL);
3775 D3DSTATE_TO_STR(WINED3D_RS_SRCBLEND);
3776 D3DSTATE_TO_STR(WINED3D_RS_DESTBLEND);
3777 D3DSTATE_TO_STR(WINED3D_RS_CULLMODE);
3778 D3DSTATE_TO_STR(WINED3D_RS_ZFUNC);
3779 D3DSTATE_TO_STR(WINED3D_RS_ALPHAREF);
3780 D3DSTATE_TO_STR(WINED3D_RS_ALPHAFUNC);
3781 D3DSTATE_TO_STR(WINED3D_RS_DITHERENABLE);
3782 D3DSTATE_TO_STR(WINED3D_RS_ALPHABLENDENABLE);
3783 D3DSTATE_TO_STR(WINED3D_RS_FOGENABLE);
3784 D3DSTATE_TO_STR(WINED3D_RS_SPECULARENABLE);
3785 D3DSTATE_TO_STR(WINED3D_RS_ZVISIBLE);
3786 D3DSTATE_TO_STR(WINED3D_RS_SUBPIXEL);
3787 D3DSTATE_TO_STR(WINED3D_RS_SUBPIXELX);
3788 D3DSTATE_TO_STR(WINED3D_RS_STIPPLEDALPHA);
3789 D3DSTATE_TO_STR(WINED3D_RS_FOGCOLOR);
3790 D3DSTATE_TO_STR(WINED3D_RS_FOGTABLEMODE);
3791 D3DSTATE_TO_STR(WINED3D_RS_FOGSTART);
3792 D3DSTATE_TO_STR(WINED3D_RS_FOGEND);
3793 D3DSTATE_TO_STR(WINED3D_RS_FOGDENSITY);
3794 D3DSTATE_TO_STR(WINED3D_RS_STIPPLEENABLE);
3795 D3DSTATE_TO_STR(WINED3D_RS_EDGEANTIALIAS);
3796 D3DSTATE_TO_STR(WINED3D_RS_COLORKEYENABLE);
3797 D3DSTATE_TO_STR(WINED3D_RS_MIPMAPLODBIAS);
3798 D3DSTATE_TO_STR(WINED3D_RS_RANGEFOGENABLE);
3799 D3DSTATE_TO_STR(WINED3D_RS_ANISOTROPY);
3800 D3DSTATE_TO_STR(WINED3D_RS_FLUSHBATCH);
3801 D3DSTATE_TO_STR(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT);
3802 D3DSTATE_TO_STR(WINED3D_RS_STENCILENABLE);
3803 D3DSTATE_TO_STR(WINED3D_RS_STENCILFAIL);
3804 D3DSTATE_TO_STR(WINED3D_RS_STENCILZFAIL);
3805 D3DSTATE_TO_STR(WINED3D_RS_STENCILPASS);
3806 D3DSTATE_TO_STR(WINED3D_RS_STENCILFUNC);
3807 D3DSTATE_TO_STR(WINED3D_RS_STENCILREF);
3808 D3DSTATE_TO_STR(WINED3D_RS_STENCILMASK);
3809 D3DSTATE_TO_STR(WINED3D_RS_STENCILWRITEMASK);
3810 D3DSTATE_TO_STR(WINED3D_RS_TEXTUREFACTOR);
3811 D3DSTATE_TO_STR(WINED3D_RS_WRAP0);
3812 D3DSTATE_TO_STR(WINED3D_RS_WRAP1);
3813 D3DSTATE_TO_STR(WINED3D_RS_WRAP2);
3814 D3DSTATE_TO_STR(WINED3D_RS_WRAP3);
3815 D3DSTATE_TO_STR(WINED3D_RS_WRAP4);
3816 D3DSTATE_TO_STR(WINED3D_RS_WRAP5);
3817 D3DSTATE_TO_STR(WINED3D_RS_WRAP6);
3818 D3DSTATE_TO_STR(WINED3D_RS_WRAP7);
3819 D3DSTATE_TO_STR(WINED3D_RS_CLIPPING);
3820 D3DSTATE_TO_STR(WINED3D_RS_LIGHTING);
3821 D3DSTATE_TO_STR(WINED3D_RS_EXTENTS);
3822 D3DSTATE_TO_STR(WINED3D_RS_AMBIENT);
3823 D3DSTATE_TO_STR(WINED3D_RS_FOGVERTEXMODE);
3824 D3DSTATE_TO_STR(WINED3D_RS_COLORVERTEX);
3825 D3DSTATE_TO_STR(WINED3D_RS_LOCALVIEWER);
3826 D3DSTATE_TO_STR(WINED3D_RS_NORMALIZENORMALS);
3827 D3DSTATE_TO_STR(WINED3D_RS_COLORKEYBLENDENABLE);
3828 D3DSTATE_TO_STR(WINED3D_RS_DIFFUSEMATERIALSOURCE);
3829 D3DSTATE_TO_STR(WINED3D_RS_SPECULARMATERIALSOURCE);
3830 D3DSTATE_TO_STR(WINED3D_RS_AMBIENTMATERIALSOURCE);
3831 D3DSTATE_TO_STR(WINED3D_RS_EMISSIVEMATERIALSOURCE);
3832 D3DSTATE_TO_STR(WINED3D_RS_VERTEXBLEND);
3833 D3DSTATE_TO_STR(WINED3D_RS_CLIPPLANEENABLE);
3834 D3DSTATE_TO_STR(WINED3D_RS_SOFTWAREVERTEXPROCESSING);
3835 D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE);
3836 D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE_MIN);
3837 D3DSTATE_TO_STR(WINED3D_RS_POINTSPRITEENABLE);
3838 D3DSTATE_TO_STR(WINED3D_RS_POINTSCALEENABLE);
3839 D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_A);
3840 D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_B);
3841 D3DSTATE_TO_STR(WINED3D_RS_POINTSCALE_C);
3842 D3DSTATE_TO_STR(WINED3D_RS_MULTISAMPLEANTIALIAS);
3843 D3DSTATE_TO_STR(WINED3D_RS_MULTISAMPLEMASK);
3844 D3DSTATE_TO_STR(WINED3D_RS_PATCHEDGESTYLE);
3845 D3DSTATE_TO_STR(WINED3D_RS_PATCHSEGMENTS);
3846 D3DSTATE_TO_STR(WINED3D_RS_DEBUGMONITORTOKEN);
3847 D3DSTATE_TO_STR(WINED3D_RS_POINTSIZE_MAX);
3848 D3DSTATE_TO_STR(WINED3D_RS_INDEXEDVERTEXBLENDENABLE);
3849 D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE);
3850 D3DSTATE_TO_STR(WINED3D_RS_TWEENFACTOR);
3851 D3DSTATE_TO_STR(WINED3D_RS_BLENDOP);
3852 D3DSTATE_TO_STR(WINED3D_RS_POSITIONDEGREE);
3853 D3DSTATE_TO_STR(WINED3D_RS_NORMALDEGREE);
3854 D3DSTATE_TO_STR(WINED3D_RS_SCISSORTESTENABLE);
3855 D3DSTATE_TO_STR(WINED3D_RS_SLOPESCALEDEPTHBIAS);
3856 D3DSTATE_TO_STR(WINED3D_RS_ANTIALIASEDLINEENABLE);
3857 D3DSTATE_TO_STR(WINED3D_RS_MINTESSELLATIONLEVEL);
3858 D3DSTATE_TO_STR(WINED3D_RS_MAXTESSELLATIONLEVEL);
3859 D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_X);
3860 D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_Y);
3861 D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_Z);
3862 D3DSTATE_TO_STR(WINED3D_RS_ADAPTIVETESS_W);
3863 D3DSTATE_TO_STR(WINED3D_RS_ENABLEADAPTIVETESSELLATION);
3864 D3DSTATE_TO_STR(WINED3D_RS_TWOSIDEDSTENCILMODE);
3865 D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILFAIL);
3866 D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILZFAIL);
3867 D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILPASS);
3868 D3DSTATE_TO_STR(WINED3D_RS_CCW_STENCILFUNC);
3869 D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE1);
3870 D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE2);
3871 D3DSTATE_TO_STR(WINED3D_RS_COLORWRITEENABLE3);
3872 D3DSTATE_TO_STR(WINED3D_RS_BLENDFACTOR);
3873 D3DSTATE_TO_STR(WINED3D_RS_SRGBWRITEENABLE);
3874 D3DSTATE_TO_STR(WINED3D_RS_DEPTHBIAS);
3875 D3DSTATE_TO_STR(WINED3D_RS_WRAP8);
3876 D3DSTATE_TO_STR(WINED3D_RS_WRAP9);
3877 D3DSTATE_TO_STR(WINED3D_RS_WRAP10);
3878 D3DSTATE_TO_STR(WINED3D_RS_WRAP11);
3879 D3DSTATE_TO_STR(WINED3D_RS_WRAP12);
3880 D3DSTATE_TO_STR(WINED3D_RS_WRAP13);
3881 D3DSTATE_TO_STR(WINED3D_RS_WRAP14);
3882 D3DSTATE_TO_STR(WINED3D_RS_WRAP15);
3883 D3DSTATE_TO_STR(WINED3D_RS_SEPARATEALPHABLENDENABLE);
3884 D3DSTATE_TO_STR(WINED3D_RS_SRCBLENDALPHA);
3885 D3DSTATE_TO_STR(WINED3D_RS_DESTBLENDALPHA);
3886 D3DSTATE_TO_STR(WINED3D_RS_BLENDOPALPHA);
3887 #undef D3DSTATE_TO_STR
3888 default:
3889 FIXME("Unrecognized %u render state!\n", state);
3890 return "unrecognized";
3891 }
3892 }
3893
3894 const char *debug_d3dsamplerstate(enum wined3d_sampler_state state)
3895 {
3896 switch (state)
3897 {
3898 #define D3DSTATE_TO_STR(u) case u: return #u
3899 D3DSTATE_TO_STR(WINED3D_SAMP_BORDER_COLOR);
3900 D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_U);
3901 D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_V);
3902 D3DSTATE_TO_STR(WINED3D_SAMP_ADDRESS_W);
3903 D3DSTATE_TO_STR(WINED3D_SAMP_MAG_FILTER);
3904 D3DSTATE_TO_STR(WINED3D_SAMP_MIN_FILTER);
3905 D3DSTATE_TO_STR(WINED3D_SAMP_MIP_FILTER);
3906 D3DSTATE_TO_STR(WINED3D_SAMP_MIPMAP_LOD_BIAS);
3907 D3DSTATE_TO_STR(WINED3D_SAMP_MAX_MIP_LEVEL);
3908 D3DSTATE_TO_STR(WINED3D_SAMP_MAX_ANISOTROPY);
3909 D3DSTATE_TO_STR(WINED3D_SAMP_SRGB_TEXTURE);
3910 D3DSTATE_TO_STR(WINED3D_SAMP_ELEMENT_INDEX);
3911 D3DSTATE_TO_STR(WINED3D_SAMP_DMAP_OFFSET);
3912 #undef D3DSTATE_TO_STR
3913 default:
3914 FIXME("Unrecognized %u sampler state!\n", state);
3915 return "unrecognized";
3916 }
3917 }
3918
3919 const char *debug_d3dtexturefiltertype(enum wined3d_texture_filter_type filter_type)
3920 {
3921 switch (filter_type)
3922 {
3923 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
3924 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_NONE);
3925 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_POINT);
3926 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_LINEAR);
3927 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_ANISOTROPIC);
3928 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_FLAT_CUBIC);
3929 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_GAUSSIAN_CUBIC);
3930 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_PYRAMIDAL_QUAD);
3931 D3DTEXTUREFILTERTYPE_TO_STR(WINED3D_TEXF_GAUSSIAN_QUAD);
3932 #undef D3DTEXTUREFILTERTYPE_TO_STR
3933 default:
3934 FIXME("Unrecognized texture filter type 0x%08x.\n", filter_type);
3935 return "unrecognized";
3936 }
3937 }
3938
3939 const char *debug_d3dtexturestate(enum wined3d_texture_stage_state state)
3940 {
3941 switch (state)
3942 {
3943 #define D3DSTATE_TO_STR(u) case u: return #u
3944 D3DSTATE_TO_STR(WINED3D_TSS_COLOR_OP);
3945 D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG1);
3946 D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG2);
3947 D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_OP);
3948 D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG1);
3949 D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG2);
3950 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT00);
3951 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT01);
3952 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT10);
3953 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_MAT11);
3954 D3DSTATE_TO_STR(WINED3D_TSS_TEXCOORD_INDEX);
3955 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_LSCALE);
3956 D3DSTATE_TO_STR(WINED3D_TSS_BUMPENV_LOFFSET);
3957 D3DSTATE_TO_STR(WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS);
3958 D3DSTATE_TO_STR(WINED3D_TSS_COLOR_ARG0);
3959 D3DSTATE_TO_STR(WINED3D_TSS_ALPHA_ARG0);
3960 D3DSTATE_TO_STR(WINED3D_TSS_RESULT_ARG);
3961 D3DSTATE_TO_STR(WINED3D_TSS_CONSTANT);
3962 #undef D3DSTATE_TO_STR
3963 default:
3964 FIXME("Unrecognized %u texture state!\n", state);
3965 return "unrecognized";
3966 }
3967 }
3968
3969 const char *debug_d3dtop(enum wined3d_texture_op d3dtop)
3970 {
3971 switch (d3dtop)
3972 {
3973 #define D3DTOP_TO_STR(u) case u: return #u
3974 D3DTOP_TO_STR(WINED3D_TOP_DISABLE);
3975 D3DTOP_TO_STR(WINED3D_TOP_SELECT_ARG1);
3976 D3DTOP_TO_STR(WINED3D_TOP_SELECT_ARG2);
3977 D3DTOP_TO_STR(WINED3D_TOP_MODULATE);
3978 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_2X);
3979 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_4X);
3980 D3DTOP_TO_STR(WINED3D_TOP_ADD);
3981 D3DTOP_TO_STR(WINED3D_TOP_ADD_SIGNED);
3982 D3DTOP_TO_STR(WINED3D_TOP_ADD_SIGNED_2X);
3983 D3DTOP_TO_STR(WINED3D_TOP_SUBTRACT);
3984 D3DTOP_TO_STR(WINED3D_TOP_ADD_SMOOTH);
3985 D3DTOP_TO_STR(WINED3D_TOP_BLEND_DIFFUSE_ALPHA);
3986 D3DTOP_TO_STR(WINED3D_TOP_BLEND_TEXTURE_ALPHA);
3987 D3DTOP_TO_STR(WINED3D_TOP_BLEND_FACTOR_ALPHA);
3988 D3DTOP_TO_STR(WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM);
3989 D3DTOP_TO_STR(WINED3D_TOP_BLEND_CURRENT_ALPHA);
3990 D3DTOP_TO_STR(WINED3D_TOP_PREMODULATE);
3991 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR);
3992 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA);
3993 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR);
3994 D3DTOP_TO_STR(WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA);
3995 D3DTOP_TO_STR(WINED3D_TOP_BUMPENVMAP);
3996 D3DTOP_TO_STR(WINED3D_TOP_BUMPENVMAP_LUMINANCE);
3997 D3DTOP_TO_STR(WINED3D_TOP_DOTPRODUCT3);
3998 D3DTOP_TO_STR(WINED3D_TOP_MULTIPLY_ADD);
3999 D3DTOP_TO_STR(WINED3D_TOP_LERP);
4000 #undef D3DTOP_TO_STR
4001 default:
4002 FIXME("Unrecognized texture op %#x.\n", d3dtop);
4003 return "unrecognized";
4004 }
4005 }
4006
4007 const char *debug_d3dtstype(enum wined3d_transform_state tstype)
4008 {
4009 switch (tstype)
4010 {
4011 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
4012 TSTYPE_TO_STR(WINED3D_TS_VIEW);
4013 TSTYPE_TO_STR(WINED3D_TS_PROJECTION);
4014 TSTYPE_TO_STR(WINED3D_TS_TEXTURE0);
4015 TSTYPE_TO_STR(WINED3D_TS_TEXTURE1);
4016 TSTYPE_TO_STR(WINED3D_TS_TEXTURE2);
4017 TSTYPE_TO_STR(WINED3D_TS_TEXTURE3);
4018 TSTYPE_TO_STR(WINED3D_TS_TEXTURE4);
4019 TSTYPE_TO_STR(WINED3D_TS_TEXTURE5);
4020 TSTYPE_TO_STR(WINED3D_TS_TEXTURE6);
4021 TSTYPE_TO_STR(WINED3D_TS_TEXTURE7);
4022 TSTYPE_TO_STR(WINED3D_TS_WORLD_MATRIX(0));
4023 TSTYPE_TO_STR(WINED3D_TS_WORLD_MATRIX(1));
4024 TSTYPE_TO_STR(WINED3D_TS_WORLD_MATRIX(2));
4025 TSTYPE_TO_STR(WINED3D_TS_WORLD_MATRIX(3));
4026 #undef TSTYPE_TO_STR
4027 default:
4028 if (tstype > 256 && tstype < 512)
4029 {
4030 FIXME("WINED3D_TS_WORLD_MATRIX(%u). 1..255 not currently supported.\n", tstype);
4031 return ("WINED3D_TS_WORLD_MATRIX > 0");
4032 }
4033 FIXME("Unrecognized transform state %#x.\n", tstype);
4034 return "unrecognized";
4035 }
4036 }
4037
4038 const char *debug_shader_type(enum wined3d_shader_type type)
4039 {
4040 switch(type)
4041 {
4042 #define WINED3D_TO_STR(type) case type: return #type
4043 WINED3D_TO_STR(WINED3D_SHADER_TYPE_PIXEL);
4044 WINED3D_TO_STR(WINED3D_SHADER_TYPE_VERTEX);
4045 WINED3D_TO_STR(WINED3D_SHADER_TYPE_GEOMETRY);
4046 WINED3D_TO_STR(WINED3D_SHADER_TYPE_HULL);
4047 WINED3D_TO_STR(WINED3D_SHADER_TYPE_DOMAIN);
4048 #undef WINED3D_TO_STR
4049 default:
4050 FIXME("Unrecognized shader type %#x.\n", type);
4051 return "unrecognized";
4052 }
4053 }
4054
4055 const char *debug_d3dstate(DWORD state)
4056 {
4057 if (STATE_IS_RENDER(state))
4058 return wine_dbg_sprintf("STATE_RENDER(%s)", debug_d3drenderstate(state - STATE_RENDER(0)));
4059 if (STATE_IS_TEXTURESTAGE(state))
4060 {
4061 DWORD texture_stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
4062 DWORD texture_state = state - STATE_TEXTURESTAGE(texture_stage, 0);
4063 return wine_dbg_sprintf("STATE_TEXTURESTAGE(%#x, %s)",
4064 texture_stage, debug_d3dtexturestate(texture_state));
4065 }
4066 if (STATE_IS_SAMPLER(state))
4067 return wine_dbg_sprintf("STATE_SAMPLER(%#x)", state - STATE_SAMPLER(0));
4068 if (STATE_IS_SHADER(state))
4069 return wine_dbg_sprintf("STATE_SHADER(%s)", debug_shader_type(state - STATE_SHADER(0)));
4070 if (STATE_IS_CONSTANT_BUFFER(state))
4071 return wine_dbg_sprintf("STATE_CONSTANT_BUFFER(%s)", debug_shader_type(state - STATE_CONSTANT_BUFFER(0)));
4072 if (STATE_IS_SHADER_RESOURCE_BINDING(state))
4073 return "STATE_SHADER_RESOURCE_BINDING";
4074 if (STATE_IS_TRANSFORM(state))
4075 return wine_dbg_sprintf("STATE_TRANSFORM(%s)", debug_d3dtstype(state - STATE_TRANSFORM(0)));
4076 if (STATE_IS_STREAMSRC(state))
4077 return "STATE_STREAMSRC";
4078 if (STATE_IS_INDEXBUFFER(state))
4079 return "STATE_INDEXBUFFER";
4080 if (STATE_IS_VDECL(state))
4081 return "STATE_VDECL";
4082 if (STATE_IS_VIEWPORT(state))
4083 return "STATE_VIEWPORT";
4084 if (STATE_IS_LIGHT_TYPE(state))
4085 return "STATE_LIGHT_TYPE";
4086 if (STATE_IS_ACTIVELIGHT(state))
4087 return wine_dbg_sprintf("STATE_ACTIVELIGHT(%#x)", state - STATE_ACTIVELIGHT(0));
4088 if (STATE_IS_SCISSORRECT(state))
4089 return "STATE_SCISSORRECT";
4090 if (STATE_IS_CLIPPLANE(state))
4091 return wine_dbg_sprintf("STATE_CLIPPLANE(%#x)", state - STATE_CLIPPLANE(0));
4092 if (STATE_IS_MATERIAL(state))
4093 return "STATE_MATERIAL";
4094 if (STATE_IS_FRONTFACE(state))
4095 return "STATE_FRONTFACE";
4096 if (STATE_IS_POINTSPRITECOORDORIGIN(state))
4097 return "STATE_POINTSPRITECOORDORIGIN";
4098 if (STATE_IS_BASEVERTEXINDEX(state))
4099 return "STATE_BASEVERTEXINDEX";
4100 if (STATE_IS_FRAMEBUFFER(state))
4101 return "STATE_FRAMEBUFFER";
4102 if (STATE_IS_POINT_ENABLE(state))
4103 return "STATE_POINT_ENABLE";
4104 if (STATE_IS_COLOR_KEY(state))
4105 return "STATE_COLOR_KEY";
4106
4107 return wine_dbg_sprintf("UNKNOWN_STATE(%#x)", state);
4108 }
4109
4110 const char *debug_d3dpool(enum wined3d_pool pool)
4111 {
4112 switch (pool)
4113 {
4114 #define POOL_TO_STR(p) case p: return #p
4115 POOL_TO_STR(WINED3D_POOL_DEFAULT);
4116 POOL_TO_STR(WINED3D_POOL_MANAGED);
4117 POOL_TO_STR(WINED3D_POOL_SYSTEM_MEM);
4118 POOL_TO_STR(WINED3D_POOL_SCRATCH);
4119 #undef POOL_TO_STR
4120 default:
4121 FIXME("Unrecognized pool %#x.\n", pool);
4122 return "unrecognized";
4123 }
4124 }
4125
4126 const char *debug_fboattachment(GLenum attachment)
4127 {
4128 switch(attachment)
4129 {
4130 #define WINED3D_TO_STR(x) case x: return #x
4131 WINED3D_TO_STR(GL_COLOR_ATTACHMENT0);
4132 WINED3D_TO_STR(GL_COLOR_ATTACHMENT1);
4133 WINED3D_TO_STR(GL_COLOR_ATTACHMENT2);
4134 WINED3D_TO_STR(GL_COLOR_ATTACHMENT3);
4135 WINED3D_TO_STR(GL_COLOR_ATTACHMENT4);
4136 WINED3D_TO_STR(GL_COLOR_ATTACHMENT5);
4137 WINED3D_TO_STR(GL_COLOR_ATTACHMENT6);
4138 WINED3D_TO_STR(GL_COLOR_ATTACHMENT7);
4139 WINED3D_TO_STR(GL_COLOR_ATTACHMENT8);
4140 WINED3D_TO_STR(GL_COLOR_ATTACHMENT9);
4141 WINED3D_TO_STR(GL_COLOR_ATTACHMENT10);
4142 WINED3D_TO_STR(GL_COLOR_ATTACHMENT11);
4143 WINED3D_TO_STR(GL_COLOR_ATTACHMENT12);
4144 WINED3D_TO_STR(GL_COLOR_ATTACHMENT13);
4145 WINED3D_TO_STR(GL_COLOR_ATTACHMENT14);
4146 WINED3D_TO_STR(GL_COLOR_ATTACHMENT15);
4147 WINED3D_TO_STR(GL_DEPTH_ATTACHMENT);
4148 WINED3D_TO_STR(GL_STENCIL_ATTACHMENT);
4149 #undef WINED3D_TO_STR
4150 default:
4151 return wine_dbg_sprintf("Unknown FBO attachment %#x", attachment);
4152 }
4153 }
4154
4155 const char *debug_fbostatus(GLenum status) {
4156 switch(status) {
4157 #define FBOSTATUS_TO_STR(u) case u: return #u
4158 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE);
4159 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
4160 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
4161 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
4162 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
4163 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
4164 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
4165 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
4166 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS);
4167 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB);
4168 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED);
4169 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNDEFINED);
4170 #undef FBOSTATUS_TO_STR
4171 default:
4172 FIXME("Unrecognized FBO status 0x%08x.\n", status);
4173 return "unrecognized";
4174 }
4175 }
4176
4177 const char *debug_glerror(GLenum error) {
4178 switch(error) {
4179 #define GLERROR_TO_STR(u) case u: return #u
4180 GLERROR_TO_STR(GL_NO_ERROR);
4181 GLERROR_TO_STR(GL_INVALID_ENUM);
4182 GLERROR_TO_STR(GL_INVALID_VALUE);
4183 GLERROR_TO_STR(GL_INVALID_OPERATION);
4184 GLERROR_TO_STR(GL_STACK_OVERFLOW);
4185 GLERROR_TO_STR(GL_STACK_UNDERFLOW);
4186 GLERROR_TO_STR(GL_OUT_OF_MEMORY);
4187 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION);
4188 #undef GLERROR_TO_STR
4189 default:
4190 FIXME("Unrecognized GL error 0x%08x.\n", error);
4191 return "unrecognized";
4192 }
4193 }
4194
4195 static const char *debug_fixup_channel_source(enum fixup_channel_source source)
4196 {
4197 switch(source)
4198 {
4199 #define WINED3D_TO_STR(x) case x: return #x
4200 WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
4201 WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
4202 WINED3D_TO_STR(CHANNEL_SOURCE_X);
4203 WINED3D_TO_STR(CHANNEL_SOURCE_Y);
4204 WINED3D_TO_STR(CHANNEL_SOURCE_Z);
4205 WINED3D_TO_STR(CHANNEL_SOURCE_W);
4206 WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX0);
4207 WINED3D_TO_STR(CHANNEL_SOURCE_COMPLEX1);
4208 #undef WINED3D_TO_STR
4209 default:
4210 FIXME("Unrecognized fixup_channel_source %#x\n", source);
4211 return "unrecognized";
4212 }
4213 }
4214
4215 static const char *debug_complex_fixup(enum complex_fixup fixup)
4216 {
4217 switch(fixup)
4218 {
4219 #define WINED3D_TO_STR(x) case x: return #x
4220 WINED3D_TO_STR(COMPLEX_FIXUP_YUY2);
4221 WINED3D_TO_STR(COMPLEX_FIXUP_UYVY);
4222 WINED3D_TO_STR(COMPLEX_FIXUP_YV12);
4223 WINED3D_TO_STR(COMPLEX_FIXUP_NV12);
4224 WINED3D_TO_STR(COMPLEX_FIXUP_P8);
4225 #undef WINED3D_TO_STR
4226 default:
4227 FIXME("Unrecognized complex fixup %#x\n", fixup);
4228 return "unrecognized";
4229 }
4230 }
4231
4232 void dump_color_fixup_desc(struct color_fixup_desc fixup)
4233 {
4234 if (is_complex_fixup(fixup))
4235 {
4236 TRACE("\tComplex: %s\n", debug_complex_fixup(get_complex_fixup(fixup)));
4237 return;
4238 }
4239
4240 TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
4241 TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
4242 TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
4243 TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
4244 }
4245
4246 BOOL is_invalid_op(const struct wined3d_state *state, int stage,
4247 enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3)
4248 {
4249 if (op == WINED3D_TOP_DISABLE)
4250 return FALSE;
4251 if (state->textures[stage])
4252 return FALSE;
4253
4254 if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
4255 && op != WINED3D_TOP_SELECT_ARG2)
4256 return TRUE;
4257 if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
4258 && op != WINED3D_TOP_SELECT_ARG1)
4259 return TRUE;
4260 if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
4261 && (op == WINED3D_TOP_MULTIPLY_ADD || op == WINED3D_TOP_LERP))
4262 return TRUE;
4263
4264 return FALSE;
4265 }
4266
4267 void get_identity_matrix(struct wined3d_matrix *mat)
4268 {
4269 static const struct wined3d_matrix identity =
4270 {
4271 1.0f, 0.0f, 0.0f, 0.0f,
4272 0.0f, 1.0f, 0.0f, 0.0f,
4273 0.0f, 0.0f, 1.0f, 0.0f,
4274 0.0f, 0.0f, 0.0f, 1.0f,
4275 };
4276
4277 *mat = identity;
4278 }
4279
4280 void get_modelview_matrix(const struct wined3d_context *context, const struct wined3d_state *state,
4281 unsigned int index, struct wined3d_matrix *mat)
4282 {
4283 if (context->last_was_rhw)
4284 get_identity_matrix(mat);
4285 else
4286 multiply_matrix(mat, &state->transforms[WINED3D_TS_VIEW], &state->transforms[WINED3D_TS_WORLD_MATRIX(index)]);
4287 }
4288
4289 void get_projection_matrix(const struct wined3d_context *context, const struct wined3d_state *state,
4290 struct wined3d_matrix *mat)
4291 {
4292 float center_offset;
4293
4294 /* There are a couple of additional things we have to take into account
4295 * here besides the projection transformation itself:
4296 * - We need to flip along the y-axis in case of offscreen rendering.
4297 * - OpenGL Z range is {-Wc,...,Wc} while D3D Z range is {0,...,Wc}.
4298 * - D3D coordinates refer to pixel centers while GL coordinates refer
4299 * to pixel corners.
4300 * - D3D has a top-left filling convention. We need to maintain this
4301 * even after the y-flip mentioned above.
4302 * In order to handle the last two points, we translate by
4303 * (63.0 / 128.0) / VPw and (63.0 / 128.0) / VPh. This is equivalent to
4304 * translating slightly less than half a pixel. We want the difference to
4305 * be large enough that it doesn't get lost due to rounding inside the
4306 * driver, but small enough to prevent it from interfering with any
4307 * anti-aliasing. */
4308
4309 if (context->swapchain->device->wined3d->flags & WINED3D_PIXEL_CENTER_INTEGER)
4310 center_offset = 63.0f / 64.0f;
4311 else
4312 center_offset = -1.0f / 64.0f;
4313
4314 if (context->last_was_rhw)
4315 {
4316 /* Transform D3D RHW coordinates to OpenGL clip coordinates. */
4317 float x = state->viewport.x;
4318 float y = state->viewport.y;
4319 float w = state->viewport.width;
4320 float h = state->viewport.height;
4321 float x_scale = 2.0f / w;
4322 float x_offset = (center_offset - (2.0f * x) - w) / w;
4323 float y_scale = context->render_offscreen ? 2.0f / h : 2.0f / -h;
4324 float y_offset = context->render_offscreen
4325 ? (center_offset - (2.0f * y) - h) / h
4326 : (center_offset - (2.0f * y) - h) / -h;
4327 enum wined3d_depth_buffer_type zenable = state->fb->depth_stencil ?
4328 state->render_states[WINED3D_RS_ZENABLE] : WINED3D_ZB_FALSE;
4329 float z_scale = zenable ? 2.0f : 0.0f;
4330 float z_offset = zenable ? -1.0f : 0.0f;
4331 const struct wined3d_matrix projection =
4332 {
4333 x_scale, 0.0f, 0.0f, 0.0f,
4334 0.0f, y_scale, 0.0f, 0.0f,
4335 0.0f, 0.0f, z_scale, 0.0f,
4336 x_offset, y_offset, z_offset, 1.0f,
4337 };
4338
4339 *mat = projection;
4340 }
4341 else
4342 {
4343 float y_scale = context->render_offscreen ? -1.0f : 1.0f;
4344 float x_offset = center_offset / state->viewport.width;
4345 float y_offset = context->render_offscreen
4346 ? center_offset / state->viewport.height
4347 : -center_offset / state->viewport.height;
4348 const struct wined3d_matrix projection =
4349 {
4350 1.0f, 0.0f, 0.0f, 0.0f,
4351 0.0f, y_scale, 0.0f, 0.0f,
4352 0.0f, 0.0f, 2.0f, 0.0f,
4353 x_offset, y_offset, -1.0f, 1.0f,
4354 };
4355
4356 multiply_matrix(mat, &projection, &state->transforms[WINED3D_TS_PROJECTION]);
4357 }
4358 }
4359
4360 /* Setup this textures matrix according to the texture flags. */
4361 static void compute_texture_matrix(const struct wined3d_gl_info *gl_info, const struct wined3d_matrix *matrix,
4362 DWORD flags, BOOL calculated_coords, BOOL transformed, enum wined3d_format_id format_id,
4363 BOOL ffp_proj_control, struct wined3d_matrix *out_matrix)
4364 {
4365 struct wined3d_matrix mat;
4366
4367 if (flags == WINED3D_TTFF_DISABLE || flags == WINED3D_TTFF_COUNT1 || transformed)
4368 {
4369 get_identity_matrix(out_matrix);
4370 return;
4371 }
4372
4373 if (flags == (WINED3D_TTFF_COUNT1 | WINED3D_TTFF_PROJECTED))
4374 {
4375 ERR("Invalid texture transform flags: WINED3D_TTFF_COUNT1 | WINED3D_TTFF_PROJECTED.\n");
4376 return;
4377 }
4378
4379 mat = *matrix;
4380
4381 if (flags & WINED3D_TTFF_PROJECTED)
4382 {
4383 if (!ffp_proj_control)
4384 {
4385 switch (flags & ~WINED3D_TTFF_PROJECTED)
4386 {
4387 case WINED3D_TTFF_COUNT2:
4388 mat._14 = mat._12;
4389 mat._24 = mat._22;
4390 mat._34 = mat._32;
4391 mat._44 = mat._42;
4392 mat._12 = mat._22 = mat._32 = mat._42 = 0.0f;
4393 break;
4394 case WINED3D_TTFF_COUNT3:
4395 mat._14 = mat._13;
4396 mat._24 = mat._23;
4397 mat._34 = mat._33;
4398 mat._44 = mat._43;
4399 mat._13 = mat._23 = mat._33 = mat._43 = 0.0f;
4400 break;
4401 }
4402 }
4403 }
4404 else
4405 {
4406 /* Under Direct3D the R/Z coord can be used for translation, under
4407 * OpenGL we use the Q coord instead. */
4408 if (!calculated_coords)
4409 {
4410 switch (format_id)
4411 {
4412 /* Direct3D passes the default 1.0 in the 2nd coord, while GL
4413 * passes it in the 4th. Swap 2nd and 4th coord. No need to
4414 * store the value of mat._41 in mat._21 because the input
4415 * value to the transformation will be 0, so the matrix value
4416 * is irrelevant. */
4417 case WINED3DFMT_R32_FLOAT:
4418 mat._41 = mat._21;
4419 mat._42 = mat._22;
4420 mat._43 = mat._23;
4421 mat._44 = mat._24;
4422 break;
4423 /* See above, just 3rd and 4th coord. */
4424 case WINED3DFMT_R32G32_FLOAT:
4425 mat._41 = mat._31;
4426 mat._42 = mat._32;
4427 mat._43 = mat._33;
4428 mat._44 = mat._34;
4429 break;
4430 case WINED3DFMT_R32G32B32_FLOAT: /* Opengl defaults match dx defaults */
4431 case WINED3DFMT_R32G32B32A32_FLOAT: /* No defaults apply, all app defined */
4432
4433 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
4434 * into a bad place. The division elimination below will apply to make sure the
4435 * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
4436 */
4437 case WINED3DFMT_UNKNOWN: /* No texture coords, 0/0/0/1 defaults are passed */
4438 break;
4439 default:
4440 FIXME("Unexpected fixed function texture coord input\n");
4441 }
4442 }
4443 if (!ffp_proj_control)
4444 {
4445 switch (flags & ~WINED3D_TTFF_PROJECTED)
4446 {
4447 /* case WINED3D_TTFF_COUNT1: Won't ever get here. */
4448 case WINED3D_TTFF_COUNT2:
4449 mat._13 = mat._23 = mat._33 = mat._43 = 0.0f;
4450 /* OpenGL divides the first 3 vertex coordinates by the 4th by
4451 * default, which is essentially the same as D3DTTFF_PROJECTED.
4452 * Make sure that the 4th coordinate evaluates to 1.0 to
4453 * eliminate that.
4454 *
4455 * If the fixed function pipeline is used, the 4th value
4456 * remains unused, so there is no danger in doing this. With
4457 * vertex shaders we have a problem. Should an application hit
4458 * that problem, the code here would have to check for pixel
4459 * shaders, and the shader has to undo the default GL divide.
4460 *
4461 * A more serious problem occurs if the application passes 4
4462 * coordinates in, and the 4th is != 1.0 (OpenGL default).
4463 * This would have to be fixed with immediate mode draws. */
4464 default:
4465 mat._14 = mat._24 = mat._34 = 0.0f; mat._44 = 1.0f;
4466 }
4467 }
4468 }
4469
4470 *out_matrix = mat;
4471 }
4472
4473 void get_texture_matrix(const struct wined3d_context *context, const struct wined3d_state *state,
4474 unsigned int tex, struct wined3d_matrix *mat)
4475 {
4476 const struct wined3d_device *device = context->swapchain->device;
4477 const struct wined3d_gl_info *gl_info = context->gl_info;
4478 BOOL generated = (state->texture_states[tex][WINED3D_TSS_TEXCOORD_INDEX] & 0xffff0000)
4479 != WINED3DTSS_TCI_PASSTHRU;
4480 unsigned int coord_idx = min(state->texture_states[tex][WINED3D_TSS_TEXCOORD_INDEX & 0x0000ffff],
4481 MAX_TEXTURES - 1);
4482
4483 compute_texture_matrix(gl_info, &state->transforms[WINED3D_TS_TEXTURE0 + tex],
4484 state->texture_states[tex][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS],
4485 generated, context->last_was_rhw,
4486 context->stream_info.use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx))
4487 ? context->stream_info.elements[WINED3D_FFP_TEXCOORD0 + coord_idx].format->id
4488 : WINED3DFMT_UNKNOWN,
4489 device->shader_backend->shader_has_ffp_proj_control(device->shader_priv), mat);
4490
4491 if ((context->lastWasPow2Texture & (1u << tex)) && state->textures[tex])
4492 {
4493 if (generated)
4494 FIXME("Non-power-of-two texture being used with generated texture coords.\n");
4495 /* NP2 texcoord fixup is implemented for pixelshaders so only enable the
4496 * fixed-function-pipeline fixup via pow2Matrix when no PS is used. */
4497 if (!use_ps(state))
4498 {
4499 TRACE("Non-power-of-two texture matrix multiply fixup.\n");
4500 multiply_matrix(mat, mat, (struct wined3d_matrix *)state->textures[tex]->pow2_matrix);
4501 }
4502 }
4503 }
4504
4505 void get_pointsize_minmax(const struct wined3d_context *context, const struct wined3d_state *state,
4506 float *out_min, float *out_max)
4507 {
4508 union
4509 {
4510 DWORD d;
4511 float f;
4512 } min, max;
4513
4514 min.d = state->render_states[WINED3D_RS_POINTSIZE_MIN];
4515 max.d = state->render_states[WINED3D_RS_POINTSIZE_MAX];
4516
4517 if (min.f > max.f)
4518 min.f = max.f;
4519
4520 *out_min = min.f;
4521 *out_max = max.f;
4522 }
4523
4524 void get_pointsize(const struct wined3d_context *context, const struct wined3d_state *state,
4525 float *out_pointsize, float *out_att)
4526 {
4527 /* POINTSCALEENABLE controls how point size value is treated. If set to
4528 * true, the point size is scaled with respect to height of viewport.
4529 * When set to false point size is in pixels. */
4530 union
4531 {
4532 DWORD d;
4533 float f;
4534 } pointsize, a, b, c;
4535
4536 out_att[0] = 1.0f;
4537 out_att[1] = 0.0f;
4538 out_att[2] = 0.0f;
4539
4540 pointsize.d = state->render_states[WINED3D_RS_POINTSIZE];
4541 a.d = state->render_states[WINED3D_RS_POINTSCALE_A];
4542 b.d = state->render_states[WINED3D_RS_POINTSCALE_B];
4543 c.d = state->render_states[WINED3D_RS_POINTSCALE_C];
4544
4545 if (state->render_states[WINED3D_RS_POINTSCALEENABLE])
4546 {
4547 float scale_factor = state->viewport.height * state->viewport.height;
4548
4549 out_att[0] = a.f / scale_factor;
4550 out_att[1] = b.f / scale_factor;
4551 out_att[2] = c.f / scale_factor;
4552 }
4553 *out_pointsize = pointsize.f;
4554 }
4555
4556 void get_fog_start_end(const struct wined3d_context *context, const struct wined3d_state *state,
4557 float *start, float *end)
4558 {
4559 union
4560 {
4561 DWORD d;
4562 float f;
4563 } tmpvalue;
4564
4565 switch (context->fog_source)
4566 {
4567 case FOGSOURCE_VS:
4568 *start = 1.0f;
4569 *end = 0.0f;
4570 break;
4571
4572 case FOGSOURCE_COORD:
4573 *start = 255.0f;
4574 *end = 0.0f;
4575 break;
4576
4577 case FOGSOURCE_FFP:
4578 tmpvalue.d = state->render_states[WINED3D_RS_FOGSTART];
4579 *start = tmpvalue.f;
4580 tmpvalue.d = state->render_states[WINED3D_RS_FOGEND];
4581 *end = tmpvalue.f;
4582 /* Special handling for fog_start == fog_end. In d3d with vertex
4583 * fog, everything is fogged. With table fog, everything with
4584 * fog_coord < fog_start is unfogged, and fog_coord > fog_start
4585 * is fogged. Windows drivers disagree when fog_coord == fog_start. */
4586 if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3D_FOG_NONE && *start == *end)
4587 {
4588 *start = -INFINITY;
4589 *end = 0.0f;
4590 }
4591 break;
4592
4593 default:
4594 /* This should not happen, context->fog_source is set in wined3d, not the app. */
4595 ERR("Unexpected fog coordinate source.\n");
4596 *start = 0.0f;
4597 *end = 0.0f;
4598 }
4599 }
4600
4601 /* Note: It's the caller's responsibility to ensure values can be expressed
4602 * in the requested format. UNORM formats for example can only express values
4603 * in the range 0.0f -> 1.0f. */
4604 DWORD wined3d_format_convert_from_float(const struct wined3d_format *format, const struct wined3d_color *color)
4605 {
4606 static const struct
4607 {
4608 enum wined3d_format_id format_id;
4609 float r_mul;
4610 float g_mul;
4611 float b_mul;
4612 float a_mul;
4613 BYTE r_shift;
4614 BYTE g_shift;
4615 BYTE b_shift;
4616 BYTE a_shift;
4617 }
4618 conv[] =
4619 {
4620 {WINED3DFMT_B8G8R8A8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 16, 8, 0, 24},
4621 {WINED3DFMT_B8G8R8X8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 16, 8, 0, 24},
4622 {WINED3DFMT_B8G8R8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 16, 8, 0, 24},
4623 {WINED3DFMT_B5G6R5_UNORM, 31.0f, 63.0f, 31.0f, 0.0f, 11, 5, 0, 0},
4624 {WINED3DFMT_B5G5R5A1_UNORM, 31.0f, 31.0f, 31.0f, 1.0f, 10, 5, 0, 15},
4625 {WINED3DFMT_B5G5R5X1_UNORM, 31.0f, 31.0f, 31.0f, 1.0f, 10, 5, 0, 15},
4626 {WINED3DFMT_R8_UNORM, 255.0f, 0.0f, 0.0f, 0.0f, 0, 0, 0, 0},
4627 {WINED3DFMT_A8_UNORM, 0.0f, 0.0f, 0.0f, 255.0f, 0, 0, 0, 0},
4628 {WINED3DFMT_B4G4R4A4_UNORM, 15.0f, 15.0f, 15.0f, 15.0f, 8, 4, 0, 12},
4629 {WINED3DFMT_B4G4R4X4_UNORM, 15.0f, 15.0f, 15.0f, 15.0f, 8, 4, 0, 12},
4630 {WINED3DFMT_B2G3R3_UNORM, 7.0f, 7.0f, 3.0f, 0.0f, 5, 2, 0, 0},
4631 {WINED3DFMT_R8G8B8A8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 0, 8, 16, 24},
4632 {WINED3DFMT_R8G8B8X8_UNORM, 255.0f, 255.0f, 255.0f, 255.0f, 0, 8, 16, 24},
4633 {WINED3DFMT_B10G10R10A2_UNORM, 1023.0f, 1023.0f, 1023.0f, 3.0f, 20, 10, 0, 30},
4634 {WINED3DFMT_R10G10B10A2_UNORM, 1023.0f, 1023.0f, 1023.0f, 3.0f, 0, 10, 20, 30},
4635 {WINED3DFMT_P8_UINT, 0.0f, 0.0f, 0.0f, 255.0f, 0, 0, 0, 0},
4636 };
4637 unsigned int i;
4638
4639 TRACE("Converting color %s to format %s.\n", debug_color(color), debug_d3dformat(format->id));
4640
4641 for (i = 0; i < sizeof(conv) / sizeof(*conv); ++i)
4642 {
4643 DWORD ret;
4644
4645 if (format->id != conv[i].format_id) continue;
4646
4647 ret = ((DWORD)((color->r * conv[i].r_mul) + 0.5f)) << conv[i].r_shift;
4648 ret |= ((DWORD)((color->g * conv[i].g_mul) + 0.5f)) << conv[i].g_shift;
4649 ret |= ((DWORD)((color->b * conv[i].b_mul) + 0.5f)) << conv[i].b_shift;
4650 ret |= ((DWORD)((color->a * conv[i].a_mul) + 0.5f)) << conv[i].a_shift;
4651
4652 TRACE("Returning 0x%08x.\n", ret);
4653
4654 return ret;
4655 }
4656
4657 FIXME("Conversion for format %s not implemented.\n", debug_d3dformat(format->id));
4658
4659 return 0;
4660 }
4661
4662 static float color_to_float(DWORD color, DWORD size, DWORD offset)
4663 {
4664 DWORD mask = (1u << size) - 1;
4665
4666 if (!size)
4667 return 1.0f;
4668
4669 color >>= offset;
4670 color &= mask;
4671
4672 return (float)color / (float)mask;
4673 }
4674
4675 BOOL wined3d_format_convert_color_to_float(const struct wined3d_format *format,
4676 const struct wined3d_palette *palette, DWORD color, struct wined3d_color *float_color)
4677 {
4678 switch (format->id)
4679 {
4680 case WINED3DFMT_B8G8R8_UNORM:
4681 case WINED3DFMT_B8G8R8A8_UNORM:
4682 case WINED3DFMT_B8G8R8X8_UNORM:
4683 case WINED3DFMT_B5G6R5_UNORM:
4684 case WINED3DFMT_B5G5R5X1_UNORM:
4685 case WINED3DFMT_B5G5R5A1_UNORM:
4686 case WINED3DFMT_B4G4R4A4_UNORM:
4687 case WINED3DFMT_B2G3R3_UNORM:
4688 case WINED3DFMT_R8_UNORM:
4689 case WINED3DFMT_A8_UNORM:
4690 case WINED3DFMT_B2G3R3A8_UNORM:
4691 case WINED3DFMT_B4G4R4X4_UNORM:
4692 case WINED3DFMT_R10G10B10A2_UNORM:
4693 case WINED3DFMT_R10G10B10A2_SNORM:
4694 case WINED3DFMT_R8G8B8A8_UNORM:
4695 case WINED3DFMT_R8G8B8X8_UNORM:
4696 case WINED3DFMT_R16G16_UNORM:
4697 case WINED3DFMT_B10G10R10A2_UNORM:
4698 float_color->r = color_to_float(color, format->red_size, format->red_offset);
4699 float_color->g = color_to_float(color, format->green_size, format->green_offset);
4700 float_color->b = color_to_float(color, format->blue_size, format->blue_offset);
4701 float_color->a = color_to_float(color, format->alpha_size, format->alpha_offset);
4702 return TRUE;
4703
4704 case WINED3DFMT_P8_UINT:
4705 if (palette)
4706 {
4707 float_color->r = palette->colors[color].rgbRed / 255.0f;
4708 float_color->g = palette->colors[color].rgbGreen / 255.0f;
4709 float_color->b = palette->colors[color].rgbBlue / 255.0f;
4710 }
4711 else
4712 {
4713 float_color->r = 0.0f;
4714 float_color->g = 0.0f;
4715 float_color->b = 0.0f;
4716 }
4717 float_color->a = color / 255.0f;
4718 return TRUE;
4719
4720 default:
4721 ERR("Unhandled conversion from %s to floating point.\n", debug_d3dformat(format->id));
4722 return FALSE;
4723 }
4724 }
4725
4726 void wined3d_format_get_float_color_key(const struct wined3d_format *format,
4727 const struct wined3d_color_key *key, struct wined3d_color *float_colors)
4728 {
4729 struct wined3d_color slop;
4730
4731 switch (format->id)
4732 {
4733 case WINED3DFMT_B8G8R8_UNORM:
4734 case WINED3DFMT_B8G8R8A8_UNORM:
4735 case WINED3DFMT_B8G8R8X8_UNORM:
4736 case WINED3DFMT_B5G6R5_UNORM:
4737 case WINED3DFMT_B5G5R5X1_UNORM:
4738 case WINED3DFMT_B5G5R5A1_UNORM:
4739 case WINED3DFMT_B4G4R4A4_UNORM:
4740 case WINED3DFMT_B2G3R3_UNORM:
4741 case WINED3DFMT_R8_UNORM:
4742 case WINED3DFMT_A8_UNORM:
4743 case WINED3DFMT_B2G3R3A8_UNORM:
4744 case WINED3DFMT_B4G4R4X4_UNORM:
4745 case WINED3DFMT_R10G10B10A2_UNORM:
4746 case WINED3DFMT_R10G10B10A2_SNORM:
4747 case WINED3DFMT_R8G8B8A8_UNORM:
4748 case WINED3DFMT_R8G8B8X8_UNORM:
4749 case WINED3DFMT_R16G16_UNORM:
4750 case WINED3DFMT_B10G10R10A2_UNORM:
4751 slop.r = 0.5f / ((1 << format->red_size) - 1);
4752 slop.g = 0.5f / ((1 << format->green_size) - 1);
4753 slop.b = 0.5f / ((1 << format->blue_size) - 1);
4754 slop.a = 0.5f / ((1 << format->alpha_size) - 1);
4755
4756 float_colors[0].r = color_to_float(key->color_space_low_value, format->red_size, format->red_offset)
4757 - slop.r;
4758 float_colors[0].g = color_to_float(key->color_space_low_value, format->green_size, format->green_offset)
4759 - slop.g;
4760 float_colors[0].b = color_to_float(key->color_space_low_value, format->blue_size, format->blue_offset)
4761 - slop.b;
4762 float_colors[0].a = color_to_float(key->color_space_low_value, format->alpha_size, format->alpha_offset)
4763 - slop.a;
4764
4765 float_colors[1].r = color_to_float(key->color_space_high_value, format->red_size, format->red_offset)
4766 + slop.r;
4767 float_colors[1].g = color_to_float(key->color_space_high_value, format->green_size, format->green_offset)
4768 + slop.g;
4769 float_colors[1].b = color_to_float(key->color_space_high_value, format->blue_size, format->blue_offset)
4770 + slop.b;
4771 float_colors[1].a = color_to_float(key->color_space_high_value, format->alpha_size, format->alpha_offset)
4772 + slop.a;
4773 break;
4774
4775 case WINED3DFMT_P8_UINT:
4776 float_colors[0].r = 0.0f;
4777 float_colors[0].g = 0.0f;
4778 float_colors[0].b = 0.0f;
4779 float_colors[0].a = (key->color_space_low_value - 0.5f) / 255.0f;
4780
4781 float_colors[1].r = 0.0f;
4782 float_colors[1].g = 0.0f;
4783 float_colors[1].b = 0.0f;
4784 float_colors[1].a = (key->color_space_high_value + 0.5f) / 255.0f;
4785 break;
4786
4787 default:
4788 ERR("Unhandled color key to float conversion for format %s.\n", debug_d3dformat(format->id));
4789 }
4790 }
4791
4792 /* DirectDraw stuff */
4793 enum wined3d_format_id pixelformat_for_depth(DWORD depth)
4794 {
4795 switch (depth)
4796 {
4797 case 8: return WINED3DFMT_P8_UINT;
4798 case 15: return WINED3DFMT_B5G5R5X1_UNORM;
4799 case 16: return WINED3DFMT_B5G6R5_UNORM;
4800 case 24: return WINED3DFMT_B8G8R8X8_UNORM; /* Robots needs 24bit to be WINED3DFMT_B8G8R8X8_UNORM */
4801 case 32: return WINED3DFMT_B8G8R8X8_UNORM; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return WINED3DFMT_B8G8R8X8_UNORM */
4802 default: return WINED3DFMT_UNKNOWN;
4803 }
4804 }
4805
4806 void multiply_matrix(struct wined3d_matrix *dst, const struct wined3d_matrix *src1, const struct wined3d_matrix *src2)
4807 {
4808 struct wined3d_matrix tmp;
4809
4810 /* Now do the multiplication 'by hand'.
4811 I know that all this could be optimised, but this will be done later :-) */
4812 tmp._11 = (src1->_11 * src2->_11) + (src1->_21 * src2->_12) + (src1->_31 * src2->_13) + (src1->_41 * src2->_14);
4813 tmp._21 = (src1->_11 * src2->_21) + (src1->_21 * src2->_22) + (src1->_31 * src2->_23) + (src1->_41 * src2->_24);
4814 tmp._31 = (src1->_11 * src2->_31) + (src1->_21 * src2->_32) + (src1->_31 * src2->_33) + (src1->_41 * src2->_34);
4815 tmp._41 = (src1->_11 * src2->_41) + (src1->_21 * src2->_42) + (src1->_31 * src2->_43) + (src1->_41 * src2->_44);
4816
4817 tmp._12 = (src1->_12 * src2->_11) + (src1->_22 * src2->_12) + (src1->_32 * src2->_13) + (src1->_42 * src2->_14);
4818 tmp._22 = (src1->_12 * src2->_21) + (src1->_22 * src2->_22) + (src1->_32 * src2->_23) + (src1->_42 * src2->_24);
4819 tmp._32 = (src1->_12 * src2->_31) + (src1->_22 * src2->_32) + (src1->_32 * src2->_33) + (src1->_42 * src2->_34);
4820 tmp._42 = (src1->_12 * src2->_41) + (src1->_22 * src2->_42) + (src1->_32 * src2->_43) + (src1->_42 * src2->_44);
4821
4822 tmp._13 = (src1->_13 * src2->_11) + (src1->_23 * src2->_12) + (src1->_33 * src2->_13) + (src1->_43 * src2->_14);
4823 tmp._23 = (src1->_13 * src2->_21) + (src1->_23 * src2->_22) + (src1->_33 * src2->_23) + (src1->_43 * src2->_24);
4824 tmp._33 = (src1->_13 * src2->_31) + (src1->_23 * src2->_32) + (src1->_33 * src2->_33) + (src1->_43 * src2->_34);
4825 tmp._43 = (src1->_13 * src2->_41) + (src1->_23 * src2->_42) + (src1->_33 * src2->_43) + (src1->_43 * src2->_44);
4826
4827 tmp._14 = (src1->_14 * src2->_11) + (src1->_24 * src2->_12) + (src1->_34 * src2->_13) + (src1->_44 * src2->_14);
4828 tmp._24 = (src1->_14 * src2->_21) + (src1->_24 * src2->_22) + (src1->_34 * src2->_23) + (src1->_44 * src2->_24);
4829 tmp._34 = (src1->_14 * src2->_31) + (src1->_24 * src2->_32) + (src1->_34 * src2->_33) + (src1->_44 * src2->_34);
4830 tmp._44 = (src1->_14 * src2->_41) + (src1->_24 * src2->_42) + (src1->_34 * src2->_43) + (src1->_44 * src2->_44);
4831
4832 *dst = tmp;
4833 }
4834
4835 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
4836 DWORD size = 0;
4837 int i;
4838 int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
4839
4840 if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
4841 if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
4842 if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
4843 if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
4844 switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
4845 case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
4846 case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
4847 case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break;
4848 case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break;
4849 case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break;
4850 case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break;
4851 case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break;
4852 case WINED3DFVF_XYZW: size += 4 * sizeof(float); break;
4853 default: ERR("Unexpected position mask\n");
4854 }
4855 for (i = 0; i < numTextures; i++) {
4856 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
4857 }
4858
4859 return size;
4860 }
4861
4862 unsigned int wined3d_max_compat_varyings(const struct wined3d_gl_info *gl_info)
4863 {
4864 /* On core profile we have to also count diffuse and specular colors and the
4865 * fog coordinate. */
4866 return gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] ? MAX_TEXTURES * 4 : (MAX_TEXTURES + 2) * 4 + 1;
4867 }
4868
4869 void gen_ffp_frag_op(const struct wined3d_context *context, const struct wined3d_state *state,
4870 struct ffp_frag_settings *settings, BOOL ignore_textype)
4871 {
4872 #define ARG1 0x01
4873 #define ARG2 0x02
4874 #define ARG0 0x04
4875 static const unsigned char args[WINED3D_TOP_LERP + 1] =
4876 {
4877 /* undefined */ 0,
4878 /* D3DTOP_DISABLE */ 0,
4879 /* D3DTOP_SELECTARG1 */ ARG1,
4880 /* D3DTOP_SELECTARG2 */ ARG2,
4881 /* D3DTOP_MODULATE */ ARG1 | ARG2,
4882 /* D3DTOP_MODULATE2X */ ARG1 | ARG2,
4883 /* D3DTOP_MODULATE4X */ ARG1 | ARG2,
4884 /* D3DTOP_ADD */ ARG1 | ARG2,
4885 /* D3DTOP_ADDSIGNED */ ARG1 | ARG2,
4886 /* D3DTOP_ADDSIGNED2X */ ARG1 | ARG2,
4887 /* D3DTOP_SUBTRACT */ ARG1 | ARG2,
4888 /* D3DTOP_ADDSMOOTH */ ARG1 | ARG2,
4889 /* D3DTOP_BLENDDIFFUSEALPHA */ ARG1 | ARG2,
4890 /* D3DTOP_BLENDTEXTUREALPHA */ ARG1 | ARG2,
4891 /* D3DTOP_BLENDFACTORALPHA */ ARG1 | ARG2,
4892 /* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1 | ARG2,
4893 /* D3DTOP_BLENDCURRENTALPHA */ ARG1 | ARG2,
4894 /* D3DTOP_PREMODULATE */ ARG1 | ARG2,
4895 /* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1 | ARG2,
4896 /* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1 | ARG2,
4897 /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1 | ARG2,
4898 /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1 | ARG2,
4899 /* D3DTOP_BUMPENVMAP */ ARG1 | ARG2,
4900 /* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1 | ARG2,
4901 /* D3DTOP_DOTPRODUCT3 */ ARG1 | ARG2,
4902 /* D3DTOP_MULTIPLYADD */ ARG1 | ARG2 | ARG0,
4903 /* D3DTOP_LERP */ ARG1 | ARG2 | ARG0
4904 };
4905 unsigned int i;
4906 DWORD ttff;
4907 DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
4908 const struct wined3d_gl_info *gl_info = context->gl_info;
4909 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
4910
4911 settings->padding = 0;
4912
4913 for (i = 0; i < d3d_info->limits.ffp_blend_stages; ++i)
4914 {
4915 const struct wined3d_texture *texture;
4916
4917 settings->op[i].padding = 0;
4918 if (state->texture_states[i][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_DISABLE)
4919 {
4920 settings->op[i].cop = WINED3D_TOP_DISABLE;
4921 settings->op[i].aop = WINED3D_TOP_DISABLE;
4922 settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
4923 settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
4924 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
4925 settings->op[i].dst = resultreg;
4926 settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_1D;
4927 settings->op[i].projected = proj_none;
4928 i++;
4929 break;
4930 }
4931
4932 if ((texture = state->textures[i]))
4933 {
4934 if (can_use_texture_swizzle(gl_info, texture->resource.format))
4935 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
4936 else
4937 settings->op[i].color_fixup = texture->resource.format->color_fixup;
4938 if (ignore_textype)
4939 {
4940 settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_1D;
4941 }
4942 else
4943 {
4944 switch (texture->target)
4945 {
4946 case GL_TEXTURE_1D:
4947 settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_1D;
4948 break;
4949 case GL_TEXTURE_2D:
4950 settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_2D;
4951 break;
4952 case GL_TEXTURE_3D:
4953 settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_3D;
4954 break;
4955 case GL_TEXTURE_CUBE_MAP_ARB:
4956 settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_CUBE;
4957 break;
4958 case GL_TEXTURE_RECTANGLE_ARB:
4959 settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_RECT;
4960 break;
4961 }
4962 }
4963 } else {
4964 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
4965 settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_1D;
4966 }
4967
4968 cop = state->texture_states[i][WINED3D_TSS_COLOR_OP];
4969 aop = state->texture_states[i][WINED3D_TSS_ALPHA_OP];
4970
4971 carg1 = (args[cop] & ARG1) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG1] : ARG_UNUSED;
4972 carg2 = (args[cop] & ARG2) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG2] : ARG_UNUSED;
4973 carg0 = (args[cop] & ARG0) ? state->texture_states[i][WINED3D_TSS_COLOR_ARG0] : ARG_UNUSED;
4974
4975 if (is_invalid_op(state, i, cop, carg1, carg2, carg0))
4976 {
4977 carg0 = ARG_UNUSED;
4978 carg2 = ARG_UNUSED;
4979 carg1 = WINED3DTA_CURRENT;
4980 cop = WINED3D_TOP_SELECT_ARG1;
4981 }
4982
4983 if (cop == WINED3D_TOP_DOTPRODUCT3)
4984 {
4985 /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
4986 * the color result to the alpha component of the destination
4987 */
4988 aop = cop;
4989 aarg1 = carg1;
4990 aarg2 = carg2;
4991 aarg0 = carg0;
4992 }
4993 else
4994 {
4995 aarg1 = (args[aop] & ARG1) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG1] : ARG_UNUSED;
4996 aarg2 = (args[aop] & ARG2) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG2] : ARG_UNUSED;
4997 aarg0 = (args[aop] & ARG0) ? state->texture_states[i][WINED3D_TSS_ALPHA_ARG0] : ARG_UNUSED;
4998 }
4999
5000 if (!i && state->textures[0] && state->render_states[WINED3D_RS_COLORKEYENABLE])
5001 {
5002 GLenum texture_dimensions;
5003
5004 texture = state->textures[0];
5005 texture_dimensions = texture->target;
5006
5007 if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
5008 {
5009 if (texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT && !texture->resource.format->alpha_size)
5010 {
5011 if (aop == WINED3D_TOP_DISABLE)
5012 {
5013 aarg1 = WINED3DTA_TEXTURE;
5014 aop = WINED3D_TOP_SELECT_ARG1;
5015 }
5016 else if (aop == WINED3D_TOP_SELECT_ARG1 && aarg1 != WINED3DTA_TEXTURE)
5017 {
5018 if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
5019 {
5020 aarg2 = WINED3DTA_TEXTURE;
5021 aop = WINED3D_TOP_MODULATE;
5022 }
5023 else aarg1 = WINED3DTA_TEXTURE;
5024 }
5025 else if (aop == WINED3D_TOP_SELECT_ARG2 && aarg2 != WINED3DTA_TEXTURE)
5026 {
5027 if (state->render_states[WINED3D_RS_ALPHABLENDENABLE])
5028 {
5029 aarg1 = WINED3DTA_TEXTURE;
5030 aop = WINED3D_TOP_MODULATE;
5031 }
5032 else aarg2 = WINED3DTA_TEXTURE;
5033 }
5034 }
5035 }
5036 }
5037
5038 if (is_invalid_op(state, i, aop, aarg1, aarg2, aarg0))
5039 {
5040 aarg0 = ARG_UNUSED;
5041 aarg2 = ARG_UNUSED;
5042 aarg1 = WINED3DTA_CURRENT;
5043 aop = WINED3D_TOP_SELECT_ARG1;
5044 }
5045
5046 if (carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE
5047 || aarg1 == WINED3DTA_TEXTURE || aarg2 == WINED3DTA_TEXTURE || aarg0 == WINED3DTA_TEXTURE)
5048 {
5049 ttff = state->texture_states[i][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS];
5050 if (ttff == (WINED3D_TTFF_PROJECTED | WINED3D_TTFF_COUNT3))
5051 settings->op[i].projected = proj_count3;
5052 else if (ttff & WINED3D_TTFF_PROJECTED)
5053 settings->op[i].projected = proj_count4;
5054 else
5055 settings->op[i].projected = proj_none;
5056 }
5057 else
5058 {
5059 settings->op[i].projected = proj_none;
5060 }
5061
5062 settings->op[i].cop = cop;
5063 settings->op[i].aop = aop;
5064 settings->op[i].carg0 = carg0;
5065 settings->op[i].carg1 = carg1;
5066 settings->op[i].carg2 = carg2;
5067 settings->op[i].aarg0 = aarg0;
5068 settings->op[i].aarg1 = aarg1;
5069 settings->op[i].aarg2 = aarg2;
5070
5071 if (state->texture_states[i][WINED3D_TSS_RESULT_ARG] == WINED3DTA_TEMP)
5072 settings->op[i].dst = tempreg;
5073 else
5074 settings->op[i].dst = resultreg;
5075 }
5076
5077 /* Clear unsupported stages */
5078 for(; i < MAX_TEXTURES; i++) {
5079 memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
5080 }
5081
5082 if (!state->render_states[WINED3D_RS_FOGENABLE])
5083 {
5084 settings->fog = WINED3D_FFP_PS_FOG_OFF;
5085 }
5086 else if (state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3D_FOG_NONE)
5087 {
5088 if (use_vs(state) || state->vertex_declaration->position_transformed)
5089 {
5090 settings->fog = WINED3D_FFP_PS_FOG_LINEAR;
5091 }
5092 else
5093 {
5094 switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
5095 {
5096 case WINED3D_FOG_NONE:
5097 case WINED3D_FOG_LINEAR:
5098 settings->fog = WINED3D_FFP_PS_FOG_LINEAR;
5099 break;
5100 case WINED3D_FOG_EXP:
5101 settings->fog = WINED3D_FFP_PS_FOG_EXP;
5102 break;
5103 case WINED3D_FOG_EXP2:
5104 settings->fog = WINED3D_FFP_PS_FOG_EXP2;
5105 break;
5106 }
5107 }
5108 }
5109 else
5110 {
5111 switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
5112 {
5113 case WINED3D_FOG_LINEAR:
5114 settings->fog = WINED3D_FFP_PS_FOG_LINEAR;
5115 break;
5116 case WINED3D_FOG_EXP:
5117 settings->fog = WINED3D_FFP_PS_FOG_EXP;
5118 break;
5119 case WINED3D_FOG_EXP2:
5120 settings->fog = WINED3D_FFP_PS_FOG_EXP2;
5121 break;
5122 }
5123 }
5124 settings->sRGB_write = !gl_info->supported[ARB_FRAMEBUFFER_SRGB] && needs_srgb_write(context, state, state->fb);
5125 if (d3d_info->vs_clipping || !use_vs(state) || !state->render_states[WINED3D_RS_CLIPPING]
5126 || !state->render_states[WINED3D_RS_CLIPPLANEENABLE])
5127 {
5128 /* No need to emulate clipplanes if GL supports native vertex shader clipping or if
5129 * the fixed function vertex pipeline is used(which always supports clipplanes), or
5130 * if no clipplane is enabled
5131 */
5132 settings->emul_clipplanes = 0;
5133 } else {
5134 settings->emul_clipplanes = 1;
5135 }
5136
5137 if (state->render_states[WINED3D_RS_COLORKEYENABLE] && state->textures[0]
5138 && state->textures[0]->async.color_key_flags & WINED3D_CKEY_SRC_BLT
5139 && settings->op[0].cop != WINED3D_TOP_DISABLE)
5140 settings->color_key_enabled = 1;
5141 else
5142 settings->color_key_enabled = 0;
5143
5144 /* texcoords_initialized is set to meaningful values only when GL doesn't
5145 * support enough varyings to always pass around all the possible texture
5146 * coordinates.
5147 * This is used to avoid reading a varying not written by the vertex shader.
5148 * Reading uninitialized varyings on core profile contexts results in an
5149 * error while with builtin varyings on legacy contexts you get undefined
5150 * behavior. */
5151 if (d3d_info->limits.varying_count
5152 && d3d_info->limits.varying_count < wined3d_max_compat_varyings(gl_info))
5153 {
5154 settings->texcoords_initialized = 0;
5155 for (i = 0; i < MAX_TEXTURES; ++i)
5156 {
5157 if (use_vs(state))
5158 {
5159 if (state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.output_registers & (1u << i))
5160 settings->texcoords_initialized |= 1u << i;
5161 }
5162 else
5163 {
5164 const struct wined3d_stream_info *si = &context->stream_info;
5165 unsigned int coord_idx = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
5166 if ((state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX] >> WINED3D_FFP_TCI_SHIFT)
5167 & WINED3D_FFP_TCI_MASK
5168 || (coord_idx < MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx)))))
5169 settings->texcoords_initialized |= 1u << i;
5170 }
5171 }
5172 }
5173 else
5174 {
5175 settings->texcoords_initialized = (1u << MAX_TEXTURES) - 1;
5176 }
5177
5178 settings->pointsprite = state->render_states[WINED3D_RS_POINTSPRITEENABLE]
5179 && state->gl_primitive_type == GL_POINTS;
5180
5181 if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
5182 settings->alpha_test_func = WINED3D_CMP_ALWAYS - 1;
5183 else
5184 settings->alpha_test_func = (state->render_states[WINED3D_RS_ALPHATESTENABLE]
5185 ? wined3d_sanitize_cmp_func(state->render_states[WINED3D_RS_ALPHAFUNC])
5186 : WINED3D_CMP_ALWAYS) - 1;
5187
5188 if (d3d_info->emulated_flatshading)
5189 settings->flatshading = state->render_states[WINED3D_RS_SHADEMODE] == WINED3D_SHADE_FLAT;
5190 else
5191 settings->flatshading = FALSE;
5192 }
5193
5194 const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
5195 const struct ffp_frag_settings *settings)
5196 {
5197 struct wine_rb_entry *entry = wine_rb_get(fragment_shaders, settings);
5198 return entry ? WINE_RB_ENTRY_VALUE(entry, struct ffp_frag_desc, entry) : NULL;
5199 }
5200
5201 void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc)
5202 {
5203 /* Note that the key is the implementation independent part of the ffp_frag_desc structure,
5204 * whereas desc points to an extended structure with implementation specific parts. */
5205 if (wine_rb_put(shaders, &desc->settings, &desc->entry) == -1)
5206 {
5207 ERR("Failed to insert ffp frag shader.\n");
5208 }
5209 }
5210
5211 /* Activates the texture dimension according to the bound D3D texture. Does
5212 * not care for the colorop or correct gl texture unit (when using nvrc).
5213 * Requires the caller to activate the correct unit. */
5214 /* Context activation is done by the caller (state handler). */
5215 void texture_activate_dimensions(const struct wined3d_texture *texture, const struct wined3d_gl_info *gl_info)
5216 {
5217 if (texture)
5218 {
5219 switch (texture->target)
5220 {
5221 case GL_TEXTURE_2D:
5222 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
5223 checkGLcall("glDisable(GL_TEXTURE_3D)");
5224 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
5225 {
5226 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
5227 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
5228 }
5229 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
5230 {
5231 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
5232 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
5233 }
5234 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_2D);
5235 checkGLcall("glEnable(GL_TEXTURE_2D)");
5236 break;
5237 case GL_TEXTURE_RECTANGLE_ARB:
5238 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
5239 checkGLcall("glDisable(GL_TEXTURE_2D)");
5240 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
5241 checkGLcall("glDisable(GL_TEXTURE_3D)");
5242 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
5243 {
5244 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
5245 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
5246 }
5247 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_RECTANGLE_ARB);
5248 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
5249 break;
5250 case GL_TEXTURE_3D:
5251 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
5252 {
5253 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
5254 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
5255 }
5256 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
5257 {
5258 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
5259 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
5260 }
5261 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
5262 checkGLcall("glDisable(GL_TEXTURE_2D)");
5263 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_3D);
5264 checkGLcall("glEnable(GL_TEXTURE_3D)");
5265 break;
5266 case GL_TEXTURE_CUBE_MAP_ARB:
5267 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
5268 checkGLcall("glDisable(GL_TEXTURE_2D)");
5269 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
5270 checkGLcall("glDisable(GL_TEXTURE_3D)");
5271 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
5272 {
5273 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
5274 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
5275 }
5276 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_CUBE_MAP_ARB);
5277 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
5278 break;
5279 }
5280 }
5281 else
5282 {
5283 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_2D);
5284 checkGLcall("glEnable(GL_TEXTURE_2D)");
5285 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
5286 checkGLcall("glDisable(GL_TEXTURE_3D)");
5287 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
5288 {
5289 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
5290 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
5291 }
5292 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
5293 {
5294 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
5295 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
5296 }
5297 /* Binding textures is done by samplers. A dummy texture will be bound */
5298 }
5299 }
5300
5301 /* Context activation is done by the caller (state handler). */
5302 void sampler_texdim(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
5303 {
5304 DWORD sampler = state_id - STATE_SAMPLER(0);
5305 DWORD mapped_stage = context->tex_unit_map[sampler];
5306
5307 /* No need to enable / disable anything here for unused samplers. The
5308 * tex_colorop handler takes care. Also no action is needed with pixel
5309 * shaders, or if tex_colorop will take care of this business. */
5310 if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures)
5311 return;
5312 if (sampler >= context->lowest_disabled_stage)
5313 return;
5314 if (isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3D_TSS_COLOR_OP)))
5315 return;
5316
5317 texture_activate_dimensions(state->textures[sampler], context->gl_info);
5318 }
5319
5320 void *wined3d_rb_alloc(size_t size)
5321 {
5322 return HeapAlloc(GetProcessHeap(), 0, size);
5323 }
5324
5325 void *wined3d_rb_realloc(void *ptr, size_t size)
5326 {
5327 return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
5328 }
5329
5330 void wined3d_rb_free(void *ptr)
5331 {
5332 HeapFree(GetProcessHeap(), 0, ptr);
5333 }
5334
5335 static int ffp_frag_program_key_compare(const void *key, const struct wine_rb_entry *entry)
5336 {
5337 const struct ffp_frag_settings *ka = key;
5338 const struct ffp_frag_settings *kb = &WINE_RB_ENTRY_VALUE(entry, const struct ffp_frag_desc, entry)->settings;
5339
5340 return memcmp(ka, kb, sizeof(*ka));
5341 }
5342
5343 const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions =
5344 {
5345 wined3d_rb_alloc,
5346 wined3d_rb_realloc,
5347 wined3d_rb_free,
5348 ffp_frag_program_key_compare,
5349 };
5350
5351 void wined3d_ffp_get_vs_settings(const struct wined3d_context *context,
5352 const struct wined3d_state *state, struct wined3d_ffp_vs_settings *settings)
5353 {
5354 const struct wined3d_stream_info *si = &context->stream_info;
5355 const struct wined3d_gl_info *gl_info = context->gl_info;
5356 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
5357 unsigned int coord_idx, i;
5358
5359 if (si->position_transformed)
5360 {
5361 memset(settings, 0, sizeof(*settings));
5362
5363 settings->transformed = 1;
5364 settings->point_size = state->gl_primitive_type == GL_POINTS;
5365 settings->per_vertex_point_size = !!(si->use_map & 1u << WINED3D_FFP_PSIZE);
5366 if (!state->render_states[WINED3D_RS_FOGENABLE])
5367 settings->fog_mode = WINED3D_FFP_VS_FOG_OFF;
5368 else if (state->render_states[WINED3D_RS_FOGTABLEMODE] != WINED3D_FOG_NONE)
5369 settings->fog_mode = WINED3D_FFP_VS_FOG_DEPTH;
5370 else
5371 settings->fog_mode = WINED3D_FFP_VS_FOG_FOGCOORD;
5372
5373 for (i = 0; i < MAX_TEXTURES; ++i)
5374 {
5375 coord_idx = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
5376 if (coord_idx < MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx))))
5377 settings->texcoords |= 1u << i;
5378 settings->texgen[i] = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
5379 }
5380 if (d3d_info->limits.varying_count >= wined3d_max_compat_varyings(gl_info))
5381 settings->texcoords = (1u << MAX_TEXTURES) - 1;
5382
5383 if (d3d_info->emulated_flatshading)
5384 settings->flatshading = state->render_states[WINED3D_RS_SHADEMODE] == WINED3D_SHADE_FLAT;
5385 else
5386 settings->flatshading = FALSE;
5387
5388 return;
5389 }
5390
5391 switch (state->render_states[WINED3D_RS_VERTEXBLEND])
5392 {
5393 case WINED3D_VBF_DISABLE:
5394 case WINED3D_VBF_1WEIGHTS:
5395 case WINED3D_VBF_2WEIGHTS:
5396 case WINED3D_VBF_3WEIGHTS:
5397 settings->vertexblends = state->render_states[WINED3D_RS_VERTEXBLEND];
5398 break;
5399 default:
5400 FIXME("Unsupported vertex blending: %d\n", state->render_states[WINED3D_RS_VERTEXBLEND]);
5401 break;
5402 }
5403
5404 settings->transformed = 0;
5405 settings->clipping = state->render_states[WINED3D_RS_CLIPPING]
5406 && state->render_states[WINED3D_RS_CLIPPLANEENABLE];
5407 settings->normal = !!(si->use_map & (1u << WINED3D_FFP_NORMAL));
5408 settings->normalize = settings->normal && state->render_states[WINED3D_RS_NORMALIZENORMALS];
5409 settings->lighting = !!state->render_states[WINED3D_RS_LIGHTING];
5410 settings->localviewer = !!state->render_states[WINED3D_RS_LOCALVIEWER];
5411 settings->point_size = state->gl_primitive_type == GL_POINTS;
5412 settings->per_vertex_point_size = !!(si->use_map & 1u << WINED3D_FFP_PSIZE);
5413
5414 if (state->render_states[WINED3D_RS_COLORVERTEX] && (si->use_map & (1u << WINED3D_FFP_DIFFUSE)))
5415 {
5416 settings->diffuse_source = state->render_states[WINED3D_RS_DIFFUSEMATERIALSOURCE];
5417 settings->emissive_source = state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE];
5418 settings->ambient_source = state->render_states[WINED3D_RS_AMBIENTMATERIALSOURCE];
5419 settings->specular_source = state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE];
5420 }
5421 else
5422 {
5423 settings->diffuse_source = WINED3D_MCS_MATERIAL;
5424 settings->emissive_source = WINED3D_MCS_MATERIAL;
5425 settings->ambient_source = WINED3D_MCS_MATERIAL;
5426 settings->specular_source = WINED3D_MCS_MATERIAL;
5427 }
5428
5429 settings->texcoords = 0;
5430 for (i = 0; i < MAX_TEXTURES; ++i)
5431 {
5432 coord_idx = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
5433 if (coord_idx < MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx))))
5434 settings->texcoords |= 1u << i;
5435 settings->texgen[i] = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
5436 }
5437 if (d3d_info->limits.varying_count >= wined3d_max_compat_varyings(gl_info))
5438 settings->texcoords = (1u << MAX_TEXTURES) - 1;
5439
5440 settings->light_type = 0;
5441 for (i = 0; i < MAX_ACTIVE_LIGHTS; ++i)
5442 {
5443 if (state->lights[i])
5444 settings->light_type |= (state->lights[i]->OriginalParms.type
5445 & WINED3D_FFP_LIGHT_TYPE_MASK) << WINED3D_FFP_LIGHT_TYPE_SHIFT(i);
5446 }
5447
5448 settings->ortho_fog = 0;
5449 if (!state->render_states[WINED3D_RS_FOGENABLE])
5450 settings->fog_mode = WINED3D_FFP_VS_FOG_OFF;
5451 else if (state->render_states[WINED3D_RS_FOGTABLEMODE] != WINED3D_FOG_NONE)
5452 {
5453 settings->fog_mode = WINED3D_FFP_VS_FOG_DEPTH;
5454
5455 if (state->transforms[WINED3D_TS_PROJECTION]._14 == 0.0f
5456 && state->transforms[WINED3D_TS_PROJECTION]._24 == 0.0f
5457 && state->transforms[WINED3D_TS_PROJECTION]._34 == 0.0f
5458 && state->transforms[WINED3D_TS_PROJECTION]._44 == 1.0f)
5459 settings->ortho_fog = 1;
5460 }
5461 else if (state->render_states[WINED3D_RS_FOGVERTEXMODE] == WINED3D_FOG_NONE)
5462 settings->fog_mode = WINED3D_FFP_VS_FOG_FOGCOORD;
5463 else if (state->render_states[WINED3D_RS_RANGEFOGENABLE])
5464 settings->fog_mode = WINED3D_FFP_VS_FOG_RANGE;
5465 else
5466 settings->fog_mode = WINED3D_FFP_VS_FOG_DEPTH;
5467
5468 if (d3d_info->emulated_flatshading)
5469 settings->flatshading = state->render_states[WINED3D_RS_SHADEMODE] == WINED3D_SHADE_FLAT;
5470 else
5471 settings->flatshading = FALSE;
5472
5473 settings->padding = 0;
5474 }
5475
5476 static int wined3d_ffp_vertex_program_key_compare(const void *key, const struct wine_rb_entry *entry)
5477 {
5478 const struct wined3d_ffp_vs_settings *ka = key;
5479 const struct wined3d_ffp_vs_settings *kb = &WINE_RB_ENTRY_VALUE(entry,
5480 const struct wined3d_ffp_vs_desc, entry)->settings;
5481
5482 return memcmp(ka, kb, sizeof(*ka));
5483 }
5484
5485 const struct wine_rb_functions wined3d_ffp_vertex_program_rb_functions =
5486 {
5487 wined3d_rb_alloc,
5488 wined3d_rb_realloc,
5489 wined3d_rb_free,
5490 wined3d_ffp_vertex_program_key_compare,
5491 };
5492
5493 const struct blit_shader *wined3d_select_blitter(const struct wined3d_gl_info *gl_info,
5494 const struct wined3d_d3d_info *d3d_info, enum wined3d_blit_op blit_op,
5495 const RECT *src_rect, DWORD src_usage, enum wined3d_pool src_pool, const struct wined3d_format *src_format,
5496 const RECT *dst_rect, DWORD dst_usage, enum wined3d_pool dst_pool, const struct wined3d_format *dst_format)
5497 {
5498 static const struct blit_shader * const blitters[] =
5499 {
5500 &arbfp_blit,
5501 &ffp_blit,
5502 &cpu_blit,
5503 };
5504 unsigned int i;
5505
5506 for (i = 0; i < sizeof(blitters) / sizeof(*blitters); ++i)
5507 {
5508 if (blitters[i]->blit_supported(gl_info, d3d_info, blit_op,
5509 src_rect, src_usage, src_pool, src_format,
5510 dst_rect, dst_usage, dst_pool, dst_format))
5511 return blitters[i];
5512 }
5513
5514 return NULL;
5515 }
5516
5517 void wined3d_get_draw_rect(const struct wined3d_state *state, RECT *rect)
5518 {
5519 const struct wined3d_viewport *vp = &state->viewport;
5520
5521 SetRect(rect, vp->x, vp->y, vp->x + vp->width, vp->y + vp->height);
5522
5523 if (state->render_states[WINED3D_RS_SCISSORTESTENABLE])
5524 IntersectRect(rect, rect, &state->scissor_rect);
5525 }
5526
5527 const char *wined3d_debug_location(DWORD location)
5528 {
5529 const char *prefix = "";
5530 const char *suffix = "";
5531 char buf[294];
5532
5533 if (wined3d_popcount(location) > 16)
5534 {
5535 prefix = "~(";
5536 location = ~location;
5537 suffix = ")";
5538 }
5539
5540 buf[0] = '\0';
5541 #define LOCATION_TO_STR(u) if (location & u) { strcat(buf, " | "#u); location &= ~u; }
5542 LOCATION_TO_STR(WINED3D_LOCATION_DISCARDED);
5543 LOCATION_TO_STR(WINED3D_LOCATION_SYSMEM);
5544 LOCATION_TO_STR(WINED3D_LOCATION_USER_MEMORY);
5545 LOCATION_TO_STR(WINED3D_LOCATION_BUFFER);
5546 LOCATION_TO_STR(WINED3D_LOCATION_TEXTURE_RGB);
5547 LOCATION_TO_STR(WINED3D_LOCATION_TEXTURE_SRGB);
5548 LOCATION_TO_STR(WINED3D_LOCATION_DRAWABLE);
5549 LOCATION_TO_STR(WINED3D_LOCATION_RB_MULTISAMPLE);
5550 LOCATION_TO_STR(WINED3D_LOCATION_RB_RESOLVED);
5551 #undef LOCATION_TO_STR
5552 if (location) FIXME("Unrecognized location flag(s) %#x.\n", location);
5553
5554 return wine_dbg_sprintf("%s%s%s", prefix, buf[0] ? &buf[3] : "0", suffix);
5555 }
5556
5557 /* Print a floating point value with the %.8e format specifier, always using
5558 * '.' as decimal separator. */
5559 void wined3d_ftoa(float value, char *s)
5560 {
5561 int idx = 1;
5562
5563 if (copysignf(1.0f, value) < 0.0f)
5564 ++idx;
5565
5566 /* Be sure to allocate a buffer of at least 17 characters for the result
5567 as sprintf may return a 3 digit exponent when using the MSVC runtime
5568 instead of a 2 digit exponent. */
5569 sprintf(s, "%.8e", value);
5570 if (isfinite(value))
5571 s[idx] = '.';
5572 }
5573
5574 void wined3d_release_dc(HWND window, HDC dc)
5575 {
5576 /* You'd figure ReleaseDC() would fail if the DC doesn't match the window.
5577 * However, that's not what actually happens, and there are user32 tests
5578 * that confirm ReleaseDC() with the wrong window is supposed to succeed.
5579 * So explicitly check that the DC belongs to the window, since we want to
5580 * avoid releasing a DC that belongs to some other window if the original
5581 * window was already destroyed. */
5582 if (WindowFromDC(dc) != window)
5583 WARN("DC %p does not belong to window %p.\n", dc, window);
5584 else if (!ReleaseDC(window, dc))
5585 ERR("Failed to release device context %p, last error %#x.\n", dc, GetLastError());
5586 }
5587
5588 BOOL wined3d_clip_blit(const RECT *clip_rect, RECT *clipped, RECT *other)
5589 {
5590 RECT orig = *clipped;
5591 float scale_x = (float)(orig.right - orig.left) / (float)(other->right - other->left);
5592 float scale_y = (float)(orig.bottom - orig.top) / (float)(other->bottom - other->top);
5593
5594 IntersectRect(clipped, clipped, clip_rect);
5595
5596 if (IsRectEmpty(clipped))
5597 {
5598 SetRectEmpty(other);
5599 return FALSE;
5600 }
5601
5602 other->left += (LONG)((clipped->left - orig.left) / scale_x);
5603 other->top += (LONG)((clipped->top - orig.top) / scale_y);
5604 other->right -= (LONG)((orig.right - clipped->right) / scale_x);
5605 other->bottom -= (LONG)((orig.bottom - clipped->bottom) / scale_y);
5606
5607 return TRUE;
5608 }
Windows API implementation