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 ,2 ,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_DXT1
,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
, 0, GL_RGBA
,GL_UNSIGNED_BYTE
150 ,WINED3DFMT_FLAG_FILTERING
},
151 {WINED3DFMT_DXT2
,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
, 0, GL_RGBA
,GL_UNSIGNED_BYTE
152 ,WINED3DFMT_FLAG_FILTERING
},
153 {WINED3DFMT_DXT3
,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_DXT4
,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
, 0, GL_RGBA
,GL_UNSIGNED_BYTE
156 ,WINED3DFMT_FLAG_FILTERING
},
157 {WINED3DFMT_DXT5
,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_MULTI2_ARGB8
,0 ,0 , 0, 0 ,0
161 {WINED3DFMT_G8R8_G8B8
,0 ,0 , 0, 0 ,0
163 {WINED3DFMT_R8G8_B8G8
,0 ,0 , 0, 0 ,0
166 {WINED3DFMT_R32F
,GL_RGB32F_ARB
,GL_RGB32F_ARB
, 0, GL_RED
,GL_FLOAT
167 ,WINED3DFMT_FLAG_RENDERTARGET
},
168 {WINED3DFMT_G32R32F
,0 ,0 , 0, 0 ,0
169 ,WINED3DFMT_FLAG_RENDERTARGET
},
170 {WINED3DFMT_A32B32G32R32F
,GL_RGBA32F_ARB
,GL_RGBA32F_ARB
, 0, GL_RGBA
,GL_FLOAT
171 ,WINED3DFMT_FLAG_RENDERTARGET
},
173 {WINED3DFMT_CxV8U8
,0 ,0 , 0, 0 ,0
176 {WINED3DFMT_R16F
,GL_RGB16F_ARB
,GL_RGB16F_ARB
, 0, GL_RED
,GL_HALF_FLOAT_ARB
177 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
178 {WINED3DFMT_G16R16F
,0 ,0 , 0, 0 ,0
179 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
180 {WINED3DFMT_A16B16G16R16F
,GL_RGBA16F_ARB
,GL_RGBA16F_ARB
, 0, GL_RGBA
,GL_HALF_FLOAT_ARB
181 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
182 /* Palettized formats */
183 {WINED3DFMT_A8P8
, 0 ,0 , 0, 0 ,0
185 {WINED3DFMT_P8
, GL_COLOR_INDEX8_EXT
,GL_COLOR_INDEX8_EXT
, 0, GL_COLOR_INDEX
,GL_UNSIGNED_BYTE
187 /* Standard ARGB formats */
188 {WINED3DFMT_R8G8B8
,GL_RGB8
,GL_RGB8
, 0, GL_BGR
,GL_UNSIGNED_BYTE
189 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
190 {WINED3DFMT_A8R8G8B8
,GL_RGBA8
,GL_SRGB8_ALPHA8_EXT
, 0, GL_BGRA
,GL_UNSIGNED_INT_8_8_8_8_REV
191 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
192 {WINED3DFMT_X8R8G8B8
,GL_RGB8
,GL_SRGB8_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_R5G6B5
,GL_RGB5
,GL_RGB5
, GL_RGB8
, GL_RGB
,GL_UNSIGNED_SHORT_5_6_5
195 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
196 {WINED3DFMT_X1R5G5B5
,GL_RGB5
,GL_RGB5_A1
, 0, GL_BGRA
,GL_UNSIGNED_SHORT_1_5_5_5_REV
197 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
198 {WINED3DFMT_A1R5G5B5
,GL_RGB5_A1
,GL_RGB5_A1
, 0, GL_BGRA
,GL_UNSIGNED_SHORT_1_5_5_5_REV
199 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
200 {WINED3DFMT_A4R4G4B4
,GL_RGBA4
,GL_SRGB8_ALPHA8_EXT
, 0, GL_BGRA
,GL_UNSIGNED_SHORT_4_4_4_4_REV
201 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
202 {WINED3DFMT_R3G3B2
,GL_R3_G3_B2
,GL_R3_G3_B2
, 0, GL_RGB
,GL_UNSIGNED_BYTE_3_3_2
203 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
},
204 {WINED3DFMT_A8
,GL_ALPHA8
,GL_ALPHA8
, 0, GL_ALPHA
,GL_UNSIGNED_BYTE
205 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
},
206 {WINED3DFMT_A8R3G3B2
,0 ,0 , 0, 0 ,0
208 {WINED3DFMT_X4R4G4B4
,GL_RGB4
,GL_RGB4
, 0, GL_BGRA
,GL_UNSIGNED_SHORT_4_4_4_4_REV
209 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
210 {WINED3DFMT_A2B10G10R10
,GL_RGB10_A2
,GL_RGB10_A2
, 0, GL_RGBA
,GL_UNSIGNED_INT_2_10_10_10_REV
211 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
212 {WINED3DFMT_A8B8G8R8
,GL_RGBA8
,GL_RGBA8
, 0, GL_RGBA
,GL_UNSIGNED_INT_8_8_8_8_REV
213 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
214 {WINED3DFMT_X8B8G8R8
,GL_RGB8
,GL_RGB8
, 0, GL_RGBA
,GL_UNSIGNED_INT_8_8_8_8_REV
215 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
216 {WINED3DFMT_G16R16
,GL_RGB16_EXT
,GL_RGB16_EXT
, 0, GL_RGB
,GL_UNSIGNED_SHORT
217 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
218 {WINED3DFMT_A2R10G10B10
,GL_RGB10_A2
,GL_RGB10_A2
, 0, GL_BGRA
,GL_UNSIGNED_INT_2_10_10_10_REV
219 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
220 {WINED3DFMT_A16B16G16R16
,GL_RGBA16_EXT
,GL_RGBA16_EXT
, 0, GL_RGBA
,GL_UNSIGNED_SHORT
221 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
223 {WINED3DFMT_L8
,GL_LUMINANCE8
,GL_SLUMINANCE8_EXT
, 0, GL_LUMINANCE
,GL_UNSIGNED_BYTE
224 ,WINED3DFMT_FLAG_FILTERING
},
225 {WINED3DFMT_A8L8
,GL_LUMINANCE8_ALPHA8
,GL_SLUMINANCE8_ALPHA8_EXT
, 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
226 ,WINED3DFMT_FLAG_FILTERING
},
227 {WINED3DFMT_A4L4
,GL_LUMINANCE4_ALPHA4
,GL_LUMINANCE4_ALPHA4
, 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
229 /* Bump mapping stuff */
230 {WINED3DFMT_V8U8
,GL_DSDT8_NV
,GL_DSDT8_NV
, 0, GL_DSDT_NV
,GL_BYTE
231 ,WINED3DFMT_FLAG_FILTERING
},
232 {WINED3DFMT_L6V5U5
,GL_DSDT8_MAG8_NV
,GL_DSDT8_MAG8_NV
, 0, GL_DSDT_MAG_NV
,GL_BYTE
233 ,WINED3DFMT_FLAG_FILTERING
},
234 {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
235 ,WINED3DFMT_FLAG_FILTERING
},
236 {WINED3DFMT_Q8W8V8U8
,GL_SIGNED_RGBA8_NV
,GL_SIGNED_RGBA8_NV
, 0, GL_RGBA
,GL_BYTE
237 ,WINED3DFMT_FLAG_FILTERING
},
238 {WINED3DFMT_V16U16
,GL_SIGNED_HILO16_NV
,GL_SIGNED_HILO16_NV
, 0, GL_HILO_NV
,GL_SHORT
239 ,WINED3DFMT_FLAG_FILTERING
},
240 {WINED3DFMT_W11V11U10
,0 ,0 , 0, 0 ,0
242 {WINED3DFMT_A2W10V10U10
,0 ,0 , 0, 0 ,0
244 /* Depth stencil formats */
245 {WINED3DFMT_D16_LOCKABLE
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_SHORT
246 ,WINED3DFMT_FLAG_DEPTH
},
247 {WINED3DFMT_D32
,GL_DEPTH_COMPONENT32_ARB
,GL_DEPTH_COMPONENT32_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_INT
248 ,WINED3DFMT_FLAG_DEPTH
},
249 {WINED3DFMT_D15S1
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_SHORT
250 ,WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
},
251 {WINED3DFMT_D24S8
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_INT
252 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
},
253 {WINED3DFMT_D24X8
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_INT
254 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_DEPTH
},
255 {WINED3DFMT_D24X4S4
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_INT
256 ,WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
},
257 {WINED3DFMT_D16
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_SHORT
258 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_DEPTH
},
259 {WINED3DFMT_L16
,GL_LUMINANCE16_EXT
,GL_LUMINANCE16_EXT
, 0, GL_LUMINANCE
,GL_UNSIGNED_SHORT
260 ,WINED3DFMT_FLAG_FILTERING
},
261 {WINED3DFMT_D32F_LOCKABLE
,GL_DEPTH_COMPONENT32_ARB
,GL_DEPTH_COMPONENT32_ARB
, 0, GL_DEPTH_COMPONENT
,GL_FLOAT
262 ,WINED3DFMT_FLAG_DEPTH
},
263 {WINED3DFMT_D24FS8
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_FLOAT
264 ,WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
},
265 /* Is this a vertex buffer? */
266 {WINED3DFMT_VERTEXDATA
,0 ,0 , 0, 0 ,0
268 {WINED3DFMT_INDEX16
,0 ,0 , 0, 0 ,0
270 {WINED3DFMT_INDEX32
,0 ,0 , 0, 0 ,0
272 {WINED3DFMT_Q16W16V16U16
,GL_COLOR_INDEX
,GL_COLOR_INDEX
, 0, GL_COLOR_INDEX
,GL_UNSIGNED_SHORT
274 /* Vendor-specific formats */
275 {WINED3DFMT_ATI2N
,0 ,0 , 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
279 static inline int getFmtIdx(WINED3DFORMAT fmt
) {
280 /* First check if the format is at the position of its value.
281 * This will catch the argb formats before the loop is entered
283 if(fmt
< (sizeof(formats
) / sizeof(formats
[0])) && formats
[fmt
].format
== fmt
) {
287 for(i
= 0; i
< (sizeof(formats
) / sizeof(formats
[0])); i
++) {
288 if(formats
[i
].format
== fmt
) {
296 #define GLINFO_LOCATION (*gl_info)
297 BOOL
initPixelFormats(WineD3D_GL_Info
*gl_info
)
302 gl_info
->gl_formats
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
303 sizeof(formats
) / sizeof(formats
[0]) * sizeof(gl_info
->gl_formats
[0]));
304 if(!gl_info
->gl_formats
) return FALSE
;
306 /* If a format depends on some extensions, remove them from the table above and initialize them
309 for(src
= 0; src
< sizeof(gl_formats_template
) / sizeof(gl_formats_template
[0]); src
++) {
310 dst
= getFmtIdx(gl_formats_template
[src
].fmt
);
311 gl_info
->gl_formats
[dst
].glInternal
= gl_formats_template
[src
].glInternal
;
312 gl_info
->gl_formats
[dst
].glGammaInternal
= gl_formats_template
[src
].glGammaInternal
;
313 gl_info
->gl_formats
[dst
].glFormat
= gl_formats_template
[src
].glFormat
;
314 gl_info
->gl_formats
[dst
].glType
= gl_formats_template
[src
].glType
;
315 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_UNKNOWN
;
316 gl_info
->gl_formats
[dst
].Flags
= gl_formats_template
[src
].Flags
;
318 if(wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&&
319 gl_formats_template
[src
].rtInternal
!= 0) {
323 /* Check if the default internal format is supported as a frame buffer target, otherwise
324 * fall back to the render target internal.
326 * Try to stick to the standard format if possible, this limits precision differences
329 glGenTextures(1, &tex
);
330 glBindTexture(GL_TEXTURE_2D
, tex
);
331 glTexImage2D(GL_TEXTURE_2D
, 0, gl_formats_template
[src
].glInternal
, 16, 16, 0,
332 GL_RGBA
, GL_UNSIGNED_BYTE
, NULL
);
334 GL_EXTCALL(glGenFramebuffersEXT(1, &fb
));
335 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, fb
));
336 GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT
, GL_COLOR_ATTACHMENT0_EXT
,
337 GL_TEXTURE_2D
, tex
, 0));
339 status
= GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT
));
340 GL_EXTCALL(glDeleteFramebuffersEXT(1, &fb
));
341 glDeleteTextures(1, &tex
);
343 checkGLcall("Framebuffer format check");
345 if(status
!= GL_FRAMEBUFFER_COMPLETE_EXT
) {
346 TRACE("Internal format of %s not supported as frame buffer target, using render target internal instead\n",
347 debug_d3dformat(gl_formats_template
[src
].fmt
));
348 gl_info
->gl_formats
[dst
].rtInternal
= gl_formats_template
[src
].rtInternal
;
350 TRACE("Format %s is supported as fbo target\n", debug_d3dformat(gl_formats_template
[src
].fmt
));
351 gl_info
->gl_formats
[dst
].rtInternal
= gl_formats_template
[src
].glInternal
;
355 gl_info
->gl_formats
[dst
].rtInternal
= gl_formats_template
[src
].glInternal
;
359 /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
360 * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
361 * their extensions are not available.
363 * In theory, V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
364 * returns 0.0 when sampling from it, DirectX 1.0. This is disabled until we find
365 * an application that needs this because it causes performance problems due to
366 * shader recompiling in some games.
368 if(!GL_SUPPORT(ATI_ENVMAP_BUMPMAP
) && !GL_SUPPORT(NV_TEXTURE_SHADER2
)) {
369 /* signed -> unsigned fixup */
370 dst
= getFmtIdx(WINED3DFMT_V8U8
);
371 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
372 dst
= getFmtIdx(WINED3DFMT_V16U16
);
373 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
374 } else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
375 /* signed -> unsigned fixup */
376 dst
= getFmtIdx(WINED3DFMT_V16U16
);
377 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V16U16
;
379 /* Blue = 1.0 fixup, disabled for now */
381 dst
= getFmtIdx(WINED3DFMT_V8U8
);
382 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
383 dst
= getFmtIdx(WINED3DFMT_V16U16
);
384 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
388 if(!GL_SUPPORT(NV_TEXTURE_SHADER
)) {
389 /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
392 dst
= getFmtIdx(WINED3DFMT_L6V5U5
);
393 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_L6V5U5
;
394 dst
= getFmtIdx(WINED3DFMT_X8L8V8U8
);
395 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_X8L8V8U8
;
396 dst
= getFmtIdx(WINED3DFMT_Q8W8V8U8
);
397 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_Q8W8V8U8
;
399 /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
400 * are converted at surface loading time, but they do not need any modification in
401 * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
402 * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
406 if(GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC
)) {
407 dst
= getFmtIdx(WINED3DFMT_ATI2N
);
408 gl_info
->gl_formats
[dst
].glInternal
= GL_COMPRESSED_RED_GREEN_RGTC2_EXT
;
409 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_COMPRESSED_RED_GREEN_RGTC2_EXT
;
410 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_ATI2N
;
411 } else if(GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC
)) {
412 dst
= getFmtIdx(WINED3DFMT_ATI2N
);
413 gl_info
->gl_formats
[dst
].glInternal
= GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI
;
414 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI
;
415 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_ATI2N
;
418 if(!GL_SUPPORT(APPLE_YCBCR_422
)) {
419 dst
= getFmtIdx(WINED3DFMT_YUY2
);
420 gl_info
->gl_formats
[dst
].glInternal
= GL_LUMINANCE_ALPHA
;
421 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_LUMINANCE_ALPHA
; /* not srgb */
422 gl_info
->gl_formats
[dst
].glFormat
= GL_LUMINANCE_ALPHA
;
423 gl_info
->gl_formats
[dst
].glType
= GL_UNSIGNED_BYTE
;
424 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_YUY2
;
426 dst
= getFmtIdx(WINED3DFMT_UYVY
);
427 gl_info
->gl_formats
[dst
].glInternal
= GL_LUMINANCE_ALPHA
;
428 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_LUMINANCE_ALPHA
; /* not srgb */
429 gl_info
->gl_formats
[dst
].glFormat
= GL_LUMINANCE_ALPHA
;
430 gl_info
->gl_formats
[dst
].glType
= GL_UNSIGNED_BYTE
;
431 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_UYVY
;
436 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
437 static WINED3DGLTYPE
const glTypeLookupTemplate
[WINED3DDECLTYPE_UNUSED
] = {
438 {WINED3DDECLTYPE_FLOAT1
, 1, GL_FLOAT
, GL_FALSE
,sizeof(float)},
439 {WINED3DDECLTYPE_FLOAT2
, 2, GL_FLOAT
, GL_FALSE
,sizeof(float)},
440 {WINED3DDECLTYPE_FLOAT3
, 3, GL_FLOAT
, GL_FALSE
,sizeof(float)},
441 {WINED3DDECLTYPE_FLOAT4
, 4, GL_FLOAT
, GL_FALSE
,sizeof(float)},
442 {WINED3DDECLTYPE_D3DCOLOR
, 4, GL_UNSIGNED_BYTE
, GL_TRUE
,sizeof(BYTE
)},
443 {WINED3DDECLTYPE_UBYTE4
, 4, GL_UNSIGNED_BYTE
, GL_FALSE
,sizeof(BYTE
)},
444 {WINED3DDECLTYPE_SHORT2
, 2, GL_SHORT
, GL_FALSE
,sizeof(short int)},
445 {WINED3DDECLTYPE_SHORT4
, 4, GL_SHORT
, GL_FALSE
,sizeof(short int)},
446 {WINED3DDECLTYPE_UBYTE4N
, 4, GL_UNSIGNED_BYTE
, GL_TRUE
,sizeof(BYTE
)},
447 {WINED3DDECLTYPE_SHORT2N
, 2, GL_SHORT
, GL_TRUE
,sizeof(short int)},
448 {WINED3DDECLTYPE_SHORT4N
, 4, GL_SHORT
, GL_TRUE
,sizeof(short int)},
449 {WINED3DDECLTYPE_USHORT2N
, 2, GL_UNSIGNED_SHORT
, GL_TRUE
,sizeof(short int)},
450 {WINED3DDECLTYPE_USHORT4N
, 4, GL_UNSIGNED_SHORT
, GL_TRUE
,sizeof(short int)},
451 {WINED3DDECLTYPE_UDEC3
, 3, GL_UNSIGNED_SHORT
, GL_FALSE
,sizeof(short int)},
452 {WINED3DDECLTYPE_DEC3N
, 3, GL_SHORT
, GL_TRUE
,sizeof(short int)},
453 {WINED3DDECLTYPE_FLOAT16_2
, 2, GL_HALF_FLOAT_NV
, GL_FALSE
,sizeof(GLhalfNV
)},
454 {WINED3DDECLTYPE_FLOAT16_4
, 4, GL_HALF_FLOAT_NV
, GL_FALSE
,sizeof(GLhalfNV
)}};
456 void init_type_lookup(WineD3D_GL_Info
*gl_info
) {
457 memcpy(gl_info
->glTypeLookup
, glTypeLookupTemplate
, sizeof(glTypeLookupTemplate
));
458 if(!GL_SUPPORT(NV_HALF_FLOAT
)) {
459 /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
460 * It is the job of the vertex buffer code to make sure that the vbos have the right format
462 gl_info
->glTypeLookup
[WINED3DDECLTYPE_FLOAT16_2
].glType
= GL_FLOAT
;
463 gl_info
->glTypeLookup
[WINED3DDECLTYPE_FLOAT16_4
].glType
= GL_FLOAT
;
467 #undef GLINFO_LOCATION
469 #define GLINFO_LOCATION This->adapter->gl_info
471 const StaticPixelFormatDesc
*getFormatDescEntry(WINED3DFORMAT fmt
, WineD3D_GL_Info
*gl_info
, const GlPixelFormatDesc
**glDesc
)
473 int idx
= getFmtIdx(fmt
);
476 FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt
), fmt
);
477 /* Get the caller a valid pointer */
478 idx
= getFmtIdx(WINED3DFMT_UNKNOWN
);
481 if(!gl_info
->gl_formats
) {
482 /* If we do not have gl format information, provide a dummy NULL format. This is an easy way to make
483 * all gl caps check return "unsupported" than catching the lack of gl all over the code. ANSI C requires
484 * static variables to be initialized to 0.
486 static const GlPixelFormatDesc dummyFmt
;
489 *glDesc
= &gl_info
->gl_formats
[idx
];
492 return &formats
[idx
];
495 /*****************************************************************************
496 * Trace formatting of useful values
498 const char* debug_d3dformat(WINED3DFORMAT fmt
) {
500 #define FMT_TO_STR(fmt) case fmt: return #fmt
501 FMT_TO_STR(WINED3DFMT_UNKNOWN
);
502 FMT_TO_STR(WINED3DFMT_R8G8B8
);
503 FMT_TO_STR(WINED3DFMT_A8R8G8B8
);
504 FMT_TO_STR(WINED3DFMT_X8R8G8B8
);
505 FMT_TO_STR(WINED3DFMT_R5G6B5
);
506 FMT_TO_STR(WINED3DFMT_X1R5G5B5
);
507 FMT_TO_STR(WINED3DFMT_A1R5G5B5
);
508 FMT_TO_STR(WINED3DFMT_A4R4G4B4
);
509 FMT_TO_STR(WINED3DFMT_R3G3B2
);
510 FMT_TO_STR(WINED3DFMT_A8
);
511 FMT_TO_STR(WINED3DFMT_A8R3G3B2
);
512 FMT_TO_STR(WINED3DFMT_X4R4G4B4
);
513 FMT_TO_STR(WINED3DFMT_A2B10G10R10
);
514 FMT_TO_STR(WINED3DFMT_A8B8G8R8
);
515 FMT_TO_STR(WINED3DFMT_X8B8G8R8
);
516 FMT_TO_STR(WINED3DFMT_G16R16
);
517 FMT_TO_STR(WINED3DFMT_A2R10G10B10
);
518 FMT_TO_STR(WINED3DFMT_A16B16G16R16
);
519 FMT_TO_STR(WINED3DFMT_A8P8
);
520 FMT_TO_STR(WINED3DFMT_P8
);
521 FMT_TO_STR(WINED3DFMT_L8
);
522 FMT_TO_STR(WINED3DFMT_A8L8
);
523 FMT_TO_STR(WINED3DFMT_A4L4
);
524 FMT_TO_STR(WINED3DFMT_V8U8
);
525 FMT_TO_STR(WINED3DFMT_L6V5U5
);
526 FMT_TO_STR(WINED3DFMT_X8L8V8U8
);
527 FMT_TO_STR(WINED3DFMT_Q8W8V8U8
);
528 FMT_TO_STR(WINED3DFMT_V16U16
);
529 FMT_TO_STR(WINED3DFMT_W11V11U10
);
530 FMT_TO_STR(WINED3DFMT_A2W10V10U10
);
531 FMT_TO_STR(WINED3DFMT_UYVY
);
532 FMT_TO_STR(WINED3DFMT_YUY2
);
533 FMT_TO_STR(WINED3DFMT_YV12
);
534 FMT_TO_STR(WINED3DFMT_DXT1
);
535 FMT_TO_STR(WINED3DFMT_DXT2
);
536 FMT_TO_STR(WINED3DFMT_DXT3
);
537 FMT_TO_STR(WINED3DFMT_DXT4
);
538 FMT_TO_STR(WINED3DFMT_DXT5
);
539 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8
);
540 FMT_TO_STR(WINED3DFMT_G8R8_G8B8
);
541 FMT_TO_STR(WINED3DFMT_R8G8_B8G8
);
542 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE
);
543 FMT_TO_STR(WINED3DFMT_D32
);
544 FMT_TO_STR(WINED3DFMT_D15S1
);
545 FMT_TO_STR(WINED3DFMT_D24S8
);
546 FMT_TO_STR(WINED3DFMT_D24X8
);
547 FMT_TO_STR(WINED3DFMT_D24X4S4
);
548 FMT_TO_STR(WINED3DFMT_D16
);
549 FMT_TO_STR(WINED3DFMT_L16
);
550 FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE
);
551 FMT_TO_STR(WINED3DFMT_D24FS8
);
552 FMT_TO_STR(WINED3DFMT_VERTEXDATA
);
553 FMT_TO_STR(WINED3DFMT_INDEX16
);
554 FMT_TO_STR(WINED3DFMT_INDEX32
);
555 FMT_TO_STR(WINED3DFMT_Q16W16V16U16
);
556 FMT_TO_STR(WINED3DFMT_R16F
);
557 FMT_TO_STR(WINED3DFMT_G16R16F
);
558 FMT_TO_STR(WINED3DFMT_A16B16G16R16F
);
559 FMT_TO_STR(WINED3DFMT_R32F
);
560 FMT_TO_STR(WINED3DFMT_G32R32F
);
561 FMT_TO_STR(WINED3DFMT_A32B32G32R32F
);
562 FMT_TO_STR(WINED3DFMT_CxV8U8
);
563 FMT_TO_STR(WINED3DFMT_ATI2N
);
564 FMT_TO_STR(WINED3DFMT_NVHU
);
565 FMT_TO_STR(WINED3DFMT_NVHS
);
570 fourcc
[0] = (char)(fmt
);
571 fourcc
[1] = (char)(fmt
>> 8);
572 fourcc
[2] = (char)(fmt
>> 16);
573 fourcc
[3] = (char)(fmt
>> 24);
575 if( isprint(fourcc
[0]) && isprint(fourcc
[1]) && isprint(fourcc
[2]) && isprint(fourcc
[3]) )
576 FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt
, fourcc
);
578 FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt
);
580 return "unrecognized";
584 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype
) {
586 #define DEVTYPE_TO_STR(dev) case dev: return #dev
587 DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL
);
588 DEVTYPE_TO_STR(WINED3DDEVTYPE_REF
);
589 DEVTYPE_TO_STR(WINED3DDEVTYPE_SW
);
590 #undef DEVTYPE_TO_STR
592 FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype
);
593 return "unrecognized";
597 const char* debug_d3dusage(DWORD usage
) {
598 switch (usage
& WINED3DUSAGE_MASK
) {
599 #define WINED3DUSAGE_TO_STR(u) case u: return #u
600 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET
);
601 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL
);
602 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY
);
603 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING
);
604 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP
);
605 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS
);
606 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES
);
607 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES
);
608 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC
);
609 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP
);
610 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP
);
611 #undef WINED3DUSAGE_TO_STR
612 case 0: return "none";
614 FIXME("Unrecognized %u Usage!\n", usage
);
615 return "unrecognized";
619 const char* debug_d3dusagequery(DWORD usagequery
) {
620 switch (usagequery
& WINED3DUSAGE_QUERY_MASK
) {
621 #define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
622 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER
);
623 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP
);
624 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
);
625 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD
);
626 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE
);
627 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE
);
628 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP
);
629 #undef WINED3DUSAGEQUERY_TO_STR
630 case 0: return "none";
632 FIXME("Unrecognized %u Usage Query!\n", usagequery
);
633 return "unrecognized";
637 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method
) {
639 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
640 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT
);
641 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU
);
642 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV
);
643 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV
);
644 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV
);
645 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP
);
646 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED
);
647 #undef WINED3DDECLMETHOD_TO_STR
649 FIXME("Unrecognized %u declaration method!\n", method
);
650 return "unrecognized";
654 const char* debug_d3ddecltype(WINED3DDECLTYPE type
) {
656 #define WINED3DDECLTYPE_TO_STR(u) case u: return #u
657 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT1
);
658 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT2
);
659 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT3
);
660 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT4
);
661 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_D3DCOLOR
);
662 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4
);
663 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2
);
664 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4
);
665 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4N
);
666 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2N
);
667 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4N
);
668 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT2N
);
669 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT4N
);
670 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UDEC3
);
671 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_DEC3N
);
672 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_2
);
673 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_4
);
674 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UNUSED
);
675 #undef WINED3DDECLTYPE_TO_STR
677 FIXME("Unrecognized %u declaration type!\n", type
);
678 return "unrecognized";
682 const char* debug_d3ddeclusage(BYTE usage
) {
684 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
685 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION
);
686 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT
);
687 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES
);
688 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL
);
689 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE
);
690 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD
);
691 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT
);
692 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL
);
693 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR
);
694 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT
);
695 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR
);
696 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG
);
697 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH
);
698 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE
);
699 #undef WINED3DDECLUSAGE_TO_STR
701 FIXME("Unrecognized %u declaration usage!\n", usage
);
702 return "unrecognized";
706 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res
) {
708 #define RES_TO_STR(res) case res: return #res;
709 RES_TO_STR(WINED3DRTYPE_SURFACE
);
710 RES_TO_STR(WINED3DRTYPE_VOLUME
);
711 RES_TO_STR(WINED3DRTYPE_TEXTURE
);
712 RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE
);
713 RES_TO_STR(WINED3DRTYPE_CUBETEXTURE
);
714 RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER
);
715 RES_TO_STR(WINED3DRTYPE_INDEXBUFFER
);
718 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res
);
719 return "unrecognized";
723 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType
) {
724 switch (PrimitiveType
) {
725 #define PRIM_TO_STR(prim) case prim: return #prim;
726 PRIM_TO_STR(WINED3DPT_POINTLIST
);
727 PRIM_TO_STR(WINED3DPT_LINELIST
);
728 PRIM_TO_STR(WINED3DPT_LINESTRIP
);
729 PRIM_TO_STR(WINED3DPT_TRIANGLELIST
);
730 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP
);
731 PRIM_TO_STR(WINED3DPT_TRIANGLEFAN
);
734 FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType
);
735 return "unrecognized";
739 const char* debug_d3drenderstate(DWORD state
) {
741 #define D3DSTATE_TO_STR(u) case u: return #u
742 D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE
);
743 D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS
);
744 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS
);
745 D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE
);
746 D3DSTATE_TO_STR(WINED3DRS_WRAPU
);
747 D3DSTATE_TO_STR(WINED3DRS_WRAPV
);
748 D3DSTATE_TO_STR(WINED3DRS_ZENABLE
);
749 D3DSTATE_TO_STR(WINED3DRS_FILLMODE
);
750 D3DSTATE_TO_STR(WINED3DRS_SHADEMODE
);
751 D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN
);
752 D3DSTATE_TO_STR(WINED3DRS_MONOENABLE
);
753 D3DSTATE_TO_STR(WINED3DRS_ROP2
);
754 D3DSTATE_TO_STR(WINED3DRS_PLANEMASK
);
755 D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE
);
756 D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE
);
757 D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL
);
758 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG
);
759 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN
);
760 D3DSTATE_TO_STR(WINED3DRS_SRCBLEND
);
761 D3DSTATE_TO_STR(WINED3DRS_DESTBLEND
);
762 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND
);
763 D3DSTATE_TO_STR(WINED3DRS_CULLMODE
);
764 D3DSTATE_TO_STR(WINED3DRS_ZFUNC
);
765 D3DSTATE_TO_STR(WINED3DRS_ALPHAREF
);
766 D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC
);
767 D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE
);
768 D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE
);
769 D3DSTATE_TO_STR(WINED3DRS_FOGENABLE
);
770 D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE
);
771 D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE
);
772 D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL
);
773 D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX
);
774 D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA
);
775 D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR
);
776 D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE
);
777 D3DSTATE_TO_STR(WINED3DRS_FOGSTART
);
778 D3DSTATE_TO_STR(WINED3DRS_FOGEND
);
779 D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY
);
780 D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE
);
781 D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS
);
782 D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE
);
783 D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR
);
784 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU
);
785 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV
);
786 D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS
);
787 D3DSTATE_TO_STR(WINED3DRS_ZBIAS
);
788 D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE
);
789 D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY
);
790 D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH
);
791 D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
);
792 D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE
);
793 D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL
);
794 D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL
);
795 D3DSTATE_TO_STR(WINED3DRS_STENCILPASS
);
796 D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC
);
797 D3DSTATE_TO_STR(WINED3DRS_STENCILREF
);
798 D3DSTATE_TO_STR(WINED3DRS_STENCILMASK
);
799 D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK
);
800 D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR
);
801 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00
);
802 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01
);
803 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02
);
804 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03
);
805 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04
);
806 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05
);
807 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06
);
808 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07
);
809 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08
);
810 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09
);
811 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10
);
812 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11
);
813 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12
);
814 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13
);
815 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14
);
816 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15
);
817 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16
);
818 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17
);
819 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18
);
820 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19
);
821 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20
);
822 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21
);
823 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22
);
824 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23
);
825 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24
);
826 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25
);
827 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26
);
828 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27
);
829 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28
);
830 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29
);
831 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30
);
832 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31
);
833 D3DSTATE_TO_STR(WINED3DRS_WRAP0
);
834 D3DSTATE_TO_STR(WINED3DRS_WRAP1
);
835 D3DSTATE_TO_STR(WINED3DRS_WRAP2
);
836 D3DSTATE_TO_STR(WINED3DRS_WRAP3
);
837 D3DSTATE_TO_STR(WINED3DRS_WRAP4
);
838 D3DSTATE_TO_STR(WINED3DRS_WRAP5
);
839 D3DSTATE_TO_STR(WINED3DRS_WRAP6
);
840 D3DSTATE_TO_STR(WINED3DRS_WRAP7
);
841 D3DSTATE_TO_STR(WINED3DRS_CLIPPING
);
842 D3DSTATE_TO_STR(WINED3DRS_LIGHTING
);
843 D3DSTATE_TO_STR(WINED3DRS_EXTENTS
);
844 D3DSTATE_TO_STR(WINED3DRS_AMBIENT
);
845 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE
);
846 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX
);
847 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER
);
848 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS
);
849 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE
);
850 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE
);
851 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE
);
852 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE
);
853 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE
);
854 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND
);
855 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE
);
856 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING
);
857 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE
);
858 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN
);
859 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE
);
860 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE
);
861 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A
);
862 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B
);
863 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C
);
864 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS
);
865 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK
);
866 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE
);
867 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS
);
868 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN
);
869 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX
);
870 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE
);
871 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE
);
872 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR
);
873 D3DSTATE_TO_STR(WINED3DRS_BLENDOP
);
874 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE
);
875 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE
);
876 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE
);
877 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS
);
878 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE
);
879 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL
);
880 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL
);
881 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X
);
882 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y
);
883 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z
);
884 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W
);
885 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION
);
886 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE
);
887 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL
);
888 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL
);
889 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS
);
890 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC
);
891 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1
);
892 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2
);
893 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3
);
894 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR
);
895 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE
);
896 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS
);
897 D3DSTATE_TO_STR(WINED3DRS_WRAP8
);
898 D3DSTATE_TO_STR(WINED3DRS_WRAP9
);
899 D3DSTATE_TO_STR(WINED3DRS_WRAP10
);
900 D3DSTATE_TO_STR(WINED3DRS_WRAP11
);
901 D3DSTATE_TO_STR(WINED3DRS_WRAP12
);
902 D3DSTATE_TO_STR(WINED3DRS_WRAP13
);
903 D3DSTATE_TO_STR(WINED3DRS_WRAP14
);
904 D3DSTATE_TO_STR(WINED3DRS_WRAP15
);
905 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE
);
906 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA
);
907 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA
);
908 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA
);
909 #undef D3DSTATE_TO_STR
911 FIXME("Unrecognized %u render state!\n", state
);
912 return "unrecognized";
916 const char* debug_d3dsamplerstate(DWORD state
) {
918 #define D3DSTATE_TO_STR(u) case u: return #u
919 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR
);
920 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU
);
921 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV
);
922 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW
);
923 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER
);
924 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER
);
925 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER
);
926 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS
);
927 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL
);
928 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY
);
929 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE
);
930 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX
);
931 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET
);
932 #undef D3DSTATE_TO_STR
934 FIXME("Unrecognized %u sampler state!\n", state
);
935 return "unrecognized";
939 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type
) {
940 switch (filter_type
) {
941 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
942 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE
);
943 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT
);
944 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR
);
945 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC
);
946 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC
);
947 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC
);
948 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD
);
949 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD
);
950 #undef D3DTEXTUREFILTERTYPE_TO_STR
952 FIXME("Unrecognied texture filter type 0x%08x\n", filter_type
);
953 return "unrecognized";
957 const char* debug_d3dtexturestate(DWORD state
) {
959 #define D3DSTATE_TO_STR(u) case u: return #u
960 D3DSTATE_TO_STR(WINED3DTSS_COLOROP
);
961 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1
);
962 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2
);
963 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP
);
964 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1
);
965 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2
);
966 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00
);
967 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01
);
968 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10
);
969 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11
);
970 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX
);
971 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE
);
972 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET
);
973 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS
);
974 D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW
);
975 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0
);
976 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0
);
977 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG
);
978 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT
);
979 #undef D3DSTATE_TO_STR
981 /* Note WINED3DTSS are not consecutive, so skip these */
984 FIXME("Unrecognized %u texture state!\n", state
);
985 return "unrecognized";
989 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop
) {
991 #define D3DTOP_TO_STR(u) case u: return #u
992 D3DTOP_TO_STR(WINED3DTOP_DISABLE
);
993 D3DTOP_TO_STR(WINED3DTOP_SELECTARG1
);
994 D3DTOP_TO_STR(WINED3DTOP_SELECTARG2
);
995 D3DTOP_TO_STR(WINED3DTOP_MODULATE
);
996 D3DTOP_TO_STR(WINED3DTOP_MODULATE2X
);
997 D3DTOP_TO_STR(WINED3DTOP_MODULATE4X
);
998 D3DTOP_TO_STR(WINED3DTOP_ADD
);
999 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED
);
1000 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X
);
1001 D3DTOP_TO_STR(WINED3DTOP_SUBTRACT
);
1002 D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH
);
1003 D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA
);
1004 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA
);
1005 D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA
);
1006 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM
);
1007 D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA
);
1008 D3DTOP_TO_STR(WINED3DTOP_PREMODULATE
);
1009 D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR
);
1010 D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA
);
1011 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
);
1012 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
);
1013 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP
);
1014 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE
);
1015 D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3
);
1016 D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD
);
1017 D3DTOP_TO_STR(WINED3DTOP_LERP
);
1018 #undef D3DTOP_TO_STR
1020 FIXME("Unrecognized %u WINED3DTOP\n", d3dtop
);
1021 return "unrecognized";
1025 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype
) {
1027 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
1028 TSTYPE_TO_STR(WINED3DTS_VIEW
);
1029 TSTYPE_TO_STR(WINED3DTS_PROJECTION
);
1030 TSTYPE_TO_STR(WINED3DTS_TEXTURE0
);
1031 TSTYPE_TO_STR(WINED3DTS_TEXTURE1
);
1032 TSTYPE_TO_STR(WINED3DTS_TEXTURE2
);
1033 TSTYPE_TO_STR(WINED3DTS_TEXTURE3
);
1034 TSTYPE_TO_STR(WINED3DTS_TEXTURE4
);
1035 TSTYPE_TO_STR(WINED3DTS_TEXTURE5
);
1036 TSTYPE_TO_STR(WINED3DTS_TEXTURE6
);
1037 TSTYPE_TO_STR(WINED3DTS_TEXTURE7
);
1038 TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
1039 #undef TSTYPE_TO_STR
1041 if (tstype
> 256 && tstype
< 512) {
1042 FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype
);
1043 return ("WINED3DTS_WORLDMATRIX > 0");
1045 FIXME("Unrecognized %u WINED3DTS\n", tstype
);
1046 return "unrecognized";
1050 const char* debug_d3dpool(WINED3DPOOL Pool
) {
1052 #define POOL_TO_STR(p) case p: return #p;
1053 POOL_TO_STR(WINED3DPOOL_DEFAULT
);
1054 POOL_TO_STR(WINED3DPOOL_MANAGED
);
1055 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM
);
1056 POOL_TO_STR(WINED3DPOOL_SCRATCH
);
1059 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool
);
1060 return "unrecognized";
1064 const char *debug_fbostatus(GLenum status
) {
1066 #define FBOSTATUS_TO_STR(u) case u: return #u
1067 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT
);
1068 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT
);
1069 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT
);
1070 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
);
1071 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT
);
1072 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT
);
1073 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT
);
1074 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT
);
1075 #undef FBOSTATUS_TO_STR
1077 FIXME("Unrecognied FBO status 0x%08x\n", status
);
1078 return "unrecognized";
1082 const char *debug_glerror(GLenum error
) {
1084 #define GLERROR_TO_STR(u) case u: return #u
1085 GLERROR_TO_STR(GL_NO_ERROR
);
1086 GLERROR_TO_STR(GL_INVALID_ENUM
);
1087 GLERROR_TO_STR(GL_INVALID_VALUE
);
1088 GLERROR_TO_STR(GL_INVALID_OPERATION
);
1089 GLERROR_TO_STR(GL_STACK_OVERFLOW
);
1090 GLERROR_TO_STR(GL_STACK_UNDERFLOW
);
1091 GLERROR_TO_STR(GL_OUT_OF_MEMORY
);
1092 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT
);
1093 #undef GLERROR_TO_STR
1095 FIXME("Unrecognied GL error 0x%08x\n", error
);
1096 return "unrecognized";
1100 const char *debug_d3dbasis(WINED3DBASISTYPE basis
) {
1102 case WINED3DBASIS_BEZIER
: return "WINED3DBASIS_BEZIER";
1103 case WINED3DBASIS_BSPLINE
: return "WINED3DBASIS_BSPLINE";
1104 case WINED3DBASIS_INTERPOLATE
: return "WINED3DBASIS_INTERPOLATE";
1105 default: return "unrecognized";
1109 const char *debug_d3ddegree(WINED3DDEGREETYPE degree
) {
1111 case WINED3DDEGREE_LINEAR
: return "WINED3DDEGREE_LINEAR";
1112 case WINED3DDEGREE_QUADRATIC
: return "WINED3DDEGREE_QUADRATIC";
1113 case WINED3DDEGREE_CUBIC
: return "WINED3DDEGREE_CUBIC";
1114 case WINED3DDEGREE_QUINTIC
: return "WINED3DDEGREE_QUINTIC";
1115 default: return "unrecognized";
1119 /*****************************************************************************
1120 * Useful functions mapping GL <-> D3D values
1122 GLenum
StencilOp(DWORD op
) {
1124 case WINED3DSTENCILOP_KEEP
: return GL_KEEP
;
1125 case WINED3DSTENCILOP_ZERO
: return GL_ZERO
;
1126 case WINED3DSTENCILOP_REPLACE
: return GL_REPLACE
;
1127 case WINED3DSTENCILOP_INCRSAT
: return GL_INCR
;
1128 case WINED3DSTENCILOP_DECRSAT
: return GL_DECR
;
1129 case WINED3DSTENCILOP_INVERT
: return GL_INVERT
;
1130 case WINED3DSTENCILOP_INCR
: return GL_INCR_WRAP_EXT
;
1131 case WINED3DSTENCILOP_DECR
: return GL_DECR_WRAP_EXT
;
1133 FIXME("Unrecognized stencil op %d\n", op
);
1138 GLenum
CompareFunc(DWORD func
) {
1139 switch ((WINED3DCMPFUNC
)func
) {
1140 case WINED3DCMP_NEVER
: return GL_NEVER
;
1141 case WINED3DCMP_LESS
: return GL_LESS
;
1142 case WINED3DCMP_EQUAL
: return GL_EQUAL
;
1143 case WINED3DCMP_LESSEQUAL
: return GL_LEQUAL
;
1144 case WINED3DCMP_GREATER
: return GL_GREATER
;
1145 case WINED3DCMP_NOTEQUAL
: return GL_NOTEQUAL
;
1146 case WINED3DCMP_GREATEREQUAL
: return GL_GEQUAL
;
1147 case WINED3DCMP_ALWAYS
: return GL_ALWAYS
;
1149 FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func
);
1154 BOOL
is_invalid_op(IWineD3DDeviceImpl
*This
, int stage
, WINED3DTEXTUREOP op
, DWORD arg1
, DWORD arg2
, DWORD arg3
) {
1155 if (op
== WINED3DTOP_DISABLE
) return FALSE
;
1156 if (This
->stateBlock
->textures
[stage
]) return FALSE
;
1158 if ((arg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1159 && op
!= WINED3DTOP_SELECTARG2
) return TRUE
;
1160 if ((arg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1161 && op
!= WINED3DTOP_SELECTARG1
) return TRUE
;
1162 if ((arg3
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1163 && (op
== WINED3DTOP_MULTIPLYADD
|| op
== WINED3DTOP_LERP
)) return TRUE
;
1168 /* Setup this textures matrix according to the texture flags*/
1169 void set_texture_matrix(const float *smat
, DWORD flags
, BOOL calculatedCoords
, BOOL transformed
, DWORD coordtype
,
1170 BOOL ffp_proj_control
)
1174 glMatrixMode(GL_TEXTURE
);
1175 checkGLcall("glMatrixMode(GL_TEXTURE)");
1177 if (flags
== WINED3DTTFF_DISABLE
|| flags
== WINED3DTTFF_COUNT1
|| transformed
) {
1179 checkGLcall("glLoadIdentity()");
1183 if (flags
== (WINED3DTTFF_COUNT1
|WINED3DTTFF_PROJECTED
)) {
1184 ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
1188 memcpy(mat
, smat
, 16 * sizeof(float));
1190 if (flags
& WINED3DTTFF_PROJECTED
) {
1191 if(!ffp_proj_control
) {
1192 switch (flags
& ~WINED3DTTFF_PROJECTED
) {
1193 case WINED3DTTFF_COUNT2
:
1194 mat
[3] = mat
[1], mat
[7] = mat
[5], mat
[11] = mat
[9], mat
[15] = mat
[13];
1195 mat
[1] = mat
[5] = mat
[9] = mat
[13] = 0;
1197 case WINED3DTTFF_COUNT3
:
1198 mat
[3] = mat
[2], mat
[7] = mat
[6], mat
[11] = mat
[10], mat
[15] = mat
[14];
1199 mat
[2] = mat
[6] = mat
[10] = mat
[14] = 0;
1203 } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1204 if(!calculatedCoords
) {
1206 case WINED3DDECLTYPE_FLOAT1
:
1207 /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
1208 * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
1209 * the input value to the transformation will be 0, so the matrix value is irrelevant
1216 case WINED3DDECLTYPE_FLOAT2
:
1217 /* See above, just 3rd and 4th coord
1224 case WINED3DDECLTYPE_FLOAT3
: /* Opengl defaults match dx defaults */
1225 case WINED3DDECLTYPE_FLOAT4
: /* No defaults apply, all app defined */
1227 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
1228 * into a bad place. The division elimination below will apply to make sure the
1229 * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
1231 case WINED3DDECLTYPE_UNUSED
: /* No texture coords, 0/0/0/1 defaults are passed */
1234 FIXME("Unexpected fixed function texture coord input\n");
1237 if(!ffp_proj_control
) {
1238 switch (flags
& ~WINED3DTTFF_PROJECTED
) {
1239 /* case WINED3DTTFF_COUNT1: Won't ever get here */
1240 case WINED3DTTFF_COUNT2
: mat
[2] = mat
[6] = mat
[10] = mat
[14] = 0;
1241 /* OpenGL divides the first 3 vertex coord by the 4th by default,
1242 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
1243 * the 4th coord evaluates to 1.0 to eliminate that.
1245 * If the fixed function pipeline is used, the 4th value remains unused,
1246 * so there is no danger in doing this. With vertex shaders we have a
1247 * problem. Should an app hit that problem, the code here would have to
1248 * check for pixel shaders, and the shader has to undo the default gl divide.
1250 * A more serious problem occurs if the app passes 4 coordinates in, and the
1251 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
1252 * or a replacement shader
1254 default: mat
[3] = mat
[7] = mat
[11] = 0; mat
[15] = 1;
1260 checkGLcall("glLoadMatrixf(mat)");
1262 #undef GLINFO_LOCATION
1264 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1266 /* This small helper function is used to convert a bitmask into the number of masked bits */
1267 unsigned int count_bits(unsigned int mask
)
1270 for (count
= 0; mask
; ++count
)
1277 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
1278 * The later function requires individual color components. */
1279 BOOL
getColorBits(WINED3DFORMAT fmt
, short *redSize
, short *greenSize
, short *blueSize
, short *alphaSize
, short *totalSize
)
1281 const StaticPixelFormatDesc
*desc
;
1283 TRACE("fmt: %s\n", debug_d3dformat(fmt
));
1286 case WINED3DFMT_X8R8G8B8
:
1287 case WINED3DFMT_R8G8B8
:
1288 case WINED3DFMT_A8R8G8B8
:
1289 case WINED3DFMT_A2R10G10B10
:
1290 case WINED3DFMT_X1R5G5B5
:
1291 case WINED3DFMT_A1R5G5B5
:
1292 case WINED3DFMT_R5G6B5
:
1293 case WINED3DFMT_X4R4G4B4
:
1294 case WINED3DFMT_A4R4G4B4
:
1295 case WINED3DFMT_R3G3B2
:
1296 case WINED3DFMT_A8P8
:
1300 ERR("Unsupported format: %s\n", debug_d3dformat(fmt
));
1304 desc
= getFormatDescEntry(fmt
, NULL
, NULL
);
1307 ERR("Unable to look up format: 0x%x\n", fmt
);
1310 *redSize
= count_bits(desc
->redMask
);
1311 *greenSize
= count_bits(desc
->greenMask
);
1312 *blueSize
= count_bits(desc
->blueMask
);
1313 *alphaSize
= count_bits(desc
->alphaMask
);
1314 *totalSize
= *redSize
+ *greenSize
+ *blueSize
+ *alphaSize
;
1316 TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n", *redSize
, *greenSize
, *blueSize
, *alphaSize
, *totalSize
, debug_d3dformat(fmt
));
1320 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
1321 BOOL
getDepthStencilBits(WINED3DFORMAT fmt
, short *depthSize
, short *stencilSize
)
1323 const StaticPixelFormatDesc
*desc
;
1325 TRACE("fmt: %s\n", debug_d3dformat(fmt
));
1328 case WINED3DFMT_D16_LOCKABLE
:
1329 case WINED3DFMT_D16
:
1330 case WINED3DFMT_D15S1
:
1331 case WINED3DFMT_D24X8
:
1332 case WINED3DFMT_D24X4S4
:
1333 case WINED3DFMT_D24S8
:
1334 case WINED3DFMT_D24FS8
:
1335 case WINED3DFMT_D32
:
1336 case WINED3DFMT_D32F_LOCKABLE
:
1339 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(fmt
));
1343 desc
= getFormatDescEntry(fmt
, NULL
, NULL
);
1346 ERR("Unable to look up format: 0x%x\n", fmt
);
1349 *depthSize
= desc
->depthSize
;
1350 *stencilSize
= desc
->stencilSize
;
1352 TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n", *depthSize
, *stencilSize
, debug_d3dformat(fmt
));
1356 #undef GLINFO_LOCATION
1358 /* DirectDraw stuff */
1359 WINED3DFORMAT
pixelformat_for_depth(DWORD depth
) {
1361 case 8: return WINED3DFMT_P8
;
1362 case 15: return WINED3DFMT_X1R5G5B5
;
1363 case 16: return WINED3DFMT_R5G6B5
;
1364 case 24: return WINED3DFMT_X8R8G8B8
; /* Robots needs 24bit to be X8R8G8B8 */
1365 case 32: return WINED3DFMT_X8R8G8B8
; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return X8R8G8B8 */
1366 default: return WINED3DFMT_UNKNOWN
;
1370 void multiply_matrix(WINED3DMATRIX
*dest
, const WINED3DMATRIX
*src1
, const WINED3DMATRIX
*src2
) {
1373 /* Now do the multiplication 'by hand'.
1374 I know that all this could be optimised, but this will be done later :-) */
1375 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
);
1376 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
);
1377 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
);
1378 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
);
1380 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
);
1381 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
);
1382 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
);
1383 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
);
1385 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
);
1386 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
);
1387 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
);
1388 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
);
1390 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
);
1391 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
);
1392 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
);
1393 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
);
1395 /* And copy the new matrix in the good storage.. */
1396 memcpy(dest
, &temp
, 16 * sizeof(float));
1399 DWORD
get_flexible_vertex_size(DWORD d3dvtVertexType
) {
1402 int numTextures
= (d3dvtVertexType
& WINED3DFVF_TEXCOUNT_MASK
) >> WINED3DFVF_TEXCOUNT_SHIFT
;
1404 if (d3dvtVertexType
& WINED3DFVF_NORMAL
) size
+= 3 * sizeof(float);
1405 if (d3dvtVertexType
& WINED3DFVF_DIFFUSE
) size
+= sizeof(DWORD
);
1406 if (d3dvtVertexType
& WINED3DFVF_SPECULAR
) size
+= sizeof(DWORD
);
1407 if (d3dvtVertexType
& WINED3DFVF_PSIZE
) size
+= sizeof(DWORD
);
1408 switch (d3dvtVertexType
& WINED3DFVF_POSITION_MASK
) {
1409 case WINED3DFVF_XYZ
: size
+= 3 * sizeof(float); break;
1410 case WINED3DFVF_XYZRHW
: size
+= 4 * sizeof(float); break;
1411 case WINED3DFVF_XYZB1
: size
+= 4 * sizeof(float); break;
1412 case WINED3DFVF_XYZB2
: size
+= 5 * sizeof(float); break;
1413 case WINED3DFVF_XYZB3
: size
+= 6 * sizeof(float); break;
1414 case WINED3DFVF_XYZB4
: size
+= 7 * sizeof(float); break;
1415 case WINED3DFVF_XYZB5
: size
+= 8 * sizeof(float); break;
1416 default: ERR("Unexpected position mask\n");
1418 for (i
= 0; i
< numTextures
; i
++) {
1419 size
+= GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType
, i
) * sizeof(float);
1425 /***********************************************************************
1428 * Calculates the dimensions of the opengl texture used for blits.
1429 * Handled oversized opengl textures and updates the source rectangle
1433 * This: Surface to operate on
1434 * Rect: Requested rectangle
1437 * TRUE if the texture part can be loaded,
1440 *********************************************************************/
1441 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
1443 BOOL
CalculateTexRect(IWineD3DSurfaceImpl
*This
, RECT
*Rect
, float glTexCoord
[4]) {
1444 int x1
= Rect
->left
, x2
= Rect
->right
;
1445 int y1
= Rect
->top
, y2
= Rect
->bottom
;
1446 GLint maxSize
= GL_LIMITS(texture_size
);
1448 TRACE("(%p)->(%d,%d)-(%d,%d)\n", This
,
1449 Rect
->left
, Rect
->top
, Rect
->right
, Rect
->bottom
);
1451 /* The sizes might be reversed */
1452 if(Rect
->left
> Rect
->right
) {
1456 if(Rect
->top
> Rect
->bottom
) {
1461 /* No oversized texture? This is easy */
1462 if(!(This
->Flags
& SFLAG_OVERSIZE
)) {
1463 /* Which rect from the texture do I need? */
1464 if(This
->glDescription
.target
== GL_TEXTURE_RECTANGLE_ARB
) {
1465 glTexCoord
[0] = (float) Rect
->left
;
1466 glTexCoord
[2] = (float) Rect
->top
;
1467 glTexCoord
[1] = (float) Rect
->right
;
1468 glTexCoord
[3] = (float) Rect
->bottom
;
1470 glTexCoord
[0] = (float) Rect
->left
/ (float) This
->pow2Width
;
1471 glTexCoord
[2] = (float) Rect
->top
/ (float) This
->pow2Height
;
1472 glTexCoord
[1] = (float) Rect
->right
/ (float) This
->pow2Width
;
1473 glTexCoord
[3] = (float) Rect
->bottom
/ (float) This
->pow2Height
;
1478 /* Check if we can succeed at all */
1479 if( (x2
- x1
) > maxSize
||
1480 (y2
- y1
) > maxSize
) {
1481 TRACE("Requested rectangle is too large for gl\n");
1485 /* A part of the texture has to be picked. First, check if
1486 * some texture part is loaded already, if yes try to re-use it.
1487 * If the texture is dirty, or the part can't be used,
1488 * re-position the part to load
1490 if(This
->Flags
& SFLAG_INTEXTURE
) {
1491 if(This
->glRect
.left
<= x1
&& This
->glRect
.right
>= x2
&&
1492 This
->glRect
.top
<= y1
&& This
->glRect
.bottom
>= x2
) {
1493 /* Ok, the rectangle is ok, re-use it */
1494 TRACE("Using existing gl Texture\n");
1496 /* Rectangle is not ok, dirtify the texture to reload it */
1497 TRACE("Dirtifying texture to force reload\n");
1498 This
->Flags
&= ~SFLAG_INTEXTURE
;
1502 /* Now if we are dirty(no else if!) */
1503 if(!(This
->Flags
& SFLAG_INTEXTURE
)) {
1504 /* Set the new rectangle. Use the following strategy:
1505 * 1) Use as big textures as possible.
1506 * 2) Place the texture part in the way that the requested
1507 * part is in the middle of the texture(well, almost)
1508 * 3) If the texture is moved over the edges of the
1509 * surface, replace it nicely
1510 * 4) If the coord is not limiting the texture size,
1511 * use the whole size
1513 if((This
->pow2Width
) > maxSize
) {
1514 This
->glRect
.left
= x1
- maxSize
/ 2;
1515 if(This
->glRect
.left
< 0) {
1516 This
->glRect
.left
= 0;
1518 This
->glRect
.right
= This
->glRect
.left
+ maxSize
;
1519 if(This
->glRect
.right
> This
->currentDesc
.Width
) {
1520 This
->glRect
.right
= This
->currentDesc
.Width
;
1521 This
->glRect
.left
= This
->glRect
.right
- maxSize
;
1524 This
->glRect
.left
= 0;
1525 This
->glRect
.right
= This
->pow2Width
;
1528 if(This
->pow2Height
> maxSize
) {
1529 This
->glRect
.top
= x1
- GL_LIMITS(texture_size
) / 2;
1530 if(This
->glRect
.top
< 0) This
->glRect
.top
= 0;
1531 This
->glRect
.bottom
= This
->glRect
.left
+ maxSize
;
1532 if(This
->glRect
.bottom
> This
->currentDesc
.Height
) {
1533 This
->glRect
.bottom
= This
->currentDesc
.Height
;
1534 This
->glRect
.top
= This
->glRect
.bottom
- maxSize
;
1537 This
->glRect
.top
= 0;
1538 This
->glRect
.bottom
= This
->pow2Height
;
1540 TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This
,
1541 This
->glRect
.left
, This
->glRect
.top
, This
->glRect
.right
, This
->glRect
.bottom
);
1544 /* Re-calculate the rect to draw */
1545 Rect
->left
-= This
->glRect
.left
;
1546 Rect
->right
-= This
->glRect
.left
;
1547 Rect
->top
-= This
->glRect
.top
;
1548 Rect
->bottom
-= This
->glRect
.top
;
1550 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
1551 * or the pow2Width / pow2Height of the surface.
1553 * Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
1554 * as regular GL_TEXTURE_2D.
1556 glTexCoord
[0] = (float) Rect
->left
/ (float) (This
->glRect
.right
- This
->glRect
.left
);
1557 glTexCoord
[2] = (float) Rect
->top
/ (float) (This
->glRect
.bottom
- This
->glRect
.top
);
1558 glTexCoord
[1] = (float) Rect
->right
/ (float) (This
->glRect
.right
- This
->glRect
.left
);
1559 glTexCoord
[3] = (float) Rect
->bottom
/ (float) (This
->glRect
.bottom
- This
->glRect
.top
);
1563 #undef GLINFO_LOCATION
1565 /* Hash table functions */
1567 struct hash_table_t
*hash_table_create(hash_function_t
*hash_function
, compare_function_t
*compare_function
)
1569 struct hash_table_t
*table
;
1570 unsigned int initial_size
= 8;
1572 table
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct hash_table_t
) + (initial_size
* sizeof(struct list
)));
1575 ERR("Failed to allocate table, returning NULL.\n");
1579 table
->hash_function
= hash_function
;
1580 table
->compare_function
= compare_function
;
1582 table
->grow_size
= initial_size
- (initial_size
>> 2);
1583 table
->shrink_size
= 0;
1585 table
->buckets
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, initial_size
* sizeof(struct list
));
1586 if (!table
->buckets
)
1588 ERR("Failed to allocate table buckets, returning NULL.\n");
1589 HeapFree(GetProcessHeap(), 0, table
);
1592 table
->bucket_count
= initial_size
;
1594 table
->entries
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, table
->grow_size
* sizeof(struct hash_table_entry_t
));
1595 if (!table
->entries
)
1597 ERR("Failed to allocate table entries, returning NULL.\n");
1598 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1599 HeapFree(GetProcessHeap(), 0, table
);
1602 table
->entry_count
= 0;
1604 list_init(&table
->free_entries
);
1610 void hash_table_destroy(struct hash_table_t
*table
, void (*free_value
)(void *value
, void *cb
), void *cb
)
1614 for (i
= 0; i
< table
->entry_count
; ++i
)
1617 free_value(table
->entries
[i
].value
, cb
);
1619 HeapFree(GetProcessHeap(), 0, table
->entries
[i
].key
);
1622 HeapFree(GetProcessHeap(), 0, table
->entries
);
1623 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1624 HeapFree(GetProcessHeap(), 0, table
);
1627 static inline struct hash_table_entry_t
*hash_table_get_by_idx(struct hash_table_t
*table
, void *key
, unsigned int idx
)
1629 struct hash_table_entry_t
*entry
;
1631 if (table
->buckets
[idx
].next
)
1632 LIST_FOR_EACH_ENTRY(entry
, &(table
->buckets
[idx
]), struct hash_table_entry_t
, entry
)
1633 if (table
->compare_function(entry
->key
, key
)) return entry
;
1638 static BOOL
hash_table_resize(struct hash_table_t
*table
, unsigned int new_bucket_count
)
1640 unsigned int new_entry_count
= 0;
1641 struct hash_table_entry_t
*new_entries
;
1642 struct list
*new_buckets
;
1643 unsigned int grow_size
= new_bucket_count
- (new_bucket_count
>> 2);
1646 new_buckets
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, new_bucket_count
* sizeof(struct list
));
1649 ERR("Failed to allocate new buckets, returning FALSE.\n");
1653 new_entries
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, grow_size
* sizeof(struct hash_table_entry_t
));
1656 ERR("Failed to allocate new entries, returning FALSE.\n");
1657 HeapFree(GetProcessHeap(), 0, new_buckets
);
1661 for (i
= 0; i
< table
->bucket_count
; ++i
)
1663 if (table
->buckets
[i
].next
)
1665 struct hash_table_entry_t
*entry
, *entry2
;
1667 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &table
->buckets
[i
], struct hash_table_entry_t
, entry
)
1670 struct hash_table_entry_t
*new_entry
= new_entries
+ (new_entry_count
++);
1671 *new_entry
= *entry
;
1673 j
= new_entry
->hash
& (new_bucket_count
- 1);
1675 if (!new_buckets
[j
].next
) list_init(&new_buckets
[j
]);
1676 list_add_head(&new_buckets
[j
], &new_entry
->entry
);
1681 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1682 table
->buckets
= new_buckets
;
1684 HeapFree(GetProcessHeap(), 0, table
->entries
);
1685 table
->entries
= new_entries
;
1687 table
->entry_count
= new_entry_count
;
1688 list_init(&table
->free_entries
);
1690 table
->bucket_count
= new_bucket_count
;
1691 table
->grow_size
= grow_size
;
1692 table
->shrink_size
= new_bucket_count
> 8 ? new_bucket_count
>> 2 : 0;
1697 void hash_table_put(struct hash_table_t
*table
, void *key
, void *value
)
1701 struct hash_table_entry_t
*entry
;
1703 hash
= table
->hash_function(key
);
1704 idx
= hash
& (table
->bucket_count
- 1);
1705 entry
= hash_table_get_by_idx(table
, key
, idx
);
1709 HeapFree(GetProcessHeap(), 0, key
);
1710 entry
->value
= value
;
1714 HeapFree(GetProcessHeap(), 0, entry
->key
);
1717 /* Remove the entry */
1718 list_remove(&entry
->entry
);
1719 list_add_head(&table
->free_entries
, &entry
->entry
);
1723 /* Shrink if necessary */
1724 if (table
->count
< table
->shrink_size
) {
1725 if (!hash_table_resize(table
, table
->bucket_count
>> 1))
1727 ERR("Failed to shrink the table...\n");
1737 /* Grow if necessary */
1738 if (table
->count
>= table
->grow_size
)
1740 if (!hash_table_resize(table
, table
->bucket_count
<< 1))
1742 ERR("Failed to grow the table, returning.\n");
1746 idx
= hash
& (table
->bucket_count
- 1);
1749 /* Find an entry to insert */
1750 if (!list_empty(&table
->free_entries
))
1752 struct list
*elem
= list_head(&table
->free_entries
);
1755 entry
= LIST_ENTRY(elem
, struct hash_table_entry_t
, entry
);
1757 entry
= table
->entries
+ (table
->entry_count
++);
1760 /* Insert the entry */
1762 entry
->value
= value
;
1764 if (!table
->buckets
[idx
].next
) list_init(&table
->buckets
[idx
]);
1765 list_add_head(&table
->buckets
[idx
], &entry
->entry
);
1770 void hash_table_remove(struct hash_table_t
*table
, void *key
)
1772 hash_table_put(table
, key
, NULL
);
1775 void *hash_table_get(struct hash_table_t
*table
, void *key
)
1778 struct hash_table_entry_t
*entry
;
1780 idx
= table
->hash_function(key
) & (table
->bucket_count
- 1);
1781 entry
= hash_table_get_by_idx(table
, key
, idx
);
1783 return entry
? entry
->value
: NULL
;
1786 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
1787 void gen_ffp_op(IWineD3DStateBlockImpl
*stateblock
, struct ffp_settings
*settings
, BOOL ignore_textype
) {
1791 static const unsigned char args
[WINED3DTOP_LERP
+ 1] = {
1793 /* D3DTOP_DISABLE */ 0,
1794 /* D3DTOP_SELECTARG1 */ ARG1
,
1795 /* D3DTOP_SELECTARG2 */ ARG2
,
1796 /* D3DTOP_MODULATE */ ARG1
| ARG2
,
1797 /* D3DTOP_MODULATE2X */ ARG1
| ARG2
,
1798 /* D3DTOP_MODULATE4X */ ARG1
| ARG2
,
1799 /* D3DTOP_ADD */ ARG1
| ARG2
,
1800 /* D3DTOP_ADDSIGNED */ ARG1
| ARG2
,
1801 /* D3DTOP_ADDSIGNED2X */ ARG1
| ARG2
,
1802 /* D3DTOP_SUBTRACT */ ARG1
| ARG2
,
1803 /* D3DTOP_ADDSMOOTH */ ARG1
| ARG2
,
1804 /* D3DTOP_BLENDDIFFUSEALPHA */ ARG1
| ARG2
,
1805 /* D3DTOP_BLENDTEXTUREALPHA */ ARG1
| ARG2
,
1806 /* D3DTOP_BLENDFACTORALPHA */ ARG1
| ARG2
,
1807 /* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1
| ARG2
,
1808 /* D3DTOP_BLENDCURRENTALPHA */ ARG1
| ARG2
,
1809 /* D3DTOP_PREMODULATE */ ARG1
| ARG2
,
1810 /* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1
| ARG2
,
1811 /* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1
| ARG2
,
1812 /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1
| ARG2
,
1813 /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1
| ARG2
,
1814 /* D3DTOP_BUMPENVMAP */ ARG1
| ARG2
,
1815 /* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1
| ARG2
,
1816 /* D3DTOP_DOTPRODUCT3 */ ARG1
| ARG2
,
1817 /* D3DTOP_MULTIPLYADD */ ARG1
| ARG2
| ARG0
,
1818 /* D3DTOP_LERP */ ARG1
| ARG2
| ARG0
1822 DWORD cop
, aop
, carg0
, carg1
, carg2
, aarg0
, aarg1
, aarg2
;
1824 for(i
= 0; i
< GL_LIMITS(texture_stages
); i
++) {
1825 IWineD3DBaseTextureImpl
*texture
;
1826 settings
->op
[i
].padding
= 0;
1827 if(stateblock
->textureState
[i
][WINED3DTSS_COLOROP
] == WINED3DTOP_DISABLE
) {
1828 settings
->op
[i
].cop
= WINED3DTOP_DISABLE
;
1829 settings
->op
[i
].aop
= WINED3DTOP_DISABLE
;
1830 settings
->op
[i
].carg0
= settings
->op
[i
].carg1
= settings
->op
[i
].carg2
= ARG_UNUSED
;
1831 settings
->op
[i
].aarg0
= settings
->op
[i
].aarg1
= settings
->op
[i
].aarg2
= ARG_UNUSED
;
1832 settings
->op
[i
].color_correction
= WINED3DFMT_UNKNOWN
;
1833 settings
->op
[i
].dst
= resultreg
;
1834 settings
->op
[i
].tex_type
= tex_1d
;
1835 settings
->op
[i
].projected
= proj_none
;
1840 texture
= (IWineD3DBaseTextureImpl
*) stateblock
->textures
[i
];
1842 settings
->op
[i
].color_correction
= texture
->baseTexture
.shader_conversion_group
;
1843 if(ignore_textype
) {
1844 settings
->op
[i
].tex_type
= tex_1d
;
1846 switch(stateblock
->textureDimensions
[i
]) {
1848 settings
->op
[i
].tex_type
= tex_1d
;
1851 settings
->op
[i
].tex_type
= tex_2d
;
1854 settings
->op
[i
].tex_type
= tex_3d
;
1856 case GL_TEXTURE_CUBE_MAP_ARB
:
1857 settings
->op
[i
].tex_type
= tex_cube
;
1859 case GL_TEXTURE_RECTANGLE_ARB
:
1860 settings
->op
[i
].tex_type
= tex_rect
;
1865 settings
->op
[i
].color_correction
= WINED3DFMT_UNKNOWN
;
1866 settings
->op
[i
].tex_type
= tex_1d
;
1869 cop
= stateblock
->textureState
[i
][WINED3DTSS_COLOROP
];
1870 aop
= stateblock
->textureState
[i
][WINED3DTSS_ALPHAOP
];
1872 carg1
= (args
[cop
] & ARG1
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG1
] : 0xffffffff;
1873 carg2
= (args
[cop
] & ARG2
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG2
] : 0xffffffff;
1874 carg0
= (args
[cop
] & ARG0
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG0
] : 0xffffffff;
1876 if(is_invalid_op(stateblock
->wineD3DDevice
, i
, cop
,
1877 carg1
, carg2
, carg0
)) {
1880 carg1
= WINED3DTA_CURRENT
;
1881 cop
= WINED3DTOP_SELECTARG1
;
1884 if(cop
== WINED3DTOP_DOTPRODUCT3
) {
1885 /* A dotproduct3 on the colorop overwrites the alphaop operation and replicates
1886 * the color result to the alpha component of the destination
1893 aarg1
= (args
[aop
] & ARG1
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG1
] : 0xffffffff;
1894 aarg2
= (args
[aop
] & ARG2
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG2
] : 0xffffffff;
1895 aarg0
= (args
[aop
] & ARG0
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG0
] : 0xffffffff;
1898 if(i
== 0 && stateblock
->textures
[0] &&
1899 stateblock
->renderState
[WINED3DRS_COLORKEYENABLE
] &&
1900 (stateblock
->textureDimensions
[0] == GL_TEXTURE_2D
||
1901 stateblock
->textureDimensions
[0] == GL_TEXTURE_RECTANGLE_ARB
)) {
1902 IWineD3DSurfaceImpl
*surf
= (IWineD3DSurfaceImpl
*) ((IWineD3DTextureImpl
*) stateblock
->textures
[0])->surfaces
[0];
1904 if(surf
->CKeyFlags
& WINEDDSD_CKSRCBLT
&&
1905 getFormatDescEntry(surf
->resource
.format
, NULL
, NULL
)->alphaMask
== 0x00000000) {
1907 if(aop
== WINED3DTOP_DISABLE
) {
1908 aarg1
= WINED3DTA_TEXTURE
;
1909 aop
= WINED3DTOP_SELECTARG1
;
1911 else if(aop
== WINED3DTOP_SELECTARG1
&& aarg1
!= WINED3DTA_TEXTURE
) {
1912 if (stateblock
->renderState
[WINED3DRS_ALPHABLENDENABLE
]) {
1913 aarg2
= WINED3DTA_TEXTURE
;
1914 aop
= WINED3DTOP_MODULATE
;
1916 else aarg1
= WINED3DTA_TEXTURE
;
1918 else if(aop
== WINED3DTOP_SELECTARG2
&& aarg2
!= WINED3DTA_TEXTURE
) {
1919 if (stateblock
->renderState
[WINED3DRS_ALPHABLENDENABLE
]) {
1920 aarg1
= WINED3DTA_TEXTURE
;
1921 aop
= WINED3DTOP_MODULATE
;
1923 else aarg2
= WINED3DTA_TEXTURE
;
1928 if(is_invalid_op(stateblock
->wineD3DDevice
, i
, aop
,
1929 aarg1
, aarg2
, aarg0
)) {
1932 aarg1
= WINED3DTA_CURRENT
;
1933 aop
= WINED3DTOP_SELECTARG1
;
1936 if(carg1
== WINED3DTA_TEXTURE
|| carg2
== WINED3DTA_TEXTURE
|| carg0
== WINED3DTA_TEXTURE
||
1937 aarg1
== WINED3DTA_TEXTURE
|| aarg2
== WINED3DTA_TEXTURE
|| aarg0
== WINED3DTA_TEXTURE
) {
1938 ttff
= stateblock
->textureState
[i
][WINED3DTSS_TEXTURETRANSFORMFLAGS
];
1939 if(ttff
== (WINED3DTTFF_PROJECTED
| WINED3DTTFF_COUNT3
)) {
1940 settings
->op
[i
].projected
= proj_count3
;
1941 } else if(ttff
== (WINED3DTTFF_PROJECTED
| WINED3DTTFF_COUNT4
)) {
1942 settings
->op
[i
].projected
= proj_count4
;
1944 settings
->op
[i
].projected
= proj_none
;
1947 settings
->op
[i
].projected
= proj_none
;
1950 settings
->op
[i
].cop
= cop
;
1951 settings
->op
[i
].aop
= aop
;
1952 settings
->op
[i
].carg0
= carg0
;
1953 settings
->op
[i
].carg1
= carg1
;
1954 settings
->op
[i
].carg2
= carg2
;
1955 settings
->op
[i
].aarg0
= aarg0
;
1956 settings
->op
[i
].aarg1
= aarg1
;
1957 settings
->op
[i
].aarg2
= aarg2
;
1959 if(stateblock
->textureState
[i
][WINED3DTSS_RESULTARG
] == WINED3DTA_TEMP
) {
1960 settings
->op
[i
].dst
= tempreg
;
1962 settings
->op
[i
].dst
= resultreg
;
1966 /* Clear unsupported stages */
1967 for(; i
< MAX_TEXTURES
; i
++) {
1968 memset(&settings
->op
[i
], 0xff, sizeof(settings
->op
[i
]));
1971 if(stateblock
->renderState
[WINED3DRS_FOGENABLE
] == FALSE
) {
1972 settings
->fog
= FOG_OFF
;
1973 } else if(stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
] == WINED3DFOG_NONE
) {
1974 switch(stateblock
->renderState
[WINED3DRS_FOGVERTEXMODE
]) {
1975 case WINED3DFOG_NONE
:
1976 case WINED3DFOG_LINEAR
:
1977 settings
->fog
= FOG_LINEAR
;
1979 case WINED3DFOG_EXP
:
1980 settings
->fog
= FOG_EXP
;
1982 case WINED3DFOG_EXP2
:
1983 settings
->fog
= FOG_EXP2
;
1987 switch(stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
]) {
1988 case WINED3DFOG_LINEAR
:
1989 settings
->fog
= FOG_LINEAR
;
1991 case WINED3DFOG_EXP
:
1992 settings
->fog
= FOG_EXP
;
1994 case WINED3DFOG_EXP2
:
1995 settings
->fog
= FOG_EXP2
;
1999 if(stateblock
->renderState
[WINED3DRS_SRGBWRITEENABLE
]) {
2000 settings
->sRGB_write
= 1;
2002 settings
->sRGB_write
= 0;
2005 #undef GLINFO_LOCATION
2007 struct ffp_desc
*find_ffp_shader(struct hash_table_t
*fragment_shaders
, struct ffp_settings
*settings
)
2009 return (struct ffp_desc
*)hash_table_get(fragment_shaders
, settings
);}
2011 void add_ffp_shader(struct hash_table_t
*shaders
, struct ffp_desc
*desc
) {
2012 struct ffp_settings
*key
= HeapAlloc(GetProcessHeap(), 0, sizeof(*key
));
2013 /* Note that the key is the implementation independent part of the ffp_desc structure,
2014 * whereas desc points to an extended structure with implementation specific parts.
2015 * Make a copy of the key because hash_table_put takes ownership of it
2017 *key
= desc
->settings
;
2018 hash_table_put(shaders
, key
, desc
);
2021 /* Activates the texture dimension according to the bound D3D texture.
2022 * Does not care for the colorop or correct gl texture unit(when using nvrc)
2023 * Requires the caller to activate the correct unit before
2025 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
2026 void texture_activate_dimensions(DWORD stage
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
2027 if(stateblock
->textures
[stage
]) {
2028 switch(stateblock
->textureDimensions
[stage
]) {
2030 glDisable(GL_TEXTURE_3D
);
2031 checkGLcall("glDisable(GL_TEXTURE_3D)");
2032 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2033 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2034 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2036 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2037 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2038 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2040 glEnable(GL_TEXTURE_2D
);
2041 checkGLcall("glEnable(GL_TEXTURE_2D)");
2043 case GL_TEXTURE_RECTANGLE_ARB
:
2044 glDisable(GL_TEXTURE_2D
);
2045 checkGLcall("glDisable(GL_TEXTURE_2D)");
2046 glDisable(GL_TEXTURE_3D
);
2047 checkGLcall("glDisable(GL_TEXTURE_3D)");
2048 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2049 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2050 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2052 glEnable(GL_TEXTURE_RECTANGLE_ARB
);
2053 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2056 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2057 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2058 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2060 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2061 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2062 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2064 glDisable(GL_TEXTURE_2D
);
2065 checkGLcall("glDisable(GL_TEXTURE_2D)");
2066 glEnable(GL_TEXTURE_3D
);
2067 checkGLcall("glEnable(GL_TEXTURE_3D)");
2069 case GL_TEXTURE_CUBE_MAP_ARB
:
2070 glDisable(GL_TEXTURE_2D
);
2071 checkGLcall("glDisable(GL_TEXTURE_2D)");
2072 glDisable(GL_TEXTURE_3D
);
2073 checkGLcall("glDisable(GL_TEXTURE_3D)");
2074 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2075 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2076 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2078 glEnable(GL_TEXTURE_CUBE_MAP_ARB
);
2079 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2083 glEnable(GL_TEXTURE_2D
);
2084 checkGLcall("glEnable(GL_TEXTURE_2D)");
2085 glDisable(GL_TEXTURE_3D
);
2086 checkGLcall("glDisable(GL_TEXTURE_3D)");
2087 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2088 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2089 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2091 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2092 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2093 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2095 /* Binding textures is done by samplers. A dummy texture will be bound */
2099 void sampler_texdim(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
2100 DWORD sampler
= state
- STATE_SAMPLER(0);
2101 DWORD mapped_stage
= stateblock
->wineD3DDevice
->texUnitMap
[sampler
];
2103 /* No need to enable / disable anything here for unused samplers. The tex_colorop
2104 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
2105 * will take care of this business
2107 if(mapped_stage
== -1 || mapped_stage
>= GL_LIMITS(textures
)) return;
2108 if(sampler
>= stateblock
->lowest_disabled_stage
) return;
2109 if(isStateDirty(context
, STATE_TEXTURESTAGE(sampler
, WINED3DTSS_COLOROP
))) return;
2111 texture_activate_dimensions(sampler
, stateblock
, context
);
2113 #undef GLINFO_LOCATION
2115 unsigned int ffp_program_key_hash(void *key
) {
2116 struct ffp_settings
*k
= (struct ffp_settings
*)key
;
2117 unsigned int hash
= 0, i
;
2120 /* This takes the texture op settings of stage 0 and 1 into account.
2121 * how exactly depends on the memory laybout of the compiler, but it
2122 * should not matter too much. Stages > 1 are used rarely, so there's
2123 * no need to process them. Even if they're used it is likely that
2124 * the ffp setup has distinct stage 0 and 1 settings.
2126 for(i
= 0; i
< 2; i
++) {
2127 blob
= (DWORD
*) &k
->op
[i
];
2128 hash
^= blob
[0] ^ blob
[1];
2131 hash
+= ~(hash
<< 15);
2132 hash
^= (hash
>> 10);
2133 hash
+= (hash
<< 3);
2134 hash
^= (hash
>> 6);
2135 hash
+= ~(hash
<< 11);
2136 hash
^= (hash
>> 16);
2141 BOOL
ffp_program_key_compare(void *keya
, void *keyb
) {
2142 struct ffp_settings
*ka
= (struct ffp_settings
*)keya
;
2143 struct ffp_settings
*kb
= (struct ffp_settings
*)keyb
;
2145 return memcmp(ka
, kb
, sizeof(*ka
)) == 0;