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