?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push d1f5df181c120dbe494f7c89b454752c2e0dcc04
[wine/hacks.git] / dlls / wined3d / utils.c
blob808b8c7d2cf96427e225bd44d82dc1afa1f6cafb
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 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26 #include "config.h"
27 #include "wined3d_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
30
31 /*****************************************************************************
32 * Pixel format array
33 *
34 * For the formats WINED3DFMT_A32B32G32R32F, WINED3DFMT_A16B16G16R16F,
35 * and WINED3DFMT_A16B16G16R16 do not have correct alpha masks, because the
36 * high masks do not fit into the 32 bit values needed for ddraw. It is only
37 * used for ddraw mostly, and to figure out if the format has alpha at all, so
38 * setting a mask like 0x1 for those surfaces is correct. The 64 and 128 bit
39 * formats are not usable in 2D rendering because ddraw doesn't support them.
40 */
41 static const StaticPixelFormatDesc formats[] = {
42 /*{WINED3DFORMAT ,alphamask ,redmask ,greenmask ,bluemask ,bpp ,depth ,stencil, isFourcc*/
43 {WINED3DFMT_UNKNOWN ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
44 /* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
45 {WINED3DFMT_UYVY ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,TRUE },
46 {WINED3DFMT_YUY2 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,TRUE },
47 {WINED3DFMT_YV12 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
48 {WINED3DFMT_DXT1 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
49 {WINED3DFMT_DXT2 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
50 {WINED3DFMT_DXT3 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
51 {WINED3DFMT_DXT4 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
52 {WINED3DFMT_DXT5 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
53 {WINED3DFMT_MULTI2_ARGB8,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
54 {WINED3DFMT_G8R8_G8B8 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
55 {WINED3DFMT_R8G8_B8G8 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,0 ,0 ,TRUE },
56 /* IEEE formats */
57 {WINED3DFMT_R32F ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
58 {WINED3DFMT_G32R32F ,0x0 ,0x0 ,0x0 ,0x0 ,8 ,0 ,0 ,FALSE },
59 {WINED3DFMT_A32B32G32R32F,0x1 ,0x0 ,0x0 ,0x0 ,16 ,0 ,0 ,FALSE },
60 /* Hmm? */
61 {WINED3DFMT_CxV8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
62 /* Float */
63 {WINED3DFMT_R16F ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
64 {WINED3DFMT_G16R16F ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
65 {WINED3DFMT_A16B16G16R16F,0x1 ,0x0 ,0x0 ,0x0 ,8 ,0 ,0 ,FALSE },
66 /* Palettized formats */
67 {WINED3DFMT_A8P8 ,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
68 {WINED3DFMT_P8 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
69 /* Standard ARGB formats. Keep WINED3DFMT_R8G8B8(=20) at position 20 */
70 {WINED3DFMT_R8G8B8 ,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,3 ,0 ,0 ,FALSE },
71 {WINED3DFMT_A8R8G8B8 ,0xff000000 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,0 ,0 ,FALSE },
72 {WINED3DFMT_X8R8G8B8 ,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,0 ,0 ,FALSE },
73 {WINED3DFMT_R5G6B5 ,0x0 ,0x0000F800 ,0x000007e0 ,0x0000001f ,2 ,0 ,0 ,FALSE },
74 {WINED3DFMT_X1R5G5B5 ,0x0 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,0 ,0 ,FALSE },
75 {WINED3DFMT_A1R5G5B5 ,0x00008000 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,0 ,0 ,FALSE },
76 {WINED3DFMT_A4R4G4B4 ,0x0000f000 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,0 ,0 ,FALSE },
77 {WINED3DFMT_R3G3B2 ,0x0 ,0x000000e0 ,0x0000001c ,0x00000003 ,1 ,0 ,0 ,FALSE },
78 {WINED3DFMT_A8 ,0x000000ff ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
79 {WINED3DFMT_A8R3G3B2 ,0x0000ff00 ,0x000000e0 ,0x0000001c ,0x00000003 ,2 ,0 ,0 ,FALSE },
80 {WINED3DFMT_X4R4G4B4 ,0x0 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,0 ,0 ,FALSE },
81 {WINED3DFMT_A2B10G10R10 ,0xb0000000 ,0x000003ff ,0x000ffc00 ,0x3ff00000 ,4 ,0 ,0 ,FALSE },
82 {WINED3DFMT_A8B8G8R8 ,0xff000000 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,0 ,0 ,FALSE },
83 {WINED3DFMT_X8B8G8R8 ,0x0 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,0 ,0 ,FALSE },
84 {WINED3DFMT_G16R16 ,0x0 ,0x0000ffff ,0xffff0000 ,0x0 ,4 ,0 ,0 ,FALSE },
85 {WINED3DFMT_A2R10G10B10 ,0xb0000000 ,0x3ff00000 ,0x000ffc00 ,0x000003ff ,4 ,0 ,0 ,FALSE },
86 {WINED3DFMT_A16B16G16R16,0x1 ,0x0000ffff ,0xffff0000 ,0x0 ,8 ,0 ,0 ,FALSE },
87 /* Luminance */
88 {WINED3DFMT_L8 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
89 {WINED3DFMT_A8L8 ,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
90 {WINED3DFMT_A4L4 ,0x000000f0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,FALSE },
91 /* Bump mapping stuff */
92 {WINED3DFMT_V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
93 {WINED3DFMT_L6V5U5 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
94 {WINED3DFMT_X8L8V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
95 {WINED3DFMT_Q8W8V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
96 {WINED3DFMT_V16U16 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
97 {WINED3DFMT_W11V11U10 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
98 {WINED3DFMT_A2W10V10U10 ,0xb0000000 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
99 /* Depth stencil formats */
100 {WINED3DFMT_D16_LOCKABLE,0x0 ,0x0 ,0x0 ,0x0 ,2 ,16 ,0 ,FALSE },
101 {WINED3DFMT_D32 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,32 ,0 ,FALSE },
102 {WINED3DFMT_D15S1 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,15 ,1 ,FALSE },
103 {WINED3DFMT_D24S8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,24 ,8 ,FALSE },
104 {WINED3DFMT_D24X8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,24 ,0 ,FALSE },
105 {WINED3DFMT_D24X4S4 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,24 ,4 ,FALSE },
106 {WINED3DFMT_D16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,16 ,0 ,FALSE },
107 {WINED3DFMT_L16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,16 ,0 ,FALSE },
108 {WINED3DFMT_D32F_LOCKABLE,0x0 ,0x0 ,0x0 ,0x0 ,4 ,32 ,0 ,FALSE },
109 {WINED3DFMT_D24FS8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,24 ,8 ,FALSE },
110 /* Is this a vertex buffer? */
111 {WINED3DFMT_VERTEXDATA ,0x0 ,0x0 ,0x0 ,0x0 ,0 ,0 ,0 ,FALSE },
112 {WINED3DFMT_INDEX16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE },
113 {WINED3DFMT_INDEX32 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,0 ,0 ,FALSE },
114 {WINED3DFMT_Q16W16V16U16,0x0 ,0x0 ,0x0 ,0x0 ,8 ,0 ,0 ,FALSE },
115 /* Vendor-specific formats */
116 {WINED3DFMT_ATI2N ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,0 ,0 ,TRUE },
117 {WINED3DFMT_NVHU ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,TRUE },
118 {WINED3DFMT_NVHS ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,TRUE },
119 };
120
121 typedef struct {
122 WINED3DFORMAT fmt;
123 GLint glInternal, glGammaInternal, rtInternal, glFormat, glType;
124 unsigned int Flags;
125 } GlPixelFormatDescTemplate;
126
127 /*****************************************************************************
128 * OpenGL format template. Contains unexciting formats which do not need
129 * extension checks. The order in this table is independent of the order in
130 * the table StaticPixelFormatDesc above. Not all formats have to be in this
131 * table.
132 */
133 static const GlPixelFormatDescTemplate gl_formats_template[] = {
134 /*{ internal ,srgbInternal , rtInternal, format ,type \
135 ,Flags }*/
136 {WINED3DFMT_UNKNOWN ,0 ,0 , 0, 0 ,0
137 ,0 },
138 /* FourCC formats */
139 /* GL_APPLE_ycbcr_422 claims that its '2YUV' format, which is supported via the UNSIGNED_SHORT_8_8_REV_APPLE type
140 * is equivalent to 'UYVY' format on Windows, and the 'YUVS' via UNSIGNED_SHORT_8_8_APPLE equates to 'YUY2'. The
141 * d3d9 test however shows that the opposite is true. Since the extension is from 2002, it predates the x86 based
142 * Macs, so probably the endianess differs. This could be tested as soon as we have a Windows and MacOS on a big
143 * endian machine
144 */
145 {WINED3DFMT_UYVY ,GL_RGB ,GL_RGB , 0, GL_YCBCR_422_APPLE ,UNSIGNED_SHORT_8_8_APPLE
146 ,WINED3DFMT_FLAG_FILTERING },
147 {WINED3DFMT_YUY2 ,GL_RGB ,GL_RGB , 0, GL_YCBCR_422_APPLE ,UNSIGNED_SHORT_8_8_REV_APPLE
148 ,WINED3DFMT_FLAG_FILTERING },
149 {WINED3DFMT_YV12 ,GL_ALPHA ,GL_ALPHA , 0, GL_ALPHA ,GL_UNSIGNED_BYTE
150 ,WINED3DFMT_FLAG_FILTERING },
151 {WINED3DFMT_DXT1 ,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
152 ,WINED3DFMT_FLAG_FILTERING },
153 {WINED3DFMT_DXT2 ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
154 ,WINED3DFMT_FLAG_FILTERING },
155 {WINED3DFMT_DXT3 ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
156 ,WINED3DFMT_FLAG_FILTERING },
157 {WINED3DFMT_DXT4 ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
158 ,WINED3DFMT_FLAG_FILTERING },
159 {WINED3DFMT_DXT5 ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT , 0, GL_RGBA ,GL_UNSIGNED_BYTE
160 ,WINED3DFMT_FLAG_FILTERING },
161 {WINED3DFMT_MULTI2_ARGB8 ,0 ,0 , 0, 0 ,0
162 ,0 },
163 {WINED3DFMT_G8R8_G8B8 ,0 ,0 , 0, 0 ,0
164 ,0 },
165 {WINED3DFMT_R8G8_B8G8 ,0 ,0 , 0, 0 ,0
166 ,0 },
167 /* IEEE formats */
168 {WINED3DFMT_R32F ,GL_RGB32F_ARB ,GL_RGB32F_ARB , 0, GL_RED ,GL_FLOAT
169 ,WINED3DFMT_FLAG_RENDERTARGET },
170 {WINED3DFMT_G32R32F ,GL_RG32F ,GL_RG32F , 0, GL_RG ,GL_FLOAT
171 ,WINED3DFMT_FLAG_RENDERTARGET },
172 {WINED3DFMT_A32B32G32R32F ,GL_RGBA32F_ARB ,GL_RGBA32F_ARB , 0, GL_RGBA ,GL_FLOAT
173 ,WINED3DFMT_FLAG_RENDERTARGET },
174 /* Hmm? */
175 {WINED3DFMT_CxV8U8 ,0 ,0 , 0, 0 ,0
176 ,0 },
177 /* Float */
178 {WINED3DFMT_R16F ,GL_RGB16F_ARB ,GL_RGB16F_ARB , 0, GL_RED ,GL_HALF_FLOAT_ARB
179 ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
180 {WINED3DFMT_G16R16F ,GL_RG16F ,GL_RG16F , 0, GL_RG ,GL_HALF_FLOAT_ARB
181 ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
182 {WINED3DFMT_A16B16G16R16F ,GL_RGBA16F_ARB ,GL_RGBA16F_ARB , 0, GL_RGBA ,GL_HALF_FLOAT_ARB
183 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
184 /* Palettized formats */
185 {WINED3DFMT_A8P8, 0 ,0 , 0, 0 ,0
186 ,0 },
187 {WINED3DFMT_P8, GL_COLOR_INDEX8_EXT ,GL_COLOR_INDEX8_EXT , 0, GL_COLOR_INDEX ,GL_UNSIGNED_BYTE
188 ,0 },
189 /* Standard ARGB formats */
190 {WINED3DFMT_R8G8B8 ,GL_RGB8 ,GL_RGB8 , 0, GL_BGR ,GL_UNSIGNED_BYTE
191 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
192 {WINED3DFMT_A8R8G8B8 ,GL_RGBA8 ,GL_SRGB8_ALPHA8_EXT , 0, GL_BGRA ,GL_UNSIGNED_INT_8_8_8_8_REV
193 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
194 {WINED3DFMT_X8R8G8B8 ,GL_RGB8 ,GL_SRGB8_EXT , 0, GL_BGRA ,GL_UNSIGNED_INT_8_8_8_8_REV
195 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
196 {WINED3DFMT_R5G6B5 ,GL_RGB5 ,GL_RGB5 , GL_RGB8, GL_RGB ,GL_UNSIGNED_SHORT_5_6_5
197 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
198 {WINED3DFMT_X1R5G5B5 ,GL_RGB5 ,GL_RGB5_A1 , 0, GL_BGRA ,GL_UNSIGNED_SHORT_1_5_5_5_REV
199 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
200 {WINED3DFMT_A1R5G5B5 ,GL_RGB5_A1 ,GL_RGB5_A1 , 0, GL_BGRA ,GL_UNSIGNED_SHORT_1_5_5_5_REV
201 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
202 {WINED3DFMT_A4R4G4B4 ,GL_RGBA4 ,GL_SRGB8_ALPHA8_EXT , 0, GL_BGRA ,GL_UNSIGNED_SHORT_4_4_4_4_REV
203 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
204 {WINED3DFMT_R3G3B2 ,GL_R3_G3_B2 ,GL_R3_G3_B2 , 0, GL_RGB ,GL_UNSIGNED_BYTE_3_3_2
205 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING },
206 {WINED3DFMT_A8 ,GL_ALPHA8 ,GL_ALPHA8 , 0, GL_ALPHA ,GL_UNSIGNED_BYTE
207 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING },
208 {WINED3DFMT_A8R3G3B2 ,0 ,0 , 0, 0 ,0
209 ,0 },
210 {WINED3DFMT_X4R4G4B4 ,GL_RGB4 ,GL_RGB4 , 0, GL_BGRA ,GL_UNSIGNED_SHORT_4_4_4_4_REV
211 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
212 {WINED3DFMT_A2B10G10R10 ,GL_RGB10_A2 ,GL_RGB10_A2 , 0, GL_RGBA ,GL_UNSIGNED_INT_2_10_10_10_REV
213 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
214 {WINED3DFMT_A8B8G8R8 ,GL_RGBA8 ,GL_RGBA8 , 0, GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV
215 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
216 {WINED3DFMT_X8B8G8R8 ,GL_RGB8 ,GL_RGB8 , 0, GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV
217 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING},
218 {WINED3DFMT_G16R16 ,GL_RGB16_EXT ,GL_RGB16_EXT , 0, GL_RGB ,GL_UNSIGNED_SHORT
219 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
220 {WINED3DFMT_A2R10G10B10 ,GL_RGB10_A2 ,GL_RGB10_A2 , 0, GL_BGRA ,GL_UNSIGNED_INT_2_10_10_10_REV
221 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING },
222 {WINED3DFMT_A16B16G16R16 ,GL_RGBA16_EXT ,GL_RGBA16_EXT , 0, GL_RGBA ,GL_UNSIGNED_SHORT
223 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING | WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_RENDERTARGET },
224 /* Luminance */
225 {WINED3DFMT_L8 ,GL_LUMINANCE8 ,GL_SLUMINANCE8_EXT , 0, GL_LUMINANCE ,GL_UNSIGNED_BYTE
226 ,WINED3DFMT_FLAG_FILTERING },
227 {WINED3DFMT_A8L8 ,GL_LUMINANCE8_ALPHA8 ,GL_SLUMINANCE8_ALPHA8_EXT , 0, GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE
228 ,WINED3DFMT_FLAG_FILTERING },
229 {WINED3DFMT_A4L4 ,GL_LUMINANCE4_ALPHA4 ,GL_LUMINANCE4_ALPHA4 , 0, GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE
230 ,0 },
231 /* Bump mapping stuff */
232 {WINED3DFMT_V8U8 ,GL_DSDT8_NV ,GL_DSDT8_NV , 0, GL_DSDT_NV ,GL_BYTE
233 ,WINED3DFMT_FLAG_FILTERING },
234 {WINED3DFMT_L6V5U5 ,GL_DSDT8_MAG8_NV ,GL_DSDT8_MAG8_NV , 0, GL_DSDT_MAG_NV ,GL_BYTE
235 ,WINED3DFMT_FLAG_FILTERING },
236 {WINED3DFMT_X8L8V8U8 ,GL_DSDT8_MAG8_INTENSITY8_NV ,GL_DSDT8_MAG8_INTENSITY8_NV , 0, GL_DSDT_MAG_VIB_NV ,GL_UNSIGNED_INT_8_8_S8_S8_REV_NV
237 ,WINED3DFMT_FLAG_FILTERING },
238 {WINED3DFMT_Q8W8V8U8 ,GL_SIGNED_RGBA8_NV ,GL_SIGNED_RGBA8_NV , 0, GL_RGBA ,GL_BYTE
239 ,WINED3DFMT_FLAG_FILTERING },
240 {WINED3DFMT_V16U16 ,GL_SIGNED_HILO16_NV ,GL_SIGNED_HILO16_NV , 0, GL_HILO_NV ,GL_SHORT
241 ,WINED3DFMT_FLAG_FILTERING },
242 {WINED3DFMT_W11V11U10 ,0 ,0 , 0, 0 ,0
243 ,0 },
244 {WINED3DFMT_A2W10V10U10 ,0 ,0 , 0, 0 ,0
245 ,0 },
246 /* Depth stencil formats */
247 {WINED3DFMT_D16_LOCKABLE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_SHORT
248 ,WINED3DFMT_FLAG_DEPTH },
249 {WINED3DFMT_D32 ,GL_DEPTH_COMPONENT32_ARB ,GL_DEPTH_COMPONENT32_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT
250 ,WINED3DFMT_FLAG_DEPTH },
251 {WINED3DFMT_D15S1 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_SHORT
252 ,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
253 {WINED3DFMT_D24S8 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT
254 ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
255 {WINED3DFMT_D24X8 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT
256 ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH },
257 {WINED3DFMT_D24X4S4 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT
258 ,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL },
259 {WINED3DFMT_D16 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_UNSIGNED_SHORT
260 ,WINED3DFMT_FLAG_FILTERING | WINED3DFMT_FLAG_DEPTH },
261 {WINED3DFMT_L16 ,GL_LUMINANCE16_EXT ,GL_LUMINANCE16_EXT , 0, GL_LUMINANCE ,GL_UNSIGNED_SHORT
262 ,WINED3DFMT_FLAG_FILTERING },
263 {WINED3DFMT_D32F_LOCKABLE ,GL_DEPTH_COMPONENT32_ARB ,GL_DEPTH_COMPONENT32_ARB , 0, GL_DEPTH_COMPONENT ,GL_FLOAT
264 ,WINED3DFMT_FLAG_DEPTH },
265 {WINED3DFMT_D24FS8 ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB , 0, GL_DEPTH_COMPONENT ,GL_FLOAT
266 ,WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL},
267 /* Is this a vertex buffer? */
268 {WINED3DFMT_VERTEXDATA ,0 ,0 , 0, 0 ,0
269 ,0 },
270 {WINED3DFMT_INDEX16 ,0 ,0 , 0, 0 ,0
271 ,0 },
272 {WINED3DFMT_INDEX32 ,0 ,0 , 0, 0 ,0
273 ,0 },
274 {WINED3DFMT_Q16W16V16U16 ,GL_COLOR_INDEX ,GL_COLOR_INDEX , 0, GL_COLOR_INDEX ,GL_UNSIGNED_SHORT
275 ,0 },
276 /* Vendor-specific formats */
277 {WINED3DFMT_ATI2N ,0 ,0 , 0, GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE
278 ,0 },
279 {WINED3DFMT_NVHU ,0 ,0 , 0, GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE
280 ,0 },
281 {WINED3DFMT_NVHS ,0 ,0 , 0, GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE
282 ,0 }
283 };
284
285 static inline int getFmtIdx(WINED3DFORMAT fmt) {
286 /* First check if the format is at the position of its value.
287 * This will catch the argb formats before the loop is entered
288 */
289 if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
290 return fmt;
291 } else {
292 unsigned int i;
293 for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
294 if(formats[i].format == fmt) {
295 return i;
296 }
297 }
298 }
299 return -1;
300 }
301
302 #define GLINFO_LOCATION (*gl_info)
303 BOOL initPixelFormats(WineD3D_GL_Info *gl_info)
304 {
305 unsigned int src;
306 int dst;
307
308 gl_info->gl_formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
309 sizeof(formats) / sizeof(formats[0]) * sizeof(gl_info->gl_formats[0]));
310 if(!gl_info->gl_formats) return FALSE;
311
312 /* If a format depends on some extensions, remove them from the table above and initialize them
313 * after this loop
314 */
315 for(src = 0; src < sizeof(gl_formats_template) / sizeof(gl_formats_template[0]); src++) {
316 dst = getFmtIdx(gl_formats_template[src].fmt);
317 gl_info->gl_formats[dst].glInternal = gl_formats_template[src].glInternal;
318 gl_info->gl_formats[dst].glGammaInternal = gl_formats_template[src].glGammaInternal;
319 gl_info->gl_formats[dst].glFormat = gl_formats_template[src].glFormat;
320 gl_info->gl_formats[dst].glType = gl_formats_template[src].glType;
321 gl_info->gl_formats[dst].color_fixup = COLOR_FIXUP_IDENTITY;
322 gl_info->gl_formats[dst].Flags = gl_formats_template[src].Flags;
323 gl_info->gl_formats[dst].heightscale = 1.0;
324
325 if(wined3d_settings.offscreen_rendering_mode == ORM_FBO &&
326 gl_formats_template[src].rtInternal != 0) {
327 GLuint tex, fb;
328 GLenum status;
329
330 /* Check if the default internal format is supported as a frame buffer target, otherwise
331 * fall back to the render target internal.
332 *
333 * Try to stick to the standard format if possible, this limits precision differences
334 */
335 while(glGetError());
336 glGenTextures(1, &tex);
337 glBindTexture(GL_TEXTURE_2D, tex);
338 glTexImage2D(GL_TEXTURE_2D, 0, gl_formats_template[src].glInternal, 16, 16, 0,
339 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
340
341 GL_EXTCALL(glGenFramebuffersEXT(1, &fb));
342 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb));
343 GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
344 GL_TEXTURE_2D, tex, 0));
345
346 status = GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
347 GL_EXTCALL(glDeleteFramebuffersEXT(1, &fb));
348 glDeleteTextures(1, &tex);
349
350 checkGLcall("Framebuffer format check");
351
352 if(status != GL_FRAMEBUFFER_COMPLETE_EXT) {
353 TRACE("Internal format of %s not supported as frame buffer target, using render target internal instead\n",
354 debug_d3dformat(gl_formats_template[src].fmt));
355 gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].rtInternal;
356 } else {
357 TRACE("Format %s is supported as fbo target\n", debug_d3dformat(gl_formats_template[src].fmt));
358 gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].glInternal;
359 }
360
361 } else {
362 gl_info->gl_formats[dst].rtInternal = gl_formats_template[src].glInternal;
363 }
364 }
365
366 dst = getFmtIdx(WINED3DFMT_R16F);
367 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
368 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
369 /* When ARB_texture_rg is supported we only require 16-bit for R16F instead of 64-bit RGBA16F */
370 if(GL_SUPPORT(ARB_TEXTURE_RG))
371 {
372 gl_info->gl_formats[dst].glInternal = GL_R16F;
373 gl_info->gl_formats[dst].glGammaInternal = GL_R16F;
374 }
375
376 dst = getFmtIdx(WINED3DFMT_R32F);
377 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
378 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
379 /* When ARB_texture_rg is supported we only require 32-bit for R32F instead of 128-bit RGBA32F */
380 if(GL_SUPPORT(ARB_TEXTURE_RG))
381 {
382 gl_info->gl_formats[dst].glInternal = GL_R32F;
383 gl_info->gl_formats[dst].glGammaInternal = GL_R32F;
384 }
385
386 dst = getFmtIdx(WINED3DFMT_G16R16);
387 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
388 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
389
390 dst = getFmtIdx(WINED3DFMT_G16R16F);
391 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
392 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
393
394 dst = getFmtIdx(WINED3DFMT_G32R32F);
395 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
396 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_W);
397
398 /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
399 * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
400 * their extensions are not available. GL_ATI_envmap_bumpmap is not used because
401 * the only driver that implements it(fglrx) has a buggy implementation.
402 *
403 * V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
404 * returns 0.0 when sampling from it, DirectX 1.0. So we always have in-shader
405 * conversion for this format.
406 */
407 if (!GL_SUPPORT(NV_TEXTURE_SHADER))
408 {
409 dst = getFmtIdx(WINED3DFMT_V8U8);
410 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
411 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
412 dst = getFmtIdx(WINED3DFMT_V16U16);
413 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
414 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
415 }
416 else
417 {
418 dst = getFmtIdx(WINED3DFMT_V8U8);
419 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
420 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
421 dst = getFmtIdx(WINED3DFMT_V16U16);
422 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
423 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
424 }
425
426 if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
427 /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
428 * with each other
429 */
430 dst = getFmtIdx(WINED3DFMT_L6V5U5);
431 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
432 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_ONE);
433 dst = getFmtIdx(WINED3DFMT_X8L8V8U8);
434 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
435 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W);
436 dst = getFmtIdx(WINED3DFMT_Q8W8V8U8);
437 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
438 1, CHANNEL_SOURCE_X, 1, CHANNEL_SOURCE_Y, 1, CHANNEL_SOURCE_Z, 1, CHANNEL_SOURCE_W);
439 } else {
440 /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
441 * are converted at surface loading time, but they do not need any modification in
442 * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
443 * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
444 */
445 }
446
447 if(GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC)) {
448 dst = getFmtIdx(WINED3DFMT_ATI2N);
449 gl_info->gl_formats[dst].glInternal = GL_COMPRESSED_RED_GREEN_RGTC2_EXT;
450 gl_info->gl_formats[dst].glGammaInternal = GL_COMPRESSED_RED_GREEN_RGTC2_EXT;
451 gl_info->gl_formats[dst].color_fixup = create_color_fixup_desc(
452 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
453 } else if(GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC)) {
454 dst = getFmtIdx(WINED3DFMT_ATI2N);
455 gl_info->gl_formats[dst].glInternal = GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI;
456 gl_info->gl_formats[dst].glGammaInternal = GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI;
457 gl_info->gl_formats[dst].color_fixup= create_color_fixup_desc(
458 0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_W, 0, CHANNEL_SOURCE_ONE, 0, CHANNEL_SOURCE_ONE);
459 }
460
461 if(!GL_SUPPORT(APPLE_YCBCR_422)) {
462 dst = getFmtIdx(WINED3DFMT_YUY2);
463 gl_info->gl_formats[dst].glInternal = GL_LUMINANCE_ALPHA;
464 gl_info->gl_formats[dst].glGammaInternal = GL_LUMINANCE_ALPHA; /* not srgb */
465 gl_info->gl_formats[dst].glFormat = GL_LUMINANCE_ALPHA;
466 gl_info->gl_formats[dst].glType = GL_UNSIGNED_BYTE;
467 gl_info->gl_formats[dst].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_YUY2);
468
469 dst = getFmtIdx(WINED3DFMT_UYVY);
470 gl_info->gl_formats[dst].glInternal = GL_LUMINANCE_ALPHA;
471 gl_info->gl_formats[dst].glGammaInternal = GL_LUMINANCE_ALPHA; /* not srgb */
472 gl_info->gl_formats[dst].glFormat = GL_LUMINANCE_ALPHA;
473 gl_info->gl_formats[dst].glType = GL_UNSIGNED_BYTE;
474 gl_info->gl_formats[dst].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_UYVY);
475 }
476
477 dst = getFmtIdx(WINED3DFMT_YV12);
478 gl_info->gl_formats[dst].heightscale = 1.5;
479 gl_info->gl_formats[dst].color_fixup = create_yuv_fixup_desc(YUV_FIXUP_YV12);
480
481 return TRUE;
482 }
483
484 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
485 static WINED3DGLTYPE const glTypeLookupTemplate[WINED3DDECLTYPE_UNUSED] =
486 {
487 {WINED3DDECLTYPE_FLOAT1, 1, GL_FLOAT, 1, GL_FALSE, sizeof(float)},
488 {WINED3DDECLTYPE_FLOAT2, 2, GL_FLOAT, 2, GL_FALSE, sizeof(float)},
489 {WINED3DDECLTYPE_FLOAT3, 3, GL_FLOAT, 3, GL_FALSE, sizeof(float)},
490 {WINED3DDECLTYPE_FLOAT4, 4, GL_FLOAT, 4, GL_FALSE, sizeof(float)},
491 {WINED3DDECLTYPE_D3DCOLOR, 4, GL_UNSIGNED_BYTE, 4, GL_TRUE, sizeof(BYTE)},
492 {WINED3DDECLTYPE_UBYTE4, 4, GL_UNSIGNED_BYTE, 4, GL_FALSE, sizeof(BYTE)},
493 {WINED3DDECLTYPE_SHORT2, 2, GL_SHORT, 2, GL_FALSE, sizeof(short int)},
494 {WINED3DDECLTYPE_SHORT4, 4, GL_SHORT, 4, GL_FALSE, sizeof(short int)},
495 {WINED3DDECLTYPE_UBYTE4N, 4, GL_UNSIGNED_BYTE, 4, GL_TRUE, sizeof(BYTE)},
496 {WINED3DDECLTYPE_SHORT2N, 2, GL_SHORT, 2, GL_TRUE, sizeof(short int)},
497 {WINED3DDECLTYPE_SHORT4N, 4, GL_SHORT, 4, GL_TRUE, sizeof(short int)},
498 {WINED3DDECLTYPE_USHORT2N, 2, GL_UNSIGNED_SHORT, 2, GL_TRUE, sizeof(short int)},
499 {WINED3DDECLTYPE_USHORT4N, 4, GL_UNSIGNED_SHORT, 4, GL_TRUE, sizeof(short int)},
500 {WINED3DDECLTYPE_UDEC3, 3, GL_UNSIGNED_SHORT, 3, GL_FALSE, sizeof(short int)},
501 {WINED3DDECLTYPE_DEC3N, 3, GL_SHORT, 3, GL_TRUE, sizeof(short int)},
502 {WINED3DDECLTYPE_FLOAT16_2, 2, GL_FLOAT, 2, GL_FALSE, sizeof(GLhalfNV)},
503 {WINED3DDECLTYPE_FLOAT16_4, 4, GL_FLOAT, 4, GL_FALSE, sizeof(GLhalfNV)}
504 };
505
506 void init_type_lookup(WineD3D_GL_Info *gl_info) {
507 memcpy(gl_info->glTypeLookup, glTypeLookupTemplate, sizeof(glTypeLookupTemplate));
508
509 if (GL_SUPPORT(EXT_VERTEX_ARRAY_BGRA))
510 {
511 gl_info->glTypeLookup[WINED3DDECLTYPE_D3DCOLOR].format = GL_BGRA;
512 }
513
514 if (GL_SUPPORT(NV_HALF_FLOAT))
515 {
516 /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
517 * It is the job of the vertex buffer code to make sure that the vbos have the right format
518 */
519 gl_info->glTypeLookup[WINED3DDECLTYPE_FLOAT16_2].glType = GL_HALF_FLOAT_NV;
520 gl_info->glTypeLookup[WINED3DDECLTYPE_FLOAT16_4].glType = GL_HALF_FLOAT_NV;
521 }
522 }
523
524 #undef GLINFO_LOCATION
525
526 #define GLINFO_LOCATION This->adapter->gl_info
527
528 const StaticPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, const WineD3D_GL_Info *gl_info,
529 const struct GlPixelFormatDesc **glDesc)
530 {
531 int idx = getFmtIdx(fmt);
532
533 if(idx == -1) {
534 FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
535 /* Get the caller a valid pointer */
536 idx = getFmtIdx(WINED3DFMT_UNKNOWN);
537 }
538 if(glDesc) {
539 if(!gl_info->gl_formats) {
540 /* If we do not have gl format information, provide a dummy NULL format. This is an easy way to make
541 * all gl caps check return "unsupported" than catching the lack of gl all over the code. ANSI C requires
542 * static variables to be initialized to 0.
543 */
544 static const struct GlPixelFormatDesc dummyFmt;
545 *glDesc = &dummyFmt;
546 } else {
547 *glDesc = &gl_info->gl_formats[idx];
548 }
549 }
550 return &formats[idx];
551 }
552
553 /*****************************************************************************
554 * Trace formatting of useful values
555 */
556 const char* debug_d3dformat(WINED3DFORMAT fmt) {
557 switch (fmt) {
558 #define FMT_TO_STR(fmt) case fmt: return #fmt
559 FMT_TO_STR(WINED3DFMT_UNKNOWN);
560 FMT_TO_STR(WINED3DFMT_R8G8B8);
561 FMT_TO_STR(WINED3DFMT_A8R8G8B8);
562 FMT_TO_STR(WINED3DFMT_X8R8G8B8);
563 FMT_TO_STR(WINED3DFMT_R5G6B5);
564 FMT_TO_STR(WINED3DFMT_X1R5G5B5);
565 FMT_TO_STR(WINED3DFMT_A1R5G5B5);
566 FMT_TO_STR(WINED3DFMT_A4R4G4B4);
567 FMT_TO_STR(WINED3DFMT_R3G3B2);
568 FMT_TO_STR(WINED3DFMT_A8);
569 FMT_TO_STR(WINED3DFMT_A8R3G3B2);
570 FMT_TO_STR(WINED3DFMT_X4R4G4B4);
571 FMT_TO_STR(WINED3DFMT_A2B10G10R10);
572 FMT_TO_STR(WINED3DFMT_A8B8G8R8);
573 FMT_TO_STR(WINED3DFMT_X8B8G8R8);
574 FMT_TO_STR(WINED3DFMT_G16R16);
575 FMT_TO_STR(WINED3DFMT_A2R10G10B10);
576 FMT_TO_STR(WINED3DFMT_A16B16G16R16);
577 FMT_TO_STR(WINED3DFMT_A8P8);
578 FMT_TO_STR(WINED3DFMT_P8);
579 FMT_TO_STR(WINED3DFMT_L8);
580 FMT_TO_STR(WINED3DFMT_A8L8);
581 FMT_TO_STR(WINED3DFMT_A4L4);
582 FMT_TO_STR(WINED3DFMT_V8U8);
583 FMT_TO_STR(WINED3DFMT_L6V5U5);
584 FMT_TO_STR(WINED3DFMT_X8L8V8U8);
585 FMT_TO_STR(WINED3DFMT_Q8W8V8U8);
586 FMT_TO_STR(WINED3DFMT_V16U16);
587 FMT_TO_STR(WINED3DFMT_W11V11U10);
588 FMT_TO_STR(WINED3DFMT_A2W10V10U10);
589 FMT_TO_STR(WINED3DFMT_UYVY);
590 FMT_TO_STR(WINED3DFMT_YUY2);
591 FMT_TO_STR(WINED3DFMT_YV12);
592 FMT_TO_STR(WINED3DFMT_DXT1);
593 FMT_TO_STR(WINED3DFMT_DXT2);
594 FMT_TO_STR(WINED3DFMT_DXT3);
595 FMT_TO_STR(WINED3DFMT_DXT4);
596 FMT_TO_STR(WINED3DFMT_DXT5);
597 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8);
598 FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
599 FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
600 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
601 FMT_TO_STR(WINED3DFMT_D32);
602 FMT_TO_STR(WINED3DFMT_D15S1);
603 FMT_TO_STR(WINED3DFMT_D24S8);
604 FMT_TO_STR(WINED3DFMT_D24X8);
605 FMT_TO_STR(WINED3DFMT_D24X4S4);
606 FMT_TO_STR(WINED3DFMT_D16);
607 FMT_TO_STR(WINED3DFMT_L16);
608 FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE);
609 FMT_TO_STR(WINED3DFMT_D24FS8);
610 FMT_TO_STR(WINED3DFMT_VERTEXDATA);
611 FMT_TO_STR(WINED3DFMT_INDEX16);
612 FMT_TO_STR(WINED3DFMT_INDEX32);
613 FMT_TO_STR(WINED3DFMT_Q16W16V16U16);
614 FMT_TO_STR(WINED3DFMT_R16F);
615 FMT_TO_STR(WINED3DFMT_G16R16F);
616 FMT_TO_STR(WINED3DFMT_A16B16G16R16F);
617 FMT_TO_STR(WINED3DFMT_R32F);
618 FMT_TO_STR(WINED3DFMT_G32R32F);
619 FMT_TO_STR(WINED3DFMT_A32B32G32R32F);
620 FMT_TO_STR(WINED3DFMT_CxV8U8);
621 FMT_TO_STR(WINED3DFMT_ATI2N);
622 FMT_TO_STR(WINED3DFMT_NVHU);
623 FMT_TO_STR(WINED3DFMT_NVHS);
624 #undef FMT_TO_STR
625 default:
626 {
627 char fourcc[5];
628 fourcc[0] = (char)(fmt);
629 fourcc[1] = (char)(fmt >> 8);
630 fourcc[2] = (char)(fmt >> 16);
631 fourcc[3] = (char)(fmt >> 24);
632 fourcc[4] = 0;
633 if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
634 FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt, fourcc);
635 else
636 FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
637 }
638 return "unrecognized";
639 }
640 }
641
642 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
643 switch (devtype) {
644 #define DEVTYPE_TO_STR(dev) case dev: return #dev
645 DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL);
646 DEVTYPE_TO_STR(WINED3DDEVTYPE_REF);
647 DEVTYPE_TO_STR(WINED3DDEVTYPE_SW);
648 #undef DEVTYPE_TO_STR
649 default:
650 FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
651 return "unrecognized";
652 }
653 }
654
655 const char* debug_d3dusage(DWORD usage) {
656 switch (usage & WINED3DUSAGE_MASK) {
657 #define WINED3DUSAGE_TO_STR(u) case u: return #u
658 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
659 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
660 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
661 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
662 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
663 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
664 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
665 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
666 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
667 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP);
668 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP);
669 #undef WINED3DUSAGE_TO_STR
670 case 0: return "none";
671 default:
672 FIXME("Unrecognized %u Usage!\n", usage);
673 return "unrecognized";
674 }
675 }
676
677 const char* debug_d3dusagequery(DWORD usagequery) {
678 switch (usagequery & WINED3DUSAGE_QUERY_MASK) {
679 #define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
680 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER);
681 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP);
682 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING);
683 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD);
684 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE);
685 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE);
686 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP);
687 #undef WINED3DUSAGEQUERY_TO_STR
688 case 0: return "none";
689 default:
690 FIXME("Unrecognized %u Usage Query!\n", usagequery);
691 return "unrecognized";
692 }
693 }
694
695 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
696 switch (method) {
697 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
698 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT);
699 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU);
700 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV);
701 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV);
702 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV);
703 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP);
704 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED);
705 #undef WINED3DDECLMETHOD_TO_STR
706 default:
707 FIXME("Unrecognized %u declaration method!\n", method);
708 return "unrecognized";
709 }
710 }
711
712 const char* debug_d3ddecltype(WINED3DDECLTYPE type) {
713 switch (type) {
714 #define WINED3DDECLTYPE_TO_STR(u) case u: return #u
715 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT1);
716 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT2);
717 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT3);
718 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT4);
719 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_D3DCOLOR);
720 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4);
721 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2);
722 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4);
723 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4N);
724 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2N);
725 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4N);
726 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT2N);
727 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT4N);
728 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UDEC3);
729 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_DEC3N);
730 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_2);
731 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_4);
732 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UNUSED);
733 #undef WINED3DDECLTYPE_TO_STR
734 default:
735 FIXME("Unrecognized %u declaration type!\n", type);
736 return "unrecognized";
737 }
738 }
739
740 const char* debug_d3ddeclusage(BYTE usage) {
741 switch (usage) {
742 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
743 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
744 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
745 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
746 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
747 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
748 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
749 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
750 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
751 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
752 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
753 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
754 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
755 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
756 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
757 #undef WINED3DDECLUSAGE_TO_STR
758 default:
759 FIXME("Unrecognized %u declaration usage!\n", usage);
760 return "unrecognized";
761 }
762 }
763
764 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
765 switch (res) {
766 #define RES_TO_STR(res) case res: return #res
767 RES_TO_STR(WINED3DRTYPE_SURFACE);
768 RES_TO_STR(WINED3DRTYPE_VOLUME);
769 RES_TO_STR(WINED3DRTYPE_TEXTURE);
770 RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
771 RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
772 RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
773 RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
774 #undef RES_TO_STR
775 default:
776 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
777 return "unrecognized";
778 }
779 }
780
781 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) {
782 switch (PrimitiveType) {
783 #define PRIM_TO_STR(prim) case prim: return #prim
784 PRIM_TO_STR(WINED3DPT_POINTLIST);
785 PRIM_TO_STR(WINED3DPT_LINELIST);
786 PRIM_TO_STR(WINED3DPT_LINESTRIP);
787 PRIM_TO_STR(WINED3DPT_TRIANGLELIST);
788 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP);
789 PRIM_TO_STR(WINED3DPT_TRIANGLEFAN);
790 #undef PRIM_TO_STR
791 default:
792 FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
793 return "unrecognized";
794 }
795 }
796
797 const char* debug_d3drenderstate(DWORD state) {
798 switch (state) {
799 #define D3DSTATE_TO_STR(u) case u: return #u
800 D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE );
801 D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS );
802 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS );
803 D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE );
804 D3DSTATE_TO_STR(WINED3DRS_WRAPU );
805 D3DSTATE_TO_STR(WINED3DRS_WRAPV );
806 D3DSTATE_TO_STR(WINED3DRS_ZENABLE );
807 D3DSTATE_TO_STR(WINED3DRS_FILLMODE );
808 D3DSTATE_TO_STR(WINED3DRS_SHADEMODE );
809 D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN );
810 D3DSTATE_TO_STR(WINED3DRS_MONOENABLE );
811 D3DSTATE_TO_STR(WINED3DRS_ROP2 );
812 D3DSTATE_TO_STR(WINED3DRS_PLANEMASK );
813 D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE );
814 D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE );
815 D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL );
816 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG );
817 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN );
818 D3DSTATE_TO_STR(WINED3DRS_SRCBLEND );
819 D3DSTATE_TO_STR(WINED3DRS_DESTBLEND );
820 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND );
821 D3DSTATE_TO_STR(WINED3DRS_CULLMODE );
822 D3DSTATE_TO_STR(WINED3DRS_ZFUNC );
823 D3DSTATE_TO_STR(WINED3DRS_ALPHAREF );
824 D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC );
825 D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE );
826 D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE );
827 D3DSTATE_TO_STR(WINED3DRS_FOGENABLE );
828 D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE );
829 D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE );
830 D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL );
831 D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX );
832 D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA );
833 D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR );
834 D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE );
835 D3DSTATE_TO_STR(WINED3DRS_FOGSTART );
836 D3DSTATE_TO_STR(WINED3DRS_FOGEND );
837 D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY );
838 D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE );
839 D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS );
840 D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE );
841 D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR );
842 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU );
843 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV );
844 D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS );
845 D3DSTATE_TO_STR(WINED3DRS_ZBIAS );
846 D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE );
847 D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY );
848 D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH );
849 D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
850 D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE );
851 D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL );
852 D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL );
853 D3DSTATE_TO_STR(WINED3DRS_STENCILPASS );
854 D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC );
855 D3DSTATE_TO_STR(WINED3DRS_STENCILREF );
856 D3DSTATE_TO_STR(WINED3DRS_STENCILMASK );
857 D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK );
858 D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR );
859 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00 );
860 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01 );
861 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02 );
862 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03 );
863 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04 );
864 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05 );
865 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06 );
866 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07 );
867 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08 );
868 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09 );
869 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10 );
870 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11 );
871 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12 );
872 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13 );
873 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14 );
874 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15 );
875 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16 );
876 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17 );
877 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18 );
878 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19 );
879 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20 );
880 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21 );
881 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22 );
882 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23 );
883 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24 );
884 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25 );
885 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26 );
886 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27 );
887 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28 );
888 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29 );
889 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30 );
890 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31 );
891 D3DSTATE_TO_STR(WINED3DRS_WRAP0 );
892 D3DSTATE_TO_STR(WINED3DRS_WRAP1 );
893 D3DSTATE_TO_STR(WINED3DRS_WRAP2 );
894 D3DSTATE_TO_STR(WINED3DRS_WRAP3 );
895 D3DSTATE_TO_STR(WINED3DRS_WRAP4 );
896 D3DSTATE_TO_STR(WINED3DRS_WRAP5 );
897 D3DSTATE_TO_STR(WINED3DRS_WRAP6 );
898 D3DSTATE_TO_STR(WINED3DRS_WRAP7 );
899 D3DSTATE_TO_STR(WINED3DRS_CLIPPING );
900 D3DSTATE_TO_STR(WINED3DRS_LIGHTING );
901 D3DSTATE_TO_STR(WINED3DRS_EXTENTS );
902 D3DSTATE_TO_STR(WINED3DRS_AMBIENT );
903 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE );
904 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX );
905 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER );
906 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS );
907 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE );
908 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE );
909 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE );
910 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE );
911 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE );
912 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND );
913 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE );
914 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING );
915 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE );
916 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN );
917 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE );
918 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE );
919 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A );
920 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B );
921 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C );
922 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS );
923 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK );
924 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE );
925 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS );
926 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN );
927 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX );
928 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE );
929 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE );
930 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR );
931 D3DSTATE_TO_STR(WINED3DRS_BLENDOP );
932 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE );
933 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE );
934 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE );
935 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS );
936 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE );
937 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL );
938 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL );
939 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X );
940 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y );
941 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z );
942 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W );
943 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
944 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE );
945 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL );
946 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL );
947 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS );
948 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC );
949 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1 );
950 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2 );
951 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3 );
952 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR );
953 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE );
954 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS );
955 D3DSTATE_TO_STR(WINED3DRS_WRAP8 );
956 D3DSTATE_TO_STR(WINED3DRS_WRAP9 );
957 D3DSTATE_TO_STR(WINED3DRS_WRAP10 );
958 D3DSTATE_TO_STR(WINED3DRS_WRAP11 );
959 D3DSTATE_TO_STR(WINED3DRS_WRAP12 );
960 D3DSTATE_TO_STR(WINED3DRS_WRAP13 );
961 D3DSTATE_TO_STR(WINED3DRS_WRAP14 );
962 D3DSTATE_TO_STR(WINED3DRS_WRAP15 );
963 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE );
964 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA );
965 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA );
966 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA );
967 #undef D3DSTATE_TO_STR
968 default:
969 FIXME("Unrecognized %u render state!\n", state);
970 return "unrecognized";
971 }
972 }
973
974 const char* debug_d3dsamplerstate(DWORD state) {
975 switch (state) {
976 #define D3DSTATE_TO_STR(u) case u: return #u
977 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR );
978 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU );
979 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV );
980 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW );
981 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER );
982 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER );
983 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER );
984 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
985 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL );
986 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
987 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE );
988 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
989 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET );
990 #undef D3DSTATE_TO_STR
991 default:
992 FIXME("Unrecognized %u sampler state!\n", state);
993 return "unrecognized";
994 }
995 }
996
997 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
998 switch (filter_type) {
999 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
1000 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
1001 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
1002 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
1003 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
1004 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
1005 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
1006 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
1007 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
1008 #undef D3DTEXTUREFILTERTYPE_TO_STR
1009 default:
1010 FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
1011 return "unrecognized";
1012 }
1013 }
1014
1015 const char* debug_d3dtexturestate(DWORD state) {
1016 switch (state) {
1017 #define D3DSTATE_TO_STR(u) case u: return #u
1018 D3DSTATE_TO_STR(WINED3DTSS_COLOROP );
1019 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1 );
1020 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2 );
1021 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP );
1022 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1 );
1023 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2 );
1024 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00 );
1025 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01 );
1026 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10 );
1027 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11 );
1028 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX );
1029 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE );
1030 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET );
1031 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
1032 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0 );
1033 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0 );
1034 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG );
1035 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT );
1036 #undef D3DSTATE_TO_STR
1037 default:
1038 FIXME("Unrecognized %u texture state!\n", state);
1039 return "unrecognized";
1040 }
1041 }
1042
1043 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
1044 switch (d3dtop) {
1045 #define D3DTOP_TO_STR(u) case u: return #u
1046 D3DTOP_TO_STR(WINED3DTOP_DISABLE);
1047 D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
1048 D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
1049 D3DTOP_TO_STR(WINED3DTOP_MODULATE);
1050 D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
1051 D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
1052 D3DTOP_TO_STR(WINED3DTOP_ADD);
1053 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
1054 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X);
1055 D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
1056 D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
1057 D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
1058 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
1059 D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
1060 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
1061 D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
1062 D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
1063 D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
1064 D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
1065 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
1066 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
1067 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
1068 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
1069 D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
1070 D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
1071 D3DTOP_TO_STR(WINED3DTOP_LERP);
1072 #undef D3DTOP_TO_STR
1073 default:
1074 FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
1075 return "unrecognized";
1076 }
1077 }
1078
1079 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
1080 switch (tstype) {
1081 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
1082 TSTYPE_TO_STR(WINED3DTS_VIEW);
1083 TSTYPE_TO_STR(WINED3DTS_PROJECTION);
1084 TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
1085 TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
1086 TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
1087 TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
1088 TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
1089 TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
1090 TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
1091 TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
1092 TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
1093 #undef TSTYPE_TO_STR
1094 default:
1095 if (tstype > 256 && tstype < 512) {
1096 FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
1097 return ("WINED3DTS_WORLDMATRIX > 0");
1098 }
1099 FIXME("Unrecognized %u WINED3DTS\n", tstype);
1100 return "unrecognized";
1101 }
1102 }
1103
1104 const char* debug_d3dpool(WINED3DPOOL Pool) {
1105 switch (Pool) {
1106 #define POOL_TO_STR(p) case p: return #p
1107 POOL_TO_STR(WINED3DPOOL_DEFAULT);
1108 POOL_TO_STR(WINED3DPOOL_MANAGED);
1109 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
1110 POOL_TO_STR(WINED3DPOOL_SCRATCH);
1111 #undef POOL_TO_STR
1112 default:
1113 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
1114 return "unrecognized";
1115 }
1116 }
1117
1118 const char *debug_fbostatus(GLenum status) {
1119 switch(status) {
1120 #define FBOSTATUS_TO_STR(u) case u: return #u
1121 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT);
1122 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT);
1123 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT);
1124 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
1125 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
1126 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT);
1127 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT);
1128 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT);
1129 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT);
1130 #undef FBOSTATUS_TO_STR
1131 default:
1132 FIXME("Unrecognied FBO status 0x%08x\n", status);
1133 return "unrecognized";
1134 }
1135 }
1136
1137 const char *debug_glerror(GLenum error) {
1138 switch(error) {
1139 #define GLERROR_TO_STR(u) case u: return #u
1140 GLERROR_TO_STR(GL_NO_ERROR);
1141 GLERROR_TO_STR(GL_INVALID_ENUM);
1142 GLERROR_TO_STR(GL_INVALID_VALUE);
1143 GLERROR_TO_STR(GL_INVALID_OPERATION);
1144 GLERROR_TO_STR(GL_STACK_OVERFLOW);
1145 GLERROR_TO_STR(GL_STACK_UNDERFLOW);
1146 GLERROR_TO_STR(GL_OUT_OF_MEMORY);
1147 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT);
1148 #undef GLERROR_TO_STR
1149 default:
1150 FIXME("Unrecognied GL error 0x%08x\n", error);
1151 return "unrecognized";
1152 }
1153 }
1154
1155 const char *debug_d3dbasis(WINED3DBASISTYPE basis) {
1156 switch(basis) {
1157 case WINED3DBASIS_BEZIER: return "WINED3DBASIS_BEZIER";
1158 case WINED3DBASIS_BSPLINE: return "WINED3DBASIS_BSPLINE";
1159 case WINED3DBASIS_INTERPOLATE: return "WINED3DBASIS_INTERPOLATE";
1160 default: return "unrecognized";
1161 }
1162 }
1163
1164 const char *debug_d3ddegree(WINED3DDEGREETYPE degree) {
1165 switch(degree) {
1166 case WINED3DDEGREE_LINEAR: return "WINED3DDEGREE_LINEAR";
1167 case WINED3DDEGREE_QUADRATIC: return "WINED3DDEGREE_QUADRATIC";
1168 case WINED3DDEGREE_CUBIC: return "WINED3DDEGREE_CUBIC";
1169 case WINED3DDEGREE_QUINTIC: return "WINED3DDEGREE_QUINTIC";
1170 default: return "unrecognized";
1171 }
1172 }
1173
1174 const char *debug_fixup_channel_source(enum fixup_channel_source source)
1175 {
1176 switch(source)
1177 {
1178 #define WINED3D_TO_STR(x) case x: return #x
1179 WINED3D_TO_STR(CHANNEL_SOURCE_ZERO);
1180 WINED3D_TO_STR(CHANNEL_SOURCE_ONE);
1181 WINED3D_TO_STR(CHANNEL_SOURCE_X);
1182 WINED3D_TO_STR(CHANNEL_SOURCE_Y);
1183 WINED3D_TO_STR(CHANNEL_SOURCE_Z);
1184 WINED3D_TO_STR(CHANNEL_SOURCE_W);
1185 WINED3D_TO_STR(CHANNEL_SOURCE_YUV0);
1186 WINED3D_TO_STR(CHANNEL_SOURCE_YUV1);
1187 #undef WINED3D_TO_STR
1188 default:
1189 FIXME("Unrecognized fixup_channel_source %#x\n", source);
1190 return "unrecognized";
1191 }
1192 }
1193
1194 const char *debug_yuv_fixup(enum yuv_fixup yuv_fixup)
1195 {
1196 switch(yuv_fixup)
1197 {
1198 #define WINED3D_TO_STR(x) case x: return #x
1199 WINED3D_TO_STR(YUV_FIXUP_YUY2);
1200 WINED3D_TO_STR(YUV_FIXUP_UYVY);
1201 WINED3D_TO_STR(YUV_FIXUP_YV12);
1202 #undef WINED3D_TO_STR
1203 default:
1204 FIXME("Unrecognized YUV fixup %#x\n", yuv_fixup);
1205 return "unrecognized";
1206 }
1207 }
1208
1209 void dump_color_fixup_desc(struct color_fixup_desc fixup)
1210 {
1211 if (is_yuv_fixup(fixup))
1212 {
1213 TRACE("\tYUV: %s\n", debug_yuv_fixup(get_yuv_fixup(fixup)));
1214 return;
1215 }
1216
1217 TRACE("\tX: %s%s\n", debug_fixup_channel_source(fixup.x_source), fixup.x_sign_fixup ? ", SIGN_FIXUP" : "");
1218 TRACE("\tY: %s%s\n", debug_fixup_channel_source(fixup.y_source), fixup.y_sign_fixup ? ", SIGN_FIXUP" : "");
1219 TRACE("\tZ: %s%s\n", debug_fixup_channel_source(fixup.z_source), fixup.z_sign_fixup ? ", SIGN_FIXUP" : "");
1220 TRACE("\tW: %s%s\n", debug_fixup_channel_source(fixup.w_source), fixup.w_sign_fixup ? ", SIGN_FIXUP" : "");
1221 }
1222
1223 /*****************************************************************************
1224 * Useful functions mapping GL <-> D3D values
1225 */
1226 GLenum StencilOp(DWORD op) {
1227 switch(op) {
1228 case WINED3DSTENCILOP_KEEP : return GL_KEEP;
1229 case WINED3DSTENCILOP_ZERO : return GL_ZERO;
1230 case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
1231 case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
1232 case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
1233 case WINED3DSTENCILOP_INVERT : return GL_INVERT;
1234 case WINED3DSTENCILOP_INCR : return GL_INCR_WRAP_EXT;
1235 case WINED3DSTENCILOP_DECR : return GL_DECR_WRAP_EXT;
1236 default:
1237 FIXME("Unrecognized stencil op %d\n", op);
1238 return GL_KEEP;
1239 }
1240 }
1241
1242 GLenum CompareFunc(DWORD func) {
1243 switch ((WINED3DCMPFUNC)func) {
1244 case WINED3DCMP_NEVER : return GL_NEVER;
1245 case WINED3DCMP_LESS : return GL_LESS;
1246 case WINED3DCMP_EQUAL : return GL_EQUAL;
1247 case WINED3DCMP_LESSEQUAL : return GL_LEQUAL;
1248 case WINED3DCMP_GREATER : return GL_GREATER;
1249 case WINED3DCMP_NOTEQUAL : return GL_NOTEQUAL;
1250 case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
1251 case WINED3DCMP_ALWAYS : return GL_ALWAYS;
1252 default:
1253 FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
1254 return 0;
1255 }
1256 }
1257
1258 BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
1259 if (op == WINED3DTOP_DISABLE) return FALSE;
1260 if (This->stateBlock->textures[stage]) return FALSE;
1261
1262 if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1263 && op != WINED3DTOP_SELECTARG2) return TRUE;
1264 if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1265 && op != WINED3DTOP_SELECTARG1) return TRUE;
1266 if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
1267 && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
1268
1269 return FALSE;
1270 }
1271
1272 /* Setup this textures matrix according to the texture flags*/
1273 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed, DWORD coordtype,
1274 BOOL ffp_proj_control)
1275 {
1276 float mat[16];
1277
1278 glMatrixMode(GL_TEXTURE);
1279 checkGLcall("glMatrixMode(GL_TEXTURE)");
1280
1281 if (flags == WINED3DTTFF_DISABLE || flags == WINED3DTTFF_COUNT1 || transformed) {
1282 glLoadIdentity();
1283 checkGLcall("glLoadIdentity()");
1284 return;
1285 }
1286
1287 if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
1288 ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
1289 return;
1290 }
1291
1292 memcpy(mat, smat, 16 * sizeof(float));
1293
1294 if (flags & WINED3DTTFF_PROJECTED) {
1295 if(!ffp_proj_control) {
1296 switch (flags & ~WINED3DTTFF_PROJECTED) {
1297 case WINED3DTTFF_COUNT2:
1298 mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
1299 mat[1] = mat[5] = mat[9] = mat[13] = 0;
1300 break;
1301 case WINED3DTTFF_COUNT3:
1302 mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
1303 mat[2] = mat[6] = mat[10] = mat[14] = 0;
1304 break;
1305 }
1306 }
1307 } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1308 if(!calculatedCoords) {
1309 switch(coordtype) {
1310 case WINED3DDECLTYPE_FLOAT1:
1311 /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
1312 * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
1313 * the input value to the transformation will be 0, so the matrix value is irrelevant
1314 */
1315 mat[12] = mat[4];
1316 mat[13] = mat[5];
1317 mat[14] = mat[6];
1318 mat[15] = mat[7];
1319 break;
1320 case WINED3DDECLTYPE_FLOAT2:
1321 /* See above, just 3rd and 4th coord
1322 */
1323 mat[12] = mat[8];
1324 mat[13] = mat[9];
1325 mat[14] = mat[10];
1326 mat[15] = mat[11];
1327 break;
1328 case WINED3DDECLTYPE_FLOAT3: /* Opengl defaults match dx defaults */
1329 case WINED3DDECLTYPE_FLOAT4: /* No defaults apply, all app defined */
1330
1331 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
1332 * into a bad place. The division elimination below will apply to make sure the
1333 * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
1334 */
1335 case WINED3DDECLTYPE_UNUSED: /* No texture coords, 0/0/0/1 defaults are passed */
1336 break;
1337 default:
1338 FIXME("Unexpected fixed function texture coord input\n");
1339 }
1340 }
1341 if(!ffp_proj_control) {
1342 switch (flags & ~WINED3DTTFF_PROJECTED) {
1343 /* case WINED3DTTFF_COUNT1: Won't ever get here */
1344 case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
1345 /* OpenGL divides the first 3 vertex coord by the 4th by default,
1346 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
1347 * the 4th coord evaluates to 1.0 to eliminate that.
1348 *
1349 * If the fixed function pipeline is used, the 4th value remains unused,
1350 * so there is no danger in doing this. With vertex shaders we have a
1351 * problem. Should an app hit that problem, the code here would have to
1352 * check for pixel shaders, and the shader has to undo the default gl divide.
1353 *
1354 * A more serious problem occurs if the app passes 4 coordinates in, and the
1355 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
1356 * or a replacement shader
1357 */
1358 default: mat[3] = mat[7] = mat[11] = 0; mat[15] = 1;
1359 }
1360 }
1361 }
1362
1363 glLoadMatrixf(mat);
1364 checkGLcall("glLoadMatrixf(mat)");
1365 }
1366 #undef GLINFO_LOCATION
1367
1368 /* This small helper function is used to convert a bitmask into the number of masked bits */
1369 unsigned int count_bits(unsigned int mask)
1370 {
1371 unsigned int count;
1372 for (count = 0; mask; ++count)
1373 {
1374 mask &= mask - 1;
1375 }
1376 return count;
1377 }
1378
1379 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
1380 * The later function requires individual color components. */
1381 BOOL getColorBits(WINED3DFORMAT fmt, short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize)
1382 {
1383 const StaticPixelFormatDesc *desc;
1384
1385 TRACE("fmt: %s\n", debug_d3dformat(fmt));
1386 switch(fmt)
1387 {
1388 case WINED3DFMT_X8R8G8B8:
1389 case WINED3DFMT_R8G8B8:
1390 case WINED3DFMT_A8R8G8B8:
1391 case WINED3DFMT_A2R10G10B10:
1392 case WINED3DFMT_X1R5G5B5:
1393 case WINED3DFMT_A1R5G5B5:
1394 case WINED3DFMT_R5G6B5:
1395 case WINED3DFMT_X4R4G4B4:
1396 case WINED3DFMT_A4R4G4B4:
1397 case WINED3DFMT_R3G3B2:
1398 case WINED3DFMT_A8P8:
1399 case WINED3DFMT_P8:
1400 break;
1401 default:
1402 ERR("Unsupported format: %s\n", debug_d3dformat(fmt));
1403 return FALSE;
1404 }
1405
1406 desc = getFormatDescEntry(fmt, NULL, NULL);
1407 if(!desc)
1408 {
1409 ERR("Unable to look up format: 0x%x\n", fmt);
1410 return FALSE;
1411 }
1412 *redSize = count_bits(desc->redMask);
1413 *greenSize = count_bits(desc->greenMask);
1414 *blueSize = count_bits(desc->blueMask);
1415 *alphaSize = count_bits(desc->alphaMask);
1416 *totalSize = *redSize + *greenSize + *blueSize + *alphaSize;
1417
1418 TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n", *redSize, *greenSize, *blueSize, *alphaSize, *totalSize, debug_d3dformat(fmt));
1419 return TRUE;
1420 }
1421
1422 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
1423 BOOL getDepthStencilBits(WINED3DFORMAT fmt, short *depthSize, short *stencilSize)
1424 {
1425 const StaticPixelFormatDesc *desc;
1426
1427 TRACE("fmt: %s\n", debug_d3dformat(fmt));
1428 switch(fmt)
1429 {
1430 case WINED3DFMT_D16_LOCKABLE:
1431 case WINED3DFMT_D16:
1432 case WINED3DFMT_D15S1:
1433 case WINED3DFMT_D24X8:
1434 case WINED3DFMT_D24X4S4:
1435 case WINED3DFMT_D24S8:
1436 case WINED3DFMT_D24FS8:
1437 case WINED3DFMT_D32:
1438 case WINED3DFMT_D32F_LOCKABLE:
1439 break;
1440 default:
1441 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(fmt));
1442 return FALSE;
1443 }
1444
1445 desc = getFormatDescEntry(fmt, NULL, NULL);
1446 if(!desc)
1447 {
1448 ERR("Unable to look up format: 0x%x\n", fmt);
1449 return FALSE;
1450 }
1451 *depthSize = desc->depthSize;
1452 *stencilSize = desc->stencilSize;
1453
1454 TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n", *depthSize, *stencilSize, debug_d3dformat(fmt));
1455 return TRUE;
1456 }
1457
1458 /* DirectDraw stuff */
1459 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
1460 switch(depth) {
1461 case 8: return WINED3DFMT_P8;
1462 case 15: return WINED3DFMT_X1R5G5B5;
1463 case 16: return WINED3DFMT_R5G6B5;
1464 case 24: return WINED3DFMT_X8R8G8B8; /* Robots needs 24bit to be X8R8G8B8 */
1465 case 32: return WINED3DFMT_X8R8G8B8; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return X8R8G8B8 */
1466 default: return WINED3DFMT_UNKNOWN;
1467 }
1468 }
1469
1470 void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
1471 WINED3DMATRIX temp;
1472
1473 /* Now do the multiplication 'by hand'.
1474 I know that all this could be optimised, but this will be done later :-) */
1475 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);
1476 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);
1477 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);
1478 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);
1479
1480 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);
1481 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);
1482 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);
1483 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);
1484
1485 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);
1486 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);
1487 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);
1488 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);
1489
1490 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);
1491 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);
1492 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);
1493 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);
1494
1495 /* And copy the new matrix in the good storage.. */
1496 memcpy(dest, &temp, 16 * sizeof(float));
1497 }
1498
1499 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
1500 DWORD size = 0;
1501 int i;
1502 int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
1503
1504 if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
1505 if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
1506 if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
1507 if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
1508 switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
1509 case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
1510 case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
1511 case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break;
1512 case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break;
1513 case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break;
1514 case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break;
1515 case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break;
1516 case WINED3DFVF_XYZW: size += 4 * sizeof(float); break;
1517 default: ERR("Unexpected position mask\n");
1518 }
1519 for (i = 0; i < numTextures; i++) {
1520 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
1521 }
1522
1523 return size;
1524 }
1525
1526 /***********************************************************************
1527 * CalculateTexRect
1528 *
1529 * Calculates the dimensions of the opengl texture used for blits.
1530 * Handled oversized opengl textures and updates the source rectangle
1531 * accordingly
1532 *
1533 * Params:
1534 * This: Surface to operate on
1535 * Rect: Requested rectangle
1536 *
1537 * Returns:
1538 * TRUE if the texture part can be loaded,
1539 * FALSE otherwise
1540 *
1541 *********************************************************************/
1542 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
1543
1544 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
1545 int x1 = Rect->left, x2 = Rect->right;
1546 int y1 = Rect->top, y2 = Rect->bottom;
1547 GLint maxSize = GL_LIMITS(texture_size);
1548
1549 TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
1550 Rect->left, Rect->top, Rect->right, Rect->bottom);
1551
1552 /* The sizes might be reversed */
1553 if(Rect->left > Rect->right) {
1554 x1 = Rect->right;
1555 x2 = Rect->left;
1556 }
1557 if(Rect->top > Rect->bottom) {
1558 y1 = Rect->bottom;
1559 y2 = Rect->top;
1560 }
1561
1562 /* No oversized texture? This is easy */
1563 if(!(This->Flags & SFLAG_OVERSIZE)) {
1564 /* Which rect from the texture do I need? */
1565 if(This->glDescription.target == GL_TEXTURE_RECTANGLE_ARB) {
1566 glTexCoord[0] = (float) Rect->left;
1567 glTexCoord[2] = (float) Rect->top;
1568 glTexCoord[1] = (float) Rect->right;
1569 glTexCoord[3] = (float) Rect->bottom;
1570 } else {
1571 glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
1572 glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
1573 glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
1574 glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
1575 }
1576
1577 return TRUE;
1578 } else {
1579 /* Check if we can succeed at all */
1580 if( (x2 - x1) > maxSize ||
1581 (y2 - y1) > maxSize ) {
1582 TRACE("Requested rectangle is too large for gl\n");
1583 return FALSE;
1584 }
1585
1586 /* A part of the texture has to be picked. First, check if
1587 * some texture part is loaded already, if yes try to re-use it.
1588 * If the texture is dirty, or the part can't be used,
1589 * re-position the part to load
1590 */
1591 if(This->Flags & SFLAG_INTEXTURE) {
1592 if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
1593 This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
1594 /* Ok, the rectangle is ok, re-use it */
1595 TRACE("Using existing gl Texture\n");
1596 } else {
1597 /* Rectangle is not ok, dirtify the texture to reload it */
1598 TRACE("Dirtifying texture to force reload\n");
1599 This->Flags &= ~SFLAG_INTEXTURE;
1600 }
1601 }
1602
1603 /* Now if we are dirty(no else if!) */
1604 if(!(This->Flags & SFLAG_INTEXTURE)) {
1605 /* Set the new rectangle. Use the following strategy:
1606 * 1) Use as big textures as possible.
1607 * 2) Place the texture part in the way that the requested
1608 * part is in the middle of the texture(well, almost)
1609 * 3) If the texture is moved over the edges of the
1610 * surface, replace it nicely
1611 * 4) If the coord is not limiting the texture size,
1612 * use the whole size
1613 */
1614 if((This->pow2Width) > maxSize) {
1615 This->glRect.left = x1 - maxSize / 2;
1616 if(This->glRect.left < 0) {
1617 This->glRect.left = 0;
1618 }
1619 This->glRect.right = This->glRect.left + maxSize;
1620 if(This->glRect.right > This->currentDesc.Width) {
1621 This->glRect.right = This->currentDesc.Width;
1622 This->glRect.left = This->glRect.right - maxSize;
1623 }
1624 } else {
1625 This->glRect.left = 0;
1626 This->glRect.right = This->pow2Width;
1627 }
1628
1629 if(This->pow2Height > maxSize) {
1630 This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
1631 if(This->glRect.top < 0) This->glRect.top = 0;
1632 This->glRect.bottom = This->glRect.left + maxSize;
1633 if(This->glRect.bottom > This->currentDesc.Height) {
1634 This->glRect.bottom = This->currentDesc.Height;
1635 This->glRect.top = This->glRect.bottom - maxSize;
1636 }
1637 } else {
1638 This->glRect.top = 0;
1639 This->glRect.bottom = This->pow2Height;
1640 }
1641 TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
1642 This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
1643 }
1644
1645 /* Re-calculate the rect to draw */
1646 Rect->left -= This->glRect.left;
1647 Rect->right -= This->glRect.left;
1648 Rect->top -= This->glRect.top;
1649 Rect->bottom -= This->glRect.top;
1650
1651 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
1652 * or the pow2Width / pow2Height of the surface.
1653 *
1654 * Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
1655 * as regular GL_TEXTURE_2D.
1656 */
1657 glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
1658 glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
1659 glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
1660 glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
1661 }
1662 return TRUE;
1663 }
1664 #undef GLINFO_LOCATION
1665
1666 /* Hash table functions */
1667
1668 struct hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function)
1669 {
1670 struct hash_table_t *table;
1671 unsigned int initial_size = 8;
1672
1673 table = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hash_table_t) + (initial_size * sizeof(struct list)));
1674 if (!table)
1675 {
1676 ERR("Failed to allocate table, returning NULL.\n");
1677 return NULL;
1678 }
1679
1680 table->hash_function = hash_function;
1681 table->compare_function = compare_function;
1682
1683 table->grow_size = initial_size - (initial_size >> 2);
1684 table->shrink_size = 0;
1685
1686 table->buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(struct list));
1687 if (!table->buckets)
1688 {
1689 ERR("Failed to allocate table buckets, returning NULL.\n");
1690 HeapFree(GetProcessHeap(), 0, table);
1691 return NULL;
1692 }
1693 table->bucket_count = initial_size;
1694
1695 table->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, table->grow_size * sizeof(struct hash_table_entry_t));
1696 if (!table->entries)
1697 {
1698 ERR("Failed to allocate table entries, returning NULL.\n");
1699 HeapFree(GetProcessHeap(), 0, table->buckets);
1700 HeapFree(GetProcessHeap(), 0, table);
1701 return NULL;
1702 }
1703 table->entry_count = 0;
1704
1705 list_init(&table->free_entries);
1706 table->count = 0;
1707
1708 return table;
1709 }
1710
1711 void hash_table_destroy(struct hash_table_t *table, void (*free_value)(void *value, void *cb), void *cb)
1712 {
1713 unsigned int i = 0;
1714
1715 for (i = 0; i < table->entry_count; ++i)
1716 {
1717 if(free_value) {
1718 free_value(table->entries[i].value, cb);
1719 }
1720 HeapFree(GetProcessHeap(), 0, table->entries[i].key);
1721 }
1722
1723 HeapFree(GetProcessHeap(), 0, table->entries);
1724 HeapFree(GetProcessHeap(), 0, table->buckets);
1725 HeapFree(GetProcessHeap(), 0, table);
1726 }
1727
1728 void hash_table_for_each_entry(struct hash_table_t *table, void (*callback)(void *value, void *context), void *context)
1729 {
1730 unsigned int i = 0;
1731
1732 for (i = 0; i < table->entry_count; ++i)
1733 {
1734 callback(table->entries[i].value, context);
1735 }
1736 }
1737
1738 static inline struct hash_table_entry_t *hash_table_get_by_idx(const struct hash_table_t *table, const void *key,
1739 unsigned int idx)
1740 {
1741 struct hash_table_entry_t *entry;
1742
1743 if (table->buckets[idx].next)
1744 LIST_FOR_EACH_ENTRY(entry, &(table->buckets[idx]), struct hash_table_entry_t, entry)
1745 if (table->compare_function(entry->key, key)) return entry;
1746
1747 return NULL;
1748 }
1749
1750 static BOOL hash_table_resize(struct hash_table_t *table, unsigned int new_bucket_count)
1751 {
1752 unsigned int new_entry_count = 0;
1753 struct hash_table_entry_t *new_entries;
1754 struct list *new_buckets;
1755 unsigned int grow_size = new_bucket_count - (new_bucket_count >> 2);
1756 unsigned int i;
1757
1758 new_buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, new_bucket_count * sizeof(struct list));
1759 if (!new_buckets)
1760 {
1761 ERR("Failed to allocate new buckets, returning FALSE.\n");
1762 return FALSE;
1763 }
1764
1765 new_entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, grow_size * sizeof(struct hash_table_entry_t));
1766 if (!new_entries)
1767 {
1768 ERR("Failed to allocate new entries, returning FALSE.\n");
1769 HeapFree(GetProcessHeap(), 0, new_buckets);
1770 return FALSE;
1771 }
1772
1773 for (i = 0; i < table->bucket_count; ++i)
1774 {
1775 if (table->buckets[i].next)
1776 {
1777 struct hash_table_entry_t *entry, *entry2;
1778
1779 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &table->buckets[i], struct hash_table_entry_t, entry)
1780 {
1781 int j;
1782 struct hash_table_entry_t *new_entry = new_entries + (new_entry_count++);
1783 *new_entry = *entry;
1784
1785 j = new_entry->hash & (new_bucket_count - 1);
1786
1787 if (!new_buckets[j].next) list_init(&new_buckets[j]);
1788 list_add_head(&new_buckets[j], &new_entry->entry);
1789 }
1790 }
1791 }
1792
1793 HeapFree(GetProcessHeap(), 0, table->buckets);
1794 table->buckets = new_buckets;
1795
1796 HeapFree(GetProcessHeap(), 0, table->entries);
1797 table->entries = new_entries;
1798
1799 table->entry_count = new_entry_count;
1800 list_init(&table->free_entries);
1801
1802 table->bucket_count = new_bucket_count;
1803 table->grow_size = grow_size;
1804 table->shrink_size = new_bucket_count > 8 ? new_bucket_count >> 2 : 0;
1805
1806 return TRUE;
1807 }
1808
1809 void hash_table_put(struct hash_table_t *table, void *key, void *value)
1810 {
1811 unsigned int idx;
1812 unsigned int hash;
1813 struct hash_table_entry_t *entry;
1814
1815 hash = table->hash_function(key);
1816 idx = hash & (table->bucket_count - 1);
1817 entry = hash_table_get_by_idx(table, key, idx);
1818
1819 if (entry)
1820 {
1821 HeapFree(GetProcessHeap(), 0, key);
1822 entry->value = value;
1823
1824 if (!value)
1825 {
1826 HeapFree(GetProcessHeap(), 0, entry->key);
1827 entry->key = NULL;
1828
1829 /* Remove the entry */
1830 list_remove(&entry->entry);
1831 list_add_head(&table->free_entries, &entry->entry);
1832
1833 --table->count;
1834
1835 /* Shrink if necessary */
1836 if (table->count < table->shrink_size) {
1837 if (!hash_table_resize(table, table->bucket_count >> 1))
1838 {
1839 ERR("Failed to shrink the table...\n");
1840 }
1841 }
1842 }
1843
1844 return;
1845 }
1846
1847 if (!value) return;
1848
1849 /* Grow if necessary */
1850 if (table->count >= table->grow_size)
1851 {
1852 if (!hash_table_resize(table, table->bucket_count << 1))
1853 {
1854 ERR("Failed to grow the table, returning.\n");
1855 return;
1856 }
1857
1858 idx = hash & (table->bucket_count - 1);
1859 }
1860
1861 /* Find an entry to insert */
1862 if (!list_empty(&table->free_entries))
1863 {
1864 struct list *elem = list_head(&table->free_entries);
1865
1866 list_remove(elem);
1867 entry = LIST_ENTRY(elem, struct hash_table_entry_t, entry);
1868 } else {
1869 entry = table->entries + (table->entry_count++);
1870 }
1871
1872 /* Insert the entry */
1873 entry->key = key;
1874 entry->value = value;
1875 entry->hash = hash;
1876 if (!table->buckets[idx].next) list_init(&table->buckets[idx]);
1877 list_add_head(&table->buckets[idx], &entry->entry);
1878
1879 ++table->count;
1880 }
1881
1882 void hash_table_remove(struct hash_table_t *table, void *key)
1883 {
1884 hash_table_put(table, key, NULL);
1885 }
1886
1887 void *hash_table_get(const struct hash_table_t *table, const void *key)
1888 {
1889 unsigned int idx;
1890 struct hash_table_entry_t *entry;
1891
1892 idx = table->hash_function(key) & (table->bucket_count - 1);
1893 entry = hash_table_get_by_idx(table, key, idx);
1894
1895 return entry ? entry->value : NULL;
1896 }
1897
1898 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
1899 void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_settings *settings, BOOL ignore_textype) {
1900 #define ARG1 0x01
1901 #define ARG2 0x02
1902 #define ARG0 0x04
1903 static const unsigned char args[WINED3DTOP_LERP + 1] = {
1904 /* undefined */ 0,
1905 /* D3DTOP_DISABLE */ 0,
1906 /* D3DTOP_SELECTARG1 */ ARG1,
1907 /* D3DTOP_SELECTARG2 */ ARG2,
1908 /* D3DTOP_MODULATE */ ARG1 | ARG2,
1909 /* D3DTOP_MODULATE2X */ ARG1 | ARG2,
1910 /* D3DTOP_MODULATE4X */ ARG1 | ARG2,
1911 /* D3DTOP_ADD */ ARG1 | ARG2,
1912 /* D3DTOP_ADDSIGNED */ ARG1 | ARG2,
1913 /* D3DTOP_ADDSIGNED2X */ ARG1 | ARG2,
1914 /* D3DTOP_SUBTRACT */ ARG1 | ARG2,
1915 /* D3DTOP_ADDSMOOTH */ ARG1 | ARG2,
1916 /* D3DTOP_BLENDDIFFUSEALPHA */ ARG1 | ARG2,
1917 /* D3DTOP_BLENDTEXTUREALPHA */ ARG1 | ARG2,
1918 /* D3DTOP_BLENDFACTORALPHA */ ARG1 | ARG2,
1919 /* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1 | ARG2,
1920 /* D3DTOP_BLENDCURRENTALPHA */ ARG1 | ARG2,
1921 /* D3DTOP_PREMODULATE */ ARG1 | ARG2,
1922 /* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1 | ARG2,
1923 /* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1 | ARG2,
1924 /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1 | ARG2,
1925 /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1 | ARG2,
1926 /* D3DTOP_BUMPENVMAP */ ARG1 | ARG2,
1927 /* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1 | ARG2,
1928 /* D3DTOP_DOTPRODUCT3 */ ARG1 | ARG2,
1929 /* D3DTOP_MULTIPLYADD */ ARG1 | ARG2 | ARG0,
1930 /* D3DTOP_LERP */ ARG1 | ARG2 | ARG0
1931 };
1932 unsigned int i;
1933 DWORD ttff;
1934 DWORD cop, aop, carg0, carg1, carg2, aarg0, aarg1, aarg2;
1935
1936 for(i = 0; i < GL_LIMITS(texture_stages); i++) {
1937 IWineD3DBaseTextureImpl *texture;
1938 settings->op[i].padding = 0;
1939 if(stateblock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
1940 settings->op[i].cop = WINED3DTOP_DISABLE;
1941 settings->op[i].aop = WINED3DTOP_DISABLE;
1942 settings->op[i].carg0 = settings->op[i].carg1 = settings->op[i].carg2 = ARG_UNUSED;
1943 settings->op[i].aarg0 = settings->op[i].aarg1 = settings->op[i].aarg2 = ARG_UNUSED;
1944 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
1945 settings->op[i].dst = resultreg;
1946 settings->op[i].tex_type = tex_1d;
1947 settings->op[i].projected = proj_none;
1948 i++;
1949 break;
1950 }
1951
1952 texture = (IWineD3DBaseTextureImpl *) stateblock->textures[i];
1953 if(texture) {
1954 settings->op[i].color_fixup = texture->baseTexture.shader_color_fixup;
1955 if(ignore_textype) {
1956 settings->op[i].tex_type = tex_1d;
1957 } else {
1958 switch (IWineD3DBaseTexture_GetTextureDimensions((IWineD3DBaseTexture *)texture)) {
1959 case GL_TEXTURE_1D:
1960 settings->op[i].tex_type = tex_1d;
1961 break;
1962 case GL_TEXTURE_2D:
1963 settings->op[i].tex_type = tex_2d;
1964 break;
1965 case GL_TEXTURE_3D:
1966 settings->op[i].tex_type = tex_3d;
1967 break;
1968 case GL_TEXTURE_CUBE_MAP_ARB:
1969 settings->op[i].tex_type = tex_cube;
1970 break;
1971 case GL_TEXTURE_RECTANGLE_ARB:
1972 settings->op[i].tex_type = tex_rect;
1973 break;
1974 }
1975 }
1976 } else {
1977 settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY;
1978 settings->op[i].tex_type = tex_1d;
1979 }
1980
1981 cop = stateblock->textureState[i][WINED3DTSS_COLOROP];
1982 aop = stateblock->textureState[i][WINED3DTSS_ALPHAOP];
1983
1984 carg1 = (args[cop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_COLORARG1] : ARG_UNUSED;
1985 carg2 = (args[cop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_COLORARG2] : ARG_UNUSED;
1986 carg0 = (args[cop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_COLORARG0] : ARG_UNUSED;
1987
1988 if(is_invalid_op(stateblock->wineD3DDevice, i, cop,
1989 carg1, carg2, carg0)) {
1990 carg0 = ARG_UNUSED;
1991 carg2 = ARG_UNUSED;
1992 carg1 = WINED3DTA_CURRENT;
1993 cop = WINED3DTOP_SELECTARG1;
1994 }
1995
1996 if(cop == WINED3DTOP_DOTPRODUCT3) {
1997 /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
1998 * the color result to the alpha component of the destination
1999 */
2000 aop = cop;
2001 aarg1 = carg1;
2002 aarg2 = carg2;
2003 aarg0 = carg0;
2004 } else {
2005 aarg1 = (args[aop] & ARG1) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG1] : ARG_UNUSED;
2006 aarg2 = (args[aop] & ARG2) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG2] : ARG_UNUSED;
2007 aarg0 = (args[aop] & ARG0) ? stateblock->textureState[i][WINED3DTSS_ALPHAARG0] : ARG_UNUSED;
2008 }
2009
2010 if (i == 0 && stateblock->textures[0] && stateblock->renderState[WINED3DRS_COLORKEYENABLE])
2011 {
2012 UINT texture_dimensions = IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[0]);
2013
2014 if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
2015 {
2016 IWineD3DSurfaceImpl *surf;
2017 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
2018
2019 if (surf->CKeyFlags & WINEDDSD_CKSRCBLT
2020 && getFormatDescEntry(surf->resource.format, NULL, NULL)->alphaMask == 0x00000000)
2021 {
2022 if (aop == WINED3DTOP_DISABLE)
2023 {
2024 aarg1 = WINED3DTA_TEXTURE;
2025 aop = WINED3DTOP_SELECTARG1;
2026 }
2027 else if (aop == WINED3DTOP_SELECTARG1 && aarg1 != WINED3DTA_TEXTURE)
2028 {
2029 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2030 {
2031 aarg2 = WINED3DTA_TEXTURE;
2032 aop = WINED3DTOP_MODULATE;
2033 }
2034 else aarg1 = WINED3DTA_TEXTURE;
2035 }
2036 else if (aop == WINED3DTOP_SELECTARG2 && aarg2 != WINED3DTA_TEXTURE)
2037 {
2038 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2039 {
2040 aarg1 = WINED3DTA_TEXTURE;
2041 aop = WINED3DTOP_MODULATE;
2042 }
2043 else aarg2 = WINED3DTA_TEXTURE;
2044 }
2045 }
2046 }
2047 }
2048
2049 if(is_invalid_op(stateblock->wineD3DDevice, i, aop,
2050 aarg1, aarg2, aarg0)) {
2051 aarg0 = ARG_UNUSED;
2052 aarg2 = ARG_UNUSED;
2053 aarg1 = WINED3DTA_CURRENT;
2054 aop = WINED3DTOP_SELECTARG1;
2055 }
2056
2057 if(carg1 == WINED3DTA_TEXTURE || carg2 == WINED3DTA_TEXTURE || carg0 == WINED3DTA_TEXTURE ||
2058 aarg1 == WINED3DTA_TEXTURE || aarg2 == WINED3DTA_TEXTURE || aarg0 == WINED3DTA_TEXTURE) {
2059 ttff = stateblock->textureState[i][WINED3DTSS_TEXTURETRANSFORMFLAGS];
2060 if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT3)) {
2061 settings->op[i].projected = proj_count3;
2062 } else if(ttff == (WINED3DTTFF_PROJECTED | WINED3DTTFF_COUNT4)) {
2063 settings->op[i].projected = proj_count4;
2064 } else {
2065 settings->op[i].projected = proj_none;
2066 }
2067 } else {
2068 settings->op[i].projected = proj_none;
2069 }
2070
2071 settings->op[i].cop = cop;
2072 settings->op[i].aop = aop;
2073 settings->op[i].carg0 = carg0;
2074 settings->op[i].carg1 = carg1;
2075 settings->op[i].carg2 = carg2;
2076 settings->op[i].aarg0 = aarg0;
2077 settings->op[i].aarg1 = aarg1;
2078 settings->op[i].aarg2 = aarg2;
2079
2080 if(stateblock->textureState[i][WINED3DTSS_RESULTARG] == WINED3DTA_TEMP) {
2081 settings->op[i].dst = tempreg;
2082 } else {
2083 settings->op[i].dst = resultreg;
2084 }
2085 }
2086
2087 /* Clear unsupported stages */
2088 for(; i < MAX_TEXTURES; i++) {
2089 memset(&settings->op[i], 0xff, sizeof(settings->op[i]));
2090 }
2091
2092 if(stateblock->renderState[WINED3DRS_FOGENABLE] == FALSE) {
2093 settings->fog = FOG_OFF;
2094 } else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
2095 if(use_vs(stateblock) || ((IWineD3DVertexDeclarationImpl *) stateblock->vertexDecl)->position_transformed) {
2096 settings->fog = FOG_LINEAR;
2097 } else {
2098 switch(stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
2099 case WINED3DFOG_NONE:
2100 case WINED3DFOG_LINEAR:
2101 settings->fog = FOG_LINEAR;
2102 break;
2103 case WINED3DFOG_EXP:
2104 settings->fog = FOG_EXP;
2105 break;
2106 case WINED3DFOG_EXP2:
2107 settings->fog = FOG_EXP2;
2108 break;
2109 }
2110 }
2111 } else {
2112 switch(stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
2113 case WINED3DFOG_LINEAR:
2114 settings->fog = FOG_LINEAR;
2115 break;
2116 case WINED3DFOG_EXP:
2117 settings->fog = FOG_EXP;
2118 break;
2119 case WINED3DFOG_EXP2:
2120 settings->fog = FOG_EXP2;
2121 break;
2122 }
2123 }
2124 if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
2125 settings->sRGB_write = 1;
2126 } else {
2127 settings->sRGB_write = 0;
2128 }
2129 }
2130 #undef GLINFO_LOCATION
2131
2132 const struct ffp_frag_desc *find_ffp_frag_shader(const struct hash_table_t *fragment_shaders,
2133 const struct ffp_frag_settings *settings)
2134 {
2135 return hash_table_get(fragment_shaders, settings);
2136 }
2137
2138 void add_ffp_frag_shader(struct hash_table_t *shaders, struct ffp_frag_desc *desc) {
2139 struct ffp_frag_settings *key = HeapAlloc(GetProcessHeap(), 0, sizeof(*key));
2140 /* Note that the key is the implementation independent part of the ffp_frag_desc structure,
2141 * whereas desc points to an extended structure with implementation specific parts.
2142 * Make a copy of the key because hash_table_put takes ownership of it
2143 */
2144 *key = desc->settings;
2145 hash_table_put(shaders, key, desc);
2146 }
2147
2148 /* Activates the texture dimension according to the bound D3D texture.
2149 * Does not care for the colorop or correct gl texture unit(when using nvrc)
2150 * Requires the caller to activate the correct unit before
2151 */
2152 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
2153 void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2154 if(stateblock->textures[stage]) {
2155 switch (IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[stage])) {
2156 case GL_TEXTURE_2D:
2157 glDisable(GL_TEXTURE_3D);
2158 checkGLcall("glDisable(GL_TEXTURE_3D)");
2159 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2160 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2161 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2162 }
2163 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2164 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2165 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2166 }
2167 glEnable(GL_TEXTURE_2D);
2168 checkGLcall("glEnable(GL_TEXTURE_2D)");
2169 break;
2170 case GL_TEXTURE_RECTANGLE_ARB:
2171 glDisable(GL_TEXTURE_2D);
2172 checkGLcall("glDisable(GL_TEXTURE_2D)");
2173 glDisable(GL_TEXTURE_3D);
2174 checkGLcall("glDisable(GL_TEXTURE_3D)");
2175 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2176 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2177 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2178 }
2179 glEnable(GL_TEXTURE_RECTANGLE_ARB);
2180 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2181 break;
2182 case GL_TEXTURE_3D:
2183 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2184 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2185 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2186 }
2187 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2188 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2189 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2190 }
2191 glDisable(GL_TEXTURE_2D);
2192 checkGLcall("glDisable(GL_TEXTURE_2D)");
2193 glEnable(GL_TEXTURE_3D);
2194 checkGLcall("glEnable(GL_TEXTURE_3D)");
2195 break;
2196 case GL_TEXTURE_CUBE_MAP_ARB:
2197 glDisable(GL_TEXTURE_2D);
2198 checkGLcall("glDisable(GL_TEXTURE_2D)");
2199 glDisable(GL_TEXTURE_3D);
2200 checkGLcall("glDisable(GL_TEXTURE_3D)");
2201 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2202 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2203 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2204 }
2205 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
2206 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2207 break;
2208 }
2209 } else {
2210 glEnable(GL_TEXTURE_2D);
2211 checkGLcall("glEnable(GL_TEXTURE_2D)");
2212 glDisable(GL_TEXTURE_3D);
2213 checkGLcall("glDisable(GL_TEXTURE_3D)");
2214 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2215 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2216 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2217 }
2218 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2219 glDisable(GL_TEXTURE_RECTANGLE_ARB);
2220 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2221 }
2222 /* Binding textures is done by samplers. A dummy texture will be bound */
2223 }
2224 }
2225
2226 void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2227 DWORD sampler = state - STATE_SAMPLER(0);
2228 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
2229
2230 /* No need to enable / disable anything here for unused samplers. The tex_colorop
2231 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
2232 * will take care of this business
2233 */
2234 if(mapped_stage == -1 || mapped_stage >= GL_LIMITS(textures)) return;
2235 if(sampler >= stateblock->lowest_disabled_stage) return;
2236 if(isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) return;
2237
2238 texture_activate_dimensions(sampler, stateblock, context);
2239 }
2240 #undef GLINFO_LOCATION
2241
2242 unsigned int ffp_frag_program_key_hash(const void *key)
2243 {
2244 const struct ffp_frag_settings *k = key;
2245 unsigned int hash = 0, i;
2246 const DWORD *blob;
2247
2248 /* This takes the texture op settings of stage 0 and 1 into account.
2249 * how exactly depends on the memory laybout of the compiler, but it
2250 * should not matter too much. Stages > 1 are used rarely, so there's
2251 * no need to process them. Even if they're used it is likely that
2252 * the ffp setup has distinct stage 0 and 1 settings.
2253 */
2254 for(i = 0; i < 2; i++) {
2255 blob = (const DWORD *)&k->op[i];
2256 hash ^= blob[0] ^ blob[1];
2257 }
2258
2259 hash += ~(hash << 15);
2260 hash ^= (hash >> 10);
2261 hash += (hash << 3);
2262 hash ^= (hash >> 6);
2263 hash += ~(hash << 11);
2264 hash ^= (hash >> 16);
2265
2266 return hash;
2267 }
2268
2269 BOOL ffp_frag_program_key_compare(const void *keya, const void *keyb)
2270 {
2271 const struct ffp_frag_settings *ka = keya;
2272 const struct ffp_frag_settings *kb = keyb;
2273
2274 return memcmp(ka, kb, sizeof(*ka)) == 0;
2275 }
2276
2277 UINT wined3d_log2i(UINT32 x)
2278 {
2279 static const BYTE l[] =
2280 {
2281 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
2282 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2283 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2284 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2285 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2286 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2287 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2288 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2289 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2290 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2291 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2292 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2293 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2294 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2295 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2296 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2297 };
2298 UINT32 i;
2299
2300 return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
2301 }
useful hacks and other patches not (yet) suitable for mainline