2 * Fixed function pipeline replacement using GL_NV_register_combiners
3 * and GL_NV_texture_shader
5 * Copyright 2006 Henri Verbeet
6 * Copyright 2008 Stefan Dösinger(for CodeWeavers)
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/port.h"
28 #include "wined3d_private.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
32 /* GL locking for state handlers is done by the caller. */
34 static void nvts_activate_dimensions(const struct wined3d_state
*state
, DWORD stage
, struct wined3d_context
*context
)
39 && (state
->texture_states
[stage
- 1][WINED3D_TSS_COLOR_OP
] == WINED3D_TOP_BUMPENVMAP_LUMINANCE
40 || state
->texture_states
[stage
- 1][WINED3D_TSS_COLOR_OP
] == WINED3D_TOP_BUMPENVMAP
))
43 context
->texShaderBumpMap
|= (1 << stage
);
45 context
->texShaderBumpMap
&= ~(1 << stage
);
48 if (state
->textures
[stage
])
50 switch (state
->textures
[stage
]->target
)
53 glTexEnvi(GL_TEXTURE_SHADER_NV
, GL_SHADER_OPERATION_NV
, bumpmap
? GL_OFFSET_TEXTURE_2D_NV
: GL_TEXTURE_2D
);
54 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)");
56 case GL_TEXTURE_RECTANGLE_ARB
:
57 glTexEnvi(GL_TEXTURE_SHADER_NV
, GL_SHADER_OPERATION_NV
, bumpmap
? GL_OFFSET_TEXTURE_2D_NV
: GL_TEXTURE_RECTANGLE_ARB
);
58 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)");
61 glTexEnvi(GL_TEXTURE_SHADER_NV
, GL_SHADER_OPERATION_NV
, GL_TEXTURE_3D
);
62 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D)");
64 case GL_TEXTURE_CUBE_MAP_ARB
:
65 glTexEnvi(GL_TEXTURE_SHADER_NV
, GL_SHADER_OPERATION_NV
, GL_TEXTURE_CUBE_MAP_ARB
);
66 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB)");
70 glTexEnvi(GL_TEXTURE_SHADER_NV
, GL_SHADER_OPERATION_NV
, GL_NONE
);
71 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE)");
79 GLenum component_usage
[3];
82 static GLenum
d3dta_to_combiner_input(DWORD d3dta
, DWORD stage
, INT texture_idx
) {
84 case WINED3DTA_DIFFUSE
:
85 return GL_PRIMARY_COLOR_NV
;
87 case WINED3DTA_CURRENT
:
88 if (stage
) return GL_SPARE0_NV
;
89 else return GL_PRIMARY_COLOR_NV
;
91 case WINED3DTA_TEXTURE
:
92 if (texture_idx
> -1) return GL_TEXTURE0_ARB
+ texture_idx
;
93 else return GL_PRIMARY_COLOR_NV
;
95 case WINED3DTA_TFACTOR
:
96 return GL_CONSTANT_COLOR0_NV
;
98 case WINED3DTA_SPECULAR
:
99 return GL_SECONDARY_COLOR_NV
;
104 case WINED3DTA_CONSTANT
:
105 /* TODO: Support per stage constants (WINED3D_TSS_CONSTANT, NV_register_combiners2) */
106 FIXME("WINED3DTA_CONSTANT, not properly supported.\n");
107 return GL_CONSTANT_COLOR1_NV
;
110 FIXME("Unrecognized texture arg %#x\n", d3dta
);
115 static GLenum
invert_mapping(GLenum mapping
) {
116 if (mapping
== GL_UNSIGNED_INVERT_NV
) return GL_UNSIGNED_IDENTITY_NV
;
117 else if (mapping
== GL_UNSIGNED_IDENTITY_NV
) return GL_UNSIGNED_INVERT_NV
;
119 FIXME("Unhandled mapping %#x\n", mapping
);
123 static void get_src_and_opr_nvrc(DWORD stage
, DWORD arg
, BOOL is_alpha
, GLenum
* input
, GLenum
* mapping
, GLenum
*component_usage
, INT texture_idx
) {
124 /* The WINED3DTA_COMPLEMENT flag specifies the complement of the input should
126 if (arg
& WINED3DTA_COMPLEMENT
) *mapping
= GL_UNSIGNED_INVERT_NV
;
127 else *mapping
= GL_UNSIGNED_IDENTITY_NV
; /* Clamp all values to positive ranges */
129 /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the input
130 * should be used for all input components. */
131 if (is_alpha
|| arg
& WINED3DTA_ALPHAREPLICATE
) *component_usage
= GL_ALPHA
;
132 else *component_usage
= GL_RGB
;
134 *input
= d3dta_to_combiner_input(arg
& WINED3DTA_SELECTMASK
, stage
, texture_idx
);
137 void set_tex_op_nvrc(const struct wined3d_gl_info
*gl_info
, const struct wined3d_state
*state
, BOOL is_alpha
,
138 int stage
, enum wined3d_texture_op op
, DWORD arg1
, DWORD arg2
, DWORD arg3
, INT texture_idx
, DWORD dst
)
140 struct tex_op_args tex_op_args
= {{0}, {0}, {0}};
141 GLenum portion
= is_alpha
? GL_ALPHA
: GL_RGB
;
142 GLenum target
= GL_COMBINER0_NV
+ stage
;
145 TRACE("stage %d, is_alpha %d, op %s, arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
146 stage
, is_alpha
, debug_d3dtop(op
), arg1
, arg2
, arg3
, texture_idx
);
148 /* If a texture stage references an invalid texture unit the stage just
149 * passes through the result from the previous stage */
150 if (is_invalid_op(state
, stage
, op
, arg1
, arg2
, arg3
))
152 arg1
= WINED3DTA_CURRENT
;
153 op
= WINED3D_TOP_SELECT_ARG1
;
156 get_src_and_opr_nvrc(stage
, arg1
, is_alpha
, &tex_op_args
.input
[0],
157 &tex_op_args
.mapping
[0], &tex_op_args
.component_usage
[0], texture_idx
);
158 get_src_and_opr_nvrc(stage
, arg2
, is_alpha
, &tex_op_args
.input
[1],
159 &tex_op_args
.mapping
[1], &tex_op_args
.component_usage
[1], texture_idx
);
160 get_src_and_opr_nvrc(stage
, arg3
, is_alpha
, &tex_op_args
.input
[2],
161 &tex_op_args
.mapping
[2], &tex_op_args
.component_usage
[2], texture_idx
);
164 if(dst
== WINED3DTA_TEMP
) {
165 output
= GL_SPARE1_NV
;
167 output
= GL_SPARE0_NV
;
170 /* This is called by a state handler which has the gl lock held and a context for the thread */
173 case WINED3D_TOP_DISABLE
:
176 ERR("Shouldn't be called for WINED3D_TSS_COLOR_OP (WINED3DTOP_DISABLE).\n");
177 /* Input, prev_alpha*1 */
178 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
179 GL_SPARE0_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_ALPHA
));
180 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
181 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, GL_ALPHA
));
184 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_SPARE0_NV
, GL_DISCARD_NV
,
185 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
188 case WINED3D_TOP_SELECT_ARG1
:
189 case WINED3D_TOP_SELECT_ARG2
:
191 if (op
== WINED3D_TOP_SELECT_ARG1
)
192 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
193 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
195 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
196 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
197 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
198 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
201 GL_EXTCALL(glCombinerOutputNV(target
, portion
, output
, GL_DISCARD_NV
,
202 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
205 case WINED3D_TOP_MODULATE
:
206 case WINED3D_TOP_MODULATE_2X
:
207 case WINED3D_TOP_MODULATE_4X
:
208 /* Input, arg1*arg2 */
209 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
210 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
211 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
212 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
215 if (op
== WINED3D_TOP_MODULATE
)
216 GL_EXTCALL(glCombinerOutputNV(target
, portion
, output
, GL_DISCARD_NV
,
217 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
218 else if (op
== WINED3D_TOP_MODULATE_2X
)
219 GL_EXTCALL(glCombinerOutputNV(target
, portion
, output
, GL_DISCARD_NV
,
220 GL_DISCARD_NV
, GL_SCALE_BY_TWO_NV
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
221 else if (op
== WINED3D_TOP_MODULATE_4X
)
222 GL_EXTCALL(glCombinerOutputNV(target
, portion
, output
, GL_DISCARD_NV
,
223 GL_DISCARD_NV
, GL_SCALE_BY_FOUR_NV
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
226 case WINED3D_TOP_ADD
:
227 case WINED3D_TOP_ADD_SIGNED
:
228 case WINED3D_TOP_ADD_SIGNED_2X
:
229 /* Input, arg1*1+arg2*1 */
230 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
231 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
232 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
233 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
234 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
235 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
236 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
237 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
240 if (op
== WINED3D_TOP_ADD
)
241 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
242 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
243 else if (op
== WINED3D_TOP_ADD_SIGNED
)
244 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
245 output
, GL_NONE
, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
246 else if (op
== WINED3D_TOP_ADD_SIGNED_2X
)
247 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
248 output
, GL_SCALE_BY_TWO_NV
, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
251 case WINED3D_TOP_SUBTRACT
:
252 /* Input, arg1*1+-arg2*1 */
253 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
254 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
255 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
256 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
257 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
258 tex_op_args
.input
[1], GL_SIGNED_NEGATE_NV
, tex_op_args
.component_usage
[1]));
259 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
260 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
263 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
264 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
267 case WINED3D_TOP_ADD_SMOOTH
:
268 /* Input, arg1*1+(1-arg1)*arg2 */
269 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
270 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
271 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
272 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
273 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
274 tex_op_args
.input
[0], invert_mapping(tex_op_args
.mapping
[0]), tex_op_args
.component_usage
[0]));
275 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
276 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
279 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
280 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
283 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA
:
284 case WINED3D_TOP_BLEND_TEXTURE_ALPHA
:
285 case WINED3D_TOP_BLEND_FACTOR_ALPHA
:
286 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
287 case WINED3D_TOP_BLEND_CURRENT_ALPHA
:
289 GLenum alpha_src
= GL_PRIMARY_COLOR_NV
;
290 if (op
== WINED3D_TOP_BLEND_DIFFUSE_ALPHA
)
291 alpha_src
= d3dta_to_combiner_input(WINED3DTA_DIFFUSE
, stage
, texture_idx
);
292 else if (op
== WINED3D_TOP_BLEND_TEXTURE_ALPHA
)
293 alpha_src
= d3dta_to_combiner_input(WINED3DTA_TEXTURE
, stage
, texture_idx
);
294 else if (op
== WINED3D_TOP_BLEND_FACTOR_ALPHA
)
295 alpha_src
= d3dta_to_combiner_input(WINED3DTA_TFACTOR
, stage
, texture_idx
);
296 else if (op
== WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
)
297 alpha_src
= d3dta_to_combiner_input(WINED3DTA_TEXTURE
, stage
, texture_idx
);
298 else if (op
== WINED3D_TOP_BLEND_CURRENT_ALPHA
)
299 alpha_src
= d3dta_to_combiner_input(WINED3DTA_CURRENT
, stage
, texture_idx
);
301 FIXME("Unhandled texture op %s, shouldn't happen.\n", debug_d3dtop(op
));
303 /* Input, arg1*alpha_src+arg2*(1-alpha_src) */
304 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
305 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
306 if (op
== WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
)
308 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
309 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
311 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
312 alpha_src
, GL_UNSIGNED_IDENTITY_NV
, GL_ALPHA
));
314 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
315 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
316 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
317 alpha_src
, GL_UNSIGNED_INVERT_NV
, GL_ALPHA
));
320 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
321 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
325 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
326 /* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
328 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEALPHA_ADDCOLOR).\n");
329 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
330 tex_op_args
.input
[0], tex_op_args
.mapping
[0], GL_ALPHA
));
331 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
332 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
333 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
334 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
335 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
336 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
339 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
340 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
343 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
344 /* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
346 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATECOLOR_ADDALPHA).\n");
347 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
348 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
349 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
350 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
351 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
352 tex_op_args
.input
[0], tex_op_args
.mapping
[0], GL_ALPHA
));
353 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
354 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
357 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
358 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
361 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
362 /* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
364 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR).\n");
365 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
366 tex_op_args
.input
[0], invert_mapping(tex_op_args
.mapping
[0]), GL_ALPHA
));
367 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
368 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
369 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
370 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
371 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
372 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
375 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
376 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
379 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
380 /* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
382 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA).\n");
383 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
384 tex_op_args
.input
[0], invert_mapping(tex_op_args
.mapping
[0]), tex_op_args
.component_usage
[0]));
385 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
386 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
387 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
388 tex_op_args
.input
[0], tex_op_args
.mapping
[0], GL_ALPHA
));
389 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
390 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
393 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
394 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
397 case WINED3D_TOP_DOTPRODUCT3
:
398 /* Input, arg1 . arg2 */
399 /* FIXME: DX7 uses a different calculation? */
400 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
401 tex_op_args
.input
[0], GL_EXPAND_NORMAL_NV
, tex_op_args
.component_usage
[0]));
402 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
403 tex_op_args
.input
[1], GL_EXPAND_NORMAL_NV
, tex_op_args
.component_usage
[1]));
406 GL_EXTCALL(glCombinerOutputNV(target
, portion
, output
, GL_DISCARD_NV
,
407 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_TRUE
, GL_FALSE
, GL_FALSE
));
410 case WINED3D_TOP_MULTIPLY_ADD
:
411 /* Input, arg3*1+arg1*arg2 */
412 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
413 tex_op_args
.input
[2], tex_op_args
.mapping
[2], tex_op_args
.component_usage
[2]));
414 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
415 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
416 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
417 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
418 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
419 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
422 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
423 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
426 case WINED3D_TOP_LERP
:
427 /* Input, arg3*arg1+(1-arg3)*arg2 */
428 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
429 tex_op_args
.input
[2], tex_op_args
.mapping
[2], tex_op_args
.component_usage
[2]));
430 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
431 tex_op_args
.input
[0], tex_op_args
.mapping
[0], tex_op_args
.component_usage
[0]));
432 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_C_NV
,
433 tex_op_args
.input
[2], invert_mapping(tex_op_args
.mapping
[2]), tex_op_args
.component_usage
[2]));
434 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_D_NV
,
435 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
438 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_DISCARD_NV
, GL_DISCARD_NV
,
439 output
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
442 case WINED3D_TOP_BUMPENVMAP_LUMINANCE
:
443 case WINED3D_TOP_BUMPENVMAP
:
444 if (gl_info
->supported
[NV_TEXTURE_SHADER
])
446 /* The bump map stage itself isn't exciting, just read the texture. But tell the next stage to
447 * perform bump mapping and source from the current stage. Pretty much a SELECTARG2.
448 * ARG2 is passed through unmodified(apps will most likely use D3DTA_CURRENT for arg2, arg1
449 * (which will most likely be D3DTA_TEXTURE) is available as a texture shader input for the next stage
451 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_A_NV
,
452 tex_op_args
.input
[1], tex_op_args
.mapping
[1], tex_op_args
.component_usage
[1]));
453 GL_EXTCALL(glCombinerInputNV(target
, portion
, GL_VARIABLE_B_NV
,
454 GL_ZERO
, GL_UNSIGNED_INVERT_NV
, portion
));
455 /* Always pass through to CURRENT, ignore temp arg */
456 GL_EXTCALL(glCombinerOutputNV(target
, portion
, GL_SPARE0_NV
, GL_DISCARD_NV
,
457 GL_DISCARD_NV
, GL_NONE
, GL_NONE
, GL_FALSE
, GL_FALSE
, GL_FALSE
));
462 FIXME("Unhandled texture op: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d.\n",
463 stage
, is_alpha
, debug_d3dtop(op
), op
, arg1
, arg2
, arg3
, texture_idx
);
466 checkGLcall("set_tex_op_nvrc()");
470 static void nvrc_colorop(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
472 DWORD stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
473 const struct wined3d_device
*device
= context
->swapchain
->device
;
474 BOOL tex_used
= device
->fixed_function_usage_map
& (1 << stage
);
475 DWORD mapped_stage
= device
->texUnitMap
[stage
];
476 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
478 TRACE("Setting color op for stage %u.\n", stage
);
480 /* Using a pixel shader? Don't care for anything here, the shader applying does it */
481 if (use_ps(state
)) return;
483 if (stage
!= mapped_stage
) WARN("Using non 1:1 mapping: %d -> %d!\n", stage
, mapped_stage
);
485 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
487 if (tex_used
&& mapped_stage
>= gl_info
->limits
.textures
)
489 FIXME("Attempt to enable unsupported stage!\n");
492 context_active_texture(context
, gl_info
, mapped_stage
);
495 if (state
->lowest_disabled_stage
> 0)
497 glEnable(GL_REGISTER_COMBINERS_NV
);
498 GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV
, state
->lowest_disabled_stage
));
502 glDisable(GL_REGISTER_COMBINERS_NV
);
504 if (stage
>= state
->lowest_disabled_stage
)
506 TRACE("Stage disabled\n");
507 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
509 /* Disable everything here */
510 glDisable(GL_TEXTURE_2D
);
511 checkGLcall("glDisable(GL_TEXTURE_2D)");
512 glDisable(GL_TEXTURE_3D
);
513 checkGLcall("glDisable(GL_TEXTURE_3D)");
514 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
516 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
517 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
519 if (gl_info
->supported
[ARB_TEXTURE_RECTANGLE
])
521 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
522 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
524 if (gl_info
->supported
[NV_TEXTURE_SHADER2
] && mapped_stage
< gl_info
->limits
.textures
)
526 glTexEnvi(GL_TEXTURE_SHADER_NV
, GL_SHADER_OPERATION_NV
, GL_NONE
);
533 /* The sampler will also activate the correct texture dimensions, so no need to do it here
534 * if the sampler for this stage is dirty
536 if (!isStateDirty(context
, STATE_SAMPLER(stage
)))
540 if (gl_info
->supported
[NV_TEXTURE_SHADER2
])
542 nvts_activate_dimensions(state
, stage
, context
);
546 texture_activate_dimensions(state
->textures
[stage
], gl_info
);
551 /* Set the texture combiners */
552 set_tex_op_nvrc(gl_info
, state
, FALSE
, stage
,
553 state
->texture_states
[stage
][WINED3D_TSS_COLOR_OP
],
554 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG1
],
555 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG2
],
556 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG0
],
558 state
->texture_states
[stage
][WINED3D_TSS_RESULT_ARG
]);
560 /* In register combiners bump mapping is done in the stage AFTER the one that has the bump map operation set,
561 * thus the texture shader may have to be updated
563 if (gl_info
->supported
[NV_TEXTURE_SHADER2
])
565 BOOL usesBump
= (state
->texture_states
[stage
][WINED3D_TSS_COLOR_OP
] == WINED3D_TOP_BUMPENVMAP_LUMINANCE
566 || state
->texture_states
[stage
][WINED3D_TSS_COLOR_OP
] == WINED3D_TOP_BUMPENVMAP
);
567 BOOL usedBump
= !!(context
->texShaderBumpMap
& 1 << (stage
+ 1));
568 if (usesBump
!= usedBump
)
570 context_active_texture(context
, gl_info
, mapped_stage
+ 1);
571 nvts_activate_dimensions(state
, stage
+ 1, context
);
572 context_active_texture(context
, gl_info
, mapped_stage
);
577 static void nvts_texdim(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
579 DWORD sampler
= state_id
- STATE_SAMPLER(0);
580 DWORD mapped_stage
= context
->swapchain
->device
->texUnitMap
[sampler
];
582 /* No need to enable / disable anything here for unused samplers. The tex_colorop
583 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
584 * will take care of this business. */
585 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
|| mapped_stage
>= context
->gl_info
->limits
.textures
)
587 if (sampler
>= state
->lowest_disabled_stage
)
589 if (isStateDirty(context
, STATE_TEXTURESTAGE(sampler
, WINED3D_TSS_COLOR_OP
)))
592 nvts_activate_dimensions(state
, sampler
, context
);
595 static void nvts_bumpenvmat(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
597 DWORD stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
598 DWORD mapped_stage
= context
->swapchain
->device
->texUnitMap
[stage
+ 1];
599 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
602 /* Direct3D sets the matrix in the stage reading the perturbation map. The result is used to
603 * offset the destination stage(always stage + 1 in d3d). In GL_NV_texture_shader, the bump
604 * map offsetting is done in the stage reading the bump mapped texture, and the perturbation
605 * map is read from a specified source stage(always stage - 1 for d3d). Thus set the matrix
606 * for stage + 1. Keep the nvrc tex unit mapping in mind too
608 if (mapped_stage
< gl_info
->limits
.textures
)
610 context_active_texture(context
, gl_info
, mapped_stage
);
612 /* We can't just pass a pointer to the state to GL due to the
613 * different matrix format (column major vs row major). */
614 mat
[0][0] = *((float *)&state
->texture_states
[stage
][WINED3D_TSS_BUMPENV_MAT00
]);
615 mat
[1][0] = *((float *)&state
->texture_states
[stage
][WINED3D_TSS_BUMPENV_MAT01
]);
616 mat
[0][1] = *((float *)&state
->texture_states
[stage
][WINED3D_TSS_BUMPENV_MAT10
]);
617 mat
[1][1] = *((float *)&state
->texture_states
[stage
][WINED3D_TSS_BUMPENV_MAT11
]);
618 glTexEnvfv(GL_TEXTURE_SHADER_NV
, GL_OFFSET_TEXTURE_MATRIX_NV
, (float *)mat
);
619 checkGLcall("glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, mat)");
623 static void nvrc_texfactor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
625 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
628 D3DCOLORTOGLFLOAT4(state
->render_states
[WINED3D_RS_TEXTUREFACTOR
], col
);
629 GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV
, &col
[0]));
632 /* Context activation is done by the caller. */
633 static void nvrc_enable(BOOL enable
)
637 glEnable(GL_REGISTER_COMBINERS_NV
);
638 checkGLcall("glEnable(GL_REGISTER_COMBINERS_NV)");
642 glDisable(GL_REGISTER_COMBINERS_NV
);
643 checkGLcall("glDisable(GL_REGISTER_COMBINERS_NV)");
647 /* Context activation and GL locking are done by the caller. */
648 static void nvts_enable(BOOL enable
)
653 glEnable(GL_TEXTURE_SHADER_NV
);
654 checkGLcall("glEnable(GL_TEXTURE_SHADER_NV)");
658 glDisable(GL_TEXTURE_SHADER_NV
);
659 checkGLcall("glDisable(GL_TEXTURE_SHADER_NV)");
663 static void nvrc_fragment_get_caps(const struct wined3d_gl_info
*gl_info
, struct fragment_caps
*caps
)
665 caps
->PrimitiveMiscCaps
= WINED3DPMISCCAPS_TSSARGTEMP
;
667 /* The caps below can be supported but aren't handled yet in utils.c
668 * 'd3dta_to_combiner_input', disable them until support is fixed */
670 if (gl_info
->supported
[NV_REGISTER_COMBINERS2
])
671 caps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_PERSTAGECONSTANT
;
674 caps
->TextureOpCaps
= WINED3DTEXOPCAPS_ADD
675 | WINED3DTEXOPCAPS_ADDSIGNED
676 | WINED3DTEXOPCAPS_ADDSIGNED2X
677 | WINED3DTEXOPCAPS_MODULATE
678 | WINED3DTEXOPCAPS_MODULATE2X
679 | WINED3DTEXOPCAPS_MODULATE4X
680 | WINED3DTEXOPCAPS_SELECTARG1
681 | WINED3DTEXOPCAPS_SELECTARG2
682 | WINED3DTEXOPCAPS_DISABLE
683 | WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
684 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
685 | WINED3DTEXOPCAPS_BLENDFACTORALPHA
686 | WINED3DTEXOPCAPS_BLENDCURRENTALPHA
687 | WINED3DTEXOPCAPS_LERP
688 | WINED3DTEXOPCAPS_SUBTRACT
689 | WINED3DTEXOPCAPS_ADDSMOOTH
690 | WINED3DTEXOPCAPS_MULTIPLYADD
691 | WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
692 | WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
693 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
694 | WINED3DTEXOPCAPS_DOTPRODUCT3
695 | WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
696 | WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA
;
698 if (gl_info
->supported
[NV_TEXTURE_SHADER2
])
700 /* Bump mapping is supported already in NV_TEXTURE_SHADER, but that extension does
701 * not support 3D textures. This asks for trouble if an app uses both bump mapping
702 * and 3D textures. It also allows us to keep the code simpler by having texture
703 * shaders constantly enabled. */
704 caps
->TextureOpCaps
|= WINED3DTEXOPCAPS_BUMPENVMAP
;
705 /* TODO: Luminance bump map? */
710 caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
711 WINED3DTEXOPCAPS_PREMODULATE */
714 caps
->MaxTextureBlendStages
= min(MAX_TEXTURES
, gl_info
->limits
.general_combiners
);
715 caps
->MaxSimultaneousTextures
= gl_info
->limits
.textures
;
718 static HRESULT
nvrc_fragment_alloc(struct wined3d_device
*device
) { return WINED3D_OK
; }
719 /* Context activation is done by the caller. */
720 static void nvrc_fragment_free(struct wined3d_device
*device
) {}
722 /* Two fixed function pipeline implementations using GL_NV_register_combiners and
723 * GL_NV_texture_shader. The nvts_fragment_pipeline assumes that both extensions
724 * are available(geforce 3 and newer), while nvrc_fragment_pipeline uses only the
725 * register combiners extension(Pre-GF3).
728 static BOOL
nvts_color_fixup_supported(struct color_fixup_desc fixup
)
732 TRACE("Checking support for fixup:\n");
733 dump_color_fixup_desc(fixup
);
736 /* We only support identity conversions. */
737 if (is_identity_fixup(fixup
))
747 static const struct StateEntryTemplate nvrc_fragmentstate_template
[] =
749 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), nvrc_colorop
}, WINED3D_GL_EXT_NONE
},
750 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
751 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
752 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
753 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
754 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
755 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), nvts_bumpenvmat
}, NV_TEXTURE_SHADER2
},
756 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
757 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
758 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
759 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
760 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
761 { STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
762 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), nvrc_colorop
}, WINED3D_GL_EXT_NONE
},
763 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
764 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
765 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
766 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
767 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
768 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), nvts_bumpenvmat
}, NV_TEXTURE_SHADER2
},
769 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
770 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
771 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
772 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
773 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
774 { STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
775 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), nvrc_colorop
}, WINED3D_GL_EXT_NONE
},
776 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
777 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
778 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
779 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
780 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
781 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), nvts_bumpenvmat
}, NV_TEXTURE_SHADER2
},
782 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
783 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
784 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
785 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
786 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
787 { STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
788 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), nvrc_colorop
}, WINED3D_GL_EXT_NONE
},
789 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
790 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
791 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
792 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
793 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
794 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), nvts_bumpenvmat
}, NV_TEXTURE_SHADER2
},
795 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
796 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
797 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
798 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
799 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
800 { STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
801 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), nvrc_colorop
}, WINED3D_GL_EXT_NONE
},
802 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
803 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
804 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
805 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
806 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
807 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), nvts_bumpenvmat
}, NV_TEXTURE_SHADER2
},
808 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
809 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
810 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
811 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
812 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
813 { STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
814 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), nvrc_colorop
}, WINED3D_GL_EXT_NONE
},
815 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
816 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
817 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
818 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
819 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
820 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), nvts_bumpenvmat
}, NV_TEXTURE_SHADER2
},
821 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
822 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
823 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
824 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
825 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
826 { STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
827 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), nvrc_colorop
}, WINED3D_GL_EXT_NONE
},
828 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
829 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
830 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
831 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
832 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
833 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), nvts_bumpenvmat
}, NV_TEXTURE_SHADER2
},
834 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
835 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
836 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
837 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
838 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
839 { STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
840 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), nvrc_colorop
}, WINED3D_GL_EXT_NONE
},
841 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
842 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
843 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
844 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
845 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
846 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), nvts_bumpenvmat
}, NV_TEXTURE_SHADER2
},
847 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
848 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
849 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, NV_TEXTURE_SHADER2
},
850 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
851 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
852 { STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
853 { STATE_PIXELSHADER
, { STATE_PIXELSHADER
, apply_pixelshader
}, WINED3D_GL_EXT_NONE
},
854 { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE
), { STATE_PIXELSHADER
, NULL
}, WINED3D_GL_EXT_NONE
},
855 { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), nvrc_texfactor
}, WINED3D_GL_EXT_NONE
},
856 { STATE_RENDER(WINED3D_RS_FOGCOLOR
), { STATE_RENDER(WINED3D_RS_FOGCOLOR
), state_fogcolor
}, WINED3D_GL_EXT_NONE
},
857 { STATE_RENDER(WINED3D_RS_FOGDENSITY
), { STATE_RENDER(WINED3D_RS_FOGDENSITY
), state_fogdensity
}, WINED3D_GL_EXT_NONE
},
858 { STATE_RENDER(WINED3D_RS_FOGENABLE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), state_fog_fragpart
}, WINED3D_GL_EXT_NONE
},
859 { STATE_RENDER(WINED3D_RS_FOGTABLEMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
860 { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
861 { STATE_RENDER(WINED3D_RS_FOGSTART
), { STATE_RENDER(WINED3D_RS_FOGSTART
), state_fogstartend
}, WINED3D_GL_EXT_NONE
},
862 { STATE_RENDER(WINED3D_RS_FOGEND
), { STATE_RENDER(WINED3D_RS_FOGSTART
), NULL
}, WINED3D_GL_EXT_NONE
},
863 { STATE_SAMPLER(0), { STATE_SAMPLER(0), nvts_texdim
}, NV_TEXTURE_SHADER2
},
864 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
865 { STATE_SAMPLER(1), { STATE_SAMPLER(1), nvts_texdim
}, NV_TEXTURE_SHADER2
},
866 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
867 { STATE_SAMPLER(2), { STATE_SAMPLER(2), nvts_texdim
}, NV_TEXTURE_SHADER2
},
868 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
869 { STATE_SAMPLER(3), { STATE_SAMPLER(3), nvts_texdim
}, NV_TEXTURE_SHADER2
},
870 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
871 { STATE_SAMPLER(4), { STATE_SAMPLER(4), nvts_texdim
}, NV_TEXTURE_SHADER2
},
872 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
873 { STATE_SAMPLER(5), { STATE_SAMPLER(5), nvts_texdim
}, NV_TEXTURE_SHADER2
},
874 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
875 { STATE_SAMPLER(6), { STATE_SAMPLER(6), nvts_texdim
}, NV_TEXTURE_SHADER2
},
876 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
877 { STATE_SAMPLER(7), { STATE_SAMPLER(7), nvts_texdim
}, NV_TEXTURE_SHADER2
},
878 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
879 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
882 const struct fragment_pipeline nvts_fragment_pipeline
= {
884 nvrc_fragment_get_caps
,
887 nvts_color_fixup_supported
,
888 nvrc_fragmentstate_template
,
889 FALSE
/* we cannot disable projected textures. The vertex pipe has to do it */
892 const struct fragment_pipeline nvrc_fragment_pipeline
= {
894 nvrc_fragment_get_caps
,
897 nvts_color_fixup_supported
,
898 nvrc_fragmentstate_template
,
899 FALSE
/* we cannot disable projected textures. The vertex pipe has to do it */