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