ReactOS Development > Doxygen
nvidia_texture_shader.c
Go to the documentation of this file.
00001 /* 00002 * Fixed function pipeline replacement using GL_NV_register_combiners 00003 * and GL_NV_texture_shader 00004 * 00005 * Copyright 2006 Henri Verbeet 00006 * Copyright 2008 Stefan Dösinger(for CodeWeavers) 00007 * 00008 * This library is free software; you can redistribute it and/or 00009 * modify it under the terms of the GNU Lesser General Public 00010 * License as published by the Free Software Foundation; either 00011 * version 2.1 of the License, or (at your option) any later version. 00012 * 00013 * This library is distributed in the hope that it will be useful, 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00016 * Lesser General Public License for more details. 00017 * 00018 * You should have received a copy of the GNU Lesser General Public 00019 * License along with this library; if not, write to the Free Software 00020 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 00021 */ 00022 #include "config.h" 00023 00024 #include <math.h> 00025 #include <stdio.h> 00026 00027 #include "wined3d_private.h" 00028 00029 WINE_DEFAULT_DEBUG_CHANNEL(d3d); 00030 00031 /* GL locking for state handlers is done by the caller. */ 00032 00033 static void nvts_activate_dimensions(const struct wined3d_state *state, DWORD stage, struct wined3d_context *context) 00034 { 00035 BOOL bumpmap = FALSE; 00036 00037 if (stage > 0 00038 && (state->texture_states[stage - 1][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP_LUMINANCE 00039 || state->texture_states[stage - 1][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP)) 00040 { 00041 bumpmap = TRUE; 00042 context->texShaderBumpMap |= (1 << stage); 00043 } else { 00044 context->texShaderBumpMap &= ~(1 << stage); 00045 } 00046 00047 if (state->textures[stage]) 00048 { 00049 switch (state->textures[stage]->target) 00050 { 00051 case GL_TEXTURE_2D: 00052 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_2D); 00053 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)"); 00054 break; 00055 case GL_TEXTURE_RECTANGLE_ARB: 00056 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_RECTANGLE_ARB); 00057 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)"); 00058 break; 00059 case GL_TEXTURE_3D: 00060 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D); 00061 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D)"); 00062 break; 00063 case GL_TEXTURE_CUBE_MAP_ARB: 00064 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB); 00065 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB)"); 00066 break; 00067 } 00068 } else { 00069 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE); 00070 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE)"); 00071 } 00072 } 00073 00074 struct tex_op_args 00075 { 00076 GLenum input[3]; 00077 GLenum mapping[3]; 00078 GLenum component_usage[3]; 00079 }; 00080 00081 static GLenum d3dta_to_combiner_input(DWORD d3dta, DWORD stage, INT texture_idx) { 00082 switch (d3dta) { 00083 case WINED3DTA_DIFFUSE: 00084 return GL_PRIMARY_COLOR_NV; 00085 00086 case WINED3DTA_CURRENT: 00087 if (stage) return GL_SPARE0_NV; 00088 else return GL_PRIMARY_COLOR_NV; 00089 00090 case WINED3DTA_TEXTURE: 00091 if (texture_idx > -1) return GL_TEXTURE0_ARB + texture_idx; 00092 else return GL_PRIMARY_COLOR_NV; 00093 00094 case WINED3DTA_TFACTOR: 00095 return GL_CONSTANT_COLOR0_NV; 00096 00097 case WINED3DTA_SPECULAR: 00098 return GL_SECONDARY_COLOR_NV; 00099 00100 case WINED3DTA_TEMP: 00101 return GL_SPARE1_NV; 00102 00103 case WINED3DTA_CONSTANT: 00104 /* TODO: Support per stage constants (WINED3D_TSS_CONSTANT, NV_register_combiners2) */ 00105 FIXME("WINED3DTA_CONSTANT, not properly supported.\n"); 00106 return GL_CONSTANT_COLOR1_NV; 00107 00108 default: 00109 FIXME("Unrecognized texture arg %#x\n", d3dta); 00110 return GL_TEXTURE; 00111 } 00112 } 00113 00114 static GLenum invert_mapping(GLenum mapping) { 00115 if (mapping == GL_UNSIGNED_INVERT_NV) return GL_UNSIGNED_IDENTITY_NV; 00116 else if (mapping == GL_UNSIGNED_IDENTITY_NV) return GL_UNSIGNED_INVERT_NV; 00117 00118 FIXME("Unhandled mapping %#x\n", mapping); 00119 return mapping; 00120 } 00121 00122 static void get_src_and_opr_nvrc(DWORD stage, DWORD arg, BOOL is_alpha, GLenum* input, GLenum* mapping, GLenum *component_usage, INT texture_idx) { 00123 /* The WINED3DTA_COMPLEMENT flag specifies the complement of the input should 00124 * be used. */ 00125 if (arg & WINED3DTA_COMPLEMENT) *mapping = GL_UNSIGNED_INVERT_NV; 00126 else *mapping = GL_UNSIGNED_IDENTITY_NV; /* Clamp all values to positive ranges */ 00127 00128 /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the input 00129 * should be used for all input components. */ 00130 if (is_alpha || arg & WINED3DTA_ALPHAREPLICATE) *component_usage = GL_ALPHA; 00131 else *component_usage = GL_RGB; 00132 00133 *input = d3dta_to_combiner_input(arg & WINED3DTA_SELECTMASK, stage, texture_idx); 00134 } 00135 00136 void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state, BOOL is_alpha, 00137 int stage, enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx, DWORD dst) 00138 { 00139 struct tex_op_args tex_op_args = {{0}, {0}, {0}}; 00140 GLenum portion = is_alpha ? GL_ALPHA : GL_RGB; 00141 GLenum target = GL_COMBINER0_NV + stage; 00142 GLenum output; 00143 00144 TRACE("stage %d, is_alpha %d, op %s, arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n", 00145 stage, is_alpha, debug_d3dtop(op), arg1, arg2, arg3, texture_idx); 00146 00147 /* If a texture stage references an invalid texture unit the stage just 00148 * passes through the result from the previous stage */ 00149 if (is_invalid_op(state, stage, op, arg1, arg2, arg3)) 00150 { 00151 arg1 = WINED3DTA_CURRENT; 00152 op = WINED3D_TOP_SELECT_ARG1; 00153 } 00154 00155 get_src_and_opr_nvrc(stage, arg1, is_alpha, &tex_op_args.input[0], 00156 &tex_op_args.mapping[0], &tex_op_args.component_usage[0], texture_idx); 00157 get_src_and_opr_nvrc(stage, arg2, is_alpha, &tex_op_args.input[1], 00158 &tex_op_args.mapping[1], &tex_op_args.component_usage[1], texture_idx); 00159 get_src_and_opr_nvrc(stage, arg3, is_alpha, &tex_op_args.input[2], 00160 &tex_op_args.mapping[2], &tex_op_args.component_usage[2], texture_idx); 00161 00162 00163 if(dst == WINED3DTA_TEMP) { 00164 output = GL_SPARE1_NV; 00165 } else { 00166 output = GL_SPARE0_NV; 00167 } 00168 00169 /* This is called by a state handler which has the gl lock held and a context for the thread */ 00170 switch (op) 00171 { 00172 case WINED3D_TOP_DISABLE: 00173 /* Only for alpha */ 00174 if (!is_alpha) 00175 ERR("Shouldn't be called for WINED3D_TSS_COLOR_OP (WINED3DTOP_DISABLE).\n"); 00176 /* Input, prev_alpha*1 */ 00177 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00178 GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA)); 00179 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00180 GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA)); 00181 00182 /* Output */ 00183 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV, 00184 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00185 break; 00186 00187 case WINED3D_TOP_SELECT_ARG1: 00188 case WINED3D_TOP_SELECT_ARG2: 00189 /* Input, arg*1 */ 00190 if (op == WINED3D_TOP_SELECT_ARG1) 00191 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00192 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00193 else 00194 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00195 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00196 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00197 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00198 00199 /* Output */ 00200 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV, 00201 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00202 break; 00203 00204 case WINED3D_TOP_MODULATE: 00205 case WINED3D_TOP_MODULATE_2X: 00206 case WINED3D_TOP_MODULATE_4X: 00207 /* Input, arg1*arg2 */ 00208 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00209 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00210 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00211 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00212 00213 /* Output */ 00214 if (op == WINED3D_TOP_MODULATE) 00215 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV, 00216 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00217 else if (op == WINED3D_TOP_MODULATE_2X) 00218 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV, 00219 GL_DISCARD_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00220 else if (op == WINED3D_TOP_MODULATE_4X) 00221 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV, 00222 GL_DISCARD_NV, GL_SCALE_BY_FOUR_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00223 break; 00224 00225 case WINED3D_TOP_ADD: 00226 case WINED3D_TOP_ADD_SIGNED: 00227 case WINED3D_TOP_ADD_SIGNED_2X: 00228 /* Input, arg1*1+arg2*1 */ 00229 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00230 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00231 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00232 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00233 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00234 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00235 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00236 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00237 00238 /* Output */ 00239 if (op == WINED3D_TOP_ADD) 00240 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00241 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00242 else if (op == WINED3D_TOP_ADD_SIGNED) 00243 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00244 output, GL_NONE, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE)); 00245 else if (op == WINED3D_TOP_ADD_SIGNED_2X) 00246 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00247 output, GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE)); 00248 break; 00249 00250 case WINED3D_TOP_SUBTRACT: 00251 /* Input, arg1*1+-arg2*1 */ 00252 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00253 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00254 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00255 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00256 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00257 tex_op_args.input[1], GL_SIGNED_NEGATE_NV, tex_op_args.component_usage[1])); 00258 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00259 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00260 00261 /* Output */ 00262 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00263 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00264 break; 00265 00266 case WINED3D_TOP_ADD_SMOOTH: 00267 /* Input, arg1*1+(1-arg1)*arg2 */ 00268 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00269 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00270 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00271 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00272 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00273 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0])); 00274 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00275 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00276 00277 /* Output */ 00278 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00279 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00280 break; 00281 00282 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA: 00283 case WINED3D_TOP_BLEND_TEXTURE_ALPHA: 00284 case WINED3D_TOP_BLEND_FACTOR_ALPHA: 00285 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM: 00286 case WINED3D_TOP_BLEND_CURRENT_ALPHA: 00287 { 00288 GLenum alpha_src = GL_PRIMARY_COLOR_NV; 00289 if (op == WINED3D_TOP_BLEND_DIFFUSE_ALPHA) 00290 alpha_src = d3dta_to_combiner_input(WINED3DTA_DIFFUSE, stage, texture_idx); 00291 else if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA) 00292 alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx); 00293 else if (op == WINED3D_TOP_BLEND_FACTOR_ALPHA) 00294 alpha_src = d3dta_to_combiner_input(WINED3DTA_TFACTOR, stage, texture_idx); 00295 else if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM) 00296 alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx); 00297 else if (op == WINED3D_TOP_BLEND_CURRENT_ALPHA) 00298 alpha_src = d3dta_to_combiner_input(WINED3DTA_CURRENT, stage, texture_idx); 00299 else 00300 FIXME("Unhandled texture op %s, shouldn't happen.\n", debug_d3dtop(op)); 00301 00302 /* Input, arg1*alpha_src+arg2*(1-alpha_src) */ 00303 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00304 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00305 if (op == WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM) 00306 { 00307 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00308 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00309 } else { 00310 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00311 alpha_src, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA)); 00312 } 00313 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00314 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00315 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00316 alpha_src, GL_UNSIGNED_INVERT_NV, GL_ALPHA)); 00317 00318 /* Output */ 00319 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00320 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00321 break; 00322 } 00323 00324 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR: 00325 /* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */ 00326 if (is_alpha) 00327 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEALPHA_ADDCOLOR).\n"); 00328 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00329 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA)); 00330 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00331 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00332 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00333 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00334 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00335 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00336 00337 /* Output */ 00338 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00339 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00340 break; 00341 00342 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA: 00343 /* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */ 00344 if (is_alpha) 00345 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATECOLOR_ADDALPHA).\n"); 00346 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00347 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00348 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00349 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00350 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00351 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA)); 00352 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00353 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00354 00355 /* Output */ 00356 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00357 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00358 break; 00359 00360 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR: 00361 /* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */ 00362 if (is_alpha) 00363 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR).\n"); 00364 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00365 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), GL_ALPHA)); 00366 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00367 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00368 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00369 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00370 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00371 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00372 00373 /* Output */ 00374 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00375 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00376 break; 00377 00378 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA: 00379 /* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */ 00380 if (is_alpha) 00381 ERR("Only supported for WINED3D_TSS_COLOR_OP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA).\n"); 00382 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00383 tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0])); 00384 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00385 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00386 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00387 tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA)); 00388 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00389 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00390 00391 /* Output */ 00392 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00393 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00394 break; 00395 00396 case WINED3D_TOP_DOTPRODUCT3: 00397 /* Input, arg1 . arg2 */ 00398 /* FIXME: DX7 uses a different calculation? */ 00399 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00400 tex_op_args.input[0], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[0])); 00401 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00402 tex_op_args.input[1], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[1])); 00403 00404 /* Output */ 00405 GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV, 00406 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE)); 00407 break; 00408 00409 case WINED3D_TOP_MULTIPLY_ADD: 00410 /* Input, arg3*1+arg1*arg2 */ 00411 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00412 tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2])); 00413 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00414 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00415 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00416 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00417 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00418 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00419 00420 /* Output */ 00421 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00422 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00423 break; 00424 00425 case WINED3D_TOP_LERP: 00426 /* Input, arg3*arg1+(1-arg3)*arg2 */ 00427 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00428 tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2])); 00429 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00430 tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0])); 00431 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV, 00432 tex_op_args.input[2], invert_mapping(tex_op_args.mapping[2]), tex_op_args.component_usage[2])); 00433 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV, 00434 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00435 00436 /* Output */ 00437 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV, 00438 output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00439 break; 00440 00441 case WINED3D_TOP_BUMPENVMAP_LUMINANCE: 00442 case WINED3D_TOP_BUMPENVMAP: 00443 if (gl_info->supported[NV_TEXTURE_SHADER]) 00444 { 00445 /* The bump map stage itself isn't exciting, just read the texture. But tell the next stage to 00446 * perform bump mapping and source from the current stage. Pretty much a SELECTARG2. 00447 * ARG2 is passed through unmodified(apps will most likely use D3DTA_CURRENT for arg2, arg1 00448 * (which will most likely be D3DTA_TEXTURE) is available as a texture shader input for the next stage 00449 */ 00450 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV, 00451 tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1])); 00452 GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV, 00453 GL_ZERO, GL_UNSIGNED_INVERT_NV, portion)); 00454 /* Always pass through to CURRENT, ignore temp arg */ 00455 GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV, 00456 GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE)); 00457 break; 00458 } 00459 00460 default: 00461 FIXME("Unhandled texture op: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d.\n", 00462 stage, is_alpha, debug_d3dtop(op), op, arg1, arg2, arg3, texture_idx); 00463 } 00464 00465 checkGLcall("set_tex_op_nvrc()"); 00466 } 00467 00468 00469 static void nvrc_colorop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) 00470 { 00471 DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); 00472 const struct wined3d_device *device = context->swapchain->device; 00473 BOOL tex_used = device->fixed_function_usage_map & (1 << stage); 00474 DWORD mapped_stage = device->texUnitMap[stage]; 00475 const struct wined3d_gl_info *gl_info = context->gl_info; 00476 00477 TRACE("Setting color op for stage %u.\n", stage); 00478 00479 /* Using a pixel shader? Don't care for anything here, the shader applying does it */ 00480 if (use_ps(state)) return; 00481 00482 if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage); 00483 00484 if (mapped_stage != WINED3D_UNMAPPED_STAGE) 00485 { 00486 if (tex_used && mapped_stage >= gl_info->limits.textures) 00487 { 00488 FIXME("Attempt to enable unsupported stage!\n"); 00489 return; 00490 } 00491 context_active_texture(context, gl_info, mapped_stage); 00492 } 00493 00494 if (state->lowest_disabled_stage > 0) 00495 { 00496 glEnable(GL_REGISTER_COMBINERS_NV); 00497 GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, state->lowest_disabled_stage)); 00498 } 00499 else 00500 { 00501 glDisable(GL_REGISTER_COMBINERS_NV); 00502 } 00503 if (stage >= state->lowest_disabled_stage) 00504 { 00505 TRACE("Stage disabled\n"); 00506 if (mapped_stage != WINED3D_UNMAPPED_STAGE) 00507 { 00508 /* Disable everything here */ 00509 glDisable(GL_TEXTURE_2D); 00510 checkGLcall("glDisable(GL_TEXTURE_2D)"); 00511 glDisable(GL_TEXTURE_3D); 00512 checkGLcall("glDisable(GL_TEXTURE_3D)"); 00513 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) 00514 { 00515 glDisable(GL_TEXTURE_CUBE_MAP_ARB); 00516 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)"); 00517 } 00518 if (gl_info->supported[ARB_TEXTURE_RECTANGLE]) 00519 { 00520 glDisable(GL_TEXTURE_RECTANGLE_ARB); 00521 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)"); 00522 } 00523 if (gl_info->supported[NV_TEXTURE_SHADER2] && mapped_stage < gl_info->limits.textures) 00524 { 00525 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE); 00526 } 00527 } 00528 /* All done */ 00529 return; 00530 } 00531 00532 /* The sampler will also activate the correct texture dimensions, so no need to do it here 00533 * if the sampler for this stage is dirty 00534 */ 00535 if (!isStateDirty(context, STATE_SAMPLER(stage))) 00536 { 00537 if (tex_used) 00538 { 00539 if (gl_info->supported[NV_TEXTURE_SHADER2]) 00540 { 00541 nvts_activate_dimensions(state, stage, context); 00542 } 00543 else 00544 { 00545 texture_activate_dimensions(state->textures[stage], gl_info); 00546 } 00547 } 00548 } 00549 00550 /* Set the texture combiners */ 00551 set_tex_op_nvrc(gl_info, state, FALSE, stage, 00552 state->texture_states[stage][WINED3D_TSS_COLOR_OP], 00553 state->texture_states[stage][WINED3D_TSS_COLOR_ARG1], 00554 state->texture_states[stage][WINED3D_TSS_COLOR_ARG2], 00555 state->texture_states[stage][WINED3D_TSS_COLOR_ARG0], 00556 mapped_stage, 00557 state->texture_states[stage][WINED3D_TSS_RESULT_ARG]); 00558 00559 /* In register combiners bump mapping is done in the stage AFTER the one that has the bump map operation set, 00560 * thus the texture shader may have to be updated 00561 */ 00562 if (gl_info->supported[NV_TEXTURE_SHADER2]) 00563 { 00564 BOOL usesBump = (state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP_LUMINANCE 00565 || state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP); 00566 BOOL usedBump = !!(context->texShaderBumpMap & 1 << (stage + 1)); 00567 if (usesBump != usedBump) 00568 { 00569 context_active_texture(context, gl_info, mapped_stage + 1); 00570 nvts_activate_dimensions(state, stage + 1, context); 00571 context_active_texture(context, gl_info, mapped_stage); 00572 } 00573 } 00574 } 00575 00576 static void nvts_texdim(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) 00577 { 00578 DWORD sampler = state_id - STATE_SAMPLER(0); 00579 DWORD mapped_stage = context->swapchain->device->texUnitMap[sampler]; 00580 00581 /* No need to enable / disable anything here for unused samplers. The tex_colorop 00582 * handler takes care. Also no action is needed with pixel shaders, or if tex_colorop 00583 * will take care of this business. */ 00584 if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures) 00585 return; 00586 if (sampler >= state->lowest_disabled_stage) 00587 return; 00588 if (isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3D_TSS_COLOR_OP))) 00589 return; 00590 00591 nvts_activate_dimensions(state, sampler, context); 00592 } 00593 00594 static void nvts_bumpenvmat(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) 00595 { 00596 DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1); 00597 DWORD mapped_stage = context->swapchain->device->texUnitMap[stage + 1]; 00598 const struct wined3d_gl_info *gl_info = context->gl_info; 00599 float mat[2][2]; 00600 00601 /* Direct3D sets the matrix in the stage reading the perturbation map. The result is used to 00602 * offset the destination stage(always stage + 1 in d3d). In GL_NV_texture_shader, the bump 00603 * map offsetting is done in the stage reading the bump mapped texture, and the perturbation 00604 * map is read from a specified source stage(always stage - 1 for d3d). Thus set the matrix 00605 * for stage + 1. Keep the nvrc tex unit mapping in mind too 00606 */ 00607 if (mapped_stage < gl_info->limits.textures) 00608 { 00609 context_active_texture(context, gl_info, mapped_stage); 00610 00611 /* We can't just pass a pointer to the state to GL due to the 00612 * different matrix format (column major vs row major). */ 00613 mat[0][0] = *((float *)&state->texture_states[stage][WINED3D_TSS_BUMPENV_MAT00]); 00614 mat[1][0] = *((float *)&state->texture_states[stage][WINED3D_TSS_BUMPENV_MAT01]); 00615 mat[0][1] = *((float *)&state->texture_states[stage][WINED3D_TSS_BUMPENV_MAT10]); 00616 mat[1][1] = *((float *)&state->texture_states[stage][WINED3D_TSS_BUMPENV_MAT11]); 00617 glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, (float *)mat); 00618 checkGLcall("glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, mat)"); 00619 } 00620 } 00621 00622 static void nvrc_texfactor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) 00623 { 00624 const struct wined3d_gl_info *gl_info = context->gl_info; 00625 float col[4]; 00626 00627 D3DCOLORTOGLFLOAT4(state->render_states[WINED3D_RS_TEXTUREFACTOR], col); 00628 GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0])); 00629 } 00630 00631 /* Context activation is done by the caller. */ 00632 static void nvrc_enable(BOOL enable) {} 00633 00634 /* Context activation and GL locking are done by the caller. */ 00635 static void nvts_enable(BOOL enable) 00636 { 00637 if(enable) { 00638 glEnable(GL_TEXTURE_SHADER_NV); 00639 checkGLcall("glEnable(GL_TEXTURE_SHADER_NV)"); 00640 } else { 00641 glDisable(GL_TEXTURE_SHADER_NV); 00642 checkGLcall("glDisable(GL_TEXTURE_SHADER_NV)"); 00643 } 00644 } 00645 00646 static void nvrc_fragment_get_caps(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps) 00647 { 00648 caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_TSSARGTEMP; 00649 00650 /* The caps below can be supported but aren't handled yet in utils.c 00651 * 'd3dta_to_combiner_input', disable them until support is fixed */ 00652 #if 0 00653 if (gl_info->supported[NV_REGISTER_COMBINERS2]) 00654 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_PERSTAGECONSTANT; 00655 #endif 00656 00657 caps->TextureOpCaps = WINED3DTEXOPCAPS_ADD 00658 | WINED3DTEXOPCAPS_ADDSIGNED 00659 | WINED3DTEXOPCAPS_ADDSIGNED2X 00660 | WINED3DTEXOPCAPS_MODULATE 00661 | WINED3DTEXOPCAPS_MODULATE2X 00662 | WINED3DTEXOPCAPS_MODULATE4X 00663 | WINED3DTEXOPCAPS_SELECTARG1 00664 | WINED3DTEXOPCAPS_SELECTARG2 00665 | WINED3DTEXOPCAPS_DISABLE 00666 | WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA 00667 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHA 00668 | WINED3DTEXOPCAPS_BLENDFACTORALPHA 00669 | WINED3DTEXOPCAPS_BLENDCURRENTALPHA 00670 | WINED3DTEXOPCAPS_LERP 00671 | WINED3DTEXOPCAPS_SUBTRACT 00672 | WINED3DTEXOPCAPS_ADDSMOOTH 00673 | WINED3DTEXOPCAPS_MULTIPLYADD 00674 | WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR 00675 | WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA 00676 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM 00677 | WINED3DTEXOPCAPS_DOTPRODUCT3 00678 | WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR 00679 | WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA; 00680 00681 if (gl_info->supported[NV_TEXTURE_SHADER2]) 00682 { 00683 /* Bump mapping is supported already in NV_TEXTURE_SHADER, but that extension does 00684 * not support 3D textures. This asks for trouble if an app uses both bump mapping 00685 * and 3D textures. It also allows us to keep the code simpler by having texture 00686 * shaders constantly enabled. */ 00687 caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP; 00688 /* TODO: Luminance bump map? */ 00689 } 00690 00691 #if 0 00692 /* FIXME: Add 00693 caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE 00694 WINED3DTEXOPCAPS_PREMODULATE */ 00695 #endif 00696 00697 caps->MaxTextureBlendStages = min(MAX_TEXTURES, gl_info->limits.general_combiners); 00698 caps->MaxSimultaneousTextures = gl_info->limits.textures; 00699 } 00700 00701 static HRESULT nvrc_fragment_alloc(struct wined3d_device *device) { return WINED3D_OK; } 00702 /* Context activation is done by the caller. */ 00703 static void nvrc_fragment_free(struct wined3d_device *device) {} 00704 00705 /* Two fixed function pipeline implementations using GL_NV_register_combiners and 00706 * GL_NV_texture_shader. The nvts_fragment_pipeline assumes that both extensions 00707 * are available(geforce 3 and newer), while nvrc_fragment_pipeline uses only the 00708 * register combiners extension(Pre-GF3). 00709 */ 00710 00711 static BOOL nvts_color_fixup_supported(struct color_fixup_desc fixup) 00712 { 00713 if (TRACE_ON(d3d)) 00714 { 00715 TRACE("Checking support for fixup:\n"); 00716 dump_color_fixup_desc(fixup); 00717 } 00718 00719 /* We only support identity conversions. */ 00720 if (is_identity_fixup(fixup)) 00721 { 00722 TRACE("[OK]\n"); 00723 return TRUE; 00724 } 00725 00726 TRACE("[FAILED]\n"); 00727 return FALSE; 00728 } 00729 00730 static const struct StateEntryTemplate nvrc_fragmentstate_template[] = 00731 { 00732 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE }, 00733 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00734 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00735 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE }, 00736 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00737 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00738 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 }, 00739 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00740 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00741 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00742 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00743 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00744 { STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00745 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE }, 00746 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00747 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00748 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE }, 00749 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00750 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00751 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 }, 00752 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00753 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00754 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00755 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00756 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00757 { STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00758 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE }, 00759 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00760 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00761 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE }, 00762 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00763 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00764 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 }, 00765 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00766 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00767 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00768 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00769 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00770 { STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00771 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE }, 00772 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00773 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00774 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE }, 00775 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00776 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00777 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 }, 00778 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00779 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00780 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00781 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00782 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00783 { STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00784 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE }, 00785 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00786 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00787 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE }, 00788 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00789 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00790 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 }, 00791 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00792 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00793 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00794 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00795 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00796 { STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00797 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE }, 00798 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00799 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00800 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE }, 00801 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00802 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00803 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 }, 00804 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00805 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00806 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00807 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00808 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00809 { STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00810 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE }, 00811 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00812 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00813 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE }, 00814 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00815 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00816 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 }, 00817 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00818 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00819 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00820 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00821 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00822 { STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00823 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), nvrc_colorop }, WINED3D_GL_EXT_NONE }, 00824 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00825 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00826 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE }, 00827 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00828 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00829 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 }, 00830 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00831 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00832 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, NV_TEXTURE_SHADER2 }, 00833 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00834 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE }, 00835 { STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE }, 00836 { STATE_PIXELSHADER, { STATE_PIXELSHADER, apply_pixelshader }, WINED3D_GL_EXT_NONE }, 00837 { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE }, 00838 { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), nvrc_texfactor }, WINED3D_GL_EXT_NONE }, 00839 { STATE_RENDER(WINED3D_RS_FOGCOLOR), { STATE_RENDER(WINED3D_RS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE }, 00840 { STATE_RENDER(WINED3D_RS_FOGDENSITY), { STATE_RENDER(WINED3D_RS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE }, 00841 { STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE }, 00842 { STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE }, 00843 { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE }, 00844 { STATE_RENDER(WINED3D_RS_FOGSTART), { STATE_RENDER(WINED3D_RS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE }, 00845 { STATE_RENDER(WINED3D_RS_FOGEND), { STATE_RENDER(WINED3D_RS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE }, 00846 { STATE_SAMPLER(0), { STATE_SAMPLER(0), nvts_texdim }, NV_TEXTURE_SHADER2 }, 00847 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE }, 00848 { STATE_SAMPLER(1), { STATE_SAMPLER(1), nvts_texdim }, NV_TEXTURE_SHADER2 }, 00849 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, WINED3D_GL_EXT_NONE }, 00850 { STATE_SAMPLER(2), { STATE_SAMPLER(2), nvts_texdim }, NV_TEXTURE_SHADER2 }, 00851 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, WINED3D_GL_EXT_NONE }, 00852 { STATE_SAMPLER(3), { STATE_SAMPLER(3), nvts_texdim }, NV_TEXTURE_SHADER2 }, 00853 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim }, WINED3D_GL_EXT_NONE }, 00854 { STATE_SAMPLER(4), { STATE_SAMPLER(4), nvts_texdim }, NV_TEXTURE_SHADER2 }, 00855 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim }, WINED3D_GL_EXT_NONE }, 00856 { STATE_SAMPLER(5), { STATE_SAMPLER(5), nvts_texdim }, NV_TEXTURE_SHADER2 }, 00857 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim }, WINED3D_GL_EXT_NONE }, 00858 { STATE_SAMPLER(6), { STATE_SAMPLER(6), nvts_texdim }, NV_TEXTURE_SHADER2 }, 00859 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim }, WINED3D_GL_EXT_NONE }, 00860 { STATE_SAMPLER(7), { STATE_SAMPLER(7), nvts_texdim }, NV_TEXTURE_SHADER2 }, 00861 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim }, WINED3D_GL_EXT_NONE }, 00862 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE }, 00863 }; 00864 00865 const struct fragment_pipeline nvts_fragment_pipeline = { 00866 nvts_enable, 00867 nvrc_fragment_get_caps, 00868 nvrc_fragment_alloc, 00869 nvrc_fragment_free, 00870 nvts_color_fixup_supported, 00871 nvrc_fragmentstate_template, 00872 FALSE /* we cannot disable projected textures. The vertex pipe has to do it */ 00873 }; 00874 00875 const struct fragment_pipeline nvrc_fragment_pipeline = { 00876 nvrc_enable, 00877 nvrc_fragment_get_caps, 00878 nvrc_fragment_alloc, 00879 nvrc_fragment_free, 00880 nvts_color_fixup_supported, 00881 nvrc_fragmentstate_template, 00882 FALSE /* we cannot disable projected textures. The vertex pipe has to do it */ 00883 };
Generated on Sun May 27 2012 04:22:19 for ReactOS by
1.7.6.1
