2 * Fixed function pipeline replacement using GL_ATI_fragment_shader
4 * Copyright 2008 Stefan Dösinger(for CodeWeavers)
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.
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.
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
26 #include "wined3d_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader
);
29 WINE_DECLARE_DEBUG_CHANNEL(d3d
);
31 /* Some private defines, Constant associations, etc.
32 * Env bump matrix and per stage constant should be independent,
33 * a stage that bump maps can't read the per state constant
35 #define ATI_FFP_CONST_BUMPMAT(i) (GL_CON_0_ATI + i)
36 #define ATI_FFP_CONST_CONSTANT0 GL_CON_0_ATI
37 #define ATI_FFP_CONST_CONSTANT1 GL_CON_1_ATI
38 #define ATI_FFP_CONST_CONSTANT2 GL_CON_2_ATI
39 #define ATI_FFP_CONST_CONSTANT3 GL_CON_3_ATI
40 #define ATI_FFP_CONST_CONSTANT4 GL_CON_4_ATI
41 #define ATI_FFP_CONST_CONSTANT5 GL_CON_5_ATI
42 #define ATI_FFP_CONST_TFACTOR GL_CON_6_ATI
44 /* GL_ATI_fragment_shader specific fixed function pipeline description. "Inherits" from the common one */
47 struct ffp_frag_desc parent
;
49 unsigned int num_textures_used
;
52 struct atifs_private_data
54 struct hash_table_t
*fragment_shaders
; /* A hashtable to track fragment pipeline replacement shaders */
58 static const char *debug_dstmod(GLuint mod
) {
60 case GL_NONE
: return "GL_NONE";
61 case GL_2X_BIT_ATI
: return "GL_2X_BIT_ATI";
62 case GL_4X_BIT_ATI
: return "GL_4X_BIT_ATI";
63 case GL_8X_BIT_ATI
: return "GL_8X_BIT_ATI";
64 case GL_HALF_BIT_ATI
: return "GL_HALF_BIT_ATI";
65 case GL_QUARTER_BIT_ATI
: return "GL_QUARTER_BIT_ATI";
66 case GL_EIGHTH_BIT_ATI
: return "GL_EIGHTH_BIT_ATI";
67 case GL_SATURATE_BIT_ATI
: return "GL_SATURATE_BIT_ATI";
68 default: return "Unexpected modifier\n";
72 static const char *debug_argmod(GLuint mod
) {
78 return "GL_2X_BIT_ATI";
80 return "GL_COMP_BIT_ATI";
81 case GL_NEGATE_BIT_ATI
:
82 return "GL_NEGATE_BIT_ATI";
84 return "GL_BIAS_BIT_ATI";
86 case GL_2X_BIT_ATI
| GL_COMP_BIT_ATI
:
87 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI";
88 case GL_2X_BIT_ATI
| GL_NEGATE_BIT_ATI
:
89 return "GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI";
90 case GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
:
91 return "GL_2X_BIT_ATI | GL_BIAS_BIT_ATI";
92 case GL_COMP_BIT_ATI
| GL_NEGATE_BIT_ATI
:
93 return "GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI";
94 case GL_COMP_BIT_ATI
| GL_BIAS_BIT_ATI
:
95 return "GL_COMP_BIT_ATI | GL_BIAS_BIT_ATI";
96 case GL_NEGATE_BIT_ATI
| GL_BIAS_BIT_ATI
:
97 return "GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
99 case GL_COMP_BIT_ATI
| GL_NEGATE_BIT_ATI
| GL_BIAS_BIT_ATI
:
100 return "GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
101 case GL_2X_BIT_ATI
| GL_NEGATE_BIT_ATI
| GL_BIAS_BIT_ATI
:
102 return "GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
103 case GL_2X_BIT_ATI
| GL_COMP_BIT_ATI
| GL_BIAS_BIT_ATI
:
104 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_BIAS_BIT_ATI";
105 case GL_2X_BIT_ATI
| GL_COMP_BIT_ATI
| GL_NEGATE_BIT_ATI
:
106 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI";
108 case GL_2X_BIT_ATI
| GL_COMP_BIT_ATI
| GL_NEGATE_BIT_ATI
| GL_BIAS_BIT_ATI
:
109 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
112 return "Unexpected argmod combination\n";
115 static const char *debug_register(GLuint reg
) {
117 case GL_REG_0_ATI
: return "GL_REG_0_ATI";
118 case GL_REG_1_ATI
: return "GL_REG_1_ATI";
119 case GL_REG_2_ATI
: return "GL_REG_2_ATI";
120 case GL_REG_3_ATI
: return "GL_REG_3_ATI";
121 case GL_REG_4_ATI
: return "GL_REG_4_ATI";
122 case GL_REG_5_ATI
: return "GL_REG_5_ATI";
124 case GL_CON_0_ATI
: return "GL_CON_0_ATI";
125 case GL_CON_1_ATI
: return "GL_CON_1_ATI";
126 case GL_CON_2_ATI
: return "GL_CON_2_ATI";
127 case GL_CON_3_ATI
: return "GL_CON_3_ATI";
128 case GL_CON_4_ATI
: return "GL_CON_4_ATI";
129 case GL_CON_5_ATI
: return "GL_CON_5_ATI";
130 case GL_CON_6_ATI
: return "GL_CON_6_ATI";
131 case GL_CON_7_ATI
: return "GL_CON_7_ATI";
133 case GL_ZERO
: return "GL_ZERO";
134 case GL_ONE
: return "GL_ONE";
135 case GL_PRIMARY_COLOR
: return "GL_PRIMARY_COLOR";
136 case GL_SECONDARY_INTERPOLATOR_ATI
: return "GL_SECONDARY_INTERPOLATOR_ATI";
138 default: return "Unknown register\n";
142 static const char *debug_swizzle(GLuint swizzle
) {
144 case GL_SWIZZLE_STR_ATI
: return "GL_SWIZZLE_STR_ATI";
145 case GL_SWIZZLE_STQ_ATI
: return "GL_SWIZZLE_STQ_ATI";
146 case GL_SWIZZLE_STR_DR_ATI
: return "GL_SWIZZLE_STR_DR_ATI";
147 case GL_SWIZZLE_STQ_DQ_ATI
: return "GL_SWIZZLE_STQ_DQ_ATI";
148 default: return "unknown swizzle";
152 static const char *debug_rep(GLuint rep
) {
154 case GL_NONE
: return "GL_NONE";
155 case GL_RED
: return "GL_RED";
156 case GL_GREEN
: return "GL_GREEN";
157 case GL_BLUE
: return "GL_BLUE";
158 default: return "unknown argrep";
162 #define GLINFO_LOCATION (*gl_info)
163 static GLuint
register_for_arg(DWORD arg
, const WineD3D_GL_Info
*gl_info
,
164 unsigned int stage
, GLuint
*mod
, GLuint
*rep
, GLuint tmparg
)
168 if(mod
) *mod
= GL_NONE
;
169 if(arg
== ARG_UNUSED
)
171 if (rep
) *rep
= GL_NONE
;
172 return -1; /* This is the marker for unused registers */
175 switch(arg
& WINED3DTA_SELECTMASK
) {
176 case WINED3DTA_DIFFUSE
:
177 ret
= GL_PRIMARY_COLOR
;
180 case WINED3DTA_CURRENT
:
181 /* Note that using GL_REG_0_ATI for the passed on register is safe because
182 * texture0 is read at stage0, so in the worst case it is read in the
183 * instruction writing to reg0. Afterwards texture0 is not used any longer.
184 * If we're reading from current
187 ret
= GL_PRIMARY_COLOR
;
193 case WINED3DTA_TEXTURE
:
194 ret
= GL_REG_0_ATI
+ stage
;
197 case WINED3DTA_TFACTOR
:
198 ret
= ATI_FFP_CONST_TFACTOR
;
201 case WINED3DTA_SPECULAR
:
202 ret
= GL_SECONDARY_INTERPOLATOR_ATI
;
209 case WINED3DTA_CONSTANT
:
210 FIXME("Unhandled source argument WINED3DTA_TEMP\n");
215 FIXME("Unknown source argument %d\n", arg
);
219 if(arg
& WINED3DTA_COMPLEMENT
) {
220 if(mod
) *mod
|= GL_COMP_BIT_ATI
;
222 if(arg
& WINED3DTA_ALPHAREPLICATE
) {
223 if(rep
) *rep
= GL_ALPHA
;
225 if(rep
) *rep
= GL_NONE
;
230 static GLuint
find_tmpreg(const struct texture_stage_op op
[MAX_TEXTURES
])
232 int lowest_read
= -1;
233 int lowest_write
= -1;
235 BOOL tex_used
[MAX_TEXTURES
];
237 memset(tex_used
, 0, sizeof(tex_used
));
238 for(i
= 0; i
< MAX_TEXTURES
; i
++) {
239 if(op
[i
].cop
== WINED3DTOP_DISABLE
) {
243 if(lowest_read
== -1 &&
244 (op
[i
].carg1
== WINED3DTA_TEMP
|| op
[i
].carg2
== WINED3DTA_TEMP
|| op
[i
].carg0
== WINED3DTA_TEMP
||
245 op
[i
].aarg1
== WINED3DTA_TEMP
|| op
[i
].aarg2
== WINED3DTA_TEMP
|| op
[i
].aarg0
== WINED3DTA_TEMP
)) {
249 if(lowest_write
== -1 && op
[i
].dst
== tempreg
) {
253 if(op
[i
].carg1
== WINED3DTA_TEXTURE
|| op
[i
].carg2
== WINED3DTA_TEXTURE
|| op
[i
].carg0
== WINED3DTA_TEXTURE
||
254 op
[i
].aarg1
== WINED3DTA_TEXTURE
|| op
[i
].aarg2
== WINED3DTA_TEXTURE
|| op
[i
].aarg0
== WINED3DTA_TEXTURE
) {
259 /* Temp reg not read? We don't need it, return GL_NONE */
260 if(lowest_read
== -1) return GL_NONE
;
262 if(lowest_write
>= lowest_read
) {
263 FIXME("Temp register read before being written\n");
266 if(lowest_write
== -1) {
267 /* This needs a test. Maybe we are supposed to return 0.0/0.0/0.0/0.0, or fail drawprim, or whatever */
268 FIXME("Temp register read without being written\n");
270 } else if(lowest_write
>= 1) {
271 /* If we're writing to the temp reg at earliest in stage 1, we can use register 1 for the temp result.
272 * there may be texture data stored in reg 1, but we do not need it any longer since stage 1 already
277 /* Search for a free texture register. We have 6 registers available. GL_REG_0_ATI is already used
278 * for the regular result
280 for(i
= 1; i
< 6; i
++) {
282 return GL_REG_0_ATI
+ i
;
285 /* What to do here? Report it in ValidateDevice? */
286 FIXME("Could not find a register for the temporary register\n");
291 static GLuint
gen_ati_shader(const struct texture_stage_op op
[MAX_TEXTURES
], const WineD3D_GL_Info
*gl_info
)
293 GLuint ret
= GL_EXTCALL(glGenFragmentShadersATI(1));
295 GLuint arg0
, arg1
, arg2
, extrarg
;
296 GLuint dstmod
, argmod0
, argmod1
, argmod2
, argmodextra
;
297 GLuint rep0
, rep1
, rep2
;
299 GLuint tmparg
= find_tmpreg(op
);
303 ERR("Failed to generate a GL_ATI_fragment_shader shader id\n");
306 GL_EXTCALL(glBindFragmentShaderATI(ret
));
307 checkGLcall("GL_EXTCALL(glBindFragmentShaderATI(ret))");
309 TRACE("glBeginFragmentShaderATI()\n");
310 GL_EXTCALL(glBeginFragmentShaderATI());
311 checkGLcall("GL_EXTCALL(glBeginFragmentShaderATI())");
313 /* Pass 1: Generate sampling instructions for perturbation maps */
314 for(stage
= 0; stage
< GL_LIMITS(textures
); stage
++) {
315 if(op
[stage
].cop
== WINED3DTOP_DISABLE
) break;
316 if(op
[stage
].cop
!= WINED3DTOP_BUMPENVMAP
&&
317 op
[stage
].cop
!= WINED3DTOP_BUMPENVMAPLUMINANCE
) continue;
319 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, GL_SWIZZLE_STR_ATI)\n",
321 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
322 GL_TEXTURE0_ARB
+ stage
,
323 GL_SWIZZLE_STR_ATI
));
324 if(op
[stage
+ 1].projected
== proj_none
) {
325 swizzle
= GL_SWIZZLE_STR_ATI
;
326 } else if(op
[stage
+ 1].projected
== proj_count4
) {
327 swizzle
= GL_SWIZZLE_STQ_DQ_ATI
;
329 swizzle
= GL_SWIZZLE_STR_DR_ATI
;
331 TRACE("glPassTexCoordATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, %s)\n",
332 stage
+ 1, stage
+ 1, debug_swizzle(swizzle
));
333 GL_EXTCALL(glPassTexCoordATI(GL_REG_0_ATI
+ stage
+ 1,
334 GL_TEXTURE0_ARB
+ stage
+ 1,
337 /* We need GL_REG_5_ATI as a temporary register to swizzle the bump matrix. So we run into
338 * issues if we're bump mapping on stage 4 or 5
341 FIXME("Bump mapping in stage %d\n", stage
);
345 /* Pass 2: Generate perturbation calculations */
346 for(stage
= 0; stage
< GL_LIMITS(textures
); stage
++) {
347 GLuint argmodextra_x
, argmodextra_y
;
348 struct color_fixup_desc fixup
;
350 if(op
[stage
].cop
== WINED3DTOP_DISABLE
) break;
351 if(op
[stage
].cop
!= WINED3DTOP_BUMPENVMAP
&&
352 op
[stage
].cop
!= WINED3DTOP_BUMPENVMAPLUMINANCE
) continue;
354 fixup
= op
[stage
].color_fixup
;
355 if (fixup
.x_source
!= CHANNEL_SOURCE_X
|| fixup
.y_source
!= CHANNEL_SOURCE_Y
)
357 FIXME("Swizzles not implemented\n");
358 argmodextra_x
= GL_NONE
;
359 argmodextra_y
= GL_NONE
;
363 /* Nice thing, we get the color correction for free :-) */
364 argmodextra_x
= fixup
.x_sign_fixup
? GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
: GL_NONE
;
365 argmodextra_y
= fixup
.y_sign_fixup
? GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
: GL_NONE
;
368 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",
369 stage
+ 1, stage
, debug_argmod(argmodextra_x
), stage
, stage
+ 1);
370 GL_EXTCALL(glColorFragmentOp3ATI(GL_DOT2_ADD_ATI
, GL_REG_0_ATI
+ stage
+ 1, GL_RED_BIT_ATI
, GL_NONE
,
371 GL_REG_0_ATI
+ stage
, GL_NONE
, argmodextra_x
,
372 ATI_FFP_CONST_BUMPMAT(stage
), GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
,
373 GL_REG_0_ATI
+ stage
+ 1, GL_RED
, GL_NONE
));
375 /* FIXME: How can I make GL_DOT2_ADD_ATI read the factors from blue and alpha? It defaults to red and green,
376 * 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
377 * one register and two instructions in this pass for a simple swizzling operation.
378 * For starters it might be good enough to merge the two movs into one, but even that isn't possible :-(
380 * NOTE: GL_BLUE | GL_ALPHA is not possible. It doesn't throw a compilation error, but an OR operation on the
381 * constants doesn't make sense, considering their values.
383 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
);
384 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI
, GL_REG_5_ATI
, GL_RED_BIT_ATI
, GL_NONE
,
385 ATI_FFP_CONST_BUMPMAT(stage
), GL_BLUE
, GL_NONE
));
386 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
);
387 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI
, GL_REG_5_ATI
, GL_GREEN_BIT_ATI
, GL_NONE
,
388 ATI_FFP_CONST_BUMPMAT(stage
), GL_ALPHA
, GL_NONE
));
389 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",
390 stage
+ 1, stage
, debug_argmod(argmodextra_y
), stage
+ 1);
391 GL_EXTCALL(glColorFragmentOp3ATI(GL_DOT2_ADD_ATI
, GL_REG_0_ATI
+ stage
+ 1, GL_GREEN_BIT_ATI
, GL_NONE
,
392 GL_REG_0_ATI
+ stage
, GL_NONE
, argmodextra_y
,
393 GL_REG_5_ATI
, GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
,
394 GL_REG_0_ATI
+ stage
+ 1, GL_GREEN
, GL_NONE
));
397 /* Pass 3: Generate sampling instructions for regular textures */
398 for(stage
= 0; stage
< GL_LIMITS(textures
); stage
++) {
399 if(op
[stage
].cop
== WINED3DTOP_DISABLE
) {
403 if(op
[stage
].projected
== proj_none
) {
404 swizzle
= GL_SWIZZLE_STR_ATI
;
405 } else if(op
[stage
].projected
== proj_count3
) {
406 swizzle
= GL_SWIZZLE_STR_DR_ATI
;
408 swizzle
= GL_SWIZZLE_STQ_DQ_ATI
;
411 if((op
[stage
].carg0
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
412 (op
[stage
].carg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
413 (op
[stage
].carg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
414 (op
[stage
].aarg0
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
415 (op
[stage
].aarg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
416 (op
[stage
].aarg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
417 op
[stage
].cop
== WINED3DTOP_BLENDTEXTUREALPHA
) {
420 (op
[stage
- 1].cop
== WINED3DTOP_BUMPENVMAP
||
421 op
[stage
- 1].cop
== WINED3DTOP_BUMPENVMAPLUMINANCE
)) {
422 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_REG_%d_ATI, GL_SWIZZLE_STR_ATI)\n",
424 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
425 GL_REG_0_ATI
+ stage
,
426 GL_SWIZZLE_STR_ATI
));
428 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, %s)\n",
429 stage
, stage
, debug_swizzle(swizzle
));
430 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
431 GL_TEXTURE0_ARB
+ stage
,
437 /* Pass 4: Generate the arithmetic instructions */
438 for(stage
= 0; stage
< MAX_TEXTURES
; stage
++) {
439 if(op
[stage
].cop
== WINED3DTOP_DISABLE
) {
441 /* Handle complete texture disabling gracefully */
442 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
443 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI
, GL_REG_0_ATI
, GL_NONE
, GL_NONE
,
444 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
));
445 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
446 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI
, GL_REG_0_ATI
, GL_NONE
,
447 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
));
452 if(op
[stage
].dst
== tempreg
) {
453 /* If we're writing to D3DTA_TEMP, but never reading from it we don't have to write there in the first place.
454 * skip the entire stage, this saves some GPU time
456 if(tmparg
== GL_NONE
) continue;
460 dstreg
= GL_REG_0_ATI
;
463 arg0
= register_for_arg(op
[stage
].carg0
, gl_info
, stage
, &argmod0
, &rep0
, tmparg
);
464 arg1
= register_for_arg(op
[stage
].carg1
, gl_info
, stage
, &argmod1
, &rep1
, tmparg
);
465 arg2
= register_for_arg(op
[stage
].carg2
, gl_info
, stage
, &argmod2
, &rep2
, tmparg
);
467 argmodextra
= GL_NONE
;
470 switch(op
[stage
].cop
) {
471 case WINED3DTOP_SELECTARG2
:
475 case WINED3DTOP_SELECTARG1
:
476 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, %s, GL_NONE, GL_NONE, %s, %s, %s)\n",
477 debug_register(dstreg
), debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
));
478 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI
, dstreg
, GL_NONE
, GL_NONE
,
479 arg1
, rep1
, argmod1
));
482 case WINED3DTOP_MODULATE4X
:
483 if(dstmod
== GL_NONE
) dstmod
= GL_4X_BIT_ATI
;
484 case WINED3DTOP_MODULATE2X
:
485 if(dstmod
== GL_NONE
) dstmod
= GL_2X_BIT_ATI
;
486 dstmod
|= GL_SATURATE_BIT_ATI
;
487 case WINED3DTOP_MODULATE
:
488 TRACE("glColorFragmentOp2ATI(GL_MUL_ATI, %s, GL_NONE, %s, %s, %s, %s, %s, %s, %s)\n",
489 debug_register(dstreg
), debug_dstmod(dstmod
),
490 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
),
491 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
));
492 GL_EXTCALL(glColorFragmentOp2ATI(GL_MUL_ATI
, dstreg
, GL_NONE
, dstmod
,
494 arg2
, rep2
, argmod2
));
497 case WINED3DTOP_ADDSIGNED2X
:
498 dstmod
= GL_2X_BIT_ATI
;
499 case WINED3DTOP_ADDSIGNED
:
500 argmodextra
= GL_BIAS_BIT_ATI
;
502 dstmod
|= GL_SATURATE_BIT_ATI
;
503 TRACE("glColorFragmentOp2ATI(GL_ADD_ATI, %s, GL_NONE, %s, %s, %s, %s, %s, %s, %s)\n",
504 debug_register(dstreg
), debug_dstmod(dstmod
),
505 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
),
506 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmodextra
| argmod2
));
507 GL_EXTCALL(glColorFragmentOp2ATI(GL_ADD_ATI
, GL_REG_0_ATI
, GL_NONE
, dstmod
,
509 arg2
, rep2
, argmodextra
| argmod2
));
512 case WINED3DTOP_SUBTRACT
:
513 dstmod
|= GL_SATURATE_BIT_ATI
;
514 TRACE("glColorFragmentOp2ATI(GL_SUB_ATI, %s, GL_NONE, %s, %s, %s, %s, %s, %s, %s)\n",
515 debug_register(dstreg
), debug_dstmod(dstmod
),
516 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
),
517 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
));
518 GL_EXTCALL(glColorFragmentOp2ATI(GL_SUB_ATI
, dstreg
, GL_NONE
, dstmod
,
520 arg2
, rep2
, argmod2
));
523 case WINED3DTOP_ADDSMOOTH
:
524 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
525 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_SATURATE_BIT_ATI, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n",
526 debug_register(dstreg
),
527 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
),
528 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmodextra
),
529 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
));
530 /* Dst = arg1 + * arg2(1 -arg 1)
531 * = arg2 * (1 - arg1) + arg1
533 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_SATURATE_BIT_ATI
,
535 arg1
, rep1
, argmodextra
,
536 arg1
, rep1
, argmod1
));
539 case WINED3DTOP_BLENDCURRENTALPHA
:
540 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_CURRENT
, gl_info
, stage
, NULL
, NULL
, -1);
541 case WINED3DTOP_BLENDFACTORALPHA
:
542 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_TFACTOR
, gl_info
, stage
, NULL
, NULL
, -1);
543 case WINED3DTOP_BLENDTEXTUREALPHA
:
544 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, NULL
, -1);
545 case WINED3DTOP_BLENDDIFFUSEALPHA
:
546 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_DIFFUSE
, gl_info
, stage
, NULL
, NULL
, -1);
547 TRACE("glColorFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, GL_NONE, %s, GL_ALPHA, GL_NONE, %s, %s, %s, %s, %s, %s)\n",
548 debug_register(dstreg
),
549 debug_register(extrarg
),
550 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
),
551 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
));
552 GL_EXTCALL(glColorFragmentOp3ATI(GL_LERP_ATI
, dstreg
, GL_NONE
, GL_NONE
,
553 extrarg
, GL_ALPHA
, GL_NONE
,
555 arg2
, rep2
, argmod2
));
558 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
559 arg0
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, NULL
, -1);
560 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_NONE, %s, %s, %s, %s, GL_ALPHA, GL_COMP_BIT_ATI, %s, %s, %s)\n",
561 debug_register(dstreg
),
562 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
),
563 debug_register(arg0
),
564 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
));
565 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_NONE
,
567 arg0
, GL_ALPHA
, GL_COMP_BIT_ATI
,
568 arg1
, rep1
, argmod1
));
571 /* D3DTOP_PREMODULATE ???? */
573 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
574 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
575 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
576 if(!argmodextra
) argmodextra
= argmod1
;
577 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_SATURATE_BIT_ATI, %s, %s, %s, %s, GL_ALPHA, %s, %s, %s, %s)\n",
578 debug_register(dstreg
),
579 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
),
580 debug_register(arg1
), debug_argmod(argmodextra
), debug_register(arg1
), debug_rep(rep1
), debug_argmod(arg1
));
581 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_SATURATE_BIT_ATI
,
583 arg1
, GL_ALPHA
, argmodextra
,
584 arg1
, rep1
, argmod1
));
587 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
588 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
589 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
590 if(!argmodextra
) argmodextra
= argmod1
;
591 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_SATURATE_BIT_ATI, %s, %s, %s, %s, %s, %s, %s, GL_ALPHA, %s)\n",
592 debug_register(dstreg
),
593 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
),
594 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmodextra
),
595 debug_register(arg1
), debug_argmod(argmod1
));
596 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_SATURATE_BIT_ATI
,
598 arg1
, rep1
, argmodextra
,
599 arg1
, GL_ALPHA
, argmod1
));
602 case WINED3DTOP_DOTPRODUCT3
:
603 TRACE("glColorFragmentOp2ATI(GL_DOT3_ATI, %s, GL_NONE, GL_4X_BIT_ATI | GL_SATURATE_BIT_ATI, %s, %s, %s, %s, %s, %s)\n",
604 debug_register(dstreg
),
605 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
| GL_BIAS_BIT_ATI
),
606 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
| GL_BIAS_BIT_ATI
));
607 GL_EXTCALL(glColorFragmentOp2ATI(GL_DOT3_ATI
, dstreg
, GL_NONE
, GL_4X_BIT_ATI
| GL_SATURATE_BIT_ATI
,
608 arg1
, rep1
, argmod1
| GL_BIAS_BIT_ATI
,
609 arg2
, rep2
, argmod2
| GL_BIAS_BIT_ATI
));
612 case WINED3DTOP_MULTIPLYADD
:
613 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_SATURATE_BIT_ATI, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n",
614 debug_register(dstreg
),
615 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
),
616 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
),
617 debug_register(arg0
), debug_rep(rep0
), debug_argmod(argmod0
));
618 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_SATURATE_BIT_ATI
,
621 arg0
, rep0
, argmod0
));
624 case WINED3DTOP_LERP
:
625 TRACE("glColorFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, GL_NONE, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n",
626 debug_register(dstreg
),
627 debug_register(arg1
), debug_rep(rep1
), debug_argmod(argmod1
),
628 debug_register(arg2
), debug_rep(rep2
), debug_argmod(argmod2
),
629 debug_register(arg0
), debug_rep(rep0
), debug_argmod(argmod0
));
630 GL_EXTCALL(glColorFragmentOp3ATI(GL_LERP_ATI
, dstreg
, GL_NONE
, GL_NONE
,
633 arg2
, rep2
, argmod2
));
636 case WINED3DTOP_BUMPENVMAP
:
637 case WINED3DTOP_BUMPENVMAPLUMINANCE
:
638 /* Those are handled in the first pass of the shader(generation pass 1 and 2) already */
641 default: FIXME("Unhandled color operation %d on stage %d\n", op
[stage
].cop
, stage
);
644 arg0
= register_for_arg(op
[stage
].aarg0
, gl_info
, stage
, &argmod0
, NULL
, tmparg
);
645 arg1
= register_for_arg(op
[stage
].aarg1
, gl_info
, stage
, &argmod1
, NULL
, tmparg
);
646 arg2
= register_for_arg(op
[stage
].aarg2
, gl_info
, stage
, &argmod2
, NULL
, tmparg
);
648 argmodextra
= GL_NONE
;
651 switch(op
[stage
].aop
) {
652 case WINED3DTOP_DISABLE
:
653 /* Get the primary color to the output if on stage 0, otherwise leave register 0 untouched */
655 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
656 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI
, GL_REG_0_ATI
, GL_NONE
,
657 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
));
661 case WINED3DTOP_SELECTARG2
:
664 case WINED3DTOP_SELECTARG1
:
665 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, %s, GL_NONE, %s, GL_NONE, %s)\n",
666 debug_register(dstreg
),
667 debug_register(arg1
), debug_argmod(argmod1
));
668 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI
, dstreg
, GL_NONE
,
669 arg1
, GL_NONE
, argmod1
));
672 case WINED3DTOP_MODULATE4X
:
673 if(dstmod
== GL_NONE
) dstmod
= GL_4X_BIT_ATI
;
674 case WINED3DTOP_MODULATE2X
:
675 if(dstmod
== GL_NONE
) dstmod
= GL_2X_BIT_ATI
;
676 dstmod
|= GL_SATURATE_BIT_ATI
;
677 case WINED3DTOP_MODULATE
:
678 TRACE("glAlphaFragmentOp2ATI(GL_MUL_ATI, %s, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
679 debug_register(dstreg
), debug_dstmod(dstmod
),
680 debug_register(arg1
), debug_argmod(argmod1
),
681 debug_register(arg2
), debug_argmod(argmod2
));
682 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_MUL_ATI
, dstreg
, dstmod
,
683 arg1
, GL_NONE
, argmod1
,
684 arg2
, GL_NONE
, argmod2
));
687 case WINED3DTOP_ADDSIGNED2X
:
688 dstmod
= GL_2X_BIT_ATI
;
689 case WINED3DTOP_ADDSIGNED
:
690 argmodextra
= GL_BIAS_BIT_ATI
;
692 dstmod
|= GL_SATURATE_BIT_ATI
;
693 TRACE("glAlphaFragmentOp2ATI(GL_ADD_ATI, %s, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
694 debug_register(dstreg
), debug_dstmod(dstmod
),
695 debug_register(arg1
), debug_argmod(argmod1
),
696 debug_register(arg2
), debug_argmod(argmodextra
| argmod2
));
697 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_ADD_ATI
, dstreg
, dstmod
,
698 arg1
, GL_NONE
, argmod1
,
699 arg2
, GL_NONE
, argmodextra
| argmod2
));
702 case WINED3DTOP_SUBTRACT
:
703 dstmod
|= GL_SATURATE_BIT_ATI
;
704 TRACE("glAlphaFragmentOp2ATI(GL_SUB_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
705 debug_register(dstreg
), debug_dstmod(dstmod
),
706 debug_register(arg1
), debug_argmod(argmod1
),
707 debug_register(arg2
), debug_argmod(argmod2
));
708 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_SUB_ATI
, dstreg
, dstmod
,
709 arg1
, GL_NONE
, argmod1
,
710 arg2
, GL_NONE
, argmod2
));
713 case WINED3DTOP_ADDSMOOTH
:
714 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
715 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
716 debug_register(dstreg
),
717 debug_register(arg2
), debug_argmod(argmod2
),
718 debug_register(arg1
), debug_argmod(argmodextra
),
719 debug_register(arg1
), debug_argmod(argmod1
));
720 /* Dst = arg1 + * arg2(1 -arg 1)
721 * = arg2 * (1 - arg1) + arg1
723 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_SATURATE_BIT_ATI
,
724 arg2
, GL_NONE
, argmod2
,
725 arg1
, GL_NONE
, argmodextra
,
726 arg1
, GL_NONE
, argmod1
));
729 case WINED3DTOP_BLENDCURRENTALPHA
:
730 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_CURRENT
, gl_info
, stage
, NULL
, NULL
, -1);
731 case WINED3DTOP_BLENDFACTORALPHA
:
732 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_TFACTOR
, gl_info
, stage
, NULL
, NULL
, -1);
733 case WINED3DTOP_BLENDTEXTUREALPHA
:
734 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, NULL
, -1);
735 case WINED3DTOP_BLENDDIFFUSEALPHA
:
736 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_DIFFUSE
, gl_info
, stage
, NULL
, NULL
, -1);
737 TRACE("glAlphaFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, %s, GL_ALPHA, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
738 debug_register(dstreg
),
739 debug_register(extrarg
),
740 debug_register(arg1
), debug_argmod(argmod1
),
741 debug_register(arg2
), debug_argmod(argmod2
));
742 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_LERP_ATI
, dstreg
, GL_NONE
,
743 extrarg
, GL_ALPHA
, GL_NONE
,
744 arg1
, GL_NONE
, argmod1
,
745 arg2
, GL_NONE
, argmod2
));
748 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
749 arg0
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, NULL
, -1);
750 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, %s, GL_NONE, %s, %s, GL_ALPHA, GL_COMP_BIT_ATI, %s, GL_NONE, %s)\n",
751 debug_register(dstreg
),
752 debug_register(arg2
), debug_argmod(argmod2
),
753 debug_register(arg0
),
754 debug_register(arg1
), debug_argmod(argmod1
));
755 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
,
756 arg2
, GL_NONE
, argmod2
,
757 arg0
, GL_ALPHA
, GL_COMP_BIT_ATI
,
758 arg1
, GL_NONE
, argmod1
));
761 /* D3DTOP_PREMODULATE ???? */
763 case WINED3DTOP_DOTPRODUCT3
:
764 TRACE("glAlphaFragmentOp2ATI(GL_DOT3_ATI, %s, GL_4X_BIT_ATI | GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
765 debug_register(dstreg
),
766 debug_register(arg1
), debug_argmod(argmod1
| GL_BIAS_BIT_ATI
),
767 debug_register(arg2
), debug_argmod(argmod2
| GL_BIAS_BIT_ATI
));
768 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_DOT3_ATI
, dstreg
, GL_4X_BIT_ATI
| GL_SATURATE_BIT_ATI
,
769 arg1
, GL_NONE
, argmod1
| GL_BIAS_BIT_ATI
,
770 arg2
, GL_NONE
, argmod2
| GL_BIAS_BIT_ATI
));
773 case WINED3DTOP_MULTIPLYADD
:
774 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
775 debug_register(dstreg
),
776 debug_register(arg1
), debug_argmod(argmod1
),
777 debug_register(arg2
), debug_argmod(argmod2
),
778 debug_register(arg0
), debug_argmod(argmod0
));
779 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_SATURATE_BIT_ATI
,
780 arg1
, GL_NONE
, argmod1
,
781 arg2
, GL_NONE
, argmod2
,
782 arg0
, GL_NONE
, argmod0
));
785 case WINED3DTOP_LERP
:
786 TRACE("glAlphaFragmentOp3ATI(GL_LERP_ATI, %s, GL_SATURATE_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
787 debug_register(dstreg
),
788 debug_register(arg1
), debug_argmod(argmod1
),
789 debug_register(arg2
), debug_argmod(argmod2
),
790 debug_register(arg0
), debug_argmod(argmod0
));
791 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_LERP_ATI
, dstreg
, GL_SATURATE_BIT_ATI
,
792 arg1
, GL_NONE
, argmod1
,
793 arg2
, GL_NONE
, argmod2
,
794 arg0
, GL_NONE
, argmod0
));
797 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
798 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
799 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
800 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
801 case WINED3DTOP_BUMPENVMAP
:
802 case WINED3DTOP_BUMPENVMAPLUMINANCE
:
803 ERR("Application uses an invalid alpha operation\n");
806 default: FIXME("Unhandled alpha operation %d on stage %d\n", op
[stage
].aop
, stage
);
810 TRACE("glEndFragmentShaderATI()\n");
811 GL_EXTCALL(glEndFragmentShaderATI());
812 checkGLcall("GL_EXTCALL(glEndFragmentShaderATI())");
815 #undef GLINFO_LOCATION
817 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
818 static void set_tex_op_atifs(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
819 IWineD3DDeviceImpl
*This
= stateblock
->wineD3DDevice
;
820 const struct atifs_ffp_desc
*desc
;
821 struct ffp_frag_settings settings
;
822 struct atifs_private_data
*priv
= (struct atifs_private_data
*) This
->fragment_priv
;
826 gen_ffp_frag_op(stateblock
, &settings
, TRUE
);
827 desc
= (const struct atifs_ffp_desc
*)find_ffp_frag_shader(priv
->fragment_shaders
, &settings
);
829 struct atifs_ffp_desc
*new_desc
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_desc
));
832 ERR("Out of memory\n");
835 new_desc
->num_textures_used
= 0;
836 for(i
= 0; i
< GL_LIMITS(texture_stages
); i
++) {
837 if(settings
.op
[i
].cop
== WINED3DTOP_DISABLE
) break;
838 new_desc
->num_textures_used
= i
;
841 memcpy(&new_desc
->parent
.settings
, &settings
, sizeof(settings
));
842 new_desc
->shader
= gen_ati_shader(settings
.op
, &GLINFO_LOCATION
);
843 add_ffp_frag_shader(priv
->fragment_shaders
, &new_desc
->parent
);
844 TRACE("Allocated fixed function replacement shader descriptor %p\n", new_desc
);
848 /* GL_ATI_fragment_shader depends on the GL_TEXTURE_xD enable settings. Update the texture stages
849 * used by this shader
851 for(i
= 0; i
< desc
->num_textures_used
; i
++) {
852 mapped_stage
= This
->texUnitMap
[i
];
853 if(mapped_stage
!= -1) {
854 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
855 checkGLcall("glActiveTextureARB");
856 texture_activate_dimensions(i
, stateblock
, context
);
860 GL_EXTCALL(glBindFragmentShaderATI(desc
->shader
));
863 static void state_texfactor_atifs(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
865 D3DCOLORTOGLFLOAT4(stateblock
->renderState
[WINED3DRS_TEXTUREFACTOR
], col
);
867 GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR
, col
));
868 checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR, col)");
871 static void set_bumpmat(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
872 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE
;
875 mat
[0][0] = *((float *) &stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVMAT00
]);
876 mat
[1][0] = *((float *) &stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVMAT01
]);
877 mat
[0][1] = *((float *) &stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVMAT10
]);
878 mat
[1][1] = *((float *) &stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVMAT11
]);
879 /* GL_ATI_fragment_shader allows only constants from 0.0 to 1.0, but the bumpmat
880 * constants can be in any range. While they should stay between [-1.0 and 1.0] because
881 * Shader Model 1.x pixel shaders are clamped to that range negative values are used occasionally,
882 * for example by our d3d9 test. So to get negative values scale -1;1 to 0;1 and undo that in the
883 * shader(it is free). This might potentially reduce precision. However, if the hardware does
884 * support proper floats it shouldn't, and if it doesn't we can't get anything better anyway
886 mat
[0][0] = (mat
[0][0] + 1.0) * 0.5;
887 mat
[1][0] = (mat
[1][0] + 1.0) * 0.5;
888 mat
[0][1] = (mat
[0][1] + 1.0) * 0.5;
889 mat
[1][1] = (mat
[1][1] + 1.0) * 0.5;
890 GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_BUMPMAT(stage
), (float *) mat
));
891 checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_BUMPMAT(stage), mat)");
894 static void textransform(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
895 if(!isStateDirty(context
, STATE_PIXELSHADER
)) {
896 set_tex_op_atifs(state
, stateblock
, context
);
900 #undef GLINFO_LOCATION
902 static const struct StateEntryTemplate atifs_fragmentstate_template
[] = {
903 {STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), state_texfactor_atifs
}, 0 },
904 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
905 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
906 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
907 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
908 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
909 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
910 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
911 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
912 {STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
913 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
914 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
915 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
916 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
917 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
918 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
919 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
920 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
921 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
922 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
923 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
924 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
925 {STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
926 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
927 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
928 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
929 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
930 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
931 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
932 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
933 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
934 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
935 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
936 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
937 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
938 {STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
939 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
940 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
941 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
942 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
943 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
944 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
945 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
946 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
947 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
948 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
949 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
950 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
951 {STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
952 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
953 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
954 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
955 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
956 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
957 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
958 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
959 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
960 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
961 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
962 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
963 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
964 {STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
965 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
966 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
967 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
968 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
969 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
970 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
971 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
972 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
973 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
974 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
975 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
976 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
977 {STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
978 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
979 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
980 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
981 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
982 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
983 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
984 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
985 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
986 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
987 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
988 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
989 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
990 {STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
991 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
992 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
993 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
994 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
995 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
996 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
997 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
998 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
999 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
1000 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
1001 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
1002 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
1003 {STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
1004 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
1005 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
1006 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
1007 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
1008 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim
}, 0 },
1009 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim
}, 0 },
1010 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim
}, 0 },
1011 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim
}, 0 },
1012 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim
}, 0 },
1013 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim
}, 0 },
1014 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim
}, 0 },
1015 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim
}, 0 },
1016 {STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(0, WINED3DTSS_TEXTURETRANSFORMFLAGS
), textransform
}, 0 },
1017 {STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(1, WINED3DTSS_TEXTURETRANSFORMFLAGS
), textransform
}, 0 },
1018 {STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(2, WINED3DTSS_TEXTURETRANSFORMFLAGS
), textransform
}, 0 },
1019 {STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(3, WINED3DTSS_TEXTURETRANSFORMFLAGS
), textransform
}, 0 },
1020 {STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(4, WINED3DTSS_TEXTURETRANSFORMFLAGS
), textransform
}, 0 },
1021 {STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(5, WINED3DTSS_TEXTURETRANSFORMFLAGS
), textransform
}, 0 },
1022 {STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(6, WINED3DTSS_TEXTURETRANSFORMFLAGS
), textransform
}, 0 },
1023 {STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(7, WINED3DTSS_TEXTURETRANSFORMFLAGS
), textransform
}, 0 },
1024 {0 /* Terminate */, { 0, 0 }, 0 },
1027 static void atifs_enable(IWineD3DDevice
*iface
, BOOL enable
) {
1029 glEnable(GL_FRAGMENT_SHADER_ATI
);
1030 checkGLcall("glEnable(GL_FRAGMENT_SHADER_ATI)");
1032 glDisable(GL_FRAGMENT_SHADER_ATI
);
1033 checkGLcall("glDisable(GL_FRAGMENT_SHADER_ATI)");
1037 static void atifs_get_caps(WINED3DDEVTYPE devtype
, const WineD3D_GL_Info
*gl_info
, struct fragment_caps
*caps
)
1039 caps
->TextureOpCaps
= WINED3DTEXOPCAPS_DISABLE
|
1040 WINED3DTEXOPCAPS_SELECTARG1
|
1041 WINED3DTEXOPCAPS_SELECTARG2
|
1042 WINED3DTEXOPCAPS_MODULATE4X
|
1043 WINED3DTEXOPCAPS_MODULATE2X
|
1044 WINED3DTEXOPCAPS_MODULATE
|
1045 WINED3DTEXOPCAPS_ADDSIGNED2X
|
1046 WINED3DTEXOPCAPS_ADDSIGNED
|
1047 WINED3DTEXOPCAPS_ADD
|
1048 WINED3DTEXOPCAPS_SUBTRACT
|
1049 WINED3DTEXOPCAPS_ADDSMOOTH
|
1050 WINED3DTEXOPCAPS_BLENDCURRENTALPHA
|
1051 WINED3DTEXOPCAPS_BLENDFACTORALPHA
|
1052 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
|
1053 WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
|
1054 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
|
1055 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
|
1056 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
|
1057 WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA
|
1058 WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
|
1059 WINED3DTEXOPCAPS_DOTPRODUCT3
|
1060 WINED3DTEXOPCAPS_MULTIPLYADD
|
1061 WINED3DTEXOPCAPS_LERP
|
1062 WINED3DTEXOPCAPS_BUMPENVMAP
;
1064 /* TODO: Implement WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
1065 and WINED3DTEXOPCAPS_PREMODULATE */
1067 /* GL_ATI_fragment_shader always supports 6 textures, which was the limit on r200 cards
1068 * which this extension is exclusively focused on(later cards have GL_ARB_fragment_program).
1069 * If the current card has more than 8 fixed function textures in OpenGL's regular fixed
1070 * function pipeline then the ATI_fragment_shader backend imposes a stricter limit. This
1071 * shouldn't be too hard since Nvidia cards have a limit of 4 textures with the default ffp
1072 * pipeline, and almost all games are happy with that. We can however support up to 8
1073 * texture stages because we have a 2nd pass limit of 8 instructions, and per stage we use
1074 * only 1 instruction.
1076 * The proper fix for this is not to use GL_ATI_fragment_shader on cards newer than the
1077 * r200 series and use an ARB or GLSL shader instead
1079 caps
->MaxTextureBlendStages
= 8;
1080 caps
->MaxSimultaneousTextures
= 6;
1082 caps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_TSSARGTEMP
;
1085 static HRESULT
atifs_alloc(IWineD3DDevice
*iface
) {
1086 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*) iface
;
1087 struct atifs_private_data
*priv
;
1089 This
->fragment_priv
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(struct atifs_private_data
));
1090 if(!This
->fragment_priv
) {
1091 ERR("Out of memory\n");
1092 return E_OUTOFMEMORY
;
1094 priv
= (struct atifs_private_data
*) This
->fragment_priv
;
1095 priv
->fragment_shaders
= hash_table_create(ffp_frag_program_key_hash
, ffp_frag_program_key_compare
);
1099 #define GLINFO_LOCATION This->adapter->gl_info
1100 static void atifs_free_ffpshader(void *value
, void *device
) {
1101 IWineD3DDeviceImpl
*This
= device
;
1102 struct atifs_ffp_desc
*entry_ati
= value
;
1105 GL_EXTCALL(glDeleteFragmentShaderATI(entry_ati
->shader
));
1106 checkGLcall("glDeleteFragmentShaderATI(entry->shader)");
1107 HeapFree(GetProcessHeap(), 0, entry_ati
);
1111 static void atifs_free(IWineD3DDevice
*iface
) {
1112 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*) iface
;
1113 struct atifs_private_data
*priv
= (struct atifs_private_data
*) This
->fragment_priv
;
1115 hash_table_destroy(priv
->fragment_shaders
, atifs_free_ffpshader
, This
);
1117 HeapFree(GetProcessHeap(), 0, priv
);
1118 This
->fragment_priv
= NULL
;
1120 #undef GLINFO_LOCATION
1122 static BOOL
atifs_color_fixup_supported(struct color_fixup_desc fixup
)
1124 if (TRACE_ON(d3d_shader
) && TRACE_ON(d3d
))
1126 TRACE("Checking support for fixup:\n");
1127 dump_color_fixup_desc(fixup
);
1130 /* We only support sign fixup of the first two channels. */
1131 if (fixup
.x_source
== CHANNEL_SOURCE_X
&& fixup
.y_source
== CHANNEL_SOURCE_Y
1132 && fixup
.z_source
== CHANNEL_SOURCE_Z
&& fixup
.w_source
== CHANNEL_SOURCE_W
1133 && !fixup
.z_sign_fixup
&& !fixup
.w_sign_fixup
)
1139 TRACE("[FAILED]\n");
1143 const struct fragment_pipeline atifs_fragment_pipeline
= {
1148 atifs_color_fixup_supported
,
1149 atifs_fragmentstate_template
,
1150 TRUE
/* We can disable projected textures */