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
22 #include "wine/port.h"
27 #include "wined3d_private.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader
);
30 WINE_DECLARE_DEBUG_CHANNEL(d3d
);
32 /* Context activation for state handlers is done by the caller. */
34 /* Some private defines, Constant associations, etc.
35 * Env bump matrix and per stage constant should be independent,
36 * a stage that bump maps can't read the per state constant
38 #define ATI_FFP_CONST_BUMPMAT(i) (GL_CON_0_ATI + i)
39 #define ATI_FFP_CONST_CONSTANT0 GL_CON_0_ATI
40 #define ATI_FFP_CONST_CONSTANT1 GL_CON_1_ATI
41 #define ATI_FFP_CONST_CONSTANT2 GL_CON_2_ATI
42 #define ATI_FFP_CONST_CONSTANT3 GL_CON_3_ATI
43 #define ATI_FFP_CONST_CONSTANT4 GL_CON_4_ATI
44 #define ATI_FFP_CONST_CONSTANT5 GL_CON_5_ATI
45 #define ATI_FFP_CONST_TFACTOR GL_CON_6_ATI
47 /* GL_ATI_fragment_shader specific fixed function pipeline description. "Inherits" from the common one */
50 struct ffp_frag_desc parent
;
52 unsigned int num_textures_used
;
55 struct atifs_private_data
57 struct wine_rb_tree fragment_shaders
; /* A rb-tree to track fragment pipeline replacement shaders */
60 static const char *debug_dstmod(GLuint mod
) {
62 case GL_NONE
: return "GL_NONE";
63 case GL_2X_BIT_ATI
: return "GL_2X_BIT_ATI";
64 case GL_4X_BIT_ATI
: return "GL_4X_BIT_ATI";
65 case GL_8X_BIT_ATI
: return "GL_8X_BIT_ATI";
66 case GL_HALF_BIT_ATI
: return "GL_HALF_BIT_ATI";
67 case GL_QUARTER_BIT_ATI
: return "GL_QUARTER_BIT_ATI";
68 case GL_EIGHTH_BIT_ATI
: return "GL_EIGHTH_BIT_ATI";
69 case GL_SATURATE_BIT_ATI
: return "GL_SATURATE_BIT_ATI";
70 default: return "Unexpected modifier\n";
74 static const char *debug_argmod(GLuint mod
) {
80 return "GL_2X_BIT_ATI";
82 return "GL_COMP_BIT_ATI";
83 case GL_NEGATE_BIT_ATI
:
84 return "GL_NEGATE_BIT_ATI";
86 return "GL_BIAS_BIT_ATI";
88 case GL_2X_BIT_ATI
| GL_COMP_BIT_ATI
:
89 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI";
90 case GL_2X_BIT_ATI
| GL_NEGATE_BIT_ATI
:
91 return "GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI";
92 case GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
:
93 return "GL_2X_BIT_ATI | GL_BIAS_BIT_ATI";
94 case GL_COMP_BIT_ATI
| GL_NEGATE_BIT_ATI
:
95 return "GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI";
96 case GL_COMP_BIT_ATI
| GL_BIAS_BIT_ATI
:
97 return "GL_COMP_BIT_ATI | GL_BIAS_BIT_ATI";
98 case GL_NEGATE_BIT_ATI
| GL_BIAS_BIT_ATI
:
99 return "GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
101 case GL_COMP_BIT_ATI
| GL_NEGATE_BIT_ATI
| GL_BIAS_BIT_ATI
:
102 return "GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
103 case GL_2X_BIT_ATI
| GL_NEGATE_BIT_ATI
| GL_BIAS_BIT_ATI
:
104 return "GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
105 case GL_2X_BIT_ATI
| GL_COMP_BIT_ATI
| GL_BIAS_BIT_ATI
:
106 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_BIAS_BIT_ATI";
107 case GL_2X_BIT_ATI
| GL_COMP_BIT_ATI
| GL_NEGATE_BIT_ATI
:
108 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI";
110 case GL_2X_BIT_ATI
| GL_COMP_BIT_ATI
| GL_NEGATE_BIT_ATI
| GL_BIAS_BIT_ATI
:
111 return "GL_2X_BIT_ATI | GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI | GL_BIAS_BIT_ATI";
114 return "Unexpected argmod combination\n";
117 static const char *debug_register(GLuint reg
) {
119 case GL_REG_0_ATI
: return "GL_REG_0_ATI";
120 case GL_REG_1_ATI
: return "GL_REG_1_ATI";
121 case GL_REG_2_ATI
: return "GL_REG_2_ATI";
122 case GL_REG_3_ATI
: return "GL_REG_3_ATI";
123 case GL_REG_4_ATI
: return "GL_REG_4_ATI";
124 case GL_REG_5_ATI
: return "GL_REG_5_ATI";
126 case GL_CON_0_ATI
: return "GL_CON_0_ATI";
127 case GL_CON_1_ATI
: return "GL_CON_1_ATI";
128 case GL_CON_2_ATI
: return "GL_CON_2_ATI";
129 case GL_CON_3_ATI
: return "GL_CON_3_ATI";
130 case GL_CON_4_ATI
: return "GL_CON_4_ATI";
131 case GL_CON_5_ATI
: return "GL_CON_5_ATI";
132 case GL_CON_6_ATI
: return "GL_CON_6_ATI";
133 case GL_CON_7_ATI
: return "GL_CON_7_ATI";
135 case GL_ZERO
: return "GL_ZERO";
136 case GL_ONE
: return "GL_ONE";
137 case GL_PRIMARY_COLOR
: return "GL_PRIMARY_COLOR";
138 case GL_SECONDARY_INTERPOLATOR_ATI
: return "GL_SECONDARY_INTERPOLATOR_ATI";
140 default: return "Unknown register\n";
144 static const char *debug_swizzle(GLuint swizzle
) {
146 case GL_SWIZZLE_STR_ATI
: return "GL_SWIZZLE_STR_ATI";
147 case GL_SWIZZLE_STQ_ATI
: return "GL_SWIZZLE_STQ_ATI";
148 case GL_SWIZZLE_STR_DR_ATI
: return "GL_SWIZZLE_STR_DR_ATI";
149 case GL_SWIZZLE_STQ_DQ_ATI
: return "GL_SWIZZLE_STQ_DQ_ATI";
150 default: return "unknown swizzle";
154 static const char *debug_rep(GLuint rep
) {
156 case GL_NONE
: return "GL_NONE";
157 case GL_RED
: return "GL_RED";
158 case GL_GREEN
: return "GL_GREEN";
159 case GL_BLUE
: return "GL_BLUE";
160 case GL_ALPHA
: return "GL_ALPHA";
161 default: return "unknown argrep";
165 static const char *debug_op(GLuint op
) {
167 case GL_MOV_ATI
: return "GL_MOV_ATI";
168 case GL_ADD_ATI
: return "GL_ADD_ATI";
169 case GL_MUL_ATI
: return "GL_MUL_ATI";
170 case GL_SUB_ATI
: return "GL_SUB_ATI";
171 case GL_DOT3_ATI
: return "GL_DOT3_ATI";
172 case GL_DOT4_ATI
: return "GL_DOT4_ATI";
173 case GL_MAD_ATI
: return "GL_MAD_ATI";
174 case GL_LERP_ATI
: return "GL_LERP_ATI";
175 case GL_CND_ATI
: return "GL_CND_ATI";
176 case GL_CND0_ATI
: return "GL_CND0_ATI";
177 case GL_DOT2_ADD_ATI
: return "GL_DOT2_ADD_ATI";
178 default: return "unexpected op";
182 static const char *debug_mask(GLuint mask
) {
184 case GL_NONE
: return "GL_NONE";
185 case GL_RED_BIT_ATI
: return "GL_RED_BIT_ATI";
186 case GL_GREEN_BIT_ATI
: return "GL_GREEN_BIT_ATI";
187 case GL_BLUE_BIT_ATI
: return "GL_BLUE_BIT_ATI";
188 case GL_RED_BIT_ATI
| GL_GREEN_BIT_ATI
: return "GL_RED_BIT_ATI | GL_GREEN_BIT_ATI";
189 case GL_RED_BIT_ATI
| GL_BLUE_BIT_ATI
: return "GL_RED_BIT_ATI | GL_BLUE_BIT_ATI";
190 case GL_GREEN_BIT_ATI
| GL_BLUE_BIT_ATI
:return "GL_GREEN_BIT_ATI | GL_BLUE_BIT_ATI";
191 case GL_RED_BIT_ATI
| GL_GREEN_BIT_ATI
| GL_BLUE_BIT_ATI
:return "GL_RED_BIT_ATI | GL_GREEN_BIT_ATI | GL_BLUE_BIT_ATI";
192 default: return "Unexpected writemask";
196 static void wrap_op1(const struct wined3d_gl_info
*gl_info
, GLuint op
, GLuint dst
, GLuint dstMask
, GLuint dstMod
,
197 GLuint arg1
, GLuint arg1Rep
, GLuint arg1Mod
)
199 if(dstMask
== GL_ALPHA
) {
200 TRACE("glAlphaFragmentOp1ATI(%s, %s, %s, %s, %s, %s)\n", debug_op(op
), debug_register(dst
), debug_dstmod(dstMod
),
201 debug_register(arg1
), debug_rep(arg1Rep
), debug_argmod(arg1Mod
));
202 GL_EXTCALL(glAlphaFragmentOp1ATI(op
, dst
, dstMod
, arg1
, arg1Rep
, arg1Mod
));
204 TRACE("glColorFragmentOp1ATI(%s, %s, %s, %s, %s, %s, %s)\n", debug_op(op
), debug_register(dst
),
205 debug_mask(dstMask
), debug_dstmod(dstMod
),
206 debug_register(arg1
), debug_rep(arg1Rep
), debug_argmod(arg1Mod
));
207 GL_EXTCALL(glColorFragmentOp1ATI(op
, dst
, dstMask
, dstMod
, arg1
, arg1Rep
, arg1Mod
));
211 static void wrap_op2(const struct wined3d_gl_info
*gl_info
, GLuint op
, GLuint dst
, GLuint dstMask
, GLuint dstMod
,
212 GLuint arg1
, GLuint arg1Rep
, GLuint arg1Mod
, GLuint arg2
, GLuint arg2Rep
, GLuint arg2Mod
)
214 if(dstMask
== GL_ALPHA
) {
215 TRACE("glAlphaFragmentOp2ATI(%s, %s, %s, %s, %s, %s, %s, %s, %s)\n", debug_op(op
), debug_register(dst
), debug_dstmod(dstMod
),
216 debug_register(arg1
), debug_rep(arg1Rep
), debug_argmod(arg1Mod
),
217 debug_register(arg2
), debug_rep(arg2Rep
), debug_argmod(arg2Mod
));
218 GL_EXTCALL(glAlphaFragmentOp2ATI(op
, dst
, dstMod
, arg1
, arg1Rep
, arg1Mod
, arg2
, arg2Rep
, arg2Mod
));
220 TRACE("glColorFragmentOp2ATI(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n", debug_op(op
), debug_register(dst
),
221 debug_mask(dstMask
), debug_dstmod(dstMod
),
222 debug_register(arg1
), debug_rep(arg1Rep
), debug_argmod(arg1Mod
),
223 debug_register(arg2
), debug_rep(arg2Rep
), debug_argmod(arg2Mod
));
224 GL_EXTCALL(glColorFragmentOp2ATI(op
, dst
, dstMask
, dstMod
, arg1
, arg1Rep
, arg1Mod
, arg2
, arg2Rep
, arg2Mod
));
228 static void wrap_op3(const struct wined3d_gl_info
*gl_info
, GLuint op
, GLuint dst
, GLuint dstMask
, GLuint dstMod
,
229 GLuint arg1
, GLuint arg1Rep
, GLuint arg1Mod
, GLuint arg2
, GLuint arg2Rep
, GLuint arg2Mod
,
230 GLuint arg3
, GLuint arg3Rep
, GLuint arg3Mod
)
232 if(dstMask
== GL_ALPHA
) {
233 /* Leave some free space to fit "GL_NONE, " in to align most alpha and color op lines */
234 TRACE("glAlphaFragmentOp3ATI(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n", debug_op(op
), debug_register(dst
), debug_dstmod(dstMod
),
235 debug_register(arg1
), debug_rep(arg1Rep
), debug_argmod(arg1Mod
),
236 debug_register(arg2
), debug_rep(arg2Rep
), debug_argmod(arg2Mod
),
237 debug_register(arg3
), debug_rep(arg3Rep
), debug_argmod(arg3Mod
));
238 GL_EXTCALL(glAlphaFragmentOp3ATI(op
, dst
, dstMod
,
239 arg1
, arg1Rep
, arg1Mod
,
240 arg2
, arg2Rep
, arg2Mod
,
241 arg3
, arg3Rep
, arg3Mod
));
243 TRACE("glColorFragmentOp3ATI(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n", debug_op(op
), debug_register(dst
),
244 debug_mask(dstMask
), debug_dstmod(dstMod
),
245 debug_register(arg1
), debug_rep(arg1Rep
), debug_argmod(arg1Mod
),
246 debug_register(arg2
), debug_rep(arg2Rep
), debug_argmod(arg2Mod
),
247 debug_register(arg3
), debug_rep(arg3Rep
), debug_argmod(arg3Mod
));
248 GL_EXTCALL(glColorFragmentOp3ATI(op
, dst
, dstMask
, dstMod
,
249 arg1
, arg1Rep
, arg1Mod
,
250 arg2
, arg2Rep
, arg2Mod
,
251 arg3
, arg3Rep
, arg3Mod
));
255 static GLuint
register_for_arg(DWORD arg
, const struct wined3d_gl_info
*gl_info
,
256 unsigned int stage
, GLuint
*mod
, GLuint
*rep
, GLuint tmparg
)
260 if(mod
) *mod
= GL_NONE
;
261 if(arg
== ARG_UNUSED
)
263 if (rep
) *rep
= GL_NONE
;
264 return -1; /* This is the marker for unused registers */
267 switch(arg
& WINED3DTA_SELECTMASK
) {
268 case WINED3DTA_DIFFUSE
:
269 ret
= GL_PRIMARY_COLOR
;
272 case WINED3DTA_CURRENT
:
273 /* Note that using GL_REG_0_ATI for the passed on register is safe because
274 * texture0 is read at stage0, so in the worst case it is read in the
275 * instruction writing to reg0. Afterwards texture0 is not used any longer.
276 * If we're reading from current
278 ret
= stage
? GL_REG_0_ATI
: GL_PRIMARY_COLOR
;
281 case WINED3DTA_TEXTURE
:
282 ret
= GL_REG_0_ATI
+ stage
;
285 case WINED3DTA_TFACTOR
:
286 ret
= ATI_FFP_CONST_TFACTOR
;
289 case WINED3DTA_SPECULAR
:
290 ret
= GL_SECONDARY_INTERPOLATOR_ATI
;
297 case WINED3DTA_CONSTANT
:
298 FIXME("Unhandled source argument WINED3DTA_TEMP\n");
303 FIXME("Unknown source argument %d\n", arg
);
307 if(arg
& WINED3DTA_COMPLEMENT
) {
308 if(mod
) *mod
|= GL_COMP_BIT_ATI
;
310 if(arg
& WINED3DTA_ALPHAREPLICATE
) {
311 if(rep
) *rep
= GL_ALPHA
;
313 if(rep
) *rep
= GL_NONE
;
318 static GLuint
find_tmpreg(const struct texture_stage_op op
[MAX_TEXTURES
])
320 int lowest_read
= -1;
321 int lowest_write
= -1;
323 BOOL tex_used
[MAX_TEXTURES
];
325 memset(tex_used
, 0, sizeof(tex_used
));
326 for (i
= 0; i
< MAX_TEXTURES
; ++i
)
328 if (op
[i
].cop
== WINED3D_TOP_DISABLE
)
331 if(lowest_read
== -1 &&
332 (op
[i
].carg1
== WINED3DTA_TEMP
|| op
[i
].carg2
== WINED3DTA_TEMP
|| op
[i
].carg0
== WINED3DTA_TEMP
||
333 op
[i
].aarg1
== WINED3DTA_TEMP
|| op
[i
].aarg2
== WINED3DTA_TEMP
|| op
[i
].aarg0
== WINED3DTA_TEMP
)) {
337 if(lowest_write
== -1 && op
[i
].dst
== tempreg
) {
341 if(op
[i
].carg1
== WINED3DTA_TEXTURE
|| op
[i
].carg2
== WINED3DTA_TEXTURE
|| op
[i
].carg0
== WINED3DTA_TEXTURE
||
342 op
[i
].aarg1
== WINED3DTA_TEXTURE
|| op
[i
].aarg2
== WINED3DTA_TEXTURE
|| op
[i
].aarg0
== WINED3DTA_TEXTURE
) {
347 /* Temp reg not read? We don't need it, return GL_NONE */
348 if(lowest_read
== -1) return GL_NONE
;
350 if(lowest_write
>= lowest_read
) {
351 FIXME("Temp register read before being written\n");
354 if(lowest_write
== -1) {
355 /* This needs a test. Maybe we are supposed to return 0.0/0.0/0.0/0.0, or fail drawprim, or whatever */
356 FIXME("Temp register read without being written\n");
358 } else if(lowest_write
>= 1) {
359 /* If we're writing to the temp reg at earliest in stage 1, we can use register 1 for the temp result.
360 * there may be texture data stored in reg 1, but we do not need it any longer since stage 1 already
365 /* Search for a free texture register. We have 6 registers available. GL_REG_0_ATI is already used
366 * for the regular result
368 for(i
= 1; i
< 6; i
++) {
370 return GL_REG_0_ATI
+ i
;
373 /* What to do here? Report it in ValidateDevice? */
374 FIXME("Could not find a register for the temporary register\n");
379 static const struct color_fixup_desc color_fixup_rg
=
383 0, CHANNEL_SOURCE_ONE
,
384 0, CHANNEL_SOURCE_ONE
386 static const struct color_fixup_desc color_fixup_rgl
=
393 static const struct color_fixup_desc color_fixup_rgba
=
401 static BOOL
op_reads_texture(const struct texture_stage_op
*op
)
403 return (op
->carg0
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
404 || (op
->carg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
405 || (op
->carg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
406 || (op
->aarg0
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
407 || (op
->aarg1
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
408 || (op
->aarg2
& WINED3DTA_SELECTMASK
) == WINED3DTA_TEXTURE
409 || op
->cop
== WINED3D_TOP_BLEND_TEXTURE_ALPHA
;
412 static void atifs_color_fixup(const struct wined3d_gl_info
*gl_info
, struct color_fixup_desc fixup
, GLuint reg
)
414 if(is_same_fixup(fixup
, color_fixup_rg
))
416 wrap_op1(gl_info
, GL_MOV_ATI
, reg
, GL_RED_BIT_ATI
| GL_GREEN_BIT_ATI
, GL_NONE
,
417 reg
, GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
);
418 wrap_op1(gl_info
, GL_MOV_ATI
, reg
, GL_BLUE_BIT_ATI
, GL_NONE
,
419 GL_ONE
, GL_NONE
, GL_NONE
);
420 wrap_op1(gl_info
, GL_MOV_ATI
, reg
, GL_ALPHA
, GL_NONE
,
421 GL_ONE
, GL_NONE
, GL_NONE
);
423 else if(is_same_fixup(fixup
, color_fixup_rgl
))
425 wrap_op1(gl_info
, GL_MOV_ATI
, reg
, GL_RED_BIT_ATI
| GL_GREEN_BIT_ATI
, GL_NONE
,
426 reg
, GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
);
428 else if (is_same_fixup(fixup
, color_fixup_rgba
))
430 wrap_op1(gl_info
, GL_MOV_ATI
, reg
, GL_NONE
, GL_NONE
,
431 reg
, GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
);
432 wrap_op1(gl_info
, GL_MOV_ATI
, reg
, GL_ALPHA
, GL_NONE
,
433 reg
, GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
);
437 /* Should not happen - atifs_color_fixup_supported refuses other fixups. */
438 ERR("Unsupported color fixup.\n");
442 static GLuint
gen_ati_shader(const struct texture_stage_op op
[MAX_TEXTURES
], const struct wined3d_gl_info
*gl_info
)
444 GLuint ret
= GL_EXTCALL(glGenFragmentShadersATI(1));
446 GLuint arg0
, arg1
, arg2
, extrarg
;
447 GLuint dstmod
, argmod0
, argmod1
, argmod2
, argmodextra
;
448 GLuint rep0
, rep1
, rep2
;
450 GLuint tmparg
= find_tmpreg(op
);
454 ERR("Failed to generate a GL_ATI_fragment_shader shader id\n");
457 GL_EXTCALL(glBindFragmentShaderATI(ret
));
458 checkGLcall("GL_EXTCALL(glBindFragmentShaderATI(ret))");
460 TRACE("glBeginFragmentShaderATI()\n");
461 GL_EXTCALL(glBeginFragmentShaderATI());
462 checkGLcall("GL_EXTCALL(glBeginFragmentShaderATI())");
464 /* Pass 1: Generate sampling instructions for perturbation maps */
465 for (stage
= 0; stage
< gl_info
->limits
.textures
; ++stage
)
467 if (op
[stage
].cop
== WINED3D_TOP_DISABLE
)
469 if (op
[stage
].cop
!= WINED3D_TOP_BUMPENVMAP
470 && op
[stage
].cop
!= WINED3D_TOP_BUMPENVMAP_LUMINANCE
)
473 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, GL_SWIZZLE_STR_ATI)\n",
475 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
476 GL_TEXTURE0_ARB
+ stage
,
477 GL_SWIZZLE_STR_ATI
));
478 if(op
[stage
+ 1].projected
== proj_none
) {
479 swizzle
= GL_SWIZZLE_STR_ATI
;
480 } else if(op
[stage
+ 1].projected
== proj_count4
) {
481 swizzle
= GL_SWIZZLE_STQ_DQ_ATI
;
483 swizzle
= GL_SWIZZLE_STR_DR_ATI
;
485 TRACE("glPassTexCoordATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, %s)\n",
486 stage
+ 1, stage
+ 1, debug_swizzle(swizzle
));
487 GL_EXTCALL(glPassTexCoordATI(GL_REG_0_ATI
+ stage
+ 1,
488 GL_TEXTURE0_ARB
+ stage
+ 1,
492 /* Pass 2: Generate perturbation calculations */
493 for (stage
= 0; stage
< gl_info
->limits
.textures
; ++stage
)
495 GLuint argmodextra_x
, argmodextra_y
;
496 struct color_fixup_desc fixup
;
498 if (op
[stage
].cop
== WINED3D_TOP_DISABLE
)
500 if (op
[stage
].cop
!= WINED3D_TOP_BUMPENVMAP
501 && op
[stage
].cop
!= WINED3D_TOP_BUMPENVMAP_LUMINANCE
)
504 fixup
= op
[stage
].color_fixup
;
505 if (fixup
.x_source
!= CHANNEL_SOURCE_X
|| fixup
.y_source
!= CHANNEL_SOURCE_Y
)
507 FIXME("Swizzles not implemented\n");
508 argmodextra_x
= GL_NONE
;
509 argmodextra_y
= GL_NONE
;
513 /* Nice thing, we get the color correction for free :-) */
514 argmodextra_x
= fixup
.x_sign_fixup
? GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
: GL_NONE
;
515 argmodextra_y
= fixup
.y_sign_fixup
? GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
: GL_NONE
;
518 wrap_op3(gl_info
, GL_DOT2_ADD_ATI
, GL_REG_0_ATI
+ stage
+ 1, GL_RED_BIT_ATI
, GL_NONE
,
519 GL_REG_0_ATI
+ stage
, GL_NONE
, argmodextra_x
,
520 ATI_FFP_CONST_BUMPMAT(stage
), GL_NONE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
,
521 GL_REG_0_ATI
+ stage
+ 1, GL_RED
, GL_NONE
);
523 /* Don't use GL_DOT2_ADD_ATI here because we cannot configure it to read the blue and alpha
524 * component of the bump matrix. Instead do this with two MADs:
526 * coord.a = tex.r * bump.b + coord.g
527 * coord.g = tex.g * bump.a + coord.a
529 * The first instruction writes to alpha so it can be coissued with the above DOT2_ADD.
530 * coord.a is unused. If the perturbed texture is projected, this was already handled
531 * in the glPassTexCoordATI above.
533 wrap_op3(gl_info
, GL_MAD_ATI
, GL_REG_0_ATI
+ stage
+ 1, GL_ALPHA
, GL_NONE
,
534 GL_REG_0_ATI
+ stage
, GL_RED
, argmodextra_y
,
535 ATI_FFP_CONST_BUMPMAT(stage
), GL_BLUE
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
,
536 GL_REG_0_ATI
+ stage
+ 1, GL_GREEN
, GL_NONE
);
537 wrap_op3(gl_info
, GL_MAD_ATI
, GL_REG_0_ATI
+ stage
+ 1, GL_GREEN_BIT_ATI
, GL_NONE
,
538 GL_REG_0_ATI
+ stage
, GL_GREEN
, argmodextra_y
,
539 ATI_FFP_CONST_BUMPMAT(stage
), GL_ALPHA
, GL_2X_BIT_ATI
| GL_BIAS_BIT_ATI
,
540 GL_REG_0_ATI
+ stage
+ 1, GL_ALPHA
, GL_NONE
);
543 /* Pass 3: Generate sampling instructions for regular textures */
544 for (stage
= 0; stage
< gl_info
->limits
.textures
; ++stage
)
546 if (op
[stage
].cop
== WINED3D_TOP_DISABLE
)
549 if(op
[stage
].projected
== proj_none
) {
550 swizzle
= GL_SWIZZLE_STR_ATI
;
551 } else if(op
[stage
].projected
== proj_count3
) {
552 swizzle
= GL_SWIZZLE_STR_DR_ATI
;
554 swizzle
= GL_SWIZZLE_STQ_DQ_ATI
;
557 if (op_reads_texture(&op
[stage
]))
560 && (op
[stage
- 1].cop
== WINED3D_TOP_BUMPENVMAP
561 || op
[stage
- 1].cop
== WINED3D_TOP_BUMPENVMAP_LUMINANCE
))
563 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_REG_%d_ATI, GL_SWIZZLE_STR_ATI)\n",
565 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
566 GL_REG_0_ATI
+ stage
,
567 GL_SWIZZLE_STR_ATI
));
569 TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, %s)\n",
570 stage
, stage
, debug_swizzle(swizzle
));
571 GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI
+ stage
,
572 GL_TEXTURE0_ARB
+ stage
,
578 /* Pass 4: Generate the arithmetic instructions */
579 for (stage
= 0; stage
< MAX_TEXTURES
; ++stage
)
581 if (op
[stage
].cop
== WINED3D_TOP_DISABLE
)
585 /* Handle complete texture disabling gracefully */
586 wrap_op1(gl_info
, GL_MOV_ATI
, GL_REG_0_ATI
, GL_NONE
, GL_NONE
,
587 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
);
588 wrap_op1(gl_info
, GL_MOV_ATI
, GL_REG_0_ATI
, GL_ALPHA
, GL_NONE
,
589 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
);
594 if(op
[stage
].dst
== tempreg
) {
595 /* If we're writing to D3DTA_TEMP, but never reading from it we don't have to write there in the first place.
596 * skip the entire stage, this saves some GPU time
598 if(tmparg
== GL_NONE
) continue;
602 dstreg
= GL_REG_0_ATI
;
605 if (op
[stage
].cop
== WINED3D_TOP_BUMPENVMAP
|| op
[stage
].cop
== WINED3D_TOP_BUMPENVMAP_LUMINANCE
)
607 /* Those are handled in the first pass of the shader (generation pass 1 and 2) already */
611 arg0
= register_for_arg(op
[stage
].carg0
, gl_info
, stage
, &argmod0
, &rep0
, tmparg
);
612 arg1
= register_for_arg(op
[stage
].carg1
, gl_info
, stage
, &argmod1
, &rep1
, tmparg
);
613 arg2
= register_for_arg(op
[stage
].carg2
, gl_info
, stage
, &argmod2
, &rep2
, tmparg
);
615 argmodextra
= GL_NONE
;
618 if (op_reads_texture(&op
[stage
]) && !is_identity_fixup(op
[stage
].color_fixup
))
619 atifs_color_fixup(gl_info
, op
[stage
].color_fixup
, GL_REG_0_ATI
+ stage
);
621 switch (op
[stage
].cop
)
623 case WINED3D_TOP_SELECT_ARG2
:
628 case WINED3D_TOP_SELECT_ARG1
:
629 wrap_op1(gl_info
, GL_MOV_ATI
, dstreg
, GL_NONE
, GL_NONE
,
630 arg1
, rep1
, argmod1
);
633 case WINED3D_TOP_MODULATE_4X
:
634 if(dstmod
== GL_NONE
) dstmod
= GL_4X_BIT_ATI
;
636 case WINED3D_TOP_MODULATE_2X
:
637 if(dstmod
== GL_NONE
) dstmod
= GL_2X_BIT_ATI
;
638 dstmod
|= GL_SATURATE_BIT_ATI
;
640 case WINED3D_TOP_MODULATE
:
641 wrap_op2(gl_info
, GL_MUL_ATI
, dstreg
, GL_NONE
, dstmod
,
643 arg2
, rep2
, argmod2
);
646 case WINED3D_TOP_ADD_SIGNED_2X
:
647 dstmod
= GL_2X_BIT_ATI
;
649 case WINED3D_TOP_ADD_SIGNED
:
650 argmodextra
= GL_BIAS_BIT_ATI
;
652 case WINED3D_TOP_ADD
:
653 dstmod
|= GL_SATURATE_BIT_ATI
;
654 wrap_op2(gl_info
, GL_ADD_ATI
, GL_REG_0_ATI
, GL_NONE
, dstmod
,
656 arg2
, rep2
, argmodextra
| argmod2
);
659 case WINED3D_TOP_SUBTRACT
:
660 dstmod
|= GL_SATURATE_BIT_ATI
;
661 wrap_op2(gl_info
, GL_SUB_ATI
, dstreg
, GL_NONE
, dstmod
,
663 arg2
, rep2
, argmod2
);
666 case WINED3D_TOP_ADD_SMOOTH
:
667 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
668 /* Dst = arg1 + * arg2(1 -arg 1)
669 * = arg2 * (1 - arg1) + arg1
671 wrap_op3(gl_info
, GL_MAD_ATI
, dstreg
, GL_NONE
, GL_SATURATE_BIT_ATI
,
673 arg1
, rep1
, argmodextra
,
674 arg1
, rep1
, argmod1
);
677 case WINED3D_TOP_BLEND_CURRENT_ALPHA
:
678 if (extrarg
== GL_NONE
)
679 extrarg
= register_for_arg(WINED3DTA_CURRENT
, gl_info
, stage
, NULL
, NULL
, -1);
681 case WINED3D_TOP_BLEND_FACTOR_ALPHA
:
682 if (extrarg
== GL_NONE
)
683 extrarg
= register_for_arg(WINED3DTA_TFACTOR
, gl_info
, stage
, NULL
, NULL
, -1);
685 case WINED3D_TOP_BLEND_TEXTURE_ALPHA
:
686 if (extrarg
== GL_NONE
)
687 extrarg
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, NULL
, -1);
689 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA
:
690 if (extrarg
== GL_NONE
)
691 extrarg
= register_for_arg(WINED3DTA_DIFFUSE
, gl_info
, stage
, NULL
, NULL
, -1);
692 wrap_op3(gl_info
, GL_LERP_ATI
, dstreg
, GL_NONE
, GL_NONE
,
693 extrarg
, GL_ALPHA
, GL_NONE
,
695 arg2
, rep2
, argmod2
);
698 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
699 arg0
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, NULL
, -1);
700 wrap_op3(gl_info
, GL_MAD_ATI
, dstreg
, GL_NONE
, GL_NONE
,
702 arg0
, GL_ALPHA
, GL_COMP_BIT_ATI
,
703 arg1
, rep1
, argmod1
);
706 /* D3DTOP_PREMODULATE ???? */
708 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
709 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
711 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
713 argmodextra
= argmod1
;
714 wrap_op3(gl_info
, GL_MAD_ATI
, dstreg
, GL_NONE
, GL_SATURATE_BIT_ATI
,
716 arg1
, GL_ALPHA
, argmodextra
,
717 arg1
, rep1
, argmod1
);
720 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
721 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
723 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
725 argmodextra
= argmod1
;
726 wrap_op3(gl_info
, GL_MAD_ATI
, dstreg
, GL_NONE
, GL_SATURATE_BIT_ATI
,
728 arg1
, rep1
, argmodextra
,
729 arg1
, GL_ALPHA
, argmod1
);
732 case WINED3D_TOP_DOTPRODUCT3
:
733 wrap_op2(gl_info
, GL_DOT3_ATI
, dstreg
, GL_NONE
, GL_4X_BIT_ATI
| GL_SATURATE_BIT_ATI
,
734 arg1
, rep1
, argmod1
| GL_BIAS_BIT_ATI
,
735 arg2
, rep2
, argmod2
| GL_BIAS_BIT_ATI
);
738 case WINED3D_TOP_MULTIPLY_ADD
:
739 wrap_op3(gl_info
, GL_MAD_ATI
, dstreg
, GL_NONE
, GL_SATURATE_BIT_ATI
,
742 arg0
, rep0
, argmod0
);
745 case WINED3D_TOP_LERP
:
746 wrap_op3(gl_info
, GL_LERP_ATI
, dstreg
, GL_NONE
, GL_NONE
,
749 arg2
, rep2
, argmod2
);
752 default: FIXME("Unhandled color operation %d on stage %d\n", op
[stage
].cop
, stage
);
755 arg0
= register_for_arg(op
[stage
].aarg0
, gl_info
, stage
, &argmod0
, NULL
, tmparg
);
756 arg1
= register_for_arg(op
[stage
].aarg1
, gl_info
, stage
, &argmod1
, NULL
, tmparg
);
757 arg2
= register_for_arg(op
[stage
].aarg2
, gl_info
, stage
, &argmod2
, NULL
, tmparg
);
759 argmodextra
= GL_NONE
;
762 switch (op
[stage
].aop
)
764 case WINED3D_TOP_DISABLE
:
765 /* Get the primary color to the output if on stage 0, otherwise leave register 0 untouched */
768 wrap_op1(gl_info
, GL_MOV_ATI
, GL_REG_0_ATI
, GL_ALPHA
, GL_NONE
,
769 GL_PRIMARY_COLOR
, GL_NONE
, GL_NONE
);
773 case WINED3D_TOP_SELECT_ARG2
:
777 case WINED3D_TOP_SELECT_ARG1
:
778 wrap_op1(gl_info
, GL_MOV_ATI
, dstreg
, GL_ALPHA
, GL_NONE
,
779 arg1
, GL_NONE
, argmod1
);
782 case WINED3D_TOP_MODULATE_4X
:
783 if (dstmod
== GL_NONE
)
784 dstmod
= GL_4X_BIT_ATI
;
786 case WINED3D_TOP_MODULATE_2X
:
787 if (dstmod
== GL_NONE
)
788 dstmod
= GL_2X_BIT_ATI
;
789 dstmod
|= GL_SATURATE_BIT_ATI
;
791 case WINED3D_TOP_MODULATE
:
792 wrap_op2(gl_info
, GL_MUL_ATI
, dstreg
, GL_ALPHA
, dstmod
,
793 arg1
, GL_NONE
, argmod1
,
794 arg2
, GL_NONE
, argmod2
);
797 case WINED3D_TOP_ADD_SIGNED_2X
:
798 dstmod
= GL_2X_BIT_ATI
;
800 case WINED3D_TOP_ADD_SIGNED
:
801 argmodextra
= GL_BIAS_BIT_ATI
;
803 case WINED3D_TOP_ADD
:
804 dstmod
|= GL_SATURATE_BIT_ATI
;
805 wrap_op2(gl_info
, GL_ADD_ATI
, dstreg
, GL_ALPHA
, dstmod
,
806 arg1
, GL_NONE
, argmod1
,
807 arg2
, GL_NONE
, argmodextra
| argmod2
);
810 case WINED3D_TOP_SUBTRACT
:
811 dstmod
|= GL_SATURATE_BIT_ATI
;
812 wrap_op2(gl_info
, GL_SUB_ATI
, dstreg
, GL_ALPHA
, dstmod
,
813 arg1
, GL_NONE
, argmod1
,
814 arg2
, GL_NONE
, argmod2
);
817 case WINED3D_TOP_ADD_SMOOTH
:
818 argmodextra
= argmod1
& GL_COMP_BIT_ATI
? argmod1
& ~GL_COMP_BIT_ATI
: argmod1
| GL_COMP_BIT_ATI
;
819 /* Dst = arg1 + * arg2(1 -arg 1)
820 * = arg2 * (1 - arg1) + arg1
822 wrap_op3(gl_info
, GL_MAD_ATI
, dstreg
, GL_ALPHA
, GL_SATURATE_BIT_ATI
,
823 arg2
, GL_NONE
, argmod2
,
824 arg1
, GL_NONE
, argmodextra
,
825 arg1
, GL_NONE
, argmod1
);
828 case WINED3D_TOP_BLEND_CURRENT_ALPHA
:
829 if (extrarg
== GL_NONE
)
830 extrarg
= register_for_arg(WINED3DTA_CURRENT
, gl_info
, stage
, NULL
, NULL
, -1);
832 case WINED3D_TOP_BLEND_FACTOR_ALPHA
:
833 if (extrarg
== GL_NONE
)
834 extrarg
= register_for_arg(WINED3DTA_TFACTOR
, gl_info
, stage
, NULL
, NULL
, -1);
836 case WINED3D_TOP_BLEND_TEXTURE_ALPHA
:
837 if (extrarg
== GL_NONE
)
838 extrarg
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, NULL
, -1);
840 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA
:
841 if (extrarg
== GL_NONE
)
842 extrarg
= register_for_arg(WINED3DTA_DIFFUSE
, gl_info
, stage
, NULL
, NULL
, -1);
843 wrap_op3(gl_info
, GL_LERP_ATI
, dstreg
, GL_ALPHA
, GL_NONE
,
844 extrarg
, GL_ALPHA
, GL_NONE
,
845 arg1
, GL_NONE
, argmod1
,
846 arg2
, GL_NONE
, argmod2
);
849 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
850 arg0
= register_for_arg(WINED3DTA_TEXTURE
, gl_info
, stage
, NULL
, NULL
, -1);
851 wrap_op3(gl_info
, GL_MAD_ATI
, dstreg
, GL_ALPHA
, GL_NONE
,
852 arg2
, GL_NONE
, argmod2
,
853 arg0
, GL_ALPHA
, GL_COMP_BIT_ATI
,
854 arg1
, GL_NONE
, argmod1
);
857 /* D3DTOP_PREMODULATE ???? */
859 case WINED3D_TOP_DOTPRODUCT3
:
860 wrap_op2(gl_info
, GL_DOT3_ATI
, dstreg
, GL_ALPHA
, GL_4X_BIT_ATI
| GL_SATURATE_BIT_ATI
,
861 arg1
, GL_NONE
, argmod1
| GL_BIAS_BIT_ATI
,
862 arg2
, GL_NONE
, argmod2
| GL_BIAS_BIT_ATI
);
865 case WINED3D_TOP_MULTIPLY_ADD
:
866 wrap_op3(gl_info
, GL_MAD_ATI
, dstreg
, GL_ALPHA
, GL_SATURATE_BIT_ATI
,
867 arg1
, GL_NONE
, argmod1
,
868 arg2
, GL_NONE
, argmod2
,
869 arg0
, GL_NONE
, argmod0
);
872 case WINED3D_TOP_LERP
:
873 wrap_op3(gl_info
, GL_LERP_ATI
, dstreg
, GL_ALPHA
, GL_SATURATE_BIT_ATI
,
874 arg1
, GL_NONE
, argmod1
,
875 arg2
, GL_NONE
, argmod2
,
876 arg0
, GL_NONE
, argmod0
);
879 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
880 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
881 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
882 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
883 case WINED3D_TOP_BUMPENVMAP
:
884 case WINED3D_TOP_BUMPENVMAP_LUMINANCE
:
885 ERR("Application uses an invalid alpha operation\n");
888 default: FIXME("Unhandled alpha operation %d on stage %d\n", op
[stage
].aop
, stage
);
892 TRACE("glEndFragmentShaderATI()\n");
893 GL_EXTCALL(glEndFragmentShaderATI());
894 checkGLcall("GL_EXTCALL(glEndFragmentShaderATI())");
898 static void set_tex_op_atifs(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
900 const struct wined3d_device
*device
= context
->swapchain
->device
;
901 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
902 const struct wined3d_d3d_info
*d3d_info
= context
->d3d_info
;
903 const struct atifs_ffp_desc
*desc
;
904 struct ffp_frag_settings settings
;
905 struct atifs_private_data
*priv
= device
->fragment_priv
;
909 gen_ffp_frag_op(context
, state
, &settings
, TRUE
);
910 desc
= (const struct atifs_ffp_desc
*)find_ffp_frag_shader(&priv
->fragment_shaders
, &settings
);
912 struct atifs_ffp_desc
*new_desc
= HeapAlloc(GetProcessHeap(), 0, sizeof(*new_desc
));
915 ERR("Out of memory\n");
918 new_desc
->num_textures_used
= 0;
919 for (i
= 0; i
< d3d_info
->limits
.ffp_blend_stages
; ++i
)
921 if (settings
.op
[i
].cop
== WINED3D_TOP_DISABLE
)
923 new_desc
->num_textures_used
= i
+ 1;
926 new_desc
->parent
.settings
= settings
;
927 new_desc
->shader
= gen_ati_shader(settings
.op
, gl_info
);
928 add_ffp_frag_shader(&priv
->fragment_shaders
, &new_desc
->parent
);
929 TRACE("Allocated fixed function replacement shader descriptor %p\n", new_desc
);
933 /* GL_ATI_fragment_shader depends on the GL_TEXTURE_xD enable settings. Update the texture stages
934 * used by this shader
936 for (i
= 0; i
< desc
->num_textures_used
; ++i
)
938 mapped_stage
= context
->tex_unit_map
[i
];
939 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
941 context_active_texture(context
, gl_info
, mapped_stage
);
942 texture_activate_dimensions(state
->textures
[i
], gl_info
);
946 GL_EXTCALL(glBindFragmentShaderATI(desc
->shader
));
949 static void state_texfactor_atifs(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
951 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
954 D3DCOLORTOGLFLOAT4(state
->render_states
[WINED3D_RS_TEXTUREFACTOR
], col
);
955 GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR
, col
));
956 checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_TFACTOR, col)");
959 static void set_bumpmat(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
961 DWORD stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
962 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
965 mat
[0][0] = *((float *)&state
->texture_states
[stage
][WINED3D_TSS_BUMPENV_MAT00
]);
966 mat
[1][0] = *((float *)&state
->texture_states
[stage
][WINED3D_TSS_BUMPENV_MAT01
]);
967 mat
[0][1] = *((float *)&state
->texture_states
[stage
][WINED3D_TSS_BUMPENV_MAT10
]);
968 mat
[1][1] = *((float *)&state
->texture_states
[stage
][WINED3D_TSS_BUMPENV_MAT11
]);
969 /* GL_ATI_fragment_shader allows only constants from 0.0 to 1.0, but the bumpmat
970 * constants can be in any range. While they should stay between [-1.0 and 1.0] because
971 * Shader Model 1.x pixel shaders are clamped to that range negative values are used occasionally,
972 * for example by our d3d9 test. So to get negative values scale -1;1 to 0;1 and undo that in the
973 * shader(it is free). This might potentially reduce precision. However, if the hardware does
974 * support proper floats it shouldn't, and if it doesn't we can't get anything better anyway
976 mat
[0][0] = (mat
[0][0] + 1.0f
) * 0.5f
;
977 mat
[1][0] = (mat
[1][0] + 1.0f
) * 0.5f
;
978 mat
[0][1] = (mat
[0][1] + 1.0f
) * 0.5f
;
979 mat
[1][1] = (mat
[1][1] + 1.0f
) * 0.5f
;
980 GL_EXTCALL(glSetFragmentShaderConstantATI(ATI_FFP_CONST_BUMPMAT(stage
), (float *) mat
));
981 checkGLcall("glSetFragmentShaderConstantATI(ATI_FFP_CONST_BUMPMAT(stage), mat)");
984 static void textransform(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
986 if (!isStateDirty(context
, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
)))
987 set_tex_op_atifs(context
, state
, state_id
);
990 static void atifs_apply_pixelshader(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
992 context
->last_was_pshader
= use_ps(state
);
993 /* The ATIFS code does not support pixel shaders currently, but we have to
994 * provide a state handler to call shader_select to select a vertex shader
995 * if one is applied because the vertex shader state may defer calling the
996 * shader backend if the pshader state is dirty.
998 * In theory the application should not be able to mark the pixel shader
999 * dirty because it cannot create a shader, and thus has no way to set the
1000 * state to something != NULL. However, a different pipeline part may link
1001 * a different state to its pixelshader handler, thus a pshader state
1002 * exists and can be dirtified. Also the pshader is always dirtified at
1003 * startup, and blitting disables all shaders and dirtifies all shader
1004 * states. If atifs can deal with this it keeps the rest of the code
1006 context
->shader_update_mask
|= 1 << WINED3D_SHADER_TYPE_PIXEL
;
1009 static void atifs_srgbwriteenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1011 if (state
->render_states
[WINED3D_RS_SRGBWRITEENABLE
])
1012 WARN("sRGB writes are not supported by this fragment pipe.\n");
1015 static const struct StateEntryTemplate atifs_fragmentstate_template
[] = {
1016 {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), state_texfactor_atifs
}, WINED3D_GL_EXT_NONE
},
1017 {STATE_RENDER(WINED3D_RS_FOGCOLOR
), { STATE_RENDER(WINED3D_RS_FOGCOLOR
), state_fogcolor
}, WINED3D_GL_EXT_NONE
},
1018 {STATE_RENDER(WINED3D_RS_FOGDENSITY
), { STATE_RENDER(WINED3D_RS_FOGDENSITY
), state_fogdensity
}, WINED3D_GL_EXT_NONE
},
1019 {STATE_RENDER(WINED3D_RS_FOGENABLE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), state_fog_fragpart
}, WINED3D_GL_EXT_NONE
},
1020 {STATE_RENDER(WINED3D_RS_FOGTABLEMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
1021 {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
1022 {STATE_RENDER(WINED3D_RS_FOGSTART
), { STATE_RENDER(WINED3D_RS_FOGSTART
), state_fogstartend
}, WINED3D_GL_EXT_NONE
},
1023 {STATE_RENDER(WINED3D_RS_FOGEND
), { STATE_RENDER(WINED3D_RS_FOGSTART
), NULL
}, WINED3D_GL_EXT_NONE
},
1024 {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE
), { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE
), atifs_srgbwriteenable
}, WINED3D_GL_EXT_NONE
},
1025 {STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), set_tex_op_atifs
}, WINED3D_GL_EXT_NONE
},
1026 {STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1027 {STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1028 {STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1029 {STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1030 {STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1031 {STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1032 {STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1033 {STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1034 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), set_bumpmat
}, WINED3D_GL_EXT_NONE
},
1035 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1036 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1037 {STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1038 {STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1039 {STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1040 {STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1041 {STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1042 {STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1043 {STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1044 {STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1045 {STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1046 {STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1047 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), set_bumpmat
}, WINED3D_GL_EXT_NONE
},
1048 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1049 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1050 {STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1051 {STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1052 {STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1053 {STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1054 {STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1055 {STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1056 {STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1057 {STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1058 {STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1059 {STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1060 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), set_bumpmat
}, WINED3D_GL_EXT_NONE
},
1061 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1062 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1063 {STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1064 {STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1065 {STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1066 {STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1067 {STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1068 {STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1069 {STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1070 {STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1071 {STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1072 {STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1073 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), set_bumpmat
}, WINED3D_GL_EXT_NONE
},
1074 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1075 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1076 {STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1077 {STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1078 {STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1079 {STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1080 {STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1081 {STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1082 {STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1083 {STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1084 {STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1085 {STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1086 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), set_bumpmat
}, WINED3D_GL_EXT_NONE
},
1087 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1088 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1089 {STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1090 {STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1091 {STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1092 {STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1093 {STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1094 {STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1095 {STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1096 {STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1097 {STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1098 {STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1099 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), set_bumpmat
}, WINED3D_GL_EXT_NONE
},
1100 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1101 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1102 {STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1103 {STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1104 {STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1105 {STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1106 {STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1107 {STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1108 {STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1109 {STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1110 {STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1111 {STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1112 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), set_bumpmat
}, WINED3D_GL_EXT_NONE
},
1113 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1114 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1115 {STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1116 {STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1117 {STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1118 {STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1119 {STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1120 {STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1121 {STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1122 {STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1123 {STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1124 {STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
1125 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), set_bumpmat
}, WINED3D_GL_EXT_NONE
},
1126 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1127 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1128 {STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
1129 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
1130 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
1131 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
1132 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
1133 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
1134 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
1135 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
1136 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
1137 {STATE_TEXTURESTAGE(0,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), textransform
}, WINED3D_GL_EXT_NONE
},
1138 {STATE_TEXTURESTAGE(1,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), textransform
}, WINED3D_GL_EXT_NONE
},
1139 {STATE_TEXTURESTAGE(2,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), textransform
}, WINED3D_GL_EXT_NONE
},
1140 {STATE_TEXTURESTAGE(3,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), textransform
}, WINED3D_GL_EXT_NONE
},
1141 {STATE_TEXTURESTAGE(4,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), textransform
}, WINED3D_GL_EXT_NONE
},
1142 {STATE_TEXTURESTAGE(5,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), textransform
}, WINED3D_GL_EXT_NONE
},
1143 {STATE_TEXTURESTAGE(6,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), textransform
}, WINED3D_GL_EXT_NONE
},
1144 {STATE_TEXTURESTAGE(7,WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), textransform
}, WINED3D_GL_EXT_NONE
},
1145 {STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), atifs_apply_pixelshader
}, WINED3D_GL_EXT_NONE
},
1146 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
1149 /* Context activation is done by the caller. */
1150 static void atifs_enable(const struct wined3d_gl_info
*gl_info
, BOOL enable
)
1154 gl_info
->gl_ops
.gl
.p_glEnable(GL_FRAGMENT_SHADER_ATI
);
1155 checkGLcall("glEnable(GL_FRAGMENT_SHADER_ATI)");
1159 gl_info
->gl_ops
.gl
.p_glDisable(GL_FRAGMENT_SHADER_ATI
);
1160 checkGLcall("glDisable(GL_FRAGMENT_SHADER_ATI)");
1164 static void atifs_get_caps(const struct wined3d_gl_info
*gl_info
, struct fragment_caps
*caps
)
1166 caps
->wined3d_caps
= WINED3D_FRAGMENT_CAP_PROJ_CONTROL
;
1167 caps
->PrimitiveMiscCaps
= WINED3DPMISCCAPS_TSSARGTEMP
;
1168 caps
->TextureOpCaps
= WINED3DTEXOPCAPS_DISABLE
|
1169 WINED3DTEXOPCAPS_SELECTARG1
|
1170 WINED3DTEXOPCAPS_SELECTARG2
|
1171 WINED3DTEXOPCAPS_MODULATE4X
|
1172 WINED3DTEXOPCAPS_MODULATE2X
|
1173 WINED3DTEXOPCAPS_MODULATE
|
1174 WINED3DTEXOPCAPS_ADDSIGNED2X
|
1175 WINED3DTEXOPCAPS_ADDSIGNED
|
1176 WINED3DTEXOPCAPS_ADD
|
1177 WINED3DTEXOPCAPS_SUBTRACT
|
1178 WINED3DTEXOPCAPS_ADDSMOOTH
|
1179 WINED3DTEXOPCAPS_BLENDCURRENTALPHA
|
1180 WINED3DTEXOPCAPS_BLENDFACTORALPHA
|
1181 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
|
1182 WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
|
1183 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
|
1184 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
|
1185 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
|
1186 WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA
|
1187 WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
|
1188 WINED3DTEXOPCAPS_DOTPRODUCT3
|
1189 WINED3DTEXOPCAPS_MULTIPLYADD
|
1190 WINED3DTEXOPCAPS_LERP
|
1191 WINED3DTEXOPCAPS_BUMPENVMAP
;
1193 /* TODO: Implement WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
1194 and WINED3DTEXOPCAPS_PREMODULATE */
1196 /* GL_ATI_fragment_shader always supports 6 textures, which was the limit on r200 cards
1197 * which this extension is exclusively focused on(later cards have GL_ARB_fragment_program).
1198 * If the current card has more than 8 fixed function textures in OpenGL's regular fixed
1199 * function pipeline then the ATI_fragment_shader backend imposes a stricter limit. This
1200 * shouldn't be too hard since Nvidia cards have a limit of 4 textures with the default ffp
1201 * pipeline, and almost all games are happy with that. We can however support up to 8
1202 * texture stages because we have a 2nd pass limit of 8 instructions, and per stage we use
1203 * only 1 instruction.
1205 * The proper fix for this is not to use GL_ATI_fragment_shader on cards newer than the
1206 * r200 series and use an ARB or GLSL shader instead
1208 caps
->MaxTextureBlendStages
= 8;
1209 caps
->MaxSimultaneousTextures
= 6;
1212 static void *atifs_alloc(const struct wined3d_shader_backend_ops
*shader_backend
, void *shader_priv
)
1214 struct atifs_private_data
*priv
;
1216 if (!(priv
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*priv
))))
1219 if (wine_rb_init(&priv
->fragment_shaders
, &wined3d_ffp_frag_program_rb_functions
) == -1)
1221 ERR("Failed to initialize rbtree.\n");
1222 HeapFree(GetProcessHeap(), 0, priv
);
1229 /* Context activation is done by the caller. */
1230 static void atifs_free_ffpshader(struct wine_rb_entry
*entry
, void *cb_ctx
)
1232 const struct wined3d_gl_info
*gl_info
= cb_ctx
;
1233 struct atifs_ffp_desc
*entry_ati
= WINE_RB_ENTRY_VALUE(entry
, struct atifs_ffp_desc
, parent
.entry
);
1235 GL_EXTCALL(glDeleteFragmentShaderATI(entry_ati
->shader
));
1236 checkGLcall("glDeleteFragmentShaderATI(entry->shader)");
1237 HeapFree(GetProcessHeap(), 0, entry_ati
);
1240 /* Context activation is done by the caller. */
1241 static void atifs_free(struct wined3d_device
*device
)
1243 struct atifs_private_data
*priv
= device
->fragment_priv
;
1245 wine_rb_destroy(&priv
->fragment_shaders
, atifs_free_ffpshader
, &device
->adapter
->gl_info
);
1247 HeapFree(GetProcessHeap(), 0, priv
);
1248 device
->fragment_priv
= NULL
;
1251 static BOOL
atifs_color_fixup_supported(struct color_fixup_desc fixup
)
1253 if (TRACE_ON(d3d_shader
) && TRACE_ON(d3d
))
1255 TRACE("Checking support for fixup:\n");
1256 dump_color_fixup_desc(fixup
);
1259 /* We only support sign fixup of the first two channels. */
1260 if (is_identity_fixup(fixup
) || is_same_fixup(fixup
, color_fixup_rg
)
1261 || is_same_fixup(fixup
, color_fixup_rgl
) || is_same_fixup(fixup
, color_fixup_rgba
))
1267 TRACE("[FAILED]\n");
1271 const struct fragment_pipeline atifs_fragment_pipeline
= {
1276 atifs_color_fixup_supported
,
1277 atifs_fragmentstate_template
,