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