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