?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Assorted spelling, case and grammar fixes.
[wine/multimedia.git] / dlls / wined3d / utils.c
blobbcf8913c7ea87b2c3219ccdc39f892a047bcef46
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 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25 #include "wined3d_private.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
28
29 /*****************************************************************************
30 * Pixel format array
31 */
32 static const PixelFormatDesc formats[] = {
33 /*{WINED3DFORMAT ,alphamask ,redmask ,greenmask ,bluemask ,bpp ,isFourcc ,internal ,format ,type }*/
34 {WINED3DFMT_UNKNOWN ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,0 ,0 ,0 },
35 /* FourCC formats, kept here to have WINED3DFMT_R8G8B8(=20) at position 20 */
36 {WINED3DFMT_UYVY ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 },
37 {WINED3DFMT_YUY2 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 },
38 {WINED3DFMT_DXT1 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,0 },
39 {WINED3DFMT_DXT2 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,0 },
40 {WINED3DFMT_DXT3 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,0 },
41 {WINED3DFMT_DXT4 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,0 },
42 {WINED3DFMT_DXT5 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,TRUE ,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,0 },
43 {WINED3DFMT_MULTI2_ARGB ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 },
44 {WINED3DFMT_G8R8_G8B8 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 },
45 {WINED3DFMT_R8G8_B8G8 ,0x0 ,0x0 ,0x0 ,0x0 ,1/*?*/ ,TRUE ,0 ,0 ,0 },
46 /* IEEE formats */
47 {WINED3DFMT_R32F ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 },
48 {WINED3DFMT_G32R32F ,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE ,0 ,0 ,0 },
49 {WINED3DFMT_A32B32G32R32F,0x0 ,0x0 ,0x0 ,0x0 ,16 ,FALSE ,0 ,0 ,0 },
50 /* Hmm? */
51 {WINED3DFMT_CxV8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,0 ,0 ,0 },
52 /* Float */
53 {WINED3DFMT_R16F ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,0 ,0 ,0 },
54 {WINED3DFMT_G16R16F ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 },
55 {WINED3DFMT_A16B16G16R16F,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE ,0 ,0 ,0 },
56 /* Palettized formats */
57 {WINED3DFMT_A8P8 ,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,0 ,0 ,0 },
58 {WINED3DFMT_P8 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,GL_COLOR_INDEX8_EXT ,GL_COLOR_INDEX ,GL_UNSIGNED_BYTE },
59 /* Standard ARGB formats. Keep WINED3DFMT_R8G8B8(=20) at position 20 */
60 {WINED3DFMT_R8G8B8 ,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,3 ,FALSE ,GL_RGB8 ,GL_RGB ,GL_UNSIGNED_BYTE },
61 {WINED3DFMT_A8R8G8B8 ,0xff000000 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,FALSE ,GL_RGBA8 ,GL_BGRA ,GL_UNSIGNED_INT_8_8_8_8_REV },
62 {WINED3DFMT_X8R8G8B8 ,0x0 ,0x00ff0000 ,0x0000ff00 ,0x000000ff ,4 ,FALSE ,GL_RGB8 ,GL_BGRA ,GL_UNSIGNED_INT_8_8_8_8_REV },
63 {WINED3DFMT_R5G6B5 ,0x0 ,0x0000F800 ,0x000007e0 ,0x0000001f ,2 ,FALSE ,GL_RGB5 ,GL_RGB ,GL_UNSIGNED_SHORT_5_6_5 },
64 {WINED3DFMT_X1R5G5B5 ,0x0 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,FALSE ,GL_RGB5_A1 ,GL_BGRA ,GL_UNSIGNED_SHORT_1_5_5_5_REV },
65 {WINED3DFMT_A1R5G5B5 ,0x00008000 ,0x00007c00 ,0x000003e0 ,0x0000001f ,2 ,FALSE ,GL_RGB5_A1 ,GL_BGRA ,GL_UNSIGNED_SHORT_1_5_5_5_REV },
66 {WINED3DFMT_A4R4G4B4 ,0x0000f000 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,FALSE ,GL_RGBA4 ,GL_BGRA ,GL_UNSIGNED_SHORT_4_4_4_4_REV },
67 {WINED3DFMT_R3G3B2 ,0x0 ,0x000000e0 ,0x0000001c ,0x00000003 ,1 ,FALSE ,GL_R3_G3_B2 ,GL_RGB ,GL_UNSIGNED_BYTE_2_3_3_REV },
68 {WINED3DFMT_A8 ,0x000000ff ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,GL_ALPHA8 ,GL_ALPHA ,GL_ALPHA },
69 {WINED3DFMT_A8R3G3B2 ,0x0000ff00 ,0x000000e0 ,0x0000001c ,0x00000003 ,2 ,FALSE ,0 ,0 ,0 },
70 {WINED3DFMT_X4R4G4B4 ,0x0 ,0x00000f00 ,0x000000f0 ,0x0000000f ,2 ,FALSE ,GL_RGB4 ,GL_BGRA ,GL_UNSIGNED_SHORT_4_4_4_4_REV },
71 {WINED3DFMT_A2B10G10R10 ,0xb0000000 ,0x000003ff ,0x000ffc00 ,0x3ff00000 ,4 ,FALSE ,0 ,0 ,0 },
72 {WINED3DFMT_A8B8G8R8 ,0xff000000 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,FALSE ,GL_RGBA8 ,GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV },
73 {WINED3DFMT_X8B8G8R8 ,0x0 ,0x000000ff ,0x0000ff00 ,0x00ff0000 ,4 ,FALSE ,GL_RGB8 ,GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV },
74 {WINED3DFMT_G16R16 ,0x0 ,0x0000ffff ,0xffff0000 ,0x0 ,4 ,FALSE ,0 ,0 ,0 },
75 {WINED3DFMT_A2R10G10B10 ,0xb0000000 ,0x3ff00000 ,0x000ffc00 ,0x000003ff ,4 ,FALSE ,0 ,0 ,0 },
76 {WINED3DFMT_A16B16G16R16,0x0 ,0x0000ffff ,0xffff0000 ,0x0 ,8 ,FALSE ,GL_RGBA16_EXT ,GL_RGBA ,GL_UNSIGNED_SHORT },
77 /* Luminance */
78 {WINED3DFMT_L8 ,0x0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,GL_LUMINANCE8 ,GL_LUMINANCE ,GL_UNSIGNED_BYTE },
79 {WINED3DFMT_A8L8 ,0x0000ff00 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_LUMINANCE8_ALPHA8 ,GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE },
80 {WINED3DFMT_A4L4 ,0x000000f0 ,0x0 ,0x0 ,0x0 ,1 ,FALSE ,GL_LUMINANCE4_ALPHA4 ,GL_LUMINANCE_ALPHA ,GL_UNSIGNED_BYTE },
81 /* Bump mapping stuff */
82 {WINED3DFMT_V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_COLOR_INDEX8_EXT ,GL_COLOR_INDEX ,GL_UNSIGNED_BYTE },
83 {WINED3DFMT_L6V5U5 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_COLOR_INDEX8_EXT ,GL_COLOR_INDEX ,GL_UNSIGNED_SHORT_5_5_5_1 },
84 {WINED3DFMT_X8L8V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_RGBA8 ,GL_BGRA ,GL_UNSIGNED_BYTE },
85 {WINED3DFMT_Q8W8V8U8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_RGBA8 ,GL_RGBA ,GL_UNSIGNED_INT_8_8_8_8_REV/*?*/},
86 {WINED3DFMT_V16U16 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_SHORT },
87 {WINED3DFMT_W11V11U10 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 },
88 {WINED3DFMT_A2W10V10U10 ,0xb0000000 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 },
89 /* Depth stencil formats */
90 {WINED3DFMT_D16_LOCKABLE,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_SHORT },
91 {WINED3DFMT_D32 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_INT },
92 {WINED3DFMT_D15S1 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_SHORT },
93 {WINED3DFMT_D24S8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_INT },
94 {WINED3DFMT_D24X8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_INT },
95 {WINED3DFMT_D24X4S4 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_INT },
96 {WINED3DFMT_D16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_SHORT },
97 {WINED3DFMT_L16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,GL_LUMINANCE16_EXT ,GL_LUMINANCE ,GL_UNSIGNED_SHORT },
98 {WINED3DFMT_D32F_LOCKABLE,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 },
99 {WINED3DFMT_D24FS8 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 },
100 /* Is this a vertex buffer? */
101 {WINED3DFMT_VERTEXDATA ,0x0 ,0x0 ,0x0 ,0x0 ,0 ,FALSE ,0 ,0 ,0 },
102 {WINED3DFMT_INDEX16 ,0x0 ,0x0 ,0x0 ,0x0 ,2 ,FALSE ,0 ,0 ,0 },
103 {WINED3DFMT_INDEX32 ,0x0 ,0x0 ,0x0 ,0x0 ,4 ,FALSE ,0 ,0 ,0 },
104 {WINED3DFMT_Q16W16V16U16,0x0 ,0x0 ,0x0 ,0x0 ,8 ,FALSE ,GL_COLOR_INDEX ,GL_COLOR_INDEX ,GL_UNSIGNED_SHORT }
105 };
106
107 const PixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt)
108 {
109 /* First check if the format is at the position of its value.
110 * This will catch the argb formats before the loop is entered
111 */
112 if(fmt < (sizeof(formats) / sizeof(formats[0])) && formats[fmt].format == fmt) {
113 return &formats[fmt];
114 } else {
115 unsigned int i;
116 for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
117 if(formats[i].format == fmt) {
118 return &formats[i];
119 }
120 }
121 }
122 FIXME("Can't find format %s(%d) in the format lookup table\n", debug_d3dformat(fmt), fmt);
123 if(fmt == WINED3DFMT_UNKNOWN) {
124 ERR("Format table corrupt - Can't find WINED3DFMT_UNKNOWN\n");
125 return NULL;
126 }
127 /* Get the caller a valid pointer */
128 return getFormatDescEntry(WINED3DFMT_UNKNOWN);
129 }
130
131 /*****************************************************************************
132 * Trace formatting of useful values
133 */
134 const char* debug_d3dformat(WINED3DFORMAT fmt) {
135 switch (fmt) {
136 #define FMT_TO_STR(fmt) case fmt: return #fmt
137 FMT_TO_STR(WINED3DFMT_UNKNOWN);
138 FMT_TO_STR(WINED3DFMT_R8G8B8);
139 FMT_TO_STR(WINED3DFMT_A8R8G8B8);
140 FMT_TO_STR(WINED3DFMT_X8R8G8B8);
141 FMT_TO_STR(WINED3DFMT_R5G6B5);
142 FMT_TO_STR(WINED3DFMT_X1R5G5B5);
143 FMT_TO_STR(WINED3DFMT_A1R5G5B5);
144 FMT_TO_STR(WINED3DFMT_A4R4G4B4);
145 FMT_TO_STR(WINED3DFMT_R3G3B2);
146 FMT_TO_STR(WINED3DFMT_A8);
147 FMT_TO_STR(WINED3DFMT_A8R3G3B2);
148 FMT_TO_STR(WINED3DFMT_X4R4G4B4);
149 FMT_TO_STR(WINED3DFMT_A2B10G10R10);
150 FMT_TO_STR(WINED3DFMT_A8B8G8R8);
151 FMT_TO_STR(WINED3DFMT_X8B8G8R8);
152 FMT_TO_STR(WINED3DFMT_G16R16);
153 FMT_TO_STR(WINED3DFMT_A2R10G10B10);
154 FMT_TO_STR(WINED3DFMT_A16B16G16R16);
155 FMT_TO_STR(WINED3DFMT_A8P8);
156 FMT_TO_STR(WINED3DFMT_P8);
157 FMT_TO_STR(WINED3DFMT_L8);
158 FMT_TO_STR(WINED3DFMT_A8L8);
159 FMT_TO_STR(WINED3DFMT_A4L4);
160 FMT_TO_STR(WINED3DFMT_V8U8);
161 FMT_TO_STR(WINED3DFMT_L6V5U5);
162 FMT_TO_STR(WINED3DFMT_X8L8V8U8);
163 FMT_TO_STR(WINED3DFMT_Q8W8V8U8);
164 FMT_TO_STR(WINED3DFMT_V16U16);
165 FMT_TO_STR(WINED3DFMT_W11V11U10);
166 FMT_TO_STR(WINED3DFMT_A2W10V10U10);
167 FMT_TO_STR(WINED3DFMT_UYVY);
168 FMT_TO_STR(WINED3DFMT_YUY2);
169 FMT_TO_STR(WINED3DFMT_DXT1);
170 FMT_TO_STR(WINED3DFMT_DXT2);
171 FMT_TO_STR(WINED3DFMT_DXT3);
172 FMT_TO_STR(WINED3DFMT_DXT4);
173 FMT_TO_STR(WINED3DFMT_DXT5);
174 FMT_TO_STR(WINED3DFMT_MULTI2_ARGB);
175 FMT_TO_STR(WINED3DFMT_G8R8_G8B8);
176 FMT_TO_STR(WINED3DFMT_R8G8_B8G8);
177 FMT_TO_STR(WINED3DFMT_D16_LOCKABLE);
178 FMT_TO_STR(WINED3DFMT_D32);
179 FMT_TO_STR(WINED3DFMT_D15S1);
180 FMT_TO_STR(WINED3DFMT_D24S8);
181 FMT_TO_STR(WINED3DFMT_D24X8);
182 FMT_TO_STR(WINED3DFMT_D24X4S4);
183 FMT_TO_STR(WINED3DFMT_D16);
184 FMT_TO_STR(WINED3DFMT_L16);
185 FMT_TO_STR(WINED3DFMT_D32F_LOCKABLE);
186 FMT_TO_STR(WINED3DFMT_D24FS8);
187 FMT_TO_STR(WINED3DFMT_VERTEXDATA);
188 FMT_TO_STR(WINED3DFMT_INDEX16);
189 FMT_TO_STR(WINED3DFMT_INDEX32);
190 FMT_TO_STR(WINED3DFMT_Q16W16V16U16);
191 FMT_TO_STR(WINED3DFMT_R16F);
192 FMT_TO_STR(WINED3DFMT_G16R16F);
193 FMT_TO_STR(WINED3DFMT_A16B16G16R16F);
194 FMT_TO_STR(WINED3DFMT_R32F);
195 FMT_TO_STR(WINED3DFMT_G32R32F);
196 FMT_TO_STR(WINED3DFMT_A32B32G32R32F);
197 FMT_TO_STR(WINED3DFMT_CxV8U8);
198 #undef FMT_TO_STR
199 default:
200 {
201 char fourcc[5];
202 fourcc[0] = (char)(fmt);
203 fourcc[1] = (char)(fmt >> 8);
204 fourcc[2] = (char)(fmt >> 16);
205 fourcc[3] = (char)(fmt >> 24);
206 fourcc[4] = 0;
207 if( isprint(fourcc[0]) && isprint(fourcc[1]) && isprint(fourcc[2]) && isprint(fourcc[3]) )
208 FIXME("Unrecognized %u (as fourcc: %s) D3DFORMAT!\n", fmt, fourcc);
209 else
210 FIXME("Unrecognized %u D3DFORMAT!\n", fmt);
211 }
212 return "unrecognized";
213 }
214 }
215
216 const char* debug_d3ddevicetype(D3DDEVTYPE devtype) {
217 switch (devtype) {
218 #define DEVTYPE_TO_STR(dev) case dev: return #dev
219 DEVTYPE_TO_STR(D3DDEVTYPE_HAL);
220 DEVTYPE_TO_STR(D3DDEVTYPE_REF);
221 DEVTYPE_TO_STR(D3DDEVTYPE_SW);
222 #undef DEVTYPE_TO_STR
223 default:
224 FIXME("Unrecognized %u D3DDEVTYPE!\n", devtype);
225 return "unrecognized";
226 }
227 }
228
229 const char* debug_d3dusage(DWORD usage) {
230 switch (usage) {
231 #define WINED3DUSAGE_TO_STR(u) case u: return #u
232 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RENDERTARGET);
233 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DEPTHSTENCIL);
234 WINED3DUSAGE_TO_STR(WINED3DUSAGE_WRITEONLY);
235 WINED3DUSAGE_TO_STR(WINED3DUSAGE_SOFTWAREPROCESSING);
236 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DONOTCLIP);
237 WINED3DUSAGE_TO_STR(WINED3DUSAGE_POINTS);
238 WINED3DUSAGE_TO_STR(WINED3DUSAGE_RTPATCHES);
239 WINED3DUSAGE_TO_STR(WINED3DUSAGE_NPATCHES);
240 WINED3DUSAGE_TO_STR(WINED3DUSAGE_DYNAMIC);
241 #undef WINED3DUSAGE_TO_STR
242 case 0: return "none";
243 default:
244 FIXME("Unrecognized %lu Usage!\n", usage);
245 return "unrecognized";
246 }
247 }
248
249 const char* debug_d3dresourcetype(WINED3DRESOURCETYPE res) {
250 switch (res) {
251 #define RES_TO_STR(res) case res: return #res;
252 RES_TO_STR(WINED3DRTYPE_SURFACE);
253 RES_TO_STR(WINED3DRTYPE_VOLUME);
254 RES_TO_STR(WINED3DRTYPE_TEXTURE);
255 RES_TO_STR(WINED3DRTYPE_VOLUMETEXTURE);
256 RES_TO_STR(WINED3DRTYPE_CUBETEXTURE);
257 RES_TO_STR(WINED3DRTYPE_VERTEXBUFFER);
258 RES_TO_STR(WINED3DRTYPE_INDEXBUFFER);
259 #undef RES_TO_STR
260 default:
261 FIXME("Unrecognized %u WINED3DRESOURCETYPE!\n", res);
262 return "unrecognized";
263 }
264 }
265
266 const char* debug_d3dprimitivetype(D3DPRIMITIVETYPE PrimitiveType) {
267 switch (PrimitiveType) {
268 #define PRIM_TO_STR(prim) case prim: return #prim;
269 PRIM_TO_STR(D3DPT_POINTLIST);
270 PRIM_TO_STR(D3DPT_LINELIST);
271 PRIM_TO_STR(D3DPT_LINESTRIP);
272 PRIM_TO_STR(D3DPT_TRIANGLELIST);
273 PRIM_TO_STR(D3DPT_TRIANGLESTRIP);
274 PRIM_TO_STR(D3DPT_TRIANGLEFAN);
275 #undef PRIM_TO_STR
276 default:
277 FIXME("Unrecognized %u D3DPRIMITIVETYPE!\n", PrimitiveType);
278 return "unrecognized";
279 }
280 }
281
282 const char* debug_d3drenderstate(DWORD state) {
283 switch (state) {
284 #define D3DSTATE_TO_STR(u) case u: return #u
285 D3DSTATE_TO_STR(WINED3DRS_TEXTUREHANDLE );
286 D3DSTATE_TO_STR(WINED3DRS_ANTIALIAS );
287 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESS );
288 D3DSTATE_TO_STR(WINED3DRS_TEXTUREPERSPECTIVE );
289 D3DSTATE_TO_STR(WINED3DRS_WRAPU );
290 D3DSTATE_TO_STR(WINED3DRS_WRAPV );
291 D3DSTATE_TO_STR(WINED3DRS_ZENABLE );
292 D3DSTATE_TO_STR(WINED3DRS_FILLMODE );
293 D3DSTATE_TO_STR(WINED3DRS_SHADEMODE );
294 D3DSTATE_TO_STR(WINED3DRS_LINEPATTERN );
295 D3DSTATE_TO_STR(WINED3DRS_MONOENABLE );
296 D3DSTATE_TO_STR(WINED3DRS_ROP2 );
297 D3DSTATE_TO_STR(WINED3DRS_PLANEMASK );
298 D3DSTATE_TO_STR(WINED3DRS_ZWRITEENABLE );
299 D3DSTATE_TO_STR(WINED3DRS_ALPHATESTENABLE );
300 D3DSTATE_TO_STR(WINED3DRS_LASTPIXEL );
301 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAG );
302 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMIN );
303 D3DSTATE_TO_STR(WINED3DRS_SRCBLEND );
304 D3DSTATE_TO_STR(WINED3DRS_DESTBLEND );
305 D3DSTATE_TO_STR(WINED3DRS_TEXTUREMAPBLEND );
306 D3DSTATE_TO_STR(WINED3DRS_CULLMODE );
307 D3DSTATE_TO_STR(WINED3DRS_ZFUNC );
308 D3DSTATE_TO_STR(WINED3DRS_ALPHAREF );
309 D3DSTATE_TO_STR(WINED3DRS_ALPHAFUNC );
310 D3DSTATE_TO_STR(WINED3DRS_DITHERENABLE );
311 D3DSTATE_TO_STR(WINED3DRS_ALPHABLENDENABLE );
312 D3DSTATE_TO_STR(WINED3DRS_FOGENABLE );
313 D3DSTATE_TO_STR(WINED3DRS_SPECULARENABLE );
314 D3DSTATE_TO_STR(WINED3DRS_ZVISIBLE );
315 D3DSTATE_TO_STR(WINED3DRS_SUBPIXEL );
316 D3DSTATE_TO_STR(WINED3DRS_SUBPIXELX );
317 D3DSTATE_TO_STR(WINED3DRS_STIPPLEDALPHA );
318 D3DSTATE_TO_STR(WINED3DRS_FOGCOLOR );
319 D3DSTATE_TO_STR(WINED3DRS_FOGTABLEMODE );
320 D3DSTATE_TO_STR(WINED3DRS_FOGSTART );
321 D3DSTATE_TO_STR(WINED3DRS_FOGEND );
322 D3DSTATE_TO_STR(WINED3DRS_FOGDENSITY );
323 D3DSTATE_TO_STR(WINED3DRS_STIPPLEENABLE );
324 D3DSTATE_TO_STR(WINED3DRS_EDGEANTIALIAS );
325 D3DSTATE_TO_STR(WINED3DRS_COLORKEYENABLE );
326 D3DSTATE_TO_STR(WINED3DRS_BORDERCOLOR );
327 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSU );
328 D3DSTATE_TO_STR(WINED3DRS_TEXTUREADDRESSV );
329 D3DSTATE_TO_STR(WINED3DRS_MIPMAPLODBIAS );
330 D3DSTATE_TO_STR(WINED3DRS_ZBIAS );
331 D3DSTATE_TO_STR(WINED3DRS_RANGEFOGENABLE );
332 D3DSTATE_TO_STR(WINED3DRS_ANISOTROPY );
333 D3DSTATE_TO_STR(WINED3DRS_FLUSHBATCH );
334 D3DSTATE_TO_STR(WINED3DRS_TRANSLUCENTSORTINDEPENDENT);
335 D3DSTATE_TO_STR(WINED3DRS_STENCILENABLE );
336 D3DSTATE_TO_STR(WINED3DRS_STENCILFAIL );
337 D3DSTATE_TO_STR(WINED3DRS_STENCILZFAIL );
338 D3DSTATE_TO_STR(WINED3DRS_STENCILPASS );
339 D3DSTATE_TO_STR(WINED3DRS_STENCILFUNC );
340 D3DSTATE_TO_STR(WINED3DRS_STENCILREF );
341 D3DSTATE_TO_STR(WINED3DRS_STENCILMASK );
342 D3DSTATE_TO_STR(WINED3DRS_STENCILWRITEMASK );
343 D3DSTATE_TO_STR(WINED3DRS_TEXTUREFACTOR );
344 D3DSTATE_TO_STR(WINED3DRS_WRAP0 );
345 D3DSTATE_TO_STR(WINED3DRS_WRAP1 );
346 D3DSTATE_TO_STR(WINED3DRS_WRAP2 );
347 D3DSTATE_TO_STR(WINED3DRS_WRAP3 );
348 D3DSTATE_TO_STR(WINED3DRS_WRAP4 );
349 D3DSTATE_TO_STR(WINED3DRS_WRAP5 );
350 D3DSTATE_TO_STR(WINED3DRS_WRAP6 );
351 D3DSTATE_TO_STR(WINED3DRS_WRAP7 );
352 D3DSTATE_TO_STR(WINED3DRS_CLIPPING );
353 D3DSTATE_TO_STR(WINED3DRS_LIGHTING );
354 D3DSTATE_TO_STR(WINED3DRS_EXTENTS );
355 D3DSTATE_TO_STR(WINED3DRS_AMBIENT );
356 D3DSTATE_TO_STR(WINED3DRS_FOGVERTEXMODE );
357 D3DSTATE_TO_STR(WINED3DRS_COLORVERTEX );
358 D3DSTATE_TO_STR(WINED3DRS_LOCALVIEWER );
359 D3DSTATE_TO_STR(WINED3DRS_NORMALIZENORMALS );
360 D3DSTATE_TO_STR(WINED3DRS_COLORKEYBLENDENABLE );
361 D3DSTATE_TO_STR(WINED3DRS_DIFFUSEMATERIALSOURCE );
362 D3DSTATE_TO_STR(WINED3DRS_SPECULARMATERIALSOURCE );
363 D3DSTATE_TO_STR(WINED3DRS_AMBIENTMATERIALSOURCE );
364 D3DSTATE_TO_STR(WINED3DRS_EMISSIVEMATERIALSOURCE );
365 D3DSTATE_TO_STR(WINED3DRS_VERTEXBLEND );
366 D3DSTATE_TO_STR(WINED3DRS_CLIPPLANEENABLE );
367 D3DSTATE_TO_STR(WINED3DRS_SOFTWAREVERTEXPROCESSING );
368 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE );
369 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MIN );
370 D3DSTATE_TO_STR(WINED3DRS_POINTSPRITEENABLE );
371 D3DSTATE_TO_STR(WINED3DRS_POINTSCALEENABLE );
372 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_A );
373 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_B );
374 D3DSTATE_TO_STR(WINED3DRS_POINTSCALE_C );
375 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEANTIALIAS );
376 D3DSTATE_TO_STR(WINED3DRS_MULTISAMPLEMASK );
377 D3DSTATE_TO_STR(WINED3DRS_PATCHEDGESTYLE );
378 D3DSTATE_TO_STR(WINED3DRS_PATCHSEGMENTS );
379 D3DSTATE_TO_STR(WINED3DRS_DEBUGMONITORTOKEN );
380 D3DSTATE_TO_STR(WINED3DRS_POINTSIZE_MAX );
381 D3DSTATE_TO_STR(WINED3DRS_INDEXEDVERTEXBLENDENABLE );
382 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE );
383 D3DSTATE_TO_STR(WINED3DRS_TWEENFACTOR );
384 D3DSTATE_TO_STR(WINED3DRS_BLENDOP );
385 D3DSTATE_TO_STR(WINED3DRS_POSITIONDEGREE );
386 D3DSTATE_TO_STR(WINED3DRS_NORMALDEGREE );
387 D3DSTATE_TO_STR(WINED3DRS_SCISSORTESTENABLE );
388 D3DSTATE_TO_STR(WINED3DRS_SLOPESCALEDEPTHBIAS );
389 D3DSTATE_TO_STR(WINED3DRS_ANTIALIASEDLINEENABLE );
390 D3DSTATE_TO_STR(WINED3DRS_MINTESSELLATIONLEVEL );
391 D3DSTATE_TO_STR(WINED3DRS_MAXTESSELLATIONLEVEL );
392 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_X );
393 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Y );
394 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_Z );
395 D3DSTATE_TO_STR(WINED3DRS_ADAPTIVETESS_W );
396 D3DSTATE_TO_STR(WINED3DRS_ENABLEADAPTIVETESSELLATION);
397 D3DSTATE_TO_STR(WINED3DRS_TWOSIDEDSTENCILMODE );
398 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFAIL );
399 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILZFAIL );
400 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILPASS );
401 D3DSTATE_TO_STR(WINED3DRS_CCW_STENCILFUNC );
402 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE1 );
403 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE2 );
404 D3DSTATE_TO_STR(WINED3DRS_COLORWRITEENABLE3 );
405 D3DSTATE_TO_STR(WINED3DRS_BLENDFACTOR );
406 D3DSTATE_TO_STR(WINED3DRS_SRGBWRITEENABLE );
407 D3DSTATE_TO_STR(WINED3DRS_DEPTHBIAS );
408 D3DSTATE_TO_STR(WINED3DRS_WRAP8 );
409 D3DSTATE_TO_STR(WINED3DRS_WRAP9 );
410 D3DSTATE_TO_STR(WINED3DRS_WRAP10 );
411 D3DSTATE_TO_STR(WINED3DRS_WRAP11 );
412 D3DSTATE_TO_STR(WINED3DRS_WRAP12 );
413 D3DSTATE_TO_STR(WINED3DRS_WRAP13 );
414 D3DSTATE_TO_STR(WINED3DRS_WRAP14 );
415 D3DSTATE_TO_STR(WINED3DRS_WRAP15 );
416 D3DSTATE_TO_STR(WINED3DRS_SEPARATEALPHABLENDENABLE );
417 D3DSTATE_TO_STR(WINED3DRS_SRCBLENDALPHA );
418 D3DSTATE_TO_STR(WINED3DRS_DESTBLENDALPHA );
419 D3DSTATE_TO_STR(WINED3DRS_BLENDOPALPHA );
420 #undef D3DSTATE_TO_STR
421 default:
422 FIXME("Unrecognized %lu render state!\n", state);
423 return "unrecognized";
424 }
425 }
426
427 const char* debug_d3dsamplerstate(DWORD state) {
428 switch (state) {
429 #define D3DSTATE_TO_STR(u) case u: return #u
430 D3DSTATE_TO_STR(WINED3DSAMP_BORDERCOLOR );
431 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSU );
432 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSV );
433 D3DSTATE_TO_STR(WINED3DSAMP_ADDRESSW );
434 D3DSTATE_TO_STR(WINED3DSAMP_MAGFILTER );
435 D3DSTATE_TO_STR(WINED3DSAMP_MINFILTER );
436 D3DSTATE_TO_STR(WINED3DSAMP_MIPFILTER );
437 D3DSTATE_TO_STR(WINED3DSAMP_MIPMAPLODBIAS);
438 D3DSTATE_TO_STR(WINED3DSAMP_MAXMIPLEVEL );
439 D3DSTATE_TO_STR(WINED3DSAMP_MAXANISOTROPY);
440 D3DSTATE_TO_STR(WINED3DSAMP_SRGBTEXTURE );
441 D3DSTATE_TO_STR(WINED3DSAMP_ELEMENTINDEX );
442 D3DSTATE_TO_STR(WINED3DSAMP_DMAPOFFSET );
443 #undef D3DSTATE_TO_STR
444 default:
445 FIXME("Unrecognized %lu sampler state!\n", state);
446 return "unrecognized";
447 }
448 }
449
450 const char* debug_d3dtexturestate(DWORD state) {
451 switch (state) {
452 #define D3DSTATE_TO_STR(u) case u: return #u
453 D3DSTATE_TO_STR(WINED3DTSS_COLOROP );
454 D3DSTATE_TO_STR(WINED3DTSS_COLORARG1 );
455 D3DSTATE_TO_STR(WINED3DTSS_COLORARG2 );
456 D3DSTATE_TO_STR(WINED3DTSS_ALPHAOP );
457 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG1 );
458 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG2 );
459 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT00 );
460 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT01 );
461 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT10 );
462 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVMAT11 );
463 D3DSTATE_TO_STR(WINED3DTSS_TEXCOORDINDEX );
464 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLSCALE );
465 D3DSTATE_TO_STR(WINED3DTSS_BUMPENVLOFFSET );
466 D3DSTATE_TO_STR(WINED3DTSS_TEXTURETRANSFORMFLAGS );
467 D3DSTATE_TO_STR(WINED3DTSS_ADDRESSW );
468 D3DSTATE_TO_STR(WINED3DTSS_COLORARG0 );
469 D3DSTATE_TO_STR(WINED3DTSS_ALPHAARG0 );
470 D3DSTATE_TO_STR(WINED3DTSS_RESULTARG );
471 D3DSTATE_TO_STR(WINED3DTSS_CONSTANT );
472 #undef D3DSTATE_TO_STR
473 case 12:
474 /* Note D3DTSS are not consecutive, so skip these */
475 return "unused";
476 break;
477 default:
478 FIXME("Unrecognized %lu texture state!\n", state);
479 return "unrecognized";
480 }
481 }
482
483 const char* debug_d3dpool(WINED3DPOOL Pool) {
484 switch (Pool) {
485 #define POOL_TO_STR(p) case p: return #p;
486 POOL_TO_STR(WINED3DPOOL_DEFAULT);
487 POOL_TO_STR(WINED3DPOOL_MANAGED);
488 POOL_TO_STR(WINED3DPOOL_SYSTEMMEM);
489 POOL_TO_STR(WINED3DPOOL_SCRATCH);
490 #undef POOL_TO_STR
491 default:
492 FIXME("Unrecognized %u WINED3DPOOL!\n", Pool);
493 return "unrecognized";
494 }
495 }
496 /*****************************************************************************
497 * Useful functions mapping GL <-> D3D values
498 */
499 GLenum StencilOp(DWORD op) {
500 switch(op) {
501 case D3DSTENCILOP_KEEP : return GL_KEEP;
502 case D3DSTENCILOP_ZERO : return GL_ZERO;
503 case D3DSTENCILOP_REPLACE : return GL_REPLACE;
504 case D3DSTENCILOP_INCRSAT : return GL_INCR;
505 case D3DSTENCILOP_DECRSAT : return GL_DECR;
506 case D3DSTENCILOP_INVERT : return GL_INVERT;
507 case D3DSTENCILOP_INCR : return GL_INCR_WRAP_EXT;
508 case D3DSTENCILOP_DECR : return GL_DECR_WRAP_EXT;
509 default:
510 FIXME("Unrecognized stencil op %ld\n", op);
511 return GL_KEEP;
512 }
513 }
514
515 GLenum StencilFunc(DWORD func) {
516 switch ((D3DCMPFUNC)func) {
517 case D3DCMP_NEVER : return GL_NEVER;
518 case D3DCMP_LESS : return GL_LESS;
519 case D3DCMP_EQUAL : return GL_EQUAL;
520 case D3DCMP_LESSEQUAL : return GL_LEQUAL;
521 case D3DCMP_GREATER : return GL_GREATER;
522 case D3DCMP_NOTEQUAL : return GL_NOTEQUAL;
523 case D3DCMP_GREATEREQUAL : return GL_GEQUAL;
524 case D3DCMP_ALWAYS : return GL_ALWAYS;
525 default:
526 FIXME("Unrecognized D3DCMPFUNC value %ld\n", func);
527 return GL_ALWAYS;
528 }
529 }
530
531 static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* operand) {
532 /* The D3DTA_ALPHAREPLICATE flag specifies the alpha component of the
533 * input should be used for all input components. The D3DTA_COMPLEMENT
534 * flag specifies the complement of the input should be used. */
535 BOOL from_alpha = is_alpha || arg & D3DTA_ALPHAREPLICATE;
536 BOOL complement = arg & D3DTA_COMPLEMENT;
537
538 /* Calculate the operand */
539 if (complement) {
540 if (from_alpha) *operand = GL_ONE_MINUS_SRC_ALPHA;
541 else *operand = GL_ONE_MINUS_SRC_COLOR;
542 } else {
543 if (from_alpha) *operand = GL_SRC_ALPHA;
544 else *operand = GL_SRC_COLOR;
545 }
546
547 /* Calculate the source */
548 switch (arg & D3DTA_SELECTMASK) {
549 case D3DTA_CURRENT: *source = GL_PREVIOUS_EXT; break;
550 case D3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT; break;
551 case D3DTA_TEXTURE: *source = GL_TEXTURE; break;
552 case D3DTA_TFACTOR: *source = GL_CONSTANT_EXT; break;
553 case D3DTA_SPECULAR:
554 /*
555 * According to the GL_ARB_texture_env_combine specs, SPECULAR is
556 * 'Secondary color' and isn't supported until base GL supports it
557 * There is no concept of temp registers as far as I can tell
558 */
559 FIXME("Unhandled texture arg D3DTA_SPECULAR\n");
560 *source = GL_TEXTURE;
561 break;
562 default:
563 FIXME("Unrecognized texture arg %#lx\n", arg);
564 *source = GL_TEXTURE;
565 break;
566 }
567 }
568
569 /* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
570 #if defined (GL_VERSION_1_3)
571 # define useext(A) A
572 # define combine_ext 1
573 #elif defined (GL_EXT_texture_env_combine)
574 # define useext(A) A##_EXT
575 # define combine_ext 1
576 #elif defined (GL_ARB_texture_env_combine)
577 # define useext(A) A##_ARB
578 # define combine_ext 1
579 #else
580 # undef combine_ext
581 #endif
582
583 #if !defined(combine_ext)
584 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
585 {
586 FIXME("Requires opengl combine extensions to work\n");
587 return;
588 }
589 #else
590 /* Setup the texture operations texture stage states */
591 void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, D3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
592 {
593 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
594 GLenum src1, src2, src3;
595 GLenum opr1, opr2, opr3;
596 GLenum comb_target;
597 GLenum src0_target, src1_target, src2_target;
598 GLenum opr0_target, opr1_target, opr2_target;
599 GLenum scal_target;
600 GLenum opr=0, invopr, src3_target, opr3_target;
601 BOOL Handled = FALSE;
602 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
603
604 TRACE("Alpha?(%d), Stage:%d Op(%d), a1(%ld), a2(%ld), a3(%ld)\n", isAlpha, Stage, op, arg1, arg2, arg3);
605
606 ENTER_GL();
607
608 /* Note: Operations usually involve two ars, src0 and src1 and are operations of
609 the form (a1 <operation> a2). However, some of the more complex operations
610 take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
611 in a third parameter called a0. Therefore these are operations of the form
612 a0 <operation> a1 <operation> a2, ie the new parameter goes to the front.
613
614 However, below we treat the new (a0) parameter as src2/opr2, so in the actual
615 functions below, expect their syntax to differ slightly to those listed in the
616 manuals, ie replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
617 This affects D3DTOP_MULTIPLYADD and D3DTOP_LERP */
618
619 if (isAlpha) {
620 comb_target = useext(GL_COMBINE_ALPHA);
621 src0_target = useext(GL_SOURCE0_ALPHA);
622 src1_target = useext(GL_SOURCE1_ALPHA);
623 src2_target = useext(GL_SOURCE2_ALPHA);
624 opr0_target = useext(GL_OPERAND0_ALPHA);
625 opr1_target = useext(GL_OPERAND1_ALPHA);
626 opr2_target = useext(GL_OPERAND2_ALPHA);
627 scal_target = GL_ALPHA_SCALE;
628 }
629 else {
630 comb_target = useext(GL_COMBINE_RGB);
631 src0_target = useext(GL_SOURCE0_RGB);
632 src1_target = useext(GL_SOURCE1_RGB);
633 src2_target = useext(GL_SOURCE2_RGB);
634 opr0_target = useext(GL_OPERAND0_RGB);
635 opr1_target = useext(GL_OPERAND1_RGB);
636 opr2_target = useext(GL_OPERAND2_RGB);
637 scal_target = useext(GL_RGB_SCALE);
638 }
639
640 /* From MSDN (WINED3DTSS_ALPHAARG1) :
641 The default argument is D3DTA_TEXTURE. If no texture is set for this stage,
642 then the default argument is D3DTA_DIFFUSE.
643 FIXME? If texture added/removed, may need to reset back as well? */
644 if (isAlpha && This->stateBlock->textures[Stage] == NULL && arg1 == D3DTA_TEXTURE) {
645 get_src_and_opr(D3DTA_DIFFUSE, isAlpha, &src1, &opr1);
646 } else {
647 get_src_and_opr(arg1, isAlpha, &src1, &opr1);
648 }
649 get_src_and_opr(arg2, isAlpha, &src2, &opr2);
650 get_src_and_opr(arg3, isAlpha, &src3, &opr3);
651
652 TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
653
654 Handled = TRUE; /* Assume will be handled */
655
656 /* Other texture operations require special extensions: */
657 if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
658 if (isAlpha) {
659 opr = GL_SRC_ALPHA;
660 invopr = GL_ONE_MINUS_SRC_ALPHA;
661 src3_target = GL_SOURCE3_ALPHA_NV;
662 opr3_target = GL_OPERAND3_ALPHA_NV;
663 } else {
664 opr = GL_SRC_COLOR;
665 invopr = GL_ONE_MINUS_SRC_COLOR;
666 src3_target = GL_SOURCE3_RGB_NV;
667 opr3_target = GL_OPERAND3_RGB_NV;
668 }
669 switch (op) {
670 case D3DTOP_DISABLE: /* Only for alpha */
671 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
672 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
673 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
674 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
675 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
676 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
677 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
678 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
679 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
680 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
681 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
682 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
683 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
684 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
685 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
686 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
687 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
688 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
689 break;
690 case D3DTOP_SELECTARG1: /* = a1 * 1 + 0 * 0 */
691 case D3DTOP_SELECTARG2: /* = a2 * 1 + 0 * 0 */
692 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
693 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
694 if (op == D3DTOP_SELECTARG1) {
695 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
696 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
697 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
698 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
699 } else {
700 glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
701 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
702 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
703 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
704 }
705 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
706 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
707 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
708 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
709 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
710 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
711 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
712 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
713 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
714 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
715 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
716 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
717 break;
718
719 case D3DTOP_MODULATE:
720 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
721 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
722 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
723 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
724 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
725 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
726 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
727 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
728 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
729 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
730 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
731 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
732 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
733 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
734 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
735 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
736 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
737 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
738 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
739 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
740 break;
741 case D3DTOP_MODULATE2X:
742 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
743 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
744 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
745 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
746 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
747 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
748 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
749 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
750 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
751 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
752 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
753 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
754 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
755 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
756 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
757 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
758 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
759 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
760 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
761 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
762 break;
763 case D3DTOP_MODULATE4X:
764 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
765 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
766 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
767 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
768 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
769 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
770 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
771 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
772 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
773 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
774 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
775 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
776 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
777 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
778 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
779 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
780 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
781 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
782 glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
783 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
784 break;
785
786 case D3DTOP_ADD:
787 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
788 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
789 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
790 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
791 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
792 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
793 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
794 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
795 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
796 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
797 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
798 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
799 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
800 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
801 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
802 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
803 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
804 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
805 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
806 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
807 break;
808
809 case D3DTOP_ADDSIGNED:
810 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
811 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
812 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
813 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
814 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
815 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
816 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
817 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
818 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
819 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
820 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
821 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
822 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
823 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
824 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
825 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
826 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
827 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
828 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
829 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
830 break;
831
832 case D3DTOP_ADDSIGNED2X:
833 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
834 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
835 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
836 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
837 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
838 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
839 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
840 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
841 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
842 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
843 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
844 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
845 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
846 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
847 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
848 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
849 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
850 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
851 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
852 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
853 break;
854
855 case D3DTOP_ADDSMOOTH:
856 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
857 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
858 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
859 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
860 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
861 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
862 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
863 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
864 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
865 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
866 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
867 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
868 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
869 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
870 glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
871 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
872 switch (opr1) {
873 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
874 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
875 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
876 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
877 }
878 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
879 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
880 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
881 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
882 break;
883
884 case D3DTOP_BLENDDIFFUSEALPHA:
885 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
886 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
887 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
888 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
889 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
890 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
891 glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR));
892 checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
893 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
894 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
895 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
896 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
897 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
898 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
899 glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR));
900 checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
901 glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
902 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
903 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
904 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
905 break;
906 case D3DTOP_BLENDTEXTUREALPHA:
907 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
908 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
909 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
910 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
911 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
912 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
913 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_TEXTURE);
914 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
915 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
916 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
917 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
918 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
919 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
920 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
921 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
922 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
923 glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
924 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
925 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
926 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
927 break;
928 case D3DTOP_BLENDFACTORALPHA:
929 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
930 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
931 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
932 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
933 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
934 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
935 glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT));
936 checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
937 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
938 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
939 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
940 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
941 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
942 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
943 glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT));
944 checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
945 glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
946 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
947 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
948 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
949 break;
950 case D3DTOP_BLENDTEXTUREALPHAPM:
951 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
952 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
953 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
954 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
955 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
956 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
957 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
958 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
959 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
960 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
961 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
962 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
963 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
964 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
965 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
966 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
967 glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
968 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
969 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
970 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
971 break;
972 case D3DTOP_MODULATEALPHA_ADDCOLOR:
973 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
974 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
975 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1); /* a0 = src1/opr1 */
976 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
977 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
978 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
979 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
980 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
981 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
982 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
983 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2); /* a2 = arg2 */
984 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
985 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
986 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
987 glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
988 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
989 switch (opr) {
990 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
991 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
992 }
993 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
994 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
995 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
996 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
997 break;
998 case D3DTOP_MODULATECOLOR_ADDALPHA:
999 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1000 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1001 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1002 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1003 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1004 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1005 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1006 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1007 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1008 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1009 glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1010 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1011 switch (opr1) {
1012 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1013 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1014 }
1015 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1016 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1017 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1018 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1019 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1020 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1021 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1022 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1023 break;
1024 case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
1025 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1026 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1027 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1028 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1029 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1030 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1031 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1032 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1033 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1034 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1035 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1036 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1037 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1038 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1039 glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
1040 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
1041 switch (opr1) {
1042 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1043 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1044 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1045 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1046 }
1047 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1048 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1049 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1050 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1051 break;
1052 case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
1053 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1054 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1055 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1056 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1057 switch (opr1) {
1058 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1059 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1060 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1061 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1062 }
1063 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1064 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1065 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1066 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1067 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1068 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1069 glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1070 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
1071 switch (opr1) {
1072 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1073 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1074 }
1075 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1076 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1077 glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1078 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1079 glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
1080 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
1081 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1082 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1083 break;
1084 case D3DTOP_MULTIPLYADD:
1085 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1086 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1087 glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
1088 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1089 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
1090 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1091 glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1092 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1093 glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1094 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1095 glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
1096 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1097 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
1098 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1099 glTexEnvi(GL_TEXTURE_ENV, src3_target, src2);
1100 checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
1101 glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr2);
1102 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
1103 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1104 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1105 break;
1106
1107 case D3DTOP_BUMPENVMAP:
1108 {
1109 if (GL_SUPPORT(NV_TEXTURE_SHADER)) {
1110 /*
1111 texture unit 0: GL_TEXTURE_2D
1112 texture unit 1: GL_DOT_PRODUCT_NV
1113 texture unit 2: GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV
1114 texture unit 3: GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV
1115 */
1116 float m[2][2];
1117
1118 union {
1119 float f;
1120 DWORD d;
1121 } tmpvalue;
1122
1123 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT00];
1124 m[0][0] = tmpvalue.f;
1125 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT01];
1126 m[0][1] = tmpvalue.f;
1127 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT10];
1128 m[1][0] = tmpvalue.f;
1129 tmpvalue.d = This->stateBlock->textureState[Stage][WINED3DTSS_BUMPENVMAT11];
1130 m[1][1] = tmpvalue.f;
1131
1132 /*FIXME("Stage %d matrix is (%.2f,%.2f),(%.2f,%.2f)\n", Stage, m[0][0], m[0][1], m[1][0], m[1][0]);*/
1133
1134 if (FALSE == This->texture_shader_active) {
1135 This->texture_shader_active = TRUE;
1136 glEnable(GL_TEXTURE_SHADER_NV);
1137 }
1138
1139 /*
1140 glEnable(GL_REGISTER_COMBINERS_NV);
1141 glCombinerParameteriNV (GL_NUM_GENERAL_COMBINERS_NV, 1);
1142 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1143 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_RGB);
1144 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1145 glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_RGB);
1146 glCombinerOutputNV (GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_PRIMARY_COLOR_NV, 0, 0, 0, 0, 0);
1147 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_ALPHA);
1148 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_B_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
1149 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB, GL_SIGNED_IDENTITY_NV, GL_ALPHA);
1150 glCombinerInputNV (GL_COMBINER0_NV, GL_ALPHA, GL_VARIABLE_D_NV, GL_NONE, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
1151 glCombinerOutputNV (GL_COMBINER0_NV, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_PRIMARY_COLOR_NV, 0, 0, 0, 0, 0);
1152 glDisable (GL_PER_STAGE_CONSTANTS_NV);
1153 glCombinerParameteriNV (GL_COLOR_SUM_CLAMP_NV, 0);
1154 glFinalCombinerInputNV (GL_VARIABLE_A_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1155 glFinalCombinerInputNV (GL_VARIABLE_B_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1156 glFinalCombinerInputNV (GL_VARIABLE_C_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1157 glFinalCombinerInputNV (GL_VARIABLE_D_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1158 glFinalCombinerInputNV (GL_VARIABLE_E_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1159 glFinalCombinerInputNV (GL_VARIABLE_F_NV, 0, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1160 glFinalCombinerInputNV (GL_VARIABLE_G_NV, GL_PRIMARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA);
1161 */
1162 /*
1163 int i;
1164 for (i = 0; i < Stage; i++) {
1165 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1166 GL_ACTIVETEXTURE(i);
1167 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1168 checkGLcall("Activate texture..");
1169 } else if (i>0) {
1170 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1171 }
1172 }
1173 */
1174 /*
1175 GL_ACTIVETEXTURE(Stage - 1);
1176 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1177 */
1178 /*
1179 GL_ACTIVETEXTURE(Stage);
1180 checkGLcall("Activate texture.. to update const color");
1181 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
1182 checkGLcall("glTexEnv");
1183 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + Stage - 1);
1184 checkGLcall("glTexEnv");
1185 glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, (float*)&m[0]);
1186 checkGLcall("glTexEnv");
1187 */
1188 LEAVE_GL();
1189 return;
1190 }
1191 }
1192
1193 case D3DTOP_BUMPENVMAPLUMINANCE:
1194
1195 default:
1196 Handled = FALSE;
1197 }
1198 if (Handled) {
1199 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
1200 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
1201
1202 LEAVE_GL();
1203 return;
1204 }
1205 } /* GL_NV_texture_env_combine4 */
1206
1207 Handled = TRUE; /* Again, assume handled */
1208 switch (op) {
1209 case D3DTOP_DISABLE: /* Only for alpha */
1210 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1211 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1212 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1213 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
1214 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1215 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
1216 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1217 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1218 break;
1219 case D3DTOP_SELECTARG1:
1220 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1221 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1222 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1223 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1224 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1225 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1226 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1227 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1228 break;
1229 case D3DTOP_SELECTARG2:
1230 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
1231 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1232 glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1233 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1234 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1235 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1236 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1237 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1238 break;
1239 case D3DTOP_MODULATE:
1240 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1241 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1242 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1243 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1244 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1245 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1246 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1247 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1248 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1249 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1250 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1251 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1252 break;
1253 case D3DTOP_MODULATE2X:
1254 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1255 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1256 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1257 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1258 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1259 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1260 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1261 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1262 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1263 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1264 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1265 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1266 break;
1267 case D3DTOP_MODULATE4X:
1268 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
1269 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
1270 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1271 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1272 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1273 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1274 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1275 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1276 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1277 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1278 glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
1279 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
1280 break;
1281 case D3DTOP_ADD:
1282 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1283 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1284 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1285 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1286 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1287 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1288 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1289 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1290 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1291 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1292 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1293 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1294 break;
1295 case D3DTOP_ADDSIGNED:
1296 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1297 checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
1298 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1299 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1300 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1301 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1302 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1303 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1304 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1305 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1306 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1307 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1308 break;
1309 case D3DTOP_ADDSIGNED2X:
1310 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
1311 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
1312 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1313 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1314 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1315 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1316 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1317 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1318 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1319 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1320 glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
1321 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
1322 break;
1323 case D3DTOP_SUBTRACT:
1324 if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE)) {
1325 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
1326 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
1327 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1328 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1329 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1330 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1331 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1332 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1333 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1334 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1335 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1336 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1337 } else {
1338 FIXME("This version of opengl does not support GL_SUBTRACT\n");
1339 }
1340 break;
1341
1342 case D3DTOP_BLENDDIFFUSEALPHA:
1343 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1344 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1345 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1346 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1347 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1348 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1349 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1350 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1351 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1352 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1353 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PRIMARY_COLOR));
1354 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
1355 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1356 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1357 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1358 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1359 break;
1360 case D3DTOP_BLENDTEXTUREALPHA:
1361 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1362 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1363 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1364 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1365 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1366 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1367 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1368 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1369 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1370 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1371 glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
1372 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
1373 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1374 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1375 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1376 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1377 break;
1378 case D3DTOP_BLENDFACTORALPHA:
1379 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1380 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1381 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1382 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1383 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1384 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1385 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1386 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1387 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1388 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1389 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_CONSTANT));
1390 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
1391 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1392 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1393 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1394 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1395 break;
1396 case D3DTOP_BLENDCURRENTALPHA:
1397 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1398 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1399 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1400 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1401 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1402 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1403 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1404 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1405 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1406 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1407 glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PREVIOUS));
1408 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
1409 glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
1410 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
1411 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1412 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1413 break;
1414 case D3DTOP_DOTPRODUCT3:
1415 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3)) {
1416 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
1417 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
1418 } else if (GL_SUPPORT(EXT_TEXTURE_ENV_DOT3)) {
1419 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
1420 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
1421 } else {
1422 FIXME("This version of opengl does not support GL_DOT3\n");
1423 }
1424 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1425 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1426 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1427 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1428 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1429 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1430 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1431 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1432 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1433 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1434 break;
1435 case D3DTOP_LERP:
1436 glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
1437 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
1438 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1439 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1440 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1441 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1442 glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1443 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
1444 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1445 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
1446 glTexEnvi(GL_TEXTURE_ENV, src2_target, src3);
1447 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
1448 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr3);
1449 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
1450 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1451 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1452 break;
1453 case D3DTOP_ADDSMOOTH:
1454 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1455 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1456 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1457 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1458 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1459 switch (opr1) {
1460 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1461 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1462 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1463 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1464 }
1465 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1466 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1467 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1468 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1469 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1470 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1471 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1472 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1473 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1474 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1475 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1476 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1477 } else
1478 Handled = FALSE;
1479 break;
1480 case D3DTOP_BLENDTEXTUREALPHAPM:
1481 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1482 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1483 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1484 glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_TEXTURE);
1485 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
1486 glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_ALPHA);
1487 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
1488 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1489 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1490 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1491 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1492 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1493 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1494 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1495 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1496 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1497 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1498 } else
1499 Handled = FALSE;
1500 break;
1501 case D3DTOP_MODULATEALPHA_ADDCOLOR:
1502 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1503 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1504 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1505 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1506 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1507 switch (opr1) {
1508 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1509 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1510 case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1511 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1512 }
1513 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1514 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1515 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1516 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1517 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1518 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1519 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1520 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1521 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1522 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1523 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1524 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1525 } else
1526 Handled = FALSE;
1527 break;
1528 case D3DTOP_MODULATECOLOR_ADDALPHA:
1529 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1530 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1531 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1532 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1533 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1534 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1535 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1536 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1537 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1538 switch (opr1) {
1539 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1540 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1541 case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1542 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1543 }
1544 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
1545 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
1546 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1547 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1548 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1549 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1550 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1551 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1552 } else
1553 Handled = FALSE;
1554 break;
1555 case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
1556 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1557 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1558 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1559 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1560 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1561 switch (opr1) {
1562 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1563 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1564 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1565 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1566 }
1567 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1568 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1569 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1570 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1571 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1572 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1573 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1574 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1575 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1576 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1577 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1578 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1579 } else
1580 Handled = FALSE;
1581 break;
1582 case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
1583 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1584 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1585 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1586 glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1587 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1588 switch (opr1) {
1589 case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
1590 case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
1591 case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1592 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1593 }
1594 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
1595 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
1596 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1597 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1598 switch (opr1) {
1599 case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
1600 case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1601 case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
1602 case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
1603 }
1604 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
1605 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
1606 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1607 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1608 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1609 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1610 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1611 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1612 } else
1613 Handled = FALSE;
1614 break;
1615 case D3DTOP_MULTIPLYADD:
1616 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
1617 glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
1618 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
1619 glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
1620 checkGLcall("GL_TEXTURE_ENV, src0_target, src3");
1621 glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
1622 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr3");
1623 glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
1624 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
1625 glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
1626 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
1627 glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
1628 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1629 glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
1630 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1631 glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1632 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1633 } else
1634 Handled = FALSE;
1635 break;
1636 default:
1637 Handled = FALSE;
1638 }
1639
1640 if (Handled) {
1641 BOOL combineOK = TRUE;
1642 if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
1643 DWORD op2;
1644
1645 if (isAlpha) {
1646 op2 = This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP];
1647 } else {
1648 op2 = This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAOP];
1649 }
1650
1651 /* Note: If COMBINE4 in effect can't go back to combine! */
1652 switch (op2) {
1653 case D3DTOP_ADDSMOOTH:
1654 case D3DTOP_BLENDTEXTUREALPHAPM:
1655 case D3DTOP_MODULATEALPHA_ADDCOLOR:
1656 case D3DTOP_MODULATECOLOR_ADDALPHA:
1657 case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
1658 case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
1659 case D3DTOP_MULTIPLYADD:
1660 /* Ignore those implemented in both cases */
1661 switch (op) {
1662 case D3DTOP_SELECTARG1:
1663 case D3DTOP_SELECTARG2:
1664 combineOK = FALSE;
1665 Handled = FALSE;
1666 break;
1667 default:
1668 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%d, otherop=%ld, isAlpha(%d)\n", op, op2, isAlpha);
1669 LEAVE_GL();
1670 return;
1671 }
1672 }
1673 }
1674
1675 if (combineOK) {
1676 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
1677 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
1678
1679 LEAVE_GL();
1680 return;
1681 }
1682 }
1683
1684 LEAVE_GL();
1685
1686 /* After all the extensions, if still unhandled, report fixme */
1687 FIXME("Unhandled texture operation %d\n", op);
1688 #undef GLINFO_LOCATION
1689 }
1690 #endif
1691
1692 /* Setup this textures matrix according to the texture flags*/
1693 void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords)
1694 {
1695 float mat[16];
1696
1697 glMatrixMode(GL_TEXTURE);
1698 checkGLcall("glMatrixMode(GL_TEXTURE)");
1699
1700 if (flags == D3DTTFF_DISABLE) {
1701 glLoadIdentity();
1702 checkGLcall("glLoadIdentity()");
1703 return;
1704 }
1705
1706 if (flags == (D3DTTFF_COUNT1|D3DTTFF_PROJECTED)) {
1707 ERR("Invalid texture transform flags: D3DTTFF_COUNT1|D3DTTFF_PROJECTED\n");
1708 return;
1709 }
1710
1711 memcpy(mat, smat, 16 * sizeof(float));
1712
1713 switch (flags & ~D3DTTFF_PROJECTED) {
1714 case D3DTTFF_COUNT1: mat[1] = mat[5] = mat[13] = 0;
1715 case D3DTTFF_COUNT2: mat[2] = mat[6] = mat[10] = mat[14] = 0;
1716 default: mat[3] = mat[7] = mat[11] = 0, mat[15] = 1;
1717 }
1718
1719 if (flags & D3DTTFF_PROJECTED) {
1720 switch (flags & ~D3DTTFF_PROJECTED) {
1721 case D3DTTFF_COUNT2:
1722 mat[3] = mat[1], mat[7] = mat[5], mat[11] = mat[9], mat[15] = mat[13];
1723 mat[1] = mat[5] = mat[9] = mat[13] = 0;
1724 break;
1725 case D3DTTFF_COUNT3:
1726 mat[3] = mat[2], mat[7] = mat[6], mat[11] = mat[10], mat[15] = mat[14];
1727 mat[2] = mat[6] = mat[10] = mat[14] = 0;
1728 break;
1729 }
1730 } else if(!calculatedCoords) { /* under directx the R/Z coord can be used for translation, under opengl we use the Q coord instead */
1731 mat[12] = mat[8];
1732 mat[13] = mat[9];
1733 }
1734
1735 glLoadMatrixf(mat);
1736 checkGLcall("glLoadMatrixf(mat)");
1737 }
1738
1739 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->wineD3D))->gl_info
1740
1741 /* Convertes a D3D format into a OpenGL configuration format */
1742 int D3DFmtMakeGlCfg(D3DFORMAT BackBufferFormat, D3DFORMAT StencilBufferFormat, int *attribs, int* nAttribs, BOOL alternate){
1743 #define PUSH1(att) attribs[(*nAttribs)++] = (att);
1744 #define PUSH2(att,value) attribs[(*nAttribs)++] = (att); attribs[(*nAttribs)++] = (value);
1745 /*We need to do some Card specific stuff in here at some point,
1746 D3D now supports floating point format buffers, and there are a number of different OpelGl ways of managing these e.g.
1747 GLX_ATI_pixel_format_float
1748 */
1749 switch (BackBufferFormat) {
1750 /* color buffer */
1751 case WINED3DFMT_P8:
1752 PUSH2(GLX_RENDER_TYPE, GLX_COLOR_INDEX_BIT);
1753 PUSH2(GLX_BUFFER_SIZE, 8);
1754 PUSH2(GLX_DOUBLEBUFFER, TRUE);
1755 break;
1756
1757 case WINED3DFMT_R3G3B2:
1758 PUSH2(GLX_RENDER_TYPE, GLX_RGBA_BIT);
1759 PUSH2(GLX_RED_SIZE, 3);
1760 PUSH2(GLX_GREEN_SIZE, 3);
1761 PUSH2(GLX_BLUE_SIZE, 2);
1762 break;
1763
1764 case WINED3DFMT_A1R5G5B5:
1765 PUSH2(GLX_ALPHA_SIZE, 1);
1766 case WINED3DFMT_X1R5G5B5:
1767 PUSH2(GLX_RED_SIZE, 5);
1768 PUSH2(GLX_GREEN_SIZE, 5);
1769 PUSH2(GLX_BLUE_SIZE, 5);
1770 break;
1771
1772 case WINED3DFMT_R5G6B5:
1773 PUSH2(GLX_RED_SIZE, 5);
1774 PUSH2(GLX_GREEN_SIZE, 6);
1775 PUSH2(GLX_BLUE_SIZE, 5);
1776 break;
1777
1778 case WINED3DFMT_A4R4G4B4:
1779 PUSH2(GLX_ALPHA_SIZE, 4);
1780 case WINED3DFMT_X4R4G4B4:
1781 PUSH2(GLX_RED_SIZE, 4);
1782 PUSH2(GLX_GREEN_SIZE, 4);
1783 PUSH2(GLX_BLUE_SIZE, 4);
1784 break;
1785
1786 case WINED3DFMT_A8R8G8B8:
1787 PUSH2(GLX_ALPHA_SIZE, 8);
1788 case WINED3DFMT_R8G8B8:
1789 case WINED3DFMT_X8R8G8B8:
1790 PUSH2(GLX_RED_SIZE, 8);
1791 PUSH2(GLX_GREEN_SIZE, 8);
1792 PUSH2(GLX_BLUE_SIZE, 8);
1793 break;
1794
1795 case WINED3DFMT_A2R10G10B10:
1796 PUSH2(GLX_ALPHA_SIZE, 2);
1797 PUSH2(GLX_RED_SIZE, 10);
1798 PUSH2(GLX_GREEN_SIZE, 10);
1799 PUSH2(GLX_BLUE_SIZE, 10);
1800 break;
1801
1802 case WINED3DFMT_A16B16G16R16:
1803 PUSH2(GLX_ALPHA_SIZE, 16);
1804 PUSH2(GLX_RED_SIZE, 16);
1805 PUSH2(GLX_GREEN_SIZE, 16);
1806 PUSH2(GLX_BLUE_SIZE, 16);
1807 break;
1808
1809 default:
1810 FIXME("Unsupported color format: %s\n", debug_d3dformat(BackBufferFormat));
1811 break;
1812 }
1813 if(!alternate){
1814 switch (StencilBufferFormat) {
1815 case 0:
1816 break;
1817
1818 case WINED3DFMT_D16_LOCKABLE:
1819 case WINED3DFMT_D16:
1820 PUSH2(GLX_DEPTH_SIZE, 16);
1821 break;
1822
1823 case WINED3DFMT_D15S1:
1824 PUSH2(GLX_DEPTH_SIZE, 15);
1825 PUSH2(GLX_STENCIL_SIZE, 1);
1826 /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
1827 e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
1828 break;
1829
1830 case WINED3DFMT_D24X8:
1831 PUSH2(GLX_DEPTH_SIZE, 24);
1832 break;
1833
1834 case WINED3DFMT_D24X4S4:
1835 PUSH2(GLX_DEPTH_SIZE, 24);
1836 PUSH2(GLX_STENCIL_SIZE, 4);
1837 break;
1838
1839 case WINED3DFMT_D24S8:
1840 PUSH2(GLX_DEPTH_SIZE, 24);
1841 PUSH2(GLX_STENCIL_SIZE, 8);
1842 break;
1843
1844 case WINED3DFMT_D24FS8:
1845 PUSH2(GLX_DEPTH_SIZE, 24);
1846 PUSH2(GLX_STENCIL_SIZE, 8);
1847 break;
1848
1849 case WINED3DFMT_D32:
1850 PUSH2(GLX_DEPTH_SIZE, 32);
1851 break;
1852
1853 default:
1854 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
1855 break;
1856 }
1857
1858 } else { /* it the device doesn't support the 'exact' format, try to find something close */
1859 switch (StencilBufferFormat) {
1860 case 0:
1861 break;
1862
1863 case WINED3DFMT_D16_LOCKABLE:
1864 case WINED3DFMT_D16:
1865 PUSH2(GLX_DEPTH_SIZE, 1);
1866 break;
1867
1868 case WINED3DFMT_D15S1:
1869 PUSH2(GLX_DEPTH_SIZE, 1);
1870 PUSH2(GLX_STENCIL_SIZE, 1);
1871 /*Does openGl support a 1bit stencil?, I've seen it used elsewhere
1872 e.g. http://www.ks.uiuc.edu/Research/vmd/doxygen/OpenGLDisplayDevice_8C-source.html*/
1873 break;
1874
1875 case WINED3DFMT_D24X8:
1876 PUSH2(GLX_DEPTH_SIZE, 1);
1877 break;
1878
1879 case WINED3DFMT_D24X4S4:
1880 PUSH2(GLX_DEPTH_SIZE, 1);
1881 PUSH2(GLX_STENCIL_SIZE, 1);
1882 break;
1883
1884 case WINED3DFMT_D24S8:
1885 PUSH2(GLX_DEPTH_SIZE, 1);
1886 PUSH2(GLX_STENCIL_SIZE, 1);
1887 break;
1888
1889 case WINED3DFMT_D24FS8:
1890 PUSH2(GLX_DEPTH_SIZE, 1);
1891 PUSH2(GLX_STENCIL_SIZE, 1);
1892 break;
1893
1894 case WINED3DFMT_D32:
1895 PUSH2(GLX_DEPTH_SIZE, 1);
1896 break;
1897
1898 default:
1899 FIXME("Unsupported stencil format: %s\n", debug_d3dformat(StencilBufferFormat));
1900 break;
1901 }
1902 }
1903
1904 return *nAttribs;
1905 }
1906
1907 #undef GLINFO_LOCATION
1908
1909 /* DirectDraw stuff */
1910 WINED3DFORMAT pixelformat_for_depth(DWORD depth) {
1911 switch(depth) {
1912 case 8: return D3DFMT_P8; break;
1913 case 15: return WINED3DFMT_X1R5G5B5; break;
1914 case 16: return WINED3DFMT_R5G6B5; break;
1915 case 24: return WINED3DFMT_R8G8B8; break;
1916 case 32: return WINED3DFMT_X8R8G8B8; break;
1917 default: return WINED3DFMT_UNKNOWN;
1918 }
1919 }
1920
1921 void multiply_matrix(D3DMATRIX *dest, D3DMATRIX *src1, D3DMATRIX *src2) {
1922 D3DMATRIX temp;
1923
1924 /* Now do the multiplication 'by hand'.
1925 I know that all this could be optimised, but this will be done later :-) */
1926 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);
1927 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);
1928 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);
1929 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);
1930
1931 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);
1932 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);
1933 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);
1934 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);
1935
1936 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);
1937 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);
1938 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);
1939 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);
1940
1941 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);
1942 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);
1943 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);
1944 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);
1945
1946 /* And copy the new matrix in the good storage.. */
1947 memcpy(dest, &temp, 16 * sizeof(float));
1948 }
1949
1950 DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) {
1951 DWORD size = 0;
1952 int i;
1953 int numTextures = (d3dvtVertexType & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
1954
1955 if (d3dvtVertexType & D3DFVF_NORMAL) size += 3 * sizeof(float);
1956 if (d3dvtVertexType & D3DFVF_DIFFUSE) size += sizeof(DWORD);
1957 if (d3dvtVertexType & D3DFVF_SPECULAR) size += sizeof(DWORD);
1958 if (d3dvtVertexType & D3DFVF_PSIZE) size += sizeof(DWORD);
1959 switch (d3dvtVertexType & D3DFVF_POSITION_MASK) {
1960 case D3DFVF_XYZ: size += 3 * sizeof(float); break;
1961 case D3DFVF_XYZRHW: size += 4 * sizeof(float); break;
1962 default: TRACE(" matrix weighting not handled yet...\n");
1963 }
1964 for (i = 0; i < numTextures; i++) {
1965 size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(float);
1966 }
1967
1968 return size;
1969 }
1970
1971 /***********************************************************************
1972 * CalculateTexRect
1973 *
1974 * Calculates the dimensions of the opengl texture used for blits.
1975 * Handled oversized opengl textures and updates the source rectangle
1976 * accordingly
1977 *
1978 * Params:
1979 * This: Surface to operate on
1980 * Rect: Requested rectangle
1981 *
1982 * Returns:
1983 * TRUE if the texture part can be loaded,
1984 * FALSE otherwise
1985 *
1986 *********************************************************************/
1987 #define GLINFO_LOCATION ((IWineD3DImpl *)(This->resource.wineD3DDevice->wineD3D))->gl_info
1988
1989 BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]) {
1990 int x1 = Rect->left, x2 = Rect->right;
1991 int y1 = Rect->top, y2 = Rect->bottom;
1992 GLint maxSize = GL_LIMITS(texture_size);
1993
1994 TRACE("(%p)->(%ld,%ld)-(%ld,%ld)\n", This,
1995 Rect->left, Rect->top, Rect->right, Rect->bottom);
1996
1997 /* The sizes might be reversed */
1998 if(Rect->left > Rect->right) {
1999 x1 = Rect->right;
2000 x2 = Rect->left;
2001 }
2002 if(Rect->top > Rect->bottom) {
2003 y1 = Rect->bottom;
2004 y2 = Rect->top;
2005 }
2006
2007 /* No oversized texture? This is easy */
2008 if(!(This->Flags & SFLAG_OVERSIZE)) {
2009 /* Which rect from the texture do I need? */
2010 glTexCoord[0] = (float) Rect->left / (float) This->pow2Width;
2011 glTexCoord[2] = (float) Rect->top / (float) This->pow2Height;
2012 glTexCoord[1] = (float) Rect->right / (float) This->pow2Width;
2013 glTexCoord[3] = (float) Rect->bottom / (float) This->pow2Height;
2014
2015 return TRUE;
2016 } else {
2017 /* Check if we can succeed at all */
2018 if( (x2 - x1) > maxSize ||
2019 (y2 - y1) > maxSize ) {
2020 TRACE("Requested rectangle is too large for gl\n");
2021 return FALSE;
2022 }
2023
2024 /* A part of the texture has to be picked. First, check if
2025 * some texture part is loaded already, if yes try to re-use it.
2026 * If the texture is dirty, or the part can't be used,
2027 * re-position the part to load
2028 */
2029 if(!(This->Flags & SFLAG_DIRTY)) {
2030 if(This->glRect.left <= x1 && This->glRect.right >= x2 &&
2031 This->glRect.top <= y1 && This->glRect.bottom >= x2 ) {
2032 /* Ok, the rectangle is ok, re-use it */
2033 TRACE("Using existing gl Texture\n");
2034 } else {
2035 /* Rectangle is not ok, dirtify the texture to reload it */
2036 TRACE("Dirtifying texture to force reload\n");
2037 This->Flags |= SFLAG_DIRTY;
2038 }
2039 }
2040
2041 /* Now if we are dirty(no else if!) */
2042 if(This->Flags & SFLAG_DIRTY) {
2043 /* Set the new rectangle. Use the following strategy:
2044 * 1) Use as big textures as possible.
2045 * 2) Place the texture part in the way that the requested
2046 * part is in the middle of the texture(well, almost)
2047 * 3) If the texture is moved over the edges of the
2048 * surface, replace it nicely
2049 * 4) If the coord is not limiting the texture size,
2050 * use the whole size
2051 */
2052 if((This->pow2Width) > maxSize) {
2053 This->glRect.left = x1 - maxSize / 2;
2054 if(This->glRect.left < 0) {
2055 This->glRect.left = 0;
2056 }
2057 This->glRect.right = This->glRect.left + maxSize;
2058 if(This->glRect.right > This->currentDesc.Width) {
2059 This->glRect.right = This->currentDesc.Width;
2060 This->glRect.left = This->glRect.right - maxSize;
2061 }
2062 } else {
2063 This->glRect.left = 0;
2064 This->glRect.right = This->pow2Width;
2065 }
2066
2067 if(This->pow2Height > maxSize) {
2068 This->glRect.top = x1 - GL_LIMITS(texture_size) / 2;
2069 if(This->glRect.top < 0) This->glRect.top = 0;
2070 This->glRect.bottom = This->glRect.left + maxSize;
2071 if(This->glRect.bottom > This->currentDesc.Height) {
2072 This->glRect.bottom = This->currentDesc.Height;
2073 This->glRect.top = This->glRect.bottom - maxSize;
2074 }
2075 } else {
2076 This->glRect.top = 0;
2077 This->glRect.bottom = This->pow2Height;
2078 }
2079 TRACE("(%p): Using rect (%ld,%ld)-(%ld,%ld)\n", This,
2080 This->glRect.left, This->glRect.top, This->glRect.right, This->glRect.bottom);
2081 }
2082
2083 /* Re-calculate the rect to draw */
2084 Rect->left -= This->glRect.left;
2085 Rect->right -= This->glRect.left;
2086 Rect->top -= This->glRect.top;
2087 Rect->bottom -= This->glRect.top;
2088
2089 /* Get the gl coordinates. The gl rectangle is a power of 2, eigher the max size,
2090 * or the pow2Width / pow2Height of the surface
2091 */
2092 glTexCoord[0] = (float) Rect->left / (float) (This->glRect.right - This->glRect.left);
2093 glTexCoord[2] = (float) Rect->top / (float) (This->glRect.bottom - This->glRect.top);
2094 glTexCoord[1] = (float) Rect->right / (float) (This->glRect.right - This->glRect.left);
2095 glTexCoord[3] = (float) Rect->bottom / (float) (This->glRect.bottom - This->glRect.top);
2096 }
2097 return TRUE;
2098 }
2099 #undef GLINFO_LOCATION
Maarten's multimedia branch