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