?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 0e883ac4a03c91e56787e1ec12e001b6558b4b62
[wine/hacks.git] / dlls / wined3d / ati_fragment_shader.c
blobe6b43d8db0ad301ba658565987df7e0a6a79d3ba
1 /*
2 * Fixed function pipeline replacement using GL_ATI_fragment_shader
3 *
4 * Copyright 2008 Stefan Dösinger(for CodeWeavers)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22
23 #include <math.h>
24 #include <stdio.h>
25
26 #include "wined3d_private.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
29
30 /* Some private defines, Constant associations, etc.
31 * Env bump matrix and per stage constant should be independent,
32 * a stage that bump maps can't read the per state constant
33 */
34 #define ATI_FFP_CONST_BUMPMAT(i) (GL_CON_0_ATI + i)
35 #define ATI_FFP_CONST_CONSTANT0 GL_CON_0_ATI
36 #define ATI_FFP_CONST_CONSTANT1 GL_CON_1_ATI
37 #define ATI_FFP_CONST_CONSTANT2 GL_CON_2_ATI
38 #define ATI_FFP_CONST_CONSTANT3 GL_CON_3_ATI
39 #define ATI_FFP_CONST_CONSTANT4 GL_CON_4_ATI
40 #define ATI_FFP_CONST_CONSTANT5 GL_CON_5_ATI
41 #define ATI_FFP_CONST_TFACTOR GL_CON_6_ATI
42
43 /* GL_ATI_fragment_shader specific fixed function pipeline description. "Inherits" from the common one */
44 struct atifs_ffp_desc
45 {
46 struct ffp_desc parent;
47 GLuint shader;
48 unsigned int num_textures_used;
49 };
50
51 struct atifs_private_data
52 {
53 hash_table_t *fragment_shaders; /* A hashtable to track fragment pipeline replacement shaders */
54
55 };
56
57 static const char *debug_dstmod(GLuint mod) {
58 switch(mod) {
59 case GL_NONE: return "GL_NONE";
60 case GL_2X_BIT_ATI: return "GL_2X_BIT_ATI";
61 case GL_4X_BIT_ATI: return "GL_4X_BIT_ATI";
62 case GL_8X_BIT_ATI: return "GL_8X_BIT_ATI";
63 case GL_HALF_BIT_ATI: return "GL_HALF_BIT_ATI";
64 case GL_QUARTER_BIT_ATI: return "GL_QUARTER_BIT_ATI";
65 case GL_EIGHTH_BIT_ATI: return "GL_EIGHTH_BIT_ATI";
66 case GL_SATURATE_BIT_ATI: return "GL_SATURATE_BIT_ATI";
67 default: return "Unexpected modifier\n";
68 }
69 }
70
71 static const char *debug_argmod(GLuint mod) {
72 switch(mod) {
73 case GL_NONE:
74 return "GL_NONE";
75
76 case GL_2X_BIT_ATI:
77 return "GL_2X_BIT_ATI";
78 case GL_COMP_BIT_ATI:
79 return "GL_COMP_BIT_ATI";
80 case GL_NEGATE_BIT_ATI:
81 return "GL_NEGATE_BIT_ATI";
82 case GL_BIAS_BIT_ATI:
83 return "GL_BIAS_BIT_ATI";
84
85 case GL_2X_BIT_ATI | GL_COMP_BIT_ATI:
86 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI";
87 case GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI:
88 return "GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI";
89 case GL_2X_BIT_ATI | GL_BIAS_BIT_ATI:
90 return "GL_2X_BIT_ATI | GL_BIAS_BIT_ATI";
91 case GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI:
92 return "GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI";
93 case GL_COMP_BIT_ATI | GL_BIAS_BIT_ATI:
94 return "GL_COMP_BIT_ATI | GL_BIAS_BIT_ATI";
95 case GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI:
96 return "GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
97
98 case GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI:
99 return "GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
100 case GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI:
101 return "GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
102 case GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_BIAS_BIT_ATI:
103 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_BIAS_BIT_ATI";
104 case GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI:
105 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI";
106
107 case GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI:
108 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
109
110 default:
111 return "Unexpected argmod combination\n";
112 }
113 }
114 static const char *debug_register(GLuint reg) {
115 switch(reg) {
116 case GL_REG_0_ATI: return "GL_REG_0_ATI";
117 case GL_REG_1_ATI: return "GL_REG_1_ATI";
118 case GL_REG_2_ATI: return "GL_REG_2_ATI";
119 case GL_REG_3_ATI: return "GL_REG_3_ATI";
120 case GL_REG_4_ATI: return "GL_REG_4_ATI";
121 case GL_REG_5_ATI: return "GL_REG_5_ATI";
122
123 case GL_CON_0_ATI: return "GL_CON_0_ATI";
124 case GL_CON_1_ATI: return "GL_CON_1_ATI";
125 case GL_CON_2_ATI: return "GL_CON_2_ATI";
126 case GL_CON_3_ATI: return "GL_CON_3_ATI";
127 case GL_CON_4_ATI: return "GL_CON_4_ATI";
128 case GL_CON_5_ATI: return "GL_CON_5_ATI";
129 case GL_CON_6_ATI: return "GL_CON_6_ATI";
130 case GL_CON_7_ATI: return "GL_CON_7_ATI";
131
132 case GL_ZERO: return "GL_ZERO";
133 case GL_ONE: return "GL_ONE";
134 case GL_PRIMARY_COLOR: return "GL_PRIMARY_COLOR";
135 case GL_SECONDARY_INTERPOLATOR_ATI: return "GL_SECONDARY_INTERPOLATOR_ATI";
136
137 default: return "Unknown register\n";
138 }
139 }
140
141 static const char *debug_swizzle(GLuint swizzle) {
142 switch(swizzle) {
143 case GL_SWIZZLE_STR_ATI: return "GL_SWIZZLE_STR_ATI";
144 case GL_SWIZZLE_STQ_ATI: return "GL_SWIZZLE_STQ_ATI";
145 case GL_SWIZZLE_STR_DR_ATI: return "GL_SWIZZLE_STR_DR_ATI";
146 case GL_SWIZZLE_STQ_DQ_ATI: return "GL_SWIZZLE_STQ_DQ_ATI";
147 default: return "unknown swizzle";
148 }
149 }
150
151 #define GLINFO_LOCATION (*gl_info)
152 static GLuint register_for_arg(DWORD arg, WineD3D_GL_Info *gl_info, unsigned int stage, GLuint *mod, GLuint tmparg) {
153 GLenum ret;
154
155 if(mod) *mod = GL_NONE;
156 if(arg == ARG_UNUSED) return -1; /* This is the marker for unused registers */
157
158 switch(arg & WINED3DTA_SELECTMASK) {
159 case WINED3DTA_DIFFUSE:
160 ret = GL_PRIMARY_COLOR;
161 break;
162
163 case WINED3DTA_CURRENT:
164 /* Note that using GL_REG_0_ATI for the passed on register is safe because
165 * texture0 is read at stage0, so in the worst case it is read in the
166 * instruction writing to reg0. Afterwards texture0 is not used any longer.
167 * If we're reading from current
168 */
169 if(stage == 0) {
170 ret = GL_PRIMARY_COLOR;
171 } else {
172 ret = GL_REG_0_ATI;
173 }
174 break;
175
176 case WINED3DTA_TEXTURE:
177 ret = GL_REG_0_ATI + stage;
178 break;
179
180 case WINED3DTA_TFACTOR:
181 ret = ATI_FFP_CONST_TFACTOR;
182 break;
183
184 case WINED3DTA_SPECULAR:
185 ret = GL_SECONDARY_INTERPOLATOR_ATI;
186 break;
187
188 case WINED3DTA_TEMP:
189 ret = tmparg;
190 break;
191
192 case WINED3DTA_CONSTANT:
193 FIXME("Unhandled source argument WINED3DTA_TEMP\n");
194 ret = GL_CON_0_ATI;
195 break;
196
197 default:
198 FIXME("Unknown source argument %d\n", arg);
199 ret = GL_ZERO;
200 }
201
202 if(arg & WINED3DTA_COMPLEMENT) {
203 if(mod) *mod |= GL_COMP_BIT_ATI;
204 }
205 if(arg & WINED3DTA_ALPHAREPLICATE) {
206 FIXME("Unhandled read modifier WINED3DTA_ALPHAREPLICATE\n");
207 }
208 return ret;
209 }
210
211 static GLuint find_tmpreg(struct texture_stage_op op[MAX_TEXTURES]) {
212 int lowest_read = -1;
213 int lowest_write = -1;
214 int i;
215 BOOL tex_used[MAX_TEXTURES];
216
217 memset(tex_used, 0, sizeof(tex_used));
218 for(i = 0; i < MAX_TEXTURES; i++) {
219 if(op[i].cop == WINED3DTOP_DISABLE) {
220 break;
221 }
222
223 if(lowest_read == -1 &&
224 (op[i].carg1 == WINED3DTA_TEMP || op[i].carg2 == WINED3DTA_TEMP || op[i].carg0 == WINED3DTA_TEMP ||
225 op[i].aarg1 == WINED3DTA_TEMP || op[i].aarg2 == WINED3DTA_TEMP || op[i].aarg0 == WINED3DTA_TEMP)) {
226 lowest_read = i;
227 }
228
229 if(lowest_write == -1 && op[i].dst == tempreg) {
230 lowest_write = i;
231 }
232
233 if(op[i].carg1 == WINED3DTA_TEXTURE || op[i].carg2 == WINED3DTA_TEXTURE || op[i].carg0 == WINED3DTA_TEXTURE ||
234 op[i].aarg1 == WINED3DTA_TEXTURE || op[i].aarg2 == WINED3DTA_TEXTURE || op[i].aarg0 == WINED3DTA_TEXTURE) {
235 tex_used[i] = TRUE;
236 }
237 }
238
239 /* Temp reg not read? We don't need it, return GL_NONE */
240 if(lowest_read == -1) return GL_NONE;
241
242 if(lowest_write >= lowest_read) {
243 FIXME("Temp register read before being written\n");
244 }
245
246 if(lowest_write == -1) {
247 /* This needs a test. Maybe we are supposed to return 0.0/0.0/0.0/0.0, or fail drawprim, or whatever */
248 FIXME("Temp register read without being written\n");
249 return GL_REG_1_ATI;
250 } else if(lowest_write >= 1) {
251 /* If we're writing to the temp reg at earliest in stage 1, we can use register 1 for the temp result.
252 * there may be texture data stored in reg 1, but we do not need it any longer since stage 1 already
253 * read it
254 */
255 return GL_REG_1_ATI;
256 } else {
257 /* Search for a free texture register. We have 6 registers available. GL_REG_0_ATI is already used
258 * for the regular result
259 */
260 for(i = 1; i < 6; i++) {
261 if(!tex_used[i]) {
262 return GL_REG_0_ATI + i;
263 }
264 }
265 /* What to do here? Report it in ValidateDevice? */
266 FIXME("Could not find a register for the temporary register\n");
267 return 0;
268 }
269 }
270
271 static GLuint gen_ati_shader(struct texture_stage_op op[MAX_TEXTURES], WineD3D_GL_Info *gl_info) {
272 GLuint ret = GL_EXTCALL(glGenFragmentShadersATI(1));
273 unsigned int stage;
274 GLuint arg0, arg1, arg2, extrarg;
275 GLuint dstmod, argmod0, argmod1, argmod2, argmodextra;
276 GLuint swizzle;
277 GLuint tmparg = find_tmpreg(op);
278 GLuint dstreg;
279
280 if(!ret) {
281 ERR("Failed to generate a GL_ATI_fragment_shader shader id\n");
282 return 0;
283 }
284 GL_EXTCALL(glBindFragmentShaderATI(ret));
285 checkGLcall("GL_EXTCALL(glBindFragmentShaderATI(ret))");
286
287 TRACE("glBeginFragmentShaderATI()\n");
288 GL_EXTCALL(glBeginFragmentShaderATI());
289 checkGLcall("GL_EXTCALL(glBeginFragmentShaderATI())");
290
291 /* Pass 1: Generate sampling instructions for perturbation maps */
292 for(stage = 0; stage < GL_LIMITS(textures); stage++) {
293 if(op[stage].cop == WINED3DTOP_DISABLE) break;
294 if(op[stage].cop != WINED3DTOP_BUMPENVMAP &&
295 op[stage].cop != WINED3DTOP_BUMPENVMAPLUMINANCE) continue;
296
297 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, GL_SWIZZLE_STR_ATI)\n",
298 stage, stage);
299 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI + stage,
300 GL_TEXTURE0_ARB + stage,
301 GL_SWIZZLE_STR_ATI));
302 TRACE("glPassTexCoordATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, GL_SWIZZLE_STR_ATI)\n",
303 stage + 1, stage + 1);
304 GL_EXTCALL(glPassTexCoordATI(GL_REG_0_ATI + stage + 1,
305 GL_TEXTURE0_ARB + stage + 1,
306 GL_SWIZZLE_STR_ATI));
307
308 /* We need GL_REG_5_ATI as a temporary register to swizzle the bump matrix. So we run into
309 * issues if we're bump mapping on stage 4 or 5
310 */
311 if(stage >= 4) {
312 FIXME("Bump mapping in stage %d\n", stage);
313 }
314 }
315
316 /* Pass 2: Generate perturbation calculations */
317 for(stage = 0; stage < GL_LIMITS(textures); stage++) {
318 if(op[stage].cop == WINED3DTOP_DISABLE) break;
319 if(op[stage].cop != WINED3DTOP_BUMPENVMAP &&
320 op[stage].cop != WINED3DTOP_BUMPENVMAPLUMINANCE) continue;
321
322 /* Nice thing, we get the color correction for free :-) */
323 if(op[stage].color_correction == WINED3DFMT_V8U8) {
324 argmodextra = GL_2X_BIT_ATI | GL_BIAS_BIT_ATI;
325 } else {
326 argmodextra = 0;
327 }
328
329 TRACE("glColorFragmentOp3ATI(GL_DOT2_ADD_ATI, GL_REG_%d_ATI, GL_RED_BIT_ATI, GL_NONE, GL_REG_%d_ATI, GL_NONE, %s, ATI_FFP_CONST_BUMPMAT(%d), GL_NONE, GL_NONE, GL_REG_%d_ATI, GL_RED, GL_NONE)\n",
330 stage + 1, stage, debug_argmod(argmodextra), stage, stage + 1);
331 GL_EXTCALL(glColorFragmentOp3ATI(GL_DOT2_ADD_ATI, GL_REG_0_ATI + stage + 1, GL_RED_BIT_ATI, GL_NONE,
332 GL_REG_0_ATI + stage, GL_NONE, argmodextra,
333 ATI_FFP_CONST_BUMPMAT(stage), GL_NONE, GL_2X_BIT_ATI | GL_BIAS_BIT_ATI,
334 GL_REG_0_ATI + stage + 1, GL_RED, GL_NONE));
335
336 /* FIXME: How can I make GL_DOT2_ADD_ATI read the factors from blue and alpha? It defaults to red and green,
337 * and it is fairly easy to make it read GL_BLUE or BL_ALPHA, but I can't get an R * B + G * A. So we're wasting
338 * one register and two instructions in this pass for a simple swizzling operation.
339 * For starters it might be good enough to merge the two movs into one, but even that isn't possible :-(
340 *
341 * NOTE: GL_BLUE | GL_ALPHA is not possible. It doesn't throw a compilation error, but an OR operation on the
342 * constants doesn't make sense, considering their values.
343 */
344 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_5_ATI, GL_RED_BIT_ATI, GL_NONE, ATI_FFP_CONST_BUMPMAT(%d), GL_BLUE, GL_NONE)\n", stage);
345 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_5_ATI, GL_RED_BIT_ATI, GL_NONE,
346 ATI_FFP_CONST_BUMPMAT(stage), GL_BLUE, GL_NONE));
347 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_5_ATI, GL_GREEN_BIT_ATI, GL_NONE, ATI_FFP_CONST_BUMPMAT(%d), GL_ALPHA, GL_NONE)\n", stage);
348 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_5_ATI, GL_GREEN_BIT_ATI, GL_NONE,
349 ATI_FFP_CONST_BUMPMAT(stage), GL_ALPHA, GL_NONE));
350 TRACE("glColorFragmentOp3ATI(GL_DOT2_ADD_ATI, GL_REG_%d_ATI, GL_GREEN_BIT_ATI, GL_NONE, GL_REG_%d_ATI, GL_NONE, %s, GL_REG_5_ATI, GL_NONE, GL_NONE, GL_REG_%d_ATI, GL_GREEN, GL_NONE)\n",
351 stage + 1, stage, debug_argmod(argmodextra), stage + 1);
352 GL_EXTCALL(glColorFragmentOp3ATI(GL_DOT2_ADD_ATI, GL_REG_0_ATI + stage + 1, GL_GREEN_BIT_ATI, GL_NONE,
353 GL_REG_0_ATI + stage, GL_NONE, argmodextra,
354 GL_REG_5_ATI, GL_NONE, GL_2X_BIT_ATI | GL_BIAS_BIT_ATI,
355 GL_REG_0_ATI + stage + 1, GL_GREEN, GL_NONE));
356 }
357
358 /* Pass 3: Generate sampling instructions for regular textures */
359 for(stage = 0; stage < GL_LIMITS(textures); stage++) {
360 if(op[stage].cop == WINED3DTOP_DISABLE) {
361 break;
362 }
363
364 if(op[stage].projected == proj_none) {
365 swizzle = GL_SWIZZLE_STR_ATI;
366 } else if(op[stage].projected == proj_count3) {
367 /* TODO: D3DTTFF_COUNT3 | D3DTTFF_PROJECTED would be GL_SWIZZLE_STR_DR_ATI.
368 * However, the FFP vertex processing texture transform matrix handler does
369 * some transformations in the texture matrix which makes the 3rd coordinate
370 * arrive in Q, not R in that case. This is needed for opengl fixed function
371 * fragment processing which always divides by Q. In this backend we can
372 * handle that properly and be compatible with vertex shader output and avoid
373 * side effects of the texture matrix games
374 */
375 swizzle = GL_SWIZZLE_STQ_DQ_ATI;
376 } else {
377 swizzle = GL_SWIZZLE_STQ_DQ_ATI;
378 }
379
380 if((op[stage].carg0 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
381 (op[stage].carg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
382 (op[stage].carg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
383 (op[stage].aarg0 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
384 (op[stage].aarg1 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
385 (op[stage].aarg2 & WINED3DTA_SELECTMASK) == WINED3DTA_TEXTURE ||
386 op[stage].cop == WINED3DTOP_BLENDTEXTUREALPHA) {
387
388 if(stage > 0 &&
389 (op[stage - 1].cop == WINED3DTOP_BUMPENVMAP ||
390 op[stage - 1].cop == WINED3DTOP_BUMPENVMAPLUMINANCE)) {
391 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_REG_%d_ATI, GL_SWIZZLE_STR_ATI)\n",
392 stage, stage);
393 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI + stage,
394 GL_REG_0_ATI + stage,
395 GL_SWIZZLE_STR_ATI));
396 } else {
397 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, %s)\n",
398 stage, stage, debug_swizzle(swizzle));
399 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI + stage,
400 GL_TEXTURE0_ARB + stage,
401 swizzle));
402 }
403 }
404 }
405
406 /* Pass 4: Generate the arithmetic instructions */
407 for(stage = 0; stage < MAX_TEXTURES; stage++) {
408 if(op[stage].cop == WINED3DTOP_DISABLE) {
409 if(stage == 0) {
410 /* Handle complete texture disabling gracefully */
411 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
412 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE,
413 GL_PRIMARY_COLOR, GL_NONE, GL_NONE));
414 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
415 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE,
416 GL_PRIMARY_COLOR, GL_NONE, GL_NONE));
417 }
418 break;
419 }
420
421 if(op[stage].dst == tempreg) {
422 /* If we're writing to D3DTA_TEMP, but never reading from it we don't have to write there in the first place.
423 * skip the entire stage, this saves some GPU time
424 */
425 if(tmparg == GL_NONE) continue;
426
427 dstreg = tmparg;
428 } else {
429 dstreg = GL_REG_0_ATI;
430 }
431
432 arg0 = register_for_arg(op[stage].carg0, gl_info, stage, &argmod0, tmparg);
433 arg1 = register_for_arg(op[stage].carg1, gl_info, stage, &argmod1, tmparg);
434 arg2 = register_for_arg(op[stage].carg2, gl_info, stage, &argmod2, tmparg);
435 dstmod = GL_NONE;
436 argmodextra = GL_NONE;
437 extrarg = GL_NONE;
438
439 switch(op[stage].cop) {
440 case WINED3DTOP_SELECTARG2:
441 arg1 = arg2;
442 argmod1 = argmod2;
443 case WINED3DTOP_SELECTARG1:
444 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s)\n",
445 debug_register(dstreg), debug_register(arg1), debug_argmod(argmod1));
446 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI, dstreg, GL_NONE, GL_NONE,
447 arg1, GL_NONE, argmod1));
448 break;
449
450 case WINED3DTOP_MODULATE4X:
451 if(dstmod == GL_NONE) dstmod = GL_4X_BIT_ATI;
452 case WINED3DTOP_MODULATE2X:
453 if(dstmod == GL_NONE) dstmod = GL_2X_BIT_ATI;
454 dstmod |= GL_SATURATE_BIT_ATI;
455 case WINED3DTOP_MODULATE:
456 TRACE("glColorFragmentOp2ATI(GL_MUL_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
457 debug_register(dstreg), debug_dstmod(dstmod),
458 debug_register(arg1), debug_argmod(argmod1),
459 debug_register(arg2), debug_argmod(argmod2));
460 GL_EXTCALL(glColorFragmentOp2ATI(GL_MUL_ATI, dstreg, GL_NONE, dstmod,
461 arg1, GL_NONE, argmod1,
462 arg2, GL_NONE, argmod2));
463 break;
464
465 case WINED3DTOP_ADDSIGNED2X:
466 dstmod = GL_2X_BIT_ATI;
467 case WINED3DTOP_ADDSIGNED:
468 argmodextra = GL_BIAS_BIT_ATI;
469 case WINED3DTOP_ADD:
470 dstmod |= GL_SATURATE_BIT_ATI;
471 TRACE("glColorFragmentOp2ATI(GL_ADD_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
472 debug_register(dstreg), debug_dstmod(dstmod),
473 debug_register(arg1), debug_argmod(argmod1),
474 debug_register(arg2), debug_argmod(argmodextra | argmod2));
475 GL_EXTCALL(glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, dstmod,
476 arg1, GL_NONE, argmod1,
477 arg2, GL_NONE, argmodextra | argmod2));
478 break;
479
480 case WINED3DTOP_SUBTRACT:
481 dstmod |= GL_SATURATE_BIT_ATI;
482 TRACE("glColorFragmentOp2ATI(GL_SUB_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
483 debug_register(dstreg), debug_dstmod(dstmod),
484 debug_register(arg1), debug_argmod(argmod1),
485 debug_register(arg2), debug_argmod(argmod2));
486 GL_EXTCALL(glColorFragmentOp2ATI(GL_SUB_ATI, dstreg, GL_NONE, dstmod,
487 arg1, GL_NONE, argmod1,
488 arg2, GL_NONE, argmod2));
489 break;
490
491 case WINED3DTOP_ADDSMOOTH:
492 argmodextra = argmod1 & GL_COMP_BIT_ATI ? argmod1 & ~GL_COMP_BIT_ATI : argmod1 | GL_COMP_BIT_ATI;
493 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
494 debug_register(dstreg),
495 debug_register(arg2), debug_argmod(argmod2),
496 debug_register(arg1), debug_argmod(argmodextra),
497 debug_register(arg1), debug_argmod(argmod1));
498 /* Dst = arg1 + * arg2(1 -arg 1)
499 * = arg2 * (1 - arg1) + arg1
500 */
501 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI, dstreg, GL_NONE, GL_SATURATE_BIT_ATI,
502 arg2, GL_NONE, argmod2,
503 arg1, GL_NONE, argmodextra,
504 arg1, GL_NONE, argmod1));
505 break;
506
507 case WINED3DTOP_BLENDCURRENTALPHA:
508 if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_CURRENT, gl_info, stage, NULL, -1);
509 case WINED3DTOP_BLENDFACTORALPHA:
510 if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_TFACTOR, gl_info, stage, NULL, -1);
511 case WINED3DTOP_BLENDTEXTUREALPHA:
512 if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, -1);
513 case WINED3DTOP_BLENDDIFFUSEALPHA:
514 if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_DIFFUSE, gl_info, stage, NULL, -1);
515 TRACE("glColorFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, GL_NONE, %s, GL_ALPHA, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
516 debug_register(dstreg),
517 debug_register(extrarg),
518 debug_register(arg1), debug_argmod(argmod1),
519 debug_register(arg2), debug_argmod(argmod2));
520 GL_EXTCALL(glColorFragmentOp3ATI(GL_LERP_ATI, dstreg, GL_NONE, GL_NONE,
521 extrarg, GL_ALPHA, GL_NONE,
522 arg1, GL_NONE, argmod1,
523 arg2, GL_NONE, argmod2));
524 break;
525
526 case WINED3DTOP_BLENDTEXTUREALPHAPM:
527 arg0 = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, -1);
528 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s, %s, GL_ALPHA, GL_COMP_BIT_ATI, %s, GL_NONE, %s)\n",
529 debug_register(dstreg),
530 debug_register(arg2), debug_argmod(argmod2),
531 debug_register(arg0),
532 debug_register(arg1), debug_argmod(argmod1));
533 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI, dstreg, GL_NONE, GL_NONE,
534 arg2, GL_NONE, argmod2,
535 arg0, GL_ALPHA, GL_COMP_BIT_ATI,
536 arg1, GL_NONE, argmod1));
537 break;
538
539 /* D3DTOP_PREMODULATE ???? */
540
541 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
542 argmodextra = argmod1 & GL_COMP_BIT_ATI ? argmod1 & ~GL_COMP_BIT_ATI : argmod1 | GL_COMP_BIT_ATI;
543 case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
544 if(!argmodextra) argmodextra = argmod1;
545 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_ALPHA, %s, %s, GL_NONE, %s)\n",
546 debug_register(dstreg),
547 debug_register(arg2), debug_argmod(argmod2),
548 debug_register(arg1), debug_argmod(argmodextra), debug_register(arg1), debug_argmod(arg1));
549 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI, dstreg, GL_NONE, GL_SATURATE_BIT_ATI,
550 arg2, GL_NONE, argmod2,
551 arg1, GL_ALPHA, argmodextra,
552 arg1, GL_NONE, argmod1));
553 break;
554
555 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
556 argmodextra = argmod1 & GL_COMP_BIT_ATI ? argmod1 & ~GL_COMP_BIT_ATI : argmod1 | GL_COMP_BIT_ATI;
557 case WINED3DTOP_MODULATECOLOR_ADDALPHA:
558 if(!argmodextra) argmodextra = argmod1;
559 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_ALPHA, %s)\n",
560 debug_register(dstreg),
561 debug_register(arg2), debug_argmod(argmod2),
562 debug_register(arg1), debug_argmod(argmodextra),
563 debug_register(arg1), debug_argmod(argmod1));
564 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI, dstreg, GL_NONE, GL_SATURATE_BIT_ATI,
565 arg2, GL_NONE, argmod2,
566 arg1, GL_NONE, argmodextra,
567 arg1, GL_ALPHA, argmod1));
568 break;
569
570 case WINED3DTOP_DOTPRODUCT3:
571 TRACE("glColorFragmentOp2ATI(GL_DOT3_ATI, %s, GL_NONE, GL_4X_BIT_ATI | GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
572 debug_register(dstreg),
573 debug_register(arg1), debug_argmod(argmod1 | GL_BIAS_BIT_ATI),
574 debug_register(arg2), debug_argmod(argmod2 | GL_BIAS_BIT_ATI));
575 GL_EXTCALL(glColorFragmentOp2ATI(GL_DOT3_ATI, dstreg, GL_NONE, GL_4X_BIT_ATI | GL_SATURATE_BIT_ATI,
576 arg1, GL_NONE, argmod1 | GL_BIAS_BIT_ATI,
577 arg2, GL_NONE, argmod2 | GL_BIAS_BIT_ATI));
578 break;
579
580 case WINED3DTOP_MULTIPLYADD:
581 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
582 debug_register(dstreg),
583 debug_register(arg1), debug_argmod(argmod1),
584 debug_register(arg2), debug_argmod(argmod2),
585 debug_register(arg0), debug_argmod(argmod0));
586 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI, dstreg, GL_NONE, GL_SATURATE_BIT_ATI,
587 arg1, GL_NONE, argmod1,
588 arg2, GL_NONE, argmod2,
589 arg0, GL_NONE, argmod0));
590 break;
591
592 case WINED3DTOP_LERP:
593 TRACE("glColorFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
594 debug_register(dstreg),
595 debug_register(arg1), debug_argmod(argmod1),
596 debug_register(arg2), debug_argmod(argmod2),
597 debug_register(arg0), debug_argmod(argmod0));
598 GL_EXTCALL(glColorFragmentOp3ATI(GL_LERP_ATI, dstreg, GL_NONE, GL_NONE,
599 arg0, GL_NONE, argmod0,
600 arg1, GL_NONE, argmod1,
601 arg2, GL_NONE, argmod2));
602 break;
603
604 case WINED3DTOP_BUMPENVMAP:
605 case WINED3DTOP_BUMPENVMAPLUMINANCE:
606 /* Those are handled in the first pass of the shader(generation pass 1 and 2) already */
607 break;
608
609 default: FIXME("Unhandled color operation %d on stage %d\n", op[stage].cop, stage);
610 }
611
612 arg0 = register_for_arg(op[stage].aarg0, gl_info, stage, &argmod0, tmparg);
613 arg1 = register_for_arg(op[stage].aarg1, gl_info, stage, &argmod1, tmparg);
614 arg2 = register_for_arg(op[stage].aarg2, gl_info, stage, &argmod2, tmparg);
615 dstmod = GL_NONE;
616 argmodextra = GL_NONE;
617 extrarg = GL_NONE;
618
619 switch(op[stage].aop) {
620 case WINED3DTOP_DISABLE:
621 /* Get the primary color to the output if on stage 0, otherwise leave register 0 untouched */
622 if(stage == 0) {
623 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
624 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE,
625 GL_PRIMARY_COLOR, GL_NONE, GL_NONE));
626 }
627 break;
628
629 case WINED3DTOP_SELECTARG2:
630 arg1 = arg2;
631 argmod1 = argmod2;
632 case WINED3DTOP_SELECTARG1:
633 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, %s, GL_NONE, %s, GL_NONE, %s)\n",
634 debug_register(dstreg),
635 debug_register(arg1), debug_argmod(argmod1));
636 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI, dstreg, GL_NONE,
637 arg1, GL_NONE, argmod1));
638 break;
639
640 case WINED3DTOP_MODULATE4X:
641 if(dstmod == GL_NONE) dstmod = GL_4X_BIT_ATI;
642 case WINED3DTOP_MODULATE2X:
643 if(dstmod == GL_NONE) dstmod = GL_2X_BIT_ATI;
644 dstmod |= GL_SATURATE_BIT_ATI;
645 case WINED3DTOP_MODULATE:
646 TRACE("glAlphaFragmentOp2ATI(GL_MUL_ATI, %s, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
647 debug_register(dstreg), debug_dstmod(dstmod),
648 debug_register(arg1), debug_argmod(argmod1),
649 debug_register(arg2), debug_argmod(argmod2));
650 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_MUL_ATI, dstreg, dstmod,
651 arg1, GL_NONE, argmod1,
652 arg2, GL_NONE, argmod2));
653 break;
654
655 case WINED3DTOP_ADDSIGNED2X:
656 dstmod = GL_2X_BIT_ATI;
657 case WINED3DTOP_ADDSIGNED:
658 argmodextra = GL_BIAS_BIT_ATI;
659 case WINED3DTOP_ADD:
660 dstmod |= GL_SATURATE_BIT_ATI;
661 TRACE("glAlphaFragmentOp2ATI(GL_ADD_ATI, %s, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
662 debug_register(dstreg), debug_dstmod(dstmod),
663 debug_register(arg1), debug_argmod(argmod1),
664 debug_register(arg2), debug_argmod(argmodextra | argmod2));
665 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_ADD_ATI, dstreg, dstmod,
666 arg1, GL_NONE, argmod1,
667 arg2, GL_NONE, argmodextra | argmod2));
668 break;
669
670 case WINED3DTOP_SUBTRACT:
671 dstmod |= GL_SATURATE_BIT_ATI;
672 TRACE("glAlphaFragmentOp2ATI(GL_SUB_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
673 debug_register(dstreg), debug_dstmod(dstmod),
674 debug_register(arg1), debug_argmod(argmod1),
675 debug_register(arg2), debug_argmod(argmod2));
676 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_SUB_ATI, dstreg, dstmod,
677 arg1, GL_NONE, argmod1,
678 arg2, GL_NONE, argmod2));
679 break;
680
681 case WINED3DTOP_ADDSMOOTH:
682 argmodextra = argmod1 & GL_COMP_BIT_ATI ? argmod1 & ~GL_COMP_BIT_ATI : argmod1 | GL_COMP_BIT_ATI;
683 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
684 debug_register(dstreg),
685 debug_register(arg2), debug_argmod(argmod2),
686 debug_register(arg1), debug_argmod(argmodextra),
687 debug_register(arg1), debug_argmod(argmod1));
688 /* Dst = arg1 + * arg2(1 -arg 1)
689 * = arg2 * (1 - arg1) + arg1
690 */
691 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI, dstreg, GL_SATURATE_BIT_ATI,
692 arg2, GL_NONE, argmod2,
693 arg1, GL_NONE, argmodextra,
694 arg1, GL_NONE, argmod1));
695 break;
696
697 case WINED3DTOP_BLENDCURRENTALPHA:
698 if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_CURRENT, gl_info, stage, NULL, -1);
699 case WINED3DTOP_BLENDFACTORALPHA:
700 if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_TFACTOR, gl_info, stage, NULL, -1);
701 case WINED3DTOP_BLENDTEXTUREALPHA:
702 if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, -1);
703 case WINED3DTOP_BLENDDIFFUSEALPHA:
704 if(extrarg == GL_NONE) extrarg = register_for_arg(WINED3DTA_DIFFUSE, gl_info, stage, NULL, -1);
705 TRACE("glAlphaFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, %s, GL_ALPHA, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
706 debug_register(dstreg),
707 debug_register(extrarg),
708 debug_register(arg1), debug_argmod(argmod1),
709 debug_register(arg2), debug_argmod(argmod2));
710 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_LERP_ATI, dstreg, GL_NONE,
711 extrarg, GL_ALPHA, GL_NONE,
712 arg1, GL_NONE, argmod1,
713 arg2, GL_NONE, argmod2));
714 break;
715
716 case WINED3DTOP_BLENDTEXTUREALPHAPM:
717 arg0 = register_for_arg(WINED3DTA_TEXTURE, gl_info, stage, NULL, -1);
718 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, %s, GL_NONE, %s, %s, GL_ALPHA, GL_COMP_BIT_ATI, %s, GL_NONE, %s)\n",
719 debug_register(dstreg),
720 debug_register(arg2), debug_argmod(argmod2),
721 debug_register(arg0),
722 debug_register(arg1), debug_argmod(argmod1));
723 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI, dstreg, GL_NONE,
724 arg2, GL_NONE, argmod2,
725 arg0, GL_ALPHA, GL_COMP_BIT_ATI,
726 arg1, GL_NONE, argmod1));
727 break;
728
729 /* D3DTOP_PREMODULATE ???? */
730
731 case WINED3DTOP_DOTPRODUCT3:
732 TRACE("glAlphaFragmentOp2ATI(GL_DOT3_ATI, %s, GL_4X_BIT_ATI | GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
733 debug_register(dstreg),
734 debug_register(arg1), debug_argmod(argmod1 | GL_BIAS_BIT_ATI),
735 debug_register(arg2), debug_argmod(argmod2 | GL_BIAS_BIT_ATI));
736 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_DOT3_ATI, dstreg, GL_4X_BIT_ATI | GL_SATURATE_BIT_ATI,
737 arg1, GL_NONE, argmod1 | GL_BIAS_BIT_ATI,
738 arg2, GL_NONE, argmod2 | GL_BIAS_BIT_ATI));
739 break;
740
741 case WINED3DTOP_MULTIPLYADD:
742 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
743 debug_register(dstreg),
744 debug_register(arg1), debug_argmod(argmod1),
745 debug_register(arg2), debug_argmod(argmod2),
746 debug_register(arg0), debug_argmod(argmod0));
747 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI, dstreg, GL_SATURATE_BIT_ATI,
748 arg1, GL_NONE, argmod1,
749 arg2, GL_NONE, argmod2,
750 arg0, GL_NONE, argmod0));
751 break;
752
753 case WINED3DTOP_LERP:
754 TRACE("glAlphaFragmentOp3ATI(GL_LERP_ATI, %s, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
755 debug_register(dstreg),
756 debug_register(arg1), debug_argmod(argmod1),
757 debug_register(arg2), debug_argmod(argmod2),
758 debug_register(arg0), debug_argmod(argmod0));
759 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_LERP_ATI, dstreg, GL_SATURATE_BIT_ATI,
760 arg1, GL_NONE, argmod1,
761 arg2, GL_NONE, argmod2,
762 arg0, GL_NONE, argmod0));
763 break;
764
765 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
766 case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
767 case WINED3DTOP_MODULATECOLOR_ADDALPHA:
768 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
769 case WINED3DTOP_BUMPENVMAP:
770 case WINED3DTOP_BUMPENVMAPLUMINANCE:
771 ERR("Application uses an invalid alpha operation\n");
772 break;
773
774 default: FIXME("Unhandled alpha operation %d on stage %d\n", op[stage].aop, stage);
775 }
776 }
777
778 TRACE("glEndFragmentShaderATI()\n");
779 GL_EXTCALL(glEndFragmentShaderATI());
780 checkGLcall("GL_EXTCALL(glEndFragmentShaderATI())");
781 return ret;
782 }
783 #undef GLINFO_LOCATION
784
785 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
786 static void set_tex_op_atifs(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
787 IWineD3DDeviceImpl *This = stateblock->wineD3DDevice;
788 struct atifs_ffp_desc *desc;
789 struct ffp_settings settings;
790 struct atifs_private_data *priv = (struct atifs_private_data *) This->fragment_priv;
791 DWORD mapped_stage;
792 unsigned int i;
793
794 gen_ffp_op(stateblock, &settings, TRUE);
795 desc = (struct atifs_ffp_desc *) find_ffp_shader(priv->fragment_shaders, &settings);
796 if(!desc) {
797 desc = HeapAlloc(GetProcessHeap(), 0, sizeof(*desc));
798 if(!desc) {
799 ERR("Out of memory\n");
800 return;
801 }
802 desc->num_textures_used = 0;
803 for(i = 0; i < GL_LIMITS(texture_stages); i++) {
804 if(settings.op[i].cop == WINED3DTOP_DISABLE) break;
805 desc->num_textures_used = i;
806 }
807
808 memcpy(&desc->parent.settings, &settings, sizeof(settings));
809 desc->shader = gen_ati_shader(settings.op, &GLINFO_LOCATION);
810 add_ffp_shader(priv->fragment_shaders, &desc->parent);
811 TRACE("Allocated fixed function replacement shader descriptor %p\n", desc);
812 }
813
814 /* GL_ATI_fragment_shader depends on the GL_TEXTURE_xD enable settings. Update the texture stages
815 * used by this shader
816 */
817 for(i = 0; i < desc->num_textures_used; i++) {
818 mapped_stage = This->texUnitMap[i];
819 if(mapped_stage != -1) {
820 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
821 checkGLcall("glActiveTextureARB");
822 texture_activate_dimensions(i, stateblock, context);
823 }
824 }
825
826 GL_EXTCALL(glBindFragmentShaderATI(desc->shader));
827 }
828
829 static void state_texfactor_atifs(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
830 float col[4];
831 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
832
833 GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR, col));
834 checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR, col)");
835 }
836
837 static void set_bumpmat(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
838 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
839 float mat[2][2];
840
841 mat[0][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT00]);
842 mat[1][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT01]);
843 mat[0][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT10]);
844 mat[1][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT11]);
845 /* GL_ATI_fragment_shader allows only constants from 0.0 to 1.0, but the bumpmat
846 * constants can be in any range. While they should stay between [-1.0 and 1.0] because
847 * Shader Model 1.x pixel shaders are clamped to that range negative values are used occasionally,
848 * for example by our d3d9 test. So to get negative values scale -1;1 to 0;1 and undo that in the
849 * shader(it is free). This might potentially reduce precision. However, if the hardware does
850 * support proper floats it shouldn't, and if it doesn't we can't get anything better anyway
851 */
852 mat[0][0] = (mat[0][0] + 1.0) * 0.5;
853 mat[1][0] = (mat[1][0] + 1.0) * 0.5;
854 mat[0][1] = (mat[0][1] + 1.0) * 0.5;
855 mat[1][1] = (mat[1][1] + 1.0) * 0.5;
856 GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_BUMPMAT(stage), (float *) mat));
857 checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_BUMPMAT(stage), mat)");
858 }
859 #undef GLINFO_LOCATION
860
861 static const struct StateEntryTemplate atifs_fragmentstate_template[] = {
862 {STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor_atifs }, 0 },
863 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
864 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
865 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
866 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
867 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
868 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
869 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
870 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
871 {STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
872 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
873 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
874 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
875 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
876 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
877 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
878 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
879 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
880 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
881 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
882 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
883 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
884 {STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
885 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
886 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
887 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
888 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
889 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
890 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
891 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
892 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
893 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
894 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
895 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
896 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
897 {STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
898 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
899 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
900 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
901 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
902 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
903 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
904 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
905 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
906 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
907 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
908 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
909 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
910 {STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
911 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
912 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
913 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
914 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
915 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
916 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
917 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
918 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
919 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
920 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
921 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
922 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
923 {STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
924 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
925 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
926 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
927 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
928 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
929 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
930 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
931 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
932 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
933 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
934 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
935 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
936 {STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
937 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
938 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
939 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
940 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
941 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
942 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
943 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
944 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
945 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
946 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
947 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
948 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
949 {STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
950 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
951 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
952 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
953 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
954 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
955 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
956 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
957 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
958 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
959 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
960 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
961 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
962 {STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), set_tex_op_atifs }, 0 },
963 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
964 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
965 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
966 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), set_bumpmat }, 0 },
967 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, 0 },
968 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, 0 },
969 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, 0 },
970 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim }, 0 },
971 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim }, 0 },
972 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim }, 0 },
973 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim }, 0 },
974 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim }, 0 },
975 {0 /* Terminate */, { 0, 0 }, 0 },
976 };
977
978 static void atifs_enable(IWineD3DDevice *iface, BOOL enable) {
979 if(enable) {
980 glEnable(GL_FRAGMENT_SHADER_ATI);
981 checkGLcall("glEnable(GL_FRAGMENT_SHADER_ATI)");
982 } else {
983 glDisable(GL_FRAGMENT_SHADER_ATI);
984 checkGLcall("glDisable(GL_FRAGMENT_SHADER_ATI)");
985 }
986 }
987
988 static void atifs_get_caps(WINED3DDEVTYPE devtype, WineD3D_GL_Info *gl_info, struct fragment_caps *caps) {
989 caps->TextureOpCaps = WINED3DTEXOPCAPS_DISABLE |
990 WINED3DTEXOPCAPS_SELECTARG1 |
991 WINED3DTEXOPCAPS_SELECTARG2 |
992 WINED3DTEXOPCAPS_MODULATE4X |
993 WINED3DTEXOPCAPS_MODULATE2X |
994 WINED3DTEXOPCAPS_MODULATE |
995 WINED3DTEXOPCAPS_ADDSIGNED2X |
996 WINED3DTEXOPCAPS_ADDSIGNED |
997 WINED3DTEXOPCAPS_ADD |
998 WINED3DTEXOPCAPS_SUBTRACT |
999 WINED3DTEXOPCAPS_ADDSMOOTH |
1000 WINED3DTEXOPCAPS_BLENDCURRENTALPHA |
1001 WINED3DTEXOPCAPS_BLENDFACTORALPHA |
1002 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA |
1003 WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA |
1004 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM |
1005 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
1006 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
1007 WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA |
1008 WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
1009 WINED3DTEXOPCAPS_DOTPRODUCT3 |
1010 WINED3DTEXOPCAPS_MULTIPLYADD |
1011 WINED3DTEXOPCAPS_LERP |
1012 WINED3DTEXOPCAPS_BUMPENVMAP;
1013
1014 /* TODO: Implement WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
1015 and WINED3DTEXOPCAPS_PREMODULATE */
1016
1017 /* GL_ATI_fragment_shader always supports 6 textures, which was the limit on r200 cards
1018 * which this extension is exclusively focused on(later cards have GL_ARB_fragment_program).
1019 * If the current card has more than 8 fixed function textures in OpenGL's regular fixed
1020 * function pipeline then the ATI_fragment_shader backend imposes a stricter limit. This
1021 * shouldn't be too hard since Nvidia cards have a limit of 4 textures with the default ffp
1022 * pipeline, and almost all games are happy with that. We can however support up to 8
1023 * texture stages because we have a 2nd pass limit of 8 instructions, and per stage we use
1024 * only 1 instruction.
1025 *
1026 * The proper fix for this is not to use GL_ATI_fragment_shader on cards newer than the
1027 * r200 series and use an ARB or GLSL shader instead
1028 */
1029 caps->MaxTextureBlendStages = 8;
1030 caps->MaxSimultaneousTextures = 6;
1031
1032 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_TSSARGTEMP;
1033 }
1034
1035 static HRESULT atifs_alloc(IWineD3DDevice *iface) {
1036 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
1037 struct atifs_private_data *priv;
1038
1039 This->fragment_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct atifs_private_data));
1040 if(!This->fragment_priv) {
1041 ERR("Out of memory\n");
1042 return E_OUTOFMEMORY;
1043 }
1044 priv = (struct atifs_private_data *) This->fragment_priv;
1045 priv->fragment_shaders = hash_table_create(ffp_program_key_hash, ffp_program_key_compare);
1046 return WINED3D_OK;
1047 }
1048
1049 #define GLINFO_LOCATION This->adapter->gl_info
1050 static void atifs_free_ffpshader(void *value, void *device) {
1051 IWineD3DDeviceImpl *This = device;
1052 struct atifs_ffp_desc *entry_ati = value;
1053
1054 ENTER_GL();
1055 GL_EXTCALL(glDeleteFragmentShaderATI(entry_ati->shader));
1056 checkGLcall("glDeleteFragmentShaderATI(entry->shader)");
1057 HeapFree(GetProcessHeap(), 0, entry_ati);
1058 LEAVE_GL();
1059 }
1060
1061 static void atifs_free(IWineD3DDevice *iface) {
1062 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
1063 struct atifs_private_data *priv = (struct atifs_private_data *) This->fragment_priv;
1064
1065 hash_table_destroy(priv->fragment_shaders, atifs_free_ffpshader, This);
1066
1067 HeapFree(GetProcessHeap(), 0, priv);
1068 This->fragment_priv = NULL;
1069 }
1070 #undef GLINFO_LOCATION
1071
1072 static BOOL atifs_conv_supported(WINED3DFORMAT fmt) {
1073 TRACE("Checking shader format support for format %s:", debug_d3dformat(fmt));
1074 switch(fmt) {
1075 case WINED3DFMT_V8U8:
1076 case WINED3DFMT_V16U16:
1077 TRACE("[OK]\n");
1078 return TRUE;
1079 default:
1080 TRACE("[FAILED\n");
1081 return FALSE;
1082 }
1083 }
1084
1085 const struct fragment_pipeline atifs_fragment_pipeline = {
1086 atifs_enable,
1087 atifs_get_caps,
1088 atifs_alloc,
1089 atifs_free,
1090 atifs_conv_supported,
1091 atifs_fragmentstate_template
1092 };
useful hacks and other patches not (yet) suitable for mainline