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