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
);
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
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
43 /* GL_ATI_fragment_shader specific fixed function pipeline description. "Inherits" from the common one */
46 struct ffp_desc parent
;
48 unsigned int num_textures_used
;
51 struct atifs_private_data
53 hash_table_t
*fragment_shaders
; /* A hashtable to track fragment pipeline replacement shaders */
57 static const char *debug_dstmod(GLuint 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";
71 static const char *debug_argmod(GLuint mod
) {
77 return "GL_2X_BIT_ATI";
79 return "GL_COMP_BIT_ATI";
80 case GL_NEGATE_BIT_ATI
:
81 return "GL_NEGATE_BIT_ATI";
83 return "GL_BIAS_BIT_ATI";
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";
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";
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";
111 return "Unexpected argmod combination\n";
114 static const char *debug_register(GLuint 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";
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";
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";
137 default: return "Unknown register\n";
141 static const char *debug_swizzle(GLuint 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";
151 #define GLINFO_LOCATION (*gl_info)
152 static GLuint
register_for_arg(DWORD arg
, WineD3D_GL_Info
*gl_info
, unsigned int stage
, GLuint
*mod
, GLuint tmparg
) {
155 if(mod
) *mod
= GL_NONE
;
156 if(arg
== 0xFFFFFFFF) return -1; /* This is the marker for unused registers */
158 switch(arg
& WINED3DTA_SELECTMASK
) {
159 case WINED3DTA_DIFFUSE
:
160 ret
= GL_PRIMARY_COLOR
;
163 case WINED3DTA_CURRENT
:
164 /* Note that using GL_REG_0_ATI for the passed on register is safe because
165 * texture0 is read at stage0, so in the worst case it is read in the
166 * instruction writing to reg0. Afterwards texture0 is not used any longer.
167 * If we're reading from current
170 ret
= GL_PRIMARY_COLOR
;
176 case WINED3DTA_TEXTURE
:
177 ret
= GL_REG_0_ATI
+ stage
;
180 case WINED3DTA_TFACTOR
:
181 ret
= ATI_FFP_CONST_TFACTOR
;
184 case WINED3DTA_SPECULAR
:
185 ret
= GL_SECONDARY_INTERPOLATOR_ATI
;
192 case WINED3DTA_CONSTANT
:
193 FIXME("Unhandled source argument WINED3DTA_TEMP\n");
198 FIXME("Unknown source argument %d\n", arg
);
202 if(arg
& WINED3DTA_COMPLEMENT
) {
203 if(mod
) *mod
|= GL_COMP_BIT_ATI
;
205 if(arg
& WINED3DTA_ALPHAREPLICATE
) {
206 FIXME("Unhandled read modifier WINED3DTA_ALPHAREPLICATE\n");
211 static GLuint
find_tmpreg(struct texture_stage_op op
[MAX_TEXTURES
]) {
212 int lowest_read
= -1;
213 int lowest_write
= -1;
215 BOOL tex_used
[MAX_TEXTURES
];
217 memset(tex_used
, 0, sizeof(tex_used
));
218 for(i
= 0; i
< MAX_TEXTURES
; i
++) {
219 if(op
[i
].cop
== WINED3DTOP_DISABLE
) {
223 if(lowest_read
== -1 &&
224 (op
[i
].carg1
== WINED3DTA_TEMP
|| op
[i
].carg2
== WINED3DTA_TEMP
|| op
[i
].carg0
== WINED3DTA_TEMP
||
225 op
[i
].aarg1
== WINED3DTA_TEMP
|| op
[i
].aarg2
== WINED3DTA_TEMP
|| op
[i
].aarg0
== WINED3DTA_TEMP
)) {
229 if(lowest_write
== -1 && op
[i
].dst
== tempreg
) {
233 if(op
[i
].carg1
== WINED3DTA_TEXTURE
|| op
[i
].carg2
== WINED3DTA_TEXTURE
|| op
[i
].carg0
== WINED3DTA_TEXTURE
||
234 op
[i
].aarg1
== WINED3DTA_TEXTURE
|| op
[i
].aarg2
== WINED3DTA_TEXTURE
|| op
[i
].aarg0
== WINED3DTA_TEXTURE
) {
239 /* Temp reg not read? We don't need it, return GL_NONE */
240 if(lowest_read
== -1) return GL_NONE
;
242 if(lowest_write
>= lowest_read
) {
243 FIXME("Temp register read before being written\n");
246 if(lowest_write
== -1) {
247 /* This needs a test. Maybe we are supposed to return 0.0/0.0/0.0/0.0, or fail drawprim, or whatever */
248 FIXME("Temp register read without being written\n");
250 } else if(lowest_write
>= 1) {
251 /* If we're writing to the temp reg at earliest in stage 1, we can use register 1 for the temp result.
252 * there may be texture data stored in reg 1, but we do not need it any longer since stage 1 already
257 /* Search for a free texture register. We have 6 registers available. GL_REG_0_ATI is already used
258 * for the regular result
260 for(i
= 1; i
< 6; i
++) {
262 return GL_REG_0_ATI
+ i
;
265 /* What to do here? Report it in ValidateDevice? */
266 FIXME("Could not find a register for the temporary register\n");
271 static GLuint
gen_ati_shader(struct texture_stage_op op
[MAX_TEXTURES
], WineD3D_GL_Info
*gl_info
) {
272 GLuint ret
= GL_EXTCALL(glGenFragmentShadersATI(1));
274 GLuint arg0
, arg1
, arg2
, extrarg
;
275 GLuint dstmod
, argmod0
, argmod1
, argmod2
, argmodextra
;
277 GLuint tmparg
= find_tmpreg(op
);
281 ERR("Failed to generate a GL_ATI_fragment_shader shader id\n");
284 GL_EXTCALL(glBindFragmentShaderATI(ret
));
285 checkGLcall("GL_EXTCALL(glBindFragmentShaderATI(ret))");
287 TRACE("glBeginFragmentShaderATI()\n");
288 GL_EXTCALL(glBeginFragmentShaderATI());
289 checkGLcall("GL_EXTCALL(glBeginFragmentShaderATI())");
291 /* Pass 1: Generate sampling instructions for perturbation maps */
292 for(stage
= 0; stage
< GL_LIMITS(textures
); stage
++) {
293 if(op
[stage
].cop
== WINED3DTOP_DISABLE
) break;
294 if(op
[stage
].cop
!= WINED3DTOP_BUMPENVMAP
&&
295 op
[stage
].cop
!= WINED3DTOP_BUMPENVMAPLUMINANCE
) continue;
297 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, GL_SWIZZLE_STR_ATI)\n",
299 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
300 GL_TEXTURE0_ARB
+ stage
,
301 GL_SWIZZLE_STR_ATI
));
302 TRACE("glPassTexCoordATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, GL_SWIZZLE_STR_ATI)\n",
303 stage
+ 1, stage
+ 1);
304 GL_EXTCALL(glPassTexCoordATI(GL_REG_0_ATI
+ stage
+ 1,
305 GL_TEXTURE0_ARB
+ stage
+ 1,
306 GL_SWIZZLE_STR_ATI
));
308 /* We need GL_REG_5_ATI as a temporary register to swizzle the bump matrix. So we run into
309 * issues if we're bump mapping on stage 4 or 5
312 FIXME("Bump mapping in stage %d\n", stage
);
316 /* Pass 2: Generate perturbation calculations */
317 for(stage
= 0; stage
< GL_LIMITS(textures
); stage
++) {
318 if(op
[stage
].cop
== WINED3DTOP_DISABLE
) break;
319 if(op
[stage
].cop
!= WINED3DTOP_BUMPENVMAP
&&
320 op
[stage
].cop
!= WINED3DTOP_BUMPENVMAPLUMINANCE
) continue;
322 /* Nice thing, we get the color correction for free :-) */
323 if(op
[stage
].color_correction
== WINED3DFMT_V8U8
) {
324 argmodextra
= GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
;
329 TRACE("glColorFragmentOp3ATI(GL_DOT2_ADD_ATI, GL_REG_%d_ATI, GL_RED_BIT_ATI, GL_NONE, GL_REG_%d_ATI, GL_NONE, %s, ATI_FFP_CONST_BUMPMAT(%d), GL_NONE, GL_NONE, GL_REG_%d_ATI, GL_RED, GL_NONE)\n",
330 stage
+ 1, stage
, debug_argmod(argmodextra
), stage
, stage
+ 1);
331 GL_EXTCALL(glColorFragmentOp3ATI(GL_DOT2_ADD_ATI
, GL_REG_0_ATI
+ stage
+ 1, GL_RED_BIT_ATI
, GL_NONE
,
332 GL_REG_0_ATI
+ stage
, GL_NONE
, argmodextra
,
333 ATI_FFP_CONST_BUMPMAT(stage
), GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
,
334 GL_REG_0_ATI
+ stage
+ 1, GL_RED
, GL_NONE
));
336 /* FIXME: How can I make GL_DOT2_ADD_ATI read the factors from blue and alpha? It defaults to red and green,
337 * and it is fairly easy to make it read GL_BLUE or BL_ALPHA, but I can't get an R * B + G * A. So we're wasting
338 * one register and two instructions in this pass for a simple swizzling operation.
339 * For starters it might be good enough to merge the two movs into one, but even that isn't possible :-(
341 * NOTE: GL_BLUE | GL_ALPHA is not possible. It doesn't throw a compilation error, but an OR operation on the
342 * constants doesn't make sense, considering their values.
344 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_5_ATI, GL_RED_BIT_ATI, GL_NONE, ATI_FFP_CONST_BUMPMAT(%d), GL_BLUE, GL_NONE)\n", stage
);
345 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI
, GL_REG_5_ATI
, GL_RED_BIT_ATI
, GL_NONE
,
346 ATI_FFP_CONST_BUMPMAT(stage
), GL_BLUE
, GL_NONE
));
347 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_5_ATI, GL_GREEN_BIT_ATI, GL_NONE, ATI_FFP_CONST_BUMPMAT(%d), GL_ALPHA, GL_NONE)\n", stage
);
348 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI
, GL_REG_5_ATI
, GL_GREEN_BIT_ATI
, GL_NONE
,
349 ATI_FFP_CONST_BUMPMAT(stage
), GL_ALPHA
, GL_NONE
));
350 TRACE("glColorFragmentOp3ATI(GL_DOT2_ADD_ATI, GL_REG_%d_ATI, GL_GREEN_BIT_ATI, GL_NONE, GL_REG_%d_ATI, GL_NONE, %s, GL_REG_5_ATI, GL_NONE, GL_NONE, GL_REG_%d_ATI, GL_GREEN, GL_NONE)\n",
351 stage
+ 1, stage
, debug_argmod(argmodextra
), stage
+ 1);
352 GL_EXTCALL(glColorFragmentOp3ATI(GL_DOT2_ADD_ATI
, GL_REG_0_ATI
+ stage
+ 1, GL_GREEN_BIT_ATI
, GL_NONE
,
353 GL_REG_0_ATI
+ stage
, GL_NONE
, argmodextra
,
354 GL_REG_5_ATI
, GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
,
355 GL_REG_0_ATI
+ stage
+ 1, GL_GREEN
, GL_NONE
));
358 /* Pass 3: Generate sampling instructions for regular textures */
359 for(stage
= 0; stage
< GL_LIMITS(textures
); stage
++) {
360 if(op
[stage
].cop
== WINED3DTOP_DISABLE
) {
364 if(op
[stage
].projected
== proj_none
) {
365 swizzle
= GL_SWIZZLE_STR_ATI
;
366 } else if(op
[stage
].projected
== proj_count3
) {
367 /* TODO: D3DTTFF_COUNT3 | D3DTTFF_PROJECTED would be GL_SWIZZLE_STR_DR_ATI.
368 * However, the FFP vertex processing texture transform matrix handler does
369 * some transformations in the texture matrix which makes the 3rd coordinate
370 * arrive in Q, not R in that case. This is needed for opengl fixed function
371 * fragment processing which always divides by Q. In this backend we can
372 * handle that properly and be compatible with vertex shader output and avoid
373 * side effects of the texture matrix games
375 swizzle
= GL_SWIZZLE_STQ_DQ_ATI
;
377 swizzle
= GL_SWIZZLE_STQ_DQ_ATI
;
380 if((op
[stage
].carg0
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
381 (op
[stage
].carg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
382 (op
[stage
].carg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
383 (op
[stage
].aarg0
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
384 (op
[stage
].aarg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
385 (op
[stage
].aarg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
||
386 op
[stage
].cop
== WINED3DTOP_BLENDTEXTUREALPHA
) {
389 (op
[stage
- 1].cop
== WINED3DTOP_BUMPENVMAP
||
390 op
[stage
- 1].cop
== WINED3DTOP_BUMPENVMAPLUMINANCE
)) {
391 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_REG_%d_ATI, GL_SWIZZLE_STR_ATI)\n",
393 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
394 GL_REG_0_ATI
+ stage
,
395 GL_SWIZZLE_STR_ATI
));
397 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, %s)\n",
398 stage
, stage
, debug_swizzle(swizzle
));
399 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
400 GL_TEXTURE0_ARB
+ stage
,
406 /* Pass 4: Generate the arithmetic instructions */
407 for(stage
= 0; stage
< MAX_TEXTURES
; stage
++) {
408 if(op
[stage
].cop
== WINED3DTOP_DISABLE
) {
410 /* Handle complete texture disabling gracefully */
411 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
412 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI
, GL_REG_0_ATI
, GL_NONE
, GL_NONE
,
413 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
));
414 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
415 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI
, GL_REG_0_ATI
, GL_NONE
,
416 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
));
421 if(op
[stage
].dst
== tempreg
) {
422 /* If we're writing to D3DTA_TEMP, but never reading from it we don't have to write there in the first place.
423 * skip the entire stage, this saves some GPU time
425 if(tmparg
== GL_NONE
) continue;
429 dstreg
= GL_REG_0_ATI
;
432 arg0
= register_for_arg(op
[stage
].carg0
, gl_info
, stage
, &argmod0
, tmparg
);
433 arg1
= register_for_arg(op
[stage
].carg1
, gl_info
, stage
, &argmod1
, tmparg
);
434 arg2
= register_for_arg(op
[stage
].carg2
, gl_info
, stage
, &argmod2
, tmparg
);
436 argmodextra
= GL_NONE
;
439 switch(op
[stage
].cop
) {
440 case WINED3DTOP_SELECTARG2
:
443 case WINED3DTOP_SELECTARG1
:
444 TRACE("glColorFragmentOp1ATI(GL_MOV_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s)\n",
445 debug_register(dstreg
), debug_register(arg1
), debug_argmod(argmod1
));
446 GL_EXTCALL(glColorFragmentOp1ATI(GL_MOV_ATI
, dstreg
, GL_NONE
, GL_NONE
,
447 arg1
, GL_NONE
, argmod1
));
450 case WINED3DTOP_MODULATE4X
:
451 if(dstmod
== GL_NONE
) dstmod
= GL_4X_BIT_ATI
;
452 case WINED3DTOP_MODULATE2X
:
453 if(dstmod
== GL_NONE
) dstmod
= GL_2X_BIT_ATI
;
454 case WINED3DTOP_MODULATE
:
455 TRACE("glColorFragmentOp2ATI(GL_MUL_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
456 debug_register(dstreg
), debug_dstmod(dstmod
),
457 debug_register(arg1
), debug_argmod(argmod1
),
458 debug_register(arg2
), debug_argmod(argmod2
));
459 GL_EXTCALL(glColorFragmentOp2ATI(GL_MUL_ATI
, dstreg
, GL_NONE
, dstmod
,
460 arg1
, GL_NONE
, argmod1
,
461 arg2
, GL_NONE
, argmod2
));
464 case WINED3DTOP_ADDSIGNED2X
:
465 dstmod
= GL_2X_BIT_ATI
;
466 case WINED3DTOP_ADDSIGNED
:
467 argmodextra
= GL_BIAS_BIT_ATI
;
469 TRACE("glColorFragmentOp2ATI(GL_ADD_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
470 debug_register(dstreg
), debug_dstmod(dstmod
),
471 debug_register(arg1
), debug_argmod(argmod1
),
472 debug_register(arg2
), debug_argmod(argmodextra
| argmod2
));
473 GL_EXTCALL(glColorFragmentOp2ATI(GL_ADD_ATI
, GL_REG_0_ATI
, GL_NONE
, dstmod
,
474 arg1
, GL_NONE
, argmod1
,
475 arg2
, GL_NONE
, argmodextra
| argmod2
));
478 case WINED3DTOP_SUBTRACT
:
479 TRACE("glColorFragmentOp2ATI(GL_SUB_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
480 debug_register(dstreg
), debug_dstmod(dstmod
),
481 debug_register(arg1
), debug_argmod(argmod1
),
482 debug_register(arg2
), debug_argmod(argmod2
));
483 GL_EXTCALL(glColorFragmentOp2ATI(GL_SUB_ATI
, dstreg
, GL_NONE
, dstmod
,
484 arg1
, GL_NONE
, argmod1
,
485 arg2
, GL_NONE
, argmod2
));
488 case WINED3DTOP_ADDSMOOTH
:
489 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
490 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
491 debug_register(dstreg
),
492 debug_register(arg2
), debug_argmod(argmod2
),
493 debug_register(arg1
), debug_argmod(argmodextra
),
494 debug_register(arg1
), debug_argmod(argmod1
));
495 /* Dst = arg1 + * arg2(1 -arg 1)
496 * = arg2 * (1 - arg1) + arg1
498 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_NONE
,
499 arg2
, GL_NONE
, argmod2
,
500 arg1
, GL_NONE
, argmodextra
,
501 arg1
, GL_NONE
, argmod1
));
504 case WINED3DTOP_BLENDCURRENTALPHA
:
505 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_CURRENT
, gl_info
, stage
, NULL
, -1);
506 case WINED3DTOP_BLENDFACTORALPHA
:
507 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_TFACTOR
, gl_info
, stage
, NULL
, -1);
508 case WINED3DTOP_BLENDTEXTUREALPHA
:
509 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, -1);
510 case WINED3DTOP_BLENDDIFFUSEALPHA
:
511 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_DIFFUSE
, gl_info
, stage
, NULL
, -1);
512 TRACE("glColorFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, GL_NONE, %s, GL_ALPHA, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
513 debug_register(dstreg
),
514 debug_register(extrarg
),
515 debug_register(arg1
), debug_argmod(argmod1
),
516 debug_register(arg2
), debug_argmod(argmod2
));
517 GL_EXTCALL(glColorFragmentOp3ATI(GL_LERP_ATI
, dstreg
, GL_NONE
, GL_NONE
,
518 extrarg
, GL_ALPHA
, GL_NONE
,
519 arg1
, GL_NONE
, argmod1
,
520 arg2
, GL_NONE
, argmod2
));
523 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
524 arg0
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, -1);
525 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s, %s, GL_ALPHA, GL_COMP_BIT_ATI, %s, GL_NONE, %s)\n",
526 debug_register(dstreg
),
527 debug_register(arg2
), debug_argmod(argmod2
),
528 debug_register(arg0
),
529 debug_register(arg1
), debug_argmod(argmod1
));
530 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_NONE
,
531 arg2
, GL_NONE
, argmod2
,
532 arg0
, GL_ALPHA
, GL_COMP_BIT_ATI
,
533 arg1
, GL_NONE
, argmod1
));
536 /* D3DTOP_PREMODULATE ???? */
538 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
539 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
540 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
541 if(!argmodextra
) argmodextra
= argmod1
;
542 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s, %s, GL_ALPHA, %s, %s, GL_NONE, %s)\n",
543 debug_register(dstreg
),
544 debug_register(arg2
), debug_argmod(argmod2
),
545 debug_register(arg1
), debug_argmod(argmodextra
), debug_register(arg1
), debug_argmod(arg1
));
546 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_NONE
,
547 arg2
, GL_NONE
, argmod2
,
548 arg1
, GL_ALPHA
, argmodextra
,
549 arg1
, GL_NONE
, argmod1
));
552 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
553 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
554 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
555 if(!argmodextra
) argmodextra
= argmod1
;
556 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_ALPHA, %s)\n",
557 debug_register(dstreg
),
558 debug_register(arg2
), debug_argmod(argmod2
),
559 debug_register(arg1
), debug_argmod(argmodextra
),
560 debug_register(arg1
), debug_argmod(argmod1
));
561 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_NONE
,
562 arg2
, GL_NONE
, argmod2
,
563 arg1
, GL_NONE
, argmodextra
,
564 arg1
, GL_ALPHA
, argmod1
));
567 case WINED3DTOP_DOTPRODUCT3
:
568 TRACE("glColorFragmentOp2ATI(GL_DOT3_ATI, %s, GL_NONE, GL_4X_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
569 debug_register(dstreg
),
570 debug_register(arg1
), debug_argmod(argmod1
| GL_BIAS_BIT_ATI
),
571 debug_register(arg2
), debug_argmod(argmod2
| GL_BIAS_BIT_ATI
));
572 GL_EXTCALL(glColorFragmentOp2ATI(GL_DOT3_ATI
, dstreg
, GL_NONE
, GL_4X_BIT_ATI
,
573 arg1
, GL_NONE
, argmod1
| GL_BIAS_BIT_ATI
,
574 arg2
, GL_NONE
, argmod2
| GL_BIAS_BIT_ATI
));
577 case WINED3DTOP_MULTIPLYADD
:
578 TRACE("glColorFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
579 debug_register(dstreg
),
580 debug_register(arg1
), debug_argmod(argmod1
),
581 debug_register(arg2
), debug_argmod(argmod2
),
582 debug_register(arg0
), debug_argmod(argmod0
));
583 GL_EXTCALL(glColorFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
, GL_NONE
,
584 arg1
, GL_NONE
, argmod1
,
585 arg2
, GL_NONE
, argmod2
,
586 arg0
, GL_NONE
, argmod0
));
589 case WINED3DTOP_LERP
:
590 TRACE("glColorFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
591 debug_register(dstreg
),
592 debug_register(arg1
), debug_argmod(argmod1
),
593 debug_register(arg2
), debug_argmod(argmod2
),
594 debug_register(arg0
), debug_argmod(argmod0
));
595 GL_EXTCALL(glColorFragmentOp3ATI(GL_LERP_ATI
, dstreg
, GL_NONE
, GL_NONE
,
596 arg0
, GL_NONE
, argmod0
,
597 arg1
, GL_NONE
, argmod1
,
598 arg2
, GL_NONE
, argmod2
));
601 case WINED3DTOP_BUMPENVMAP
:
602 case WINED3DTOP_BUMPENVMAPLUMINANCE
:
603 /* Those are handled in the first pass of the shader(generation pass 1 and 2) already */
606 default: FIXME("Unhandled color operation %d on stage %d\n", op
[stage
].cop
, stage
);
609 arg0
= register_for_arg(op
[stage
].aarg0
, gl_info
, stage
, &argmod0
, tmparg
);
610 arg1
= register_for_arg(op
[stage
].aarg1
, gl_info
, stage
, &argmod1
, tmparg
);
611 arg2
= register_for_arg(op
[stage
].aarg2
, gl_info
, stage
, &argmod2
, tmparg
);
613 argmodextra
= GL_NONE
;
616 switch(op
[stage
].aop
) {
617 case WINED3DTOP_DISABLE
:
618 /* Get the primary color to the output if on stage 0, otherwise leave register 0 untouched */
620 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE)\n");
621 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI
, GL_REG_0_ATI
, GL_NONE
,
622 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
));
626 case WINED3DTOP_SELECTARG2
:
629 case WINED3DTOP_SELECTARG1
:
630 TRACE("glAlphaFragmentOp1ATI(GL_MOV_ATI, %s, GL_NONE, %s, GL_NONE, %s)\n",
631 debug_register(dstreg
),
632 debug_register(arg1
), debug_argmod(argmod1
));
633 GL_EXTCALL(glAlphaFragmentOp1ATI(GL_MOV_ATI
, dstreg
, GL_NONE
,
634 arg1
, GL_NONE
, argmod1
));
637 case WINED3DTOP_MODULATE4X
:
638 if(dstmod
== GL_NONE
) dstmod
= GL_4X_BIT_ATI
;
639 case WINED3DTOP_MODULATE2X
:
640 if(dstmod
== GL_NONE
) dstmod
= GL_2X_BIT_ATI
;
641 case WINED3DTOP_MODULATE
:
642 TRACE("glAlphaFragmentOp2ATI(GL_MUL_ATI, %s, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
643 debug_register(dstreg
), debug_dstmod(dstmod
),
644 debug_register(arg1
), debug_argmod(argmod1
),
645 debug_register(arg2
), debug_argmod(argmod2
));
646 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_MUL_ATI
, dstreg
, dstmod
,
647 arg1
, GL_NONE
, argmod1
,
648 arg2
, GL_NONE
, argmod2
));
651 case WINED3DTOP_ADDSIGNED2X
:
652 dstmod
= GL_2X_BIT_ATI
;
653 case WINED3DTOP_ADDSIGNED
:
654 argmodextra
= GL_BIAS_BIT_ATI
;
656 TRACE("glAlphaFragmentOp2ATI(GL_ADD_ATI, %s, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
657 debug_register(dstreg
), debug_dstmod(dstmod
),
658 debug_register(arg1
), debug_argmod(argmod1
),
659 debug_register(arg2
), debug_argmod(argmodextra
| argmod2
));
660 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_ADD_ATI
, dstreg
, dstmod
,
661 arg1
, GL_NONE
, argmod1
,
662 arg2
, GL_NONE
, argmodextra
| argmod2
));
665 case WINED3DTOP_SUBTRACT
:
666 TRACE("glAlphaFragmentOp2ATI(GL_SUB_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
667 debug_register(dstreg
), debug_dstmod(dstmod
),
668 debug_register(arg1
), debug_argmod(argmod1
),
669 debug_register(arg2
), debug_argmod(argmod2
));
670 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_SUB_ATI
, dstreg
, dstmod
,
671 arg1
, GL_NONE
, argmod1
,
672 arg2
, GL_NONE
, argmod2
));
675 case WINED3DTOP_ADDSMOOTH
:
676 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
677 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
678 debug_register(dstreg
),
679 debug_register(arg2
), debug_argmod(argmod2
),
680 debug_register(arg1
), debug_argmod(argmodextra
),
681 debug_register(arg1
), debug_argmod(argmod1
));
682 /* Dst = arg1 + * arg2(1 -arg 1)
683 * = arg2 * (1 - arg1) + arg1
685 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
,
686 arg2
, GL_NONE
, argmod2
,
687 arg1
, GL_NONE
, argmodextra
,
688 arg1
, GL_NONE
, argmod1
));
691 case WINED3DTOP_BLENDCURRENTALPHA
:
692 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_CURRENT
, gl_info
, stage
, NULL
, -1);
693 case WINED3DTOP_BLENDFACTORALPHA
:
694 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_TFACTOR
, gl_info
, stage
, NULL
, -1);
695 case WINED3DTOP_BLENDTEXTUREALPHA
:
696 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, -1);
697 case WINED3DTOP_BLENDDIFFUSEALPHA
:
698 if(extrarg
== GL_NONE
) extrarg
= register_for_arg(WINED3DTA_DIFFUSE
, gl_info
, stage
, NULL
, -1);
699 TRACE("glAlphaFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, %s, GL_ALPHA, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
700 debug_register(dstreg
),
701 debug_register(extrarg
),
702 debug_register(arg1
), debug_argmod(argmod1
),
703 debug_register(arg2
), debug_argmod(argmod2
));
704 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_LERP_ATI
, dstreg
, GL_NONE
,
705 extrarg
, GL_ALPHA
, GL_NONE
,
706 arg1
, GL_NONE
, argmod1
,
707 arg2
, GL_NONE
, argmod2
));
710 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
711 arg0
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, -1);
712 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, %s, GL_NONE, %s, %s, GL_ALPHA, GL_COMP_BIT_ATI, %s, GL_NONE, %s)\n",
713 debug_register(dstreg
),
714 debug_register(arg2
), debug_argmod(argmod2
),
715 debug_register(arg0
),
716 debug_register(arg1
), debug_argmod(argmod1
));
717 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
,
718 arg2
, GL_NONE
, argmod2
,
719 arg0
, GL_ALPHA
, GL_COMP_BIT_ATI
,
720 arg1
, GL_NONE
, argmod1
));
723 /* D3DTOP_PREMODULATE ???? */
725 case WINED3DTOP_DOTPRODUCT3
:
726 TRACE("glAlphaFragmentOp2ATI(GL_DOT3_ATI, %s, GL_NONE, GL_4X_BIT_ATI, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
727 debug_register(dstreg
),
728 debug_register(arg1
), debug_argmod(argmod1
| GL_BIAS_BIT_ATI
),
729 debug_register(arg2
), debug_argmod(argmod2
| GL_BIAS_BIT_ATI
));
730 GL_EXTCALL(glAlphaFragmentOp2ATI(GL_DOT3_ATI
, dstreg
, GL_4X_BIT_ATI
,
731 arg1
, GL_NONE
, argmod1
| GL_BIAS_BIT_ATI
,
732 arg2
, GL_NONE
, argmod2
| GL_BIAS_BIT_ATI
));
735 case WINED3DTOP_MULTIPLYADD
:
736 TRACE("glAlphaFragmentOp3ATI(GL_MAD_ATI, %s, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
737 debug_register(dstreg
),
738 debug_register(arg1
), debug_argmod(argmod1
),
739 debug_register(arg2
), debug_argmod(argmod2
),
740 debug_register(arg0
), debug_argmod(argmod0
));
741 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_MAD_ATI
, dstreg
, GL_NONE
,
742 arg1
, GL_NONE
, argmod1
,
743 arg2
, GL_NONE
, argmod2
,
744 arg0
, GL_NONE
, argmod0
));
747 case WINED3DTOP_LERP
:
748 TRACE("glAlphaFragmentOp3ATI(GL_LERP_ATI, %s, GL_NONE, %s, GL_NONE, %s, %s, GL_NONE, %s, %s, GL_NONE, %s)\n",
749 debug_register(dstreg
),
750 debug_register(arg1
), debug_argmod(argmod1
),
751 debug_register(arg2
), debug_argmod(argmod2
),
752 debug_register(arg0
), debug_argmod(argmod0
));
753 GL_EXTCALL(glAlphaFragmentOp3ATI(GL_LERP_ATI
, dstreg
, GL_NONE
,
754 arg1
, GL_NONE
, argmod1
,
755 arg2
, GL_NONE
, argmod2
,
756 arg0
, GL_NONE
, argmod0
));
759 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
760 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
761 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
762 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
763 case WINED3DTOP_BUMPENVMAP
:
764 case WINED3DTOP_BUMPENVMAPLUMINANCE
:
765 ERR("Application uses an invalid alpha operation\n");
768 default: FIXME("Unhandled alpha operation %d on stage %d\n", op
[stage
].aop
, stage
);
772 TRACE("glEndFragmentShaderATI()\n");
773 GL_EXTCALL(glEndFragmentShaderATI());
774 checkGLcall("GL_EXTCALL(glEndFragmentShaderATI())");
777 #undef GLINFO_LOCATION
779 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
780 static void set_tex_op_atifs(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
781 IWineD3DDeviceImpl
*This
= stateblock
->wineD3DDevice
;
782 struct atifs_ffp_desc
*desc
;
783 struct ffp_settings settings
;
784 struct atifs_private_data
*priv
= (struct atifs_private_data
*) This
->fragment_priv
;
788 gen_ffp_op(stateblock
, &settings
, TRUE
);
789 desc
= (struct atifs_ffp_desc
*) find_ffp_shader(priv
->fragment_shaders
, &settings
);
791 desc
= HeapAlloc(GetProcessHeap(), 0, sizeof(*desc
));
793 ERR("Out of memory\n");
796 desc
->num_textures_used
= 0;
797 for(i
= 0; i
< GL_LIMITS(texture_stages
); i
++) {
798 if(settings
.op
[i
].cop
== WINED3DTOP_DISABLE
) break;
799 desc
->num_textures_used
= i
;
802 memcpy(&desc
->parent
.settings
, &settings
, sizeof(settings
));
803 desc
->shader
= gen_ati_shader(settings
.op
, &GLINFO_LOCATION
);
804 add_ffp_shader(priv
->fragment_shaders
, &desc
->parent
);
805 TRACE("Allocated fixed function replacement shader descriptor %p\n", desc
);
808 /* GL_ATI_fragment_shader depends on the GL_TEXTURE_xD enable settings. Update the texture stages
809 * used by this shader
811 for(i
= 0; i
< desc
->num_textures_used
; i
++) {
812 mapped_stage
= This
->texUnitMap
[i
];
813 if(mapped_stage
!= -1) {
814 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
815 checkGLcall("glActiveTextureARB");
816 texture_activate_dimensions(i
, stateblock
, context
);
820 GL_EXTCALL(glBindFragmentShaderATI(desc
->shader
));
823 static void state_texfactor_atifs(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
825 D3DCOLORTOGLFLOAT4(stateblock
->renderState
[WINED3DRS_TEXTUREFACTOR
], col
);
827 GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR
, col
));
828 checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR, col)");
831 static void set_bumpmat(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, WineD3DContext
*context
) {
832 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE
;
835 mat
[0][0] = *((float *) &stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVMAT00
]);
836 mat
[1][0] = *((float *) &stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVMAT01
]);
837 mat
[0][1] = *((float *) &stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVMAT10
]);
838 mat
[1][1] = *((float *) &stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVMAT11
]);
839 /* GL_ATI_fragment_shader allows only constants from 0.0 to 1.0, but the bumpmat
840 * constants can be in any range. While they should stay between [-1.0 and 1.0] because
841 * Shader Model 1.x pixel shaders are clamped to that range negative values are used occasionally,
842 * for example by our d3d9 test. So to get negative values scale -1;1 to 0;1 and undo that in the
843 * shader(it is free). This might potentially reduce precision. However, if the hardware does
844 * support proper floats it shouldn't, and if it doesn't we can't get anything better anyway
846 mat
[0][0] = (mat
[0][0] + 1.0) * 0.5;
847 mat
[1][0] = (mat
[1][0] + 1.0) * 0.5;
848 mat
[0][1] = (mat
[0][1] + 1.0) * 0.5;
849 mat
[1][1] = (mat
[1][1] + 1.0) * 0.5;
850 GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_BUMPMAT(stage
), (float *) mat
));
851 checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_BUMPMAT(stage), mat)");
853 #undef GLINFO_LOCATION
855 static const struct StateEntryTemplate atifs_fragmentstate_template
[] = {
856 {STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), state_texfactor_atifs
}, 0 },
857 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
858 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
859 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
860 {STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
861 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
862 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
863 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
864 {STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
865 {STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
866 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
867 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
868 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
869 {STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
870 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
871 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
872 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
873 {STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
874 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
875 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
876 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
877 {STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
878 {STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
879 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
880 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
881 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
882 {STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
883 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
884 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
885 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
886 {STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
887 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
888 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
889 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
890 {STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
891 {STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
892 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
893 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
894 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
895 {STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
896 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
897 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
898 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
899 {STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
900 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
901 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
902 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
903 {STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
904 {STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
905 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
906 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
907 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
908 {STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
909 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
910 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
911 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
912 {STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
913 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
914 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
915 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
916 {STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
917 {STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
918 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
919 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
920 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
921 {STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
922 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
923 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
924 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
925 {STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
926 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
927 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
928 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
929 {STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
930 {STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
931 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
932 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
933 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
934 {STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
935 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
936 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
937 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
938 {STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
939 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
940 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
941 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
942 {STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
943 {STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
944 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
945 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
946 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
947 {STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
948 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
949 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
950 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
951 {STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
952 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
953 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
954 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
955 {STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
956 {STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), set_tex_op_atifs
}, 0 },
957 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
958 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
959 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
960 {STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), set_bumpmat
}, 0 },
961 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim
}, 0 },
962 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim
}, 0 },
963 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim
}, 0 },
964 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim
}, 0 },
965 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim
}, 0 },
966 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim
}, 0 },
967 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim
}, 0 },
968 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim
}, 0 },
969 {0 /* Terminate */, { 0, 0 }, 0 },
972 static void atifs_enable(IWineD3DDevice
*iface
, BOOL enable
) {
974 glEnable(GL_FRAGMENT_SHADER_ATI
);
975 checkGLcall("glEnable(GL_FRAGMENT_SHADER_ATI)");
977 glDisable(GL_FRAGMENT_SHADER_ATI
);
978 checkGLcall("glDisable(GL_FRAGMENT_SHADER_ATI)");
982 static void atifs_get_caps(WINED3DDEVTYPE devtype
, WineD3D_GL_Info
*gl_info
, struct fragment_caps
*caps
) {
983 caps
->TextureOpCaps
= WINED3DTEXOPCAPS_DISABLE
|
984 WINED3DTEXOPCAPS_SELECTARG1
|
985 WINED3DTEXOPCAPS_SELECTARG2
|
986 WINED3DTEXOPCAPS_MODULATE4X
|
987 WINED3DTEXOPCAPS_MODULATE2X
|
988 WINED3DTEXOPCAPS_MODULATE
|
989 WINED3DTEXOPCAPS_ADDSIGNED2X
|
990 WINED3DTEXOPCAPS_ADDSIGNED
|
991 WINED3DTEXOPCAPS_ADD
|
992 WINED3DTEXOPCAPS_SUBTRACT
|
993 WINED3DTEXOPCAPS_ADDSMOOTH
|
994 WINED3DTEXOPCAPS_BLENDCURRENTALPHA
|
995 WINED3DTEXOPCAPS_BLENDFACTORALPHA
|
996 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
|
997 WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
|
998 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
|
999 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
|
1000 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
|
1001 WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA
|
1002 WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
|
1003 WINED3DTEXOPCAPS_DOTPRODUCT3
|
1004 WINED3DTEXOPCAPS_MULTIPLYADD
|
1005 WINED3DTEXOPCAPS_LERP
|
1006 WINED3DTEXOPCAPS_BUMPENVMAP
;
1008 /* TODO: Implement WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
1009 and WINED3DTEXOPCAPS_PREMODULATE */
1011 /* GL_ATI_fragment_shader always supports 6 textures, which was the limit on r200 cards
1012 * which this extension is exclusively focused on(later cards have GL_ARB_fragment_program).
1013 * If the current card has more than 8 fixed function textures in OpenGL's regular fixed
1014 * function pipeline then the ATI_fragment_shader backend imposes a stricter limit. This
1015 * shouldn't be too hard since Nvidia cards have a limit of 4 textures with the default ffp
1016 * pipeline, and almost all games are happy with that. We can however support up to 8
1017 * texture stages because we have a 2nd pass limit of 8 instructions, and per stage we use
1018 * only 1 instruction.
1020 * The proper fix for this is not to use GL_ATI_fragment_shader on cards newer than the
1021 * r200 series and use an ARB or GLSL shader instead
1023 caps
->MaxTextureBlendStages
= 8;
1024 caps
->MaxSimultaneousTextures
= 6;
1026 caps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_TSSARGTEMP
;
1029 static HRESULT
atifs_alloc(IWineD3DDevice
*iface
) {
1030 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*) iface
;
1031 struct atifs_private_data
*priv
;
1033 This
->fragment_priv
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(struct atifs_private_data
));
1034 if(!This
->fragment_priv
) {
1035 ERR("Out of memory\n");
1036 return E_OUTOFMEMORY
;
1038 priv
= (struct atifs_private_data
*) This
->fragment_priv
;
1039 priv
->fragment_shaders
= hash_table_create(ffp_program_key_hash
, ffp_program_key_compare
);
1043 #define GLINFO_LOCATION This->adapter->gl_info
1044 static void atifs_free_ffpshader(void *value
, void *device
) {
1045 IWineD3DDeviceImpl
*This
= device
;
1046 struct atifs_ffp_desc
*entry_ati
= value
;
1049 GL_EXTCALL(glDeleteFragmentShaderATI(entry_ati
->shader
));
1050 checkGLcall("glDeleteFragmentShaderATI(entry->shader)");
1051 HeapFree(GetProcessHeap(), 0, entry_ati
);
1055 static void atifs_free(IWineD3DDevice
*iface
) {
1056 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*) iface
;
1057 struct atifs_private_data
*priv
= (struct atifs_private_data
*) This
->fragment_priv
;
1059 hash_table_destroy(priv
->fragment_shaders
, atifs_free_ffpshader
, This
);
1061 HeapFree(GetProcessHeap(), 0, priv
);
1062 This
->fragment_priv
= NULL
;
1064 #undef GLINFO_LOCATION
1066 const struct fragment_pipeline atifs_fragment_pipeline
= {
1071 atifs_fragmentstate_template