2 * Utility functions for the WineD3D Library
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
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.
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.
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
27 #include "wined3d_private.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
31 /*****************************************************************************
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.
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
},
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
},
61 {WINED3DFMT_CxV8U8
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,0 ,0 ,FALSE
},
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
},
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
},
123 GLint glInternal
, glGammaInternal
, rtInternal
, glFormat
, glType
;
125 } GlPixelFormatDescTemplate
;
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
133 static const GlPixelFormatDescTemplate gl_formats_template
[] = {
134 /*{ internal ,srgbInternal , rtInternal, format ,type \
136 {WINED3DFMT_UNKNOWN
,0 ,0 , 0, 0 ,0
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
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
163 {WINED3DFMT_G8R8_G8B8
,0 ,0 , 0, 0 ,0
165 {WINED3DFMT_R8G8_B8G8
,0 ,0 , 0, 0 ,0
168 {WINED3DFMT_R32F
,GL_RGB32F_ARB
,GL_RGB32F_ARB
, 0, GL_RED
,GL_FLOAT
169 ,WINED3DFMT_FLAG_RENDERTARGET
},
170 {WINED3DFMT_G32R32F
,0 ,0 , 0, 0 ,0
171 ,WINED3DFMT_FLAG_RENDERTARGET
},
172 {WINED3DFMT_A32B32G32R32F
,GL_RGBA32F_ARB
,GL_RGBA32F_ARB
, 0, GL_RGBA
,GL_FLOAT
173 ,WINED3DFMT_FLAG_RENDERTARGET
},
175 {WINED3DFMT_CxV8U8
,0 ,0 , 0, 0 ,0
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
,0 ,0 , 0, 0 ,0
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
187 {WINED3DFMT_P8
, GL_COLOR_INDEX8_EXT
,GL_COLOR_INDEX8_EXT
, 0, GL_COLOR_INDEX
,GL_UNSIGNED_BYTE
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
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
},
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
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
244 {WINED3DFMT_A2W10V10U10
,0 ,0 , 0, 0 ,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
270 {WINED3DFMT_INDEX16
,0 ,0 , 0, 0 ,0
272 {WINED3DFMT_INDEX32
,0 ,0 , 0, 0 ,0
274 {WINED3DFMT_Q16W16V16U16
,GL_COLOR_INDEX
,GL_COLOR_INDEX
, 0, GL_COLOR_INDEX
,GL_UNSIGNED_SHORT
276 /* Vendor-specific formats */
277 {WINED3DFMT_ATI2N
,0 ,0 , 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
279 {WINED3DFMT_NVHU
,0 ,0 , 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
281 {WINED3DFMT_NVHS
,0 ,0 , 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
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
289 if(fmt
< (sizeof(formats
) / sizeof(formats
[0])) && formats
[fmt
].format
== fmt
) {
293 for(i
= 0; i
< (sizeof(formats
) / sizeof(formats
[0])); i
++) {
294 if(formats
[i
].format
== fmt
) {
302 #define GLINFO_LOCATION (*gl_info)
303 BOOL
initPixelFormats(WineD3D_GL_Info
*gl_info
)
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
;
312 /* If a format depends on some extensions, remove them from the table above and initialize them
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
].conversion_group
= WINED3DFMT_UNKNOWN
;
322 gl_info
->gl_formats
[dst
].Flags
= gl_formats_template
[src
].Flags
;
323 gl_info
->gl_formats
[dst
].heightscale
= 1.0;
325 if(wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&&
326 gl_formats_template
[src
].rtInternal
!= 0) {
330 /* Check if the default internal format is supported as a frame buffer target, otherwise
331 * fall back to the render target internal.
333 * Try to stick to the standard format if possible, this limits precision differences
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
);
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));
346 status
= GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT
));
347 GL_EXTCALL(glDeleteFramebuffersEXT(1, &fb
));
348 glDeleteTextures(1, &tex
);
350 checkGLcall("Framebuffer format check");
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
;
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
;
362 gl_info
->gl_formats
[dst
].rtInternal
= gl_formats_template
[src
].glInternal
;
366 /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
367 * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
368 * their extensions are not available.
370 * In theory, V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
371 * returns 0.0 when sampling from it, DirectX 1.0. This is disabled until we find
372 * an application that needs this because it causes performance problems due to
373 * shader recompiling in some games.
375 if(!GL_SUPPORT(NV_TEXTURE_SHADER2
)) {
376 /* signed -> unsigned fixup */
377 dst
= getFmtIdx(WINED3DFMT_V8U8
);
378 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
379 dst
= getFmtIdx(WINED3DFMT_V16U16
);
380 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
382 /* Blue = 1.0 fixup, disabled for now */
384 dst
= getFmtIdx(WINED3DFMT_V8U8
);
385 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
386 dst
= getFmtIdx(WINED3DFMT_V16U16
);
387 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
391 if(!GL_SUPPORT(NV_TEXTURE_SHADER
)) {
392 /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
395 dst
= getFmtIdx(WINED3DFMT_L6V5U5
);
396 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_L6V5U5
;
397 dst
= getFmtIdx(WINED3DFMT_X8L8V8U8
);
398 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_X8L8V8U8
;
399 dst
= getFmtIdx(WINED3DFMT_Q8W8V8U8
);
400 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_Q8W8V8U8
;
402 /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
403 * are converted at surface loading time, but they do not need any modification in
404 * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
405 * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
409 if(GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC
)) {
410 dst
= getFmtIdx(WINED3DFMT_ATI2N
);
411 gl_info
->gl_formats
[dst
].glInternal
= GL_COMPRESSED_RED_GREEN_RGTC2_EXT
;
412 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_COMPRESSED_RED_GREEN_RGTC2_EXT
;
413 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_ATI2N
;
414 } else if(GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC
)) {
415 dst
= getFmtIdx(WINED3DFMT_ATI2N
);
416 gl_info
->gl_formats
[dst
].glInternal
= GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI
;
417 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI
;
418 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_ATI2N
;
421 if(!GL_SUPPORT(APPLE_YCBCR_422
)) {
422 dst
= getFmtIdx(WINED3DFMT_YUY2
);
423 gl_info
->gl_formats
[dst
].glInternal
= GL_LUMINANCE_ALPHA
;
424 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_LUMINANCE_ALPHA
; /* not srgb */
425 gl_info
->gl_formats
[dst
].glFormat
= GL_LUMINANCE_ALPHA
;
426 gl_info
->gl_formats
[dst
].glType
= GL_UNSIGNED_BYTE
;
427 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_YUY2
;
429 dst
= getFmtIdx(WINED3DFMT_UYVY
);
430 gl_info
->gl_formats
[dst
].glInternal
= GL_LUMINANCE_ALPHA
;
431 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_LUMINANCE_ALPHA
; /* not srgb */
432 gl_info
->gl_formats
[dst
].glFormat
= GL_LUMINANCE_ALPHA
;
433 gl_info
->gl_formats
[dst
].glType
= GL_UNSIGNED_BYTE
;
434 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_UYVY
;
437 dst
= getFmtIdx(WINED3DFMT_YV12
);
438 gl_info
->gl_formats
[dst
].heightscale
= 1.5;
439 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_YV12
;
444 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
445 static WINED3DGLTYPE
const glTypeLookupTemplate
[WINED3DDECLTYPE_UNUSED
] = {
446 {WINED3DDECLTYPE_FLOAT1
, 1, GL_FLOAT
, GL_FALSE
,sizeof(float)},
447 {WINED3DDECLTYPE_FLOAT2
, 2, GL_FLOAT
, GL_FALSE
,sizeof(float)},
448 {WINED3DDECLTYPE_FLOAT3
, 3, GL_FLOAT
, GL_FALSE
,sizeof(float)},
449 {WINED3DDECLTYPE_FLOAT4
, 4, GL_FLOAT
, GL_FALSE
,sizeof(float)},
450 {WINED3DDECLTYPE_D3DCOLOR
, 4, GL_UNSIGNED_BYTE
, GL_TRUE
,sizeof(BYTE
)},
451 {WINED3DDECLTYPE_UBYTE4
, 4, GL_UNSIGNED_BYTE
, GL_FALSE
,sizeof(BYTE
)},
452 {WINED3DDECLTYPE_SHORT2
, 2, GL_SHORT
, GL_FALSE
,sizeof(short int)},
453 {WINED3DDECLTYPE_SHORT4
, 4, GL_SHORT
, GL_FALSE
,sizeof(short int)},
454 {WINED3DDECLTYPE_UBYTE4N
, 4, GL_UNSIGNED_BYTE
, GL_TRUE
,sizeof(BYTE
)},
455 {WINED3DDECLTYPE_SHORT2N
, 2, GL_SHORT
, GL_TRUE
,sizeof(short int)},
456 {WINED3DDECLTYPE_SHORT4N
, 4, GL_SHORT
, GL_TRUE
,sizeof(short int)},
457 {WINED3DDECLTYPE_USHORT2N
, 2, GL_UNSIGNED_SHORT
, GL_TRUE
,sizeof(short int)},
458 {WINED3DDECLTYPE_USHORT4N
, 4, GL_UNSIGNED_SHORT
, GL_TRUE
,sizeof(short int)},
459 {WINED3DDECLTYPE_UDEC3
, 3, GL_UNSIGNED_SHORT
, GL_FALSE
,sizeof(short int)},
460 {WINED3DDECLTYPE_DEC3N
, 3, GL_SHORT
, GL_TRUE
,sizeof(short int)},
461 {WINED3DDECLTYPE_FLOAT16_2
, 2, GL_HALF_FLOAT_NV
, GL_FALSE
,sizeof(GLhalfNV
)},
462 {WINED3DDECLTYPE_FLOAT16_4
, 4, GL_HALF_FLOAT_NV
, GL_FALSE
,sizeof(GLhalfNV
)}};
464 void init_type_lookup(WineD3D_GL_Info
*gl_info
) {
465 memcpy(gl_info
->glTypeLookup
, glTypeLookupTemplate
, sizeof(glTypeLookupTemplate
));
466 if(!GL_SUPPORT(NV_HALF_FLOAT
)) {
467 /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
468 * It is the job of the vertex buffer code to make sure that the vbos have the right format
470 gl_info
->glTypeLookup
[WINED3DDECLTYPE_FLOAT16_2
].glType
= GL_FLOAT
;
471 gl_info
->glTypeLookup
[WINED3DDECLTYPE_FLOAT16_4
].glType
= GL_FLOAT
;
475 #undef GLINFO_LOCATION
477 #define GLINFO_LOCATION This->adapter->gl_info
479 const StaticPixelFormatDesc
*getFormatDescEntry(WINED3DFORMAT fmt
, WineD3D_GL_Info
*gl_info
, const GlPixelFormatDesc
**glDesc
)
481 int idx
= getFmtIdx(fmt
);
484 FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt
), fmt
);
485 /* Get the caller a valid pointer */
486 idx
= getFmtIdx(WINED3DFMT_UNKNOWN
);
489 if(!gl_info
->gl_formats
) {
490 /* If we do not have gl format information, provide a dummy NULL format. This is an easy way to make
491 * all gl caps check return "unsupported" than catching the lack of gl all over the code. ANSI C requires
492 * static variables to be initialized to 0.
494 static const GlPixelFormatDesc dummyFmt
;
497 *glDesc
= &gl_info
->gl_formats
[idx
];
500 return &formats
[idx
];
503 /*****************************************************************************
504 * Trace formatting of useful values
506 const char* debug_d3dformat(WINED3DFORMAT fmt
) {
508 #define FMT_TO_STR(fmt) case fmt: return #fmt
509 FMT_TO_STR(WINED3DFMT_UNKNOWN
);
510 FMT_TO_STR(WINED3DFMT_R8G8B8
);
511 FMT_TO_STR(WINED3DFMT_A8R8G8B8
);
512 FMT_TO_STR(WINED3DFMT_X8R8G8B8
);
513 FMT_TO_STR(WINED3DFMT_R5G6B5
);
514 FMT_TO_STR(WINED3DFMT_X1R5G5B5
);
515 FMT_TO_STR(WINED3DFMT_A1R5G5B5
);
516 FMT_TO_STR(WINED3DFMT_A4R4G4B4
);
517 FMT_TO_STR(WINED3DFMT_R3G3B2
);
518 FMT_TO_STR(WINED3DFMT_A8
);
519 FMT_TO_STR(WINED3DFMT_A8R3G3B2
);
520 FMT_TO_STR(WINED3DFMT_X4R4G4B4
);
521 FMT_TO_STR(WINED3DFMT_A2B10G10R10
);
522 FMT_TO_STR(WINED3DFMT_A8B8G8R8
);
523 FMT_TO_STR(WINED3DFMT_X8B8G8R8
);
524 FMT_TO_STR(WINED3DFMT_G16R16
);
525 FMT_TO_STR(WINED3DFMT_A2R10G10B10
);
526 FMT_TO_STR(WINED3DFMT_A16B16G16R16
);
527 FMT_TO_STR(WINED3DFMT_A8P8
);
528 FMT_TO_STR(WINED3DFMT_P8
);
529 FMT_TO_STR(WINED3DFMT_L8
);
530 FMT_TO_STR(WINED3DFMT_A8L8
);
531 FMT_TO_STR(WINED3DFMT_A4L4
);
532 FMT_TO_STR(WINED3DFMT_V8U8
);
533 FMT_TO_STR(WINED3DFMT_L6V5U5
);
534 FMT_TO_STR(WINED3DFMT_X8L8V8U8
);
535 FMT_TO_STR(WINED3DFMT_Q8W8V8U8
);
536 FMT_TO_STR(WINED3DFMT_V16U16
);
537 FMT_TO_STR(WINED3DFMT_W11V11U10
);
538 FMT_TO_STR(WINED3DFMT_A2W10V10U10
);
539 FMT_TO_STR(WINED3DFMT_UYVY
);
540 FMT_TO_STR(WINED3DFMT_YUY2
);
541 FMT_TO_STR(WINED3DFMT_YV12
);
542 FMT_TO_STR(WINED3DFMT_DXT1
);
543 FMT_TO_STR(WINED3DFMT_DXT2
);
544 FMT_TO_STR(WINED3DFMT_DXT3
);
545 FMT_TO_STR(WINED3DFMT_DXT4
);
546 FMT_TO_STR(WINED3DFMT_DXT5
);
547 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8
);
548 FMT_TO_STR(WINED3DFMT_G8R8_G8B8
);
549 FMT_TO_STR(WINED3DFMT_R8G8_B8G8
);
550 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE
);
551 FMT_TO_STR(WINED3DFMT_D32
);
552 FMT_TO_STR(WINED3DFMT_D15S1
);
553 FMT_TO_STR(WINED3DFMT_D24S8
);
554 FMT_TO_STR(WINED3DFMT_D24X8
);
555 FMT_TO_STR(WINED3DFMT_D24X4S4
);
556 FMT_TO_STR(WINED3DFMT_D16
);
557 FMT_TO_STR(WINED3DFMT_L16
);
558 FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE
);
559 FMT_TO_STR(WINED3DFMT_D24FS8
);
560 FMT_TO_STR(WINED3DFMT_VERTEXDATA
);
561 FMT_TO_STR(WINED3DFMT_INDEX16
);
562 FMT_TO_STR(WINED3DFMT_INDEX32
);
563 FMT_TO_STR(WINED3DFMT_Q16W16V16U16
);
564 FMT_TO_STR(WINED3DFMT_R16F
);
565 FMT_TO_STR(WINED3DFMT_G16R16F
);
566 FMT_TO_STR(WINED3DFMT_A16B16G16R16F
);
567 FMT_TO_STR(WINED3DFMT_R32F
);
568 FMT_TO_STR(WINED3DFMT_G32R32F
);
569 FMT_TO_STR(WINED3DFMT_A32B32G32R32F
);
570 FMT_TO_STR(WINED3DFMT_CxV8U8
);
571 FMT_TO_STR(WINED3DFMT_ATI2N
);
572 FMT_TO_STR(WINED3DFMT_NVHU
);
573 FMT_TO_STR(WINED3DFMT_NVHS
);
578 fourcc
[0] = (char)(fmt
);
579 fourcc
[1] = (char)(fmt
>> 8);
580 fourcc
[2] = (char)(fmt
>> 16);
581 fourcc
[3] = (char)(fmt
>> 24);
583 if( isprint(fourcc
[0]) && isprint(fourcc
[1]) && isprint(fourcc
[2]) && isprint(fourcc
[3]) )
584 FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt
, fourcc
);
586 FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt
);
588 return "unrecognized";
592 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype
) {
594 #define DEVTYPE_TO_STR(dev) case dev: return #dev
595 DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL
);
596 DEVTYPE_TO_STR(WINED3DDEVTYPE_REF
);
597 DEVTYPE_TO_STR(WINED3DDEVTYPE_SW
);
598 #undef DEVTYPE_TO_STR
600 FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype
);
601 return "unrecognized";
605 const char* debug_d3dusage(DWORD usage
) {
606 switch (usage
& WINED3DUSAGE_MASK
) {
607 #define WINED3DUSAGE_TO_STR(u) case u: return #u
608 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET
);
609 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL
);
610 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY
);
611 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING
);
612 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP
);
613 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS
);
614 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES
);
615 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES
);
616 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC
);
617 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP
);
618 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP
);
619 #undef WINED3DUSAGE_TO_STR
620 case 0: return "none";
622 FIXME("Unrecognized %u Usage!\n", usage
);
623 return "unrecognized";
627 const char* debug_d3dusagequery(DWORD usagequery
) {
628 switch (usagequery
& WINED3DUSAGE_QUERY_MASK
) {
629 #define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
630 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER
);
631 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP
);
632 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
);
633 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD
);
634 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE
);
635 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE
);
636 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP
);
637 #undef WINED3DUSAGEQUERY_TO_STR
638 case 0: return "none";
640 FIXME("Unrecognized %u Usage Query!\n", usagequery
);
641 return "unrecognized";
645 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method
) {
647 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
648 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT
);
649 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU
);
650 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV
);
651 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV
);
652 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV
);
653 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP
);
654 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED
);
655 #undef WINED3DDECLMETHOD_TO_STR
657 FIXME("Unrecognized %u declaration method!\n", method
);
658 return "unrecognized";
662 const char* debug_d3ddecltype(WINED3DDECLTYPE type
) {
664 #define WINED3DDECLTYPE_TO_STR(u) case u: return #u
665 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT1
);
666 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT2
);
667 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT3
);
668 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT4
);
669 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_D3DCOLOR
);
670 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4
);
671 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2
);
672 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4
);
673 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4N
);
674 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2N
);
675 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4N
);
676 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT2N
);
677 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT4N
);
678 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UDEC3
);
679 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_DEC3N
);
680 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_2
);
681 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_4
);
682 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UNUSED
);
683 #undef WINED3DDECLTYPE_TO_STR
685 FIXME("Unrecognized %u declaration type!\n", type
);
686 return "unrecognized";
690 const char* debug_d3ddeclusage(BYTE usage
) {
692 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
693 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION
);
694 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT
);
695 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES
);
696 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL
);
697 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE
);
698 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD
);
699 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT
);
700 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL
);
701 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR
);
702 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT
);
703 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR
);
704 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG
);
705 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH
);
706 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE
);
707 #undef WINED3DDECLUSAGE_TO_STR
709 FIXME("Unrecognized %u declaration usage!\n", usage
);
710 return "unrecognized";
714 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res
) {
716 #define RES_TO_STR(res) case res: return #res;
717 RES_TO_STR(WINED3DRTYPE_SURFACE
);
718 RES_TO_STR(WINED3DRTYPE_VOLUME
);
719 RES_TO_STR(WINED3DRTYPE_TEXTURE
);
720 RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE
);
721 RES_TO_STR(WINED3DRTYPE_CUBETEXTURE
);
722 RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER
);
723 RES_TO_STR(WINED3DRTYPE_INDEXBUFFER
);
726 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res
);
727 return "unrecognized";
731 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType
) {
732 switch (PrimitiveType
) {
733 #define PRIM_TO_STR(prim) case prim: return #prim;
734 PRIM_TO_STR(WINED3DPT_POINTLIST
);
735 PRIM_TO_STR(WINED3DPT_LINELIST
);
736 PRIM_TO_STR(WINED3DPT_LINESTRIP
);
737 PRIM_TO_STR(WINED3DPT_TRIANGLELIST
);
738 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP
);
739 PRIM_TO_STR(WINED3DPT_TRIANGLEFAN
);
742 FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType
);
743 return "unrecognized";
747 const char* debug_d3drenderstate(DWORD state
) {
749 #define D3DSTATE_TO_STR(u) case u: return #u
750 D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE
);
751 D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS
);
752 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS
);
753 D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE
);
754 D3DSTATE_TO_STR(WINED3DRS_WRAPU
);
755 D3DSTATE_TO_STR(WINED3DRS_WRAPV
);
756 D3DSTATE_TO_STR(WINED3DRS_ZENABLE
);
757 D3DSTATE_TO_STR(WINED3DRS_FILLMODE
);
758 D3DSTATE_TO_STR(WINED3DRS_SHADEMODE
);
759 D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN
);
760 D3DSTATE_TO_STR(WINED3DRS_MONOENABLE
);
761 D3DSTATE_TO_STR(WINED3DRS_ROP2
);
762 D3DSTATE_TO_STR(WINED3DRS_PLANEMASK
);
763 D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE
);
764 D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE
);
765 D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL
);
766 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG
);
767 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN
);
768 D3DSTATE_TO_STR(WINED3DRS_SRCBLEND
);
769 D3DSTATE_TO_STR(WINED3DRS_DESTBLEND
);
770 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND
);
771 D3DSTATE_TO_STR(WINED3DRS_CULLMODE
);
772 D3DSTATE_TO_STR(WINED3DRS_ZFUNC
);
773 D3DSTATE_TO_STR(WINED3DRS_ALPHAREF
);
774 D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC
);
775 D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE
);
776 D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE
);
777 D3DSTATE_TO_STR(WINED3DRS_FOGENABLE
);
778 D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE
);
779 D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE
);
780 D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL
);
781 D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX
);
782 D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA
);
783 D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR
);
784 D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE
);
785 D3DSTATE_TO_STR(WINED3DRS_FOGSTART
);
786 D3DSTATE_TO_STR(WINED3DRS_FOGEND
);
787 D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY
);
788 D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE
);
789 D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS
);
790 D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE
);
791 D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR
);
792 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU
);
793 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV
);
794 D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS
);
795 D3DSTATE_TO_STR(WINED3DRS_ZBIAS
);
796 D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE
);
797 D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY
);
798 D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH
);
799 D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
);
800 D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE
);
801 D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL
);
802 D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL
);
803 D3DSTATE_TO_STR(WINED3DRS_STENCILPASS
);
804 D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC
);
805 D3DSTATE_TO_STR(WINED3DRS_STENCILREF
);
806 D3DSTATE_TO_STR(WINED3DRS_STENCILMASK
);
807 D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK
);
808 D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR
);
809 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00
);
810 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01
);
811 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02
);
812 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03
);
813 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04
);
814 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05
);
815 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06
);
816 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07
);
817 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08
);
818 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09
);
819 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10
);
820 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11
);
821 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12
);
822 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13
);
823 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14
);
824 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15
);
825 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16
);
826 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17
);
827 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18
);
828 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19
);
829 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20
);
830 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21
);
831 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22
);
832 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23
);
833 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24
);
834 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25
);
835 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26
);
836 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27
);
837 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28
);
838 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29
);
839 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30
);
840 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31
);
841 D3DSTATE_TO_STR(WINED3DRS_WRAP0
);
842 D3DSTATE_TO_STR(WINED3DRS_WRAP1
);
843 D3DSTATE_TO_STR(WINED3DRS_WRAP2
);
844 D3DSTATE_TO_STR(WINED3DRS_WRAP3
);
845 D3DSTATE_TO_STR(WINED3DRS_WRAP4
);
846 D3DSTATE_TO_STR(WINED3DRS_WRAP5
);
847 D3DSTATE_TO_STR(WINED3DRS_WRAP6
);
848 D3DSTATE_TO_STR(WINED3DRS_WRAP7
);
849 D3DSTATE_TO_STR(WINED3DRS_CLIPPING
);
850 D3DSTATE_TO_STR(WINED3DRS_LIGHTING
);
851 D3DSTATE_TO_STR(WINED3DRS_EXTENTS
);
852 D3DSTATE_TO_STR(WINED3DRS_AMBIENT
);
853 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE
);
854 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX
);
855 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER
);
856 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS
);
857 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE
);
858 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE
);
859 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE
);
860 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE
);
861 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE
);
862 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND
);
863 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE
);
864 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING
);
865 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE
);
866 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN
);
867 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE
);
868 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE
);
869 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A
);
870 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B
);
871 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C
);
872 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS
);
873 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK
);
874 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE
);
875 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS
);
876 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN
);
877 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX
);
878 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE
);
879 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE
);
880 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR
);
881 D3DSTATE_TO_STR(WINED3DRS_BLENDOP
);
882 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE
);
883 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE
);
884 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE
);
885 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS
);
886 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE
);
887 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL
);
888 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL
);
889 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X
);
890 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y
);
891 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z
);
892 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W
);
893 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION
);
894 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE
);
895 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL
);
896 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL
);
897 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS
);
898 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC
);
899 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1
);
900 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2
);
901 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3
);
902 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR
);
903 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE
);
904 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS
);
905 D3DSTATE_TO_STR(WINED3DRS_WRAP8
);
906 D3DSTATE_TO_STR(WINED3DRS_WRAP9
);
907 D3DSTATE_TO_STR(WINED3DRS_WRAP10
);
908 D3DSTATE_TO_STR(WINED3DRS_WRAP11
);
909 D3DSTATE_TO_STR(WINED3DRS_WRAP12
);
910 D3DSTATE_TO_STR(WINED3DRS_WRAP13
);
911 D3DSTATE_TO_STR(WINED3DRS_WRAP14
);
912 D3DSTATE_TO_STR(WINED3DRS_WRAP15
);
913 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE
);
914 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA
);
915 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA
);
916 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA
);
917 #undef D3DSTATE_TO_STR
919 FIXME("Unrecognized %u render state!\n", state
);
920 return "unrecognized";
924 const char* debug_d3dsamplerstate(DWORD state
) {
926 #define D3DSTATE_TO_STR(u) case u: return #u
927 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR
);
928 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU
);
929 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV
);
930 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW
);
931 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER
);
932 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER
);
933 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER
);
934 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS
);
935 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL
);
936 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY
);
937 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE
);
938 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX
);
939 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET
);
940 #undef D3DSTATE_TO_STR
942 FIXME("Unrecognized %u sampler state!\n", state
);
943 return "unrecognized";
947 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type
) {
948 switch (filter_type
) {
949 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
950 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE
);
951 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT
);
952 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR
);
953 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC
);
954 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC
);
955 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC
);
956 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD
);
957 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD
);
958 #undef D3DTEXTUREFILTERTYPE_TO_STR
960 FIXME("Unrecognied texture filter type 0x%08x\n", filter_type
);
961 return "unrecognized";
965 const char* debug_d3dtexturestate(DWORD state
) {
967 #define D3DSTATE_TO_STR(u) case u: return #u
968 D3DSTATE_TO_STR(WINED3DTSS_COLOROP
);
969 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1
);
970 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2
);
971 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP
);
972 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1
);
973 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2
);
974 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00
);
975 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01
);
976 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10
);
977 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11
);
978 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX
);
979 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE
);
980 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET
);
981 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS
);
982 D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW
);
983 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0
);
984 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0
);
985 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG
);
986 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT
);
987 #undef D3DSTATE_TO_STR
989 /* Note WINED3DTSS are not consecutive, so skip these */
992 FIXME("Unrecognized %u texture state!\n", state
);
993 return "unrecognized";
997 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop
) {
999 #define D3DTOP_TO_STR(u) case u: return #u
1000 D3DTOP_TO_STR(WINED3DTOP_DISABLE
);
1001 D3DTOP_TO_STR(WINED3DTOP_SELECTARG1
);
1002 D3DTOP_TO_STR(WINED3DTOP_SELECTARG2
);
1003 D3DTOP_TO_STR(WINED3DTOP_MODULATE
);
1004 D3DTOP_TO_STR(WINED3DTOP_MODULATE2X
);
1005 D3DTOP_TO_STR(WINED3DTOP_MODULATE4X
);
1006 D3DTOP_TO_STR(WINED3DTOP_ADD
);
1007 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED
);
1008 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X
);
1009 D3DTOP_TO_STR(WINED3DTOP_SUBTRACT
);
1010 D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH
);
1011 D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA
);
1012 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA
);
1013 D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA
);
1014 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM
);
1015 D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA
);
1016 D3DTOP_TO_STR(WINED3DTOP_PREMODULATE
);
1017 D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR
);
1018 D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA
);
1019 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
);
1020 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
);
1021 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP
);
1022 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE
);
1023 D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3
);
1024 D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD
);
1025 D3DTOP_TO_STR(WINED3DTOP_LERP
);
1026 #undef D3DTOP_TO_STR
1028 FIXME("Unrecognized %u WINED3DTOP\n", d3dtop
);
1029 return "unrecognized";
1033 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype
) {
1035 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
1036 TSTYPE_TO_STR(WINED3DTS_VIEW
);
1037 TSTYPE_TO_STR(WINED3DTS_PROJECTION
);
1038 TSTYPE_TO_STR(WINED3DTS_TEXTURE0
);
1039 TSTYPE_TO_STR(WINED3DTS_TEXTURE1
);
1040 TSTYPE_TO_STR(WINED3DTS_TEXTURE2
);
1041 TSTYPE_TO_STR(WINED3DTS_TEXTURE3
);
1042 TSTYPE_TO_STR(WINED3DTS_TEXTURE4
);
1043 TSTYPE_TO_STR(WINED3DTS_TEXTURE5
);
1044 TSTYPE_TO_STR(WINED3DTS_TEXTURE6
);
1045 TSTYPE_TO_STR(WINED3DTS_TEXTURE7
);
1046 TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
1047 #undef TSTYPE_TO_STR
1049 if (tstype
> 256 && tstype
< 512) {
1050 FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype
);
1051 return ("WINED3DTS_WORLDMATRIX > 0");
1053 FIXME("Unrecognized %u WINED3DTS\n", tstype
);
1054 return "unrecognized";
1058 const char* debug_d3dpool(WINED3DPOOL Pool
) {
1060 #define POOL_TO_STR(p) case p: return #p;
1061 POOL_TO_STR(WINED3DPOOL_DEFAULT
);
1062 POOL_TO_STR(WINED3DPOOL_MANAGED
);
1063 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM
);
1064 POOL_TO_STR(WINED3DPOOL_SCRATCH
);
1067 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool
);
1068 return "unrecognized";
1072 const char *debug_fbostatus(GLenum status
) {
1074 #define FBOSTATUS_TO_STR(u) case u: return #u
1075 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT
);
1076 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT
);
1077 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT
);
1078 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
);
1079 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT
);
1080 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT
);
1081 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT
);
1082 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT
);
1083 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT
);
1084 #undef FBOSTATUS_TO_STR
1086 FIXME("Unrecognied FBO status 0x%08x\n", status
);
1087 return "unrecognized";
1091 const char *debug_glerror(GLenum error
) {
1093 #define GLERROR_TO_STR(u) case u: return #u
1094 GLERROR_TO_STR(GL_NO_ERROR
);
1095 GLERROR_TO_STR(GL_INVALID_ENUM
);
1096 GLERROR_TO_STR(GL_INVALID_VALUE
);
1097 GLERROR_TO_STR(GL_INVALID_OPERATION
);
1098 GLERROR_TO_STR(GL_STACK_OVERFLOW
);
1099 GLERROR_TO_STR(GL_STACK_UNDERFLOW
);
1100 GLERROR_TO_STR(GL_OUT_OF_MEMORY
);
1101 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT
);
1102 #undef GLERROR_TO_STR
1104 FIXME("Unrecognied GL error 0x%08x\n", error
);
1105 return "unrecognized";
1109 const char *debug_d3dbasis(WINED3DBASISTYPE basis
) {
1111 case WINED3DBASIS_BEZIER
: return "WINED3DBASIS_BEZIER";
1112 case WINED3DBASIS_BSPLINE
: return "WINED3DBASIS_BSPLINE";
1113 case WINED3DBASIS_INTERPOLATE
: return "WINED3DBASIS_INTERPOLATE";
1114 default: return "unrecognized";
1118 const char *debug_d3ddegree(WINED3DDEGREETYPE degree
) {
1120 case WINED3DDEGREE_LINEAR
: return "WINED3DDEGREE_LINEAR";
1121 case WINED3DDEGREE_QUADRATIC
: return "WINED3DDEGREE_QUADRATIC";
1122 case WINED3DDEGREE_CUBIC
: return "WINED3DDEGREE_CUBIC";
1123 case WINED3DDEGREE_QUINTIC
: return "WINED3DDEGREE_QUINTIC";
1124 default: return "unrecognized";
1128 /*****************************************************************************
1129 * Useful functions mapping GL <-> D3D values
1131 GLenum
StencilOp(DWORD op
) {
1133 case WINED3DSTENCILOP_KEEP
: return GL_KEEP
;
1134 case WINED3DSTENCILOP_ZERO
: return GL_ZERO
;
1135 case WINED3DSTENCILOP_REPLACE
: return GL_REPLACE
;
1136 case WINED3DSTENCILOP_INCRSAT
: return GL_INCR
;
1137 case WINED3DSTENCILOP_DECRSAT
: return GL_DECR
;
1138 case WINED3DSTENCILOP_INVERT
: return GL_INVERT
;
1139 case WINED3DSTENCILOP_INCR
: return GL_INCR_WRAP_EXT
;
1140 case WINED3DSTENCILOP_DECR
: return GL_DECR_WRAP_EXT
;
1142 FIXME("Unrecognized stencil op %d\n", op
);
1147 GLenum
CompareFunc(DWORD func
) {
1148 switch ((WINED3DCMPFUNC
)func
) {
1149 case WINED3DCMP_NEVER
: return GL_NEVER
;
1150 case WINED3DCMP_LESS
: return GL_LESS
;
1151 case WINED3DCMP_EQUAL
: return GL_EQUAL
;
1152 case WINED3DCMP_LESSEQUAL
: return GL_LEQUAL
;
1153 case WINED3DCMP_GREATER
: return GL_GREATER
;
1154 case WINED3DCMP_NOTEQUAL
: return GL_NOTEQUAL
;
1155 case WINED3DCMP_GREATEREQUAL
: return GL_GEQUAL
;
1156 case WINED3DCMP_ALWAYS
: return GL_ALWAYS
;
1158 FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func
);
1163 BOOL
is_invalid_op(IWineD3DDeviceImpl
*This
, int stage
, WINED3DTEXTUREOP op
, DWORD arg1
, DWORD arg2
, DWORD arg3
) {
1164 if (op
== WINED3DTOP_DISABLE
) return FALSE
;
1165 if (This
->stateBlock
->textures
[stage
]) return FALSE
;
1167 if ((arg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1168 && op
!= WINED3DTOP_SELECTARG2
) return TRUE
;
1169 if ((arg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1170 && op
!= WINED3DTOP_SELECTARG1
) return TRUE
;
1171 if ((arg3
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1172 && (op
== WINED3DTOP_MULTIPLYADD
|| op
== WINED3DTOP_LERP
)) return TRUE
;
1177 /* Setup this textures matrix according to the texture flags*/
1178 void set_texture_matrix(const float *smat
, DWORD flags
, BOOL calculatedCoords
, BOOL transformed
, DWORD coordtype
,
1179 BOOL ffp_proj_control
)
1183 glMatrixMode(GL_TEXTURE
);
1184 checkGLcall("glMatrixMode(GL_TEXTURE)");
1186 if (flags
== WINED3DTTFF_DISABLE
|| flags
== WINED3DTTFF_COUNT1
|| transformed
) {
1188 checkGLcall("glLoadIdentity()");
1192 if (flags
== (WINED3DTTFF_COUNT1
|WINED3DTTFF_PROJECTED
)) {
1193 ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
1197 memcpy(mat
, smat
, 16 * sizeof(float));
1199 if (flags
& WINED3DTTFF_PROJECTED
) {
1200 if(!ffp_proj_control
) {
1201 switch (flags
& ~WINED3DTTFF_PROJECTED
) {
1202 case WINED3DTTFF_COUNT2
:
1203 mat
[3] = mat
[1], mat
[7] = mat
[5], mat
[11] = mat
[9], mat
[15] = mat
[13];
1204 mat
[1] = mat
[5] = mat
[9] = mat
[13] = 0;
1206 case WINED3DTTFF_COUNT3
:
1207 mat
[3] = mat
[2], mat
[7] = mat
[6], mat
[11] = mat
[10], mat
[15] = mat
[14];
1208 mat
[2] = mat
[6] = mat
[10] = mat
[14] = 0;
1212 } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1213 if(!calculatedCoords
) {
1215 case WINED3DDECLTYPE_FLOAT1
:
1216 /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
1217 * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
1218 * the input value to the transformation will be 0, so the matrix value is irrelevant
1225 case WINED3DDECLTYPE_FLOAT2
:
1226 /* See above, just 3rd and 4th coord
1233 case WINED3DDECLTYPE_FLOAT3
: /* Opengl defaults match dx defaults */
1234 case WINED3DDECLTYPE_FLOAT4
: /* No defaults apply, all app defined */
1236 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
1237 * into a bad place. The division elimination below will apply to make sure the
1238 * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
1240 case WINED3DDECLTYPE_UNUSED
: /* No texture coords, 0/0/0/1 defaults are passed */
1243 FIXME("Unexpected fixed function texture coord input\n");
1246 if(!ffp_proj_control
) {
1247 switch (flags
& ~WINED3DTTFF_PROJECTED
) {
1248 /* case WINED3DTTFF_COUNT1: Won't ever get here */
1249 case WINED3DTTFF_COUNT2
: mat
[2] = mat
[6] = mat
[10] = mat
[14] = 0;
1250 /* OpenGL divides the first 3 vertex coord by the 4th by default,
1251 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
1252 * the 4th coord evaluates to 1.0 to eliminate that.
1254 * If the fixed function pipeline is used, the 4th value remains unused,
1255 * so there is no danger in doing this. With vertex shaders we have a
1256 * problem. Should an app hit that problem, the code here would have to
1257 * check for pixel shaders, and the shader has to undo the default gl divide.
1259 * A more serious problem occurs if the app passes 4 coordinates in, and the
1260 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
1261 * or a replacement shader
1263 default: mat
[3] = mat
[7] = mat
[11] = 0; mat
[15] = 1;
1269 checkGLcall("glLoadMatrixf(mat)");
1271 #undef GLINFO_LOCATION
1273 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1275 /* This small helper function is used to convert a bitmask into the number of masked bits */
1276 unsigned int count_bits(unsigned int mask
)
1279 for (count
= 0; mask
; ++count
)
1286 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
1287 * The later function requires individual color components. */
1288 BOOL
getColorBits(WINED3DFORMAT fmt
, short *redSize
, short *greenSize
, short *blueSize
, short *alphaSize
, short *totalSize
)
1290 const StaticPixelFormatDesc
*desc
;
1292 TRACE("fmt: %s\n", debug_d3dformat(fmt
));
1295 case WINED3DFMT_X8R8G8B8
:
1296 case WINED3DFMT_R8G8B8
:
1297 case WINED3DFMT_A8R8G8B8
:
1298 case WINED3DFMT_A2R10G10B10
:
1299 case WINED3DFMT_X1R5G5B5
:
1300 case WINED3DFMT_A1R5G5B5
:
1301 case WINED3DFMT_R5G6B5
:
1302 case WINED3DFMT_X4R4G4B4
:
1303 case WINED3DFMT_A4R4G4B4
:
1304 case WINED3DFMT_R3G3B2
:
1305 case WINED3DFMT_A8P8
:
1309 ERR("Unsupported format: %s\n", debug_d3dformat(fmt
));
1313 desc
= getFormatDescEntry(fmt
, NULL
, NULL
);
1316 ERR("Unable to look up format: 0x%x\n", fmt
);
1319 *redSize
= count_bits(desc
->redMask
);
1320 *greenSize
= count_bits(desc
->greenMask
);
1321 *blueSize
= count_bits(desc
->blueMask
);
1322 *alphaSize
= count_bits(desc
->alphaMask
);
1323 *totalSize
= *redSize
+ *greenSize
+ *blueSize
+ *alphaSize
;
1325 TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n", *redSize
, *greenSize
, *blueSize
, *alphaSize
, *totalSize
, debug_d3dformat(fmt
));
1329 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
1330 BOOL
getDepthStencilBits(WINED3DFORMAT fmt
, short *depthSize
, short *stencilSize
)
1332 const StaticPixelFormatDesc
*desc
;
1334 TRACE("fmt: %s\n", debug_d3dformat(fmt
));
1337 case WINED3DFMT_D16_LOCKABLE
:
1338 case WINED3DFMT_D16
:
1339 case WINED3DFMT_D15S1
:
1340 case WINED3DFMT_D24X8
:
1341 case WINED3DFMT_D24X4S4
:
1342 case WINED3DFMT_D24S8
:
1343 case WINED3DFMT_D24FS8
:
1344 case WINED3DFMT_D32
:
1345 case WINED3DFMT_D32F_LOCKABLE
:
1348 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(fmt
));
1352 desc
= getFormatDescEntry(fmt
, NULL
, NULL
);
1355 ERR("Unable to look up format: 0x%x\n", fmt
);
1358 *depthSize
= desc
->depthSize
;
1359 *stencilSize
= desc
->stencilSize
;
1361 TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n", *depthSize
, *stencilSize
, debug_d3dformat(fmt
));
1365 #undef GLINFO_LOCATION
1367 /* DirectDraw stuff */
1368 WINED3DFORMAT
pixelformat_for_depth(DWORD depth
) {
1370 case 8: return WINED3DFMT_P8
;
1371 case 15: return WINED3DFMT_X1R5G5B5
;
1372 case 16: return WINED3DFMT_R5G6B5
;
1373 case 24: return WINED3DFMT_X8R8G8B8
; /* Robots needs 24bit to be X8R8G8B8 */
1374 case 32: return WINED3DFMT_X8R8G8B8
; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return X8R8G8B8 */
1375 default: return WINED3DFMT_UNKNOWN
;
1379 void multiply_matrix(WINED3DMATRIX
*dest
, const WINED3DMATRIX
*src1
, const WINED3DMATRIX
*src2
) {
1382 /* Now do the multiplication 'by hand'.
1383 I know that all this could be optimised, but this will be done later :-) */
1384 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
);
1385 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
);
1386 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
);
1387 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
);
1389 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
);
1390 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
);
1391 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
);
1392 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
);
1394 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
);
1395 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
);
1396 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
);
1397 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
);
1399 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
);
1400 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
);
1401 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
);
1402 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
);
1404 /* And copy the new matrix in the good storage.. */
1405 memcpy(dest
, &temp
, 16 * sizeof(float));
1408 DWORD
get_flexible_vertex_size(DWORD d3dvtVertexType
) {
1411 int numTextures
= (d3dvtVertexType
& WINED3DFVF_TEXCOUNT_MASK
) >> WINED3DFVF_TEXCOUNT_SHIFT
;
1413 if (d3dvtVertexType
& WINED3DFVF_NORMAL
) size
+= 3 * sizeof(float);
1414 if (d3dvtVertexType
& WINED3DFVF_DIFFUSE
) size
+= sizeof(DWORD
);
1415 if (d3dvtVertexType
& WINED3DFVF_SPECULAR
) size
+= sizeof(DWORD
);
1416 if (d3dvtVertexType
& WINED3DFVF_PSIZE
) size
+= sizeof(DWORD
);
1417 switch (d3dvtVertexType
& WINED3DFVF_POSITION_MASK
) {
1418 case WINED3DFVF_XYZ
: size
+= 3 * sizeof(float); break;
1419 case WINED3DFVF_XYZRHW
: size
+= 4 * sizeof(float); break;
1420 case WINED3DFVF_XYZB1
: size
+= 4 * sizeof(float); break;
1421 case WINED3DFVF_XYZB2
: size
+= 5 * sizeof(float); break;
1422 case WINED3DFVF_XYZB3
: size
+= 6 * sizeof(float); break;
1423 case WINED3DFVF_XYZB4
: size
+= 7 * sizeof(float); break;
1424 case WINED3DFVF_XYZB5
: size
+= 8 * sizeof(float); break;
1425 default: ERR("Unexpected position mask\n");
1427 for (i
= 0; i
< numTextures
; i
++) {
1428 size
+= GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType
, i
) * sizeof(float);
1434 /***********************************************************************
1437 * Calculates the dimensions of the opengl texture used for blits.
1438 * Handled oversized opengl textures and updates the source rectangle
1442 * This: Surface to operate on
1443 * Rect: Requested rectangle
1446 * TRUE if the texture part can be loaded,
1449 *********************************************************************/
1450 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
1452 BOOL
CalculateTexRect(IWineD3DSurfaceImpl
*This
, RECT
*Rect
, float glTexCoord
[4]) {
1453 int x1
= Rect
->left
, x2
= Rect
->right
;
1454 int y1
= Rect
->top
, y2
= Rect
->bottom
;
1455 GLint maxSize
= GL_LIMITS(texture_size
);
1457 TRACE("(%p)->(%d,%d)-(%d,%d)\n", This
,
1458 Rect
->left
, Rect
->top
, Rect
->right
, Rect
->bottom
);
1460 /* The sizes might be reversed */
1461 if(Rect
->left
> Rect
->right
) {
1465 if(Rect
->top
> Rect
->bottom
) {
1470 /* No oversized texture? This is easy */
1471 if(!(This
->Flags
& SFLAG_OVERSIZE
)) {
1472 /* Which rect from the texture do I need? */
1473 if(This
->glDescription
.target
== GL_TEXTURE_RECTANGLE_ARB
) {
1474 glTexCoord
[0] = (float) Rect
->left
;
1475 glTexCoord
[2] = (float) Rect
->top
;
1476 glTexCoord
[1] = (float) Rect
->right
;
1477 glTexCoord
[3] = (float) Rect
->bottom
;
1479 glTexCoord
[0] = (float) Rect
->left
/ (float) This
->pow2Width
;
1480 glTexCoord
[2] = (float) Rect
->top
/ (float) This
->pow2Height
;
1481 glTexCoord
[1] = (float) Rect
->right
/ (float) This
->pow2Width
;
1482 glTexCoord
[3] = (float) Rect
->bottom
/ (float) This
->pow2Height
;
1487 /* Check if we can succeed at all */
1488 if( (x2
- x1
) > maxSize
||
1489 (y2
- y1
) > maxSize
) {
1490 TRACE("Requested rectangle is too large for gl\n");
1494 /* A part of the texture has to be picked. First, check if
1495 * some texture part is loaded already, if yes try to re-use it.
1496 * If the texture is dirty, or the part can't be used,
1497 * re-position the part to load
1499 if(This
->Flags
& SFLAG_INTEXTURE
) {
1500 if(This
->glRect
.left
<= x1
&& This
->glRect
.right
>= x2
&&
1501 This
->glRect
.top
<= y1
&& This
->glRect
.bottom
>= x2
) {
1502 /* Ok, the rectangle is ok, re-use it */
1503 TRACE("Using existing gl Texture\n");
1505 /* Rectangle is not ok, dirtify the texture to reload it */
1506 TRACE("Dirtifying texture to force reload\n");
1507 This
->Flags
&= ~SFLAG_INTEXTURE
;
1511 /* Now if we are dirty(no else if!) */
1512 if(!(This
->Flags
& SFLAG_INTEXTURE
)) {
1513 /* Set the new rectangle. Use the following strategy:
1514 * 1) Use as big textures as possible.
1515 * 2) Place the texture part in the way that the requested
1516 * part is in the middle of the texture(well, almost)
1517 * 3) If the texture is moved over the edges of the
1518 * surface, replace it nicely
1519 * 4) If the coord is not limiting the texture size,
1520 * use the whole size
1522 if((This
->pow2Width
) > maxSize
) {
1523 This
->glRect
.left
= x1
- maxSize
/ 2;
1524 if(This
->glRect
.left
< 0) {
1525 This
->glRect
.left
= 0;
1527 This
->glRect
.right
= This
->glRect
.left
+ maxSize
;
1528 if(This
->glRect
.right
> This
->currentDesc
.Width
) {
1529 This
->glRect
.right
= This
->currentDesc
.Width
;
1530 This
->glRect
.left
= This
->glRect
.right
- maxSize
;
1533 This
->glRect
.left
= 0;
1534 This
->glRect
.right
= This
->pow2Width
;
1537 if(This
->pow2Height
> maxSize
) {
1538 This
->glRect
.top
= x1
- GL_LIMITS(texture_size
) / 2;
1539 if(This
->glRect
.top
< 0) This
->glRect
.top
= 0;
1540 This
->glRect
.bottom
= This
->glRect
.left
+ maxSize
;
1541 if(This
->glRect
.bottom
> This
->currentDesc
.Height
) {
1542 This
->glRect
.bottom
= This
->currentDesc
.Height
;
1543 This
->glRect
.top
= This
->glRect
.bottom
- maxSize
;
1546 This
->glRect
.top
= 0;
1547 This
->glRect
.bottom
= This
->pow2Height
;
1549 TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This
,
1550 This
->glRect
.left
, This
->glRect
.top
, This
->glRect
.right
, This
->glRect
.bottom
);
1553 /* Re-calculate the rect to draw */
1554 Rect
->left
-= This
->glRect
.left
;
1555 Rect
->right
-= This
->glRect
.left
;
1556 Rect
->top
-= This
->glRect
.top
;
1557 Rect
->bottom
-= This
->glRect
.top
;
1559 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
1560 * or the pow2Width / pow2Height of the surface.
1562 * Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
1563 * as regular GL_TEXTURE_2D.
1565 glTexCoord
[0] = (float) Rect
->left
/ (float) (This
->glRect
.right
- This
->glRect
.left
);
1566 glTexCoord
[2] = (float) Rect
->top
/ (float) (This
->glRect
.bottom
- This
->glRect
.top
);
1567 glTexCoord
[1] = (float) Rect
->right
/ (float) (This
->glRect
.right
- This
->glRect
.left
);
1568 glTexCoord
[3] = (float) Rect
->bottom
/ (float) (This
->glRect
.bottom
- This
->glRect
.top
);
1572 #undef GLINFO_LOCATION
1574 /* Hash table functions */
1576 struct hash_table_t
*hash_table_create(hash_function_t
*hash_function
, compare_function_t
*compare_function
)
1578 struct hash_table_t
*table
;
1579 unsigned int initial_size
= 8;
1581 table
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct hash_table_t
) + (initial_size
* sizeof(struct list
)));
1584 ERR("Failed to allocate table, returning NULL.\n");
1588 table
->hash_function
= hash_function
;
1589 table
->compare_function
= compare_function
;
1591 table
->grow_size
= initial_size
- (initial_size
>> 2);
1592 table
->shrink_size
= 0;
1594 table
->buckets
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, initial_size
* sizeof(struct list
));
1595 if (!table
->buckets
)
1597 ERR("Failed to allocate table buckets, returning NULL.\n");
1598 HeapFree(GetProcessHeap(), 0, table
);
1601 table
->bucket_count
= initial_size
;
1603 table
->entries
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, table
->grow_size
* sizeof(struct hash_table_entry_t
));
1604 if (!table
->entries
)
1606 ERR("Failed to allocate table entries, returning NULL.\n");
1607 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1608 HeapFree(GetProcessHeap(), 0, table
);
1611 table
->entry_count
= 0;
1613 list_init(&table
->free_entries
);
1619 void hash_table_destroy(struct hash_table_t
*table
, void (*free_value
)(void *value
, void *cb
), void *cb
)
1623 for (i
= 0; i
< table
->entry_count
; ++i
)
1626 free_value(table
->entries
[i
].value
, cb
);
1628 HeapFree(GetProcessHeap(), 0, table
->entries
[i
].key
);
1631 HeapFree(GetProcessHeap(), 0, table
->entries
);
1632 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1633 HeapFree(GetProcessHeap(), 0, table
);
1636 static inline struct hash_table_entry_t
*hash_table_get_by_idx(struct hash_table_t
*table
, void *key
, unsigned int idx
)
1638 struct hash_table_entry_t
*entry
;
1640 if (table
->buckets
[idx
].next
)
1641 LIST_FOR_EACH_ENTRY(entry
, &(table
->buckets
[idx
]), struct hash_table_entry_t
, entry
)
1642 if (table
->compare_function(entry
->key
, key
)) return entry
;
1647 static BOOL
hash_table_resize(struct hash_table_t
*table
, unsigned int new_bucket_count
)
1649 unsigned int new_entry_count
= 0;
1650 struct hash_table_entry_t
*new_entries
;
1651 struct list
*new_buckets
;
1652 unsigned int grow_size
= new_bucket_count
- (new_bucket_count
>> 2);
1655 new_buckets
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, new_bucket_count
* sizeof(struct list
));
1658 ERR("Failed to allocate new buckets, returning FALSE.\n");
1662 new_entries
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, grow_size
* sizeof(struct hash_table_entry_t
));
1665 ERR("Failed to allocate new entries, returning FALSE.\n");
1666 HeapFree(GetProcessHeap(), 0, new_buckets
);
1670 for (i
= 0; i
< table
->bucket_count
; ++i
)
1672 if (table
->buckets
[i
].next
)
1674 struct hash_table_entry_t
*entry
, *entry2
;
1676 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &table
->buckets
[i
], struct hash_table_entry_t
, entry
)
1679 struct hash_table_entry_t
*new_entry
= new_entries
+ (new_entry_count
++);
1680 *new_entry
= *entry
;
1682 j
= new_entry
->hash
& (new_bucket_count
- 1);
1684 if (!new_buckets
[j
].next
) list_init(&new_buckets
[j
]);
1685 list_add_head(&new_buckets
[j
], &new_entry
->entry
);
1690 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1691 table
->buckets
= new_buckets
;
1693 HeapFree(GetProcessHeap(), 0, table
->entries
);
1694 table
->entries
= new_entries
;
1696 table
->entry_count
= new_entry_count
;
1697 list_init(&table
->free_entries
);
1699 table
->bucket_count
= new_bucket_count
;
1700 table
->grow_size
= grow_size
;
1701 table
->shrink_size
= new_bucket_count
> 8 ? new_bucket_count
>> 2 : 0;
1706 void hash_table_put(struct hash_table_t
*table
, void *key
, void *value
)
1710 struct hash_table_entry_t
*entry
;
1712 hash
= table
->hash_function(key
);
1713 idx
= hash
& (table
->bucket_count
- 1);
1714 entry
= hash_table_get_by_idx(table
, key
, idx
);
1718 HeapFree(GetProcessHeap(), 0, key
);
1719 entry
->value
= value
;
1723 HeapFree(GetProcessHeap(), 0, entry
->key
);
1726 /* Remove the entry */
1727 list_remove(&entry
->entry
);
1728 list_add_head(&table
->free_entries
, &entry
->entry
);
1732 /* Shrink if necessary */
1733 if (table
->count
< table
->shrink_size
) {
1734 if (!hash_table_resize(table
, table
->bucket_count
>> 1))
1736 ERR("Failed to shrink the table...\n");
1746 /* Grow if necessary */
1747 if (table
->count
>= table
->grow_size
)
1749 if (!hash_table_resize(table
, table
->bucket_count
<< 1))
1751 ERR("Failed to grow the table, returning.\n");
1755 idx
= hash
& (table
->bucket_count
- 1);
1758 /* Find an entry to insert */
1759 if (!list_empty(&table
->free_entries
))
1761 struct list
*elem
= list_head(&table
->free_entries
);
1764 entry
= LIST_ENTRY(elem
, struct hash_table_entry_t
, entry
);
1766 entry
= table
->entries
+ (table
->entry_count
++);
1769 /* Insert the entry */
1771 entry
->value
= value
;
1773 if (!table
->buckets
[idx
].next
) list_init(&table
->buckets
[idx
]);
1774 list_add_head(&table
->buckets
[idx
], &entry
->entry
);
1779 void hash_table_remove(struct hash_table_t
*table
, void *key
)
1781 hash_table_put(table
, key
, NULL
);
1784 void *hash_table_get(struct hash_table_t
*table
, void *key
)
1787 struct hash_table_entry_t
*entry
;
1789 idx
= table
->hash_function(key
) & (table
->bucket_count
- 1);
1790 entry
= hash_table_get_by_idx(table
, key
, idx
);
1792 return entry
? entry
->value
: NULL
;
1795 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
1796 void gen_ffp_op(IWineD3DStateBlockImpl
*stateblock
, struct ffp_settings
*settings
, BOOL ignore_textype
) {
1800 static const unsigned char args
[WINED3DTOP_LERP
+ 1] = {
1802 /* D3DTOP_DISABLE */ 0,
1803 /* D3DTOP_SELECTARG1 */ ARG1
,
1804 /* D3DTOP_SELECTARG2 */ ARG2
,
1805 /* D3DTOP_MODULATE */ ARG1
| ARG2
,
1806 /* D3DTOP_MODULATE2X */ ARG1
| ARG2
,
1807 /* D3DTOP_MODULATE4X */ ARG1
| ARG2
,
1808 /* D3DTOP_ADD */ ARG1
| ARG2
,
1809 /* D3DTOP_ADDSIGNED */ ARG1
| ARG2
,
1810 /* D3DTOP_ADDSIGNED2X */ ARG1
| ARG2
,
1811 /* D3DTOP_SUBTRACT */ ARG1
| ARG2
,
1812 /* D3DTOP_ADDSMOOTH */ ARG1
| ARG2
,
1813 /* D3DTOP_BLENDDIFFUSEALPHA */ ARG1
| ARG2
,
1814 /* D3DTOP_BLENDTEXTUREALPHA */ ARG1
| ARG2
,
1815 /* D3DTOP_BLENDFACTORALPHA */ ARG1
| ARG2
,
1816 /* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1
| ARG2
,
1817 /* D3DTOP_BLENDCURRENTALPHA */ ARG1
| ARG2
,
1818 /* D3DTOP_PREMODULATE */ ARG1
| ARG2
,
1819 /* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1
| ARG2
,
1820 /* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1
| ARG2
,
1821 /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1
| ARG2
,
1822 /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1
| ARG2
,
1823 /* D3DTOP_BUMPENVMAP */ ARG1
| ARG2
,
1824 /* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1
| ARG2
,
1825 /* D3DTOP_DOTPRODUCT3 */ ARG1
| ARG2
,
1826 /* D3DTOP_MULTIPLYADD */ ARG1
| ARG2
| ARG0
,
1827 /* D3DTOP_LERP */ ARG1
| ARG2
| ARG0
1831 DWORD cop
, aop
, carg0
, carg1
, carg2
, aarg0
, aarg1
, aarg2
;
1833 for(i
= 0; i
< GL_LIMITS(texture_stages
); i
++) {
1834 IWineD3DBaseTextureImpl
*texture
;
1835 settings
->op
[i
].padding
= 0;
1836 if(stateblock
->textureState
[i
][WINED3DTSS_COLOROP
] == WINED3DTOP_DISABLE
) {
1837 settings
->op
[i
].cop
= WINED3DTOP_DISABLE
;
1838 settings
->op
[i
].aop
= WINED3DTOP_DISABLE
;
1839 settings
->op
[i
].carg0
= settings
->op
[i
].carg1
= settings
->op
[i
].carg2
= ARG_UNUSED
;
1840 settings
->op
[i
].aarg0
= settings
->op
[i
].aarg1
= settings
->op
[i
].aarg2
= ARG_UNUSED
;
1841 settings
->op
[i
].color_correction
= WINED3DFMT_UNKNOWN
;
1842 settings
->op
[i
].dst
= resultreg
;
1843 settings
->op
[i
].tex_type
= tex_1d
;
1844 settings
->op
[i
].projected
= proj_none
;
1849 texture
= (IWineD3DBaseTextureImpl
*) stateblock
->textures
[i
];
1851 settings
->op
[i
].color_correction
= texture
->baseTexture
.shader_conversion_group
;
1852 if(ignore_textype
) {
1853 settings
->op
[i
].tex_type
= tex_1d
;
1855 switch(stateblock
->textureDimensions
[i
]) {
1857 settings
->op
[i
].tex_type
= tex_1d
;
1860 settings
->op
[i
].tex_type
= tex_2d
;
1863 settings
->op
[i
].tex_type
= tex_3d
;
1865 case GL_TEXTURE_CUBE_MAP_ARB
:
1866 settings
->op
[i
].tex_type
= tex_cube
;
1868 case GL_TEXTURE_RECTANGLE_ARB
:
1869 settings
->op
[i
].tex_type
= tex_rect
;
1874 settings
->op
[i
].color_correction
= WINED3DFMT_UNKNOWN
;
1875 settings
->op
[i
].tex_type
= tex_1d
;
1878 cop
= stateblock
->textureState
[i
][WINED3DTSS_COLOROP
];
1879 aop
= stateblock
->textureState
[i
][WINED3DTSS_ALPHAOP
];
1881 carg1
= (args
[cop
] & ARG1
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG1
] : 0xffffffff;
1882 carg2
= (args
[cop
] & ARG2
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG2
] : 0xffffffff;
1883 carg0
= (args
[cop
] & ARG0
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG0
] : 0xffffffff;
1885 if(is_invalid_op(stateblock
->wineD3DDevice
, i
, cop
,
1886 carg1
, carg2
, carg0
)) {
1889 carg1
= WINED3DTA_CURRENT
;
1890 cop
= WINED3DTOP_SELECTARG1
;
1893 if(cop
== WINED3DTOP_DOTPRODUCT3
) {
1894 /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
1895 * the color result to the alpha component of the destination
1902 aarg1
= (args
[aop
] & ARG1
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG1
] : 0xffffffff;
1903 aarg2
= (args
[aop
] & ARG2
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG2
] : 0xffffffff;
1904 aarg0
= (args
[aop
] & ARG0
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG0
] : 0xffffffff;
1907 if(i
== 0 && stateblock
->textures
[0] &&
1908 stateblock
->renderState
[WINED3DRS_COLORKEYENABLE
] &&
1909 (stateblock
->textureDimensions
[0] == GL_TEXTURE_2D
||
1910 stateblock
->textureDimensions
[0] == GL_TEXTURE_RECTANGLE_ARB
)) {
1911 IWineD3DSurfaceImpl
*surf
= (IWineD3DSurfaceImpl
*) ((IWineD3DTextureImpl
*) stateblock
->textures
[0])->surfaces
[0];
1913 if(surf
->CKeyFlags
& WINEDDSD_CKSRCBLT
&&
1914 getFormatDescEntry(surf
->resource
.format
, NULL
, NULL
)->alphaMask
== 0x00000000) {
1916 if(aop
== WINED3DTOP_DISABLE
) {
1917 aarg1
= WINED3DTA_TEXTURE
;
1918 aop
= WINED3DTOP_SELECTARG1
;
1920 else if(aop
== WINED3DTOP_SELECTARG1
&& aarg1
!= WINED3DTA_TEXTURE
) {
1921 if (stateblock
->renderState
[WINED3DRS_ALPHABLENDENABLE
]) {
1922 aarg2
= WINED3DTA_TEXTURE
;
1923 aop
= WINED3DTOP_MODULATE
;
1925 else aarg1
= WINED3DTA_TEXTURE
;
1927 else if(aop
== WINED3DTOP_SELECTARG2
&& aarg2
!= WINED3DTA_TEXTURE
) {
1928 if (stateblock
->renderState
[WINED3DRS_ALPHABLENDENABLE
]) {
1929 aarg1
= WINED3DTA_TEXTURE
;
1930 aop
= WINED3DTOP_MODULATE
;
1932 else aarg2
= WINED3DTA_TEXTURE
;
1937 if(is_invalid_op(stateblock
->wineD3DDevice
, i
, aop
,
1938 aarg1
, aarg2
, aarg0
)) {
1941 aarg1
= WINED3DTA_CURRENT
;
1942 aop
= WINED3DTOP_SELECTARG1
;
1945 if(carg1
== WINED3DTA_TEXTURE
|| carg2
== WINED3DTA_TEXTURE
|| carg0
== WINED3DTA_TEXTURE
||
1946 aarg1
== WINED3DTA_TEXTURE
|| aarg2
== WINED3DTA_TEXTURE
|| aarg0
== WINED3DTA_TEXTURE
) {
1947 ttff
= stateblock
->textureState
[i
][WINED3DTSS_TEXTURETRANSFORMFLAGS
];
1948 if(ttff
== (WINED3DTTFF_PROJECTED
| WINED3DTTFF_COUNT3
)) {
1949 settings
->op
[i
].projected
= proj_count3
;
1950 } else if(ttff
== (WINED3DTTFF_PROJECTED
| WINED3DTTFF_COUNT4
)) {
1951 settings
->op
[i
].projected
= proj_count4
;
1953 settings
->op
[i
].projected
= proj_none
;
1956 settings
->op
[i
].projected
= proj_none
;
1959 settings
->op
[i
].cop
= cop
;
1960 settings
->op
[i
].aop
= aop
;
1961 settings
->op
[i
].carg0
= carg0
;
1962 settings
->op
[i
].carg1
= carg1
;
1963 settings
->op
[i
].carg2
= carg2
;
1964 settings
->op
[i
].aarg0
= aarg0
;
1965 settings
->op
[i
].aarg1
= aarg1
;
1966 settings
->op
[i
].aarg2
= aarg2
;
1968 if(stateblock
->textureState
[i
][WINED3DTSS_RESULTARG
] == WINED3DTA_TEMP
) {
1969 settings
->op
[i
].dst
= tempreg
;
1971 settings
->op
[i
].dst
= resultreg
;
1975 /* Clear unsupported stages */
1976 for(; i
< MAX_TEXTURES
; i
++) {
1977 memset(&settings
->op
[i
], 0xff, sizeof(settings
->op
[i
]));
1980 if(stateblock
->renderState
[WINED3DRS_FOGENABLE
] == FALSE
) {
1981 settings
->fog
= FOG_OFF
;
1982 } else if(stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
] == WINED3DFOG_NONE
) {
1983 switch(stateblock
->renderState
[WINED3DRS_FOGVERTEXMODE
]) {
1984 case WINED3DFOG_NONE
:
1985 case WINED3DFOG_LINEAR
:
1986 settings
->fog
= FOG_LINEAR
;
1988 case WINED3DFOG_EXP
:
1989 settings
->fog
= FOG_EXP
;
1991 case WINED3DFOG_EXP2
:
1992 settings
->fog
= FOG_EXP2
;
1996 switch(stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
]) {
1997 case WINED3DFOG_LINEAR
:
1998 settings
->fog
= FOG_LINEAR
;
2000 case WINED3DFOG_EXP
:
2001 settings
->fog
= FOG_EXP
;
2003 case WINED3DFOG_EXP2
:
2004 settings
->fog
= FOG_EXP2
;
2008 if(stateblock
->renderState
[WINED3DRS_SRGBWRITEENABLE
]) {
2009 settings
->sRGB_write
= 1;
2011 settings
->sRGB_write
= 0;
2014 #undef GLINFO_LOCATION
2016 struct ffp_desc
*find_ffp_shader(struct hash_table_t
*fragment_shaders
, struct ffp_settings
*settings
)
2018 return (struct ffp_desc
*)hash_table_get(fragment_shaders
, settings
);}
2020 void add_ffp_shader(struct hash_table_t
*shaders
, struct ffp_desc
*desc
) {
2021 struct ffp_settings
*key
= HeapAlloc(GetProcessHeap(), 0, sizeof(*key
));
2022 /* Note that the key is the implementation independent part of the ffp_desc structure,
2023 * whereas desc points to an extended structure with implementation specific parts.
2024 * Make a copy of the key because hash_table_put takes ownership of it
2026 *key
= desc
->settings
;
2027 hash_table_put(shaders
, key
, desc
);
2030 /* Activates the texture dimension according to the bound D3D texture.
2031 * Does not care for the colorop or correct gl texture unit(when using nvrc)
2032 * Requires the caller to activate the correct unit before
2034 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
2035 void texture_activate_dimensions(DWORD stage
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
2036 if(stateblock
->textures
[stage
]) {
2037 switch(stateblock
->textureDimensions
[stage
]) {
2039 glDisable(GL_TEXTURE_3D
);
2040 checkGLcall("glDisable(GL_TEXTURE_3D)");
2041 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2042 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2043 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2045 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2046 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2047 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2049 glEnable(GL_TEXTURE_2D
);
2050 checkGLcall("glEnable(GL_TEXTURE_2D)");
2052 case GL_TEXTURE_RECTANGLE_ARB
:
2053 glDisable(GL_TEXTURE_2D
);
2054 checkGLcall("glDisable(GL_TEXTURE_2D)");
2055 glDisable(GL_TEXTURE_3D
);
2056 checkGLcall("glDisable(GL_TEXTURE_3D)");
2057 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2058 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2059 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2061 glEnable(GL_TEXTURE_RECTANGLE_ARB
);
2062 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2065 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2066 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2067 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2069 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2070 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2071 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2073 glDisable(GL_TEXTURE_2D
);
2074 checkGLcall("glDisable(GL_TEXTURE_2D)");
2075 glEnable(GL_TEXTURE_3D
);
2076 checkGLcall("glEnable(GL_TEXTURE_3D)");
2078 case GL_TEXTURE_CUBE_MAP_ARB
:
2079 glDisable(GL_TEXTURE_2D
);
2080 checkGLcall("glDisable(GL_TEXTURE_2D)");
2081 glDisable(GL_TEXTURE_3D
);
2082 checkGLcall("glDisable(GL_TEXTURE_3D)");
2083 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2084 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2085 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2087 glEnable(GL_TEXTURE_CUBE_MAP_ARB
);
2088 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2092 glEnable(GL_TEXTURE_2D
);
2093 checkGLcall("glEnable(GL_TEXTURE_2D)");
2094 glDisable(GL_TEXTURE_3D
);
2095 checkGLcall("glDisable(GL_TEXTURE_3D)");
2096 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2097 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2098 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2100 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2101 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2102 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2104 /* Binding textures is done by samplers. A dummy texture will be bound */
2108 void sampler_texdim(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
2109 DWORD sampler
= state
- STATE_SAMPLER(0);
2110 DWORD mapped_stage
= stateblock
->wineD3DDevice
->texUnitMap
[sampler
];
2112 /* No need to enable / disable anything here for unused samplers. The tex_colorop
2113 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
2114 * will take care of this business
2116 if(mapped_stage
== -1 || mapped_stage
>= GL_LIMITS(textures
)) return;
2117 if(sampler
>= stateblock
->lowest_disabled_stage
) return;
2118 if(isStateDirty(context
, STATE_TEXTURESTAGE(sampler
, WINED3DTSS_COLOROP
))) return;
2120 texture_activate_dimensions(sampler
, stateblock
, context
);
2122 #undef GLINFO_LOCATION
2124 unsigned int ffp_program_key_hash(void *key
) {
2125 struct ffp_settings
*k
= (struct ffp_settings
*)key
;
2126 unsigned int hash
= 0, i
;
2129 /* This takes the texture op settings of stage 0 and 1 into account.
2130 * how exactly depends on the memory laybout of the compiler, but it
2131 * should not matter too much. Stages > 1 are used rarely, so there's
2132 * no need to process them. Even if they're used it is likely that
2133 * the ffp setup has distinct stage 0 and 1 settings.
2135 for(i
= 0; i
< 2; i
++) {
2136 blob
= (DWORD
*) &k
->op
[i
];
2137 hash
^= blob
[0] ^ blob
[1];
2140 hash
+= ~(hash
<< 15);
2141 hash
^= (hash
>> 10);
2142 hash
+= (hash
<< 3);
2143 hash
^= (hash
>> 6);
2144 hash
+= ~(hash
<< 11);
2145 hash
^= (hash
>> 16);
2150 BOOL
ffp_program_key_compare(void *keya
, void *keyb
) {
2151 struct ffp_settings
*ka
= (struct ffp_settings
*)keya
;
2152 struct ffp_settings
*kb
= (struct ffp_settings
*)keyb
;
2154 return memcmp(ka
, kb
, sizeof(*ka
)) == 0;