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