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