VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/utils.c@ 27629

Last change on this file since 27629 was 25949, checked in by vboxsync, 15 years ago

crOpenGL: update to wine 1.1.36 and disable unnecessary fbo state poll
  • Property svn:eol-style set to native
File size: 129.8 KB
Line 
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 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/*
28 * Sun LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
29 * other than GPL or LGPL is available it will apply instead, Sun elects to use only
30 * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
31 * a choice of LGPL license versions is made available with the language indicating
32 * that LGPLv2 or any later version may be used, or where a choice of which version
33 * of the LGPL is applied is otherwise unspecified.
34 */
35
36#include "config.h"
37#include "wined3d_private.h"
38
39WINE_DEFAULT_DEBUG_CHANNEL(d3d);
40
41struct StaticPixelFormatDesc
42{
43 WINED3DFORMAT format;
44 DWORD alphaMask, redMask, greenMask, blueMask;
45 UINT bpp;
46 short depthSize, stencilSize;
47};
48
49/*****************************************************************************
50 * Pixel format array
51 *
52 * For the formats WINED3DFMT_A32B32G32R32F, WINED3DFMT_A16B16G16R16F,
53 * and WINED3DFMT_A16B16G16R16 do not have correct alpha masks, because the
54 * high masks do not fit into the 32 bit values needed for ddraw. It is only
55 * used for ddraw mostly, and to figure out if the format has alpha at all, so
56 * setting a mask like 0x1 for those surfaces is correct. The 64 and 128 bit
57 * formats are not usable in 2D rendering because ddraw doesn't support them.
58 */
59static const struct StaticPixelFormatDesc formats[] =
60{
61 /* WINED3DFORMAT alphamask redmask greenmask bluemask bpp depth stencil */
62 {WINED3DFMT_UNKNOWN, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
63 /* FourCC formats */
64 {WINED3DFMT_UYVY, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
65 {WINED3DFMT_YUY2, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
66 {WINED3DFMT_YV12, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
67 {WINED3DFMT_DXT1, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
68 {WINED3DFMT_DXT2, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
69 {WINED3DFMT_DXT3, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
70 {WINED3DFMT_DXT4, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
71 {WINED3DFMT_DXT5, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
72 {WINED3DFMT_MULTI2_ARGB8, 0x0, 0x0, 0x0, 0x0, 1/*?*/, 0, 0},
73 {WINED3DFMT_G8R8_G8B8, 0x0, 0x0, 0x0, 0x0, 1/*?*/, 0, 0},
74 {WINED3DFMT_R8G8_B8G8, 0x0, 0x0, 0x0, 0x0, 1/*?*/, 0, 0},
75 /* IEEE formats */
76 {WINED3DFMT_R32_FLOAT, 0x0, 0x0, 0x0, 0x0, 4, 0, 0},
77 {WINED3DFMT_R32G32_FLOAT, 0x0, 0x0, 0x0, 0x0, 8, 0, 0},
78 {WINED3DFMT_R32G32B32_FLOAT, 0x0, 0x0, 0x0, 0x0, 12, 0, 0},
79 {WINED3DFMT_R32G32B32A32_FLOAT, 0x1, 0x0, 0x0, 0x0, 16, 0, 0},
80 /* Hmm? */
81 {WINED3DFMT_R8G8_SNORM_Cx, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
82 /* Float */
83 {WINED3DFMT_R16_FLOAT, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
84 {WINED3DFMT_R16G16_FLOAT, 0x0, 0x0, 0x0, 0x0, 4, 0, 0},
85 {WINED3DFMT_R16G16_SINT, 0x0, 0x0, 0x0, 0x0, 4, 0, 0},
86 {WINED3DFMT_R16G16B16A16_FLOAT, 0x1, 0x0, 0x0, 0x0, 8, 0, 0},
87 {WINED3DFMT_R16G16B16A16_SINT, 0x1, 0x0, 0x0, 0x0, 8, 0, 0},
88 /* Palettized formats */
89 {WINED3DFMT_P8_UINT_A8_UNORM, 0x0000ff00, 0x0, 0x0, 0x0, 2, 0, 0},
90 {WINED3DFMT_P8_UINT, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
91 /* Standard ARGB formats. */
92 {WINED3DFMT_B8G8R8_UNORM, 0x0, 0x00ff0000, 0x0000ff00, 0x000000ff, 3, 0, 0},
93 {WINED3DFMT_B8G8R8A8_UNORM, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 4, 0, 0},
94 {WINED3DFMT_B8G8R8X8_UNORM, 0x0, 0x00ff0000, 0x0000ff00, 0x000000ff, 4, 0, 0},
95 {WINED3DFMT_B5G6R5_UNORM, 0x0, 0x0000f800, 0x000007e0, 0x0000001f, 2, 0, 0},
96 {WINED3DFMT_B5G5R5X1_UNORM, 0x0, 0x00007c00, 0x000003e0, 0x0000001f, 2, 0, 0},
97 {WINED3DFMT_B5G5R5A1_UNORM, 0x00008000, 0x00007c00, 0x000003e0, 0x0000001f, 2, 0, 0},
98 {WINED3DFMT_B4G4R4A4_UNORM, 0x0000f000, 0x00000f00, 0x000000f0, 0x0000000f, 2, 0, 0},
99 {WINED3DFMT_B2G3R3_UNORM, 0x0, 0x000000e0, 0x0000001c, 0x00000003, 1, 0, 0},
100 {WINED3DFMT_A8_UNORM, 0x000000ff, 0x0, 0x0, 0x0, 1, 0, 0},
101 {WINED3DFMT_B2G3R3A8_UNORM, 0x0000ff00, 0x000000e0, 0x0000001c, 0x00000003, 2, 0, 0},
102 {WINED3DFMT_B4G4R4X4_UNORM, 0x0, 0x00000f00, 0x000000f0, 0x0000000f, 2, 0, 0},
103 {WINED3DFMT_R10G10B10A2_UNORM, 0xc0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4, 0, 0},
104 {WINED3DFMT_R10G10B10A2_UINT, 0xc0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4, 0, 0},
105 {WINED3DFMT_R10G10B10A2_SNORM, 0xc0000000, 0x000003ff, 0x000ffc00, 0x3ff00000, 4, 0, 0},
106 {WINED3DFMT_R8G8B8A8_UNORM, 0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4, 0, 0},
107 {WINED3DFMT_R8G8B8A8_UINT, 0xff000000, 0x000000ff, 0x0000ff00, 0x00ff0000, 4, 0, 0},
108 {WINED3DFMT_R8G8B8X8_UNORM, 0x0, 0x000000ff, 0x0000ff00, 0x00ff0000, 4, 0, 0},
109 {WINED3DFMT_R16G16_UNORM, 0x0, 0x0000ffff, 0xffff0000, 0x0, 4, 0, 0},
110 {WINED3DFMT_B10G10R10A2_UNORM, 0xc0000000, 0x3ff00000, 0x000ffc00, 0x000003ff, 4, 0, 0},
111 {WINED3DFMT_R16G16B16A16_UNORM, 0x1, 0x0000ffff, 0xffff0000, 0x0, 8, 0, 0},
112 /* Luminance */
113 {WINED3DFMT_L8_UNORM, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
114 {WINED3DFMT_L8A8_UNORM, 0x0000ff00, 0x0, 0x0, 0x0, 2, 0, 0},
115 {WINED3DFMT_L4A4_UNORM, 0x000000f0, 0x0, 0x0, 0x0, 1, 0, 0},
116 {WINED3DFMT_L16_UNORM, 0x0, 0x0, 0x0, 0x0, 2, 16, 0},
117 /* Bump mapping stuff */
118 {WINED3DFMT_R8G8_SNORM, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
119 {WINED3DFMT_R5G5_SNORM_L6_UNORM, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
120 {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, 0x0, 0x0, 0x0, 0x0, 4, 0, 0},
121 {WINED3DFMT_R8G8B8A8_SNORM, 0x0, 0x0, 0x0, 0x0, 4, 0, 0},
122 {WINED3DFMT_R16G16_SNORM, 0x0, 0x0, 0x0, 0x0, 4, 0, 0},
123 {WINED3DFMT_R10G11B11_SNORM, 0x0, 0x0, 0x0, 0x0, 4, 0, 0},
124 {WINED3DFMT_R10G10B10_SNORM_A2_UNORM, 0xb0000000, 0x0, 0x0, 0x0, 4, 0, 0},
125 /* Depth stencil formats */
126 {WINED3DFMT_D16_LOCKABLE, 0x0, 0x0, 0x0, 0x0, 2, 16, 0},
127 {WINED3DFMT_D32_UNORM, 0x0, 0x0, 0x0, 0x0, 4, 32, 0},
128 {WINED3DFMT_S1_UINT_D15_UNORM, 0x0, 0x0, 0x0, 0x0, 2, 15, 1},
129 {WINED3DFMT_D24_UNORM_S8_UINT, 0x0, 0x0, 0x0, 0x0, 4, 24, 8},
130 {WINED3DFMT_X8D24_UNORM, 0x0, 0x0, 0x0, 0x0, 4, 24, 0},
131 {WINED3DFMT_S4X4_UINT_D24_UNORM, 0x0, 0x0, 0x0, 0x0, 4, 24, 4},
132 {WINED3DFMT_D16_UNORM, 0x0, 0x0, 0x0, 0x0, 2, 16, 0},
133 {WINED3DFMT_D32_FLOAT, 0x0, 0x0, 0x0, 0x0, 4, 32, 0},
134 {WINED3DFMT_S8_UINT_D24_FLOAT, 0x0, 0x0, 0x0, 0x0, 4, 24, 8},
135 {WINED3DFMT_VERTEXDATA, 0x0, 0x0, 0x0, 0x0, 0, 0, 0},
136 {WINED3DFMT_R16_UINT, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
137 {WINED3DFMT_R32_UINT, 0x0, 0x0, 0x0, 0x0, 4, 0, 0},
138 {WINED3DFMT_R16G16B16A16_SNORM, 0x0, 0x0, 0x0, 0x0, 8, 0, 0},
139 /* Vendor-specific formats */
140 {WINED3DFMT_ATI2N, 0x0, 0x0, 0x0, 0x0, 1, 0, 0},
141 {WINED3DFMT_NVHU, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
142 {WINED3DFMT_NVHS, 0x0, 0x0, 0x0, 0x0, 2, 0, 0},
143};
144
145struct wined3d_format_base_flags
146{
147 WINED3DFORMAT format;
148 DWORD flags;
149};
150
151static const struct wined3d_format_base_flags format_base_flags[] =
152{
153 {WINED3DFMT_UYVY, WINED3DFMT_FLAG_FOURCC},
154 {WINED3DFMT_YUY2, WINED3DFMT_FLAG_FOURCC},
155 {WINED3DFMT_YV12, WINED3DFMT_FLAG_FOURCC},
156 {WINED3DFMT_DXT1, WINED3DFMT_FLAG_FOURCC},
157 {WINED3DFMT_DXT2, WINED3DFMT_FLAG_FOURCC},
158 {WINED3DFMT_DXT3, WINED3DFMT_FLAG_FOURCC},
159 {WINED3DFMT_DXT4, WINED3DFMT_FLAG_FOURCC},
160 {WINED3DFMT_DXT5, WINED3DFMT_FLAG_FOURCC},
161 {WINED3DFMT_MULTI2_ARGB8, WINED3DFMT_FLAG_FOURCC},
162 {WINED3DFMT_G8R8_G8B8, WINED3DFMT_FLAG_FOURCC},
163 {WINED3DFMT_R8G8_B8G8, WINED3DFMT_FLAG_FOURCC},
164 {WINED3DFMT_P8_UINT, WINED3DFMT_FLAG_GETDC},
165 {WINED3DFMT_B8G8R8_UNORM, WINED3DFMT_FLAG_GETDC},
166 {WINED3DFMT_B8G8R8A8_UNORM, WINED3DFMT_FLAG_GETDC},
167 {WINED3DFMT_B8G8R8X8_UNORM, WINED3DFMT_FLAG_GETDC},
168 {WINED3DFMT_B5G6R5_UNORM, WINED3DFMT_FLAG_GETDC},
169 {WINED3DFMT_B5G5R5X1_UNORM, WINED3DFMT_FLAG_GETDC},
170 {WINED3DFMT_B5G5R5A1_UNORM, WINED3DFMT_FLAG_GETDC},
171 {WINED3DFMT_B4G4R4A4_UNORM, WINED3DFMT_FLAG_GETDC},
172 {WINED3DFMT_B4G4R4X4_UNORM, WINED3DFMT_FLAG_GETDC},
173 {WINED3DFMT_R8G8B8A8_UNORM, WINED3DFMT_FLAG_GETDC},
174 {WINED3DFMT_R8G8B8X8_UNORM, WINED3DFMT_FLAG_GETDC},
175 {WINED3DFMT_ATI2N, WINED3DFMT_FLAG_FOURCC},
176 {WINED3DFMT_NVHU, WINED3DFMT_FLAG_FOURCC},
177 {WINED3DFMT_NVHS, WINED3DFMT_FLAG_FOURCC},
178};
179
180struct wined3d_format_compression_info
181{
182 WINED3DFORMAT format;
183 UINT block_width;
184 UINT block_height;
185 UINT block_byte_count;
186};
187
188static const struct wined3d_format_compression_info format_compression_info[] =
189{
190 {WINED3DFMT_DXT1, 4, 4, 8},
191 {WINED3DFMT_DXT2, 4, 4, 16},
192 {WINED3DFMT_DXT3, 4, 4, 16},
193 {WINED3DFMT_DXT4, 4, 4, 16},
194 {WINED3DFMT_DXT5, 4, 4, 16},
195 {WINED3DFMT_ATI2N, 4, 4, 16},
196};
197
198struct wined3d_format_vertex_info
199{
200 WINED3DFORMAT format;
201 enum wined3d_ffp_emit_idx emit_idx;
202 GLint component_count;
203 GLenum gl_vtx_type;
204 GLint gl_vtx_format;
205 GLboolean gl_normalized;
206 unsigned int component_size;
207};
208
209static const struct wined3d_format_vertex_info format_vertex_info[] =
210{
211 {WINED3DFMT_R32_FLOAT, WINED3D_FFP_EMIT_FLOAT1, 1, GL_FLOAT, 1, GL_FALSE, sizeof(float)},
212 {WINED3DFMT_R32G32_FLOAT, WINED3D_FFP_EMIT_FLOAT2, 2, GL_FLOAT, 2, GL_FALSE, sizeof(float)},
213 {WINED3DFMT_R32G32B32_FLOAT, WINED3D_FFP_EMIT_FLOAT3, 3, GL_FLOAT, 3, GL_FALSE, sizeof(float)},
214 {WINED3DFMT_R32G32B32A32_FLOAT, WINED3D_FFP_EMIT_FLOAT4, 4, GL_FLOAT, 4, GL_FALSE, sizeof(float)},
215 {WINED3DFMT_B8G8R8A8_UNORM, WINED3D_FFP_EMIT_D3DCOLOR, 4, GL_UNSIGNED_BYTE, 4, GL_TRUE, sizeof(BYTE)},
216 {WINED3DFMT_R8G8B8A8_UINT, WINED3D_FFP_EMIT_UBYTE4, 4, GL_UNSIGNED_BYTE, 4, GL_FALSE, sizeof(BYTE)},
217 {WINED3DFMT_R16G16_SINT, WINED3D_FFP_EMIT_SHORT2, 2, GL_SHORT, 2, GL_FALSE, sizeof(short int)},
218 {WINED3DFMT_R16G16B16A16_SINT, WINED3D_FFP_EMIT_SHORT4, 4, GL_SHORT, 4, GL_FALSE, sizeof(short int)},
219 {WINED3DFMT_R8G8B8A8_UNORM, WINED3D_FFP_EMIT_UBYTE4N, 4, GL_UNSIGNED_BYTE, 4, GL_TRUE, sizeof(BYTE)},
220 {WINED3DFMT_R16G16_SNORM, WINED3D_FFP_EMIT_SHORT2N, 2, GL_SHORT, 2, GL_TRUE, sizeof(short int)},
221 {WINED3DFMT_R16G16B16A16_SNORM, WINED3D_FFP_EMIT_SHORT4N, 4, GL_SHORT, 4, GL_TRUE, sizeof(short int)},
222 {WINED3DFMT_R16G16_UNORM, WINED3D_FFP_EMIT_USHORT2N, 2, GL_UNSIGNED_SHORT, 2, GL_TRUE, sizeof(short int)},
223 {WINED3DFMT_R16G16B16A16_UNORM, WINED3D_FFP_EMIT_USHORT4N, 4, GL_UNSIGNED_SHORT, 4, GL_TRUE, sizeof(short int)},
224 {WINED3DFMT_R10G10B10A2_UINT, WINED3D_FFP_EMIT_UDEC3, 3, GL_UNSIGNED_SHORT, 3, GL_FALSE, sizeof(short int)},
225 {WINED3DFMT_R10G10B10A2_SNORM, WINED3D_FFP_EMIT_DEC3N, 3, GL_SHORT, 3, GL_TRUE, sizeof(short int)},
226 {WINED3DFMT_R16G16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_2, 2, GL_FLOAT, 2, GL_FALSE, sizeof(GLhalfNV)},
227 {WINED3DFMT_R16G16B16A16_FLOAT, WINED3D_FFP_EMIT_FLOAT16_4, 4, GL_FLOAT, 4, GL_FALSE, sizeof(GLhalfNV)}
228};
229
230typedef struct {
231 WINED3DFORMAT fmt;
232 GLint glInternal, glGammaInternal, rtInternal, glFormat, glType;
233 unsigned int Flags;
234 GL_SupportedExt extension;
235} GlPixelFormatDescTemplate;
236
237/*****************************************************************************
238 * OpenGL format template. Contains unexciting formats which do not need
239 * extension checks. The order in this table is independent of the order in
240 * the table StaticPixelFormatDesc above. Not all formats have to be in this
241 * table.
242 */
243static const GlPixelFormatDescTemplate gl_formats_template[] = {
244 /* WINED3DFORMAT internal srgbInternal rtInternal
245 format type
246 flags
247 extension */
248 /* FourCC formats */
249 /* GL_APPLE_ycbcr_422 claims that its '2YUV' format, which is supported via the UNSIGNED_SHORT_8_8_REV_APPLE type
250 * is equivalent to 'UYVY' format on Windows, and the 'YUVS' via UNSIGNED_SHORT_8_8_APPLE equates to 'YUY2'. The
251 * d3d9 test however shows that the opposite is true. Since the extension is from 2002, it predates the x86 based
252 * Macs, so probably the endianess differs. This could be tested as soon as we have a Windows and MacOS on a big
253 * endian machine
254 */
255 {WINED3DFMT_UYVY, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, 0,
256 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
257 WINED3DFMT_FLAG_FILTERING,
258 WINED3D_GL_EXT_NONE},
259 {WINED3DFMT_UYVY, GL_RGB, GL_RGB, 0,
260 GL_YCBCR_422_APPLE, UNSIGNED_SHORT_8_8_APPLE,
261 WINED3DFMT_FLAG_FILTERING,
262 APPLE_YCBCR_422},
263 {WINED3DFMT_YUY2, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, 0,
264 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
265 WINED3DFMT_FLAG_FILTERING,
266 WINED3D_GL_EXT_NONE},
267 {WINED3DFMT_YUY2, GL_RGB, GL_RGB, 0,
268 GL_YCBCR_422_APPLE, UNSIGNED_SHORT_8_8_REV_APPLE,
269 WINED3DFMT_FLAG_FILTERING,
270 APPLE_YCBCR_422},
271 {WINED3DFMT_YV12, GL_ALPHA, GL_ALPHA, 0,
272 GL_ALPHA, GL_UNSIGNED_BYTE,
273 WINED3DFMT_FLAG_FILTERING,
274 WINED3D_GL_EXT_NONE},
275 {WINED3DFMT_DXT1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0,
276 GL_RGBA, GL_UNSIGNED_BYTE,
277 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
278 EXT_TEXTURE_COMPRESSION_S3TC},
279 {WINED3DFMT_DXT2, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
280 GL_RGBA, GL_UNSIGNED_BYTE,
281 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
282 EXT_TEXTURE_COMPRESSION_S3TC},
283 {WINED3DFMT_DXT3, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0,
284 GL_RGBA, GL_UNSIGNED_BYTE,
285 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
286 EXT_TEXTURE_COMPRESSION_S3TC},
287 {WINED3DFMT_DXT4, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
288 GL_RGBA, GL_UNSIGNED_BYTE,
289 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
290 EXT_TEXTURE_COMPRESSION_S3TC},
291 {WINED3DFMT_DXT5, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0,
292 GL_RGBA, GL_UNSIGNED_BYTE,
293 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
294 EXT_TEXTURE_COMPRESSION_S3TC},
295 /* IEEE formats */
296 {WINED3DFMT_R32_FLOAT, GL_RGB32F_ARB, GL_RGB32F_ARB, 0,
297 GL_RED, GL_FLOAT,
298 WINED3DFMT_FLAG_RENDERTARGET,
299 ARB_TEXTURE_FLOAT},
300 {WINED3DFMT_R32_FLOAT, GL_R32F, GL_R32F, 0,
301 GL_RED, GL_FLOAT,
302 WINED3DFMT_FLAG_RENDERTARGET,
303 ARB_TEXTURE_RG},
304 {WINED3DFMT_R32G32_FLOAT, GL_RGB32F_ARB, GL_RGB32F_ARB, 0,
305 GL_RGB, GL_FLOAT,
306 WINED3DFMT_FLAG_RENDERTARGET,
307 ARB_TEXTURE_FLOAT},
308 {WINED3DFMT_R32G32_FLOAT, GL_RG32F, GL_RG32F, 0,
309 GL_RG, GL_FLOAT,
310 WINED3DFMT_FLAG_RENDERTARGET,
311 ARB_TEXTURE_RG},
312 {WINED3DFMT_R32G32B32A32_FLOAT, GL_RGBA32F_ARB, GL_RGBA32F_ARB, 0,
313 GL_RGBA, GL_FLOAT,
314 WINED3DFMT_FLAG_RENDERTARGET,
315 ARB_TEXTURE_FLOAT},
316 /* Float */
317 {WINED3DFMT_R16_FLOAT, GL_RGB16F_ARB, GL_RGB16F_ARB, 0,
318 GL_RED, GL_HALF_FLOAT_ARB,
319 WINED3DFMT_FLAG_RENDERTARGET,
320 ARB_TEXTURE_FLOAT},
321 {WINED3DFMT_R16_FLOAT, GL_R16F, GL_R16F, 0,
322 GL_RED, GL_HALF_FLOAT_ARB,
323 WINED3DFMT_FLAG_RENDERTARGET,
324 ARB_TEXTURE_RG},
325 {WINED3DFMT_R16G16_FLOAT, GL_RGB16F_ARB, GL_RGB16F_ARB, 0,
326 GL_RGB, GL_HALF_FLOAT_ARB,
327 WINED3DFMT_FLAG_RENDERTARGET,
328 ARB_TEXTURE_FLOAT},
329 {WINED3DFMT_R16G16_FLOAT, GL_RG16F, GL_RG16F, 0,
330 GL_RG, GL_HALF_FLOAT_ARB,
331 WINED3DFMT_FLAG_RENDERTARGET,
332 ARB_TEXTURE_RG},
333 {WINED3DFMT_R16G16B16A16_FLOAT, GL_RGBA16F_ARB, GL_RGBA16F_ARB, 0,
334 GL_RGBA, GL_HALF_FLOAT_ARB,
335 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_RENDERTARGET,
336 ARB_TEXTURE_FLOAT},
337 /* Palettized formats */
338 {WINED3DFMT_P8_UINT, GL_RGBA, GL_RGBA, 0,
339 GL_RGBA, GL_UNSIGNED_BYTE,
340 0,
341 ARB_FRAGMENT_PROGRAM},
342 {WINED3DFMT_P8_UINT, GL_COLOR_INDEX8_EXT, GL_COLOR_INDEX8_EXT, 0,
343 GL_COLOR_INDEX, GL_UNSIGNED_BYTE,
344 0,
345 EXT_PALETTED_TEXTURE},
346 /* Standard ARGB formats */
347 {WINED3DFMT_B8G8R8_UNORM, GL_RGB8, GL_RGB8, 0,
348 GL_BGR, GL_UNSIGNED_BYTE,
349 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
350 WINED3D_GL_EXT_NONE},
351 {WINED3DFMT_B8G8R8A8_UNORM, GL_RGBA8, GL_SRGB8_ALPHA8_EXT, 0,
352 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
353 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
354 WINED3D_GL_EXT_NONE},
355 {WINED3DFMT_B8G8R8X8_UNORM, GL_RGB8, GL_SRGB8_EXT, 0,
356 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
357 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
358 WINED3D_GL_EXT_NONE},
359 {WINED3DFMT_B5G6R5_UNORM, GL_RGB5, GL_RGB5, GL_RGB8,
360 GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
361 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
362 WINED3D_GL_EXT_NONE},
363 {WINED3DFMT_B5G5R5X1_UNORM, GL_RGB5, GL_RGB5_A1, 0,
364 GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV,
365 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
366 WINED3D_GL_EXT_NONE},
367 {WINED3DFMT_B5G5R5A1_UNORM, GL_RGB5_A1, GL_RGB5_A1, 0,
368 GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV,
369 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
370 WINED3D_GL_EXT_NONE},
371 {WINED3DFMT_B4G4R4A4_UNORM, GL_RGBA4, GL_SRGB8_ALPHA8_EXT, 0,
372 GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV,
373 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
374 WINED3D_GL_EXT_NONE},
375 {WINED3DFMT_B2G3R3_UNORM, GL_R3_G3_B2, GL_R3_G3_B2, 0,
376 GL_RGB, GL_UNSIGNED_BYTE_3_3_2,
377 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING,
378 WINED3D_GL_EXT_NONE},
379 {WINED3DFMT_A8_UNORM, GL_ALPHA8, GL_ALPHA8, 0,
380 GL_ALPHA, GL_UNSIGNED_BYTE,
381 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING,
382 WINED3D_GL_EXT_NONE},
383 {WINED3DFMT_B4G4R4X4_UNORM, GL_RGB4, GL_RGB4, 0,
384 GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV,
385 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
386 WINED3D_GL_EXT_NONE},
387 {WINED3DFMT_R10G10B10A2_UNORM, GL_RGB10_A2, GL_RGB10_A2, 0,
388 GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV,
389 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
390 WINED3D_GL_EXT_NONE},
391 {WINED3DFMT_R8G8B8A8_UNORM, GL_RGBA8, GL_RGBA8, 0,
392 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV,
393 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
394 WINED3D_GL_EXT_NONE},
395 {WINED3DFMT_R8G8B8X8_UNORM, GL_RGB8, GL_RGB8, 0,
396 GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV,
397 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
398 WINED3D_GL_EXT_NONE},
399 {WINED3DFMT_R16G16_UNORM, GL_RGB16_EXT, GL_RGB16_EXT, GL_RGBA16_EXT,
400 GL_RGB, GL_UNSIGNED_SHORT,
401 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
402 WINED3D_GL_EXT_NONE},
403 {WINED3DFMT_B10G10R10A2_UNORM, GL_RGB10_A2, GL_RGB10_A2, 0,
404 GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV,
405 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
406 WINED3D_GL_EXT_NONE},
407 {WINED3DFMT_R16G16B16A16_UNORM, GL_RGBA16_EXT, GL_RGBA16_EXT, 0,
408 GL_RGBA, GL_UNSIGNED_SHORT,
409 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET,
410 WINED3D_GL_EXT_NONE},
411 /* Luminance */
412 {WINED3DFMT_L8_UNORM, GL_LUMINANCE8, GL_SLUMINANCE8_EXT, 0,
413 GL_LUMINANCE, GL_UNSIGNED_BYTE,
414 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
415 WINED3D_GL_EXT_NONE},
416 {WINED3DFMT_L8A8_UNORM, GL_LUMINANCE8_ALPHA8, GL_SLUMINANCE8_ALPHA8_EXT, 0,
417 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
418 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
419 WINED3D_GL_EXT_NONE},
420 {WINED3DFMT_L4A4_UNORM, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE4_ALPHA4, 0,
421 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
422 0,
423 WINED3D_GL_EXT_NONE},
424 /* Bump mapping stuff */
425 {WINED3DFMT_R8G8_SNORM, GL_RGB8, GL_RGB8, 0,
426 GL_BGR, GL_UNSIGNED_BYTE,
427 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
428 WINED3D_GL_EXT_NONE},
429 {WINED3DFMT_R8G8_SNORM, GL_DSDT8_NV, GL_DSDT8_NV, 0,
430 GL_DSDT_NV, GL_BYTE,
431 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
432 NV_TEXTURE_SHADER},
433 {WINED3DFMT_R5G5_SNORM_L6_UNORM, GL_RGB5, GL_RGB5, 0,
434 GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
435 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
436 WINED3D_GL_EXT_NONE},
437 {WINED3DFMT_R5G5_SNORM_L6_UNORM, GL_DSDT8_MAG8_NV, GL_DSDT8_MAG8_NV, 0,
438 GL_DSDT_MAG_NV, GL_BYTE,
439 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
440 NV_TEXTURE_SHADER},
441 {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, GL_RGB8, GL_RGB8, 0,
442 GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
443 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
444 WINED3D_GL_EXT_NONE},
445 {WINED3DFMT_R8G8_SNORM_L8X8_UNORM, GL_DSDT8_MAG8_INTENSITY8_NV, GL_DSDT8_MAG8_INTENSITY8_NV, 0,
446 GL_DSDT_MAG_VIB_NV, GL_UNSIGNED_INT_8_8_S8_S8_REV_NV,
447 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
448 NV_TEXTURE_SHADER},
449 {WINED3DFMT_R8G8B8A8_SNORM, GL_RGBA8, GL_RGBA8, 0,
450 GL_BGRA, GL_UNSIGNED_BYTE,
451 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
452 WINED3D_GL_EXT_NONE},
453 {WINED3DFMT_R8G8B8A8_SNORM, GL_SIGNED_RGBA8_NV, GL_SIGNED_RGBA8_NV, 0,
454 GL_RGBA, GL_BYTE,
455 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
456 NV_TEXTURE_SHADER},
457 {WINED3DFMT_R16G16_SNORM, GL_RGB16_EXT, GL_RGB16_EXT, 0,
458 GL_BGR, GL_UNSIGNED_SHORT,
459 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
460 WINED3D_GL_EXT_NONE},
461 {WINED3DFMT_R16G16_SNORM, GL_SIGNED_HILO16_NV, GL_SIGNED_HILO16_NV, 0,
462 GL_HILO_NV, GL_SHORT,
463 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
464 NV_TEXTURE_SHADER},
465 /* Depth stencil formats */
466 {WINED3DFMT_D16_LOCKABLE, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
467 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,
468 WINED3DFMT_FLAG_DEPTH,
469 ARB_DEPTH_TEXTURE},
470 {WINED3DFMT_D32_UNORM, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT32_ARB, 0,
471 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
472 WINED3DFMT_FLAG_DEPTH,
473 ARB_DEPTH_TEXTURE},
474 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
475 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,
476 WINED3DFMT_FLAG_DEPTH,
477 ARB_DEPTH_TEXTURE},
478 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
479 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
480 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
481 EXT_PACKED_DEPTH_STENCIL},
482 {WINED3DFMT_S1_UINT_D15_UNORM, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
483 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8,
484 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
485 ARB_FRAMEBUFFER_OBJECT},
486 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
487 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
488 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH,
489 ARB_DEPTH_TEXTURE},
490 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
491 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
492 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
493 EXT_PACKED_DEPTH_STENCIL},
494 {WINED3DFMT_D24_UNORM_S8_UINT, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
495 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8,
496 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
497 ARB_FRAMEBUFFER_OBJECT},
498 {WINED3DFMT_X8D24_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
499 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
500 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH,
501 ARB_DEPTH_TEXTURE},
502 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
503 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
504 WINED3DFMT_FLAG_DEPTH,
505 ARB_DEPTH_TEXTURE},
506 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH24_STENCIL8_EXT, 0,
507 GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT,
508 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
509 EXT_PACKED_DEPTH_STENCIL},
510 {WINED3DFMT_S4X4_UINT_D24_UNORM, GL_DEPTH24_STENCIL8, GL_DEPTH24_STENCIL8, 0,
511 GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8,
512 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
513 ARB_FRAMEBUFFER_OBJECT},
514 {WINED3DFMT_D16_UNORM, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT24_ARB, 0,
515 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,
516 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH,
517 ARB_DEPTH_TEXTURE},
518 {WINED3DFMT_L16_UNORM, GL_LUMINANCE16_EXT, GL_LUMINANCE16_EXT, 0,
519 GL_LUMINANCE, GL_UNSIGNED_SHORT,
520 WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING,
521 WINED3D_GL_EXT_NONE},
522 {WINED3DFMT_D32_FLOAT, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT32F, 0,
523 GL_DEPTH_COMPONENT, GL_FLOAT,
524 WINED3DFMT_FLAG_DEPTH,
525 ARB_DEPTH_BUFFER_FLOAT},
526 {WINED3DFMT_S8_UINT_D24_FLOAT, GL_DEPTH32F_STENCIL8, GL_DEPTH32F_STENCIL8, 0,
527 GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
528 WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL,
529 ARB_DEPTH_BUFFER_FLOAT},
530 /* Vendor-specific formats */
531 {WINED3DFMT_ATI2N, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0,
532 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
533 0,
534 ATI_TEXTURE_COMPRESSION_3DC},
535 {WINED3DFMT_ATI2N, GL_COMPRESSED_RED_GREEN_RGTC2_EXT, GL_COMPRESSED_RED_GREEN_RGTC2_EXT, 0,
536 GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
537 0,
538 EXT_TEXTURE_COMPRESSION_RGTC},
539};
540
541static inline int getFmtIdx(WINED3DFORMAT fmt) {
542 /* First check if the format is at the position of its value.
543 * This will catch the argb formats before the loop is entered
544 */
545 if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
546 return fmt;
547 } else {
548 unsigned int i;
549 for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
550 if(formats[i].format == fmt) {
551 return i;
552 }
553 }
554 }
555 return -1;
556}
557
558static BOOL init_format_base_info(struct wined3d_gl_info *gl_info)
559{
560 UINT format_count = sizeof(formats) / sizeof(*formats);
561 UINT i;
562
563 gl_info->gl_formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, format_count * sizeof(*gl_info->gl_formats));
564 if (!gl_info->gl_formats)
565 {
566 ERR("Failed to allocate memory.\n");
567 return FALSE;
568 }
569
570 for (i = 0; i < format_count; ++i)
571 {
572 struct GlPixelFormatDesc *desc = &gl_info->gl_formats[i];
573 desc->format = formats[i].format;
574 desc->red_mask = formats[i].redMask;
575 desc->green_mask = formats[i].greenMask;
576 desc->blue_mask = formats[i].blueMask;
577 desc->alpha_mask = formats[i].alphaMask;
578 desc->byte_count = formats[i].bpp;
579 desc->depth_size = formats[i].depthSize;
580 desc->stencil_size = formats[i].stencilSize;
581 }
582
583 for (i = 0; i < (sizeof(format_base_flags) / sizeof(*format_base_flags)); ++i)
584 {
585 int fmt_idx = getFmtIdx(format_base_flags[i].format);
586
587 if (fmt_idx == -1)
588 {
589 ERR("Format %s (%#x) not found.\n",
590 debug_d3dformat(format_base_flags[i].format), format_base_flags[i].format);
591 HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
592 return FALSE;
593 }
594
595 gl_info->gl_formats[fmt_idx].Flags |= format_base_flags[i].flags;
596 }
597
598 return TRUE;
599}
600
601static BOOL init_format_compression_info(struct wined3d_gl_info *gl_info)
602{
603 unsigned int i;
604
605 for (i = 0; i < (sizeof(format_compression_info) / sizeof(*format_compression_info)); ++i)
606 {
607 struct GlPixelFormatDesc *format_desc;
608 int fmt_idx = getFmtIdx(format_compression_info[i].format);
609
610 if (fmt_idx == -1)
611 {
612 ERR("Format %s (%#x) not found.\n",
613 debug_d3dformat(format_compression_info[i].format), format_compression_info[i].format);
614 return FALSE;
615 }
616
617 format_desc = &gl_info->gl_formats[fmt_idx];
618 format_desc->block_width = format_compression_info[i].block_width;
619 format_desc->block_height = format_compression_info[i].block_height;
620 format_desc->block_byte_count = format_compression_info[i].block_byte_count;
621 format_desc->Flags |= WINED3DFMT_FLAG_COMPRESSED;
622 }
623
624 return TRUE;
625}
626
627/* Context activation is done by the caller. */
628static void check_fbo_compat(const struct wined3d_gl_info *gl_info, struct GlPixelFormatDesc *format_desc)
629{
630 /* Check if the default internal format is supported as a frame buffer
631 * target, otherwise fall back to the render target internal.
632 *
633 * Try to stick to the standard format if possible, this limits precision differences. */
634 GLenum status;
635 GLuint tex;
636
637 ENTER_GL();
638
639 while(glGetError());
640 glDisable(GL_BLEND);
641
642 glGenTextures(1, &tex);
643 glBindTexture(GL_TEXTURE_2D, tex);
644
645 glTexImage2D(GL_TEXTURE_2D, 0, format_desc->glInternal, 16, 16, 0,
646 format_desc->glFormat, format_desc->glType, NULL);
647 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
648 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
649
650 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
651
652 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
653 checkGLcall("Framebuffer format check");
654
655 if (status == GL_FRAMEBUFFER_COMPLETE)
656 {
657 TRACE("Format %s is supported as FBO color attachment\n", debug_d3dformat(format_desc->format));
658 format_desc->Flags |= WINED3DFMT_FLAG_FBO_ATTACHABLE;
659 format_desc->rtInternal = format_desc->glInternal;
660 }
661 else
662 {
663 if (!format_desc->rtInternal)
664 {
665 if (format_desc->Flags & WINED3DFMT_FLAG_RENDERTARGET)
666 {
667 FIXME("Format %s with rendertarget flag is not supported as FBO color attachment,"
668 " and no fallback specified.\n", debug_d3dformat(format_desc->format));
669 format_desc->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
670 }
671 else
672 {
673 TRACE("Format %s is not supported as FBO color attachment.\n", debug_d3dformat(format_desc->format));
674 }
675 format_desc->rtInternal = format_desc->glInternal;
676 }
677 else
678 {
679 TRACE("Format %s is not supported as FBO color attachment, trying rtInternal format as fallback.\n",
680 debug_d3dformat(format_desc->format));
681
682 while(glGetError());
683
684 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
685
686 glTexImage2D(GL_TEXTURE_2D, 0, format_desc->rtInternal, 16, 16, 0,
687 format_desc->glFormat, format_desc->glType, NULL);
688 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
689 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
690
691 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
692
693 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
694 checkGLcall("Framebuffer format check");
695
696 if (status == GL_FRAMEBUFFER_COMPLETE)
697 {
698 TRACE("Format %s rtInternal format is supported as FBO color attachment\n",
699 debug_d3dformat(format_desc->format));
700 }
701 else
702 {
703 FIXME("Format %s rtInternal format is not supported as FBO color attachment.\n",
704 debug_d3dformat(format_desc->format));
705 format_desc->Flags &= ~WINED3DFMT_FLAG_RENDERTARGET;
706 }
707 }
708 }
709
710 if (status == GL_FRAMEBUFFER_COMPLETE && format_desc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
711 {
712 GLuint rb;
713
714 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
715 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
716 {
717 gl_info->fbo_ops.glGenRenderbuffers(1, &rb);
718 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, rb);
719 gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 16, 16);
720 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb);
721 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rb);
722 checkGLcall("RB attachment");
723 }
724
725 glEnable(GL_BLEND);
726 glClear(GL_COLOR_BUFFER_BIT);
727 if (glGetError() == GL_INVALID_FRAMEBUFFER_OPERATION)
728 {
729 while(glGetError());
730 TRACE("Format doesn't support post-pixelshader blending.\n");
731 format_desc->Flags &= ~WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING;
732 }
733
734 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
735 || gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
736 {
737 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
738 gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
739 gl_info->fbo_ops.glDeleteRenderbuffers(1, &rb);
740 checkGLcall("RB cleanup");
741 }
742 }
743
744 glDeleteTextures(1, &tex);
745
746 LEAVE_GL();
747}
748
749/* Context activation is done by the caller. */
750static void init_format_fbo_compat_info(struct wined3d_gl_info *gl_info)
751{
752 unsigned int i;
753 GLuint fbo;
754
755 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
756 {
757 ENTER_GL();
758
759 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
760 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
761
762 LEAVE_GL();
763 }
764
765 for (i = 0; i < sizeof(formats) / sizeof(*formats); ++i)
766 {
767 struct GlPixelFormatDesc *desc = &gl_info->gl_formats[i];
768
769 if (!desc->glInternal) continue;
770
771 if (desc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
772 {
773 TRACE("Skipping format %s because it's a depth/stencil format.\n",
774 debug_d3dformat(desc->format));
775 continue;
776 }
777
778 if (desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
779 {
780 TRACE("Skipping format %s because it's a compressed format.\n",
781 debug_d3dformat(desc->format));
782 continue;
783 }
784
785 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
786 {
787 TRACE("Checking if format %s is supported as FBO color attachment...\n", debug_d3dformat(desc->format));
788 check_fbo_compat(gl_info, desc);
789 }
790 else
791 {
792 desc->rtInternal = desc->glInternal;
793 }
794 }
795
796 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
797 {
798 ENTER_GL();
799
800 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
801
802 LEAVE_GL();
803 }
804}
805
806static BOOL init_format_texture_info(struct wined3d_gl_info *gl_info)
807{
808 unsigned int i;
809
810 for (i = 0; i < sizeof(gl_formats_template) / sizeof(gl_formats_template[0]); ++i)
811 {
812 int fmt_idx = getFmtIdx(gl_formats_template[i].fmt);
813 struct GlPixelFormatDesc *desc;
814
815 if (fmt_idx == -1)
816 {
817 ERR("Format %s (%#x) not found.\n",
818 debug_d3dformat(gl_formats_template[i].fmt), gl_formats_template[i].fmt);
819 return FALSE;
820 }
821
822 if (!gl_info->supported[gl_formats_template[i].extension]) continue;
823
824 desc = &gl_info->gl_formats[fmt_idx];
825 desc->glInternal = gl_formats_template[i].glInternal;
826 desc->glGammaInternal = gl_formats_template[i].glGammaInternal;
827 desc->rtInternal = gl_formats_template[i].rtInternal;
828 desc->glFormat = gl_formats_template[i].glFormat;
829 desc->glType = gl_formats_template[i].glType;
830 desc->color_fixup = COLOR_FIXUP_IDENTITY;
831 desc->Flags |= gl_formats_template[i].Flags;
832 desc->heightscale = 1.0f;
833 }
834
835 return TRUE;
836}
837
838static BOOL color_match(DWORD c1, DWORD c2, BYTE max_diff)
839{
840 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
841 c1 >>= 8; c2 >>= 8;
842 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
843 c1 >>= 8; c2 >>= 8;
844 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
845 c1 >>= 8; c2 >>= 8;
846 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
847 return TRUE;
848}
849
850/* A context is provided by the caller */
851static BOOL check_filter(const struct wined3d_gl_info *gl_info, GLenum internal)
852{
853 GLuint tex, fbo, buffer;
854 const DWORD data[] = {0x00000000, 0xffffffff};
855 DWORD readback[16 * 1];
856 BOOL ret = FALSE;
857
858 /* Render a filtered texture and see what happens. This is intended to detect the lack of
859 * float16 filtering on ATI X1000 class cards. The drivers disable filtering instead of
860 * falling back to software. If this changes in the future this code will get fooled and
861 * apps might hit the software path due to incorrectly advertised caps.
862 *
863 * Its unlikely that this changes however. GL Games like Mass Effect depend on the filter
864 * disable fallback, if Apple or ATI ever change the driver behavior they will break more
865 * than Wine. The Linux binary <= r500 driver is not maintained any more anyway
866 */
867
868 ENTER_GL();
869 while(glGetError());
870
871 glGenTextures(1, &buffer);
872 glBindTexture(GL_TEXTURE_2D, buffer);
873 memset(readback, 0x7e, sizeof(readback));
874 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, readback);
875 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
876 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
877 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
878 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
879 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
880
881 glGenTextures(1, &tex);
882 glBindTexture(GL_TEXTURE_2D, tex);
883 glTexImage2D(GL_TEXTURE_2D, 0, internal, 2, 1, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
884 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
885 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
886 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
887 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
888 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
889 glEnable(GL_TEXTURE_2D);
890
891 gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
892 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
893 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer, 0);
894 glDrawBuffer(GL_COLOR_ATTACHMENT0);
895
896 glViewport(0, 0, 16, 1);
897 glDisable(GL_LIGHTING);
898 glMatrixMode(GL_MODELVIEW);
899 glLoadIdentity();
900 glMatrixMode(GL_PROJECTION);
901 glLoadIdentity();
902
903 glClearColor(0, 1, 0, 0);
904 glClear(GL_COLOR_BUFFER_BIT);
905
906 glBegin(GL_TRIANGLE_STRIP);
907 glTexCoord2f(0.0, 0.0);
908 glVertex2f(-1.0f, -1.0f);
909 glTexCoord2f(1.0, 0.0);
910 glVertex2f(1.0f, -1.0f);
911 glTexCoord2f(0.0, 1.0);
912 glVertex2f(-1.0f, 1.0f);
913 glTexCoord2f(1.0, 1.0);
914 glVertex2f(1.0f, 1.0f);
915 glEnd();
916
917 glBindTexture(GL_TEXTURE_2D, buffer);
918 memset(readback, 0x7f, sizeof(readback));
919 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, readback);
920 if(color_match(readback[6], 0xffffffff, 5) || color_match(readback[6], 0x00000000, 5) ||
921 color_match(readback[9], 0xffffffff, 5) || color_match(readback[9], 0x00000000, 5))
922 {
923 TRACE("Read back colors 0x%08x and 0x%08x close to unfiltered color, asuming no filtering\n",
924 readback[6], readback[9]);
925 ret = FALSE;
926 }
927 else
928 {
929 TRACE("Read back colors are 0x%08x and 0x%08x, assuming texture is filtered\n",
930 readback[6], readback[9]);
931 ret = TRUE;
932 }
933
934 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
935 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
936 glDeleteTextures(1, &tex);
937 glDeleteTextures(1, &buffer);
938
939 if(glGetError())
940 {
941 FIXME("Error during filtering test for format %x, returning no filtering\n", internal);
942 ret = FALSE;
943 }
944 LEAVE_GL();
945 return ret;
946}
947
948static void init_format_filter_info(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
949{
950 unsigned int fmt_idx, i;
951 WINED3DFORMAT fmts16[] = {
952 WINED3DFMT_R16_FLOAT,
953 WINED3DFMT_R16G16_FLOAT,
954 WINED3DFMT_R16G16B16A16_FLOAT,
955 };
956 BOOL filtered;
957 struct GlPixelFormatDesc *desc;
958
959 if(wined3d_settings.offscreen_rendering_mode != ORM_FBO)
960 {
961 WARN("No FBO support, or no FBO ORM, guessing filter info from GL caps\n");
962 if (vendor == VENDOR_NVIDIA && gl_info->supported[ARB_TEXTURE_FLOAT])
963 {
964 TRACE("Nvidia card with texture_float support: Assuming float16 blending\n");
965 filtered = TRUE;
966 }
967 else if (gl_info->limits.glsl_varyings > 44)
968 {
969 TRACE("More than 44 GLSL varyings - assuming d3d10 card with float16 blending\n");
970 filtered = TRUE;
971 }
972 else
973 {
974 TRACE("Assuming no float16 blending\n");
975 filtered = FALSE;
976 }
977
978 if(filtered)
979 {
980 for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
981 {
982 fmt_idx = getFmtIdx(fmts16[i]);
983 gl_info->gl_formats[fmt_idx].Flags |= WINED3DFMT_FLAG_FILTERING;
984 }
985 }
986 return;
987 }
988
989 for(i = 0; i < (sizeof(fmts16) / sizeof(*fmts16)); i++)
990 {
991 fmt_idx = getFmtIdx(fmts16[i]);
992 desc = &gl_info->gl_formats[fmt_idx];
993 if(!desc->glInternal) continue; /* Not supported by GL */
994
995 filtered = check_filter(gl_info, gl_info->gl_formats[fmt_idx].glInternal);
996 if(filtered)
997 {
998 TRACE("Format %s supports filtering\n", debug_d3dformat(fmts16[i]));
999 desc->Flags |= WINED3DFMT_FLAG_FILTERING;
1000 }
1001 else
1002 {
1003 TRACE("Format %s does not support filtering\n", debug_d3dformat(fmts16[i]));
1004 }
1005 }
1006}
1007
1008static void apply_format_fixups(struct wined3d_gl_info *gl_info)
1009{
1010 int idx;
1011
1012 idx = getFmtIdx(WINED3DFMT_R16_FLOAT);
1013 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1014 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1015
1016 idx = getFmtIdx(WINED3DFMT_R32_FLOAT);
1017 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1018 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1019
1020 idx = getFmtIdx(WINED3DFMT_R16G16_UNORM);
1021 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1022 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1023
1024 idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1025 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1026 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1027
1028 idx = getFmtIdx(WINED3DFMT_R32G32_FLOAT);
1029 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1030 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
1031
1032 /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
1033 * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
1034 * their extensions are not available. GL_ATI_envmap_bumpmap is not used because
1035 * the only driver that implements it(fglrx) has a buggy implementation.
1036 *
1037 * V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
1038 * returns 0.0 when sampling from it, DirectX 1.0. So we always have in-shader
1039 * conversion for this format.
1040 */
1041 if (!gl_info->supported[NV_TEXTURE_SHADER])
1042 {
1043 idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
1044 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1045 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1046 idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
1047 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1048 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1049 }
1050 else
1051 {
1052 idx = getFmtIdx(WINED3DFMT_R8G8_SNORM);
1053 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1054 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1055 idx = getFmtIdx(WINED3DFMT_R16G16_SNORM);
1056 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1057 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1058 }
1059
1060 if (!gl_info->supported[NV_TEXTURE_SHADER])
1061 {
1062 /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
1063 * with each other
1064 */
1065 idx = getFmtIdx(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1066 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1067 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
1068 idx = getFmtIdx(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1069 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1070 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
1071 idx = getFmtIdx(WINED3DFMT_R8G8B8A8_SNORM);
1072 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1073 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
1074 }
1075 else
1076 {
1077 /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
1078 * are converted at surface loading time, but they do not need any modification in
1079 * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
1080 * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
1081 */
1082 }
1083
1084 if (gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
1085 {
1086 idx = getFmtIdx(WINED3DFMT_ATI2N);
1087 gl_info->gl_formats[idx].color_fixup = create_color_fixup_desc(
1088 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1089 }
1090 else if (gl_info->supported[ATI_TEXTURE_COMPRESSION_3DC])
1091 {
1092 idx = getFmtIdx(WINED3DFMT_ATI2N);
1093 gl_info->gl_formats[idx].color_fixup= create_color_fixup_desc(
1094 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
1095 }
1096
1097 if (!gl_info->supported[APPLE_YCBCR_422])
1098 {
1099 idx = getFmtIdx(WINED3DFMT_YUY2);
1100 gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_YUY2);
1101
1102 idx = getFmtIdx(WINED3DFMT_UYVY);
1103 gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_UYVY);
1104 }
1105
1106 idx = getFmtIdx(WINED3DFMT_YV12);
1107 gl_info->gl_formats[idx].heightscale = 1.5f;
1108 gl_info->gl_formats[idx].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_YV12);
1109
1110 if (gl_info->supported[EXT_VERTEX_ARRAY_BGRA])
1111 {
1112 idx = getFmtIdx(WINED3DFMT_B8G8R8A8_UNORM);
1113 gl_info->gl_formats[idx].gl_vtx_format = GL_BGRA;
1114 }
1115
1116 if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
1117 {
1118 /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
1119 * It is the job of the vertex buffer code to make sure that the vbos have the right format */
1120 idx = getFmtIdx(WINED3DFMT_R16G16_FLOAT);
1121 gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT; /* == GL_HALF_FLOAT_NV */
1122
1123 idx = getFmtIdx(WINED3DFMT_R16G16B16A16_FLOAT);
1124 gl_info->gl_formats[idx].gl_vtx_type = GL_HALF_FLOAT;
1125 }
1126}
1127
1128static BOOL init_format_vertex_info(struct wined3d_gl_info *gl_info)
1129{
1130 unsigned int i;
1131
1132 for (i = 0; i < (sizeof(format_vertex_info) / sizeof(*format_vertex_info)); ++i)
1133 {
1134 struct GlPixelFormatDesc *format_desc;
1135 int fmt_idx = getFmtIdx(format_vertex_info[i].format);
1136
1137 if (fmt_idx == -1)
1138 {
1139 ERR("Format %s (%#x) not found.\n",
1140 debug_d3dformat(format_vertex_info[i].format), format_vertex_info[i].format);
1141 return FALSE;
1142 }
1143
1144 format_desc = &gl_info->gl_formats[fmt_idx];
1145 format_desc->emit_idx = format_vertex_info[i].emit_idx;
1146 format_desc->component_count = format_vertex_info[i].component_count;
1147 format_desc->gl_vtx_type = format_vertex_info[i].gl_vtx_type;
1148 format_desc->gl_vtx_format = format_vertex_info[i].gl_vtx_format;
1149 format_desc->gl_normalized = format_vertex_info[i].gl_normalized;
1150 format_desc->component_size = format_vertex_info[i].component_size;
1151 }
1152
1153 return TRUE;
1154}
1155
1156BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info)
1157{
1158 if (!init_format_base_info(gl_info)) return FALSE;
1159
1160 if (!init_format_compression_info(gl_info))
1161 {
1162 HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
1163 gl_info->gl_formats = NULL;
1164 return FALSE;
1165 }
1166
1167 return TRUE;
1168}
1169
1170/* Context activation is done by the caller. */
1171BOOL initPixelFormats(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor)
1172{
1173 if (!init_format_base_info(gl_info)) return FALSE;
1174
1175 if (!init_format_compression_info(gl_info)) goto fail;
1176 if (!init_format_texture_info(gl_info)) goto fail;
1177 if (!init_format_vertex_info(gl_info)) goto fail;
1178
1179 apply_format_fixups(gl_info);
1180 init_format_fbo_compat_info(gl_info);
1181 init_format_filter_info(gl_info, vendor);
1182
1183 return TRUE;
1184
1185fail:
1186 HeapFree(GetProcessHeap(), 0, gl_info->gl_formats);
1187 gl_info->gl_formats = NULL;
1188 return FALSE;
1189}
1190
1191const struct GlPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, const struct wined3d_gl_info *gl_info)
1192{
1193 int idx = getFmtIdx(fmt);
1194
1195 if(idx == -1) {
1196 FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
1197 /* Get the caller a valid pointer */
1198 idx = getFmtIdx(WINED3DFMT_UNKNOWN);
1199 }
1200
1201 return &gl_info->gl_formats[idx];
1202}
1203
1204/*****************************************************************************
1205 * Trace formatting of useful values
1206 */
1207const char* debug_d3dformat(WINED3DFORMAT fmt) {
1208 switch (fmt) {
1209#define FMT_TO_STR(fmt) case fmt: return #fmt
1210 FMT_TO_STR(WINED3DFMT_UNKNOWN);
1211 FMT_TO_STR(WINED3DFMT_B8G8R8_UNORM);
1212 FMT_TO_STR(WINED3DFMT_B5G5R5X1_UNORM);
1213 FMT_TO_STR(WINED3DFMT_B4G4R4A4_UNORM);
1214 FMT_TO_STR(WINED3DFMT_B2G3R3_UNORM);
1215 FMT_TO_STR(WINED3DFMT_B2G3R3A8_UNORM);
1216 FMT_TO_STR(WINED3DFMT_B4G4R4X4_UNORM);
1217 FMT_TO_STR(WINED3DFMT_R8G8B8X8_UNORM);
1218 FMT_TO_STR(WINED3DFMT_B10G10R10A2_UNORM);
1219 FMT_TO_STR(WINED3DFMT_P8_UINT_A8_UNORM);
1220 FMT_TO_STR(WINED3DFMT_P8_UINT);
1221 FMT_TO_STR(WINED3DFMT_L8_UNORM);
1222 FMT_TO_STR(WINED3DFMT_L8A8_UNORM);
1223 FMT_TO_STR(WINED3DFMT_L4A4_UNORM);
1224 FMT_TO_STR(WINED3DFMT_R5G5_SNORM_L6_UNORM);
1225 FMT_TO_STR(WINED3DFMT_R8G8_SNORM_L8X8_UNORM);
1226 FMT_TO_STR(WINED3DFMT_R10G11B11_SNORM);
1227 FMT_TO_STR(WINED3DFMT_R10G10B10_SNORM_A2_UNORM);
1228 FMT_TO_STR(WINED3DFMT_UYVY);
1229 FMT_TO_STR(WINED3DFMT_YUY2);
1230 FMT_TO_STR(WINED3DFMT_YV12);
1231 FMT_TO_STR(WINED3DFMT_DXT1);
1232 FMT_TO_STR(WINED3DFMT_DXT2);
1233 FMT_TO_STR(WINED3DFMT_DXT3);
1234 FMT_TO_STR(WINED3DFMT_DXT4);
1235 FMT_TO_STR(WINED3DFMT_DXT5);
1236 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
1237 FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
1238 FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
1239 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
1240 FMT_TO_STR(WINED3DFMT_D32_UNORM);
1241 FMT_TO_STR(WINED3DFMT_S1_UINT_D15_UNORM);
1242 FMT_TO_STR(WINED3DFMT_X8D24_UNORM);
1243 FMT_TO_STR(WINED3DFMT_S4X4_UINT_D24_UNORM);
1244 FMT_TO_STR(WINED3DFMT_L16_UNORM);
1245 FMT_TO_STR(WINED3DFMT_S8_UINT_D24_FLOAT);
1246 FMT_TO_STR(WINED3DFMT_VERTEXDATA);
1247 FMT_TO_STR(WINED3DFMT_R8G8_SNORM_Cx);
1248 FMT_TO_STR(WINED3DFMT_ATI2N);
1249 FMT_TO_STR(WINED3DFMT_NVHU);
1250 FMT_TO_STR(WINED3DFMT_NVHS);
1251 FMT_TO_STR(WINED3DFMT_R32G32B32A32_TYPELESS);
1252 FMT_TO_STR(WINED3DFMT_R32G32B32A32_FLOAT);
1253 FMT_TO_STR(WINED3DFMT_R32G32B32A32_UINT);
1254 FMT_TO_STR(WINED3DFMT_R32G32B32A32_SINT);
1255 FMT_TO_STR(WINED3DFMT_R32G32B32_TYPELESS);
1256 FMT_TO_STR(WINED3DFMT_R32G32B32_FLOAT);
1257 FMT_TO_STR(WINED3DFMT_R32G32B32_UINT);
1258 FMT_TO_STR(WINED3DFMT_R32G32B32_SINT);
1259 FMT_TO_STR(WINED3DFMT_R16G16B16A16_TYPELESS);
1260 FMT_TO_STR(WINED3DFMT_R16G16B16A16_FLOAT);
1261 FMT_TO_STR(WINED3DFMT_R16G16B16A16_UNORM);
1262 FMT_TO_STR(WINED3DFMT_R16G16B16A16_UINT);
1263 FMT_TO_STR(WINED3DFMT_R16G16B16A16_SNORM);
1264 FMT_TO_STR(WINED3DFMT_R16G16B16A16_SINT);
1265 FMT_TO_STR(WINED3DFMT_R32G32_TYPELESS);
1266 FMT_TO_STR(WINED3DFMT_R32G32_FLOAT);
1267 FMT_TO_STR(WINED3DFMT_R32G32_UINT);
1268 FMT_TO_STR(WINED3DFMT_R32G32_SINT);
1269 FMT_TO_STR(WINED3DFMT_R32G8X24_TYPELESS);
1270 FMT_TO_STR(WINED3DFMT_D32_FLOAT_S8X24_UINT);
1271 FMT_TO_STR(WINED3DFMT_R32_FLOAT_X8X24_TYPELESS);
1272 FMT_TO_STR(WINED3DFMT_X32_TYPELESS_G8X24_UINT);
1273 FMT_TO_STR(WINED3DFMT_R10G10B10A2_TYPELESS);
1274 FMT_TO_STR(WINED3DFMT_R10G10B10A2_UNORM);
1275 FMT_TO_STR(WINED3DFMT_R10G10B10A2_UINT);
1276 FMT_TO_STR(WINED3DFMT_R10G10B10A2_SNORM);
1277 FMT_TO_STR(WINED3DFMT_R11G11B10_FLOAT);
1278 FMT_TO_STR(WINED3DFMT_R8G8B8A8_TYPELESS);
1279 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM);
1280 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UNORM_SRGB);
1281 FMT_TO_STR(WINED3DFMT_R8G8B8A8_UINT);
1282 FMT_TO_STR(WINED3DFMT_R8G8B8A8_SNORM);
1283 FMT_TO_STR(WINED3DFMT_R8G8B8A8_SINT);
1284 FMT_TO_STR(WINED3DFMT_R16G16_TYPELESS);
1285 FMT_TO_STR(WINED3DFMT_R16G16_FLOAT);
1286 FMT_TO_STR(WINED3DFMT_R16G16_UNORM);
1287 FMT_TO_STR(WINED3DFMT_R16G16_UINT);
1288 FMT_TO_STR(WINED3DFMT_R16G16_SNORM);
1289 FMT_TO_STR(WINED3DFMT_R16G16_SINT);
1290 FMT_TO_STR(WINED3DFMT_R32_TYPELESS);
1291 FMT_TO_STR(WINED3DFMT_D32_FLOAT);
1292 FMT_TO_STR(WINED3DFMT_R32_FLOAT);
1293 FMT_TO_STR(WINED3DFMT_R32_UINT);
1294 FMT_TO_STR(WINED3DFMT_R32_SINT);
1295 FMT_TO_STR(WINED3DFMT_R24G8_TYPELESS);
1296 FMT_TO_STR(WINED3DFMT_D24_UNORM_S8_UINT);
1297 FMT_TO_STR(WINED3DFMT_R24_UNORM_X8_TYPELESS);
1298 FMT_TO_STR(WINED3DFMT_X24_TYPELESS_G8_UINT);
1299 FMT_TO_STR(WINED3DFMT_R8G8_TYPELESS);
1300 FMT_TO_STR(WINED3DFMT_R8G8_UNORM);
1301 FMT_TO_STR(WINED3DFMT_R8G8_UINT);
1302 FMT_TO_STR(WINED3DFMT_R8G8_SNORM);
1303 FMT_TO_STR(WINED3DFMT_R8G8_SINT);
1304 FMT_TO_STR(WINED3DFMT_R16_TYPELESS);
1305 FMT_TO_STR(WINED3DFMT_R16_FLOAT);
1306 FMT_TO_STR(WINED3DFMT_D16_UNORM);
1307 FMT_TO_STR(WINED3DFMT_R16_UNORM);
1308 FMT_TO_STR(WINED3DFMT_R16_UINT);
1309 FMT_TO_STR(WINED3DFMT_R16_SNORM);
1310 FMT_TO_STR(WINED3DFMT_R16_SINT);
1311 FMT_TO_STR(WINED3DFMT_R8_TYPELESS);
1312 FMT_TO_STR(WINED3DFMT_R8_UNORM);
1313 FMT_TO_STR(WINED3DFMT_R8_UINT);
1314 FMT_TO_STR(WINED3DFMT_R8_SNORM);
1315 FMT_TO_STR(WINED3DFMT_R8_SINT);
1316 FMT_TO_STR(WINED3DFMT_A8_UNORM);
1317 FMT_TO_STR(WINED3DFMT_R1_UNORM);
1318 FMT_TO_STR(WINED3DFMT_R9G9B9E5_SHAREDEXP);
1319 FMT_TO_STR(WINED3DFMT_R8G8_B8G8_UNORM);
1320 FMT_TO_STR(WINED3DFMT_G8R8_G8B8_UNORM);
1321 FMT_TO_STR(WINED3DFMT_BC1_TYPELESS);
1322 FMT_TO_STR(WINED3DFMT_BC1_UNORM);
1323 FMT_TO_STR(WINED3DFMT_BC1_UNORM_SRGB);
1324 FMT_TO_STR(WINED3DFMT_BC2_TYPELESS);
1325 FMT_TO_STR(WINED3DFMT_BC2_UNORM);
1326 FMT_TO_STR(WINED3DFMT_BC2_UNORM_SRGB);
1327 FMT_TO_STR(WINED3DFMT_BC3_TYPELESS);
1328 FMT_TO_STR(WINED3DFMT_BC3_UNORM);
1329 FMT_TO_STR(WINED3DFMT_BC3_UNORM_SRGB);
1330 FMT_TO_STR(WINED3DFMT_BC4_TYPELESS);
1331 FMT_TO_STR(WINED3DFMT_BC4_UNORM);
1332 FMT_TO_STR(WINED3DFMT_BC4_SNORM);
1333 FMT_TO_STR(WINED3DFMT_BC5_TYPELESS);
1334 FMT_TO_STR(WINED3DFMT_BC5_UNORM);
1335 FMT_TO_STR(WINED3DFMT_BC5_SNORM);
1336 FMT_TO_STR(WINED3DFMT_B5G6R5_UNORM);
1337 FMT_TO_STR(WINED3DFMT_B5G5R5A1_UNORM);
1338 FMT_TO_STR(WINED3DFMT_B8G8R8A8_UNORM);
1339 FMT_TO_STR(WINED3DFMT_B8G8R8X8_UNORM);
1340#undef FMT_TO_STR
1341 default:
1342 {
1343 char fourcc[5];
1344 fourcc[0] = (char)(fmt);
1345 fourcc[1] = (char)(fmt >> 8);
1346 fourcc[2] = (char)(fmt >> 16);
1347 fourcc[3] = (char)(fmt >> 24);
1348 fourcc[4] = 0;
1349 if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
1350 FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
1351 else
1352 FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
1353 }
1354 return "unrecognized";
1355 }
1356}
1357
1358const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
1359 switch (devtype) {
1360#define DEVTYPE_TO_STR(dev) case dev: return #dev
1361 DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
1362 DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
1363 DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
1364#undef DEVTYPE_TO_STR
1365 default:
1366 FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
1367 return "unrecognized";
1368 }
1369}
1370
1371const char *debug_d3dusage(DWORD usage)
1372{
1373 char buf[284];
1374
1375 buf[0] = '\0';
1376#define WINED3DUSAGE_TO_STR(u) if (usage & u) { strcat(buf, " | "#u); usage &= ~u; }
1377 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
1378 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
1379 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
1380 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
1381 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
1382 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
1383 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
1384 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
1385 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
1386 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
1387 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
1388#undef WINED3DUSAGE_TO_STR
1389 if (usage) FIXME("Unrecognized usage flag(s) %#x\n", usage);
1390
1391 return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1392}
1393
1394const char *debug_d3dusagequery(DWORD usagequery)
1395{
1396 char buf[238];
1397
1398 buf[0] = '\0';
1399#define WINED3DUSAGEQUERY_TO_STR(u) if (usagequery & u) { strcat(buf, " | "#u); usagequery &= ~u; }
1400 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
1401 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
1402 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
1403 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
1404 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
1405 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
1406 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
1407#undef WINED3DUSAGEQUERY_TO_STR
1408 if (usagequery) FIXME("Unrecognized usage query flag(s) %#x\n", usagequery);
1409
1410 return buf[0] ? wine_dbg_sprintf("%s", &buf[3]) : "0";
1411}
1412
1413const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
1414 switch (method) {
1415#define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
1416 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
1417 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
1418 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
1419 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
1420 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
1421 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
1422 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
1423#undef WINED3DDECLMETHOD_TO_STR
1424 default:
1425 FIXME("Unrecognized %u declaration method!\n", method);
1426 return "unrecognized";
1427 }
1428}
1429
1430const char* debug_d3ddeclusage(BYTE usage) {
1431 switch (usage) {
1432#define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
1433 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
1434 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
1435 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
1436 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
1437 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
1438 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
1439 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
1440 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
1441 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
1442 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
1443 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
1444 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
1445 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
1446 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
1447#undef WINED3DDECLUSAGE_TO_STR
1448 default:
1449 FIXME("Unrecognized %u declaration usage!\n", usage);
1450 return "unrecognized";
1451 }
1452}
1453
1454const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
1455 switch (res) {
1456#define RES_TO_STR(res) case res: return #res
1457 RES_TO_STR(WINED3DRTYPE_SURFACE);
1458 RES_TO_STR(WINED3DRTYPE_VOLUME);
1459 RES_TO_STR(WINED3DRTYPE_TEXTURE);
1460 RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
1461 RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
1462 RES_TO_STR(WINED3DRTYPE_BUFFER);
1463#undef RES_TO_STR
1464 default:
1465 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
1466 return "unrecognized";
1467 }
1468}
1469
1470const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
1471 switch (PrimitiveType) {
1472#define PRIM_TO_STR(prim) case prim: return #prim
1473 PRIM_TO_STR(WINED3DPT_UNDEFINED);
1474 PRIM_TO_STR(WINED3DPT_POINTLIST);
1475 PRIM_TO_STR(WINED3DPT_LINELIST);
1476 PRIM_TO_STR(WINED3DPT_LINESTRIP);
1477 PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
1478 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
1479 PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
1480 PRIM_TO_STR(WINED3DPT_LINELIST_ADJ);
1481 PRIM_TO_STR(WINED3DPT_LINESTRIP_ADJ);
1482 PRIM_TO_STR(WINED3DPT_TRIANGLELIST_ADJ);
1483 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP_ADJ);
1484#undef PRIM_TO_STR
1485 default:
1486 FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
1487 return "unrecognized";
1488 }
1489}
1490
1491const char* debug_d3drenderstate(DWORD state) {
1492 switch (state) {
1493#define D3DSTATE_TO_STR(u) case u: return #u
1494 D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE );
1495 D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS );
1496 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS );
1497 D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE );
1498 D3DSTATE_TO_STR(WINED3DRS_WRAPU );
1499 D3DSTATE_TO_STR(WINED3DRS_WRAPV );
1500 D3DSTATE_TO_STR(WINED3DRS_ZENABLE );
1501 D3DSTATE_TO_STR(WINED3DRS_FILLMODE );
1502 D3DSTATE_TO_STR(WINED3DRS_SHADEMODE );
1503 D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN );
1504 D3DSTATE_TO_STR(WINED3DRS_MONOENABLE );
1505 D3DSTATE_TO_STR(WINED3DRS_ROP2 );
1506 D3DSTATE_TO_STR(WINED3DRS_PLANEMASK );
1507 D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE );
1508 D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE );
1509 D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL );
1510 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG );
1511 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN );
1512 D3DSTATE_TO_STR(WINED3DRS_SRCBLEND );
1513 D3DSTATE_TO_STR(WINED3DRS_DESTBLEND );
1514 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND );
1515 D3DSTATE_TO_STR(WINED3DRS_CULLMODE );
1516 D3DSTATE_TO_STR(WINED3DRS_ZFUNC );
1517 D3DSTATE_TO_STR(WINED3DRS_ALPHAREF );
1518 D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC );
1519 D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE );
1520 D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE );
1521 D3DSTATE_TO_STR(WINED3DRS_FOGENABLE );
1522 D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE );
1523 D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE );
1524 D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL );
1525 D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX );
1526 D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA );
1527 D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR );
1528 D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE );
1529 D3DSTATE_TO_STR(WINED3DRS_FOGSTART );
1530 D3DSTATE_TO_STR(WINED3DRS_FOGEND );
1531 D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY );
1532 D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE );
1533 D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS );
1534 D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE );
1535 D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR );
1536 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU );
1537 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV );
1538 D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS );
1539 D3DSTATE_TO_STR(WINED3DRS_ZBIAS );
1540 D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE );
1541 D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY );
1542 D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH );
1543 D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
1544 D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE );
1545 D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL );
1546 D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL );
1547 D3DSTATE_TO_STR(WINED3DRS_STENCILPASS );
1548 D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC );
1549 D3DSTATE_TO_STR(WINED3DRS_STENCILREF );
1550 D3DSTATE_TO_STR(WINED3DRS_STENCILMASK );
1551 D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK );
1552 D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR );
1553 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00 );
1554 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01 );
1555 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02 );
1556 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03 );
1557 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04 );
1558 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05 );
1559 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06 );
1560 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07 );
1561 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08 );
1562 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09 );
1563 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10 );
1564 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11 );
1565 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12 );
1566 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13 );
1567 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14 );
1568 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15 );
1569 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16 );
1570 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17 );
1571 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18 );
1572 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19 );
1573 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20 );
1574 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21 );
1575 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22 );
1576 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23 );
1577 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24 );
1578 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25 );
1579 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26 );
1580 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27 );
1581 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28 );
1582 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29 );
1583 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30 );
1584 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31 );
1585 D3DSTATE_TO_STR(WINED3DRS_WRAP0 );
1586 D3DSTATE_TO_STR(WINED3DRS_WRAP1 );
1587 D3DSTATE_TO_STR(WINED3DRS_WRAP2 );
1588 D3DSTATE_TO_STR(WINED3DRS_WRAP3 );
1589 D3DSTATE_TO_STR(WINED3DRS_WRAP4 );
1590 D3DSTATE_TO_STR(WINED3DRS_WRAP5 );
1591 D3DSTATE_TO_STR(WINED3DRS_WRAP6 );
1592 D3DSTATE_TO_STR(WINED3DRS_WRAP7 );
1593 D3DSTATE_TO_STR(WINED3DRS_CLIPPING );
1594 D3DSTATE_TO_STR(WINED3DRS_LIGHTING );
1595 D3DSTATE_TO_STR(WINED3DRS_EXTENTS );
1596 D3DSTATE_TO_STR(WINED3DRS_AMBIENT );
1597 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE );
1598 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX );
1599 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER );
1600 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS );
1601 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE );
1602 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE );
1603 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE );
1604 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE );
1605 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE );
1606 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND );
1607 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE );
1608 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING );
1609 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE );
1610 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN );
1611 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE );
1612 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE );
1613 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A );
1614 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B );
1615 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C );
1616 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS );
1617 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK );
1618 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE );
1619 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS );
1620 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN );
1621 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX );
1622 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE );
1623 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE );
1624 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR );
1625 D3DSTATE_TO_STR(WINED3DRS_BLENDOP );
1626 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE );
1627 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE );
1628 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE );
1629 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS );
1630 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE );
1631 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL );
1632 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL );
1633 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X );
1634 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y );
1635 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z );
1636 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W );
1637 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
1638 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE );
1639 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL );
1640 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL );
1641 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS );
1642 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC );
1643 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1 );
1644 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2 );
1645 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3 );
1646 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR );
1647 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE );
1648 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS );
1649 D3DSTATE_TO_STR(WINED3DRS_WRAP8 );
1650 D3DSTATE_TO_STR(WINED3DRS_WRAP9 );
1651 D3DSTATE_TO_STR(WINED3DRS_WRAP10 );
1652 D3DSTATE_TO_STR(WINED3DRS_WRAP11 );
1653 D3DSTATE_TO_STR(WINED3DRS_WRAP12 );
1654 D3DSTATE_TO_STR(WINED3DRS_WRAP13 );
1655 D3DSTATE_TO_STR(WINED3DRS_WRAP14 );
1656 D3DSTATE_TO_STR(WINED3DRS_WRAP15 );
1657 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE );
1658 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA );
1659 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA );
1660 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA );
1661#undef D3DSTATE_TO_STR
1662 default:
1663 FIXME("Unrecognized %u render state!\n", state);
1664 return "unrecognized";
1665 }
1666}
1667
1668const char* debug_d3dsamplerstate(DWORD state) {
1669 switch (state) {
1670#define D3DSTATE_TO_STR(u) case u: return #u
1671 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR );
1672 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU );
1673 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV );
1674 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW );
1675 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER );
1676 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER );
1677 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER );
1678 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
1679 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL );
1680 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
1681 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE );
1682 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
1683 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET );
1684#undef D3DSTATE_TO_STR
1685 default:
1686 FIXME("Unrecognized %u sampler state!\n", state);
1687 return "unrecognized";
1688 }
1689}
1690
1691const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
1692 switch (filter_type) {
1693#define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
1694 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
1695 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
1696 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
1697 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
1698 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
1699 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
1700 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
1701 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
1702#undef D3DTEXTUREFILTERTYPE_TO_STR
1703 default:
1704 FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
1705 return "unrecognized";
1706 }
1707}
1708
1709const char* debug_d3dtexturestate(DWORD state) {
1710 switch (state) {
1711#define D3DSTATE_TO_STR(u) case u: return #u
1712 D3DSTATE_TO_STR(WINED3DTSS_COLOROP );
1713 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1 );
1714 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2 );
1715 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP );
1716 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1 );
1717 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2 );
1718 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00 );
1719 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01 );
1720 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10 );
1721 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11 );
1722 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX );
1723 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE );
1724 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET );
1725 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
1726 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0 );
1727 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0 );
1728 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG );
1729 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT );
1730#undef D3DSTATE_TO_STR
1731 default:
1732 FIXME("Unrecognized %u texture state!\n", state);
1733 return "unrecognized";
1734 }
1735}
1736
1737const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
1738 switch (d3dtop) {
1739#define D3DTOP_TO_STR(u) case u: return #u
1740 D3DTOP_TO_STR(WINED3DTOP_DISABLE);
1741 D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
1742 D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
1743 D3DTOP_TO_STR(WINED3DTOP_MODULATE);
1744 D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
1745 D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
1746 D3DTOP_TO_STR(WINED3DTOP_ADD);
1747 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
1748 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
1749 D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
1750 D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
1751 D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
1752 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
1753 D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
1754 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
1755 D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
1756 D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
1757 D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
1758 D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
1759 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
1760 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
1761 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
1762 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
1763 D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
1764 D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
1765 D3DTOP_TO_STR(WINED3DTOP_LERP);
1766#undef D3DTOP_TO_STR
1767 default:
1768 FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
1769 return "unrecognized";
1770 }
1771}
1772
1773const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
1774 switch (tstype) {
1775#define TSTYPE_TO_STR(tstype) case tstype: return #tstype
1776 TSTYPE_TO_STR(WINED3DTS_VIEW);
1777 TSTYPE_TO_STR(WINED3DTS_PROJECTION);
1778 TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
1779 TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
1780 TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
1781 TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
1782 TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
1783 TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
1784 TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
1785 TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
1786 TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
1787#undef TSTYPE_TO_STR
1788 default:
1789 if (tstype > 256 && tstype < 512) {
1790 FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
1791 return ("WINED3DTS_WORLDMATRIX > 0");
1792 }
1793 FIXME("Unrecognized %u WINED3DTS\n", tstype);
1794 return "unrecognized";
1795 }
1796}
1797
1798const char* debug_d3dpool(WINED3DPOOL Pool) {
1799 switch (Pool) {
1800#define POOL_TO_STR(p) case p: return #p
1801 POOL_TO_STR(WINED3DPOOL_DEFAULT);
1802 POOL_TO_STR(WINED3DPOOL_MANAGED);
1803 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
1804 POOL_TO_STR(WINED3DPOOL_SCRATCH);
1805#undef POOL_TO_STR
1806 default:
1807 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
1808 return "unrecognized";
1809 }
1810}
1811
1812const char *debug_fbostatus(GLenum status) {
1813 switch(status) {
1814#define FBOSTATUS_TO_STR(u) case u: return #u
1815 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE);
1816 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
1817 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
1818 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
1819 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
1820 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
1821 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
1822 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
1823 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED);
1824 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNDEFINED);
1825#undef FBOSTATUS_TO_STR
1826 default:
1827 FIXME("Unrecognied FBO status 0x%08x\n", status);
1828 return "unrecognized";
1829 }
1830}
1831
1832const char *debug_glerror(GLenum error) {
1833 switch(error) {
1834#define GLERROR_TO_STR(u) case u: return #u
1835 GLERROR_TO_STR(GL_NO_ERROR);
1836 GLERROR_TO_STR(GL_INVALID_ENUM);
1837 GLERROR_TO_STR(GL_INVALID_VALUE);
1838 GLERROR_TO_STR(GL_INVALID_OPERATION);
1839 GLERROR_TO_STR(GL_STACK_OVERFLOW);
1840 GLERROR_TO_STR(GL_STACK_UNDERFLOW);
1841 GLERROR_TO_STR(GL_OUT_OF_MEMORY);
1842 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION);
1843#undef GLERROR_TO_STR
1844 default:
1845 FIXME("Unrecognied GL error 0x%08x\n", error);
1846 return "unrecognized";
1847 }
1848}
1849
1850const char *debug_d3dbasis(WINED3DBASISTYPE basis) {
1851 switch(basis) {
1852 case WINED3DBASIS_BEZIER: return "WINED3DBASIS_BEZIER";
1853 case WINED3DBASIS_BSPLINE: return "WINED3DBASIS_BSPLINE";
1854 case WINED3DBASIS_INTERPOLATE: return "WINED3DBASIS_INTERPOLATE";
1855 default: return "unrecognized";
1856 }
1857}
1858
1859const char *debug_d3ddegree(WINED3DDEGREETYPE degree) {
1860 switch(degree) {
1861 case WINED3DDEGREE_LINEAR: return "WINED3DDEGREE_LINEAR";
1862 case WINED3DDEGREE_QUADRATIC: return "WINED3DDEGREE_QUADRATIC";
1863 case WINED3DDEGREE_CUBIC: return "WINED3DDEGREE_CUBIC";
1864 case WINED3DDEGREE_QUINTIC: return "WINED3DDEGREE_QUINTIC";
1865 default: return "unrecognized";
1866 }
1867}
1868
1869static const char *debug_fixup_channel_source(enum fixup_channel_source source)
1870{
1871 switch(source)
1872 {
1873#define WINED3D_TO_STR(x) case x: return #x
1874 WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
1875 WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
1876 WINED3D_TO_STR(CHANNEL_SOURCE_X);
1877 WINED3D_TO_STR(CHANNEL_SOURCE_Y);
1878 WINED3D_TO_STR(CHANNEL_SOURCE_Z);
1879 WINED3D_TO_STR(CHANNEL_SOURCE_W);
1880 WINED3D_TO_STR(CHANNEL_SOURCE_YUV0);
1881 WINED3D_TO_STR(CHANNEL_SOURCE_YUV1);
1882#undef WINED3D_TO_STR
1883 default:
1884 FIXME("Unrecognized fixup_channel_source %#x\n", source);
1885 return "unrecognized";
1886 }
1887}
1888
1889static const char *debug_yuv_fixup(enum yuv_fixup yuv_fixup)
1890{
1891 switch(yuv_fixup)
1892 {
1893#define WINED3D_TO_STR(x) case x: return #x
1894 WINED3D_TO_STR(YUV_FIXUP_YUY2);
1895 WINED3D_TO_STR(YUV_FIXUP_UYVY);
1896 WINED3D_TO_STR(YUV_FIXUP_YV12);
1897#undef WINED3D_TO_STR
1898 default:
1899 FIXME("Unrecognized YUV fixup %#x\n", yuv_fixup);
1900 return "unrecognized";
1901 }
1902}
1903
1904void dump_color_fixup_desc(struct color_fixup_desc fixup)
1905{
1906 if (is_yuv_fixup(fixup))
1907 {
1908 TRACE("\tYUV: %s\n", debug_yuv_fixup(get_yuv_fixup(fixup)));
1909 return;
1910 }
1911
1912 TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
1913 TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
1914 TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
1915 TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
1916}
1917
1918const char *debug_surflocation(DWORD flag) {
1919 char buf[128];
1920
1921 buf[0] = 0;
1922 if(flag & SFLAG_INSYSMEM) strcat(buf, " | SFLAG_INSYSMEM");
1923 if(flag & SFLAG_INDRAWABLE) strcat(buf, " | SFLAG_INDRAWABLE");
1924 if(flag & SFLAG_INTEXTURE) strcat(buf, " | SFLAG_INTEXTURE");
1925 if(flag & SFLAG_INSRGBTEX) strcat(buf, " | SFLAG_INSRGBTEX");
1926 return wine_dbg_sprintf("%s", buf[0] ? buf + 3 : "0");
1927}
1928
1929/*****************************************************************************
1930 * Useful functions mapping GL <-> D3D values
1931 */
1932GLenum StencilOp(DWORD op) {
1933 switch(op) {
1934 case WINED3DSTENCILOP_KEEP : return GL_KEEP;
1935 case WINED3DSTENCILOP_ZERO : return GL_ZERO;
1936 case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
1937 case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
1938 case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
1939 case WINED3DSTENCILOP_INVERT : return GL_INVERT;
1940 case WINED3DSTENCILOP_INCR : return GL_INCR_WRAP_EXT;
1941 case WINED3DSTENCILOP_DECR : return GL_DECR_WRAP_EXT;
1942 default:
1943 FIXME("Unrecognized stencil op %d\n", op);
1944 return GL_KEEP;
1945 }
1946}
1947
1948GLenum CompareFunc(DWORD func) {
1949 switch ((WINED3DCMPFUNC)func) {
1950 case WINED3DCMP_NEVER : return GL_NEVER;
1951 case WINED3DCMP_LESS : return GL_LESS;
1952 case WINED3DCMP_EQUAL : return GL_EQUAL;
1953 case WINED3DCMP_LESSEQUAL : return GL_LEQUAL;
1954 case WINED3DCMP_GREATER : return GL_GREATER;
1955 case WINED3DCMP_NOTEQUAL : return GL_NOTEQUAL;
1956 case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
1957 case WINED3DCMP_ALWAYS : return GL_ALWAYS;
1958 default:
1959 FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
1960 return 0;
1961 }
1962}
1963
1964BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
1965 if (op == WINED3DTOP_DISABLE) return FALSE;
1966 if (This->stateBlock->textures[stage]) return FALSE;
1967
1968 if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1969 && op != WINED3DTOP_SELECTARG2) return TRUE;
1970 if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1971 && op != WINED3DTOP_SELECTARG1) return TRUE;
1972 if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1973 && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
1974
1975 return FALSE;
1976}
1977
1978/* Setup this textures matrix according to the texture flags*/
1979/* GL locking is done by the caller (state handler) */
1980void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed,
1981 WINED3DFORMAT vtx_fmt, BOOL ffp_proj_control)
1982{
1983 float mat[16];
1984
1985 glMatrixMode(GL_TEXTURE);
1986 checkGLcall("glMatrixMode(GL_TEXTURE)");
1987
1988 if (flags == WINED3DTTFF_DISABLE || flags == WINED3DTTFF_COUNT1 || transformed) {
1989 glLoadIdentity();
1990 checkGLcall("glLoadIdentity()");
1991 return;
1992 }
1993
1994 if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
1995 ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
1996 return;
1997 }
1998
1999 memcpy(mat, smat, 16 * sizeof(float));
2000
2001 if (flags & WINED3DTTFF_PROJECTED) {
2002 if(!ffp_proj_control) {
2003 switch (flags & ~WINED3DTTFF_PROJECTED) {
2004 case WINED3DTTFF_COUNT2:
2005 mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
2006 mat[1] = mat[5] = mat[9] = mat[13] = 0;
2007 break;
2008 case WINED3DTTFF_COUNT3:
2009 mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
2010 mat[2] = mat[6] = mat[10] = mat[14] = 0;
2011 break;
2012 }
2013 }
2014 } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2015 if(!calculatedCoords) {
2016 switch(vtx_fmt)
2017 {
2018 case WINED3DFMT_R32_FLOAT:
2019 /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
2020 * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
2021 * the input value to the transformation will be 0, so the matrix value is irrelevant
2022 */
2023 mat[12] = mat[4];
2024 mat[13] = mat[5];
2025 mat[14] = mat[6];
2026 mat[15] = mat[7];
2027 break;
2028 case WINED3DFMT_R32G32_FLOAT:
2029 /* See above, just 3rd and 4th coord
2030 */
2031 mat[12] = mat[8];
2032 mat[13] = mat[9];
2033 mat[14] = mat[10];
2034 mat[15] = mat[11];
2035 break;
2036 case WINED3DFMT_R32G32B32_FLOAT: /* Opengl defaults match dx defaults */
2037 case WINED3DFMT_R32G32B32A32_FLOAT: /* No defaults apply, all app defined */
2038
2039 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
2040 * into a bad place. The division elimination below will apply to make sure the
2041 * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
2042 */
2043 case WINED3DFMT_UNKNOWN: /* No texture coords, 0/0/0/1 defaults are passed */
2044 break;
2045 default:
2046 FIXME("Unexpected fixed function texture coord input\n");
2047 }
2048 }
2049 if(!ffp_proj_control) {
2050 switch (flags & ~WINED3DTTFF_PROJECTED) {
2051 /* case WINED3DTTFF_COUNT1: Won't ever get here */
2052 case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
2053 /* OpenGL divides the first 3 vertex coord by the 4th by default,
2054 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
2055 * the 4th coord evaluates to 1.0 to eliminate that.
2056 *
2057 * If the fixed function pipeline is used, the 4th value remains unused,
2058 * so there is no danger in doing this. With vertex shaders we have a
2059 * problem. Should an app hit that problem, the code here would have to
2060 * check for pixel shaders, and the shader has to undo the default gl divide.
2061 *
2062 * A more serious problem occurs if the app passes 4 coordinates in, and the
2063 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
2064 * or a replacement shader
2065 */
2066 default: mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
2067 }
2068 }
2069 }
2070
2071 glLoadMatrixf(mat);
2072 checkGLcall("glLoadMatrixf(mat)");
2073}
2074
2075/* This small helper function is used to convert a bitmask into the number of masked bits */
2076unsigned int count_bits(unsigned int mask)
2077{
2078 unsigned int count;
2079 for (count = 0; mask; ++count)
2080 {
2081 mask &= mask - 1;
2082 }
2083 return count;
2084}
2085
2086/* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
2087 * The later function requires individual color components. */
2088BOOL getColorBits(const struct GlPixelFormatDesc *format_desc,
2089 short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize)
2090{
2091 TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
2092 switch(format_desc->format)
2093 {
2094 case WINED3DFMT_B8G8R8X8_UNORM:
2095 case WINED3DFMT_B8G8R8_UNORM:
2096 case WINED3DFMT_B8G8R8A8_UNORM:
2097 case WINED3DFMT_R8G8B8A8_UNORM:
2098 case WINED3DFMT_B10G10R10A2_UNORM:
2099 case WINED3DFMT_B5G5R5X1_UNORM:
2100 case WINED3DFMT_B5G5R5A1_UNORM:
2101 case WINED3DFMT_B5G6R5_UNORM:
2102 case WINED3DFMT_B4G4R4X4_UNORM:
2103 case WINED3DFMT_B4G4R4A4_UNORM:
2104 case WINED3DFMT_B2G3R3_UNORM:
2105 case WINED3DFMT_P8_UINT_A8_UNORM:
2106 case WINED3DFMT_P8_UINT:
2107 break;
2108 default:
2109 ERR("Unsupported format: %s\n", debug_d3dformat(format_desc->format));
2110 return FALSE;
2111 }
2112
2113 *redSize = count_bits(format_desc->red_mask);
2114 *greenSize = count_bits(format_desc->green_mask);
2115 *blueSize = count_bits(format_desc->blue_mask);
2116 *alphaSize = count_bits(format_desc->alpha_mask);
2117 *totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
2118
2119 TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n",
2120 *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(format_desc->format));
2121 return TRUE;
2122}
2123
2124/* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
2125BOOL getDepthStencilBits(const struct GlPixelFormatDesc *format_desc, short *depthSize, short *stencilSize)
2126{
2127 TRACE("fmt: %s\n", debug_d3dformat(format_desc->format));
2128 switch(format_desc->format)
2129 {
2130 case WINED3DFMT_D16_LOCKABLE:
2131 case WINED3DFMT_D16_UNORM:
2132 case WINED3DFMT_S1_UINT_D15_UNORM:
2133 case WINED3DFMT_X8D24_UNORM:
2134 case WINED3DFMT_S4X4_UINT_D24_UNORM:
2135 case WINED3DFMT_D24_UNORM_S8_UINT:
2136 case WINED3DFMT_S8_UINT_D24_FLOAT:
2137 case WINED3DFMT_D32_UNORM:
2138 case WINED3DFMT_D32_FLOAT:
2139 break;
2140 default:
2141 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(format_desc->format));
2142 return FALSE;
2143 }
2144
2145 *depthSize = format_desc->depth_size;
2146 *stencilSize = format_desc->stencil_size;
2147
2148 TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n",
2149 *depthSize, *stencilSize, debug_d3dformat(format_desc->format));
2150 return TRUE;
2151}
2152
2153/* DirectDraw stuff */
2154WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
2155 switch(depth) {
2156 case 8: return WINED3DFMT_P8_UINT;
2157 case 15: return WINED3DFMT_B5G5R5X1_UNORM;
2158 case 16: return WINED3DFMT_B5G6R5_UNORM;
2159 case 24: return WINED3DFMT_B8G8R8X8_UNORM; /* Robots needs 24bit to be WINED3DFMT_B8G8R8X8_UNORM */
2160 case 32: return WINED3DFMT_B8G8R8X8_UNORM; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return WINED3DFMT_B8G8R8X8_UNORM */
2161 default: return WINED3DFMT_UNKNOWN;
2162 }
2163}
2164
2165void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
2166 WINED3DMATRIX temp;
2167
2168 /* Now do the multiplication 'by hand'.
2169 I know that all this could be optimised, but this will be done later :-) */
2170 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);
2171 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);
2172 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);
2173 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);
2174
2175 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);
2176 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);
2177 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);
2178 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);
2179
2180 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);
2181 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);
2182 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);
2183 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);
2184
2185 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);
2186 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);
2187 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);
2188 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);
2189
2190 /* And copy the new matrix in the good storage.. */
2191 memcpy(dest, &temp, 16 * sizeof(float));
2192}
2193
2194DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
2195 DWORD size = 0;
2196 int i;
2197 int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
2198
2199 if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
2200 if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
2201 if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
2202 if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
2203 switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
2204 case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
2205 case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
2206 case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break;
2207 case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break;
2208 case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break;
2209 case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break;
2210 case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break;
2211 case WINED3DFVF_XYZW: size += 4 * sizeof(float); break;
2212 default: ERR("Unexpected position mask\n");
2213 }
2214 for (i = 0; i < numTextures; i++) {
2215 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
2216 }
2217
2218 return size;
2219}
2220
2221/***********************************************************************
2222 * CalculateTexRect
2223 *
2224 * Calculates the dimensions of the opengl texture used for blits.
2225 * Handled oversized opengl textures and updates the source rectangle
2226 * accordingly
2227 *
2228 * Params:
2229 * This: Surface to operate on
2230 * Rect: Requested rectangle
2231 *
2232 * Returns:
2233 * TRUE if the texture part can be loaded,
2234 * FALSE otherwise
2235 *
2236 *********************************************************************/
2237BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4])
2238{
2239 const struct wined3d_gl_info *gl_info = &This->resource.device->adapter->gl_info;
2240 int x1 = Rect->left, x2 = Rect->right;
2241 int y1 = Rect->top, y2 = Rect->bottom;
2242 GLint maxSize = gl_info->limits.texture_size;
2243
2244 TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
2245 Rect->left, Rect->top, Rect->right, Rect->bottom);
2246
2247 /* The sizes might be reversed */
2248 if(Rect->left > Rect->right) {
2249 x1 = Rect->right;
2250 x2 = Rect->left;
2251 }
2252 if(Rect->top > Rect->bottom) {
2253 y1 = Rect->bottom;
2254 y2 = Rect->top;
2255 }
2256
2257 /* No oversized texture? This is easy */
2258 if(!(This->Flags & SFLAG_OVERSIZE)) {
2259 /* Which rect from the texture do I need? */
2260 if (This->texture_target == GL_TEXTURE_RECTANGLE_ARB)
2261 {
2262 glTexCoord[0] = (float) Rect->left;
2263 glTexCoord[2] = (float) Rect->top;
2264 glTexCoord[1] = (float) Rect->right;
2265 glTexCoord[3] = (float) Rect->bottom;
2266 } else {
2267 glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
2268 glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
2269 glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
2270 glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
2271 }
2272
2273 return TRUE;
2274 } else {
2275 /* Check if we can succeed at all */
2276 if( (x2 - x1) > maxSize ||
2277 (y2 - y1) > maxSize ) {
2278 TRACE("Requested rectangle is too large for gl\n");
2279 return FALSE;
2280 }
2281
2282 /* A part of the texture has to be picked. First, check if
2283 * some texture part is loaded already, if yes try to re-use it.
2284 * If the texture is dirty, or the part can't be used,
2285 * re-position the part to load
2286 */
2287 if(This->Flags & SFLAG_INTEXTURE) {
2288 if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
2289 This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
2290 /* Ok, the rectangle is ok, re-use it */
2291 TRACE("Using existing gl Texture\n");
2292 } else {
2293 /* Rectangle is not ok, dirtify the texture to reload it */
2294 TRACE("Dirtifying texture to force reload\n");
2295 This->Flags &= ~SFLAG_INTEXTURE;
2296 }
2297 }
2298
2299 /* Now if we are dirty(no else if!) */
2300 if(!(This->Flags & SFLAG_INTEXTURE)) {
2301 /* Set the new rectangle. Use the following strategy:
2302 * 1) Use as big textures as possible.
2303 * 2) Place the texture part in the way that the requested
2304 * part is in the middle of the texture(well, almost)
2305 * 3) If the texture is moved over the edges of the
2306 * surface, replace it nicely
2307 * 4) If the coord is not limiting the texture size,
2308 * use the whole size
2309 */
2310 if((This->pow2Width) > maxSize) {
2311 This->glRect.left = x1 - maxSize / 2;
2312 if(This->glRect.left < 0) {
2313 This->glRect.left = 0;
2314 }
2315 This->glRect.right = This->glRect.left + maxSize;
2316 if(This->glRect.right > This->currentDesc.Width) {
2317 This->glRect.right = This->currentDesc.Width;
2318 This->glRect.left = This->glRect.right - maxSize;
2319 }
2320 } else {
2321 This->glRect.left = 0;
2322 This->glRect.right = This->pow2Width;
2323 }
2324
2325 if (This->pow2Height > maxSize)
2326 {
2327 This->glRect.top = x1 - gl_info->limits.texture_size / 2;
2328 if(This->glRect.top < 0) This->glRect.top = 0;
2329 This->glRect.bottom = This->glRect.left + maxSize;
2330 if(This->glRect.bottom > This->currentDesc.Height) {
2331 This->glRect.bottom = This->currentDesc.Height;
2332 This->glRect.top = This->glRect.bottom - maxSize;
2333 }
2334 } else {
2335 This->glRect.top = 0;
2336 This->glRect.bottom = This->pow2Height;
2337 }
2338 TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
2339 This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
2340 }
2341
2342 /* Re-calculate the rect to draw */
2343 Rect->left -= This->glRect.left;
2344 Rect->right -= This->glRect.left;
2345 Rect->top -= This->glRect.top;
2346 Rect->bottom -= This->glRect.top;
2347
2348 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
2349 * or the pow2Width / pow2Height of the surface.
2350 *
2351 * Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
2352 * as regular GL_TEXTURE_2D.
2353 */
2354 glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
2355 glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
2356 glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
2357 glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
2358 }
2359 return TRUE;
2360}
2361
2362void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_settings *settings, BOOL ignore_textype) {
2363#define ARG1 0x01
2364#define ARG2 0x02
2365#define ARG0 0x04
2366 static const unsigned char args[WINED3DTOP_LERP + 1] = {
2367 /* undefined */ 0,
2368 /* D3DTOP_DISABLE */ 0,
2369 /* D3DTOP_SELECTARG1 */ ARG1,
2370 /* D3DTOP_SELECTARG2 */ ARG2,
2371 /* D3DTOP_MODULATE */ ARG1 | ARG2,
2372 /* D3DTOP_MODULATE2X */ ARG1 | ARG2,
2373 /* D3DTOP_MODULATE4X */ ARG1 | ARG2,
2374 /* D3DTOP_ADD */ ARG1 | ARG2,
2375 /* D3DTOP_ADDSIGNED */ ARG1 | ARG2,
2376 /* D3DTOP_ADDSIGNED2X */ ARG1 | ARG2,
2377 /* D3DTOP_SUBTRACT */ ARG1 | ARG2,
2378 /* D3DTOP_ADDSMOOTH */ ARG1 | ARG2,
2379 /* D3DTOP_BLENDDIFFUSEALPHA */ ARG1 | ARG2,
2380 /* D3DTOP_BLENDTEXTUREALPHA */ ARG1 | ARG2,
2381 /* D3DTOP_BLENDFACTORALPHA */ ARG1 | ARG2,
2382 /* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1 | ARG2,
2383 /* D3DTOP_BLENDCURRENTALPHA */ ARG1 | ARG2,
2384 /* D3DTOP_PREMODULATE */ ARG1 | ARG2,
2385 /* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1 | ARG2,
2386 /* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1 | ARG2,
2387 /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1 | ARG2,
2388 /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1 | ARG2,
2389 /* D3DTOP_BUMPENVMAP */ ARG1 | ARG2,
2390 /* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1 | ARG2,
2391 /* D3DTOP_DOTPRODUCT3 */ ARG1 | ARG2,
2392 /* D3DTOP_MULTIPLYADD */ ARG1 | ARG2 | ARG0,
2393 /* D3DTOP_LERP */ ARG1 | ARG2 | ARG0
2394 };
2395 unsigned int i;
2396 DWORD ttff;
2397 DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
2398 IWineD3DDeviceImpl *device = stateblock->device;
2399 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2400
2401 memset(settings, 0, sizeof(*settings));
2402
2403 for (i = 0; i < gl_info->limits.texture_stages; ++i)
2404 {
2405 IWineD3DBaseTextureImpl *texture;
2406 settings->op[i].padding = 0;
2407 if(stateblock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
2408 settings->op[i].cop = WINED3DTOP_DISABLE;
2409 settings->op[i].aop = WINED3DTOP_DISABLE;
2410 settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
2411 settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
2412 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2413 settings->op[i].dst = resultreg;
2414 settings->op[i].tex_type = tex_1d;
2415 settings->op[i].projected = proj_none;
2416 i++;
2417 break;
2418 }
2419
2420 texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
2421 if(texture) {
2422 settings->op[i].color_fixup = texture->resource.format_desc->color_fixup;
2423 if(ignore_textype) {
2424 settings->op[i].tex_type = tex_1d;
2425 } else {
2426 switch (IWineD3DBaseTexture_GetTextureDimensions((IWineD3DBaseTexture *)texture)) {
2427 case GL_TEXTURE_1D:
2428 settings->op[i].tex_type = tex_1d;
2429 break;
2430 case GL_TEXTURE_2D:
2431 settings->op[i].tex_type = tex_2d;
2432 break;
2433 case GL_TEXTURE_3D:
2434 settings->op[i].tex_type = tex_3d;
2435 break;
2436 case GL_TEXTURE_CUBE_MAP_ARB:
2437 settings->op[i].tex_type = tex_cube;
2438 break;
2439 case GL_TEXTURE_RECTANGLE_ARB:
2440 settings->op[i].tex_type = tex_rect;
2441 break;
2442 }
2443 }
2444 } else {
2445 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
2446 settings->op[i].tex_type = tex_1d;
2447 }
2448
2449 cop = stateblock->textureState[i][WINED3DTSS_COLOROP];
2450 aop = stateblock->textureState[i][WINED3DTSS_ALPHAOP];
2451
2452 carg1 = (args[cop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_COLORARG1] : ARG_UNUSED;
2453 carg2 = (args[cop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_COLORARG2] : ARG_UNUSED;
2454 carg0 = (args[cop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_COLORARG0] : ARG_UNUSED;
2455
2456 if(is_invalid_op(device, i, cop, carg1, carg2, carg0)) {
2457 carg0 = ARG_UNUSED;
2458 carg2 = ARG_UNUSED;
2459 carg1 = WINED3DTA_CURRENT;
2460 cop = WINED3DTOP_SELECTARG1;
2461 }
2462
2463 if(cop == WINED3DTOP_DOTPRODUCT3) {
2464 /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
2465 * the color result to the alpha component of the destination
2466 */
2467 aop = cop;
2468 aarg1 = carg1;
2469 aarg2 = carg2;
2470 aarg0 = carg0;
2471 } else {
2472 aarg1 = (args[aop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG1] : ARG_UNUSED;
2473 aarg2 = (args[aop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG2] : ARG_UNUSED;
2474 aarg0 = (args[aop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG0] : ARG_UNUSED;
2475 }
2476
2477 if (i == 0 && stateblock->textures[0] && stateblock->renderState[WINED3DRS_COLORKEYENABLE])
2478 {
2479 UINT texture_dimensions = IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[0]);
2480
2481 if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
2482 {
2483 IWineD3DSurfaceImpl *surf;
2484 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
2485
2486 if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format_desc->alpha_mask)
2487 {
2488 if (aop == WINED3DTOP_DISABLE)
2489 {
2490 aarg1 = WINED3DTA_TEXTURE;
2491 aop = WINED3DTOP_SELECTARG1;
2492 }
2493 else if (aop == WINED3DTOP_SELECTARG1 && aarg1 != WINED3DTA_TEXTURE)
2494 {
2495 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2496 {
2497 aarg2 = WINED3DTA_TEXTURE;
2498 aop = WINED3DTOP_MODULATE;
2499 }
2500 else aarg1 = WINED3DTA_TEXTURE;
2501 }
2502 else if (aop == WINED3DTOP_SELECTARG2 && aarg2 != WINED3DTA_TEXTURE)
2503 {
2504 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2505 {
2506 aarg1 = WINED3DTA_TEXTURE;
2507 aop = WINED3DTOP_MODULATE;
2508 }
2509 else aarg2 = WINED3DTA_TEXTURE;
2510 }
2511 }
2512 }
2513 }
2514
2515 if(is_invalid_op(device, i, aop, aarg1, aarg2, aarg0)) {
2516 aarg0 = ARG_UNUSED;
2517 aarg2 = ARG_UNUSED;
2518 aarg1 = WINED3DTA_CURRENT;
2519 aop = WINED3DTOP_SELECTARG1;
2520 }
2521
2522 if(carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE ||
2523 aarg1 == WINED3DTA_TEXTURE || aarg2 == WINED3DTA_TEXTURE || aarg0 == WINED3DTA_TEXTURE) {
2524 ttff = stateblock->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2525 if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT3)) {
2526 settings->op[i].projected = proj_count3;
2527 } else if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT4)) {
2528 settings->op[i].projected = proj_count4;
2529 } else {
2530 settings->op[i].projected = proj_none;
2531 }
2532 } else {
2533 settings->op[i].projected = proj_none;
2534 }
2535
2536 settings->op[i].cop = cop;
2537 settings->op[i].aop = aop;
2538 settings->op[i].carg0 = carg0;
2539 settings->op[i].carg1 = carg1;
2540 settings->op[i].carg2 = carg2;
2541 settings->op[i].aarg0 = aarg0;
2542 settings->op[i].aarg1 = aarg1;
2543 settings->op[i].aarg2 = aarg2;
2544
2545 if(stateblock->textureState[i][WINED3DTSS_RESULTARG] == WINED3DTA_TEMP) {
2546 settings->op[i].dst = tempreg;
2547 } else {
2548 settings->op[i].dst = resultreg;
2549 }
2550 }
2551
2552 /* Clear unsupported stages */
2553 for(; i < MAX_TEXTURES; i++) {
2554 memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
2555 }
2556
2557 if(stateblock->renderState[WINED3DRS_FOGENABLE] == FALSE) {
2558 settings->fog = FOG_OFF;
2559 } else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
2560 if(use_vs(stateblock) || ((IWineD3DVertexDeclarationImpl *) stateblock->vertexDecl)->position_transformed) {
2561 settings->fog = FOG_LINEAR;
2562 } else {
2563 switch(stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
2564 case WINED3DFOG_NONE:
2565 case WINED3DFOG_LINEAR:
2566 settings->fog = FOG_LINEAR;
2567 break;
2568 case WINED3DFOG_EXP:
2569 settings->fog = FOG_EXP;
2570 break;
2571 case WINED3DFOG_EXP2:
2572 settings->fog = FOG_EXP2;
2573 break;
2574 }
2575 }
2576 } else {
2577 switch(stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
2578 case WINED3DFOG_LINEAR:
2579 settings->fog = FOG_LINEAR;
2580 break;
2581 case WINED3DFOG_EXP:
2582 settings->fog = FOG_EXP;
2583 break;
2584 case WINED3DFOG_EXP2:
2585 settings->fog = FOG_EXP2;
2586 break;
2587 }
2588 }
2589 if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
2590 settings->sRGB_write = 1;
2591 } else {
2592 settings->sRGB_write = 0;
2593 }
2594 if(device->vs_clipping || !use_vs(stateblock) || !stateblock->renderState[WINED3DRS_CLIPPING] ||
2595 !stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
2596 /* No need to emulate clipplanes if GL supports native vertex shader clipping or if
2597 * the fixed function vertex pipeline is used(which always supports clipplanes), or
2598 * if no clipplane is enabled
2599 */
2600 settings->emul_clipplanes = 0;
2601 } else {
2602 settings->emul_clipplanes = 1;
2603 }
2604}
2605
2606const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
2607 const struct ffp_frag_settings *settings)
2608{
2609 struct wine_rb_entry *entry = wine_rb_get(fragment_shaders, settings);
2610 return entry ? WINE_RB_ENTRY_VALUE(entry, struct ffp_frag_desc, entry) : NULL;
2611}
2612
2613void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc)
2614{
2615 /* Note that the key is the implementation independent part of the ffp_frag_desc structure,
2616 * whereas desc points to an extended structure with implementation specific parts. */
2617 if (wine_rb_put(shaders, &desc->settings, &desc->entry) == -1)
2618 {
2619 ERR("Failed to insert ffp frag shader.\n");
2620 }
2621}
2622
2623/* Activates the texture dimension according to the bound D3D texture.
2624 * Does not care for the colorop or correct gl texture unit(when using nvrc)
2625 * Requires the caller to activate the correct unit before
2626 */
2627/* GL locking is done by the caller (state handler) */
2628void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context)
2629{
2630 const struct wined3d_gl_info *gl_info = context->gl_info;
2631
2632 if (stateblock->textures[stage])
2633 {
2634 switch (IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[stage])) {
2635 case GL_TEXTURE_2D:
2636 glDisable(GL_TEXTURE_3D);
2637 checkGLcall("glDisable(GL_TEXTURE_3D)");
2638 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2639 {
2640 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2641 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2642 }
2643 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2644 {
2645 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2646 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2647 }
2648 glEnable(GL_TEXTURE_2D);
2649 checkGLcall("glEnable(GL_TEXTURE_2D)");
2650 break;
2651 case GL_TEXTURE_RECTANGLE_ARB:
2652 glDisable(GL_TEXTURE_2D);
2653 checkGLcall("glDisable(GL_TEXTURE_2D)");
2654 glDisable(GL_TEXTURE_3D);
2655 checkGLcall("glDisable(GL_TEXTURE_3D)");
2656 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2657 {
2658 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2659 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2660 }
2661 glEnable(GL_TEXTURE_RECTANGLE_ARB);
2662 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2663 break;
2664 case GL_TEXTURE_3D:
2665 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2666 {
2667 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2668 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2669 }
2670 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2671 {
2672 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2673 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2674 }
2675 glDisable(GL_TEXTURE_2D);
2676 checkGLcall("glDisable(GL_TEXTURE_2D)");
2677 glEnable(GL_TEXTURE_3D);
2678 checkGLcall("glEnable(GL_TEXTURE_3D)");
2679 break;
2680 case GL_TEXTURE_CUBE_MAP_ARB:
2681 glDisable(GL_TEXTURE_2D);
2682 checkGLcall("glDisable(GL_TEXTURE_2D)");
2683 glDisable(GL_TEXTURE_3D);
2684 checkGLcall("glDisable(GL_TEXTURE_3D)");
2685 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2686 {
2687 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2688 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2689 }
2690 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
2691 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2692 break;
2693 }
2694 } else {
2695 glEnable(GL_TEXTURE_2D);
2696 checkGLcall("glEnable(GL_TEXTURE_2D)");
2697 glDisable(GL_TEXTURE_3D);
2698 checkGLcall("glDisable(GL_TEXTURE_3D)");
2699 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2700 {
2701 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2702 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2703 }
2704 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2705 {
2706 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2707 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2708 }
2709 /* Binding textures is done by samplers. A dummy texture will be bound */
2710 }
2711}
2712
2713/* GL locking is done by the caller (state handler) */
2714void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context)
2715{
2716 DWORD sampler = state - STATE_SAMPLER(0);
2717 DWORD mapped_stage = stateblock->device->texUnitMap[sampler];
2718
2719 /* No need to enable / disable anything here for unused samplers. The tex_colorop
2720 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
2721 * will take care of this business
2722 */
2723 if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures) return;
2724 if(sampler >= stateblock->lowest_disabled_stage) return;
2725 if(isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) return;
2726
2727 texture_activate_dimensions(sampler, stateblock, context);
2728}
2729
2730void *wined3d_rb_alloc(size_t size)
2731{
2732 return HeapAlloc(GetProcessHeap(), 0, size);
2733}
2734
2735void *wined3d_rb_realloc(void *ptr, size_t size)
2736{
2737 return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
2738}
2739
2740void wined3d_rb_free(void *ptr)
2741{
2742 HeapFree(GetProcessHeap(), 0, ptr);
2743}
2744
2745static int ffp_frag_program_key_compare(const void *key, const struct wine_rb_entry *entry)
2746{
2747 const struct ffp_frag_settings *ka = key;
2748 const struct ffp_frag_settings *kb = &WINE_RB_ENTRY_VALUE(entry, const struct ffp_frag_desc, entry)->settings;
2749
2750 return memcmp(ka, kb, sizeof(*ka));
2751}
2752
2753const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions =
2754{
2755 wined3d_rb_alloc,
2756 wined3d_rb_realloc,
2757 wined3d_rb_free,
2758 ffp_frag_program_key_compare,
2759};
2760
2761UINT wined3d_log2i(UINT32 x)
2762{
2763 static const UINT l[] =
2764 {
2765 ~0U, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
2766 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2767 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2768 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2769 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2770 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2771 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2772 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2773 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2774 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2775 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2776 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2777 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2778 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2779 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2780 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2781 };
2782 UINT32 i;
2783
2784 return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
2785}
2786
2787/* Set the shader type for this device, depending on the given capabilities
2788 * and the user preferences in wined3d_settings. */
2789void select_shader_mode(const struct wined3d_gl_info *gl_info, int *ps_selected, int *vs_selected)
2790{
2791 if (wined3d_settings.vs_mode == VS_NONE) *vs_selected = SHADER_NONE;
2792 else if (gl_info->supported[ARB_VERTEX_SHADER] && wined3d_settings.glslRequested)
2793 {
2794 /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
2795 * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
2796 * shaders only on this card. */
2797 if (gl_info->supported[NV_VERTEX_PROGRAM] && !gl_info->supported[NV_VERTEX_PROGRAM2]) *vs_selected = SHADER_ARB;
2798 else *vs_selected = SHADER_GLSL;
2799 }
2800 else if (gl_info->supported[ARB_VERTEX_PROGRAM]) *vs_selected = SHADER_ARB;
2801 else *vs_selected = SHADER_NONE;
2802
2803 if (wined3d_settings.ps_mode == PS_NONE) *ps_selected = SHADER_NONE;
2804 else if (gl_info->supported[ARB_FRAGMENT_SHADER] && wined3d_settings.glslRequested) *ps_selected = SHADER_GLSL;
2805 else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) *ps_selected = SHADER_ARB;
2806 else if (gl_info->supported[ATI_FRAGMENT_SHADER]) *ps_selected = SHADER_ATI;
2807 else *ps_selected = SHADER_NONE;
2808}
2809
2810const shader_backend_t *select_shader_backend(struct wined3d_adapter *adapter, WINED3DDEVTYPE device_type)
2811{
2812 int vs_selected_mode, ps_selected_mode;
2813
2814 select_shader_mode(&adapter->gl_info, &ps_selected_mode, &vs_selected_mode);
2815 if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) return &glsl_shader_backend;
2816 if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) return &arb_program_shader_backend;
2817 return &none_shader_backend;
2818}
2819
2820const struct fragment_pipeline *select_fragment_implementation(struct wined3d_adapter *adapter,
2821 WINED3DDEVTYPE device_type)
2822{
2823 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2824 int vs_selected_mode, ps_selected_mode;
2825
2826 select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2827 if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2828 && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_fragment_pipeline;
2829 else if (ps_selected_mode == SHADER_ATI) return &atifs_fragment_pipeline;
2830 else if (gl_info->supported[NV_REGISTER_COMBINERS]
2831 && gl_info->supported[NV_TEXTURE_SHADER2]) return &nvts_fragment_pipeline;
2832 else if (gl_info->supported[NV_REGISTER_COMBINERS]) return &nvrc_fragment_pipeline;
2833 else return &ffp_fragment_pipeline;
2834}
2835
2836const struct blit_shader *select_blit_implementation(struct wined3d_adapter *adapter, WINED3DDEVTYPE device_type)
2837{
2838 const struct wined3d_gl_info *gl_info = &adapter->gl_info;
2839 int vs_selected_mode, ps_selected_mode;
2840
2841 select_shader_mode(gl_info, &ps_selected_mode, &vs_selected_mode);
2842 if ((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL)
2843 && gl_info->supported[ARB_FRAGMENT_PROGRAM]) return &arbfp_blit;
2844 else return &ffp_blit;
2845}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette