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 Henri Verbeet
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wined3d_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
30 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
32 /*****************************************************************************
35 static const PixelFormatDesc formats
[] = {
36 /*{WINED3DFORMAT ,alphamask ,redmask ,greenmask ,bluemask ,bpp ,isFourcc ,internal ,format ,type }*/
37 {WINED3DFMT_UNKNOWN
,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE
,0 ,0 ,0 },
38 /* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
39 {WINED3DFMT_UYVY
,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE
,0 ,0 ,0 },
40 {WINED3DFMT_YUY2
,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE
,0 ,0 ,0 },
41 {WINED3DFMT_DXT1
,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE
,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
,GL_RGBA
,GL_UNSIGNED_BYTE
},
42 {WINED3DFMT_DXT2
,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE
,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
,GL_RGBA
,GL_UNSIGNED_BYTE
},
43 {WINED3DFMT_DXT3
,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE
,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
,GL_RGBA
,GL_UNSIGNED_BYTE
},
44 {WINED3DFMT_DXT4
,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE
,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
,GL_RGBA
,GL_UNSIGNED_BYTE
},
45 {WINED3DFMT_DXT5
,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE
,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
,GL_RGBA
,GL_UNSIGNED_BYTE
},
46 {WINED3DFMT_MULTI2_ARGB
,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE
,0 ,0 ,0 },
47 {WINED3DFMT_G8R8_G8B8
,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE
,0 ,0 ,0 },
48 {WINED3DFMT_R8G8_B8G8
,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE
,0 ,0 ,0 },
50 {WINED3DFMT_R32F
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,GL_RGB32F_ARB
,GL_RED
,GL_FLOAT
},
51 {WINED3DFMT_G32R32F
,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE
,0 ,0 ,0 },
52 {WINED3DFMT_A32B32G32R32F
,0x0 ,0x0 ,0x0 ,0x0 ,16 ,FALSE
,GL_RGBA32F_ARB
,GL_RGBA
,GL_FLOAT
},
54 {WINED3DFMT_CxV8U8
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,0 ,0 ,0 },
56 {WINED3DFMT_R16F
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,GL_RGB16F_ARB
,GL_RED
,GL_HALF_FLOAT_ARB
},
57 {WINED3DFMT_G16R16F
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,0 ,0 ,0 },
58 {WINED3DFMT_A16B16G16R16F
,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE
,GL_RGBA16F_ARB
,GL_RGBA
,GL_HALF_FLOAT_ARB
},
59 /* Palettized formats */
60 {WINED3DFMT_A8P8
,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,0 ,0 ,0 },
61 {WINED3DFMT_P8
,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE
,GL_COLOR_INDEX8_EXT
,GL_COLOR_INDEX
,GL_UNSIGNED_BYTE
},
62 /* Standard ARGB formats. Keep WINED3DFMT_R8G8B8(=20) at position 20 */
63 {WINED3DFMT_R8G8B8
,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,3 ,FALSE
,GL_RGB8
,GL_BGR
,GL_UNSIGNED_BYTE
},
64 {WINED3DFMT_A8R8G8B8
,0xff000000 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,FALSE
,GL_RGBA8
,GL_BGRA
,GL_UNSIGNED_INT_8_8_8_8_REV
},
65 {WINED3DFMT_X8R8G8B8
,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,FALSE
,GL_RGB8
,GL_BGRA
,GL_UNSIGNED_INT_8_8_8_8_REV
},
66 {WINED3DFMT_R5G6B5
,0x0 ,0x0000F800 ,0x000007e0 ,0x0000001f ,2 ,FALSE
,GL_RGB5
,GL_RGB
,GL_UNSIGNED_SHORT_5_6_5
},
67 {WINED3DFMT_X1R5G5B5
,0x0 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,FALSE
,GL_RGB5_A1
,GL_BGRA
,GL_UNSIGNED_SHORT_1_5_5_5_REV
},
68 {WINED3DFMT_A1R5G5B5
,0x00008000 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,FALSE
,GL_RGB5_A1
,GL_BGRA
,GL_UNSIGNED_SHORT_1_5_5_5_REV
},
69 {WINED3DFMT_A4R4G4B4
,0x0000f000 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,FALSE
,GL_RGBA4
,GL_BGRA
,GL_UNSIGNED_SHORT_4_4_4_4_REV
},
70 {WINED3DFMT_R3G3B2
,0x0 ,0x000000e0 ,0x0000001c ,0x00000003 ,1 ,FALSE
,GL_R3_G3_B2
,GL_RGB
,GL_UNSIGNED_BYTE_2_3_3_REV
},
71 {WINED3DFMT_A8
,0x000000ff ,0x0 ,0x0 ,0x0 ,1 ,FALSE
,GL_ALPHA8
,GL_ALPHA
,GL_ALPHA
},
72 {WINED3DFMT_A8R3G3B2
,0x0000ff00 ,0x000000e0 ,0x0000001c ,0x00000003 ,2 ,FALSE
,0 ,0 ,0 },
73 {WINED3DFMT_X4R4G4B4
,0x0 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,FALSE
,GL_RGB4
,GL_BGRA
,GL_UNSIGNED_SHORT_4_4_4_4_REV
},
74 {WINED3DFMT_A2B10G10R10
,0xb0000000 ,0x000003ff ,0x000ffc00 ,0x3ff00000 ,4 ,FALSE
,GL_RGB
,GL_RGBA
,GL_UNSIGNED_INT_2_10_10_10_REV
},
75 {WINED3DFMT_A8B8G8R8
,0xff000000 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,FALSE
,GL_RGBA8
,GL_RGBA
,GL_UNSIGNED_INT_8_8_8_8_REV
},
76 {WINED3DFMT_X8B8G8R8
,0x0 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,FALSE
,GL_RGB8
,GL_RGBA
,GL_UNSIGNED_INT_8_8_8_8_REV
},
77 {WINED3DFMT_G16R16
,0x0 ,0x0000ffff ,0xffff0000 ,0x0 ,4 ,FALSE
,0 ,0 ,0 },
78 {WINED3DFMT_A2R10G10B10
,0xb0000000 ,0x3ff00000 ,0x000ffc00 ,0x000003ff ,4 ,FALSE
,GL_RGBA
,GL_BGRA
,GL_UNSIGNED_INT_2_10_10_10_REV
},
79 {WINED3DFMT_A16B16G16R16
,0x0 ,0x0000ffff ,0xffff0000 ,0x0 ,8 ,FALSE
,GL_RGBA16_EXT
,GL_RGBA
,GL_UNSIGNED_SHORT
},
81 {WINED3DFMT_L8
,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE
,GL_LUMINANCE8
,GL_LUMINANCE
,GL_UNSIGNED_BYTE
},
82 {WINED3DFMT_A8L8
,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,GL_LUMINANCE8_ALPHA8
,GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
},
83 {WINED3DFMT_A4L4
,0x000000f0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE
,GL_LUMINANCE4_ALPHA4
,GL_LUMINANCE_ALPHA
,GL_UNSIGNED_BYTE
},
84 /* Bump mapping stuff */
85 {WINED3DFMT_V8U8
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,GL_COLOR_INDEX8_EXT
,GL_COLOR_INDEX
,GL_UNSIGNED_BYTE
},
86 {WINED3DFMT_L6V5U5
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,GL_COLOR_INDEX8_EXT
,GL_COLOR_INDEX
,GL_UNSIGNED_SHORT_5_5_5_1
},
87 {WINED3DFMT_X8L8V8U8
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,GL_RGBA8
,GL_BGRA
,GL_UNSIGNED_BYTE
},
88 {WINED3DFMT_Q8W8V8U8
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,GL_RGBA8
,GL_RGBA
,GL_UNSIGNED_INT_8_8_8_8_REV
/*?*/},
89 {WINED3DFMT_V16U16
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_SHORT
},
90 {WINED3DFMT_W11V11U10
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,0 ,0 ,0 },
91 {WINED3DFMT_A2W10V10U10
,0xb0000000 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,0 ,0 ,0 },
92 /* Depth stencil formats */
93 {WINED3DFMT_D16_LOCKABLE
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_SHORT
},
94 {WINED3DFMT_D32
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_INT
},
95 {WINED3DFMT_D15S1
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_SHORT
},
96 {WINED3DFMT_D24S8
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_INT
},
97 {WINED3DFMT_D24X8
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_INT
},
98 {WINED3DFMT_D24X4S4
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_INT
},
99 {WINED3DFMT_D16
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_SHORT
},
100 {WINED3DFMT_L16
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,GL_LUMINANCE16_EXT
,GL_LUMINANCE
,GL_UNSIGNED_SHORT
},
101 {WINED3DFMT_D32F_LOCKABLE
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,0 ,0 ,0 },
102 {WINED3DFMT_D24FS8
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,0 ,0 ,0 },
103 /* Is this a vertex buffer? */
104 {WINED3DFMT_VERTEXDATA
,0x0 ,0x0 ,0x0 ,0x0 ,0 ,FALSE
,0 ,0 ,0 },
105 {WINED3DFMT_INDEX16
,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE
,0 ,0 ,0 },
106 {WINED3DFMT_INDEX32
,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE
,0 ,0 ,0 },
107 {WINED3DFMT_Q16W16V16U16
,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE
,GL_COLOR_INDEX
,GL_COLOR_INDEX
,GL_UNSIGNED_SHORT
}
110 const PixelFormatDesc
*getFormatDescEntry(WINED3DFORMAT fmt
)
112 /* First check if the format is at the position of its value.
113 * This will catch the argb formats before the loop is entered
115 if(fmt
< (sizeof(formats
) / sizeof(formats
[0])) && formats
[fmt
].format
== fmt
) {
116 return &formats
[fmt
];
119 for(i
= 0; i
< (sizeof(formats
) / sizeof(formats
[0])); i
++) {
120 if(formats
[i
].format
== fmt
) {
125 FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt
), fmt
);
126 if(fmt
== WINED3DFMT_UNKNOWN
) {
127 ERR("Format table corrupt - Can't find WINED3DFMT_UNKNOWN\n");
130 /* Get the caller a valid pointer */
131 return getFormatDescEntry(WINED3DFMT_UNKNOWN
);
134 /*****************************************************************************
135 * Trace formatting of useful values
137 const char* debug_d3dformat(WINED3DFORMAT fmt
) {
139 #define FMT_TO_STR(fmt) case fmt: return #fmt
140 FMT_TO_STR(WINED3DFMT_UNKNOWN
);
141 FMT_TO_STR(WINED3DFMT_R8G8B8
);
142 FMT_TO_STR(WINED3DFMT_A8R8G8B8
);
143 FMT_TO_STR(WINED3DFMT_X8R8G8B8
);
144 FMT_TO_STR(WINED3DFMT_R5G6B5
);
145 FMT_TO_STR(WINED3DFMT_X1R5G5B5
);
146 FMT_TO_STR(WINED3DFMT_A1R5G5B5
);
147 FMT_TO_STR(WINED3DFMT_A4R4G4B4
);
148 FMT_TO_STR(WINED3DFMT_R3G3B2
);
149 FMT_TO_STR(WINED3DFMT_A8
);
150 FMT_TO_STR(WINED3DFMT_A8R3G3B2
);
151 FMT_TO_STR(WINED3DFMT_X4R4G4B4
);
152 FMT_TO_STR(WINED3DFMT_A2B10G10R10
);
153 FMT_TO_STR(WINED3DFMT_A8B8G8R8
);
154 FMT_TO_STR(WINED3DFMT_X8B8G8R8
);
155 FMT_TO_STR(WINED3DFMT_G16R16
);
156 FMT_TO_STR(WINED3DFMT_A2R10G10B10
);
157 FMT_TO_STR(WINED3DFMT_A16B16G16R16
);
158 FMT_TO_STR(WINED3DFMT_A8P8
);
159 FMT_TO_STR(WINED3DFMT_P8
);
160 FMT_TO_STR(WINED3DFMT_L8
);
161 FMT_TO_STR(WINED3DFMT_A8L8
);
162 FMT_TO_STR(WINED3DFMT_A4L4
);
163 FMT_TO_STR(WINED3DFMT_V8U8
);
164 FMT_TO_STR(WINED3DFMT_L6V5U5
);
165 FMT_TO_STR(WINED3DFMT_X8L8V8U8
);
166 FMT_TO_STR(WINED3DFMT_Q8W8V8U8
);
167 FMT_TO_STR(WINED3DFMT_V16U16
);
168 FMT_TO_STR(WINED3DFMT_W11V11U10
);
169 FMT_TO_STR(WINED3DFMT_A2W10V10U10
);
170 FMT_TO_STR(WINED3DFMT_UYVY
);
171 FMT_TO_STR(WINED3DFMT_YUY2
);
172 FMT_TO_STR(WINED3DFMT_DXT1
);
173 FMT_TO_STR(WINED3DFMT_DXT2
);
174 FMT_TO_STR(WINED3DFMT_DXT3
);
175 FMT_TO_STR(WINED3DFMT_DXT4
);
176 FMT_TO_STR(WINED3DFMT_DXT5
);
177 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB
);
178 FMT_TO_STR(WINED3DFMT_G8R8_G8B8
);
179 FMT_TO_STR(WINED3DFMT_R8G8_B8G8
);
180 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE
);
181 FMT_TO_STR(WINED3DFMT_D32
);
182 FMT_TO_STR(WINED3DFMT_D15S1
);
183 FMT_TO_STR(WINED3DFMT_D24S8
);
184 FMT_TO_STR(WINED3DFMT_D24X8
);
185 FMT_TO_STR(WINED3DFMT_D24X4S4
);
186 FMT_TO_STR(WINED3DFMT_D16
);
187 FMT_TO_STR(WINED3DFMT_L16
);
188 FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE
);
189 FMT_TO_STR(WINED3DFMT_D24FS8
);
190 FMT_TO_STR(WINED3DFMT_VERTEXDATA
);
191 FMT_TO_STR(WINED3DFMT_INDEX16
);
192 FMT_TO_STR(WINED3DFMT_INDEX32
);
193 FMT_TO_STR(WINED3DFMT_Q16W16V16U16
);
194 FMT_TO_STR(WINED3DFMT_R16F
);
195 FMT_TO_STR(WINED3DFMT_G16R16F
);
196 FMT_TO_STR(WINED3DFMT_A16B16G16R16F
);
197 FMT_TO_STR(WINED3DFMT_R32F
);
198 FMT_TO_STR(WINED3DFMT_G32R32F
);
199 FMT_TO_STR(WINED3DFMT_A32B32G32R32F
);
200 FMT_TO_STR(WINED3DFMT_CxV8U8
);
205 fourcc
[0] = (char)(fmt
);
206 fourcc
[1] = (char)(fmt
>> 8);
207 fourcc
[2] = (char)(fmt
>> 16);
208 fourcc
[3] = (char)(fmt
>> 24);
210 if( isprint(fourcc
[0]) && isprint(fourcc
[1]) && isprint(fourcc
[2]) && isprint(fourcc
[3]) )
211 FIXME("Unrecognized %u (as fourcc: %s) WINED3DFORMAT!\n", fmt
, fourcc
);
213 FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt
);
215 return "unrecognized";
219 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype
) {
221 #define DEVTYPE_TO_STR(dev) case dev: return #dev
222 DEVTYPE_TO_STR(WINED3DDEVTYPE_HAL
);
223 DEVTYPE_TO_STR(WINED3DDEVTYPE_REF
);
224 DEVTYPE_TO_STR(WINED3DDEVTYPE_SW
);
225 #undef DEVTYPE_TO_STR
227 FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype
);
228 return "unrecognized";
232 const char* debug_d3dusage(DWORD usage
) {
233 switch (usage
& WINED3DUSAGE_MASK
) {
234 #define WINED3DUSAGE_TO_STR(u) case u: return #u
235 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET
);
236 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL
);
237 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY
);
238 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING
);
239 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP
);
240 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS
);
241 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES
);
242 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES
);
243 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC
);
244 WINED3DUSAGE_TO_STR(WINED3DUSAGE_AUTOGENMIPMAP
);
245 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DMAP
);
246 #undef WINED3DUSAGE_TO_STR
247 case 0: return "none";
249 FIXME("Unrecognized %u Usage!\n", usage
);
250 return "unrecognized";
254 const char* debug_d3dusagequery(DWORD usagequery
) {
255 switch (usagequery
& WINED3DUSAGE_QUERY_MASK
) {
256 #define WINED3DUSAGEQUERY_TO_STR(u) case u: return #u
257 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_FILTER
);
258 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_LEGACYBUMPMAP
);
259 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
);
260 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBREAD
);
261 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_SRGBWRITE
);
262 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_VERTEXTEXTURE
);
263 WINED3DUSAGEQUERY_TO_STR(WINED3DUSAGE_QUERY_WRAPANDMIP
);
264 #undef WINED3DUSAGEQUERY_TO_STR
265 case 0: return "none";
267 FIXME("Unrecognized %u Usage Query!\n", usagequery
);
268 return "unrecognized";
272 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method
) {
274 #define WINED3DDECLMETHOD_TO_STR(u) case u: return #u
275 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_DEFAULT
);
276 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALU
);
277 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_PARTIALV
);
278 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_CROSSUV
);
279 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_UV
);
280 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUP
);
281 WINED3DDECLMETHOD_TO_STR(WINED3DDECLMETHOD_LOOKUPPRESAMPLED
);
282 #undef WINED3DDECLMETHOD_TO_STR
284 FIXME("Unrecognized %u declaration method!\n", method
);
285 return "unrecognized";
289 const char* debug_d3ddecltype(WINED3DDECLTYPE type
) {
291 #define WINED3DDECLTYPE_TO_STR(u) case u: return #u
292 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT1
);
293 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT2
);
294 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT3
);
295 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT4
);
296 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_D3DCOLOR
);
297 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4
);
298 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2
);
299 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4
);
300 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UBYTE4N
);
301 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT2N
);
302 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_SHORT4N
);
303 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT2N
);
304 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_USHORT4N
);
305 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UDEC3
);
306 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_DEC3N
);
307 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_2
);
308 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_FLOAT16_4
);
309 WINED3DDECLTYPE_TO_STR(WINED3DDECLTYPE_UNUSED
);
310 #undef WINED3DDECLTYPE_TO_STR
312 FIXME("Unrecognized %u declaration type!\n", type
);
313 return "unrecognized";
317 const char* debug_d3ddeclusage(BYTE usage
) {
319 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
320 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_POSITION
);
321 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_BLENDWEIGHT
);
322 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_BLENDINDICES
);
323 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_NORMAL
);
324 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_PSIZE
);
325 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_TEXCOORD
);
326 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_TANGENT
);
327 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_BINORMAL
);
328 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_TESSFACTOR
);
329 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_POSITIONT
);
330 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_COLOR
);
331 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_FOG
);
332 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_DEPTH
);
333 WINED3DDECLUSAGE_TO_STR(D3DDECLUSAGE_SAMPLE
);
334 #undef WINED3DDECLUSAGE_TO_STR
336 FIXME("Unrecognized %u declaration usage!\n", usage
);
337 return "unrecognized";
341 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res
) {
343 #define RES_TO_STR(res) case res: return #res;
344 RES_TO_STR(WINED3DRTYPE_SURFACE
);
345 RES_TO_STR(WINED3DRTYPE_VOLUME
);
346 RES_TO_STR(WINED3DRTYPE_TEXTURE
);
347 RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE
);
348 RES_TO_STR(WINED3DRTYPE_CUBETEXTURE
);
349 RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER
);
350 RES_TO_STR(WINED3DRTYPE_INDEXBUFFER
);
353 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res
);
354 return "unrecognized";
358 const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType
) {
359 switch (PrimitiveType
) {
360 #define PRIM_TO_STR(prim) case prim: return #prim;
361 PRIM_TO_STR(WINED3DPT_POINTLIST
);
362 PRIM_TO_STR(WINED3DPT_LINELIST
);
363 PRIM_TO_STR(WINED3DPT_LINESTRIP
);
364 PRIM_TO_STR(WINED3DPT_TRIANGLELIST
);
365 PRIM_TO_STR(WINED3DPT_TRIANGLESTRIP
);
366 PRIM_TO_STR(WINED3DPT_TRIANGLEFAN
);
369 FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType
);
370 return "unrecognized";
374 const char* debug_d3drenderstate(DWORD state
) {
376 #define D3DSTATE_TO_STR(u) case u: return #u
377 D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE
);
378 D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS
);
379 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS
);
380 D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE
);
381 D3DSTATE_TO_STR(WINED3DRS_WRAPU
);
382 D3DSTATE_TO_STR(WINED3DRS_WRAPV
);
383 D3DSTATE_TO_STR(WINED3DRS_ZENABLE
);
384 D3DSTATE_TO_STR(WINED3DRS_FILLMODE
);
385 D3DSTATE_TO_STR(WINED3DRS_SHADEMODE
);
386 D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN
);
387 D3DSTATE_TO_STR(WINED3DRS_MONOENABLE
);
388 D3DSTATE_TO_STR(WINED3DRS_ROP2
);
389 D3DSTATE_TO_STR(WINED3DRS_PLANEMASK
);
390 D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE
);
391 D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE
);
392 D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL
);
393 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG
);
394 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN
);
395 D3DSTATE_TO_STR(WINED3DRS_SRCBLEND
);
396 D3DSTATE_TO_STR(WINED3DRS_DESTBLEND
);
397 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND
);
398 D3DSTATE_TO_STR(WINED3DRS_CULLMODE
);
399 D3DSTATE_TO_STR(WINED3DRS_ZFUNC
);
400 D3DSTATE_TO_STR(WINED3DRS_ALPHAREF
);
401 D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC
);
402 D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE
);
403 D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE
);
404 D3DSTATE_TO_STR(WINED3DRS_FOGENABLE
);
405 D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE
);
406 D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE
);
407 D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL
);
408 D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX
);
409 D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA
);
410 D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR
);
411 D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE
);
412 D3DSTATE_TO_STR(WINED3DRS_FOGSTART
);
413 D3DSTATE_TO_STR(WINED3DRS_FOGEND
);
414 D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY
);
415 D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE
);
416 D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS
);
417 D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE
);
418 D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR
);
419 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU
);
420 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV
);
421 D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS
);
422 D3DSTATE_TO_STR(WINED3DRS_ZBIAS
);
423 D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE
);
424 D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY
);
425 D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH
);
426 D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
);
427 D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE
);
428 D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL
);
429 D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL
);
430 D3DSTATE_TO_STR(WINED3DRS_STENCILPASS
);
431 D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC
);
432 D3DSTATE_TO_STR(WINED3DRS_STENCILREF
);
433 D3DSTATE_TO_STR(WINED3DRS_STENCILMASK
);
434 D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK
);
435 D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR
);
436 D3DSTATE_TO_STR(WINED3DRS_WRAP0
);
437 D3DSTATE_TO_STR(WINED3DRS_WRAP1
);
438 D3DSTATE_TO_STR(WINED3DRS_WRAP2
);
439 D3DSTATE_TO_STR(WINED3DRS_WRAP3
);
440 D3DSTATE_TO_STR(WINED3DRS_WRAP4
);
441 D3DSTATE_TO_STR(WINED3DRS_WRAP5
);
442 D3DSTATE_TO_STR(WINED3DRS_WRAP6
);
443 D3DSTATE_TO_STR(WINED3DRS_WRAP7
);
444 D3DSTATE_TO_STR(WINED3DRS_CLIPPING
);
445 D3DSTATE_TO_STR(WINED3DRS_LIGHTING
);
446 D3DSTATE_TO_STR(WINED3DRS_EXTENTS
);
447 D3DSTATE_TO_STR(WINED3DRS_AMBIENT
);
448 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE
);
449 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX
);
450 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER
);
451 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS
);
452 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE
);
453 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE
);
454 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE
);
455 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE
);
456 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE
);
457 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND
);
458 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE
);
459 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING
);
460 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE
);
461 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN
);
462 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE
);
463 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE
);
464 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A
);
465 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B
);
466 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C
);
467 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS
);
468 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK
);
469 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE
);
470 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS
);
471 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN
);
472 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX
);
473 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE
);
474 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE
);
475 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR
);
476 D3DSTATE_TO_STR(WINED3DRS_BLENDOP
);
477 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE
);
478 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE
);
479 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE
);
480 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS
);
481 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE
);
482 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL
);
483 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL
);
484 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X
);
485 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y
);
486 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z
);
487 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W
);
488 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION
);
489 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE
);
490 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL
);
491 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL
);
492 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS
);
493 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC
);
494 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1
);
495 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2
);
496 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3
);
497 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR
);
498 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE
);
499 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS
);
500 D3DSTATE_TO_STR(WINED3DRS_WRAP8
);
501 D3DSTATE_TO_STR(WINED3DRS_WRAP9
);
502 D3DSTATE_TO_STR(WINED3DRS_WRAP10
);
503 D3DSTATE_TO_STR(WINED3DRS_WRAP11
);
504 D3DSTATE_TO_STR(WINED3DRS_WRAP12
);
505 D3DSTATE_TO_STR(WINED3DRS_WRAP13
);
506 D3DSTATE_TO_STR(WINED3DRS_WRAP14
);
507 D3DSTATE_TO_STR(WINED3DRS_WRAP15
);
508 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE
);
509 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA
);
510 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA
);
511 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA
);
512 #undef D3DSTATE_TO_STR
514 FIXME("Unrecognized %u render state!\n", state
);
515 return "unrecognized";
519 const char* debug_d3dsamplerstate(DWORD state
) {
521 #define D3DSTATE_TO_STR(u) case u: return #u
522 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR
);
523 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU
);
524 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV
);
525 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW
);
526 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER
);
527 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER
);
528 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER
);
529 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS
);
530 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL
);
531 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY
);
532 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE
);
533 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX
);
534 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET
);
535 #undef D3DSTATE_TO_STR
537 FIXME("Unrecognized %u sampler state!\n", state
);
538 return "unrecognized";
542 const char* debug_d3dtexturestate(DWORD state
) {
544 #define D3DSTATE_TO_STR(u) case u: return #u
545 D3DSTATE_TO_STR(WINED3DTSS_COLOROP
);
546 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1
);
547 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2
);
548 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP
);
549 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1
);
550 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2
);
551 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00
);
552 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01
);
553 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10
);
554 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11
);
555 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX
);
556 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE
);
557 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET
);
558 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS
);
559 D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW
);
560 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0
);
561 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0
);
562 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG
);
563 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT
);
564 #undef D3DSTATE_TO_STR
566 /* Note WINED3DTSS are not consecutive, so skip these */
570 FIXME("Unrecognized %u texture state!\n", state
);
571 return "unrecognized";
575 const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop
) {
577 #define D3DTOP_TO_STR(u) case u: return #u
578 D3DTOP_TO_STR(WINED3DTOP_DISABLE
);
579 D3DTOP_TO_STR(WINED3DTOP_SELECTARG1
);
580 D3DTOP_TO_STR(WINED3DTOP_SELECTARG2
);
581 D3DTOP_TO_STR(WINED3DTOP_MODULATE
);
582 D3DTOP_TO_STR(WINED3DTOP_MODULATE2X
);
583 D3DTOP_TO_STR(WINED3DTOP_MODULATE4X
);
584 D3DTOP_TO_STR(WINED3DTOP_ADD
);
585 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED
);
586 D3DTOP_TO_STR(WINED3DTOP_SUBTRACT
);
587 D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH
);
588 D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA
);
589 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA
);
590 D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA
);
591 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM
);
592 D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA
);
593 D3DTOP_TO_STR(WINED3DTOP_PREMODULATE
);
594 D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR
);
595 D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA
);
596 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
);
597 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
);
598 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP
);
599 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE
);
600 D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3
);
601 D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD
);
602 D3DTOP_TO_STR(WINED3DTOP_LERP
);
605 FIXME("Unrecognized %u WINED3DTOP\n", d3dtop
);
606 return "unrecognized";
610 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype
) {
612 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
613 TSTYPE_TO_STR(WINED3DTS_VIEW
);
614 TSTYPE_TO_STR(WINED3DTS_PROJECTION
);
615 TSTYPE_TO_STR(WINED3DTS_TEXTURE0
);
616 TSTYPE_TO_STR(WINED3DTS_TEXTURE1
);
617 TSTYPE_TO_STR(WINED3DTS_TEXTURE2
);
618 TSTYPE_TO_STR(WINED3DTS_TEXTURE3
);
619 TSTYPE_TO_STR(WINED3DTS_TEXTURE4
);
620 TSTYPE_TO_STR(WINED3DTS_TEXTURE5
);
621 TSTYPE_TO_STR(WINED3DTS_TEXTURE6
);
622 TSTYPE_TO_STR(WINED3DTS_TEXTURE7
);
623 TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
626 if (tstype
> 256 && tstype
< 512) {
627 FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype
);
628 return ("WINED3DTS_WORLDMATRIX > 0");
630 FIXME("Unrecognized %u WINED3DTS\n", tstype
);
631 return "unrecognized";
635 const char* debug_d3dpool(WINED3DPOOL Pool
) {
637 #define POOL_TO_STR(p) case p: return #p;
638 POOL_TO_STR(WINED3DPOOL_DEFAULT
);
639 POOL_TO_STR(WINED3DPOOL_MANAGED
);
640 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM
);
641 POOL_TO_STR(WINED3DPOOL_SCRATCH
);
644 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool
);
645 return "unrecognized";
649 /*****************************************************************************
650 * Useful functions mapping GL <-> D3D values
652 GLenum
StencilOp(DWORD op
) {
654 case D3DSTENCILOP_KEEP
: return GL_KEEP
;
655 case D3DSTENCILOP_ZERO
: return GL_ZERO
;
656 case D3DSTENCILOP_REPLACE
: return GL_REPLACE
;
657 case D3DSTENCILOP_INCRSAT
: return GL_INCR
;
658 case D3DSTENCILOP_DECRSAT
: return GL_DECR
;
659 case D3DSTENCILOP_INVERT
: return GL_INVERT
;
660 case D3DSTENCILOP_INCR
: return GL_INCR_WRAP_EXT
;
661 case D3DSTENCILOP_DECR
: return GL_DECR_WRAP_EXT
;
663 FIXME("Unrecognized stencil op %d\n", op
);
668 GLenum
CompareFunc(DWORD func
) {
669 switch ((D3DCMPFUNC
)func
) {
670 case D3DCMP_NEVER
: return GL_NEVER
;
671 case D3DCMP_LESS
: return GL_LESS
;
672 case D3DCMP_EQUAL
: return GL_EQUAL
;
673 case D3DCMP_LESSEQUAL
: return GL_LEQUAL
;
674 case D3DCMP_GREATER
: return GL_GREATER
;
675 case D3DCMP_NOTEQUAL
: return GL_NOTEQUAL
;
676 case D3DCMP_GREATEREQUAL
: return GL_GEQUAL
;
677 case D3DCMP_ALWAYS
: return GL_ALWAYS
;
679 FIXME("Unrecognized D3DCMPFUNC value %d\n", func
);
684 static GLenum
d3dta_to_combiner_input(DWORD d3dta
, DWORD stage
, INT texture_idx
) {
687 return GL_PRIMARY_COLOR_NV
;
690 if (stage
) return GL_SPARE0_NV
;
691 else return GL_PRIMARY_COLOR_NV
;
694 if (texture_idx
> -1) return GL_TEXTURE0_ARB
+ texture_idx
;
695 else return GL_PRIMARY_COLOR_NV
;
698 return GL_CONSTANT_COLOR0_NV
;
701 return GL_SECONDARY_COLOR_NV
;
704 /* TODO: Support WINED3DTSS_RESULTARG */
705 FIXME("D3DTA_TEMP, not properly supported.\n");
709 /* TODO: Support per stage constants (WINED3DTSS_CONSTANT, NV_register_combiners2) */
710 FIXME("D3DTA_CONSTANT, not properly supported.\n");
711 return GL_CONSTANT_COLOR1_NV
;
714 FIXME("Unrecognized texture arg %#x\n", d3dta
);
719 static GLenum
invert_mapping(GLenum mapping
) {
720 if (mapping
== GL_UNSIGNED_INVERT_NV
) return GL_SIGNED_IDENTITY_NV
;
721 else if (mapping
== GL_SIGNED_IDENTITY_NV
) return GL_UNSIGNED_INVERT_NV
;
723 FIXME("Unhandled mapping %#x\n", mapping
);
727 static void get_src_and_opr_nvrc(DWORD stage
, DWORD arg
, BOOL is_alpha
, GLenum
* input
, GLenum
* mapping
, GLenum
*component_usage
, INT texture_idx
) {
728 /* The D3DTA_COMPLEMENT flag specifies the complement of the input should
730 if (arg
& D3DTA_COMPLEMENT
) *mapping
= GL_UNSIGNED_INVERT_NV
;
731 else *mapping
= GL_SIGNED_IDENTITY_NV
;
733 /* The D3DTA_ALPHAREPLICATE flag specifies the alpha component of the input
734 * should be used for all input components. */
735 if (is_alpha
|| arg
& D3DTA_ALPHAREPLICATE
) *component_usage
= GL_ALPHA
;
736 else *component_usage
= GL_RGB
;
738 *input
= d3dta_to_combiner_input(arg
& D3DTA_SELECTMASK
, stage
, texture_idx
);
744 GLenum component_usage
[3];
747 static BOOL
is_invalid_op(IWineD3DDeviceImpl
*This
, int stage
, WINED3DTEXTUREOP op
, DWORD arg1
, DWORD arg2
, DWORD arg3
) {
748 if (op
== WINED3DTOP_DISABLE
) return FALSE
;
749 if (This
->stateBlock
->textures
[stage
]) return FALSE
;
751 if (arg1
== D3DTA_TEXTURE
&& op
!= WINED3DTOP_SELECTARG2
) return TRUE
;
752 if (arg2
== D3DTA_TEXTURE
&& op
!= WINED3DTOP_SELECTARG1
) return TRUE
;
753 if (arg3
== D3DTA_TEXTURE
&& (op
== WINED3DTOP_MULTIPLYADD
|| op
== WINED3DTOP_LERP
)) return TRUE
;
758 void set_tex_op_nvrc(IWineD3DDevice
*iface
, BOOL is_alpha
, int stage
, WINED3DTEXTUREOP op
, DWORD arg1
, DWORD arg2
, DWORD arg3
, INT texture_idx
) {
759 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
760 tex_op_args tex_op_args
= {{0}, {0}, {0}};
761 GLenum portion
= is_alpha
? GL_ALPHA
: GL_RGB
;
762 GLenum target
= GL_COMBINER0_NV
+ stage
;
764 TRACE("stage %d, is_alpha %d, op %s, arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
765 stage
, is_alpha
, debug_d3dtop(op
), arg1
, arg2
, arg3
, texture_idx
);
767 /* If a texture stage references an invalid texture unit the stage just
768 * passes through the result from the previous stage */
769 if (is_invalid_op(This
, stage
, op
, arg1
, arg2
, arg3
)) {
770 arg1
= D3DTA_CURRENT
;
771 op
= WINED3DTOP_SELECTARG1
;
774 get_src_and_opr_nvrc(stage
, arg1
, is_alpha
, &tex_op_args
.input
[0],
775 &tex_op_args
.mapping
[0], &tex_op_args
.component_usage
[0], texture_idx
);
776 get_src_and_opr_nvrc(stage
, arg2
, is_alpha
, &tex_op_args
.input
[1],
777 &tex_op_args
.mapping
[1], &tex_op_args
.component_usage
[1], texture_idx
);
778 get_src_and_opr_nvrc(stage
, arg3
, is_alpha
, &tex_op_args
.input
[2],
779 &tex_op_args
.mapping
[2], &tex_op_args
.component_usage
[2], texture_idx
);
785 case WINED3DTOP_DISABLE
:
787 if (!is_alpha
) ERR("Shouldn't be called for WINED3DTSS_COLOROP (WINED3DTOP_DISABLE)\n");
788 /* Input, prev_alpha*1 */
789 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
790 GL_SPARE0_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_ALPHA
));
791 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
792 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, GL_ALPHA
));
795 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_SPARE0_NV
, GL_DISCARD_NV
,
796 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
799 case WINED3DTOP_SELECTARG1
:
800 case WINED3DTOP_SELECTARG2
:
802 if (op
== WINED3DTOP_SELECTARG1
) {
803 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
804 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
806 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
807 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
809 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
810 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
813 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_SPARE0_NV
, GL_DISCARD_NV
,
814 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
817 case WINED3DTOP_MODULATE
:
818 case WINED3DTOP_MODULATE2X
:
819 case WINED3DTOP_MODULATE4X
:
820 /* Input, arg1*arg2 */
821 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
822 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
823 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
824 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
827 if (op
== WINED3DTOP_MODULATE
) {
828 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_SPARE0_NV
, GL_DISCARD_NV
,
829 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
830 } else if (op
== WINED3DTOP_MODULATE2X
) {
831 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_SPARE0_NV
, GL_DISCARD_NV
,
832 GL_DISCARD_NV
, GL_SCALE_BY_TWO_NV
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
833 } else if (op
== WINED3DTOP_MODULATE4X
) {
834 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_SPARE0_NV
, GL_DISCARD_NV
,
835 GL_DISCARD_NV
, GL_SCALE_BY_FOUR_NV
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
840 case WINED3DTOP_ADDSIGNED
:
841 case WINED3DTOP_ADDSIGNED2X
:
842 /* Input, arg1*1+arg2*1 */
843 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
844 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
845 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
846 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
847 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
848 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
849 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
850 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
853 if (op
== WINED3DTOP_ADD
) {
854 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
855 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
856 } else if (op
== WINED3DTOP_ADDSIGNED
) {
857 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
858 GL_SPARE0_NV
, GL_NONE
, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
859 } else if (op
== WINED3DTOP_ADDSIGNED2X
) {
860 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
861 GL_SPARE0_NV
, GL_SCALE_BY_TWO_NV
, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
865 case WINED3DTOP_SUBTRACT
:
866 /* Input, arg1*1+-arg2*1 */
867 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
868 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
869 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
870 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
871 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
872 tex_op_args
.input
[1], GL_SIGNED_NEGATE_NV
, tex_op_args
.component_usage
[1]));
873 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
874 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
877 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
878 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
881 case WINED3DTOP_ADDSMOOTH
:
882 /* Input, arg1*1+(1-arg1)*arg2 */
883 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
884 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
885 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
886 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
887 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
888 tex_op_args
.input
[0], invert_mapping(tex_op_args
.mapping
[0]), tex_op_args
.component_usage
[0]));
889 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
890 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
893 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
894 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
897 case WINED3DTOP_BLENDDIFFUSEALPHA
:
898 case WINED3DTOP_BLENDTEXTUREALPHA
:
899 case WINED3DTOP_BLENDFACTORALPHA
:
900 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
901 case WINED3DTOP_BLENDCURRENTALPHA
:
903 GLenum alpha_src
= GL_PRIMARY_COLOR_NV
;
904 if (op
== WINED3DTOP_BLENDDIFFUSEALPHA
) alpha_src
= d3dta_to_combiner_input(D3DTA_DIFFUSE
, stage
, texture_idx
);
905 else if (op
== WINED3DTOP_BLENDTEXTUREALPHA
) alpha_src
= d3dta_to_combiner_input(D3DTA_TEXTURE
, stage
, texture_idx
);
906 else if (op
== WINED3DTOP_BLENDFACTORALPHA
) alpha_src
= d3dta_to_combiner_input(D3DTA_TFACTOR
, stage
, texture_idx
);
907 else if (op
== WINED3DTOP_BLENDTEXTUREALPHAPM
) alpha_src
= d3dta_to_combiner_input(D3DTA_TEXTURE
, stage
, texture_idx
);
908 else if (op
== WINED3DTOP_BLENDCURRENTALPHA
) alpha_src
= d3dta_to_combiner_input(D3DTA_CURRENT
, stage
, texture_idx
);
909 else FIXME("Unhandled WINED3DTOP %s, shouldn't happen\n", debug_d3dtop(op
));
911 /* Input, arg1*alpha_src+arg2*(1-alpha_src) */
912 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
913 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
914 if (op
== WINED3DTOP_BLENDTEXTUREALPHAPM
)
916 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
917 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
919 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
920 alpha_src
, GL_UNSIGNED_IDENTITY_NV
, GL_ALPHA
));
922 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
923 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
924 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
925 alpha_src
, GL_UNSIGNED_INVERT_NV
, GL_ALPHA
));
928 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
929 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
933 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
934 /* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
935 if (is_alpha
) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEALPHA_ADDCOLOR)\n");
936 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
937 tex_op_args
.input
[0], tex_op_args
.mapping
[0], GL_ALPHA
));
938 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
939 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
940 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
941 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
942 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
943 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
946 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
947 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
950 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
951 /* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
952 if (is_alpha
) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATECOLOR_ADDALPHA)\n");
953 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
954 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
955 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
956 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
957 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
958 tex_op_args
.input
[0], tex_op_args
.mapping
[0], GL_ALPHA
));
959 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
960 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
963 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
964 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
967 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
968 /* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
969 if (is_alpha
) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR)\n");
970 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
971 tex_op_args
.input
[0], invert_mapping(tex_op_args
.mapping
[0]), GL_ALPHA
));
972 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
973 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
974 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
975 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
976 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
977 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
980 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
981 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
984 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
985 /* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
986 if (is_alpha
) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA)\n");
987 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
988 tex_op_args
.input
[0], invert_mapping(tex_op_args
.mapping
[0]), tex_op_args
.component_usage
[0]));
989 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
990 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
991 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
992 tex_op_args
.input
[0], tex_op_args
.mapping
[0], GL_ALPHA
));
993 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
994 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
997 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
998 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
1001 case WINED3DTOP_DOTPRODUCT3
:
1002 /* Input, arg1 . arg2 */
1003 /* FIXME: DX7 uses a different calculation? */
1004 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
1005 tex_op_args
.input
[0], GL_EXPAND_NORMAL_NV
, tex_op_args
.component_usage
[0]));
1006 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
1007 tex_op_args
.input
[1], GL_EXPAND_NORMAL_NV
, tex_op_args
.component_usage
[1]));
1010 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_SPARE0_NV
, GL_DISCARD_NV
,
1011 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_TRUE
, GL_FALSE
, GL_FALSE
));
1014 case WINED3DTOP_MULTIPLYADD
:
1015 /* Input, arg1*1+arg2*arg3 */
1016 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
1017 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
1018 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
1019 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
1020 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
1021 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
1022 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
1023 tex_op_args
.input
[2], tex_op_args
.mapping
[2], tex_op_args
.component_usage
[2]));
1026 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
1027 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
1030 case WINED3DTOP_LERP
:
1031 /* Input, arg1*arg2+(1-arg1)*arg3 */
1032 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
1033 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
1034 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
1035 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
1036 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
1037 tex_op_args
.input
[0], invert_mapping(tex_op_args
.mapping
[0]), tex_op_args
.component_usage
[0]));
1038 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
1039 tex_op_args
.input
[2], tex_op_args
.mapping
[2], tex_op_args
.component_usage
[2]));
1042 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
1043 GL_SPARE0_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
1047 FIXME("Unhandled WINED3DTOP: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
1048 stage
, is_alpha
, debug_d3dtop(op
), op
, arg1
, arg2
, arg3
, texture_idx
);
1051 checkGLcall("set_tex_op_nvrc()\n");
1056 static void get_src_and_opr(DWORD arg
, BOOL is_alpha
, GLenum
* source
, GLenum
* operand
) {
1057 /* The D3DTA_ALPHAREPLICATE flag specifies the alpha component of the
1058 * input should be used for all input components. The D3DTA_COMPLEMENT
1059 * flag specifies the complement of the input should be used. */
1060 BOOL from_alpha
= is_alpha
|| arg
& D3DTA_ALPHAREPLICATE
;
1061 BOOL complement
= arg
& D3DTA_COMPLEMENT
;
1063 /* Calculate the operand */
1065 if (from_alpha
) *operand
= GL_ONE_MINUS_SRC_ALPHA
;
1066 else *operand
= GL_ONE_MINUS_SRC_COLOR
;
1068 if (from_alpha
) *operand
= GL_SRC_ALPHA
;
1069 else *operand
= GL_SRC_COLOR
;
1072 /* Calculate the source */
1073 switch (arg
& D3DTA_SELECTMASK
) {
1074 case D3DTA_CURRENT
: *source
= GL_PREVIOUS_EXT
; break;
1075 case D3DTA_DIFFUSE
: *source
= GL_PRIMARY_COLOR_EXT
; break;
1076 case D3DTA_TEXTURE
: *source
= GL_TEXTURE
; break;
1077 case D3DTA_TFACTOR
: *source
= GL_CONSTANT_EXT
; break;
1078 case D3DTA_SPECULAR
:
1080 * According to the GL_ARB_texture_env_combine specs, SPECULAR is
1081 * 'Secondary color' and isn't supported until base GL supports it
1082 * There is no concept of temp registers as far as I can tell
1084 FIXME("Unhandled texture arg D3DTA_SPECULAR\n");
1085 *source
= GL_TEXTURE
;
1088 FIXME("Unrecognized texture arg %#x\n", arg
);
1089 *source
= GL_TEXTURE
;
1094 /* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
1095 #if defined (GL_VERSION_1_3)
1096 # define useext(A) A
1097 # define combine_ext 1
1098 #elif defined (GL_EXT_texture_env_combine)
1099 # define useext(A) A##_EXT
1100 # define combine_ext 1
1101 #elif defined (GL_ARB_texture_env_combine)
1102 # define useext(A) A##_ARB
1103 # define combine_ext 1
1108 #if !defined(combine_ext)
1109 void set_tex_op(IWineD3DDevice
*iface
, BOOL isAlpha
, int Stage
, WINED3DTEXTUREOP op
, DWORD arg1
, DWORD arg2
, DWORD arg3
)
1111 FIXME("Requires opengl combine extensions to work\n");
1115 /* Setup the texture operations texture stage states */
1116 void set_tex_op(IWineD3DDevice
*iface
, BOOL isAlpha
, int Stage
, WINED3DTEXTUREOP op
, DWORD arg1
, DWORD arg2
, DWORD arg3
)
1118 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1119 GLenum src1
, src2
, src3
;
1120 GLenum opr1
, opr2
, opr3
;
1122 GLenum src0_target
, src1_target
, src2_target
;
1123 GLenum opr0_target
, opr1_target
, opr2_target
;
1125 GLenum opr
=0, invopr
, src3_target
, opr3_target
;
1126 BOOL Handled
= FALSE
;
1127 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
1129 TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha
, Stage
, debug_d3dtop(op
), arg1
, arg2
, arg3
);
1133 /* Note: Operations usually involve two ars, src0 and src1 and are operations of
1134 the form (a1 <operation> a2). However, some of the more complex operations
1135 take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
1136 in a third parameter called a0. Therefore these are operations of the form
1137 a0 <operation> a1 <operation> a2, ie the new parameter goes to the front.
1139 However, below we treat the new (a0) parameter as src2/opr2, so in the actual
1140 functions below, expect their syntax to differ slightly to those listed in the
1141 manuals, ie replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
1142 This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP */
1145 comb_target
= useext(GL_COMBINE_ALPHA
);
1146 src0_target
= useext(GL_SOURCE0_ALPHA
);
1147 src1_target
= useext(GL_SOURCE1_ALPHA
);
1148 src2_target
= useext(GL_SOURCE2_ALPHA
);
1149 opr0_target
= useext(GL_OPERAND0_ALPHA
);
1150 opr1_target
= useext(GL_OPERAND1_ALPHA
);
1151 opr2_target
= useext(GL_OPERAND2_ALPHA
);
1152 scal_target
= GL_ALPHA_SCALE
;
1155 comb_target
= useext(GL_COMBINE_RGB
);
1156 src0_target
= useext(GL_SOURCE0_RGB
);
1157 src1_target
= useext(GL_SOURCE1_RGB
);
1158 src2_target
= useext(GL_SOURCE2_RGB
);
1159 opr0_target
= useext(GL_OPERAND0_RGB
);
1160 opr1_target
= useext(GL_OPERAND1_RGB
);
1161 opr2_target
= useext(GL_OPERAND2_RGB
);
1162 scal_target
= useext(GL_RGB_SCALE
);
1165 /* If a texture stage references an invalid texture unit the stage just
1166 * passes through the result from the previous stage */
1167 if (is_invalid_op(This
, Stage
, op
, arg1
, arg2
, arg3
)) {
1168 arg1
= D3DTA_CURRENT
;
1169 op
= WINED3DTOP_SELECTARG1
;
1172 /* From MSDN (WINED3DTSS_ALPHAARG1) :
1173 The default argument is D3DTA_TEXTURE. If no texture is set for this stage,
1174 then the default argument is D3DTA_DIFFUSE.
1175 FIXME? If texture added/removed, may need to reset back as well? */
1176 if (isAlpha
&& This
->stateBlock
->textures
[Stage
] == NULL
&& arg1
== D3DTA_TEXTURE
) {
1177 get_src_and_opr(D3DTA_DIFFUSE
, isAlpha
, &src1
, &opr1
);
1179 get_src_and_opr(arg1
, isAlpha
, &src1
, &opr1
);
1181 get_src_and_opr(arg2
, isAlpha
, &src2
, &opr2
);
1182 get_src_and_opr(arg3
, isAlpha
, &src3
, &opr3
);
1184 TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target
, src1
, opr1
, src2
, opr2
, src3
, opr3
);
1186 Handled
= TRUE
; /* Assume will be handled */
1188 /* Other texture operations require special extensions: */
1189 if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4
)) {
1192 invopr
= GL_ONE_MINUS_SRC_ALPHA
;
1193 src3_target
= GL_SOURCE3_ALPHA_NV
;
1194 opr3_target
= GL_OPERAND3_ALPHA_NV
;
1197 invopr
= GL_ONE_MINUS_SRC_COLOR
;
1198 src3_target
= GL_SOURCE3_RGB_NV
;
1199 opr3_target
= GL_OPERAND3_RGB_NV
;
1202 case WINED3DTOP_DISABLE
: /* Only for alpha */
1203 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1204 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1205 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_PREVIOUS_EXT
);
1206 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1207 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_SRC_ALPHA
);
1208 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1209 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1210 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1211 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1212 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1213 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
1214 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1215 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
1216 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1217 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1218 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1219 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
1220 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1222 case WINED3DTOP_SELECTARG1
: /* = a1 * 1 + 0 * 0 */
1223 case WINED3DTOP_SELECTARG2
: /* = a2 * 1 + 0 * 0 */
1224 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1225 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1226 if (op
== WINED3DTOP_SELECTARG1
) {
1227 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1228 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1229 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1230 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1232 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src2
);
1233 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1234 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr2
);
1235 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1237 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1238 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1239 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1240 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1241 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
1242 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1243 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
1244 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1245 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1246 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1247 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
1248 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1251 case WINED3DTOP_MODULATE
:
1252 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1253 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1254 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1255 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1256 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1257 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1258 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1259 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1260 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1261 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1262 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
1263 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1264 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
1265 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1266 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1267 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1268 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
1269 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1270 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1271 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1273 case WINED3DTOP_MODULATE2X
:
1274 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1275 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1276 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1277 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1278 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1279 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1280 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1281 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1282 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1283 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1284 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
1285 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1286 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
1287 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1288 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1289 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1290 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
1291 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1292 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
1293 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1295 case WINED3DTOP_MODULATE4X
:
1296 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1297 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1298 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1299 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1300 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1301 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1302 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1303 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1304 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1305 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1306 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
1307 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1308 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
1309 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1310 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1311 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1312 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
1313 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1314 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 4);
1315 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1318 case WINED3DTOP_ADD
:
1319 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1320 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1321 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1322 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1323 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1324 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1325 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1326 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1327 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1328 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1329 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1330 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1331 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1332 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1333 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1334 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1335 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
1336 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1337 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1338 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1341 case WINED3DTOP_ADDSIGNED
:
1342 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_ADD_SIGNED
));
1343 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1344 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1345 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1346 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1347 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1348 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1349 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1350 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1351 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1352 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1353 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1354 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1355 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1356 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1357 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1358 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
1359 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1360 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1361 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1364 case WINED3DTOP_ADDSIGNED2X
:
1365 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_ADD_SIGNED
));
1366 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1367 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1368 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1369 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1370 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1371 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1372 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1373 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1374 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1375 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1376 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1377 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1378 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1379 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1380 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1381 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
1382 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1383 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
1384 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1387 case WINED3DTOP_ADDSMOOTH
:
1388 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1389 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1390 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1391 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1392 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1393 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1394 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1395 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1396 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1397 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1398 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1399 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1400 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1401 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1402 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
1403 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1405 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
1406 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
1407 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
1408 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
1410 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
1411 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1412 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1413 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1416 case WINED3DTOP_BLENDDIFFUSEALPHA
:
1417 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1418 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1419 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1420 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1421 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1422 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1423 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, useext(GL_PRIMARY_COLOR
));
1424 checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
1425 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1426 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1427 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1428 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1429 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1430 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1431 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, useext(GL_PRIMARY_COLOR
));
1432 checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
1433 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
1434 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1435 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1436 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1438 case WINED3DTOP_BLENDTEXTUREALPHA
:
1439 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1440 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1441 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1442 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1443 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1444 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1445 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_TEXTURE
);
1446 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
1447 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1448 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1449 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1450 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1451 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1452 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1453 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_TEXTURE
);
1454 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
1455 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
1456 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1457 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1458 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1460 case WINED3DTOP_BLENDFACTORALPHA
:
1461 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1462 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1463 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1464 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1465 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1466 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1467 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, useext(GL_CONSTANT
));
1468 checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
1469 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1470 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1471 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1472 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1473 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1474 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1475 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, useext(GL_CONSTANT
));
1476 checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
1477 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
1478 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1479 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1480 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1482 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
1483 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1484 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1485 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1486 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1487 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1488 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1489 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1490 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1491 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1492 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1493 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1494 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1495 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1496 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1497 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_TEXTURE
);
1498 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
1499 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
1500 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1501 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1502 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1504 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
1505 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1506 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1507 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
); /* a0 = src1/opr1 */
1508 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1509 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1510 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
1511 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1512 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1513 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1514 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1515 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
); /* a2 = arg2 */
1516 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1517 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1518 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
1519 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
1520 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1522 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
1523 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
1525 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
1526 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1527 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1528 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1530 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
1531 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1532 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1533 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1534 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1535 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1536 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1537 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1538 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1539 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1540 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1541 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
1542 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1544 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
1545 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
1547 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
1548 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1549 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1550 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1551 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
1552 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1553 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1554 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1556 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
1557 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1558 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1559 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1560 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1561 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1562 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1563 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1564 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1565 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1566 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1567 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
1568 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1569 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
1570 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1571 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
1572 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1574 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
1575 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
1576 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
1577 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
1579 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
1580 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1581 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1582 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1584 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
1585 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1586 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1587 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1588 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1590 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
1591 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
1592 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
1593 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
1595 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
1596 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1597 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1598 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1599 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1600 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1601 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
1602 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1604 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
1605 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
1607 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
1608 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1609 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
1610 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1611 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
1612 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1613 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1614 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1616 case WINED3DTOP_MULTIPLYADD
:
1617 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1618 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1619 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src3
);
1620 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1621 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr3
);
1622 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1623 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
1624 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1625 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
1626 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1627 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
1628 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1629 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr1
);
1630 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1631 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src2
);
1632 checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
1633 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr2
);
1634 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
1635 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1636 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1639 case WINED3DTOP_BUMPENVMAP
:
1641 if (GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1643 texture unit 0: GL_TEXTURE_2D
1644 texture unit 1: GL_DOT_PRODUCT_NV
1645 texture unit 2: GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV
1646 texture unit 3: GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV
1655 tmpvalue
.d
= This
->stateBlock
->textureState
[Stage
][WINED3DTSS_BUMPENVMAT00
];
1656 m
[0][0] = tmpvalue
.f
;
1657 tmpvalue
.d
= This
->stateBlock
->textureState
[Stage
][WINED3DTSS_BUMPENVMAT01
];
1658 m
[0][1] = tmpvalue
.f
;
1659 tmpvalue
.d
= This
->stateBlock
->textureState
[Stage
][WINED3DTSS_BUMPENVMAT10
];
1660 m
[1][0] = tmpvalue
.f
;
1661 tmpvalue
.d
= This
->stateBlock
->textureState
[Stage
][WINED3DTSS_BUMPENVMAT11
];
1662 m
[1][1] = tmpvalue
.f
;
1664 /*FIXME("Stage %d matrix is (%.2f,%.2f),(%.2f,%.2f)\n", Stage, m[0][0], m[0][1], m[1][0], m[1][0]);*/
1666 if (!This
->texture_shader_active
) {
1667 This
->texture_shader_active
= TRUE
;
1668 glEnable(GL_TEXTURE_SHADER_NV
);
1672 glEnable(GL_REGISTER_COMBINERS_NV);
1673 glCombinerParameteriNV (GL_NUM_GENERAL_COMBINERS_NV, 1);
1674 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1675 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_RGB);
1676 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1677 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_RGB);
1678 glCombinerOutputNV (GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_PRIMARY_COLOR_NV, 0, 0, 0, 0, 0);
1679 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_ALPHA);
1680 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_B_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
1681 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB, GL_SIGNED_IDENTITY_NV, GL_ALPHA);
1682 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_D_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
1683 glCombinerOutputNV (GL_COMBINER0_NV, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_PRIMARY_COLOR_NV, 0, 0, 0, 0, 0);
1684 glDisable (GL_PER_STAGE_CONSTANTS_NV);
1685 glCombinerParameteriNV (GL_COLOR_SUM_CLAMP_NV, 0);
1686 glFinalCombinerInputNV (GL_VARIABLE_A_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1687 glFinalCombinerInputNV (GL_VARIABLE_B_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1688 glFinalCombinerInputNV (GL_VARIABLE_C_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1689 glFinalCombinerInputNV (GL_VARIABLE_D_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1690 glFinalCombinerInputNV (GL_VARIABLE_E_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1691 glFinalCombinerInputNV (GL_VARIABLE_F_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1692 glFinalCombinerInputNV (GL_VARIABLE_G_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
1696 for (i = 0; i < Stage; i++) {
1697 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1698 GL_ACTIVETEXTURE(i);
1699 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1700 checkGLcall("Activate texture..");
1702 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1707 GL_ACTIVETEXTURE(Stage - 1);
1708 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1711 GL_ACTIVETEXTURE(Stage);
1712 checkGLcall("Activate texture.. to update const color");
1713 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
1714 checkGLcall("glTexEnv");
1715 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + Stage - 1);
1716 checkGLcall("glTexEnv");
1717 glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, (float*)&m[0]);
1718 checkGLcall("glTexEnv");
1725 case WINED3DTOP_BUMPENVMAPLUMINANCE
:
1731 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_COMBINE4_NV
);
1732 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
1737 } /* GL_NV_texture_env_combine4 */
1739 Handled
= TRUE
; /* Again, assume handled */
1741 case WINED3DTOP_DISABLE
: /* Only for alpha */
1742 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
1743 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1744 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_PREVIOUS_EXT
);
1745 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
1746 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_SRC_ALPHA
);
1747 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
1748 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1749 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1751 case WINED3DTOP_SELECTARG1
:
1752 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
1753 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1754 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1755 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1756 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1757 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1758 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1759 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1761 case WINED3DTOP_SELECTARG2
:
1762 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
1763 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1764 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src2
);
1765 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1766 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr2
);
1767 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1768 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1769 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1771 case WINED3DTOP_MODULATE
:
1772 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
1773 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1774 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1775 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1776 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1777 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1778 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1779 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1780 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1781 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1782 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1783 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1785 case WINED3DTOP_MODULATE2X
:
1786 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
1787 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1788 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1789 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1790 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1791 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1792 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1793 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1794 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1795 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1796 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
1797 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1799 case WINED3DTOP_MODULATE4X
:
1800 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
1801 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1802 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1803 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1804 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1805 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1806 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1807 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1808 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1809 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1810 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 4);
1811 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1813 case WINED3DTOP_ADD
:
1814 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
1815 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1816 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1817 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1818 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1819 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1820 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1821 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1822 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1823 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1824 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1825 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1827 case WINED3DTOP_ADDSIGNED
:
1828 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_ADD_SIGNED
));
1829 checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
1830 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1831 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1832 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1833 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1834 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1835 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1836 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1837 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1838 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1839 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1841 case WINED3DTOP_ADDSIGNED2X
:
1842 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_ADD_SIGNED
));
1843 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1844 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1845 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1846 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1847 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1848 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1849 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1850 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1851 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1852 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
1853 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1855 case WINED3DTOP_SUBTRACT
:
1856 if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE
)) {
1857 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_SUBTRACT
);
1858 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
1859 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1860 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1861 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1862 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1863 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1864 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1865 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1866 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1867 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1868 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1870 FIXME("This version of opengl does not support GL_SUBTRACT\n");
1874 case WINED3DTOP_BLENDDIFFUSEALPHA
:
1875 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
1876 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1877 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1878 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1879 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1880 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1881 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1882 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1883 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1884 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1885 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, useext(GL_PRIMARY_COLOR
));
1886 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
1887 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
1888 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1889 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1890 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1892 case WINED3DTOP_BLENDTEXTUREALPHA
:
1893 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
1894 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1895 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1896 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1897 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1898 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1899 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1900 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1901 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1902 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1903 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_TEXTURE
);
1904 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
1905 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
1906 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1907 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1908 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1910 case WINED3DTOP_BLENDFACTORALPHA
:
1911 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
1912 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1913 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1914 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1915 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1916 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1917 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1918 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1919 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1920 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1921 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, useext(GL_CONSTANT
));
1922 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
1923 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
1924 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1925 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1926 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1928 case WINED3DTOP_BLENDCURRENTALPHA
:
1929 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
1930 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1931 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1932 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1933 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1934 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1935 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1936 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1937 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1938 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1939 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, useext(GL_PREVIOUS
));
1940 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
1941 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
1942 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1943 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1944 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1946 case WINED3DTOP_DOTPRODUCT3
:
1947 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3
)) {
1948 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_DOT3_RGBA_ARB
);
1949 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
1950 } else if (GL_SUPPORT(EXT_TEXTURE_ENV_DOT3
)) {
1951 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_DOT3_RGBA_EXT
);
1952 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
1954 FIXME("This version of opengl does not support GL_DOT3\n");
1956 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1957 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1958 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1959 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1960 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1961 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1962 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1963 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1964 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1965 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1967 case WINED3DTOP_LERP
:
1968 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
1969 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1970 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1971 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1972 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
1973 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1974 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
1975 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1976 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
1977 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1978 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src3
);
1979 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
1980 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr3
);
1981 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
1982 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
1983 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1985 case WINED3DTOP_ADDSMOOTH
:
1986 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3
)) {
1987 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
1988 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1989 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
1990 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1992 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
1993 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
1994 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
1995 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
1997 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
1998 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1999 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2000 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2001 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2002 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2003 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2004 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2005 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2006 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2007 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2008 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2012 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
2013 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3
)) {
2014 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2015 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2016 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_TEXTURE
);
2017 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
2018 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_ONE_MINUS_SRC_ALPHA
);
2019 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
2020 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2021 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2022 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2023 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2024 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2025 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2026 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2027 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2028 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2029 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2033 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
2034 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3
)) {
2035 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2036 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2037 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2038 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2040 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2041 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2042 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2043 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2045 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2046 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2047 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2048 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2049 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2050 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2051 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2052 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2053 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2054 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2055 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2056 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2060 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
2061 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3
)) {
2062 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2063 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2064 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2065 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2066 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2067 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2068 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2069 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2071 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2072 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2073 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2074 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2076 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr
);
2077 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2078 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2079 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2080 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2081 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2082 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2083 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2087 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
2088 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3
)) {
2089 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2090 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2091 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2092 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2094 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2095 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2096 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2097 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2099 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2100 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2101 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2102 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2103 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2104 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2105 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2106 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2107 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2108 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2109 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2110 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2114 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
2115 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3
)) {
2116 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2117 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2118 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2119 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2121 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2122 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2123 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2124 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2126 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2127 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2128 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2129 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2131 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2132 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2133 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2134 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2136 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr
);
2137 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2138 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2139 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2140 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2141 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2142 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2143 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2147 case WINED3DTOP_MULTIPLYADD
:
2148 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3
)) {
2149 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2150 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2151 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src3
);
2152 checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
2153 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr3
);
2154 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
2155 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2156 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2157 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2158 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2159 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2160 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2161 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2162 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2163 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2164 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2173 BOOL combineOK
= TRUE
;
2174 if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4
)) {
2178 op2
= This
->stateBlock
->textureState
[Stage
][WINED3DTSS_COLOROP
];
2180 op2
= This
->stateBlock
->textureState
[Stage
][WINED3DTSS_ALPHAOP
];
2183 /* Note: If COMBINE4 in effect can't go back to combine! */
2185 case WINED3DTOP_ADDSMOOTH
:
2186 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
2187 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
2188 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
2189 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
2190 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
2191 case WINED3DTOP_MULTIPLYADD
:
2192 /* Ignore those implemented in both cases */
2194 case WINED3DTOP_SELECTARG1
:
2195 case WINED3DTOP_SELECTARG2
:
2200 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op
), debug_d3dtop(op2
), isAlpha
);
2208 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, useext(GL_COMBINE
));
2209 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
2218 /* After all the extensions, if still unhandled, report fixme */
2219 FIXME("Unhandled texture operation %s\n", debug_d3dtop(op
));
2220 #undef GLINFO_LOCATION
2224 /* Setup this textures matrix according to the texture flags*/
2225 void set_texture_matrix(const float *smat
, DWORD flags
, BOOL calculatedCoords
)
2229 glMatrixMode(GL_TEXTURE
);
2230 checkGLcall("glMatrixMode(GL_TEXTURE)");
2232 if (flags
== D3DTTFF_DISABLE
) {
2234 checkGLcall("glLoadIdentity()");
2238 if (flags
== (D3DTTFF_COUNT1
|D3DTTFF_PROJECTED
)) {
2239 ERR("Invalid texture transform flags: D3DTTFF_COUNT1|D3DTTFF_PROJECTED\n");
2243 memcpy(mat
, smat
, 16 * sizeof(float));
2245 switch (flags
& ~D3DTTFF_PROJECTED
) {
2246 case D3DTTFF_COUNT1
: mat
[1] = mat
[5] = mat
[13] = 0;
2247 case D3DTTFF_COUNT2
: mat
[2] = mat
[6] = mat
[10] = mat
[14] = 0;
2248 default: mat
[3] = mat
[7] = mat
[11] = 0, mat
[15] = 1;
2251 if (flags
& D3DTTFF_PROJECTED
) {
2252 switch (flags
& ~D3DTTFF_PROJECTED
) {
2253 case D3DTTFF_COUNT2
:
2254 mat
[3] = mat
[1], mat
[7] = mat
[5], mat
[11] = mat
[9], mat
[15] = mat
[13];
2255 mat
[1] = mat
[5] = mat
[9] = mat
[13] = 0;
2257 case D3DTTFF_COUNT3
:
2258 mat
[3] = mat
[2], mat
[7] = mat
[6], mat
[11] = mat
[10], mat
[15] = mat
[14];
2259 mat
[2] = mat
[6] = mat
[10] = mat
[14] = 0;
2262 } else if(!calculatedCoords
) { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2268 checkGLcall("glLoadMatrixf(mat)");
2271 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
2273 /* Convertes a D3D format into a OpenGL configuration format */
2274 int D3DFmtMakeGlCfg(WINED3DFORMAT BackBufferFormat
, WINED3DFORMAT StencilBufferFormat
, int *attribs
, int* nAttribs
, BOOL alternate
){
2275 #define PUSH1(att) attribs[(*nAttribs)++] = (att);
2276 #define PUSH2(att,value) attribs[(*nAttribs)++] = (att); attribs[(*nAttribs)++] = (value);
2277 /*We need to do some Card specific stuff in here at some point,
2278 D3D now supports floating point format buffers, and there are a number of different OpelGl ways of managing these e.g.
2279 GLX_ATI_pixel_format_float
2281 switch (BackBufferFormat
) {
2284 PUSH2(GLX_RENDER_TYPE
, GLX_COLOR_INDEX_BIT
);
2285 PUSH2(GLX_BUFFER_SIZE
, 8);
2286 PUSH2(GLX_DOUBLEBUFFER
, TRUE
);
2289 case WINED3DFMT_R3G3B2
:
2290 PUSH2(GLX_RENDER_TYPE
, GLX_RGBA_BIT
);
2291 PUSH2(GLX_RED_SIZE
, 3);
2292 PUSH2(GLX_GREEN_SIZE
, 3);
2293 PUSH2(GLX_BLUE_SIZE
, 2);
2296 case WINED3DFMT_A1R5G5B5
:
2297 PUSH2(GLX_ALPHA_SIZE
, 1);
2298 case WINED3DFMT_X1R5G5B5
:
2299 PUSH2(GLX_RED_SIZE
, 5);
2300 PUSH2(GLX_GREEN_SIZE
, 5);
2301 PUSH2(GLX_BLUE_SIZE
, 5);
2304 case WINED3DFMT_R5G6B5
:
2305 PUSH2(GLX_RED_SIZE
, 5);
2306 PUSH2(GLX_GREEN_SIZE
, 6);
2307 PUSH2(GLX_BLUE_SIZE
, 5);
2310 case WINED3DFMT_A4R4G4B4
:
2311 PUSH2(GLX_ALPHA_SIZE
, 4);
2312 case WINED3DFMT_X4R4G4B4
:
2313 PUSH2(GLX_RED_SIZE
, 4);
2314 PUSH2(GLX_GREEN_SIZE
, 4);
2315 PUSH2(GLX_BLUE_SIZE
, 4);
2318 case WINED3DFMT_A8R8G8B8
:
2319 PUSH2(GLX_ALPHA_SIZE
, 8);
2320 case WINED3DFMT_R8G8B8
:
2321 case WINED3DFMT_X8R8G8B8
:
2322 PUSH2(GLX_RED_SIZE
, 8);
2323 PUSH2(GLX_GREEN_SIZE
, 8);
2324 PUSH2(GLX_BLUE_SIZE
, 8);
2327 case WINED3DFMT_A2R10G10B10
:
2328 PUSH2(GLX_ALPHA_SIZE
, 2);
2329 PUSH2(GLX_RED_SIZE
, 10);
2330 PUSH2(GLX_GREEN_SIZE
, 10);
2331 PUSH2(GLX_BLUE_SIZE
, 10);
2334 case WINED3DFMT_A16B16G16R16
:
2335 PUSH2(GLX_ALPHA_SIZE
, 16);
2336 PUSH2(GLX_RED_SIZE
, 16);
2337 PUSH2(GLX_GREEN_SIZE
, 16);
2338 PUSH2(GLX_BLUE_SIZE
, 16);
2342 FIXME("Unsupported color format: %s\n", debug_d3dformat(BackBufferFormat
));
2346 switch (StencilBufferFormat
) {
2350 case WINED3DFMT_D16_LOCKABLE
:
2351 case WINED3DFMT_D16
:
2352 PUSH2(GLX_DEPTH_SIZE
, 16);
2355 case WINED3DFMT_D15S1
:
2356 PUSH2(GLX_DEPTH_SIZE
, 15);
2357 PUSH2(GLX_STENCIL_SIZE
, 1);
2358 /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
2359 e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
2362 case WINED3DFMT_D24X8
:
2363 PUSH2(GLX_DEPTH_SIZE
, 24);
2366 case WINED3DFMT_D24X4S4
:
2367 PUSH2(GLX_DEPTH_SIZE
, 24);
2368 PUSH2(GLX_STENCIL_SIZE
, 4);
2371 case WINED3DFMT_D24S8
:
2372 PUSH2(GLX_DEPTH_SIZE
, 24);
2373 PUSH2(GLX_STENCIL_SIZE
, 8);
2376 case WINED3DFMT_D24FS8
:
2377 PUSH2(GLX_DEPTH_SIZE
, 24);
2378 PUSH2(GLX_STENCIL_SIZE
, 8);
2381 case WINED3DFMT_D32
:
2382 PUSH2(GLX_DEPTH_SIZE
, 32);
2386 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat
));
2390 } else { /* it the device doesn't support the 'exact' format, try to find something close */
2391 switch (StencilBufferFormat
) {
2395 case WINED3DFMT_D16_LOCKABLE
:
2396 case WINED3DFMT_D16
:
2397 PUSH2(GLX_DEPTH_SIZE
, 1);
2400 case WINED3DFMT_D15S1
:
2401 PUSH2(GLX_DEPTH_SIZE
, 1);
2402 PUSH2(GLX_STENCIL_SIZE
, 1);
2403 /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
2404 e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
2407 case WINED3DFMT_D24X8
:
2408 PUSH2(GLX_DEPTH_SIZE
, 1);
2411 case WINED3DFMT_D24X4S4
:
2412 PUSH2(GLX_DEPTH_SIZE
, 1);
2413 PUSH2(GLX_STENCIL_SIZE
, 1);
2416 case WINED3DFMT_D24S8
:
2417 PUSH2(GLX_DEPTH_SIZE
, 1);
2418 PUSH2(GLX_STENCIL_SIZE
, 1);
2421 case WINED3DFMT_D24FS8
:
2422 PUSH2(GLX_DEPTH_SIZE
, 1);
2423 PUSH2(GLX_STENCIL_SIZE
, 1);
2426 case WINED3DFMT_D32
:
2427 PUSH2(GLX_DEPTH_SIZE
, 1);
2431 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat
));
2439 #undef GLINFO_LOCATION
2441 /* DirectDraw stuff */
2442 WINED3DFORMAT
pixelformat_for_depth(DWORD depth
) {
2444 case 8: return WINED3DFMT_P8
; break;
2445 case 15: return WINED3DFMT_X1R5G5B5
; break;
2446 case 16: return WINED3DFMT_R5G6B5
; break;
2447 case 24: return WINED3DFMT_R8G8B8
; break;
2448 case 32: return WINED3DFMT_X8R8G8B8
; break;
2449 default: return WINED3DFMT_UNKNOWN
;
2453 void multiply_matrix(WINED3DMATRIX
*dest
, WINED3DMATRIX
*src1
, WINED3DMATRIX
*src2
) {
2456 /* Now do the multiplication 'by hand'.
2457 I know that all this could be optimised, but this will be done later :-) */
2458 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
);
2459 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
);
2460 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
);
2461 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
);
2463 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
);
2464 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
);
2465 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
);
2466 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
);
2468 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
);
2469 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
);
2470 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
);
2471 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
);
2473 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
);
2474 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
);
2475 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
);
2476 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
);
2478 /* And copy the new matrix in the good storage.. */
2479 memcpy(dest
, &temp
, 16 * sizeof(float));
2482 DWORD
get_flexible_vertex_size(DWORD d3dvtVertexType
) {
2485 int numTextures
= (d3dvtVertexType
& D3DFVF_TEXCOUNT_MASK
) >> D3DFVF_TEXCOUNT_SHIFT
;
2487 if (d3dvtVertexType
& D3DFVF_NORMAL
) size
+= 3 * sizeof(float);
2488 if (d3dvtVertexType
& D3DFVF_DIFFUSE
) size
+= sizeof(DWORD
);
2489 if (d3dvtVertexType
& D3DFVF_SPECULAR
) size
+= sizeof(DWORD
);
2490 if (d3dvtVertexType
& D3DFVF_PSIZE
) size
+= sizeof(DWORD
);
2491 switch (d3dvtVertexType
& D3DFVF_POSITION_MASK
) {
2492 case D3DFVF_XYZ
: size
+= 3 * sizeof(float); break;
2493 case D3DFVF_XYZRHW
: size
+= 4 * sizeof(float); break;
2494 default: TRACE(" matrix weighting not handled yet...\n");
2496 for (i
= 0; i
< numTextures
; i
++) {
2497 size
+= GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType
, i
) * sizeof(float);
2503 /***********************************************************************
2506 * Calculates the dimensions of the opengl texture used for blits.
2507 * Handled oversized opengl textures and updates the source rectangle
2511 * This: Surface to operate on
2512 * Rect: Requested rectangle
2515 * TRUE if the texture part can be loaded,
2518 *********************************************************************/
2519 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->resource.wineD3DDevice->wineD3D))->gl_info
2521 BOOL
CalculateTexRect(IWineD3DSurfaceImpl
*This
, RECT
*Rect
, float glTexCoord
[4]) {
2522 int x1
= Rect
->left
, x2
= Rect
->right
;
2523 int y1
= Rect
->top
, y2
= Rect
->bottom
;
2524 GLint maxSize
= GL_LIMITS(texture_size
);
2526 TRACE("(%p)->(%d,%d)-(%d,%d)\n", This
,
2527 Rect
->left
, Rect
->top
, Rect
->right
, Rect
->bottom
);
2529 /* The sizes might be reversed */
2530 if(Rect
->left
> Rect
->right
) {
2534 if(Rect
->top
> Rect
->bottom
) {
2539 /* No oversized texture? This is easy */
2540 if(!(This
->Flags
& SFLAG_OVERSIZE
)) {
2541 /* Which rect from the texture do I need? */
2542 glTexCoord
[0] = (float) Rect
->left
/ (float) This
->pow2Width
;
2543 glTexCoord
[2] = (float) Rect
->top
/ (float) This
->pow2Height
;
2544 glTexCoord
[1] = (float) Rect
->right
/ (float) This
->pow2Width
;
2545 glTexCoord
[3] = (float) Rect
->bottom
/ (float) This
->pow2Height
;
2549 /* Check if we can succeed at all */
2550 if( (x2
- x1
) > maxSize
||
2551 (y2
- y1
) > maxSize
) {
2552 TRACE("Requested rectangle is too large for gl\n");
2556 /* A part of the texture has to be picked. First, check if
2557 * some texture part is loaded already, if yes try to re-use it.
2558 * If the texture is dirty, or the part can't be used,
2559 * re-position the part to load
2561 if(!(This
->Flags
& SFLAG_DIRTY
)) {
2562 if(This
->glRect
.left
<= x1
&& This
->glRect
.right
>= x2
&&
2563 This
->glRect
.top
<= y1
&& This
->glRect
.bottom
>= x2
) {
2564 /* Ok, the rectangle is ok, re-use it */
2565 TRACE("Using existing gl Texture\n");
2567 /* Rectangle is not ok, dirtify the texture to reload it */
2568 TRACE("Dirtifying texture to force reload\n");
2569 This
->Flags
|= SFLAG_DIRTY
;
2573 /* Now if we are dirty(no else if!) */
2574 if(This
->Flags
& SFLAG_DIRTY
) {
2575 /* Set the new rectangle. Use the following strategy:
2576 * 1) Use as big textures as possible.
2577 * 2) Place the texture part in the way that the requested
2578 * part is in the middle of the texture(well, almost)
2579 * 3) If the texture is moved over the edges of the
2580 * surface, replace it nicely
2581 * 4) If the coord is not limiting the texture size,
2582 * use the whole size
2584 if((This
->pow2Width
) > maxSize
) {
2585 This
->glRect
.left
= x1
- maxSize
/ 2;
2586 if(This
->glRect
.left
< 0) {
2587 This
->glRect
.left
= 0;
2589 This
->glRect
.right
= This
->glRect
.left
+ maxSize
;
2590 if(This
->glRect
.right
> This
->currentDesc
.Width
) {
2591 This
->glRect
.right
= This
->currentDesc
.Width
;
2592 This
->glRect
.left
= This
->glRect
.right
- maxSize
;
2595 This
->glRect
.left
= 0;
2596 This
->glRect
.right
= This
->pow2Width
;
2599 if(This
->pow2Height
> maxSize
) {
2600 This
->glRect
.top
= x1
- GL_LIMITS(texture_size
) / 2;
2601 if(This
->glRect
.top
< 0) This
->glRect
.top
= 0;
2602 This
->glRect
.bottom
= This
->glRect
.left
+ maxSize
;
2603 if(This
->glRect
.bottom
> This
->currentDesc
.Height
) {
2604 This
->glRect
.bottom
= This
->currentDesc
.Height
;
2605 This
->glRect
.top
= This
->glRect
.bottom
- maxSize
;
2608 This
->glRect
.top
= 0;
2609 This
->glRect
.bottom
= This
->pow2Height
;
2611 TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This
,
2612 This
->glRect
.left
, This
->glRect
.top
, This
->glRect
.right
, This
->glRect
.bottom
);
2615 /* Re-calculate the rect to draw */
2616 Rect
->left
-= This
->glRect
.left
;
2617 Rect
->right
-= This
->glRect
.left
;
2618 Rect
->top
-= This
->glRect
.top
;
2619 Rect
->bottom
-= This
->glRect
.top
;
2621 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
2622 * or the pow2Width / pow2Height of the surface
2624 glTexCoord
[0] = (float) Rect
->left
/ (float) (This
->glRect
.right
- This
->glRect
.left
);
2625 glTexCoord
[2] = (float) Rect
->top
/ (float) (This
->glRect
.bottom
- This
->glRect
.top
);
2626 glTexCoord
[1] = (float) Rect
->right
/ (float) (This
->glRect
.right
- This
->glRect
.left
);
2627 glTexCoord
[3] = (float) Rect
->bottom
/ (float) (This
->glRect
.bottom
- This
->glRect
.top
);
2631 #undef GLINFO_LOCATION