?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dsound/winealsa: Remove writelead for alsa directsound.
[wine/multimedia.git] / dlls / wined3d / utils.c
blob65bff5cc7b76cf140810ea71293bc093a0f26441
1 /*
2 * Utility functions for the WineD3D Library
3 *
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2003-2004 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
8 * Copyright 2006-2007 Henri Verbeet
9 *
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.
14 *
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.
19 *
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
23 */
24
25 #include "config.h"
26 #include "wined3d_private.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
29
30 #define GLINFO_LOCATION This->adapter->gl_info
31
32 /*****************************************************************************
33 * Pixel format array
34 */
35 static const PixelFormatDesc formats[] = {
36 /*{WINED3DFORMAT ,alphamask ,redmask ,greenmask ,bluemask ,bpp ,isFourcc ,internal ,srgbInternal ,format ,type }*/
37 {WINED3DFMT_UNKNOWN ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,0 ,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 ,0 },
40 {WINED3DFMT_YUY2 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 ,0 },
41 {WINED3DFMT_DXT1 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT ,GL_RGBA ,GL_UNSIGNED_BYTE },
42 {WINED3DFMT_DXT2 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT ,GL_RGBA ,GL_UNSIGNED_BYTE },
43 {WINED3DFMT_DXT3 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT ,GL_RGBA ,GL_UNSIGNED_BYTE },
44 {WINED3DFMT_DXT4 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT ,GL_RGBA ,GL_UNSIGNED_BYTE },
45 {WINED3DFMT_DXT5 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ,GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT ,GL_RGBA ,GL_UNSIGNED_BYTE },
46 {WINED3DFMT_MULTI2_ARGB8,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 ,0 },
47 {WINED3DFMT_G8R8_G8B8 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 ,0 },
48 {WINED3DFMT_R8G8_B8G8 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 ,0 },
49 /* IEEE formats */
50 {WINED3DFMT_R32F ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_RGB32F_ARB ,GL_RGB32F_ARB ,GL_RED ,GL_FLOAT },
51 {WINED3DFMT_G32R32F ,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE ,0 ,0 ,0 ,0 },
52 {WINED3DFMT_A32B32G32R32F,0x0 ,0x0 ,0x0 ,0x0 ,16 ,FALSE ,GL_RGBA32F_ARB ,GL_RGBA32F_ARB ,GL_RGBA ,GL_FLOAT },
53 /* Hmm? */
54 {WINED3DFMT_CxV8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,0 ,0 ,0 ,0 },
55 /* Float */
56 {WINED3DFMT_R16F ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_RGB16F_ARB ,GL_RGB16F_ARB ,GL_RED ,GL_HALF_FLOAT_ARB },
57 {WINED3DFMT_G16R16F ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 ,0 },
58 {WINED3DFMT_A16B16G16R16F,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE ,GL_RGBA16F_ARB ,GL_RGBA16F_ARB ,GL_RGBA ,GL_HALF_FLOAT_ARB },
59 /* Palettized formats */
60 {WINED3DFMT_A8P8 ,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,0 ,0 ,0 ,0 },
61 {WINED3DFMT_P8 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,GL_COLOR_INDEX8_EXT ,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_RGB8 ,GL_BGR ,GL_UNSIGNED_BYTE },
64 {WINED3DFMT_A8R8G8B8 ,0xff000000 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,FALSE ,GL_RGBA8 ,GL_SRGB8_ALPHA8_EXT ,GL_BGRA ,GL_UNSIGNED_INT_8_8_8_8_REV },
65 {WINED3DFMT_X8R8G8B8 ,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,FALSE ,GL_RGB8 ,GL_SRGB8_EXT ,GL_BGRA ,GL_UNSIGNED_INT_8_8_8_8_REV },
66 {WINED3DFMT_R5G6B5 ,0x0 ,0x0000F800 ,0x000007e0 ,0x0000001f ,2 ,FALSE ,GL_RGB5 ,GL_RGB5 ,GL_RGB ,GL_UNSIGNED_SHORT_5_6_5 },
67 {WINED3DFMT_X1R5G5B5 ,0x0 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,FALSE ,GL_RGB5_A1 ,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_RGB5_A1 ,GL_BGRA ,GL_UNSIGNED_SHORT_1_5_5_5_REV },
69 {WINED3DFMT_A4R4G4B4 ,0x0000f000 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,FALSE ,GL_RGBA4 ,GL_SRGB8_ALPHA8_EXT ,GL_BGRA ,GL_UNSIGNED_SHORT_4_4_4_4_REV },
70 {WINED3DFMT_R3G3B2 ,0x0 ,0x000000e0 ,0x0000001c ,0x00000003 ,1 ,FALSE ,GL_R3_G3_B2 ,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_ALPHA8 ,GL_ALPHA ,GL_UNSIGNED_BYTE },
72 {WINED3DFMT_A8R3G3B2 ,0x0000ff00 ,0x000000e0 ,0x0000001c ,0x00000003 ,2 ,FALSE ,0 ,0 ,0 ,0 },
73 {WINED3DFMT_X4R4G4B4 ,0x0 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,FALSE ,GL_RGB4 ,GL_RGB4 ,GL_BGRA ,GL_UNSIGNED_SHORT_4_4_4_4_REV },
74 {WINED3DFMT_A2B10G10R10 ,0xb0000000 ,0x000003ff ,0x000ffc00 ,0x3ff00000 ,4 ,FALSE ,GL_RGB ,GL_RGB ,GL_RGBA ,GL_UNSIGNED_INT_2_10_10_10_REV },
75 {WINED3DFMT_A8B8G8R8 ,0xff000000 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,FALSE ,GL_RGBA8 ,GL_RGBA8 ,GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV },
76 {WINED3DFMT_X8B8G8R8 ,0x0 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,FALSE ,GL_RGB8 ,GL_RGB8 ,GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV },
77 {WINED3DFMT_G16R16 ,0x0 ,0x0000ffff ,0xffff0000 ,0x0 ,4 ,FALSE ,0 ,0 ,0 ,0 },
78 {WINED3DFMT_A2R10G10B10 ,0xb0000000 ,0x3ff00000 ,0x000ffc00 ,0x000003ff ,4 ,FALSE ,GL_RGBA ,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_RGBA16_EXT ,GL_RGBA ,GL_UNSIGNED_SHORT },
80 /* Luminance */
81 {WINED3DFMT_L8 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,GL_LUMINANCE8 ,GL_SLUMINANCE8_EXT ,GL_LUMINANCE ,GL_UNSIGNED_BYTE },
82 {WINED3DFMT_A8L8 ,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_LUMINANCE8_ALPHA8 ,GL_SLUMINANCE8_ALPHA8_EXT ,GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE },
83 {WINED3DFMT_A4L4 ,0x000000f0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,GL_LUMINANCE4_ALPHA4 ,GL_LUMINANCE4_ALPHA4 ,GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE },
84 /* Bump mapping stuff */
85 {WINED3DFMT_V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_DSDT8_NV ,GL_DSDT8_NV ,GL_DSDT_NV ,GL_BYTE },
86 {WINED3DFMT_L6V5U5 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_COLOR_INDEX8_EXT ,GL_COLOR_INDEX8_EXT ,GL_COLOR_INDEX ,GL_UNSIGNED_SHORT_5_5_5_1 },
87 {WINED3DFMT_X8L8V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_DSDT8_MAG8_INTENSITY8_NV ,GL_DSDT8_MAG8_INTENSITY8_NV ,GL_DSDT_MAG_INTENSITY_NV ,GL_BYTE },
88 {WINED3DFMT_Q8W8V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_SIGNED_RGBA8_NV ,GL_SIGNED_RGBA8_NV ,GL_RGBA ,GL_BYTE },
89 {WINED3DFMT_V16U16 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_SIGNED_HILO16_NV ,GL_SIGNED_HILO16_NV ,GL_HILO_NV ,GL_SHORT },
90 {WINED3DFMT_W11V11U10 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 ,0 },
91 {WINED3DFMT_A2W10V10U10 ,0xb0000000 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 ,0 },
92 /* Depth stencil formats */
93 {WINED3DFMT_D16_LOCKABLE,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT ,GL_UNSIGNED_SHORT },
94 {WINED3DFMT_D32 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_DEPTH_COMPONENT32_ARB ,GL_DEPTH_COMPONENT32_ARB ,GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT },
95 {WINED3DFMT_D15S1 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT ,GL_UNSIGNED_SHORT },
96 {WINED3DFMT_D24S8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT ,GL_UNSIGNED_INT },
97 {WINED3DFMT_D24X8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT,GL_UNSIGNED_INT },
98 {WINED3DFMT_D24X4S4 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT,GL_UNSIGNED_INT },
99 {WINED3DFMT_D16 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT,GL_UNSIGNED_SHORT },
100 {WINED3DFMT_L16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_LUMINANCE16_EXT ,GL_LUMINANCE16_EXT ,GL_LUMINANCE ,GL_UNSIGNED_SHORT },
101 {WINED3DFMT_D32F_LOCKABLE,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_DEPTH_COMPONENT32_ARB ,GL_DEPTH_COMPONENT32_ARB ,GL_DEPTH_COMPONENT ,GL_FLOAT },
102 {WINED3DFMT_D24FS8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT24_ARB ,GL_DEPTH_COMPONENT ,GL_FLOAT },
103 /* Is this a vertex buffer? */
104 {WINED3DFMT_VERTEXDATA ,0x0 ,0x0 ,0x0 ,0x0 ,0 ,FALSE ,0 ,0 ,0 ,0 },
105 {WINED3DFMT_INDEX16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,0 ,0 ,0 ,0 },
106 {WINED3DFMT_INDEX32 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 ,0 },
107 {WINED3DFMT_Q16W16V16U16,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_SHORT }
108 };
109
110 const PixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt)
111 {
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
114 */
115 if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
116 return &formats[fmt];
117 } else {
118 unsigned int i;
119 for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
120 if(formats[i].format == fmt) {
121 return &formats[i];
122 }
123 }
124 }
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");
128 return NULL;
129 }
130 /* Get the caller a valid pointer */
131 return getFormatDescEntry(WINED3DFMT_UNKNOWN);
132 }
133
134 /*****************************************************************************
135 * Trace formatting of useful values
136 */
137 const char* debug_d3dformat(WINED3DFORMAT fmt) {
138 switch (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_ARGB8);
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);
201 #undef FMT_TO_STR
202 default:
203 {
204 char fourcc[5];
205 fourcc[0] = (char)(fmt);
206 fourcc[1] = (char)(fmt >> 8);
207 fourcc[2] = (char)(fmt >> 16);
208 fourcc[3] = (char)(fmt >> 24);
209 fourcc[4] = 0;
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);
212 else
213 FIXME("Unrecognized %u WINED3DFORMAT!\n", fmt);
214 }
215 return "unrecognized";
216 }
217 }
218
219 const char* debug_d3ddevicetype(WINED3DDEVTYPE devtype) {
220 switch (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
226 default:
227 FIXME("Unrecognized %u WINED3DDEVTYPE!\n", devtype);
228 return "unrecognized";
229 }
230 }
231
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";
248 default:
249 FIXME("Unrecognized %u Usage!\n", usage);
250 return "unrecognized";
251 }
252 }
253
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";
266 default:
267 FIXME("Unrecognized %u Usage Query!\n", usagequery);
268 return "unrecognized";
269 }
270 }
271
272 const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method) {
273 switch (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
283 default:
284 FIXME("Unrecognized %u declaration method!\n", method);
285 return "unrecognized";
286 }
287 }
288
289 const char* debug_d3ddecltype(WINED3DDECLTYPE type) {
290 switch (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
311 default:
312 FIXME("Unrecognized %u declaration type!\n", type);
313 return "unrecognized";
314 }
315 }
316
317 const char* debug_d3ddeclusage(BYTE usage) {
318 switch (usage) {
319 #define WINED3DDECLUSAGE_TO_STR(u) case u: return #u
320 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITION);
321 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDWEIGHT);
322 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BLENDINDICES);
323 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_NORMAL);
324 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_PSIZE);
325 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TEXCOORD);
326 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TANGENT);
327 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_BINORMAL);
328 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_TESSFACTOR);
329 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_POSITIONT);
330 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_COLOR);
331 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_FOG);
332 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_DEPTH);
333 WINED3DDECLUSAGE_TO_STR(WINED3DDECLUSAGE_SAMPLE);
334 #undef WINED3DDECLUSAGE_TO_STR
335 default:
336 FIXME("Unrecognized %u declaration usage!\n", usage);
337 return "unrecognized";
338 }
339 }
340
341 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
342 switch (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);
351 #undef RES_TO_STR
352 default:
353 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
354 return "unrecognized";
355 }
356 }
357
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);
367 #undef PRIM_TO_STR
368 default:
369 FIXME("Unrecognized %u WINED3DPRIMITIVETYPE!\n", PrimitiveType);
370 return "unrecognized";
371 }
372 }
373
374 const char* debug_d3drenderstate(DWORD state) {
375 switch (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_STIPPLEPATTERN00 );
437 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN01 );
438 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN02 );
439 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN03 );
440 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN04 );
441 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN05 );
442 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN06 );
443 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN07 );
444 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN08 );
445 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN09 );
446 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN10 );
447 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN11 );
448 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN12 );
449 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN13 );
450 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN14 );
451 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN15 );
452 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN16 );
453 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN17 );
454 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN18 );
455 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN19 );
456 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN20 );
457 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN21 );
458 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN22 );
459 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN23 );
460 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN24 );
461 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN25 );
462 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN26 );
463 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN27 );
464 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN28 );
465 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN29 );
466 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN30 );
467 D3DSTATE_TO_STR(WINED3DRS_STIPPLEPATTERN31 );
468 D3DSTATE_TO_STR(WINED3DRS_WRAP0 );
469 D3DSTATE_TO_STR(WINED3DRS_WRAP1 );
470 D3DSTATE_TO_STR(WINED3DRS_WRAP2 );
471 D3DSTATE_TO_STR(WINED3DRS_WRAP3 );
472 D3DSTATE_TO_STR(WINED3DRS_WRAP4 );
473 D3DSTATE_TO_STR(WINED3DRS_WRAP5 );
474 D3DSTATE_TO_STR(WINED3DRS_WRAP6 );
475 D3DSTATE_TO_STR(WINED3DRS_WRAP7 );
476 D3DSTATE_TO_STR(WINED3DRS_CLIPPING );
477 D3DSTATE_TO_STR(WINED3DRS_LIGHTING );
478 D3DSTATE_TO_STR(WINED3DRS_EXTENTS );
479 D3DSTATE_TO_STR(WINED3DRS_AMBIENT );
480 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE );
481 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX );
482 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER );
483 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS );
484 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE );
485 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE );
486 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE );
487 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE );
488 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE );
489 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND );
490 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE );
491 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING );
492 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE );
493 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN );
494 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE );
495 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE );
496 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A );
497 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B );
498 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C );
499 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS );
500 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK );
501 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE );
502 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS );
503 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN );
504 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX );
505 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE );
506 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE );
507 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR );
508 D3DSTATE_TO_STR(WINED3DRS_BLENDOP );
509 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE );
510 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE );
511 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE );
512 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS );
513 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE );
514 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL );
515 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL );
516 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X );
517 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y );
518 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z );
519 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W );
520 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
521 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE );
522 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL );
523 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL );
524 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS );
525 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC );
526 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1 );
527 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2 );
528 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3 );
529 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR );
530 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE );
531 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS );
532 D3DSTATE_TO_STR(WINED3DRS_WRAP8 );
533 D3DSTATE_TO_STR(WINED3DRS_WRAP9 );
534 D3DSTATE_TO_STR(WINED3DRS_WRAP10 );
535 D3DSTATE_TO_STR(WINED3DRS_WRAP11 );
536 D3DSTATE_TO_STR(WINED3DRS_WRAP12 );
537 D3DSTATE_TO_STR(WINED3DRS_WRAP13 );
538 D3DSTATE_TO_STR(WINED3DRS_WRAP14 );
539 D3DSTATE_TO_STR(WINED3DRS_WRAP15 );
540 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE );
541 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA );
542 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA );
543 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA );
544 #undef D3DSTATE_TO_STR
545 default:
546 FIXME("Unrecognized %u render state!\n", state);
547 return "unrecognized";
548 }
549 }
550
551 const char* debug_d3dsamplerstate(DWORD state) {
552 switch (state) {
553 #define D3DSTATE_TO_STR(u) case u: return #u
554 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR );
555 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU );
556 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV );
557 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW );
558 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER );
559 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER );
560 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER );
561 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
562 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL );
563 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
564 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE );
565 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
566 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET );
567 #undef D3DSTATE_TO_STR
568 default:
569 FIXME("Unrecognized %u sampler state!\n", state);
570 return "unrecognized";
571 }
572 }
573
574 const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) {
575 switch (filter_type) {
576 #define D3DTEXTUREFILTERTYPE_TO_STR(u) case u: return #u
577 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_NONE);
578 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_POINT);
579 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_LINEAR);
580 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_ANISOTROPIC);
581 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_FLATCUBIC);
582 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANCUBIC);
583 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_PYRAMIDALQUAD);
584 D3DTEXTUREFILTERTYPE_TO_STR(WINED3DTEXF_GAUSSIANQUAD);
585 #undef D3DTEXTUREFILTERTYPE_TO_STR
586 default:
587 FIXME("Unrecognied texture filter type 0x%08x\n", filter_type);
588 return "unrecognized";
589 }
590 }
591
592 const char* debug_d3dtexturestate(DWORD state) {
593 switch (state) {
594 #define D3DSTATE_TO_STR(u) case u: return #u
595 D3DSTATE_TO_STR(WINED3DTSS_COLOROP );
596 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1 );
597 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2 );
598 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP );
599 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1 );
600 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2 );
601 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00 );
602 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01 );
603 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10 );
604 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11 );
605 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX );
606 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE );
607 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET );
608 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
609 D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW );
610 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0 );
611 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0 );
612 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG );
613 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT );
614 #undef D3DSTATE_TO_STR
615 case 12:
616 /* Note WINED3DTSS are not consecutive, so skip these */
617 return "unused";
618 break;
619 default:
620 FIXME("Unrecognized %u texture state!\n", state);
621 return "unrecognized";
622 }
623 }
624
625 static const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop) {
626 switch (d3dtop) {
627 #define D3DTOP_TO_STR(u) case u: return #u
628 D3DTOP_TO_STR(WINED3DTOP_DISABLE);
629 D3DTOP_TO_STR(WINED3DTOP_SELECTARG1);
630 D3DTOP_TO_STR(WINED3DTOP_SELECTARG2);
631 D3DTOP_TO_STR(WINED3DTOP_MODULATE);
632 D3DTOP_TO_STR(WINED3DTOP_MODULATE2X);
633 D3DTOP_TO_STR(WINED3DTOP_MODULATE4X);
634 D3DTOP_TO_STR(WINED3DTOP_ADD);
635 D3DTOP_TO_STR(WINED3DTOP_ADDSIGNED);
636 D3DTOP_TO_STR(WINED3DTOP_SUBTRACT);
637 D3DTOP_TO_STR(WINED3DTOP_ADDSMOOTH);
638 D3DTOP_TO_STR(WINED3DTOP_BLENDDIFFUSEALPHA);
639 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHA);
640 D3DTOP_TO_STR(WINED3DTOP_BLENDFACTORALPHA);
641 D3DTOP_TO_STR(WINED3DTOP_BLENDTEXTUREALPHAPM);
642 D3DTOP_TO_STR(WINED3DTOP_BLENDCURRENTALPHA);
643 D3DTOP_TO_STR(WINED3DTOP_PREMODULATE);
644 D3DTOP_TO_STR(WINED3DTOP_MODULATEALPHA_ADDCOLOR);
645 D3DTOP_TO_STR(WINED3DTOP_MODULATECOLOR_ADDALPHA);
646 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVALPHA_ADDCOLOR);
647 D3DTOP_TO_STR(WINED3DTOP_MODULATEINVCOLOR_ADDALPHA);
648 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAP);
649 D3DTOP_TO_STR(WINED3DTOP_BUMPENVMAPLUMINANCE);
650 D3DTOP_TO_STR(WINED3DTOP_DOTPRODUCT3);
651 D3DTOP_TO_STR(WINED3DTOP_MULTIPLYADD);
652 D3DTOP_TO_STR(WINED3DTOP_LERP);
653 #undef D3DTOP_TO_STR
654 default:
655 FIXME("Unrecognized %u WINED3DTOP\n", d3dtop);
656 return "unrecognized";
657 }
658 }
659
660 const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) {
661 switch (tstype) {
662 #define TSTYPE_TO_STR(tstype) case tstype: return #tstype
663 TSTYPE_TO_STR(WINED3DTS_VIEW);
664 TSTYPE_TO_STR(WINED3DTS_PROJECTION);
665 TSTYPE_TO_STR(WINED3DTS_TEXTURE0);
666 TSTYPE_TO_STR(WINED3DTS_TEXTURE1);
667 TSTYPE_TO_STR(WINED3DTS_TEXTURE2);
668 TSTYPE_TO_STR(WINED3DTS_TEXTURE3);
669 TSTYPE_TO_STR(WINED3DTS_TEXTURE4);
670 TSTYPE_TO_STR(WINED3DTS_TEXTURE5);
671 TSTYPE_TO_STR(WINED3DTS_TEXTURE6);
672 TSTYPE_TO_STR(WINED3DTS_TEXTURE7);
673 TSTYPE_TO_STR(WINED3DTS_WORLDMATRIX(0));
674 #undef TSTYPE_TO_STR
675 default:
676 if (tstype > 256 && tstype < 512) {
677 FIXME("WINED3DTS_WORLDMATRIX(%u). 1..255 not currently supported\n", tstype);
678 return ("WINED3DTS_WORLDMATRIX > 0");
679 }
680 FIXME("Unrecognized %u WINED3DTS\n", tstype);
681 return "unrecognized";
682 }
683 }
684
685 const char* debug_d3dpool(WINED3DPOOL Pool) {
686 switch (Pool) {
687 #define POOL_TO_STR(p) case p: return #p;
688 POOL_TO_STR(WINED3DPOOL_DEFAULT);
689 POOL_TO_STR(WINED3DPOOL_MANAGED);
690 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
691 POOL_TO_STR(WINED3DPOOL_SCRATCH);
692 #undef POOL_TO_STR
693 default:
694 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
695 return "unrecognized";
696 }
697 }
698
699 const char *debug_fbostatus(GLenum status) {
700 switch(status) {
701 #define FBOSTATUS_TO_STR(u) case u: return #u
702 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_COMPLETE_EXT);
703 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT);
704 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT);
705 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT);
706 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT);
707 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT);
708 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT);
709 FBOSTATUS_TO_STR(GL_FRAMEBUFFER_UNSUPPORTED_EXT);
710 #undef FBOSTATUS_TO_STR
711 default:
712 FIXME("Unrecognied FBO status 0x%08x\n", status);
713 return "unrecognized";
714 }
715 }
716
717 const char *debug_glerror(GLenum error) {
718 switch(error) {
719 #define GLERROR_TO_STR(u) case u: return #u
720 GLERROR_TO_STR(GL_NO_ERROR);
721 GLERROR_TO_STR(GL_INVALID_ENUM);
722 GLERROR_TO_STR(GL_INVALID_VALUE);
723 GLERROR_TO_STR(GL_INVALID_OPERATION);
724 GLERROR_TO_STR(GL_STACK_OVERFLOW);
725 GLERROR_TO_STR(GL_STACK_UNDERFLOW);
726 GLERROR_TO_STR(GL_OUT_OF_MEMORY);
727 GLERROR_TO_STR(GL_INVALID_FRAMEBUFFER_OPERATION_EXT);
728 #undef GLERROR_TO_STR
729 default:
730 FIXME("Unrecognied GL error 0x%08x\n", error);
731 return "unrecognized";
732 }
733 }
734
735 /*****************************************************************************
736 * Useful functions mapping GL <-> D3D values
737 */
738 GLenum StencilOp(DWORD op) {
739 switch(op) {
740 case WINED3DSTENCILOP_KEEP : return GL_KEEP;
741 case WINED3DSTENCILOP_ZERO : return GL_ZERO;
742 case WINED3DSTENCILOP_REPLACE : return GL_REPLACE;
743 case WINED3DSTENCILOP_INCRSAT : return GL_INCR;
744 case WINED3DSTENCILOP_DECRSAT : return GL_DECR;
745 case WINED3DSTENCILOP_INVERT : return GL_INVERT;
746 case WINED3DSTENCILOP_INCR : return GL_INCR_WRAP_EXT;
747 case WINED3DSTENCILOP_DECR : return GL_DECR_WRAP_EXT;
748 default:
749 FIXME("Unrecognized stencil op %d\n", op);
750 return GL_KEEP;
751 }
752 }
753
754 GLenum CompareFunc(DWORD func) {
755 switch ((WINED3DCMPFUNC)func) {
756 case WINED3DCMP_NEVER : return GL_NEVER;
757 case WINED3DCMP_LESS : return GL_LESS;
758 case WINED3DCMP_EQUAL : return GL_EQUAL;
759 case WINED3DCMP_LESSEQUAL : return GL_LEQUAL;
760 case WINED3DCMP_GREATER : return GL_GREATER;
761 case WINED3DCMP_NOTEQUAL : return GL_NOTEQUAL;
762 case WINED3DCMP_GREATEREQUAL : return GL_GEQUAL;
763 case WINED3DCMP_ALWAYS : return GL_ALWAYS;
764 default:
765 FIXME("Unrecognized WINED3DCMPFUNC value %d\n", func);
766 return 0;
767 }
768 }
769
770 static GLenum d3dta_to_combiner_input(DWORD d3dta, DWORD stage, INT texture_idx) {
771 switch (d3dta) {
772 case WINED3DTA_DIFFUSE:
773 return GL_PRIMARY_COLOR_NV;
774
775 case WINED3DTA_CURRENT:
776 if (stage) return GL_SPARE0_NV;
777 else return GL_PRIMARY_COLOR_NV;
778
779 case WINED3DTA_TEXTURE:
780 if (texture_idx > -1) return GL_TEXTURE0_ARB + texture_idx;
781 else return GL_PRIMARY_COLOR_NV;
782
783 case WINED3DTA_TFACTOR:
784 return GL_CONSTANT_COLOR0_NV;
785
786 case WINED3DTA_SPECULAR:
787 return GL_SECONDARY_COLOR_NV;
788
789 case WINED3DTA_TEMP:
790 /* TODO: Support WINED3DTSS_RESULTARG */
791 FIXME("WINED3DTA_TEMP, not properly supported.\n");
792 return GL_SPARE1_NV;
793
794 case WINED3DTA_CONSTANT:
795 /* TODO: Support per stage constants (WINED3DTSS_CONSTANT, NV_register_combiners2) */
796 FIXME("WINED3DTA_CONSTANT, not properly supported.\n");
797 return GL_CONSTANT_COLOR1_NV;
798
799 default:
800 FIXME("Unrecognized texture arg %#x\n", d3dta);
801 return GL_TEXTURE;
802 }
803 }
804
805 static GLenum invert_mapping(GLenum mapping) {
806 if (mapping == GL_UNSIGNED_INVERT_NV) return GL_SIGNED_IDENTITY_NV;
807 else if (mapping == GL_SIGNED_IDENTITY_NV) return GL_UNSIGNED_INVERT_NV;
808
809 FIXME("Unhandled mapping %#x\n", mapping);
810 return mapping;
811 }
812
813 static void get_src_and_opr_nvrc(DWORD stage, DWORD arg, BOOL is_alpha, GLenum* input, GLenum* mapping, GLenum *component_usage, INT texture_idx) {
814 /* The WINED3DTA_COMPLEMENT flag specifies the complement of the input should
815 * be used. */
816 if (arg & WINED3DTA_COMPLEMENT) *mapping = GL_UNSIGNED_INVERT_NV;
817 else *mapping = GL_SIGNED_IDENTITY_NV;
818
819 /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the input
820 * should be used for all input components. */
821 if (is_alpha || arg & WINED3DTA_ALPHAREPLICATE) *component_usage = GL_ALPHA;
822 else *component_usage = GL_RGB;
823
824 *input = d3dta_to_combiner_input(arg & WINED3DTA_SELECTMASK, stage, texture_idx);
825 }
826
827 typedef struct {
828 GLenum input[3];
829 GLenum mapping[3];
830 GLenum component_usage[3];
831 } tex_op_args;
832
833 static BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) {
834 if (op == WINED3DTOP_DISABLE) return FALSE;
835 if (This->stateBlock->textures[stage]) return FALSE;
836
837 if ((arg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
838 && op != WINED3DTOP_SELECTARG2) return TRUE;
839 if ((arg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
840 && op != WINED3DTOP_SELECTARG1) return TRUE;
841 if ((arg3 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE
842 && (op == WINED3DTOP_MULTIPLYADD || op == WINED3DTOP_LERP)) return TRUE;
843
844 return FALSE;
845 }
846
847 void set_tex_op_nvrc(IWineD3DDevice *iface, BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx) {
848 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl*)iface;
849 tex_op_args tex_op_args = {{0}, {0}, {0}};
850 GLenum portion = is_alpha ? GL_ALPHA : GL_RGB;
851 GLenum target = GL_COMBINER0_NV + stage;
852
853 TRACE("stage %d, is_alpha %d, op %s, arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
854 stage, is_alpha, debug_d3dtop(op), arg1, arg2, arg3, texture_idx);
855
856 /* If a texture stage references an invalid texture unit the stage just
857 * passes through the result from the previous stage */
858 if (is_invalid_op(This, stage, op, arg1, arg2, arg3)) {
859 arg1 = WINED3DTA_CURRENT;
860 op = WINED3DTOP_SELECTARG1;
861 }
862
863 get_src_and_opr_nvrc(stage, arg1, is_alpha, &tex_op_args.input[0],
864 &tex_op_args.mapping[0], &tex_op_args.component_usage[0], texture_idx);
865 get_src_and_opr_nvrc(stage, arg2, is_alpha, &tex_op_args.input[1],
866 &tex_op_args.mapping[1], &tex_op_args.component_usage[1], texture_idx);
867 get_src_and_opr_nvrc(stage, arg3, is_alpha, &tex_op_args.input[2],
868 &tex_op_args.mapping[2], &tex_op_args.component_usage[2], texture_idx);
869
870
871 /* This is called by a state handler which has the gl lock held and a context for the thread */
872 switch(op)
873 {
874 case WINED3DTOP_DISABLE:
875 /* Only for alpha */
876 if (!is_alpha) ERR("Shouldn't be called for WINED3DTSS_COLOROP (WINED3DTOP_DISABLE)\n");
877 /* Input, prev_alpha*1 */
878 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
879 GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
880 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
881 GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
882
883 /* Output */
884 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
885 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
886 break;
887
888 case WINED3DTOP_SELECTARG1:
889 case WINED3DTOP_SELECTARG2:
890 /* Input, arg*1 */
891 if (op == WINED3DTOP_SELECTARG1) {
892 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
893 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
894 } else {
895 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
896 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
897 }
898 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
899 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
900
901 /* Output */
902 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
903 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
904 break;
905
906 case WINED3DTOP_MODULATE:
907 case WINED3DTOP_MODULATE2X:
908 case WINED3DTOP_MODULATE4X:
909 /* Input, arg1*arg2 */
910 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
911 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
912 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
913 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
914
915 /* Output */
916 if (op == WINED3DTOP_MODULATE) {
917 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
918 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
919 } else if (op == WINED3DTOP_MODULATE2X) {
920 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
921 GL_DISCARD_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
922 } else if (op == WINED3DTOP_MODULATE4X) {
923 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
924 GL_DISCARD_NV, GL_SCALE_BY_FOUR_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
925 }
926 break;
927
928 case WINED3DTOP_ADD:
929 case WINED3DTOP_ADDSIGNED:
930 case WINED3DTOP_ADDSIGNED2X:
931 /* Input, arg1*1+arg2*1 */
932 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
933 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
934 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
935 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
936 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
937 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
938 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
939 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
940
941 /* Output */
942 if (op == WINED3DTOP_ADD) {
943 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
944 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
945 } else if (op == WINED3DTOP_ADDSIGNED) {
946 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
947 GL_SPARE0_NV, GL_NONE, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
948 } else if (op == WINED3DTOP_ADDSIGNED2X) {
949 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
950 GL_SPARE0_NV, GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
951 }
952 break;
953
954 case WINED3DTOP_SUBTRACT:
955 /* Input, arg1*1+-arg2*1 */
956 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
957 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
958 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
959 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
960 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
961 tex_op_args.input[1], GL_SIGNED_NEGATE_NV, tex_op_args.component_usage[1]));
962 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
963 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
964
965 /* Output */
966 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
967 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
968 break;
969
970 case WINED3DTOP_ADDSMOOTH:
971 /* Input, arg1*1+(1-arg1)*arg2 */
972 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
973 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
974 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
975 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
976 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
977 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
978 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
979 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
980
981 /* Output */
982 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
983 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
984 break;
985
986 case WINED3DTOP_BLENDDIFFUSEALPHA:
987 case WINED3DTOP_BLENDTEXTUREALPHA:
988 case WINED3DTOP_BLENDFACTORALPHA:
989 case WINED3DTOP_BLENDTEXTUREALPHAPM:
990 case WINED3DTOP_BLENDCURRENTALPHA:
991 {
992 GLenum alpha_src = GL_PRIMARY_COLOR_NV;
993 if (op == WINED3DTOP_BLENDDIFFUSEALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_DIFFUSE, stage, texture_idx);
994 else if (op == WINED3DTOP_BLENDTEXTUREALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
995 else if (op == WINED3DTOP_BLENDFACTORALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TFACTOR, stage, texture_idx);
996 else if (op == WINED3DTOP_BLENDTEXTUREALPHAPM) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
997 else if (op == WINED3DTOP_BLENDCURRENTALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_CURRENT, stage, texture_idx);
998 else FIXME("Unhandled WINED3DTOP %s, shouldn't happen\n", debug_d3dtop(op));
999
1000 /* Input, arg1*alpha_src+arg2*(1-alpha_src) */
1001 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1002 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1003 if (op == WINED3DTOP_BLENDTEXTUREALPHAPM)
1004 {
1005 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1006 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1007 } else {
1008 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1009 alpha_src, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
1010 }
1011 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1012 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1013 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1014 alpha_src, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
1015
1016 /* Output */
1017 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1018 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1019 break;
1020 }
1021
1022 case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
1023 /* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
1024 if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEALPHA_ADDCOLOR)\n");
1025 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1026 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
1027 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1028 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1029 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1030 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1031 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1032 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1033
1034 /* Output */
1035 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1036 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1037 break;
1038
1039 case WINED3DTOP_MODULATECOLOR_ADDALPHA:
1040 /* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
1041 if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATECOLOR_ADDALPHA)\n");
1042 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1043 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1044 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1045 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1046 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1047 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
1048 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1049 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1050
1051 /* Output */
1052 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1053 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1054 break;
1055
1056 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
1057 /* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
1058 if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR)\n");
1059 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1060 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), GL_ALPHA));
1061 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1062 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1063 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1064 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1065 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1066 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1067
1068 /* Output */
1069 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1070 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1071 break;
1072
1073 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
1074 /* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
1075 if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA)\n");
1076 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1077 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
1078 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1079 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1080 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1081 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
1082 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1083 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1084
1085 /* Output */
1086 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1087 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1088 break;
1089
1090 case WINED3DTOP_DOTPRODUCT3:
1091 /* Input, arg1 . arg2 */
1092 /* FIXME: DX7 uses a different calculation? */
1093 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1094 tex_op_args.input[0], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[0]));
1095 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1096 tex_op_args.input[1], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[1]));
1097
1098 /* Output */
1099 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
1100 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE));
1101 break;
1102
1103 case WINED3DTOP_MULTIPLYADD:
1104 /* Input, arg1*1+arg2*arg3 */
1105 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1106 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1107 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1108 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1109 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1110 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1111 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1112 tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
1113
1114 /* Output */
1115 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1116 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1117 break;
1118
1119 case WINED3DTOP_LERP:
1120 /* Input, arg1*arg2+(1-arg1)*arg3 */
1121 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1122 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
1123 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1124 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1125 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
1126 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
1127 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
1128 tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
1129
1130 /* Output */
1131 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
1132 GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1133 break;
1134
1135 case WINED3DTOP_BUMPENVMAPLUMINANCE:
1136 case WINED3DTOP_BUMPENVMAP:
1137 if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1138 /* The bump map stage itself isn't exciting, just read the texture. But tell the next stage to
1139 * perform bump mapping and source from the current stage. Pretty much a SELECTARG2.
1140 * ARG2 is passed through unmodified(apps will most likely use D3DTA_CURRENT for arg2, arg1
1141 * (which will most likely be D3DTA_TEXTURE) is available as a texture shader input for the next stage
1142 */
1143 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
1144 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
1145 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
1146 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
1147 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
1148 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
1149 break;
1150 }
1151
1152 default:
1153 FIXME("Unhandled WINED3DTOP: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
1154 stage, is_alpha, debug_d3dtop(op), op, arg1, arg2, arg3, texture_idx);
1155 }
1156
1157 checkGLcall("set_tex_op_nvrc()\n");
1158
1159 }
1160
1161 static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* operand) {
1162 /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the
1163 * input should be used for all input components. The WINED3DTA_COMPLEMENT
1164 * flag specifies the complement of the input should be used. */
1165 BOOL from_alpha = is_alpha || arg & WINED3DTA_ALPHAREPLICATE;
1166 BOOL complement = arg & WINED3DTA_COMPLEMENT;
1167
1168 /* Calculate the operand */
1169 if (complement) {
1170 if (from_alpha) *operand = GL_ONE_MINUS_SRC_ALPHA;
1171 else *operand = GL_ONE_MINUS_SRC_COLOR;
1172 } else {
1173 if (from_alpha) *operand = GL_SRC_ALPHA;
1174 else *operand = GL_SRC_COLOR;
1175 }
1176
1177 /* Calculate the source */
1178 switch (arg & WINED3DTA_SELECTMASK) {
1179 case WINED3DTA_CURRENT: *source = GL_PREVIOUS_EXT; break;
1180 case WINED3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT; break;
1181 case WINED3DTA_TEXTURE: *source = GL_TEXTURE; break;
1182 case WINED3DTA_TFACTOR: *source = GL_CONSTANT_EXT; break;
1183 case WINED3DTA_SPECULAR:
1184 /*
1185 * According to the GL_ARB_texture_env_combine specs, SPECULAR is
1186 * 'Secondary color' and isn't supported until base GL supports it
1187 * There is no concept of temp registers as far as I can tell
1188 */
1189 FIXME("Unhandled texture arg WINED3DTA_SPECULAR\n");
1190 *source = GL_TEXTURE;
1191 break;
1192 default:
1193 FIXME("Unrecognized texture arg %#x\n", arg);
1194 *source = GL_TEXTURE;
1195 break;
1196 }
1197 }
1198
1199 /* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
1200 #if defined (GL_VERSION_1_3)
1201 # define useext(A) A
1202 # define combine_ext 1
1203 #elif defined (GL_EXT_texture_env_combine)
1204 # define useext(A) A##_EXT
1205 # define combine_ext 1
1206 #elif defined (GL_ARB_texture_env_combine)
1207 # define useext(A) A##_ARB
1208 # define combine_ext 1
1209 #else
1210 # undef combine_ext
1211 #endif
1212
1213 #if !defined(combine_ext)
1214 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
1215 {
1216 FIXME("Requires opengl combine extensions to work\n");
1217 return;
1218 }
1219 #else
1220 /* Setup the texture operations texture stage states */
1221 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
1222 {
1223 GLenum src1, src2, src3;
1224 GLenum opr1, opr2, opr3;
1225 GLenum comb_target;
1226 GLenum src0_target, src1_target, src2_target;
1227 GLenum opr0_target, opr1_target, opr2_target;
1228 GLenum scal_target;
1229 GLenum opr=0, invopr, src3_target, opr3_target;
1230 BOOL Handled = FALSE;
1231 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1232
1233 TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha, Stage, debug_d3dtop(op), arg1, arg2, arg3);
1234
1235 /* This is called by a state handler which has the gl lock held and a context for the thread */
1236
1237 /* Note: Operations usually involve two ars, src0 and src1 and are operations of
1238 the form (a1 <operation> a2). However, some of the more complex operations
1239 take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
1240 in a third parameter called a0. Therefore these are operations of the form
1241 a0 <operation> a1 <operation> a2, ie the new parameter goes to the front.
1242
1243 However, below we treat the new (a0) parameter as src2/opr2, so in the actual
1244 functions below, expect their syntax to differ slightly to those listed in the
1245 manuals, ie replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
1246 This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP */
1247
1248 if (isAlpha) {
1249 comb_target = useext(GL_COMBINE_ALPHA);
1250 src0_target = useext(GL_SOURCE0_ALPHA);
1251 src1_target = useext(GL_SOURCE1_ALPHA);
1252 src2_target = useext(GL_SOURCE2_ALPHA);
1253 opr0_target = useext(GL_OPERAND0_ALPHA);
1254 opr1_target = useext(GL_OPERAND1_ALPHA);
1255 opr2_target = useext(GL_OPERAND2_ALPHA);
1256 scal_target = GL_ALPHA_SCALE;
1257 }
1258 else {
1259 comb_target = useext(GL_COMBINE_RGB);
1260 src0_target = useext(GL_SOURCE0_RGB);
1261 src1_target = useext(GL_SOURCE1_RGB);
1262 src2_target = useext(GL_SOURCE2_RGB);
1263 opr0_target = useext(GL_OPERAND0_RGB);
1264 opr1_target = useext(GL_OPERAND1_RGB);
1265 opr2_target = useext(GL_OPERAND2_RGB);
1266 scal_target = useext(GL_RGB_SCALE);
1267 }
1268
1269 /* If a texture stage references an invalid texture unit the stage just
1270 * passes through the result from the previous stage */
1271 if (is_invalid_op(This, Stage, op, arg1, arg2, arg3)) {
1272 arg1 = WINED3DTA_CURRENT;
1273 op = WINED3DTOP_SELECTARG1;
1274 }
1275
1276 /* From MSDN (WINED3DTSS_ALPHAARG1) :
1277 The default argument is WINED3DTA_TEXTURE. If no texture is set for this stage,
1278 then the default argument is WINED3DTA_DIFFUSE.
1279 FIXME? If texture added/removed, may need to reset back as well? */
1280 if (isAlpha && This->stateBlock->textures[Stage] == NULL && arg1 == WINED3DTA_TEXTURE) {
1281 get_src_and_opr(WINED3DTA_DIFFUSE, isAlpha, &src1, &opr1);
1282 } else {
1283 get_src_and_opr(arg1, isAlpha, &src1, &opr1);
1284 }
1285 get_src_and_opr(arg2, isAlpha, &src2, &opr2);
1286 get_src_and_opr(arg3, isAlpha, &src3, &opr3);
1287
1288 TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
1289
1290 Handled = TRUE; /* Assume will be handled */
1291
1292 /* Other texture operations require special extensions: */
1293 if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
1294 if (isAlpha) {
1295 opr = GL_SRC_ALPHA;
1296 invopr = GL_ONE_MINUS_SRC_ALPHA;
1297 src3_target = GL_SOURCE3_ALPHA_NV;
1298 opr3_target = GL_OPERAND3_ALPHA_NV;
1299 } else {
1300 opr = GL_SRC_COLOR;
1301 invopr = GL_ONE_MINUS_SRC_COLOR;
1302 src3_target = GL_SOURCE3_RGB_NV;
1303 opr3_target = GL_OPERAND3_RGB_NV;
1304 }
1305 switch (op) {
1306 case WINED3DTOP_DISABLE: /* Only for alpha */
1307 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1308 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1309 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1310 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1311 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1312 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1313 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1314 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1315 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1316 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1317 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1318 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1319 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1320 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1321 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1322 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1323 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1324 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1325 break;
1326 case WINED3DTOP_SELECTARG1: /* = a1 * 1 + 0 * 0 */
1327 case WINED3DTOP_SELECTARG2: /* = a2 * 1 + 0 * 0 */
1328 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1329 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1330 if (op == WINED3DTOP_SELECTARG1) {
1331 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1332 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1333 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1334 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1335 } else {
1336 glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1337 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1338 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1339 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1340 }
1341 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1342 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1343 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1344 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1345 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1346 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1347 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1348 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1349 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1350 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1351 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1352 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1353 break;
1354
1355 case WINED3DTOP_MODULATE:
1356 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1357 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1358 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1359 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1360 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1361 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1362 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1363 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1364 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1365 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1366 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1367 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1368 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1369 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1370 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1371 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1372 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1373 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1374 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1375 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1376 break;
1377 case WINED3DTOP_MODULATE2X:
1378 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1379 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1380 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1381 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1382 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1383 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1384 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1385 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1386 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1387 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1388 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1389 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1390 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1391 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1392 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1393 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1394 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1395 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1396 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1397 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1398 break;
1399 case WINED3DTOP_MODULATE4X:
1400 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1401 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1402 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1403 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1404 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1405 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1406 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1407 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1408 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1409 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1410 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1411 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1412 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1413 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1414 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1415 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1416 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1417 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1418 glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
1419 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1420 break;
1421
1422 case WINED3DTOP_ADD:
1423 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1424 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1425 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1426 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1427 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1428 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1429 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1430 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1431 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1432 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1433 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1434 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1435 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1436 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1437 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1438 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1439 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1440 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1441 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1442 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1443 break;
1444
1445 case WINED3DTOP_ADDSIGNED:
1446 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1447 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1448 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1449 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1450 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1451 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1452 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1453 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1454 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1455 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1456 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1457 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1458 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1459 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1460 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1461 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1462 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1463 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1464 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1465 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1466 break;
1467
1468 case WINED3DTOP_ADDSIGNED2X:
1469 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1470 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1471 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1472 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1473 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1474 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1475 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1476 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1477 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1478 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1479 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1480 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1481 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1482 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1483 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1484 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1485 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1486 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1487 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1488 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1489 break;
1490
1491 case WINED3DTOP_ADDSMOOTH:
1492 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1493 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1494 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1495 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1496 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1497 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1498 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1499 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1500 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1501 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1502 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1503 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1504 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1505 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1506 glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1507 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1508 switch (opr1) {
1509 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1510 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1511 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1512 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1513 }
1514 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1515 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1516 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1517 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1518 break;
1519
1520 case WINED3DTOP_BLENDDIFFUSEALPHA:
1521 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1522 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1523 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1524 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1525 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1526 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1527 glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR));
1528 checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
1529 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1530 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1531 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1532 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1533 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1534 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1535 glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR));
1536 checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
1537 glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1538 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1539 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1540 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1541 break;
1542 case WINED3DTOP_BLENDTEXTUREALPHA:
1543 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1544 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1545 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1546 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1547 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1548 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1549 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_TEXTURE);
1550 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
1551 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1552 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1553 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1554 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1555 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1556 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1557 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
1558 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
1559 glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1560 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1561 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1562 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1563 break;
1564 case WINED3DTOP_BLENDFACTORALPHA:
1565 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1566 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1567 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1568 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1569 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1570 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1571 glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT));
1572 checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
1573 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1574 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1575 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1576 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1577 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1578 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1579 glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT));
1580 checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
1581 glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1582 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1583 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1584 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1585 break;
1586 case WINED3DTOP_BLENDTEXTUREALPHAPM:
1587 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1588 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1589 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1590 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1591 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1592 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1593 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1594 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1595 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1596 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1597 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1598 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1599 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1600 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1601 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
1602 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
1603 glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
1604 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
1605 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1606 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1607 break;
1608 case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
1609 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1610 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
1611 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1); /* a0 = src1/opr1 */
1612 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1613 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1614 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
1615 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1616 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1617 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1618 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1619 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2); /* a2 = arg2 */
1620 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1621 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1622 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
1623 glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1624 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1625 switch (opr) {
1626 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1627 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1628 }
1629 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1630 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1631 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1632 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1633 break;
1634 case WINED3DTOP_MODULATECOLOR_ADDALPHA:
1635 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1636 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1637 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1638 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1639 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1640 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1641 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1642 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1643 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1644 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1645 glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1646 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1647 switch (opr1) {
1648 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1649 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1650 }
1651 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1652 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1653 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1654 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1655 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1656 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1657 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1658 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1659 break;
1660 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
1661 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1662 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1663 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1664 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1665 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1666 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1667 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1668 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1669 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1670 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1671 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1672 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1673 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1674 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1675 glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1676 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1677 switch (opr1) {
1678 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1679 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1680 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1681 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1682 }
1683 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1684 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1685 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1686 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1687 break;
1688 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
1689 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1690 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1691 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1692 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1693 switch (opr1) {
1694 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1695 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1696 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1697 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1698 }
1699 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1700 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1701 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1702 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1703 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1704 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1705 glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1706 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1707 switch (opr1) {
1708 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1709 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1710 }
1711 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1712 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1713 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1714 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1715 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1716 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1717 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1718 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1719 break;
1720 case WINED3DTOP_MULTIPLYADD:
1721 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1722 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1723 glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
1724 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1725 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
1726 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1727 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1728 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1729 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1730 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1731 glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1732 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1733 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
1734 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1735 glTexEnvi(GL_TEXTURE_ENV, src3_target, src2);
1736 checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
1737 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr2);
1738 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
1739 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1740 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1741 break;
1742
1743 case WINED3DTOP_BUMPENVMAP:
1744 {
1745 }
1746
1747 case WINED3DTOP_BUMPENVMAPLUMINANCE:
1748 FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
1749
1750 default:
1751 Handled = FALSE;
1752 }
1753 if (Handled) {
1754 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
1755 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
1756
1757 return;
1758 }
1759 } /* GL_NV_texture_env_combine4 */
1760
1761 Handled = TRUE; /* Again, assume handled */
1762 switch (op) {
1763 case WINED3DTOP_DISABLE: /* Only for alpha */
1764 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1765 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1766 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1767 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
1768 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1769 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
1770 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1771 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1772 break;
1773 case WINED3DTOP_SELECTARG1:
1774 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1775 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1776 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1777 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1778 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1779 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1780 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1781 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1782 break;
1783 case WINED3DTOP_SELECTARG2:
1784 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1785 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1786 glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1787 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1788 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1789 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1790 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1791 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1792 break;
1793 case WINED3DTOP_MODULATE:
1794 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1795 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1796 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1797 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1798 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1799 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1800 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1801 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1802 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1803 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1804 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1805 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1806 break;
1807 case WINED3DTOP_MODULATE2X:
1808 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1809 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1810 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1811 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1812 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1813 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1814 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1815 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1816 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1817 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1818 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1819 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1820 break;
1821 case WINED3DTOP_MODULATE4X:
1822 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1823 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1824 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1825 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1826 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1827 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1828 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1829 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1830 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1831 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1832 glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
1833 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1834 break;
1835 case WINED3DTOP_ADD:
1836 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1837 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1838 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1839 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1840 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1841 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1842 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1843 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1844 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1845 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1846 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1847 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1848 break;
1849 case WINED3DTOP_ADDSIGNED:
1850 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1851 checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
1852 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1853 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1854 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1855 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1856 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1857 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1858 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1859 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1860 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1861 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1862 break;
1863 case WINED3DTOP_ADDSIGNED2X:
1864 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1865 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1866 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1867 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1868 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1869 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1870 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1871 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1872 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1873 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1874 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1875 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1876 break;
1877 case WINED3DTOP_SUBTRACT:
1878 if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE)) {
1879 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
1880 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
1881 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1882 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1883 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1884 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1885 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1886 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1887 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1888 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1889 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1890 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1891 } else {
1892 FIXME("This version of opengl does not support GL_SUBTRACT\n");
1893 }
1894 break;
1895
1896 case WINED3DTOP_BLENDDIFFUSEALPHA:
1897 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1898 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1899 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1900 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1901 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1902 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1903 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1904 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1905 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1906 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1907 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PRIMARY_COLOR));
1908 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
1909 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1910 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1911 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1912 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1913 break;
1914 case WINED3DTOP_BLENDTEXTUREALPHA:
1915 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1916 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1917 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1918 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1919 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1920 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1921 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1922 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1923 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1924 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1925 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
1926 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
1927 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1928 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1929 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1930 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1931 break;
1932 case WINED3DTOP_BLENDFACTORALPHA:
1933 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1934 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1935 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1936 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1937 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1938 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1939 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1940 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1941 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1942 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1943 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_CONSTANT));
1944 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
1945 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1946 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1947 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1948 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1949 break;
1950 case WINED3DTOP_BLENDCURRENTALPHA:
1951 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1952 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1953 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1954 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1955 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1956 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1957 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1958 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1959 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1960 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1961 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PREVIOUS));
1962 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
1963 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1964 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1965 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1966 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1967 break;
1968 case WINED3DTOP_DOTPRODUCT3:
1969 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3)) {
1970 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
1971 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
1972 } else if (GL_SUPPORT(EXT_TEXTURE_ENV_DOT3)) {
1973 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
1974 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
1975 } else {
1976 FIXME("This version of opengl does not support GL_DOT3\n");
1977 }
1978 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1979 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1980 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1981 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1982 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1983 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1984 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1985 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1986 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1987 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1988 break;
1989 case WINED3DTOP_LERP:
1990 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1991 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1992 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1993 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1994 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1995 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1996 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1997 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1998 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1999 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2000 glTexEnvi(GL_TEXTURE_ENV, src2_target, src3);
2001 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
2002 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr3);
2003 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
2004 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2005 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2006 break;
2007 case WINED3DTOP_ADDSMOOTH:
2008 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2009 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2010 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2011 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2012 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2013 switch (opr1) {
2014 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
2015 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
2016 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2017 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2018 }
2019 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2020 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2021 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2022 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2023 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2024 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2025 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2026 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2027 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2028 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2029 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2030 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2031 } else
2032 Handled = FALSE;
2033 break;
2034 case WINED3DTOP_BLENDTEXTUREALPHAPM:
2035 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2036 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2037 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2038 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_TEXTURE);
2039 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
2040 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_ALPHA);
2041 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
2042 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2043 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2044 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2045 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2046 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2047 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2048 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2049 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2050 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2051 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2052 } else
2053 Handled = FALSE;
2054 break;
2055 case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
2056 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2057 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2058 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2059 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2060 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2061 switch (opr1) {
2062 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2063 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2064 case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2065 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2066 }
2067 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2068 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2069 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2070 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2071 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2072 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2073 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2074 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2075 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2076 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2077 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2078 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2079 } else
2080 Handled = FALSE;
2081 break;
2082 case WINED3DTOP_MODULATECOLOR_ADDALPHA:
2083 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2084 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2085 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2086 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2087 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2088 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2089 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2090 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2091 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2092 switch (opr1) {
2093 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2094 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2095 case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2096 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2097 }
2098 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
2099 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2100 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2101 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2102 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2103 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2104 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2105 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2106 } else
2107 Handled = FALSE;
2108 break;
2109 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
2110 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2111 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2112 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2113 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2114 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2115 switch (opr1) {
2116 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2117 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2118 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2119 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2120 }
2121 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2122 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2123 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2124 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2125 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2126 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2127 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2128 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2129 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2130 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2131 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2132 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2133 } else
2134 Handled = FALSE;
2135 break;
2136 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
2137 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2138 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2139 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2140 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2141 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2142 switch (opr1) {
2143 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
2144 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
2145 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2146 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2147 }
2148 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2149 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2150 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2151 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2152 switch (opr1) {
2153 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2154 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2155 case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2156 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2157 }
2158 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
2159 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2160 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2161 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2162 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2163 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2164 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2165 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2166 } else
2167 Handled = FALSE;
2168 break;
2169 case WINED3DTOP_MULTIPLYADD:
2170 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2171 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2172 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2173 glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
2174 checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
2175 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
2176 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
2177 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2178 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2179 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2180 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2181 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2182 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2183 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2184 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2185 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2186 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2187 } else
2188 Handled = FALSE;
2189 break;
2190 case WINED3DTOP_BUMPENVMAPLUMINANCE:
2191 if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
2192 /* Some apps use BUMPENVMAPLUMINANCE instead of D3DTOP_BUMPENVMAP, although
2193 * they check for the non-luminance cap flag. Well, give them what they asked
2194 * for :-)
2195 */
2196 WARN("Application uses WINED3DTOP_BUMPENVMAPLUMINANCE\n");
2197 } else {
2198 Handled = FALSE;
2199 break;
2200 }
2201 /* Fall through */
2202 case WINED3DTOP_BUMPENVMAP:
2203 if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
2204 TRACE("Using ati bumpmap on stage %d, target %d\n", Stage, Stage + 1);
2205 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_BUMP_ENVMAP_ATI);
2206 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_BUMP_ENVMAP_ATI)");
2207 glTexEnvi(GL_TEXTURE_ENV, GL_BUMP_TARGET_ATI, GL_TEXTURE0_ARB + Stage + 1);
2208 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_BUMP_TARGET_ATI, GL_TEXTURE0_ARB + Stage + 1)");
2209 glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
2210 checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
2211 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
2212 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
2213 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2214 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2215 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2216 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2217 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2218 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2219 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2220 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2221
2222 Handled = TRUE;
2223 break;
2224 } else if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
2225 /* Technically texture shader support without register combiners is possible, but not expected to occur
2226 * on real world cards, so for now a fixme should be enough
2227 */
2228 FIXME("Implement bump mapping with GL_NV_texture_shader in non register combiner path\n");
2229 }
2230 default:
2231 Handled = FALSE;
2232 }
2233
2234 if (Handled) {
2235 BOOL combineOK = TRUE;
2236 if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2237 DWORD op2;
2238
2239 if (isAlpha) {
2240 op2 = This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP];
2241 } else {
2242 op2 = This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAOP];
2243 }
2244
2245 /* Note: If COMBINE4 in effect can't go back to combine! */
2246 switch (op2) {
2247 case WINED3DTOP_ADDSMOOTH:
2248 case WINED3DTOP_BLENDTEXTUREALPHAPM:
2249 case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
2250 case WINED3DTOP_MODULATECOLOR_ADDALPHA:
2251 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
2252 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
2253 case WINED3DTOP_MULTIPLYADD:
2254 /* Ignore those implemented in both cases */
2255 switch (op) {
2256 case WINED3DTOP_SELECTARG1:
2257 case WINED3DTOP_SELECTARG2:
2258 combineOK = FALSE;
2259 Handled = FALSE;
2260 break;
2261 default:
2262 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op), debug_d3dtop(op2), isAlpha);
2263 return;
2264 }
2265 }
2266 }
2267
2268 if (combineOK) {
2269 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
2270 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
2271
2272 return;
2273 }
2274 }
2275
2276 /* After all the extensions, if still unhandled, report fixme */
2277 FIXME("Unhandled texture operation %s\n", debug_d3dtop(op));
2278 #undef GLINFO_LOCATION
2279 }
2280 #endif
2281
2282 /* Setup this textures matrix according to the texture flags*/
2283 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords)
2284 {
2285 float mat[16];
2286
2287 glMatrixMode(GL_TEXTURE);
2288 checkGLcall("glMatrixMode(GL_TEXTURE)");
2289
2290 if (flags == WINED3DTTFF_DISABLE) {
2291 glLoadIdentity();
2292 checkGLcall("glLoadIdentity()");
2293 return;
2294 }
2295
2296 if (flags == (WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED)) {
2297 ERR("Invalid texture transform flags: WINED3DTTFF_COUNT1|WINED3DTTFF_PROJECTED\n");
2298 return;
2299 }
2300
2301 memcpy(mat, smat, 16 * sizeof(float));
2302
2303 switch (flags & ~WINED3DTTFF_PROJECTED) {
2304 case WINED3DTTFF_COUNT1: mat[1] = mat[5] = mat[13] = 0;
2305 case WINED3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
2306 default: mat[3] = mat[7] = mat[11] = 0, mat[15] = 1;
2307 }
2308
2309 if (flags & WINED3DTTFF_PROJECTED) {
2310 switch (flags & ~WINED3DTTFF_PROJECTED) {
2311 case WINED3DTTFF_COUNT2:
2312 mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
2313 mat[1] = mat[5] = mat[9] = mat[13] = 0;
2314 break;
2315 case WINED3DTTFF_COUNT3:
2316 mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
2317 mat[2] = mat[6] = mat[10] = mat[14] = 0;
2318 break;
2319 }
2320 } else if(!calculatedCoords) { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
2321 mat[12] = mat[8];
2322 mat[13] = mat[9];
2323 }
2324
2325 glLoadMatrixf(mat);
2326 checkGLcall("glLoadMatrixf(mat)");
2327 }
2328
2329 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
2330
2331 /* Convertes a D3D format into a OpenGL configuration format */
2332 int D3DFmtMakeGlCfg(WINED3DFORMAT BackBufferFormat, WINED3DFORMAT StencilBufferFormat, int *attribs, int* nAttribs, BOOL alternate){
2333 #define PUSH1(att) attribs[(*nAttribs)++] = (att);
2334 #define PUSH2(att,value) attribs[(*nAttribs)++] = (att); attribs[(*nAttribs)++] = (value);
2335 /*We need to do some Card specific stuff in here at some point,
2336 D3D now supports floating point format buffers, and there are a number of different OpelGl ways of managing these e.g.
2337 GLX_ATI_pixel_format_float
2338 */
2339 switch (BackBufferFormat) {
2340 /* color buffer */
2341 case WINED3DFMT_P8:
2342 PUSH2(GLX_RENDER_TYPE, GLX_COLOR_INDEX_BIT);
2343 PUSH2(GLX_BUFFER_SIZE, 8);
2344 PUSH2(GLX_DOUBLEBUFFER, TRUE);
2345 break;
2346
2347 case WINED3DFMT_R3G3B2:
2348 PUSH2(GLX_RENDER_TYPE, GLX_RGBA_BIT);
2349 PUSH2(GLX_RED_SIZE, 3);
2350 PUSH2(GLX_GREEN_SIZE, 3);
2351 PUSH2(GLX_BLUE_SIZE, 2);
2352 break;
2353
2354 case WINED3DFMT_A1R5G5B5:
2355 PUSH2(GLX_ALPHA_SIZE, 1);
2356 case WINED3DFMT_X1R5G5B5:
2357 PUSH2(GLX_RED_SIZE, 5);
2358 PUSH2(GLX_GREEN_SIZE, 5);
2359 PUSH2(GLX_BLUE_SIZE, 5);
2360 break;
2361
2362 case WINED3DFMT_R5G6B5:
2363 PUSH2(GLX_RED_SIZE, 5);
2364 PUSH2(GLX_GREEN_SIZE, 6);
2365 PUSH2(GLX_BLUE_SIZE, 5);
2366 break;
2367
2368 case WINED3DFMT_A4R4G4B4:
2369 PUSH2(GLX_ALPHA_SIZE, 4);
2370 case WINED3DFMT_X4R4G4B4:
2371 PUSH2(GLX_RED_SIZE, 4);
2372 PUSH2(GLX_GREEN_SIZE, 4);
2373 PUSH2(GLX_BLUE_SIZE, 4);
2374 break;
2375
2376 case WINED3DFMT_A8R8G8B8:
2377 PUSH2(GLX_ALPHA_SIZE, 8);
2378 case WINED3DFMT_R8G8B8:
2379 case WINED3DFMT_X8R8G8B8:
2380 PUSH2(GLX_RED_SIZE, 8);
2381 PUSH2(GLX_GREEN_SIZE, 8);
2382 PUSH2(GLX_BLUE_SIZE, 8);
2383 break;
2384
2385 case WINED3DFMT_A2R10G10B10:
2386 PUSH2(GLX_ALPHA_SIZE, 2);
2387 PUSH2(GLX_RED_SIZE, 10);
2388 PUSH2(GLX_GREEN_SIZE, 10);
2389 PUSH2(GLX_BLUE_SIZE, 10);
2390 break;
2391
2392 case WINED3DFMT_A16B16G16R16:
2393 PUSH2(GLX_ALPHA_SIZE, 16);
2394 PUSH2(GLX_RED_SIZE, 16);
2395 PUSH2(GLX_GREEN_SIZE, 16);
2396 PUSH2(GLX_BLUE_SIZE, 16);
2397 break;
2398
2399 default:
2400 FIXME("Unsupported color format: %s\n", debug_d3dformat(BackBufferFormat));
2401 break;
2402 }
2403 if(!alternate){
2404 switch (StencilBufferFormat) {
2405 case 0:
2406 break;
2407
2408 case WINED3DFMT_D16_LOCKABLE:
2409 case WINED3DFMT_D16:
2410 PUSH2(GLX_DEPTH_SIZE, 16);
2411 break;
2412
2413 case WINED3DFMT_D15S1:
2414 PUSH2(GLX_DEPTH_SIZE, 15);
2415 PUSH2(GLX_STENCIL_SIZE, 1);
2416 /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
2417 e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
2418 break;
2419
2420 case WINED3DFMT_D24X8:
2421 PUSH2(GLX_DEPTH_SIZE, 24);
2422 break;
2423
2424 case WINED3DFMT_D24X4S4:
2425 PUSH2(GLX_DEPTH_SIZE, 24);
2426 PUSH2(GLX_STENCIL_SIZE, 4);
2427 break;
2428
2429 case WINED3DFMT_D24S8:
2430 PUSH2(GLX_DEPTH_SIZE, 24);
2431 PUSH2(GLX_STENCIL_SIZE, 8);
2432 break;
2433
2434 case WINED3DFMT_D24FS8:
2435 PUSH2(GLX_DEPTH_SIZE, 24);
2436 PUSH2(GLX_STENCIL_SIZE, 8);
2437 break;
2438
2439 case WINED3DFMT_D32:
2440 PUSH2(GLX_DEPTH_SIZE, 32);
2441 break;
2442
2443 default:
2444 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
2445 break;
2446 }
2447
2448 } else { /* it the device doesn't support the 'exact' format, try to find something close */
2449 switch (StencilBufferFormat) {
2450 case 0:
2451 break;
2452
2453 case WINED3DFMT_D16_LOCKABLE:
2454 case WINED3DFMT_D16:
2455 PUSH2(GLX_DEPTH_SIZE, 1);
2456 break;
2457
2458 case WINED3DFMT_D15S1:
2459 PUSH2(GLX_DEPTH_SIZE, 1);
2460 PUSH2(GLX_STENCIL_SIZE, 1);
2461 /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
2462 e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
2463 break;
2464
2465 case WINED3DFMT_D24X8:
2466 PUSH2(GLX_DEPTH_SIZE, 1);
2467 break;
2468
2469 case WINED3DFMT_D24X4S4:
2470 PUSH2(GLX_DEPTH_SIZE, 1);
2471 PUSH2(GLX_STENCIL_SIZE, 1);
2472 break;
2473
2474 case WINED3DFMT_D24S8:
2475 PUSH2(GLX_DEPTH_SIZE, 1);
2476 PUSH2(GLX_STENCIL_SIZE, 1);
2477 break;
2478
2479 case WINED3DFMT_D24FS8:
2480 PUSH2(GLX_DEPTH_SIZE, 1);
2481 PUSH2(GLX_STENCIL_SIZE, 1);
2482 break;
2483
2484 case WINED3DFMT_D32:
2485 PUSH2(GLX_DEPTH_SIZE, 1);
2486 break;
2487
2488 default:
2489 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
2490 break;
2491 }
2492 }
2493
2494 return *nAttribs;
2495 }
2496
2497 #undef GLINFO_LOCATION
2498
2499 /* DirectDraw stuff */
2500 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
2501 switch(depth) {
2502 case 8: return WINED3DFMT_P8; break;
2503 case 15: return WINED3DFMT_X1R5G5B5; break;
2504 case 16: return WINED3DFMT_R5G6B5; break;
2505 case 24: return WINED3DFMT_R8G8B8; break;
2506 case 32: return WINED3DFMT_X8R8G8B8; break;
2507 default: return WINED3DFMT_UNKNOWN;
2508 }
2509 }
2510
2511 void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) {
2512 WINED3DMATRIX temp;
2513
2514 /* Now do the multiplication 'by hand'.
2515 I know that all this could be optimised, but this will be done later :-) */
2516 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);
2517 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);
2518 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);
2519 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);
2520
2521 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);
2522 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);
2523 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);
2524 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);
2525
2526 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);
2527 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);
2528 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);
2529 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);
2530
2531 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);
2532 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);
2533 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);
2534 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);
2535
2536 /* And copy the new matrix in the good storage.. */
2537 memcpy(dest, &temp, 16 * sizeof(float));
2538 }
2539
2540 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
2541 DWORD size = 0;
2542 int i;
2543 int numTextures = (d3dvtVertexType & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
2544
2545 if (d3dvtVertexType & WINED3DFVF_NORMAL) size += 3 * sizeof(float);
2546 if (d3dvtVertexType & WINED3DFVF_DIFFUSE) size += sizeof(DWORD);
2547 if (d3dvtVertexType & WINED3DFVF_SPECULAR) size += sizeof(DWORD);
2548 if (d3dvtVertexType & WINED3DFVF_PSIZE) size += sizeof(DWORD);
2549 switch (d3dvtVertexType & WINED3DFVF_POSITION_MASK) {
2550 case WINED3DFVF_XYZ: size += 3 * sizeof(float); break;
2551 case WINED3DFVF_XYZRHW: size += 4 * sizeof(float); break;
2552 case WINED3DFVF_XYZB1: size += 4 * sizeof(float); break;
2553 case WINED3DFVF_XYZB2: size += 5 * sizeof(float); break;
2554 case WINED3DFVF_XYZB3: size += 6 * sizeof(float); break;
2555 case WINED3DFVF_XYZB4: size += 7 * sizeof(float); break;
2556 case WINED3DFVF_XYZB5: size += 8 * sizeof(float); break;
2557 default: ERR("Unexpected position mask\n");
2558 }
2559 for (i = 0; i < numTextures; i++) {
2560 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
2561 }
2562
2563 return size;
2564 }
2565
2566 /***********************************************************************
2567 * CalculateTexRect
2568 *
2569 * Calculates the dimensions of the opengl texture used for blits.
2570 * Handled oversized opengl textures and updates the source rectangle
2571 * accordingly
2572 *
2573 * Params:
2574 * This: Surface to operate on
2575 * Rect: Requested rectangle
2576 *
2577 * Returns:
2578 * TRUE if the texture part can be loaded,
2579 * FALSE otherwise
2580 *
2581 *********************************************************************/
2582 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
2583
2584 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
2585 int x1 = Rect->left, x2 = Rect->right;
2586 int y1 = Rect->top, y2 = Rect->bottom;
2587 GLint maxSize = GL_LIMITS(texture_size);
2588
2589 TRACE("(%p)->(%d,%d)-(%d,%d)\n", This,
2590 Rect->left, Rect->top, Rect->right, Rect->bottom);
2591
2592 /* The sizes might be reversed */
2593 if(Rect->left > Rect->right) {
2594 x1 = Rect->right;
2595 x2 = Rect->left;
2596 }
2597 if(Rect->top > Rect->bottom) {
2598 y1 = Rect->bottom;
2599 y2 = Rect->top;
2600 }
2601
2602 /* No oversized texture? This is easy */
2603 if(!(This->Flags & SFLAG_OVERSIZE)) {
2604 /* Which rect from the texture do I need? */
2605 glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
2606 glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
2607 glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
2608 glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
2609
2610 return TRUE;
2611 } else {
2612 /* Check if we can succeed at all */
2613 if( (x2 - x1) > maxSize ||
2614 (y2 - y1) > maxSize ) {
2615 TRACE("Requested rectangle is too large for gl\n");
2616 return FALSE;
2617 }
2618
2619 /* A part of the texture has to be picked. First, check if
2620 * some texture part is loaded already, if yes try to re-use it.
2621 * If the texture is dirty, or the part can't be used,
2622 * re-position the part to load
2623 */
2624 if(This->Flags & SFLAG_INTEXTURE) {
2625 if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
2626 This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
2627 /* Ok, the rectangle is ok, re-use it */
2628 TRACE("Using existing gl Texture\n");
2629 } else {
2630 /* Rectangle is not ok, dirtify the texture to reload it */
2631 TRACE("Dirtifying texture to force reload\n");
2632 This->Flags &= ~SFLAG_INTEXTURE;
2633 }
2634 }
2635
2636 /* Now if we are dirty(no else if!) */
2637 if(!(This->Flags & SFLAG_INTEXTURE)) {
2638 /* Set the new rectangle. Use the following strategy:
2639 * 1) Use as big textures as possible.
2640 * 2) Place the texture part in the way that the requested
2641 * part is in the middle of the texture(well, almost)
2642 * 3) If the texture is moved over the edges of the
2643 * surface, replace it nicely
2644 * 4) If the coord is not limiting the texture size,
2645 * use the whole size
2646 */
2647 if((This->pow2Width) > maxSize) {
2648 This->glRect.left = x1 - maxSize / 2;
2649 if(This->glRect.left < 0) {
2650 This->glRect.left = 0;
2651 }
2652 This->glRect.right = This->glRect.left + maxSize;
2653 if(This->glRect.right > This->currentDesc.Width) {
2654 This->glRect.right = This->currentDesc.Width;
2655 This->glRect.left = This->glRect.right - maxSize;
2656 }
2657 } else {
2658 This->glRect.left = 0;
2659 This->glRect.right = This->pow2Width;
2660 }
2661
2662 if(This->pow2Height > maxSize) {
2663 This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
2664 if(This->glRect.top < 0) This->glRect.top = 0;
2665 This->glRect.bottom = This->glRect.left + maxSize;
2666 if(This->glRect.bottom > This->currentDesc.Height) {
2667 This->glRect.bottom = This->currentDesc.Height;
2668 This->glRect.top = This->glRect.bottom - maxSize;
2669 }
2670 } else {
2671 This->glRect.top = 0;
2672 This->glRect.bottom = This->pow2Height;
2673 }
2674 TRACE("(%p): Using rect (%d,%d)-(%d,%d)\n", This,
2675 This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
2676 }
2677
2678 /* Re-calculate the rect to draw */
2679 Rect->left -= This->glRect.left;
2680 Rect->right -= This->glRect.left;
2681 Rect->top -= This->glRect.top;
2682 Rect->bottom -= This->glRect.top;
2683
2684 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
2685 * or the pow2Width / pow2Height of the surface
2686 */
2687 glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
2688 glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
2689 glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
2690 glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
2691 }
2692 return TRUE;
2693 }
2694 #undef GLINFO_LOCATION
2695
2696 /* Hash table functions */
2697
2698 hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function)
2699 {
2700 hash_table_t *table;
2701 unsigned int initial_size = 8;
2702
2703 table = HeapAlloc(GetProcessHeap(), 0, sizeof(hash_table_t) + (initial_size * sizeof(struct list)));
2704 if (!table)
2705 {
2706 ERR("Failed to allocate table, returning NULL.\n");
2707 return NULL;
2708 }
2709
2710 table->hash_function = hash_function;
2711 table->compare_function = compare_function;
2712
2713 table->grow_size = initial_size - (initial_size >> 2);
2714 table->shrink_size = 0;
2715
2716 table->buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, initial_size * sizeof(struct list));
2717 if (!table->buckets)
2718 {
2719 ERR("Failed to allocate table buckets, returning NULL.\n");
2720 HeapFree(GetProcessHeap(), 0, table);
2721 return NULL;
2722 }
2723 table->bucket_count = initial_size;
2724
2725 table->entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, table->grow_size * sizeof(hash_table_entry_t));
2726 if (!table->entries)
2727 {
2728 ERR("Failed to allocate table entries, returning NULL.\n");
2729 HeapFree(GetProcessHeap(), 0, table->buckets);
2730 HeapFree(GetProcessHeap(), 0, table);
2731 return NULL;
2732 }
2733 table->entry_count = 0;
2734
2735 list_init(&table->free_entries);
2736 table->count = 0;
2737
2738 return table;
2739 }
2740
2741 void hash_table_destroy(hash_table_t *table)
2742 {
2743 unsigned int i = 0;
2744
2745 for (i = 0; i < table->entry_count; ++i)
2746 {
2747 HeapFree(GetProcessHeap(), 0, table->entries[i].key);
2748 }
2749
2750 HeapFree(GetProcessHeap(), 0, table->entries);
2751 HeapFree(GetProcessHeap(), 0, table->buckets);
2752 HeapFree(GetProcessHeap(), 0, table);
2753 }
2754
2755 static inline hash_table_entry_t *hash_table_get_by_idx(hash_table_t *table, void *key, unsigned int idx)
2756 {
2757 hash_table_entry_t *entry;
2758
2759 if (table->buckets[idx].next)
2760 LIST_FOR_EACH_ENTRY(entry, &(table->buckets[idx]), hash_table_entry_t, entry)
2761 if (table->compare_function(entry->key, key)) return entry;
2762
2763 return NULL;
2764 }
2765
2766 static BOOL hash_table_resize(hash_table_t *table, unsigned int new_bucket_count)
2767 {
2768 unsigned int new_entry_count = 0;
2769 hash_table_entry_t *new_entries;
2770 struct list *new_buckets;
2771 unsigned int grow_size = new_bucket_count - (new_bucket_count >> 2);
2772 unsigned int i;
2773
2774 new_buckets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, new_bucket_count * sizeof(struct list));
2775 if (!new_buckets)
2776 {
2777 ERR("Failed to allocate new buckets, returning FALSE.\n");
2778 return FALSE;
2779 }
2780
2781 new_entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, grow_size * sizeof(hash_table_entry_t));
2782 if (!new_entries)
2783 {
2784 ERR("Failed to allocate new entries, returning FALSE.\n");
2785 HeapFree(GetProcessHeap(), 0, new_buckets);
2786 return FALSE;
2787 }
2788
2789 for (i = 0; i < table->bucket_count; ++i)
2790 {
2791 if (table->buckets[i].next)
2792 {
2793 hash_table_entry_t *entry, *entry2;
2794
2795 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &table->buckets[i], hash_table_entry_t, entry)
2796 {
2797 int j;
2798 hash_table_entry_t *new_entry = new_entries + (new_entry_count++);
2799 *new_entry = *entry;
2800
2801 j = new_entry->hash & (new_bucket_count - 1);
2802
2803 if (!new_buckets[j].next) list_init(&new_buckets[j]);
2804 list_add_head(&new_buckets[j], &new_entry->entry);
2805 }
2806 }
2807 }
2808
2809 HeapFree(GetProcessHeap(), 0, table->buckets);
2810 table->buckets = new_buckets;
2811
2812 HeapFree(GetProcessHeap(), 0, table->entries);
2813 table->entries = new_entries;
2814
2815 table->entry_count = new_entry_count;
2816 list_init(&table->free_entries);
2817
2818 table->bucket_count = new_bucket_count;
2819 table->grow_size = grow_size;
2820 table->shrink_size = new_bucket_count > 8 ? new_bucket_count >> 2 : 0;
2821
2822 return TRUE;
2823 }
2824
2825 void hash_table_put(hash_table_t *table, void *key, void *value)
2826 {
2827 unsigned int idx;
2828 unsigned int hash;
2829 hash_table_entry_t *entry;
2830
2831 hash = table->hash_function(key);
2832 idx = hash & (table->bucket_count - 1);
2833 entry = hash_table_get_by_idx(table, key, idx);
2834
2835 if (entry)
2836 {
2837 HeapFree(GetProcessHeap(), 0, key);
2838 entry->value = value;
2839
2840 if (!value)
2841 {
2842 HeapFree(GetProcessHeap(), 0, entry->key);
2843 entry->key = NULL;
2844
2845 /* Remove the entry */
2846 list_remove(&entry->entry);
2847 list_add_head(&table->free_entries, &entry->entry);
2848
2849 --table->count;
2850
2851 /* Shrink if necessary */
2852 if (table->count < table->shrink_size) {
2853 if (!hash_table_resize(table, table->bucket_count >> 1))
2854 {
2855 ERR("Failed to shrink the table...\n");
2856 }
2857 }
2858 }
2859
2860 return;
2861 }
2862
2863 if (!value) return;
2864
2865 /* Grow if necessary */
2866 if (table->count >= table->grow_size)
2867 {
2868 if (!hash_table_resize(table, table->bucket_count << 1))
2869 {
2870 ERR("Failed to grow the table, returning.\n");
2871 return;
2872 }
2873
2874 idx = hash & (table->bucket_count - 1);
2875 }
2876
2877 /* Find an entry to insert */
2878 if (!list_empty(&table->free_entries))
2879 {
2880 struct list *elem = list_head(&table->free_entries);
2881
2882 list_remove(elem);
2883 entry = LIST_ENTRY(elem, hash_table_entry_t, entry);
2884 } else {
2885 entry = table->entries + (table->entry_count++);
2886 }
2887
2888 /* Insert the entry */
2889 entry->key = key;
2890 entry->value = value;
2891 entry->hash = hash;
2892 if (!table->buckets[idx].next) list_init(&table->buckets[idx]);
2893 list_add_head(&table->buckets[idx], &entry->entry);
2894
2895 ++table->count;
2896 }
2897
2898 void hash_table_remove(hash_table_t *table, void *key)
2899 {
2900 hash_table_put(table, key, NULL);
2901 }
2902
2903 void *hash_table_get(hash_table_t *table, void *key)
2904 {
2905 unsigned int idx;
2906 hash_table_entry_t *entry;
2907
2908 idx = table->hash_function(key) & (table->bucket_count - 1);
2909 entry = hash_table_get_by_idx(table, key, idx);
2910
2911 return entry ? entry->value : NULL;
2912 }
Maarten's multimedia branch