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