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