1 /*
2 * Fixed function pipeline replacement using GL_NV_register_combiners
3 * and GL_NV_texture_shader
4 *
5 * Copyright 2006 Henri Verbeet
6 * Copyright 2008 Stefan Dösinger(for CodeWeavers)
7 *
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.
12 *
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.
17 *
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
21 */
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdio.h>
26
27 #include "wined3d_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
30
31 /* Context activation for state handlers is done by the caller. */
32
nvts_activate_dimensions(const struct wined3d_state * state,DWORD stage,struct wined3d_context * context)33 static void nvts_activate_dimensions(const struct wined3d_state *state, DWORD stage, struct wined3d_context *context)
34 {
35 const struct wined3d_gl_info *gl_info = context->gl_info;
36 BOOL bumpmap = FALSE;
37
38 if (stage > 0
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))
41 {
42 bumpmap = TRUE;
43 context->texShaderBumpMap |= (1u << stage);
44 }
45 else
46 {
47 context->texShaderBumpMap &= ~(1u << stage);
48 }
49
50 if (state->textures[stage])
51 {
52 switch (state->textures[stage]->target)
53 {
54 case GL_TEXTURE_2D:
55 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV,
56 bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_2D);
57 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)");
58 break;
59 case GL_TEXTURE_RECTANGLE_ARB:
60 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV,
61 bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_RECTANGLE_ARB);
62 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)");
63 break;
64 case GL_TEXTURE_3D:
65 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D);
66 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D)");
67 break;
68 case GL_TEXTURE_CUBE_MAP_ARB:
69 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB);
70 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB)");
71 break;
72 }
73 }
74 else
75 {
76 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
77 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE)");
78 }
79 }
80
81 struct tex_op_args
82 {
83 GLenum input[3];
84 GLenum mapping[3];
85 GLenum component_usage[3];
86 };
87
d3dta_to_combiner_input(DWORD d3dta,DWORD stage,INT texture_idx)88 static GLenum d3dta_to_combiner_input(DWORD d3dta, DWORD stage, INT texture_idx) {
89 switch (d3dta) {
90 case WINED3DTA_DIFFUSE:
91 return GL_PRIMARY_COLOR_NV;
92
93 case WINED3DTA_CURRENT:
94 if (stage) return GL_SPARE0_NV;
95 else return GL_PRIMARY_COLOR_NV;
96
97 case WINED3DTA_TEXTURE:
98 if (texture_idx > -1) return GL_TEXTURE0_ARB + texture_idx;
99 else return GL_PRIMARY_COLOR_NV;
100
101 case WINED3DTA_TFACTOR:
102 return GL_CONSTANT_COLOR0_NV;
103
104 case WINED3DTA_SPECULAR:
105 return GL_SECONDARY_COLOR_NV;
106
107 case WINED3DTA_TEMP:
108 return GL_SPARE1_NV;
109
110 case WINED3DTA_CONSTANT:
111 /* TODO: Support per stage constants (WINED3D_TSS_CONSTANT, NV_register_combiners2) */
112 FIXME("WINED3DTA_CONSTANT, not properly supported.\n");
113 return GL_CONSTANT_COLOR1_NV;
114
115 default:
116 FIXME("Unrecognized texture arg %#x\n", d3dta);
117 return GL_TEXTURE;
118 }
119 }
120
invert_mapping(GLenum mapping)121 static GLenum invert_mapping(GLenum mapping) {
122 if (mapping == GL_UNSIGNED_INVERT_NV) return GL_UNSIGNED_IDENTITY_NV;
123 else if (mapping == GL_UNSIGNED_IDENTITY_NV) return GL_UNSIGNED_INVERT_NV;
124
125 FIXME("Unhandled mapping %#x\n", mapping);
126 return mapping;
127 }
128
get_src_and_opr_nvrc(DWORD stage,DWORD arg,BOOL is_alpha,GLenum * input,GLenum * mapping,GLenum * component_usage,INT texture_idx)129 static void get_src_and_opr_nvrc(DWORD stage, DWORD arg, BOOL is_alpha, GLenum* input, GLenum* mapping, GLenum *component_usage, INT texture_idx) {
130 /* The WINED3DTA_COMPLEMENT flag specifies the complement of the input should
131 * be used. */
132 if (arg & WINED3DTA_COMPLEMENT) *mapping = GL_UNSIGNED_INVERT_NV;
133 else *mapping = GL_UNSIGNED_IDENTITY_NV; /* Clamp all values to positive ranges */
134
135 /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the input
136 * should be used for all input components. */
137 if (is_alpha || arg & WINED3DTA_ALPHAREPLICATE) *component_usage = GL_ALPHA;
138 else *component_usage = GL_RGB;
139
140 *input = d3dta_to_combiner_input(arg & WINED3DTA_SELECTMASK, stage, texture_idx);
141 }
142
set_tex_op_nvrc(const struct wined3d_gl_info * gl_info,const struct wined3d_state * state,BOOL is_alpha,int stage,enum wined3d_texture_op op,DWORD arg1,DWORD arg2,DWORD arg3,INT texture_idx,DWORD dst)143 void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state, BOOL is_alpha,
144 int stage, enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx, DWORD dst)
145 {
146 struct tex_op_args tex_op_args = {{0}, {0}, {0}};
147 GLenum portion = is_alpha ? GL_ALPHA : GL_RGB;
148 GLenum target = GL_COMBINER0_NV + stage;
149 GLenum output;
150
151 TRACE("stage %d, is_alpha %d, op %s, arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
152 stage, is_alpha, debug_d3dtop(op), arg1, arg2, arg3, texture_idx);
153
154 /* If a texture stage references an invalid texture unit the stage just
155 * passes through the result from the previous stage */
156 if (is_invalid_op(state, stage, op, arg1, arg2, arg3))
157 {
158 arg1 = WINED3DTA_CURRENT;
159 op = WINED3D_TOP_SELECT_ARG1;
160 }
161
162 get_src_and_opr_nvrc(stage, arg1, is_alpha, &tex_op_args.input[0],
163 &tex_op_args.mapping[0], &tex_op_args.component_usage[0], texture_idx);
164 get_src_and_opr_nvrc(stage, arg2, is_alpha, &tex_op_args.input[1],
165 &tex_op_args.mapping[1], &tex_op_args.component_usage[1], texture_idx);
166 get_src_and_opr_nvrc(stage, arg3, is_alpha, &tex_op_args.input[2],
167 &tex_op_args.mapping[2], &tex_op_args.component_usage[2], texture_idx);
168
169
170 if(dst == WINED3DTA_TEMP) {
171 output = GL_SPARE1_NV;
172 } else {
173 output = GL_SPARE0_NV;
174 }
175
176 switch (op)
177 {
178 case WINED3D_TOP_DISABLE:
179 /* Only for alpha */
180 if (!is_alpha)
181 ERR("Shouldn't be called for WINED3D_TSS_COLOR_OP (WINED3DTOP_DISABLE).\n");
182 /* Input, prev_alpha*1 */
183 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
184 GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
185 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
186 GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
187
188 /* Output */
189 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
190 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
191 break;
192
193 case WINED3D_TOP_SELECT_ARG1:
194 case WINED3D_TOP_SELECT_ARG2:
195 /* Input, arg*1 */
196 if (op == WINED3D_TOP_SELECT_ARG1)
197 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
198 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
199 else
200 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
201 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
202 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
203 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
204
205 /* Output */
206 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
207 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
208 break;
209
210 case WINED3D_TOP_MODULATE:
211 case WINED3D_TOP_MODULATE_2X:
212 case WINED3D_TOP_MODULATE_4X:
213 /* Input, arg1*arg2 */
214 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
215 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
216 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
217 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
218
219 /* Output */
220 if (op == WINED3D_TOP_MODULATE)
221 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
222 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
223 else if (op == WINED3D_TOP_MODULATE_2X)
224 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
225 GL_DISCARD_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
226 else if (op == WINED3D_TOP_MODULATE_4X)
227 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
228 GL_DISCARD_NV, GL_SCALE_BY_FOUR_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
229 break;
230
231 case WINED3D_TOP_ADD:
232 case WINED3D_TOP_ADD_SIGNED:
233 case WINED3D_TOP_ADD_SIGNED_2X:
234 /* Input, arg1*1+arg2*1 */
235 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
236 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
237 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
238 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
239 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
240 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
241 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
242 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
243
244 /* Output */
245 if (op == WINED3D_TOP_ADD)
246 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
247 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
248 else if (op == WINED3D_TOP_ADD_SIGNED)
249 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
250 output, GL_NONE, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
251 else if (op == WINED3D_TOP_ADD_SIGNED_2X)
252 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
253 output, GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
254 break;
255
256 case WINED3D_TOP_SUBTRACT:
257 /* Input, arg1*1+-arg2*1 */
258 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
259 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
260 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
261 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
262 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
263 tex_op_args.input[1], GL_SIGNED_NEGATE_NV, tex_op_args.component_usage[1]));
264 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
265 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
266
267 /* Output */
268 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
269 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
270 break;
271
272 case WINED3D_TOP_ADD_SMOOTH:
273 /* Input, arg1*1+(1-arg1)*arg2 */
274 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
275 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
276 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
277 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
278 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
279 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
280 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
281 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
282
283 /* Output */
284 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
285 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
286 break;
287
288 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA:
289 case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
290 case WINED3D_TOP_BLEND_FACTOR_ALPHA:
291 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
292 case WINED3D_TOP_BLEND_CURRENT_ALPHA:
293 {
294 GLenum alpha_src = GL_PRIMARY_COLOR_NV;
295 if (op == WINED3D_TOP_BLEND_DIFFUSE_ALPHA)
296 alpha_src = d3dta_to_combiner_input(WINED3DTA_DIFFUSE, stage, texture_idx);
297 else if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA)
298 alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
299 else if (op == WINED3D_TOP_BLEND_FACTOR_ALPHA)
300 alpha_src = d3dta_to_combiner_input(WINED3DTA_TFACTOR, stage, texture_idx);
301 else if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM)
302 alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
303 else if (op == WINED3D_TOP_BLEND_CURRENT_ALPHA)
304 alpha_src = d3dta_to_combiner_input(WINED3DTA_CURRENT, stage, texture_idx);
305 else
306 FIXME("Unhandled texture op %s, shouldn't happen.\n", debug_d3dtop(op));
307
308 /* Input, arg1*alpha_src+arg2*(1-alpha_src) */
309 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
310 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
311 if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM)
312 {
313 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
314 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
315 } else {
316 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
317 alpha_src, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
318 }
319 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
320 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
321 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
322 alpha_src, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
323
324 /* Output */
325 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
326 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
327 break;
328 }
329
330 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR:
331 /* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
332 if (is_alpha)
333 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEALPHA_ADDCOLOR).\n");
334 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
335 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
336 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
337 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
338 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
339 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
340 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
341 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
342
343 /* Output */
344 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
345 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
346 break;
347
348 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA:
349 /* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
350 if (is_alpha)
351 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATECOLOR_ADDALPHA).\n");
352 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
353 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
354 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
355 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
356 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
357 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
358 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
359 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
360
361 /* Output */
362 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
363 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
364 break;
365
366 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR:
367 /* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
368 if (is_alpha)
369 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR).\n");
370 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
371 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), GL_ALPHA));
372 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
373 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
374 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
375 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
376 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
377 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
378
379 /* Output */
380 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
381 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
382 break;
383
384 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA:
385 /* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
386 if (is_alpha)
387 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA).\n");
388 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
389 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
390 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
391 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
392 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
393 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
394 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
395 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
396
397 /* Output */
398 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
399 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
400 break;
401
402 case WINED3D_TOP_DOTPRODUCT3:
403 /* Input, arg1 . arg2 */
404 /* FIXME: DX7 uses a different calculation? */
405 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
406 tex_op_args.input[0], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[0]));
407 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
408 tex_op_args.input[1], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[1]));
409
410 /* Output */
411 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
412 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE));
413 break;
414
415 case WINED3D_TOP_MULTIPLY_ADD:
416 /* Input, arg3*1+arg1*arg2 */
417 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
418 tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
419 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
420 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
421 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
422 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
423 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
424 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
425
426 /* Output */
427 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
428 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
429 break;
430
431 case WINED3D_TOP_LERP:
432 /* Input, arg3*arg1+(1-arg3)*arg2 */
433 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
434 tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
435 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
436 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
437 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
438 tex_op_args.input[2], invert_mapping(tex_op_args.mapping[2]), tex_op_args.component_usage[2]));
439 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
440 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
441
442 /* Output */
443 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
444 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
445 break;
446
447 case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
448 case WINED3D_TOP_BUMPENVMAP:
449 if (!gl_info->supported[NV_TEXTURE_SHADER])
450 {
451 WARN("BUMPENVMAP requires GL_NV_texture_shader in this codepath\n");
452 break;
453 }
454
455 /* The bump map stage itself isn't exciting, just read the texture. But tell the next stage to
456 * perform bump mapping and source from the current stage. Pretty much a SELECTARG2.
457 * ARG2 is passed through unmodified(apps will most likely use D3DTA_CURRENT for arg2, arg1
458 * (which will most likely be D3DTA_TEXTURE) is available as a texture shader input for the
459 * next stage */
460 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
461 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
462 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
463 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
464 /* Always pass through to CURRENT, ignore temp arg */
465 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
466 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
467 break;
468
469 default:
470 FIXME("Unhandled texture op: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d.\n",
471 stage, is_alpha, debug_d3dtop(op), op, arg1, arg2, arg3, texture_idx);
472 }
473
474 checkGLcall("set_tex_op_nvrc()");
475 }
476
477
nvrc_colorop(struct wined3d_context * context,const struct wined3d_state * state,DWORD state_id)478 static void nvrc_colorop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
479 {
480 DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
481 BOOL tex_used = context->fixed_function_usage_map & (1u << stage);
482 DWORD mapped_stage = context->tex_unit_map[stage];
483 const struct wined3d_gl_info *gl_info = context->gl_info;
484
485 TRACE("Setting color op for stage %u.\n", stage);
486
487 /* Using a pixel shader? Don't care for anything here, the shader applying does it */
488 if (use_ps(state)) return;
489
490 if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
491
492 if (mapped_stage != WINED3D_UNMAPPED_STAGE)
493 {
494 if (tex_used && mapped_stage >= gl_info->limits.textures)
495 {
496 FIXME("Attempt to enable unsupported stage!\n");
497 return;
498 }
499 context_active_texture(context, gl_info, mapped_stage);
500 }
501
502 if (context->lowest_disabled_stage > 0)
503 {
504 gl_info->gl_ops.gl.p_glEnable(GL_REGISTER_COMBINERS_NV);
505 GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, context->lowest_disabled_stage));
506 }
507 else
508 {
509 gl_info->gl_ops.gl.p_glDisable(GL_REGISTER_COMBINERS_NV);
510 }
511 if (stage >= context->lowest_disabled_stage)
512 {
513 TRACE("Stage disabled\n");
514 if (mapped_stage != WINED3D_UNMAPPED_STAGE)
515 {
516 /* Disable everything here */
517 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
518 checkGLcall("glDisable(GL_TEXTURE_2D)");
519 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
520 checkGLcall("glDisable(GL_TEXTURE_3D)");
521 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
522 {
523 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
524 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
525 }
526 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
527 {
528 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
529 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
530 }
531 if (gl_info->supported[NV_TEXTURE_SHADER2] && mapped_stage < gl_info->limits.textures)
532 {
533 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
534 }
535 }
536 /* All done */
537 return;
538 }
539
540 /* The sampler will also activate the correct texture dimensions, so no need to do it here
541 * if the sampler for this stage is dirty
542 */
543 if (!isStateDirty(context, STATE_SAMPLER(stage)))
544 {
545 if (tex_used)
546 {
547 if (gl_info->supported[NV_TEXTURE_SHADER2])
548 {
549 nvts_activate_dimensions(state, stage, context);
550 }
551 else
552 {
553 texture_activate_dimensions(state->textures[stage], gl_info);
554 }
555 }
556 }
557
558 /* Set the texture combiners */
559 set_tex_op_nvrc(gl_info, state, FALSE, stage,
560 state->texture_states[stage][WINED3D_TSS_COLOR_OP],
561 state->texture_states[stage][WINED3D_TSS_COLOR_ARG1],
562 state->texture_states[stage][WINED3D_TSS_COLOR_ARG2],
563 state->texture_states[stage][WINED3D_TSS_COLOR_ARG0],
564 mapped_stage,
565 state->texture_states[stage][WINED3D_TSS_RESULT_ARG]);
566
567 /* In register combiners bump mapping is done in the stage AFTER the one that has the bump map operation set,
568 * thus the texture shader may have to be updated
569 */
570 if (gl_info->supported[NV_TEXTURE_SHADER2])
571 {
572 BOOL usesBump = (state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP_LUMINANCE
573 || state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP);
574 BOOL usedBump = !!(context->texShaderBumpMap & 1u << (stage + 1));
575 if (usesBump != usedBump)
576 {
577 context_active_texture(context, gl_info, mapped_stage + 1);
578 nvts_activate_dimensions(state, stage + 1, context);
579 context_active_texture(context, gl_info, mapped_stage);
580 }
581 }
582 }
583
nvrc_resultarg(struct wined3d_context * context,const struct wined3d_state * state,DWORD state_id)584 static void nvrc_resultarg(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
585 {
586 DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
587
588 TRACE("Setting result arg for stage %u.\n", stage);
589
590 if (!isStateDirty(context, STATE_TEXTURESTAGE(stage, WINED3D_TSS_COLOR_OP)))
591 {
592 context_apply_state(context, state, STATE_TEXTURESTAGE(stage, WINED3D_TSS_COLOR_OP));
593 }
594 if (!isStateDirty(context, STATE_TEXTURESTAGE(stage, WINED3D_TSS_ALPHA_OP)))
595 {
596 context_apply_state(context, state, STATE_TEXTURESTAGE(stage, WINED3D_TSS_ALPHA_OP));
597 }
598 }
599
nvts_texdim(struct wined3d_context * context,const struct wined3d_state * state,DWORD state_id)600 static void nvts_texdim(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
601 {
602 DWORD sampler = state_id - STATE_SAMPLER(0);
603 DWORD mapped_stage = context->tex_unit_map[sampler];
604
605 /* No need to enable / disable anything here for unused samplers. The tex_colorop
606 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
607 * will take care of this business. */
608 if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures)
609 return;
610 if (sampler >= context->lowest_disabled_stage)
611 return;
612 if (isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3D_TSS_COLOR_OP)))
613 return;
614
615 nvts_activate_dimensions(state, sampler, context);
616 }
617
nvts_bumpenvmat(struct wined3d_context * context,const struct wined3d_state * state,DWORD state_id)618 static void nvts_bumpenvmat(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
619 {
620 DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
621 DWORD mapped_stage = context->tex_unit_map[stage + 1];
622 const struct wined3d_gl_info *gl_info = context->gl_info;
623 float mat[2][2];
624
625 /* Direct3D sets the matrix in the stage reading the perturbation map. The result is used to
626 * offset the destination stage(always stage + 1 in d3d). In GL_NV_texture_shader, the bump
627 * map offsetting is done in the stage reading the bump mapped texture, and the perturbation
628 * map is read from a specified source stage(always stage - 1 for d3d). Thus set the matrix
629 * for stage + 1. Keep the nvrc tex unit mapping in mind too
630 */
631 if (mapped_stage < gl_info->limits.textures)
632 {
633 context_active_texture(context, gl_info, mapped_stage);
634
635 /* We can't just pass a pointer to the state to GL due to the
636 * different matrix format (column major vs row major). */
637 mat[0][0] = *((float *)&state->texture_states[stage][WINED3D_TSS_BUMPENV_MAT00]);
638 mat[1][0] = *((float *)&state->texture_states[stage][WINED3D_TSS_BUMPENV_MAT01]);
639 mat[0][1] = *((float *)&state->texture_states[stage][WINED3D_TSS_BUMPENV_MAT10]);
640 mat[1][1] = *((float *)&state->texture_states[stage][WINED3D_TSS_BUMPENV_MAT11]);
641 gl_info->gl_ops.gl.p_glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, (float *)mat);
642 checkGLcall("glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, mat)");
643 }
644 }
645
nvrc_texfactor(struct wined3d_context * context,const struct wined3d_state * state,DWORD state_id)646 static void nvrc_texfactor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
647 {
648 const struct wined3d_gl_info *gl_info = context->gl_info;
649 struct wined3d_color color;
650
651 wined3d_color_from_d3dcolor(&color, state->render_states[WINED3D_RS_TEXTUREFACTOR]);
652 GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &color.r));
653 }
654
655 /* Context activation is done by the caller. */
nvrc_enable(const struct wined3d_gl_info * gl_info,BOOL enable)656 static void nvrc_enable(const struct wined3d_gl_info *gl_info, BOOL enable)
657 {
658 if (enable)
659 {
660 gl_info->gl_ops.gl.p_glEnable(GL_REGISTER_COMBINERS_NV);
661 checkGLcall("glEnable(GL_REGISTER_COMBINERS_NV)");
662 }
663 else
664 {
665 gl_info->gl_ops.gl.p_glDisable(GL_REGISTER_COMBINERS_NV);
666 checkGLcall("glDisable(GL_REGISTER_COMBINERS_NV)");
667 }
668 }
669
670 /* Context activation is done by the caller. */
nvts_enable(const struct wined3d_gl_info * gl_info,BOOL enable)671 static void nvts_enable(const struct wined3d_gl_info *gl_info, BOOL enable)
672 {
673 nvrc_enable(gl_info, enable);
674 if (enable)
675 {
676 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_SHADER_NV);
677 checkGLcall("glEnable(GL_TEXTURE_SHADER_NV)");
678 }
679 else
680 {
681 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_SHADER_NV);
682 checkGLcall("glDisable(GL_TEXTURE_SHADER_NV)");
683 }
684 }
685
nvrc_fragment_get_caps(const struct wined3d_gl_info * gl_info,struct fragment_caps * caps)686 static void nvrc_fragment_get_caps(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps)
687 {
688 caps->wined3d_caps = 0;
689 caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_TSSARGTEMP;
690
691 /* The caps below can be supported but aren't handled yet in utils.c
692 * 'd3dta_to_combiner_input', disable them until support is fixed */
693 #if 0
694 if (gl_info->supported[NV_REGISTER_COMBINERS2])
695 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_PERSTAGECONSTANT;
696 #endif
697
698 caps->TextureOpCaps = WINED3DTEXOPCAPS_ADD
699 | WINED3DTEXOPCAPS_ADDSIGNED
700 | WINED3DTEXOPCAPS_ADDSIGNED2X
701 | WINED3DTEXOPCAPS_MODULATE
702 | WINED3DTEXOPCAPS_MODULATE2X
703 | WINED3DTEXOPCAPS_MODULATE4X
704 | WINED3DTEXOPCAPS_SELECTARG1
705 | WINED3DTEXOPCAPS_SELECTARG2
706 | WINED3DTEXOPCAPS_DISABLE
707 | WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
708 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
709 | WINED3DTEXOPCAPS_BLENDFACTORALPHA
710 | WINED3DTEXOPCAPS_BLENDCURRENTALPHA
711 | WINED3DTEXOPCAPS_LERP
712 | WINED3DTEXOPCAPS_SUBTRACT
713 | WINED3DTEXOPCAPS_ADDSMOOTH
714 | WINED3DTEXOPCAPS_MULTIPLYADD
715 | WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
716 | WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
717 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
718 | WINED3DTEXOPCAPS_DOTPRODUCT3
719 | WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
720 | WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA;
721
722 if (gl_info->supported[NV_TEXTURE_SHADER2])
723 {
724 /* Bump mapping is supported already in NV_TEXTURE_SHADER, but that extension does
725 * not support 3D textures. This asks for trouble if an app uses both bump mapping
726 * and 3D textures. It also allows us to keep the code simpler by having texture
727 * shaders constantly enabled. */
728 caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
729 /* TODO: Luminance bump map? */
730 }
731
732 #if 0
733 /* FIXME: Add
734 caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
735 WINED3DTEXOPCAPS_PREMODULATE */
736 #endif
737
738 caps->MaxTextureBlendStages = min(MAX_TEXTURES, gl_info->limits.general_combiners);
739 caps->MaxSimultaneousTextures = gl_info->limits.textures;
740 }
741
nvrc_fragment_get_emul_mask(const struct wined3d_gl_info * gl_info)742 static DWORD nvrc_fragment_get_emul_mask(const struct wined3d_gl_info *gl_info)
743 {
744 return GL_EXT_EMUL_ARB_MULTITEXTURE | GL_EXT_EMUL_EXT_FOG_COORD;
745 }
746
nvrc_fragment_alloc(const struct wined3d_shader_backend_ops * shader_backend,void * shader_priv)747 static void *nvrc_fragment_alloc(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv)
748 {
749 return shader_priv;
750 }
751
752 /* Context activation is done by the caller. */
nvrc_fragment_free(struct wined3d_device * device)753 static void nvrc_fragment_free(struct wined3d_device *device) {}
754
755 /* Two fixed function pipeline implementations using GL_NV_register_combiners and
756 * GL_NV_texture_shader. The nvts_fragment_pipeline assumes that both extensions
757 * are available(geforce 3 and newer), while nvrc_fragment_pipeline uses only the
758 * register combiners extension(Pre-GF3).
759 */
760
nvts_color_fixup_supported(struct color_fixup_desc fixup)761 static BOOL nvts_color_fixup_supported(struct color_fixup_desc fixup)
762 {
763 /* We only support identity conversions. */
764 return is_identity_fixup(fixup);
765 }
766
767 static const struct StateEntryTemplate nvrc_fragmentstate_template[] =
768 {
769 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
770 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
771 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
772 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
773 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
774 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
775 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
776 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
777 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
778 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
779 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
780 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
781 { STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG), nvrc_resultarg }, WINED3D_GL_EXT_NONE },
782 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
783 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
784 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
785 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
786 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
787 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
788 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
789 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
790 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
791 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
792 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
793 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
794 { STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG), nvrc_resultarg }, WINED3D_GL_EXT_NONE },
795 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
796 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
797 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
798 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
799 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
800 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
801 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
802 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
803 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
804 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
805 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
806 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
807 { STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG), nvrc_resultarg }, WINED3D_GL_EXT_NONE },
808 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
809 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
810 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
811 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
812 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
813 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
814 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
815 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
816 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
817 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
818 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
819 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
820 { STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG), nvrc_resultarg }, WINED3D_GL_EXT_NONE },
821 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
822 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
823 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
824 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
825 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
826 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
827 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
828 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
829 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
830 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
831 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
832 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
833 { STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG), nvrc_resultarg }, WINED3D_GL_EXT_NONE },
834 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
835 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
836 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
837 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
838 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
839 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
840 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
841 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
842 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
843 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
844 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
845 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
846 { STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG), nvrc_resultarg }, WINED3D_GL_EXT_NONE },
847 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
848 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
849 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
850 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
851 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
852 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
853 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
854 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
855 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
856 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
857 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
858 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
859 { STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG), nvrc_resultarg }, WINED3D_GL_EXT_NONE },
860 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
861 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
862 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
863 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
864 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
865 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
866 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
867 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
868 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
869 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 },
870 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
871 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
872 { STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG), nvrc_resultarg }, WINED3D_GL_EXT_NONE },
873 { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL), apply_pixelshader }, WINED3D_GL_EXT_NONE },
874 { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL), NULL }, WINED3D_GL_EXT_NONE },
875 { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), nvrc_texfactor }, WINED3D_GL_EXT_NONE },
876 { STATE_RENDER(WINED3D_RS_ALPHAFUNC), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
877 { STATE_RENDER(WINED3D_RS_ALPHAREF), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
878 { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), state_alpha_test }, WINED3D_GL_EXT_NONE },
879 { STATE_RENDER(WINED3D_RS_COLORKEYENABLE), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
880 { STATE_COLOR_KEY, { STATE_COLOR_KEY, state_nop }, WINED3D_GL_EXT_NONE },
881 { STATE_RENDER(WINED3D_RS_FOGCOLOR), { STATE_RENDER(WINED3D_RS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
882 { STATE_RENDER(WINED3D_RS_FOGDENSITY), { STATE_RENDER(WINED3D_RS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
883 { STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
884 { STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
885 { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
886 { STATE_RENDER(WINED3D_RS_FOGSTART), { STATE_RENDER(WINED3D_RS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
887 { STATE_RENDER(WINED3D_RS_FOGEND), { STATE_RENDER(WINED3D_RS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
888 { STATE_RENDER(WINED3D_RS_SHADEMODE), { STATE_RENDER(WINED3D_RS_SHADEMODE), state_shademode }, WINED3D_GL_EXT_NONE },
889 { STATE_SAMPLER(0), { STATE_SAMPLER(0), nvts_texdim }, NV_TEXTURE_SHADER2 },
890 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE },
891 { STATE_SAMPLER(1), { STATE_SAMPLER(1), nvts_texdim }, NV_TEXTURE_SHADER2 },
892 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, WINED3D_GL_EXT_NONE },
893 { STATE_SAMPLER(2), { STATE_SAMPLER(2), nvts_texdim }, NV_TEXTURE_SHADER2 },
894 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, WINED3D_GL_EXT_NONE },
895 { STATE_SAMPLER(3), { STATE_SAMPLER(3), nvts_texdim }, NV_TEXTURE_SHADER2 },
896 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim }, WINED3D_GL_EXT_NONE },
897 { STATE_SAMPLER(4), { STATE_SAMPLER(4), nvts_texdim }, NV_TEXTURE_SHADER2 },
898 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim }, WINED3D_GL_EXT_NONE },
899 { STATE_SAMPLER(5), { STATE_SAMPLER(5), nvts_texdim }, NV_TEXTURE_SHADER2 },
900 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim }, WINED3D_GL_EXT_NONE },
901 { STATE_SAMPLER(6), { STATE_SAMPLER(6), nvts_texdim }, NV_TEXTURE_SHADER2 },
902 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim }, WINED3D_GL_EXT_NONE },
903 { STATE_SAMPLER(7), { STATE_SAMPLER(7), nvts_texdim }, NV_TEXTURE_SHADER2 },
904 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim }, WINED3D_GL_EXT_NONE },
905 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
906 };
907
nvrc_context_alloc(struct wined3d_context * context)908 static BOOL nvrc_context_alloc(struct wined3d_context *context)
909 {
910 return TRUE;
911 }
912
nvrc_context_free(struct wined3d_context * context)913 static void nvrc_context_free(struct wined3d_context *context)
914 {
915 }
916
917
918 const struct fragment_pipeline nvts_fragment_pipeline = {
919 nvts_enable,
920 nvrc_fragment_get_caps,
921 nvrc_fragment_get_emul_mask,
922 nvrc_fragment_alloc,
923 nvrc_fragment_free,
924 nvrc_context_alloc,
925 nvrc_context_free,
926 nvts_color_fixup_supported,
927 nvrc_fragmentstate_template,
928 };
929
930 const struct fragment_pipeline nvrc_fragment_pipeline = {
931 nvrc_enable,
932 nvrc_fragment_get_caps,
933 nvrc_fragment_get_emul_mask,
934 nvrc_fragment_alloc,
935 nvrc_fragment_free,
936 nvrc_context_alloc,
937 nvrc_context_free,
938 nvts_color_fixup_supported,
939 nvrc_fragmentstate_template,
940 };
941