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-2007 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 ,1/*?*/ ,0 ,0 ,TRUE
},
46 {WINED3DFMT_YUY2
,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,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
},
121 GLint glInternal
, glGammaInternal
, rtInternal
, glFormat
, glType
;
123 } GlPixelFormatDescTemplate
;
125 /*****************************************************************************
126 * OpenGL format template. Contains unexciting formats which do not need
127 * extension checks. The order in this table is independent of the order in
128 * the table StaticPixelFormatDesc above. Not all formats have to be in this
131 static const GlPixelFormatDescTemplate gl_formats_template
[] = {
132 /*{ internal ,srgbInternal , rtInternal, format ,type \
134 {WINED3DFMT_UNKNOWN
,0 ,0 , 0, 0 ,0
137 {WINED3DFMT_UYVY
,0 ,0 , 0, 0 ,0
139 {WINED3DFMT_YUY2
,0 ,0 , 0, 0 ,0
141 {WINED3DFMT_DXT1
,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
, 0, GL_RGBA
,GL_UNSIGNED_BYTE
142 ,WINED3DFMT_FLAG_FILTERING
},
143 {WINED3DFMT_DXT2
,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
, 0, GL_RGBA
,GL_UNSIGNED_BYTE
144 ,WINED3DFMT_FLAG_FILTERING
},
145 {WINED3DFMT_DXT3
,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
, 0, GL_RGBA
,GL_UNSIGNED_BYTE
146 ,WINED3DFMT_FLAG_FILTERING
},
147 {WINED3DFMT_DXT4
,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
, 0, GL_RGBA
,GL_UNSIGNED_BYTE
148 ,WINED3DFMT_FLAG_FILTERING
},
149 {WINED3DFMT_DXT5
,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
, 0, GL_RGBA
,GL_UNSIGNED_BYTE
150 ,WINED3DFMT_FLAG_FILTERING
},
151 {WINED3DFMT_MULTI2_ARGB8
,0 ,0 , 0, 0 ,0
153 {WINED3DFMT_G8R8_G8B8
,0 ,0 , 0, 0 ,0
155 {WINED3DFMT_R8G8_B8G8
,0 ,0 , 0, 0 ,0
158 {WINED3DFMT_R32F
,GL_RGB32F_ARB
,GL_RGB32F_ARB
, 0, GL_RED
,GL_FLOAT
159 ,WINED3DFMT_FLAG_RENDERTARGET
},
160 {WINED3DFMT_G32R32F
,0 ,0 , 0, 0 ,0
161 ,WINED3DFMT_FLAG_RENDERTARGET
},
162 {WINED3DFMT_A32B32G32R32F
,GL_RGBA32F_ARB
,GL_RGBA32F_ARB
, 0, GL_RGBA
,GL_FLOAT
163 ,WINED3DFMT_FLAG_RENDERTARGET
},
165 {WINED3DFMT_CxV8U8
,0 ,0 , 0, 0 ,0
168 {WINED3DFMT_R16F
,GL_RGB16F_ARB
,GL_RGB16F_ARB
, 0, GL_RED
,GL_HALF_FLOAT_ARB
169 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
170 {WINED3DFMT_G16R16F
,0 ,0 , 0, 0 ,0
171 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
172 {WINED3DFMT_A16B16G16R16F
,GL_RGBA16F_ARB
,GL_RGBA16F_ARB
, 0, GL_RGBA
,GL_HALF_FLOAT_ARB
173 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
174 /* Palettized formats */
175 {WINED3DFMT_A8P8
, 0 ,0 , 0, 0 ,0
177 {WINED3DFMT_P8
, GL_COLOR_INDEX8_EXT
,GL_COLOR_INDEX8_EXT
, 0, GL_COLOR_INDEX
,GL_UNSIGNED_BYTE
179 /* Standard ARGB formats */
180 {WINED3DFMT_R8G8B8
,GL_RGB8
,GL_RGB8
, 0, GL_BGR
,GL_UNSIGNED_BYTE
181 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
182 {WINED3DFMT_A8R8G8B8
,GL_RGBA8
,GL_SRGB8_ALPHA8_EXT
, 0, GL_BGRA
,GL_UNSIGNED_INT_8_8_8_8_REV
183 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
184 {WINED3DFMT_X8R8G8B8
,GL_RGB8
,GL_SRGB8_EXT
, 0, GL_BGRA
,GL_UNSIGNED_INT_8_8_8_8_REV
185 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
186 {WINED3DFMT_R5G6B5
,GL_RGB5
,GL_RGB5
, GL_RGB8
, GL_RGB
,GL_UNSIGNED_SHORT_5_6_5
187 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
188 {WINED3DFMT_X1R5G5B5
,GL_RGB5
,GL_RGB5_A1
, 0, GL_BGRA
,GL_UNSIGNED_SHORT_1_5_5_5_REV
189 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
190 {WINED3DFMT_A1R5G5B5
,GL_RGB5_A1
,GL_RGB5_A1
, 0, GL_BGRA
,GL_UNSIGNED_SHORT_1_5_5_5_REV
191 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
192 {WINED3DFMT_A4R4G4B4
,GL_RGBA4
,GL_SRGB8_ALPHA8_EXT
, 0, GL_BGRA
,GL_UNSIGNED_SHORT_4_4_4_4_REV
193 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
194 {WINED3DFMT_R3G3B2
,GL_R3_G3_B2
,GL_R3_G3_B2
, 0, GL_RGB
,GL_UNSIGNED_BYTE_3_3_2
195 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
},
196 {WINED3DFMT_A8
,GL_ALPHA8
,GL_ALPHA8
, 0, GL_ALPHA
,GL_UNSIGNED_BYTE
197 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
},
198 {WINED3DFMT_A8R3G3B2
,0 ,0 , 0, 0 ,0
200 {WINED3DFMT_X4R4G4B4
,GL_RGB4
,GL_RGB4
, 0, GL_BGRA
,GL_UNSIGNED_SHORT_4_4_4_4_REV
201 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
202 {WINED3DFMT_A2B10G10R10
,GL_RGBA
,GL_RGBA
, 0, GL_RGBA
,GL_UNSIGNED_INT_2_10_10_10_REV
203 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
204 {WINED3DFMT_A8B8G8R8
,GL_RGBA8
,GL_RGBA8
, 0, GL_RGBA
,GL_UNSIGNED_INT_8_8_8_8_REV
205 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
206 {WINED3DFMT_X8B8G8R8
,GL_RGB8
,GL_RGB8
, 0, GL_RGBA
,GL_UNSIGNED_INT_8_8_8_8_REV
207 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
208 {WINED3DFMT_G16R16
,GL_RGB16_EXT
,GL_RGB16_EXT
, 0, GL_RGB
,GL_UNSIGNED_SHORT
209 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
210 {WINED3DFMT_A2R10G10B10
,GL_RGBA
,GL_RGBA
, 0, GL_BGRA
,GL_UNSIGNED_INT_2_10_10_10_REV
211 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
},
212 {WINED3DFMT_A16B16G16R16
,GL_RGBA16_EXT
,GL_RGBA16_EXT
, 0, GL_RGBA
,GL_UNSIGNED_SHORT
213 ,WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
| WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_RENDERTARGET
},
215 {WINED3DFMT_L8
,GL_LUMINANCE8
,GL_SLUMINANCE8_EXT
, 0, GL_LUMINANCE
,GL_UNSIGNED_BYTE
216 ,WINED3DFMT_FLAG_FILTERING
},
217 {WINED3DFMT_A8L8
,GL_LUMINANCE8_ALPHA8
,GL_SLUMINANCE8_ALPHA8_EXT
, 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
218 ,WINED3DFMT_FLAG_FILTERING
},
219 {WINED3DFMT_A4L4
,GL_LUMINANCE4_ALPHA4
,GL_LUMINANCE4_ALPHA4
, 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
221 /* Bump mapping stuff */
222 {WINED3DFMT_V8U8
,GL_DSDT8_NV
,GL_DSDT8_NV
, 0, GL_DSDT_NV
,GL_BYTE
223 ,WINED3DFMT_FLAG_FILTERING
},
224 {WINED3DFMT_L6V5U5
,GL_DSDT8_MAG8_NV
,GL_DSDT8_MAG8_NV
, 0, GL_DSDT_MAG_NV
,GL_BYTE
225 ,WINED3DFMT_FLAG_FILTERING
},
226 {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
227 ,WINED3DFMT_FLAG_FILTERING
},
228 {WINED3DFMT_Q8W8V8U8
,GL_SIGNED_RGBA8_NV
,GL_SIGNED_RGBA8_NV
, 0, GL_RGBA
,GL_BYTE
229 ,WINED3DFMT_FLAG_FILTERING
},
230 {WINED3DFMT_V16U16
,GL_SIGNED_HILO16_NV
,GL_SIGNED_HILO16_NV
, 0, GL_HILO_NV
,GL_SHORT
231 ,WINED3DFMT_FLAG_FILTERING
},
232 {WINED3DFMT_W11V11U10
,0 ,0 , 0, 0 ,0
234 {WINED3DFMT_A2W10V10U10
,0 ,0 , 0, 0 ,0
236 /* Depth stencil formats */
237 {WINED3DFMT_D16_LOCKABLE
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_SHORT
238 ,WINED3DFMT_FLAG_DEPTH
},
239 {WINED3DFMT_D32
,GL_DEPTH_COMPONENT32_ARB
,GL_DEPTH_COMPONENT32_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_INT
240 ,WINED3DFMT_FLAG_DEPTH
},
241 {WINED3DFMT_D15S1
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_SHORT
242 ,WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
},
243 {WINED3DFMT_D24S8
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_INT
244 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
},
245 {WINED3DFMT_D24X8
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_INT
246 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_DEPTH
},
247 {WINED3DFMT_D24X4S4
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_INT
248 ,WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
},
249 {WINED3DFMT_D16
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_UNSIGNED_SHORT
250 ,WINED3DFMT_FLAG_FILTERING
| WINED3DFMT_FLAG_DEPTH
},
251 {WINED3DFMT_L16
,GL_LUMINANCE16_EXT
,GL_LUMINANCE16_EXT
, 0, GL_LUMINANCE
,GL_UNSIGNED_SHORT
252 ,WINED3DFMT_FLAG_FILTERING
},
253 {WINED3DFMT_D32F_LOCKABLE
,GL_DEPTH_COMPONENT32_ARB
,GL_DEPTH_COMPONENT32_ARB
, 0, GL_DEPTH_COMPONENT
,GL_FLOAT
254 ,WINED3DFMT_FLAG_DEPTH
},
255 {WINED3DFMT_D24FS8
,GL_DEPTH_COMPONENT24_ARB
,GL_DEPTH_COMPONENT24_ARB
, 0, GL_DEPTH_COMPONENT
,GL_FLOAT
256 ,WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
},
257 /* Is this a vertex buffer? */
258 {WINED3DFMT_VERTEXDATA
,0 ,0 , 0, 0 ,0
260 {WINED3DFMT_INDEX16
,0 ,0 , 0, 0 ,0
262 {WINED3DFMT_INDEX32
,0 ,0 , 0, 0 ,0
264 {WINED3DFMT_Q16W16V16U16
,GL_COLOR_INDEX
,GL_COLOR_INDEX
, 0, GL_COLOR_INDEX
,GL_UNSIGNED_SHORT
266 /* Vendor-specific formats */
267 {WINED3DFMT_ATI2N
,0 ,0 , 0, GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
271 static inline int getFmtIdx(WINED3DFORMAT fmt
) {
272 /* First check if the format is at the position of its value.
273 * This will catch the argb formats before the loop is entered
275 if(fmt
< (sizeof(formats
) / sizeof(formats
[0])) && formats
[fmt
].format
== fmt
) {
279 for(i
= 0; i
< (sizeof(formats
) / sizeof(formats
[0])); i
++) {
280 if(formats
[i
].format
== fmt
) {
288 #define GLINFO_LOCATION (*gl_info)
289 BOOL
initPixelFormats(WineD3D_GL_Info
*gl_info
)
294 gl_info
->gl_formats
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
295 sizeof(formats
) / sizeof(formats
[0]) * sizeof(gl_info
->gl_formats
[0]));
296 if(!gl_info
->gl_formats
) return FALSE
;
298 /* If a format depends on some extensions, remove them from the table above and initialize them
301 for(src
= 0; src
< sizeof(gl_formats_template
) / sizeof(gl_formats_template
[0]); src
++) {
302 dst
= getFmtIdx(gl_formats_template
[src
].fmt
);
303 gl_info
->gl_formats
[dst
].glInternal
= gl_formats_template
[src
].glInternal
;
304 gl_info
->gl_formats
[dst
].glGammaInternal
= gl_formats_template
[src
].glGammaInternal
;
305 gl_info
->gl_formats
[dst
].glFormat
= gl_formats_template
[src
].glFormat
;
306 gl_info
->gl_formats
[dst
].glType
= gl_formats_template
[src
].glType
;
307 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_UNKNOWN
;
308 gl_info
->gl_formats
[dst
].Flags
= gl_formats_template
[src
].Flags
;
310 if(wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&&
311 gl_formats_template
[src
].rtInternal
!= 0) {
315 /* Check if the default internal format is supported as a frame buffer target, otherwise
316 * fall back to the render target internal.
318 * Try to stick to the standard format if possible, this limits precision differences
321 glGenTextures(1, &tex
);
322 glBindTexture(GL_TEXTURE_2D
, tex
);
323 glTexImage2D(GL_TEXTURE_2D
, 0, gl_formats_template
[src
].glInternal
, 16, 16, 0,
324 GL_RGBA
, GL_UNSIGNED_BYTE
, NULL
);
326 GL_EXTCALL(glGenFramebuffersEXT(1, &fb
));
327 GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT
, fb
));
328 GL_EXTCALL(glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT
, GL_COLOR_ATTACHMENT0_EXT
,
329 GL_TEXTURE_2D
, tex
, 0));
331 status
= GL_EXTCALL(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT
));
332 GL_EXTCALL(glDeleteFramebuffersEXT(1, &fb
));
333 glDeleteTextures(1, &tex
);
335 checkGLcall("Framebuffer format check");
337 if(status
!= GL_FRAMEBUFFER_COMPLETE_EXT
) {
338 TRACE("Internal format of %s not supported as frame buffer target, using render target internal instead\n",
339 debug_d3dformat(gl_formats_template
[src
].fmt
));
340 gl_info
->gl_formats
[dst
].rtInternal
= gl_formats_template
[src
].rtInternal
;
342 TRACE("Format %s is supported as fbo target\n", debug_d3dformat(gl_formats_template
[src
].fmt
));
343 gl_info
->gl_formats
[dst
].rtInternal
= gl_formats_template
[src
].glInternal
;
347 gl_info
->gl_formats
[dst
].rtInternal
= gl_formats_template
[src
].glInternal
;
351 /* V8U8 is supported natively by GL_ATI_envmap_bumpmap and GL_NV_texture_shader.
352 * V16U16 is only supported by GL_NV_texture_shader. The formats need fixup if
353 * their extensions are not available.
355 * In theory, V8U8 and V16U16 need a fixup of the undefined blue channel. OpenGL
356 * returns 0.0 when sampling from it, DirectX 1.0. This is disabled until we find
357 * an application that needs this because it causes performance problems due to
358 * shader recompiling in some games.
360 if(!GL_SUPPORT(ATI_ENVMAP_BUMPMAP
) && !GL_SUPPORT(NV_TEXTURE_SHADER2
)) {
361 /* signed -> unsigned fixup */
362 dst
= getFmtIdx(WINED3DFMT_V8U8
);
363 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
364 dst
= getFmtIdx(WINED3DFMT_V16U16
);
365 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
366 } else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
367 /* signed -> unsigned fixup */
368 dst
= getFmtIdx(WINED3DFMT_V16U16
);
369 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V16U16
;
371 /* Blue = 1.0 fixup, disabled for now */
373 dst
= getFmtIdx(WINED3DFMT_V8U8
);
374 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
375 dst
= getFmtIdx(WINED3DFMT_V16U16
);
376 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_V8U8
;
380 if(!GL_SUPPORT(NV_TEXTURE_SHADER
)) {
381 /* If GL_NV_texture_shader is not supported, those formats are converted, incompatibly
384 dst
= getFmtIdx(WINED3DFMT_L6V5U5
);
385 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_L6V5U5
;
386 dst
= getFmtIdx(WINED3DFMT_X8L8V8U8
);
387 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_X8L8V8U8
;
388 dst
= getFmtIdx(WINED3DFMT_Q8W8V8U8
);
389 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_Q8W8V8U8
;
391 /* If GL_NV_texture_shader is supported, WINED3DFMT_L6V5U5 and WINED3DFMT_X8L8V8U8
392 * are converted at surface loading time, but they do not need any modification in
393 * the shader, thus they are compatible with all WINED3DFMT_UNKNOWN group formats.
394 * WINED3DFMT_Q8W8V8U8 doesn't even need load-time conversion
398 if(GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC
)) {
399 dst
= getFmtIdx(WINED3DFMT_ATI2N
);
400 gl_info
->gl_formats
[dst
].glInternal
= GL_COMPRESSED_RED_GREEN_RGTC2_EXT
;
401 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_COMPRESSED_RED_GREEN_RGTC2_EXT
;
402 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_ATI2N
;
403 } else if(GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC
)) {
404 dst
= getFmtIdx(WINED3DFMT_ATI2N
);
405 gl_info
->gl_formats
[dst
].glInternal
= GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI
;
406 gl_info
->gl_formats
[dst
].glGammaInternal
= GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI
;
407 gl_info
->gl_formats
[dst
].conversion_group
= WINED3DFMT_ATI2N
;
413 /* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
414 static WINED3DGLTYPE
const glTypeLookupTemplate
[WINED3DDECLTYPE_UNUSED
] = {
415 {WINED3DDECLTYPE_FLOAT1
, 1, GL_FLOAT
, GL_FALSE
,sizeof(float)},
416 {WINED3DDECLTYPE_FLOAT2
, 2, GL_FLOAT
, GL_FALSE
,sizeof(float)},
417 {WINED3DDECLTYPE_FLOAT3
, 3, GL_FLOAT
, GL_FALSE
,sizeof(float)},
418 {WINED3DDECLTYPE_FLOAT4
, 4, GL_FLOAT
, GL_FALSE
,sizeof(float)},
419 {WINED3DDECLTYPE_D3DCOLOR
, 4, GL_UNSIGNED_BYTE
, GL_TRUE
,sizeof(BYTE
)},
420 {WINED3DDECLTYPE_UBYTE4
, 4, GL_UNSIGNED_BYTE
, GL_FALSE
,sizeof(BYTE
)},
421 {WINED3DDECLTYPE_SHORT2
, 2, GL_SHORT
, GL_FALSE
,sizeof(short int)},
422 {WINED3DDECLTYPE_SHORT4
, 4, GL_SHORT
, GL_FALSE
,sizeof(short int)},
423 {WINED3DDECLTYPE_UBYTE4N
, 4, GL_UNSIGNED_BYTE
, GL_TRUE
,sizeof(BYTE
)},
424 {WINED3DDECLTYPE_SHORT2N
, 2, GL_SHORT
, GL_TRUE
,sizeof(short int)},
425 {WINED3DDECLTYPE_SHORT4N
, 4, GL_SHORT
, GL_TRUE
,sizeof(short int)},
426 {WINED3DDECLTYPE_USHORT2N
, 2, GL_UNSIGNED_SHORT
, GL_TRUE
,sizeof(short int)},
427 {WINED3DDECLTYPE_USHORT4N
, 4, GL_UNSIGNED_SHORT
, GL_TRUE
,sizeof(short int)},
428 {WINED3DDECLTYPE_UDEC3
, 3, GL_UNSIGNED_SHORT
, GL_FALSE
,sizeof(short int)},
429 {WINED3DDECLTYPE_DEC3N
, 3, GL_SHORT
, GL_TRUE
,sizeof(short int)},
430 {WINED3DDECLTYPE_FLOAT16_2
, 2, GL_HALF_FLOAT_NV
, GL_FALSE
,sizeof(GLhalfNV
)},
431 {WINED3DDECLTYPE_FLOAT16_4
, 4, GL_HALF_FLOAT_NV
, GL_FALSE
,sizeof(GLhalfNV
)}};
433 void init_type_lookup(WineD3D_GL_Info
*gl_info
) {
434 memcpy(gl_info
->glTypeLookup
, glTypeLookupTemplate
, sizeof(glTypeLookupTemplate
));
435 if(!GL_SUPPORT(NV_HALF_FLOAT
)) {
436 /* Do not change the size of the type, it is CPU side. We have to change the GPU-side information though.
437 * It is the job of the vertex buffer code to make sure that the vbos have the right format
439 gl_info
->glTypeLookup
[WINED3DDECLTYPE_FLOAT16_2
].glType
= GL_FLOAT
;
440 gl_info
->glTypeLookup
[WINED3DDECLTYPE_FLOAT16_4
].glType
= GL_FLOAT
;
444 #undef GLINFO_LOCATION
446 #define GLINFO_LOCATION This->adapter->gl_info
448 const StaticPixelFormatDesc
*getFormatDescEntry(WINED3DFORMAT fmt
, WineD3D_GL_Info
*gl_info
, const GlPixelFormatDesc
**glDesc
)
450 int idx
= getFmtIdx(fmt
);
453 FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt
), fmt
);
454 /* Get the caller a valid pointer */
455 idx
= getFmtIdx(WINED3DFMT_UNKNOWN
);
458 if(!gl_info
->gl_formats
) {
459 /* If we do not have gl format information, provide a dummy NULL format. This is an easy way to make
460 * all gl caps check return "unsupported" than catching the lack of gl all over the code. ANSI C requires
461 * static variables to be initialized to 0.
463 static const GlPixelFormatDesc dummyFmt
;
466 *glDesc
= &gl_info
->gl_formats
[idx
];
469 return &formats
[idx
];
472 /*****************************************************************************
473 * Trace formatting of useful values
475 const char* debug_d3dformat(WINED3DFORMAT fmt
) {
477 #define FMT_TO_STR(fmt) case fmt: return #fmt
478 FMT_TO_STR(WINED3DFMT_UNKNOWN
);
479 FMT_TO_STR(WINED3DFMT_R8G8B8
);
480 FMT_TO_STR(WINED3DFMT_A8R8G8B8
);
481 FMT_TO_STR(WINED3DFMT_X8R8G8B8
);
482 FMT_TO_STR(WINED3DFMT_R5G6B5
);
483 FMT_TO_STR(WINED3DFMT_X1R5G5B5
);
484 FMT_TO_STR(WINED3DFMT_A1R5G5B5
);
485 FMT_TO_STR(WINED3DFMT_A4R4G4B4
);
486 FMT_TO_STR(WINED3DFMT_R3G3B2
);
487 FMT_TO_STR(WINED3DFMT_A8
);
488 FMT_TO_STR(WINED3DFMT_A8R3G3B2
);
489 FMT_TO_STR(WINED3DFMT_X4R4G4B4
);
490 FMT_TO_STR(WINED3DFMT_A2B10G10R10
);
491 FMT_TO_STR(WINED3DFMT_A8B8G8R8
);
492 FMT_TO_STR(WINED3DFMT_X8B8G8R8
);
493 FMT_TO_STR(WINED3DFMT_G16R16
);
494 FMT_TO_STR(WINED3DFMT_A2R10G10B10
);
495 FMT_TO_STR(WINED3DFMT_A16B16G16R16
);
496 FMT_TO_STR(WINED3DFMT_A8P8
);
497 FMT_TO_STR(WINED3DFMT_P8
);
498 FMT_TO_STR(WINED3DFMT_L8
);
499 FMT_TO_STR(WINED3DFMT_A8L8
);
500 FMT_TO_STR(WINED3DFMT_A4L4
);
501 FMT_TO_STR(WINED3DFMT_V8U8
);
502 FMT_TO_STR(WINED3DFMT_L6V5U5
);
503 FMT_TO_STR(WINED3DFMT_X8L8V8U8
);
504 FMT_TO_STR(WINED3DFMT_Q8W8V8U8
);
505 FMT_TO_STR(WINED3DFMT_V16U16
);
506 FMT_TO_STR(WINED3DFMT_W11V11U10
);
507 FMT_TO_STR(WINED3DFMT_A2W10V10U10
);
508 FMT_TO_STR(WINED3DFMT_UYVY
);
509 FMT_TO_STR(WINED3DFMT_YUY2
);
510 FMT_TO_STR(WINED3DFMT_DXT1
);
511 FMT_TO_STR(WINED3DFMT_DXT2
);
512 FMT_TO_STR(WINED3DFMT_DXT3
);
513 FMT_TO_STR(WINED3DFMT_DXT4
);
514 FMT_TO_STR(WINED3DFMT_DXT5
);
515 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB8
);
516 FMT_TO_STR(WINED3DFMT_G8R8_G8B8
);
517 FMT_TO_STR(WINED3DFMT_R8G8_B8G8
);
518 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE
);
519 FMT_TO_STR(WINED3DFMT_D32
);
520 FMT_TO_STR(WINED3DFMT_D15S1
);
521 FMT_TO_STR(WINED3DFMT_D24S8
);
522 FMT_TO_STR(WINED3DFMT_D24X8
);
523 FMT_TO_STR(WINED3DFMT_D24X4S4
);
524 FMT_TO_STR(WINED3DFMT_D16
);
525 FMT_TO_STR(WINED3DFMT_L16
);
526 FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE
);
527 FMT_TO_STR(WINED3DFMT_D24FS8
);
528 FMT_TO_STR(WINED3DFMT_VERTEXDATA
);
529 FMT_TO_STR(WINED3DFMT_INDEX16
);
530 FMT_TO_STR(WINED3DFMT_INDEX32
);
531 FMT_TO_STR(WINED3DFMT_Q16W16V16U16
);
532 FMT_TO_STR(WINED3DFMT_R16F
);
533 FMT_TO_STR(WINED3DFMT_G16R16F
);
534 FMT_TO_STR(WINED3DFMT_A16B16G16R16F
);
535 FMT_TO_STR(WINED3DFMT_R32F
);
536 FMT_TO_STR(WINED3DFMT_G32R32F
);
537 FMT_TO_STR(WINED3DFMT_A32B32G32R32F
);
538 FMT_TO_STR(WINED3DFMT_CxV8U8
);
539 FMT_TO_STR(WINED3DFMT_ATI2N
);
544 fourcc
[0] = (char)(fmt
);
545 fourcc
[1] = (char)(fmt
>> 8);
546 fourcc
[2] = (char)(fmt
>> 16);
547 fourcc
[3] = (char)(fmt
>> 24);
549 if( isprint(fourcc
[0]) && isprint(fourcc
[1]) && isprint(fourcc
[2]) && isprint(fourcc
[3]) )
550 FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt
, fourcc
);
552 FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt
);
554 return "unrecognized";
558 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype
) {
560 #define DEVTYPE_TO_STR(dev) case dev: return #dev
561 DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL
);
562 DEVTYPE_TO_STR(WINED3DDEVTYPE_REF
);
563 DEVTYPE_TO_STR(WINED3DDEVTYPE_SW
);
564 #undef DEVTYPE_TO_STR
566 FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype
);
567 return "unrecognized";
571 const char* debug_d3dusage(DWORD usage
) {
572 switch (usage
& WINED3DUSAGE_MASK
) {
573 #define WINED3DUSAGE_TO_STR(u) case u: return #u
574 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET
);
575 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL
);
576 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY
);
577 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING
);
578 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP
);
579 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS
);
580 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES
);
581 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES
);
582 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC
);
583 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP
);
584 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP
);
585 #undef WINED3DUSAGE_TO_STR
586 case 0: return "none";
588 FIXME("Unrecognized %u Usage!\n", usage
);
589 return "unrecognized";
593 const char* debug_d3dusagequery(DWORD usagequery
) {
594 switch (usagequery
& WINED3DUSAGE_QUERY_MASK
) {
595 #define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
596 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER
);
597 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP
);
598 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
);
599 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD
);
600 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE
);
601 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE
);
602 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP
);
603 #undef WINED3DUSAGEQUERY_TO_STR
604 case 0: return "none";
606 FIXME("Unrecognized %u Usage Query!\n", usagequery
);
607 return "unrecognized";
611 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method
) {
613 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
614 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT
);
615 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU
);
616 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV
);
617 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV
);
618 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV
);
619 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP
);
620 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED
);
621 #undef WINED3DDECLMETHOD_TO_STR
623 FIXME("Unrecognized %u declaration method!\n", method
);
624 return "unrecognized";
628 const char* debug_d3ddecltype(WINED3DDECLTYPE type
) {
630 #define WINED3DDECLTYPE_TO_STR(u) case u: return #u
631 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT1
);
632 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT2
);
633 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT3
);
634 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT4
);
635 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_D3DCOLOR
);
636 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4
);
637 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2
);
638 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4
);
639 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4N
);
640 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2N
);
641 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4N
);
642 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT2N
);
643 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT4N
);
644 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UDEC3
);
645 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_DEC3N
);
646 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_2
);
647 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_4
);
648 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UNUSED
);
649 #undef WINED3DDECLTYPE_TO_STR
651 FIXME("Unrecognized %u declaration type!\n", type
);
652 return "unrecognized";
656 const char* debug_d3ddeclusage(BYTE usage
) {
658 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
659 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION
);
660 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT
);
661 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES
);
662 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL
);
663 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE
);
664 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD
);
665 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT
);
666 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL
);
667 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR
);
668 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT
);
669 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR
);
670 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG
);
671 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH
);
672 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE
);
673 #undef WINED3DDECLUSAGE_TO_STR
675 FIXME("Unrecognized %u declaration usage!\n", usage
);
676 return "unrecognized";
680 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res
) {
682 #define RES_TO_STR(res) case res: return #res;
683 RES_TO_STR(WINED3DRTYPE_SURFACE
);
684 RES_TO_STR(WINED3DRTYPE_VOLUME
);
685 RES_TO_STR(WINED3DRTYPE_TEXTURE
);
686 RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE
);
687 RES_TO_STR(WINED3DRTYPE_CUBETEXTURE
);
688 RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER
);
689 RES_TO_STR(WINED3DRTYPE_INDEXBUFFER
);
692 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res
);
693 return "unrecognized";
697 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType
) {
698 switch (PrimitiveType
) {
699 #define PRIM_TO_STR(prim) case prim: return #prim;
700 PRIM_TO_STR(WINED3DPT_POINTLIST
);
701 PRIM_TO_STR(WINED3DPT_LINELIST
);
702 PRIM_TO_STR(WINED3DPT_LINESTRIP
);
703 PRIM_TO_STR(WINED3DPT_TRIANGLELIST
);
704 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP
);
705 PRIM_TO_STR(WINED3DPT_TRIANGLEFAN
);
708 FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType
);
709 return "unrecognized";
713 const char* debug_d3drenderstate(DWORD state
) {
715 #define D3DSTATE_TO_STR(u) case u: return #u
716 D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE
);
717 D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS
);
718 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS
);
719 D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE
);
720 D3DSTATE_TO_STR(WINED3DRS_WRAPU
);
721 D3DSTATE_TO_STR(WINED3DRS_WRAPV
);
722 D3DSTATE_TO_STR(WINED3DRS_ZENABLE
);
723 D3DSTATE_TO_STR(WINED3DRS_FILLMODE
);
724 D3DSTATE_TO_STR(WINED3DRS_SHADEMODE
);
725 D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN
);
726 D3DSTATE_TO_STR(WINED3DRS_MONOENABLE
);
727 D3DSTATE_TO_STR(WINED3DRS_ROP2
);
728 D3DSTATE_TO_STR(WINED3DRS_PLANEMASK
);
729 D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE
);
730 D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE
);
731 D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL
);
732 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG
);
733 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN
);
734 D3DSTATE_TO_STR(WINED3DRS_SRCBLEND
);
735 D3DSTATE_TO_STR(WINED3DRS_DESTBLEND
);
736 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND
);
737 D3DSTATE_TO_STR(WINED3DRS_CULLMODE
);
738 D3DSTATE_TO_STR(WINED3DRS_ZFUNC
);
739 D3DSTATE_TO_STR(WINED3DRS_ALPHAREF
);
740 D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC
);
741 D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE
);
742 D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE
);
743 D3DSTATE_TO_STR(WINED3DRS_FOGENABLE
);
744 D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE
);
745 D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE
);
746 D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL
);
747 D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX
);
748 D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA
);
749 D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR
);
750 D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE
);
751 D3DSTATE_TO_STR(WINED3DRS_FOGSTART
);
752 D3DSTATE_TO_STR(WINED3DRS_FOGEND
);
753 D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY
);
754 D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE
);
755 D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS
);
756 D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE
);
757 D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR
);
758 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU
);
759 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV
);
760 D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS
);
761 D3DSTATE_TO_STR(WINED3DRS_ZBIAS
);
762 D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE
);
763 D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY
);
764 D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH
);
765 D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
);
766 D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE
);
767 D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL
);
768 D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL
);
769 D3DSTATE_TO_STR(WINED3DRS_STENCILPASS
);
770 D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC
);
771 D3DSTATE_TO_STR(WINED3DRS_STENCILREF
);
772 D3DSTATE_TO_STR(WINED3DRS_STENCILMASK
);
773 D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK
);
774 D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR
);
775 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN00
);
776 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01
);
777 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02
);
778 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03
);
779 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04
);
780 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05
);
781 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06
);
782 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07
);
783 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08
);
784 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09
);
785 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10
);
786 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11
);
787 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12
);
788 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13
);
789 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14
);
790 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15
);
791 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16
);
792 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17
);
793 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18
);
794 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19
);
795 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20
);
796 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21
);
797 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22
);
798 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23
);
799 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24
);
800 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25
);
801 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26
);
802 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27
);
803 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28
);
804 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29
);
805 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30
);
806 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31
);
807 D3DSTATE_TO_STR(WINED3DRS_WRAP0
);
808 D3DSTATE_TO_STR(WINED3DRS_WRAP1
);
809 D3DSTATE_TO_STR(WINED3DRS_WRAP2
);
810 D3DSTATE_TO_STR(WINED3DRS_WRAP3
);
811 D3DSTATE_TO_STR(WINED3DRS_WRAP4
);
812 D3DSTATE_TO_STR(WINED3DRS_WRAP5
);
813 D3DSTATE_TO_STR(WINED3DRS_WRAP6
);
814 D3DSTATE_TO_STR(WINED3DRS_WRAP7
);
815 D3DSTATE_TO_STR(WINED3DRS_CLIPPING
);
816 D3DSTATE_TO_STR(WINED3DRS_LIGHTING
);
817 D3DSTATE_TO_STR(WINED3DRS_EXTENTS
);
818 D3DSTATE_TO_STR(WINED3DRS_AMBIENT
);
819 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE
);
820 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX
);
821 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER
);
822 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS
);
823 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE
);
824 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE
);
825 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE
);
826 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE
);
827 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE
);
828 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND
);
829 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE
);
830 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING
);
831 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE
);
832 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN
);
833 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE
);
834 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE
);
835 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A
);
836 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B
);
837 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C
);
838 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS
);
839 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK
);
840 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE
);
841 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS
);
842 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN
);
843 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX
);
844 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE
);
845 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE
);
846 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR
);
847 D3DSTATE_TO_STR(WINED3DRS_BLENDOP
);
848 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE
);
849 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE
);
850 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE
);
851 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS
);
852 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE
);
853 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL
);
854 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL
);
855 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X
);
856 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y
);
857 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z
);
858 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W
);
859 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION
);
860 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE
);
861 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL
);
862 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL
);
863 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS
);
864 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC
);
865 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1
);
866 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2
);
867 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3
);
868 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR
);
869 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE
);
870 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS
);
871 D3DSTATE_TO_STR(WINED3DRS_WRAP8
);
872 D3DSTATE_TO_STR(WINED3DRS_WRAP9
);
873 D3DSTATE_TO_STR(WINED3DRS_WRAP10
);
874 D3DSTATE_TO_STR(WINED3DRS_WRAP11
);
875 D3DSTATE_TO_STR(WINED3DRS_WRAP12
);
876 D3DSTATE_TO_STR(WINED3DRS_WRAP13
);
877 D3DSTATE_TO_STR(WINED3DRS_WRAP14
);
878 D3DSTATE_TO_STR(WINED3DRS_WRAP15
);
879 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE
);
880 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA
);
881 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA
);
882 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA
);
883 #undef D3DSTATE_TO_STR
885 FIXME("Unrecognized %u render state!\n", state
);
886 return "unrecognized";
890 const char* debug_d3dsamplerstate(DWORD state
) {
892 #define D3DSTATE_TO_STR(u) case u: return #u
893 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR
);
894 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU
);
895 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV
);
896 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW
);
897 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER
);
898 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER
);
899 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER
);
900 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS
);
901 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL
);
902 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY
);
903 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE
);
904 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX
);
905 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET
);
906 #undef D3DSTATE_TO_STR
908 FIXME("Unrecognized %u sampler state!\n", state
);
909 return "unrecognized";
913 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type
) {
914 switch (filter_type
) {
915 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
916 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE
);
917 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT
);
918 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR
);
919 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC
);
920 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC
);
921 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC
);
922 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD
);
923 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD
);
924 #undef D3DTEXTUREFILTERTYPE_TO_STR
926 FIXME("Unrecognied texture filter type 0x%08x\n", filter_type
);
927 return "unrecognized";
931 const char* debug_d3dtexturestate(DWORD state
) {
933 #define D3DSTATE_TO_STR(u) case u: return #u
934 D3DSTATE_TO_STR(WINED3DTSS_COLOROP
);
935 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1
);
936 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2
);
937 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP
);
938 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1
);
939 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2
);
940 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00
);
941 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01
);
942 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10
);
943 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11
);
944 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX
);
945 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE
);
946 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET
);
947 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS
);
948 D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW
);
949 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0
);
950 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0
);
951 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG
);
952 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT
);
953 #undef D3DSTATE_TO_STR
955 /* Note WINED3DTSS are not consecutive, so skip these */
958 FIXME("Unrecognized %u texture state!\n", state
);
959 return "unrecognized";
963 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop
) {
965 #define D3DTOP_TO_STR(u) case u: return #u
966 D3DTOP_TO_STR(WINED3DTOP_DISABLE
);
967 D3DTOP_TO_STR(WINED3DTOP_SELECTARG1
);
968 D3DTOP_TO_STR(WINED3DTOP_SELECTARG2
);
969 D3DTOP_TO_STR(WINED3DTOP_MODULATE
);
970 D3DTOP_TO_STR(WINED3DTOP_MODULATE2X
);
971 D3DTOP_TO_STR(WINED3DTOP_MODULATE4X
);
972 D3DTOP_TO_STR(WINED3DTOP_ADD
);
973 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED
);
974 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED2X
);
975 D3DTOP_TO_STR(WINED3DTOP_SUBTRACT
);
976 D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH
);
977 D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA
);
978 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA
);
979 D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA
);
980 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM
);
981 D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA
);
982 D3DTOP_TO_STR(WINED3DTOP_PREMODULATE
);
983 D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR
);
984 D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA
);
985 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
);
986 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
);
987 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP
);
988 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE
);
989 D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3
);
990 D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD
);
991 D3DTOP_TO_STR(WINED3DTOP_LERP
);
994 FIXME("Unrecognized %u WINED3DTOP\n", d3dtop
);
995 return "unrecognized";
999 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype
) {
1001 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
1002 TSTYPE_TO_STR(WINED3DTS_VIEW
);
1003 TSTYPE_TO_STR(WINED3DTS_PROJECTION
);
1004 TSTYPE_TO_STR(WINED3DTS_TEXTURE0
);
1005 TSTYPE_TO_STR(WINED3DTS_TEXTURE1
);
1006 TSTYPE_TO_STR(WINED3DTS_TEXTURE2
);
1007 TSTYPE_TO_STR(WINED3DTS_TEXTURE3
);
1008 TSTYPE_TO_STR(WINED3DTS_TEXTURE4
);
1009 TSTYPE_TO_STR(WINED3DTS_TEXTURE5
);
1010 TSTYPE_TO_STR(WINED3DTS_TEXTURE6
);
1011 TSTYPE_TO_STR(WINED3DTS_TEXTURE7
);
1012 TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
1013 #undef TSTYPE_TO_STR
1015 if (tstype
> 256 && tstype
< 512) {
1016 FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype
);
1017 return ("WINED3DTS_WORLDMATRIX > 0");
1019 FIXME("Unrecognized %u WINED3DTS\n", tstype
);
1020 return "unrecognized";
1024 const char* debug_d3dpool(WINED3DPOOL Pool
) {
1026 #define POOL_TO_STR(p) case p: return #p;
1027 POOL_TO_STR(WINED3DPOOL_DEFAULT
);
1028 POOL_TO_STR(WINED3DPOOL_MANAGED
);
1029 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM
);
1030 POOL_TO_STR(WINED3DPOOL_SCRATCH
);
1033 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool
);
1034 return "unrecognized";
1038 const char *debug_fbostatus(GLenum status
) {
1040 #define FBOSTATUS_TO_STR(u) case u: return #u
1041 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT
);
1042 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT
);
1043 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT
);
1044 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
);
1045 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT
);
1046 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT
);
1047 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT
);
1048 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT
);
1049 #undef FBOSTATUS_TO_STR
1051 FIXME("Unrecognied FBO status 0x%08x\n", status
);
1052 return "unrecognized";
1056 const char *debug_glerror(GLenum error
) {
1058 #define GLERROR_TO_STR(u) case u: return #u
1059 GLERROR_TO_STR(GL_NO_ERROR
);
1060 GLERROR_TO_STR(GL_INVALID_ENUM
);
1061 GLERROR_TO_STR(GL_INVALID_VALUE
);
1062 GLERROR_TO_STR(GL_INVALID_OPERATION
);
1063 GLERROR_TO_STR(GL_STACK_OVERFLOW
);
1064 GLERROR_TO_STR(GL_STACK_UNDERFLOW
);
1065 GLERROR_TO_STR(GL_OUT_OF_MEMORY
);
1066 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT
);
1067 #undef GLERROR_TO_STR
1069 FIXME("Unrecognied GL error 0x%08x\n", error
);
1070 return "unrecognized";
1074 const char *debug_d3dbasis(WINED3DBASISTYPE basis
) {
1076 case WINED3DBASIS_BEZIER
: return "WINED3DBASIS_BEZIER";
1077 case WINED3DBASIS_BSPLINE
: return "WINED3DBASIS_BSPLINE";
1078 case WINED3DBASIS_INTERPOLATE
: return "WINED3DBASIS_INTERPOLATE";
1079 default: return "unrecognized";
1083 const char *debug_d3ddegree(WINED3DDEGREETYPE degree
) {
1085 case WINED3DDEGREE_LINEAR
: return "WINED3DDEGREE_LINEAR";
1086 case WINED3DDEGREE_QUADRATIC
: return "WINED3DDEGREE_QUADRATIC";
1087 case WINED3DDEGREE_CUBIC
: return "WINED3DDEGREE_CUBIC";
1088 case WINED3DDEGREE_QUINTIC
: return "WINED3DDEGREE_QUINTIC";
1089 default: return "unrecognized";
1093 /*****************************************************************************
1094 * Useful functions mapping GL <-> D3D values
1096 GLenum
StencilOp(DWORD op
) {
1098 case WINED3DSTENCILOP_KEEP
: return GL_KEEP
;
1099 case WINED3DSTENCILOP_ZERO
: return GL_ZERO
;
1100 case WINED3DSTENCILOP_REPLACE
: return GL_REPLACE
;
1101 case WINED3DSTENCILOP_INCRSAT
: return GL_INCR
;
1102 case WINED3DSTENCILOP_DECRSAT
: return GL_DECR
;
1103 case WINED3DSTENCILOP_INVERT
: return GL_INVERT
;
1104 case WINED3DSTENCILOP_INCR
: return GL_INCR_WRAP_EXT
;
1105 case WINED3DSTENCILOP_DECR
: return GL_DECR_WRAP_EXT
;
1107 FIXME("Unrecognized stencil op %d\n", op
);
1112 GLenum
CompareFunc(DWORD func
) {
1113 switch ((WINED3DCMPFUNC
)func
) {
1114 case WINED3DCMP_NEVER
: return GL_NEVER
;
1115 case WINED3DCMP_LESS
: return GL_LESS
;
1116 case WINED3DCMP_EQUAL
: return GL_EQUAL
;
1117 case WINED3DCMP_LESSEQUAL
: return GL_LEQUAL
;
1118 case WINED3DCMP_GREATER
: return GL_GREATER
;
1119 case WINED3DCMP_NOTEQUAL
: return GL_NOTEQUAL
;
1120 case WINED3DCMP_GREATEREQUAL
: return GL_GEQUAL
;
1121 case WINED3DCMP_ALWAYS
: return GL_ALWAYS
;
1123 FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func
);
1128 BOOL
is_invalid_op(IWineD3DDeviceImpl
*This
, int stage
, WINED3DTEXTUREOP op
, DWORD arg1
, DWORD arg2
, DWORD arg3
) {
1129 if (op
== WINED3DTOP_DISABLE
) return FALSE
;
1130 if (This
->stateBlock
->textures
[stage
]) return FALSE
;
1132 if ((arg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1133 && op
!= WINED3DTOP_SELECTARG2
) return TRUE
;
1134 if ((arg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1135 && op
!= WINED3DTOP_SELECTARG1
) return TRUE
;
1136 if ((arg3
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
1137 && (op
== WINED3DTOP_MULTIPLYADD
|| op
== WINED3DTOP_LERP
)) return TRUE
;
1142 /* Setup this textures matrix according to the texture flags*/
1143 void set_texture_matrix(const float *smat
, DWORD flags
, BOOL calculatedCoords
, BOOL transformed
, DWORD coordtype
)
1147 glMatrixMode(GL_TEXTURE
);
1148 checkGLcall("glMatrixMode(GL_TEXTURE)");
1150 if (flags
== WINED3DTTFF_DISABLE
|| flags
== WINED3DTTFF_COUNT1
|| transformed
) {
1152 checkGLcall("glLoadIdentity()");
1156 if (flags
== (WINED3DTTFF_COUNT1
|WINED3DTTFF_PROJECTED
)) {
1157 ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
1161 memcpy(mat
, smat
, 16 * sizeof(float));
1163 if (flags
& WINED3DTTFF_PROJECTED
) {
1164 switch (flags
& ~WINED3DTTFF_PROJECTED
) {
1165 case WINED3DTTFF_COUNT2
:
1166 mat
[3] = mat
[1], mat
[7] = mat
[5], mat
[11] = mat
[9], mat
[15] = mat
[13];
1167 mat
[1] = mat
[5] = mat
[9] = mat
[13] = 0;
1169 case WINED3DTTFF_COUNT3
:
1170 mat
[3] = mat
[2], mat
[7] = mat
[6], mat
[11] = mat
[10], mat
[15] = mat
[14];
1171 mat
[2] = mat
[6] = mat
[10] = mat
[14] = 0;
1174 } else { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1175 if(!calculatedCoords
) {
1177 case WINED3DDECLTYPE_FLOAT1
:
1178 /* Direct3D passes the default 1.0 in the 2nd coord, while gl passes it in the 4th.
1179 * swap 2nd and 4th coord. No need to store the value of mat[12] in mat[4] because
1180 * the input value to the transformation will be 0, so the matrix value is irrelevant
1187 case WINED3DDECLTYPE_FLOAT2
:
1188 /* See above, just 3rd and 4th coord
1195 case WINED3DDECLTYPE_FLOAT3
: /* Opengl defaults match dx defaults */
1196 case WINED3DDECLTYPE_FLOAT4
: /* No defaults apply, all app defined */
1198 /* This is to prevent swapping the matrix lines and put the default 4th coord = 1.0
1199 * into a bad place. The division elimination below will apply to make sure the
1200 * 1.0 doesn't do anything bad. The caller will set this value if the stride is 0
1202 case WINED3DDECLTYPE_UNUSED
: /* No texture coords, 0/0/0/1 defaults are passed */
1205 FIXME("Unexpected fixed function texture coord input\n");
1208 switch (flags
& ~WINED3DTTFF_PROJECTED
) {
1209 /* case WINED3DTTFF_COUNT1: Won't ever get here */
1210 case WINED3DTTFF_COUNT2
: mat
[2] = mat
[6] = mat
[10] = mat
[14] = 0;
1211 /* OpenGL divides the first 3 vertex coord by the 4th by default,
1212 * which is essentially the same as D3DTTFF_PROJECTED. Make sure that
1213 * the 4th coord evaluates to 1.0 to eliminate that.
1215 * If the fixed function pipeline is used, the 4th value remains unused,
1216 * so there is no danger in doing this. With vertex shaders we have a
1217 * problem. Should an app hit that problem, the code here would have to
1218 * check for pixel shaders, and the shader has to undo the default gl divide.
1220 * A more serious problem occurs if the app passes 4 coordinates in, and the
1221 * 4th is != 1.0(opengl default). This would have to be fixed in drawStridedSlow
1222 * or a replacement shader
1224 default: mat
[3] = mat
[7] = mat
[11] = 0; mat
[15] = 1;
1229 checkGLcall("glLoadMatrixf(mat)");
1231 #undef GLINFO_LOCATION
1233 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1235 /* This small helper function is used to convert a bitmask into the number of masked bits */
1236 unsigned int count_bits(unsigned int mask
)
1239 for (count
= 0; mask
; ++count
)
1246 /* Helper function for retrieving color info for ChoosePixelFormat and wglChoosePixelFormatARB.
1247 * The later function requires individual color components. */
1248 BOOL
getColorBits(WINED3DFORMAT fmt
, short *redSize
, short *greenSize
, short *blueSize
, short *alphaSize
, short *totalSize
)
1250 const StaticPixelFormatDesc
*desc
;
1252 TRACE("fmt: %s\n", debug_d3dformat(fmt
));
1255 case WINED3DFMT_X8R8G8B8
:
1256 case WINED3DFMT_R8G8B8
:
1257 case WINED3DFMT_A8R8G8B8
:
1258 case WINED3DFMT_A2R10G10B10
:
1259 case WINED3DFMT_X1R5G5B5
:
1260 case WINED3DFMT_A1R5G5B5
:
1261 case WINED3DFMT_R5G6B5
:
1262 case WINED3DFMT_X4R4G4B4
:
1263 case WINED3DFMT_A4R4G4B4
:
1264 case WINED3DFMT_R3G3B2
:
1265 case WINED3DFMT_A8P8
:
1269 ERR("Unsupported format: %s\n", debug_d3dformat(fmt
));
1273 desc
= getFormatDescEntry(fmt
, NULL
, NULL
);
1276 ERR("Unable to look up format: 0x%x\n", fmt
);
1279 *redSize
= count_bits(desc
->redMask
);
1280 *greenSize
= count_bits(desc
->greenMask
);
1281 *blueSize
= count_bits(desc
->blueMask
);
1282 *alphaSize
= count_bits(desc
->alphaMask
);
1283 *totalSize
= *redSize
+ *greenSize
+ *blueSize
+ *alphaSize
;
1285 TRACE("Returning red: %d, green: %d, blue: %d, alpha: %d, total: %d for fmt=%s\n", *redSize
, *greenSize
, *blueSize
, *alphaSize
, *totalSize
, debug_d3dformat(fmt
));
1289 /* Helper function for retrieving depth/stencil info for ChoosePixelFormat and wglChoosePixelFormatARB */
1290 BOOL
getDepthStencilBits(WINED3DFORMAT fmt
, short *depthSize
, short *stencilSize
)
1292 const StaticPixelFormatDesc
*desc
;
1294 TRACE("fmt: %s\n", debug_d3dformat(fmt
));
1297 case WINED3DFMT_D16_LOCKABLE
:
1298 case WINED3DFMT_D16
:
1299 case WINED3DFMT_D15S1
:
1300 case WINED3DFMT_D24X8
:
1301 case WINED3DFMT_D24X4S4
:
1302 case WINED3DFMT_D24S8
:
1303 case WINED3DFMT_D24FS8
:
1304 case WINED3DFMT_D32
:
1305 case WINED3DFMT_D32F_LOCKABLE
:
1308 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(fmt
));
1312 desc
= getFormatDescEntry(fmt
, NULL
, NULL
);
1315 ERR("Unable to look up format: 0x%x\n", fmt
);
1318 *depthSize
= desc
->depthSize
;
1319 *stencilSize
= desc
->stencilSize
;
1321 TRACE("Returning depthSize: %d and stencilSize: %d for fmt=%s\n", *depthSize
, *stencilSize
, debug_d3dformat(fmt
));
1325 #undef GLINFO_LOCATION
1327 /* DirectDraw stuff */
1328 WINED3DFORMAT
pixelformat_for_depth(DWORD depth
) {
1330 case 8: return WINED3DFMT_P8
;
1331 case 15: return WINED3DFMT_X1R5G5B5
;
1332 case 16: return WINED3DFMT_R5G6B5
;
1333 case 24: return WINED3DFMT_X8R8G8B8
; /* Robots needs 24bit to be X8R8G8B8 */
1334 case 32: return WINED3DFMT_X8R8G8B8
; /* EVE online and the Fur demo need 32bit AdapterDisplayMode to return X8R8G8B8 */
1335 default: return WINED3DFMT_UNKNOWN
;
1339 void multiply_matrix(WINED3DMATRIX
*dest
, const WINED3DMATRIX
*src1
, const WINED3DMATRIX
*src2
) {
1342 /* Now do the multiplication 'by hand'.
1343 I know that all this could be optimised, but this will be done later :-) */
1344 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
);
1345 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
);
1346 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
);
1347 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
);
1349 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
);
1350 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
);
1351 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
);
1352 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
);
1354 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
);
1355 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
);
1356 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
);
1357 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
);
1359 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
);
1360 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
);
1361 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
);
1362 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
);
1364 /* And copy the new matrix in the good storage.. */
1365 memcpy(dest
, &temp
, 16 * sizeof(float));
1368 DWORD
get_flexible_vertex_size(DWORD d3dvtVertexType
) {
1371 int numTextures
= (d3dvtVertexType
& WINED3DFVF_TEXCOUNT_MASK
) >> WINED3DFVF_TEXCOUNT_SHIFT
;
1373 if (d3dvtVertexType
& WINED3DFVF_NORMAL
) size
+= 3 * sizeof(float);
1374 if (d3dvtVertexType
& WINED3DFVF_DIFFUSE
) size
+= sizeof(DWORD
);
1375 if (d3dvtVertexType
& WINED3DFVF_SPECULAR
) size
+= sizeof(DWORD
);
1376 if (d3dvtVertexType
& WINED3DFVF_PSIZE
) size
+= sizeof(DWORD
);
1377 switch (d3dvtVertexType
& WINED3DFVF_POSITION_MASK
) {
1378 case WINED3DFVF_XYZ
: size
+= 3 * sizeof(float); break;
1379 case WINED3DFVF_XYZRHW
: size
+= 4 * sizeof(float); break;
1380 case WINED3DFVF_XYZB1
: size
+= 4 * sizeof(float); break;
1381 case WINED3DFVF_XYZB2
: size
+= 5 * sizeof(float); break;
1382 case WINED3DFVF_XYZB3
: size
+= 6 * sizeof(float); break;
1383 case WINED3DFVF_XYZB4
: size
+= 7 * sizeof(float); break;
1384 case WINED3DFVF_XYZB5
: size
+= 8 * sizeof(float); break;
1385 default: ERR("Unexpected position mask\n");
1387 for (i
= 0; i
< numTextures
; i
++) {
1388 size
+= GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType
, i
) * sizeof(float);
1394 /***********************************************************************
1397 * Calculates the dimensions of the opengl texture used for blits.
1398 * Handled oversized opengl textures and updates the source rectangle
1402 * This: Surface to operate on
1403 * Rect: Requested rectangle
1406 * TRUE if the texture part can be loaded,
1409 *********************************************************************/
1410 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
1412 BOOL
CalculateTexRect(IWineD3DSurfaceImpl
*This
, RECT
*Rect
, float glTexCoord
[4]) {
1413 int x1
= Rect
->left
, x2
= Rect
->right
;
1414 int y1
= Rect
->top
, y2
= Rect
->bottom
;
1415 GLint maxSize
= GL_LIMITS(texture_size
);
1417 TRACE("(%p)->(%d,%d)-(%d,%d)\n", This
,
1418 Rect
->left
, Rect
->top
, Rect
->right
, Rect
->bottom
);
1420 /* The sizes might be reversed */
1421 if(Rect
->left
> Rect
->right
) {
1425 if(Rect
->top
> Rect
->bottom
) {
1430 /* No oversized texture? This is easy */
1431 if(!(This
->Flags
& SFLAG_OVERSIZE
)) {
1432 /* Which rect from the texture do I need? */
1433 if(This
->glDescription
.target
== GL_TEXTURE_RECTANGLE_ARB
) {
1434 glTexCoord
[0] = (float) Rect
->left
;
1435 glTexCoord
[2] = (float) Rect
->top
;
1436 glTexCoord
[1] = (float) Rect
->right
;
1437 glTexCoord
[3] = (float) Rect
->bottom
;
1439 glTexCoord
[0] = (float) Rect
->left
/ (float) This
->pow2Width
;
1440 glTexCoord
[2] = (float) Rect
->top
/ (float) This
->pow2Height
;
1441 glTexCoord
[1] = (float) Rect
->right
/ (float) This
->pow2Width
;
1442 glTexCoord
[3] = (float) Rect
->bottom
/ (float) This
->pow2Height
;
1447 /* Check if we can succeed at all */
1448 if( (x2
- x1
) > maxSize
||
1449 (y2
- y1
) > maxSize
) {
1450 TRACE("Requested rectangle is too large for gl\n");
1454 /* A part of the texture has to be picked. First, check if
1455 * some texture part is loaded already, if yes try to re-use it.
1456 * If the texture is dirty, or the part can't be used,
1457 * re-position the part to load
1459 if(This
->Flags
& SFLAG_INTEXTURE
) {
1460 if(This
->glRect
.left
<= x1
&& This
->glRect
.right
>= x2
&&
1461 This
->glRect
.top
<= y1
&& This
->glRect
.bottom
>= x2
) {
1462 /* Ok, the rectangle is ok, re-use it */
1463 TRACE("Using existing gl Texture\n");
1465 /* Rectangle is not ok, dirtify the texture to reload it */
1466 TRACE("Dirtifying texture to force reload\n");
1467 This
->Flags
&= ~SFLAG_INTEXTURE
;
1471 /* Now if we are dirty(no else if!) */
1472 if(!(This
->Flags
& SFLAG_INTEXTURE
)) {
1473 /* Set the new rectangle. Use the following strategy:
1474 * 1) Use as big textures as possible.
1475 * 2) Place the texture part in the way that the requested
1476 * part is in the middle of the texture(well, almost)
1477 * 3) If the texture is moved over the edges of the
1478 * surface, replace it nicely
1479 * 4) If the coord is not limiting the texture size,
1480 * use the whole size
1482 if((This
->pow2Width
) > maxSize
) {
1483 This
->glRect
.left
= x1
- maxSize
/ 2;
1484 if(This
->glRect
.left
< 0) {
1485 This
->glRect
.left
= 0;
1487 This
->glRect
.right
= This
->glRect
.left
+ maxSize
;
1488 if(This
->glRect
.right
> This
->currentDesc
.Width
) {
1489 This
->glRect
.right
= This
->currentDesc
.Width
;
1490 This
->glRect
.left
= This
->glRect
.right
- maxSize
;
1493 This
->glRect
.left
= 0;
1494 This
->glRect
.right
= This
->pow2Width
;
1497 if(This
->pow2Height
> maxSize
) {
1498 This
->glRect
.top
= x1
- GL_LIMITS(texture_size
) / 2;
1499 if(This
->glRect
.top
< 0) This
->glRect
.top
= 0;
1500 This
->glRect
.bottom
= This
->glRect
.left
+ maxSize
;
1501 if(This
->glRect
.bottom
> This
->currentDesc
.Height
) {
1502 This
->glRect
.bottom
= This
->currentDesc
.Height
;
1503 This
->glRect
.top
= This
->glRect
.bottom
- maxSize
;
1506 This
->glRect
.top
= 0;
1507 This
->glRect
.bottom
= This
->pow2Height
;
1509 TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This
,
1510 This
->glRect
.left
, This
->glRect
.top
, This
->glRect
.right
, This
->glRect
.bottom
);
1513 /* Re-calculate the rect to draw */
1514 Rect
->left
-= This
->glRect
.left
;
1515 Rect
->right
-= This
->glRect
.left
;
1516 Rect
->top
-= This
->glRect
.top
;
1517 Rect
->bottom
-= This
->glRect
.top
;
1519 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
1520 * or the pow2Width / pow2Height of the surface.
1522 * Can never be GL_TEXTURE_RECTANGLE_ARB because oversized surfaces are always set up
1523 * as regular GL_TEXTURE_2D.
1525 glTexCoord
[0] = (float) Rect
->left
/ (float) (This
->glRect
.right
- This
->glRect
.left
);
1526 glTexCoord
[2] = (float) Rect
->top
/ (float) (This
->glRect
.bottom
- This
->glRect
.top
);
1527 glTexCoord
[1] = (float) Rect
->right
/ (float) (This
->glRect
.right
- This
->glRect
.left
);
1528 glTexCoord
[3] = (float) Rect
->bottom
/ (float) (This
->glRect
.bottom
- This
->glRect
.top
);
1532 #undef GLINFO_LOCATION
1534 /* Hash table functions */
1536 hash_table_t
*hash_table_create(hash_function_t
*hash_function
, compare_function_t
*compare_function
)
1538 hash_table_t
*table
;
1539 unsigned int initial_size
= 8;
1541 table
= HeapAlloc(GetProcessHeap(), 0, sizeof(hash_table_t
) + (initial_size
* sizeof(struct list
)));
1544 ERR("Failed to allocate table, returning NULL.\n");
1548 table
->hash_function
= hash_function
;
1549 table
->compare_function
= compare_function
;
1551 table
->grow_size
= initial_size
- (initial_size
>> 2);
1552 table
->shrink_size
= 0;
1554 table
->buckets
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, initial_size
* sizeof(struct list
));
1555 if (!table
->buckets
)
1557 ERR("Failed to allocate table buckets, returning NULL.\n");
1558 HeapFree(GetProcessHeap(), 0, table
);
1561 table
->bucket_count
= initial_size
;
1563 table
->entries
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, table
->grow_size
* sizeof(hash_table_entry_t
));
1564 if (!table
->entries
)
1566 ERR("Failed to allocate table entries, returning NULL.\n");
1567 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1568 HeapFree(GetProcessHeap(), 0, table
);
1571 table
->entry_count
= 0;
1573 list_init(&table
->free_entries
);
1579 void hash_table_destroy(hash_table_t
*table
)
1583 for (i
= 0; i
< table
->entry_count
; ++i
)
1585 HeapFree(GetProcessHeap(), 0, table
->entries
[i
].key
);
1588 HeapFree(GetProcessHeap(), 0, table
->entries
);
1589 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1590 HeapFree(GetProcessHeap(), 0, table
);
1593 static inline hash_table_entry_t
*hash_table_get_by_idx(hash_table_t
*table
, void *key
, unsigned int idx
)
1595 hash_table_entry_t
*entry
;
1597 if (table
->buckets
[idx
].next
)
1598 LIST_FOR_EACH_ENTRY(entry
, &(table
->buckets
[idx
]), hash_table_entry_t
, entry
)
1599 if (table
->compare_function(entry
->key
, key
)) return entry
;
1604 static BOOL
hash_table_resize(hash_table_t
*table
, unsigned int new_bucket_count
)
1606 unsigned int new_entry_count
= 0;
1607 hash_table_entry_t
*new_entries
;
1608 struct list
*new_buckets
;
1609 unsigned int grow_size
= new_bucket_count
- (new_bucket_count
>> 2);
1612 new_buckets
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, new_bucket_count
* sizeof(struct list
));
1615 ERR("Failed to allocate new buckets, returning FALSE.\n");
1619 new_entries
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, grow_size
* sizeof(hash_table_entry_t
));
1622 ERR("Failed to allocate new entries, returning FALSE.\n");
1623 HeapFree(GetProcessHeap(), 0, new_buckets
);
1627 for (i
= 0; i
< table
->bucket_count
; ++i
)
1629 if (table
->buckets
[i
].next
)
1631 hash_table_entry_t
*entry
, *entry2
;
1633 LIST_FOR_EACH_ENTRY_SAFE(entry
, entry2
, &table
->buckets
[i
], hash_table_entry_t
, entry
)
1636 hash_table_entry_t
*new_entry
= new_entries
+ (new_entry_count
++);
1637 *new_entry
= *entry
;
1639 j
= new_entry
->hash
& (new_bucket_count
- 1);
1641 if (!new_buckets
[j
].next
) list_init(&new_buckets
[j
]);
1642 list_add_head(&new_buckets
[j
], &new_entry
->entry
);
1647 HeapFree(GetProcessHeap(), 0, table
->buckets
);
1648 table
->buckets
= new_buckets
;
1650 HeapFree(GetProcessHeap(), 0, table
->entries
);
1651 table
->entries
= new_entries
;
1653 table
->entry_count
= new_entry_count
;
1654 list_init(&table
->free_entries
);
1656 table
->bucket_count
= new_bucket_count
;
1657 table
->grow_size
= grow_size
;
1658 table
->shrink_size
= new_bucket_count
> 8 ? new_bucket_count
>> 2 : 0;
1663 void hash_table_put(hash_table_t
*table
, void *key
, void *value
)
1667 hash_table_entry_t
*entry
;
1669 hash
= table
->hash_function(key
);
1670 idx
= hash
& (table
->bucket_count
- 1);
1671 entry
= hash_table_get_by_idx(table
, key
, idx
);
1675 HeapFree(GetProcessHeap(), 0, key
);
1676 entry
->value
= value
;
1680 HeapFree(GetProcessHeap(), 0, entry
->key
);
1683 /* Remove the entry */
1684 list_remove(&entry
->entry
);
1685 list_add_head(&table
->free_entries
, &entry
->entry
);
1689 /* Shrink if necessary */
1690 if (table
->count
< table
->shrink_size
) {
1691 if (!hash_table_resize(table
, table
->bucket_count
>> 1))
1693 ERR("Failed to shrink the table...\n");
1703 /* Grow if necessary */
1704 if (table
->count
>= table
->grow_size
)
1706 if (!hash_table_resize(table
, table
->bucket_count
<< 1))
1708 ERR("Failed to grow the table, returning.\n");
1712 idx
= hash
& (table
->bucket_count
- 1);
1715 /* Find an entry to insert */
1716 if (!list_empty(&table
->free_entries
))
1718 struct list
*elem
= list_head(&table
->free_entries
);
1721 entry
= LIST_ENTRY(elem
, hash_table_entry_t
, entry
);
1723 entry
= table
->entries
+ (table
->entry_count
++);
1726 /* Insert the entry */
1728 entry
->value
= value
;
1730 if (!table
->buckets
[idx
].next
) list_init(&table
->buckets
[idx
]);
1731 list_add_head(&table
->buckets
[idx
], &entry
->entry
);
1736 void hash_table_remove(hash_table_t
*table
, void *key
)
1738 hash_table_put(table
, key
, NULL
);
1741 void *hash_table_get(hash_table_t
*table
, void *key
)
1744 hash_table_entry_t
*entry
;
1746 idx
= table
->hash_function(key
) & (table
->bucket_count
- 1);
1747 entry
= hash_table_get_by_idx(table
, key
, idx
);
1749 return entry
? entry
->value
: NULL
;
1752 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
1753 void gen_ffp_op(IWineD3DStateBlockImpl
*stateblock
, struct ffp_settings
*settings
, BOOL ignore_textype
) {
1757 static const unsigned char args
[WINED3DTOP_LERP
+ 1] = {
1759 /* D3DTOP_DISABLE */ 0,
1760 /* D3DTOP_SELECTARG1 */ ARG1
,
1761 /* D3DTOP_SELECTARG2 */ ARG2
,
1762 /* D3DTOP_MODULATE */ ARG1
| ARG2
,
1763 /* D3DTOP_MODULATE2X */ ARG1
| ARG2
,
1764 /* D3DTOP_MODULATE4X */ ARG1
| ARG2
,
1765 /* D3DTOP_ADD */ ARG1
| ARG2
,
1766 /* D3DTOP_ADDSIGNED */ ARG1
| ARG2
,
1767 /* D3DTOP_ADDSIGNED2X */ ARG1
| ARG2
,
1768 /* D3DTOP_SUBTRACT */ ARG1
| ARG2
,
1769 /* D3DTOP_ADDSMOOTH */ ARG1
| ARG2
,
1770 /* D3DTOP_BLENDDIFFUSEALPHA */ ARG1
| ARG2
,
1771 /* D3DTOP_BLENDTEXTUREALPHA */ ARG1
| ARG2
,
1772 /* D3DTOP_BLENDFACTORALPHA */ ARG1
| ARG2
,
1773 /* D3DTOP_BLENDTEXTUREALPHAPM */ ARG1
| ARG2
,
1774 /* D3DTOP_BLENDCURRENTALPHA */ ARG1
| ARG2
,
1775 /* D3DTOP_PREMODULATE */ ARG1
| ARG2
,
1776 /* D3DTOP_MODULATEALPHA_ADDCOLOR */ ARG1
| ARG2
,
1777 /* D3DTOP_MODULATECOLOR_ADDALPHA */ ARG1
| ARG2
,
1778 /* D3DTOP_MODULATEINVALPHA_ADDCOLOR */ ARG1
| ARG2
,
1779 /* D3DTOP_MODULATEINVCOLOR_ADDALPHA */ ARG1
| ARG2
,
1780 /* D3DTOP_BUMPENVMAP */ ARG1
| ARG2
,
1781 /* D3DTOP_BUMPENVMAPLUMINANCE */ ARG1
| ARG2
,
1782 /* D3DTOP_DOTPRODUCT3 */ ARG1
| ARG2
,
1783 /* D3DTOP_MULTIPLYADD */ ARG1
| ARG2
| ARG0
,
1784 /* D3DTOP_LERP */ ARG1
| ARG2
| ARG0
1788 DWORD cop
, aop
, carg0
, carg1
, carg2
, aarg0
, aarg1
, aarg2
;
1790 for(i
= 0; i
< GL_LIMITS(texture_stages
); i
++) {
1791 IWineD3DBaseTextureImpl
*texture
;
1792 if(stateblock
->textureState
[i
][WINED3DTSS_COLOROP
] == WINED3DTOP_DISABLE
) {
1793 settings
->op
[i
].cop
= WINED3DTOP_DISABLE
;
1794 settings
->op
[i
].aop
= WINED3DTOP_DISABLE
;
1795 /* 0x3F: set all 6 bits of the args to 1 */
1796 settings
->op
[i
].carg0
= settings
->op
[i
].carg1
= settings
->op
[i
].carg2
= 0x3F;
1797 settings
->op
[i
].aarg0
= settings
->op
[i
].aarg1
= settings
->op
[i
].aarg2
= 0x3F;
1798 settings
->op
[i
].color_correction
= WINED3DFMT_UNKNOWN
;
1799 settings
->op
[i
].dst
= resultreg
;
1804 texture
= (IWineD3DBaseTextureImpl
*) stateblock
->textures
[i
];
1806 settings
->op
[i
].color_correction
= texture
->baseTexture
.shader_conversion_group
;
1807 if(ignore_textype
) {
1808 settings
->op
[i
].tex_type
= tex_1d
;
1810 switch(stateblock
->textureDimensions
[i
]) {
1812 settings
->op
[i
].tex_type
= tex_1d
;
1815 settings
->op
[i
].tex_type
= tex_2d
;
1818 settings
->op
[i
].tex_type
= tex_3d
;
1820 case GL_TEXTURE_CUBE_MAP_ARB
:
1821 settings
->op
[i
].tex_type
= tex_cube
;
1823 case GL_TEXTURE_RECTANGLE_ARB
:
1824 settings
->op
[i
].tex_type
= tex_rect
;
1829 settings
->op
[i
].color_correction
= WINED3DFMT_UNKNOWN
;
1830 settings
->op
[i
].tex_type
= tex_1d
;
1833 cop
= stateblock
->textureState
[i
][WINED3DTSS_COLOROP
];
1834 aop
= stateblock
->textureState
[i
][WINED3DTSS_ALPHAOP
];
1836 carg1
= (args
[cop
] & ARG1
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG1
] : 0xffffffff;
1837 carg2
= (args
[cop
] & ARG2
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG2
] : 0xffffffff;
1838 carg0
= (args
[cop
] & ARG0
) ? stateblock
->textureState
[i
][WINED3DTSS_COLORARG0
] : 0xffffffff;
1840 if(is_invalid_op(stateblock
->wineD3DDevice
, i
, cop
,
1841 carg1
, carg2
, carg0
)) {
1844 carg1
= WINED3DTA_CURRENT
;
1845 cop
= WINED3DTOP_SELECTARG1
;
1848 aarg1
= (args
[aop
] & ARG1
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG1
] : 0xffffffff;
1849 aarg2
= (args
[aop
] & ARG2
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG2
] : 0xffffffff;
1850 aarg0
= (args
[aop
] & ARG0
) ? stateblock
->textureState
[i
][WINED3DTSS_ALPHAARG0
] : 0xffffffff;
1852 if(i
== 0 && stateblock
->textures
[0] &&
1853 stateblock
->renderState
[WINED3DRS_COLORKEYENABLE
] &&
1854 (stateblock
->textureDimensions
[0] == GL_TEXTURE_2D
||
1855 stateblock
->textureDimensions
[0] == GL_TEXTURE_RECTANGLE_ARB
)) {
1856 IWineD3DSurfaceImpl
*surf
= (IWineD3DSurfaceImpl
*) ((IWineD3DTextureImpl
*) stateblock
->textures
[0])->surfaces
[0];
1858 if(surf
->CKeyFlags
& WINEDDSD_CKSRCBLT
&&
1859 getFormatDescEntry(surf
->resource
.format
, NULL
, NULL
)->alphaMask
== 0x00000000) {
1861 if(aop
== WINED3DTOP_DISABLE
) {
1862 aarg1
= WINED3DTA_TEXTURE
;
1863 aop
= WINED3DTOP_SELECTARG1
;
1865 else if(aop
== WINED3DTOP_SELECTARG1
&& aarg1
!= WINED3DTA_TEXTURE
) {
1866 if (stateblock
->renderState
[WINED3DRS_ALPHABLENDENABLE
]) {
1867 aarg2
= WINED3DTA_TEXTURE
;
1868 aop
= WINED3DTOP_MODULATE
;
1870 else aarg1
= WINED3DTA_TEXTURE
;
1872 else if(aop
== WINED3DTOP_SELECTARG2
&& aarg2
!= WINED3DTA_TEXTURE
) {
1873 if (stateblock
->renderState
[WINED3DRS_ALPHABLENDENABLE
]) {
1874 aarg1
= WINED3DTA_TEXTURE
;
1875 aop
= WINED3DTOP_MODULATE
;
1877 else aarg2
= WINED3DTA_TEXTURE
;
1882 if(is_invalid_op(stateblock
->wineD3DDevice
, i
, aop
,
1883 aarg1
, aarg2
, aarg0
)) {
1886 aarg1
= WINED3DTA_CURRENT
;
1887 aop
= WINED3DTOP_SELECTARG1
;
1890 if(carg1
== WINED3DTA_TEXTURE
|| carg2
== WINED3DTA_TEXTURE
|| carg0
== WINED3DTA_TEXTURE
||
1891 aarg1
== WINED3DTA_TEXTURE
|| aarg2
== WINED3DTA_TEXTURE
|| aarg0
== WINED3DTA_TEXTURE
) {
1892 ttff
= stateblock
->textureState
[i
][WINED3DTSS_TEXTURETRANSFORMFLAGS
];
1893 if(ttff
== (WINED3DTTFF_PROJECTED
| WINED3DTTFF_COUNT3
)) {
1894 settings
->op
[i
].projected
= proj_count3
;
1895 } else if(ttff
== (WINED3DTTFF_PROJECTED
| WINED3DTTFF_COUNT4
)) {
1896 settings
->op
[i
].projected
= proj_count4
;
1898 settings
->op
[i
].projected
= proj_none
;
1901 settings
->op
[i
].projected
= proj_none
;
1904 settings
->op
[i
].cop
= cop
;
1905 settings
->op
[i
].aop
= aop
;
1906 settings
->op
[i
].carg0
= carg0
;
1907 settings
->op
[i
].carg1
= carg1
;
1908 settings
->op
[i
].carg2
= carg2
;
1909 settings
->op
[i
].aarg0
= aarg0
;
1910 settings
->op
[i
].aarg1
= aarg1
;
1911 settings
->op
[i
].aarg2
= aarg2
;
1913 if(stateblock
->textureState
[i
][WINED3DTSS_RESULTARG
] == WINED3DTA_TEMP
) {
1914 settings
->op
[i
].dst
= tempreg
;
1916 settings
->op
[i
].dst
= resultreg
;
1920 /* Clear unsupported stages */
1921 for(; i
< MAX_TEXTURES
; i
++) {
1922 memset(&settings
->op
[i
], 0xff, sizeof(settings
->op
[i
]));
1925 if(stateblock
->renderState
[WINED3DRS_FOGENABLE
] == FALSE
) {
1926 settings
->fog
= FOG_OFF
;
1927 } else if(stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
] == WINED3DFOG_NONE
) {
1928 switch(stateblock
->renderState
[WINED3DRS_FOGVERTEXMODE
]) {
1929 case WINED3DFOG_NONE
:
1930 case WINED3DFOG_LINEAR
:
1931 settings
->fog
= FOG_LINEAR
;
1933 case WINED3DFOG_EXP
:
1934 settings
->fog
= FOG_EXP
;
1936 case WINED3DFOG_EXP2
:
1937 settings
->fog
= FOG_EXP2
;
1941 switch(stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
]) {
1942 case WINED3DFOG_LINEAR
:
1943 settings
->fog
= FOG_LINEAR
;
1945 case WINED3DFOG_EXP
:
1946 settings
->fog
= FOG_EXP
;
1948 case WINED3DFOG_EXP2
:
1949 settings
->fog
= FOG_EXP2
;
1954 #undef GLINFO_LOCATION
1956 struct ffp_desc
*find_ffp_shader(struct list
*shaders
, struct ffp_settings
*settings
)
1958 struct ffp_desc
*entry
;
1960 /* TODO: Optimize this. Finding the shader can be optimized by e.g. sorting the list,
1961 * or maybe consider using hashtables
1963 LIST_FOR_EACH_ENTRY(entry
, shaders
, struct ffp_desc
, entry
) {
1964 if(memcmp(settings
, &entry
->settings
, sizeof(*settings
)) == 0) {
1965 TRACE("Found shader entry %p\n", entry
);
1970 TRACE("Shader not found\n");
1974 void add_ffp_shader(struct list
*shaders
, struct ffp_desc
*desc
) {
1975 list_add_head(shaders
, &desc
->entry
);
1978 /* Activates the texture dimension according to the bound D3D texture.
1979 * Does not care for the colorop or correct gl texture unit(when using nvrc)
1980 * Requires the caller to activate the correct unit before
1982 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
1983 void texture_activate_dimensions(DWORD stage
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
1984 if(stateblock
->textures
[stage
]) {
1985 switch(stateblock
->textureDimensions
[stage
]) {
1987 glDisable(GL_TEXTURE_3D
);
1988 checkGLcall("glDisable(GL_TEXTURE_3D)");
1989 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
1990 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
1991 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1993 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
1994 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
1995 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
1997 glEnable(GL_TEXTURE_2D
);
1998 checkGLcall("glEnable(GL_TEXTURE_2D)");
2000 case GL_TEXTURE_RECTANGLE_ARB
:
2001 glDisable(GL_TEXTURE_2D
);
2002 checkGLcall("glDisable(GL_TEXTURE_2D)");
2003 glDisable(GL_TEXTURE_3D
);
2004 checkGLcall("glDisable(GL_TEXTURE_3D)");
2005 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2006 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2007 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2009 glEnable(GL_TEXTURE_RECTANGLE_ARB
);
2010 checkGLcall("glEnable(GL_TEXTURE_RECTANGLE_ARB)");
2013 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2014 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2015 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2017 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2018 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2019 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2021 glDisable(GL_TEXTURE_2D
);
2022 checkGLcall("glDisable(GL_TEXTURE_2D)");
2023 glEnable(GL_TEXTURE_3D
);
2024 checkGLcall("glEnable(GL_TEXTURE_3D)");
2026 case GL_TEXTURE_CUBE_MAP_ARB
:
2027 glDisable(GL_TEXTURE_2D
);
2028 checkGLcall("glDisable(GL_TEXTURE_2D)");
2029 glDisable(GL_TEXTURE_3D
);
2030 checkGLcall("glDisable(GL_TEXTURE_3D)");
2031 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2032 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2033 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2035 glEnable(GL_TEXTURE_CUBE_MAP_ARB
);
2036 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
2040 glEnable(GL_TEXTURE_2D
);
2041 checkGLcall("glEnable(GL_TEXTURE_2D)");
2042 glDisable(GL_TEXTURE_3D
);
2043 checkGLcall("glDisable(GL_TEXTURE_3D)");
2044 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2045 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
2046 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2048 if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE
)) {
2049 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
2050 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2052 /* Binding textures is done by samplers. A dummy texture will be bound */
2056 void sampler_texdim(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
2057 DWORD sampler
= state
- STATE_SAMPLER(0);
2058 DWORD mapped_stage
= stateblock
->wineD3DDevice
->texUnitMap
[sampler
];
2060 /* No need to enable / disable anything here for unused samplers. The tex_colorop
2061 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
2062 * will take care of this business
2064 if(mapped_stage
== -1 || mapped_stage
>= GL_LIMITS(textures
)) return;
2065 if(sampler
>= stateblock
->lowest_disabled_stage
) return;
2066 if(use_ps(stateblock
->wineD3DDevice
)) return;
2067 if(isStateDirty(context
, STATE_TEXTURESTAGE(sampler
, WINED3DTSS_COLOROP
))) return;
2069 texture_activate_dimensions(sampler
, stateblock
, context
);
2071 #undef GLINFO_LOCATION