projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* Sync to recent trunk (r52563).
[reactos.git] / dll / directx / wine / 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]->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 and GL locking are done by the caller. */
627 static void nvts_enable(BOOL enable)
628 {
629 if(enable) {
630 glEnable(GL_TEXTURE_SHADER_NV);
631 checkGLcall("glEnable(GL_TEXTURE_SHADER_NV)");
632 } else {
633 glDisable(GL_TEXTURE_SHADER_NV);
634 checkGLcall("glDisable(GL_TEXTURE_SHADER_NV)");
635 }
636 }
637
638 static void nvrc_fragment_get_caps(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps)
639 {
640 caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_TSSARGTEMP;
641
642 /* The caps below can be supported but aren't handled yet in utils.c
643 * 'd3dta_to_combiner_input', disable them until support is fixed */
644 #if 0
645 if (gl_info->supported[NV_REGISTER_COMBINERS2])
646 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_PERSTAGECONSTANT;
647 #endif
648
649 caps->TextureOpCaps = WINED3DTEXOPCAPS_ADD
650 | WINED3DTEXOPCAPS_ADDSIGNED
651 | WINED3DTEXOPCAPS_ADDSIGNED2X
652 | WINED3DTEXOPCAPS_MODULATE
653 | WINED3DTEXOPCAPS_MODULATE2X
654 | WINED3DTEXOPCAPS_MODULATE4X
655 | WINED3DTEXOPCAPS_SELECTARG1
656 | WINED3DTEXOPCAPS_SELECTARG2
657 | WINED3DTEXOPCAPS_DISABLE
658 | WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
659 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
660 | WINED3DTEXOPCAPS_BLENDFACTORALPHA
661 | WINED3DTEXOPCAPS_BLENDCURRENTALPHA
662 | WINED3DTEXOPCAPS_LERP
663 | WINED3DTEXOPCAPS_SUBTRACT
664 | WINED3DTEXOPCAPS_ADDSMOOTH
665 | WINED3DTEXOPCAPS_MULTIPLYADD
666 | WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
667 | WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
668 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
669 | WINED3DTEXOPCAPS_DOTPRODUCT3
670 | WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
671 | WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA;
672
673 if (gl_info->supported[NV_TEXTURE_SHADER2])
674 {
675 /* Bump mapping is supported already in NV_TEXTURE_SHADER, but that extension does
676 * not support 3D textures. This asks for trouble if an app uses both bump mapping
677 * and 3D textures. It also allows us to keep the code simpler by having texture
678 * shaders constantly enabled. */
679 caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
680 /* TODO: Luminance bump map? */
681 }
682
683 #if 0
684 /* FIXME: Add
685 caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
686 WINED3DTEXOPCAPS_PREMODULATE */
687 #endif
688
689 caps->MaxTextureBlendStages = min(MAX_TEXTURES, gl_info->limits.general_combiners);
690 caps->MaxSimultaneousTextures = gl_info->limits.textures;
691 }
692
693 static HRESULT nvrc_fragment_alloc(struct wined3d_device *device) { return WINED3D_OK; }
694 /* Context activation is done by the caller. */
695 static void nvrc_fragment_free(struct wined3d_device *device) {}
696
697 /* Two fixed function pipeline implementations using GL_NV_register_combiners and
698 * GL_NV_texture_shader. The nvts_fragment_pipeline assumes that both extensions
699 * are available(geforce 3 and newer), while nvrc_fragment_pipeline uses only the
700 * register combiners extension(Pre-GF3).
701 */
702
703 static BOOL nvts_color_fixup_supported(struct color_fixup_desc fixup)
704 {
705 if (TRACE_ON(d3d))
706 {
707 TRACE("Checking support for fixup:\n");
708 dump_color_fixup_desc(fixup);
709 }
710
711 /* We only support identity conversions. */
712 if (is_identity_fixup(fixup))
713 {
714 TRACE("[OK]\n");
715 return TRUE;
716 }
717
718 TRACE("[FAILED]\n");
719 return FALSE;
720 }
721
722 static const struct StateEntryTemplate nvrc_fragmentstate_template[] = {
723 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
724 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
725 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
726 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
727 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
728 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
729 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
730 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
731 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
732 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
733 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
734 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
735 { STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
736 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
737 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
738 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
739 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
740 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
741 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
742 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
743 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
744 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
745 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
746 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
747 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
748 { STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
749 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
750 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
751 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
752 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
753 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
754 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
755 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
756 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
757 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
758 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
759 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
760 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
761 { STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
762 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
763 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
764 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
765 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
766 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
767 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
768 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
769 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
770 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
771 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
772 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
773 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
774 { STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
775 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
776 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
777 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
778 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
779 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
780 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
781 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
782 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
783 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
784 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
785 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
786 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
787 { STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
788 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
789 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
790 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
791 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
792 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
793 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
794 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
795 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
796 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
797 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
798 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
799 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
800 { STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
801 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
802 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
803 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
804 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
805 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
806 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
807 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
808 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
809 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
810 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
811 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
812 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
813 { STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
814 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
815 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
816 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
817 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
818 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
819 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
820 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
821 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
822 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
823 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
824 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
825 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
826 { STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
827 { STATE_PIXELSHADER, { STATE_PIXELSHADER, apply_pixelshader }, WINED3D_GL_EXT_NONE },
828 { STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
829 { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), nvrc_texfactor }, WINED3D_GL_EXT_NONE },
830 { STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
831 { STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
832 { STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
833 { STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
834 { STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
835 { STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
836 { STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
837 { STATE_SAMPLER(0), { STATE_SAMPLER(0), nvts_texdim }, NV_TEXTURE_SHADER2 },
838 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE },
839 { STATE_SAMPLER(1), { STATE_SAMPLER(1), nvts_texdim }, NV_TEXTURE_SHADER2 },
840 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, WINED3D_GL_EXT_NONE },
841 { STATE_SAMPLER(2), { STATE_SAMPLER(2), nvts_texdim }, NV_TEXTURE_SHADER2 },
842 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, WINED3D_GL_EXT_NONE },
843 { STATE_SAMPLER(3), { STATE_SAMPLER(3), nvts_texdim }, NV_TEXTURE_SHADER2 },
844 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim }, WINED3D_GL_EXT_NONE },
845 { STATE_SAMPLER(4), { STATE_SAMPLER(4), nvts_texdim }, NV_TEXTURE_SHADER2 },
846 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim }, WINED3D_GL_EXT_NONE },
847 { STATE_SAMPLER(5), { STATE_SAMPLER(5), nvts_texdim }, NV_TEXTURE_SHADER2 },
848 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim }, WINED3D_GL_EXT_NONE },
849 { STATE_SAMPLER(6), { STATE_SAMPLER(6), nvts_texdim }, NV_TEXTURE_SHADER2 },
850 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim }, WINED3D_GL_EXT_NONE },
851 { STATE_SAMPLER(7), { STATE_SAMPLER(7), nvts_texdim }, NV_TEXTURE_SHADER2 },
852 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim }, WINED3D_GL_EXT_NONE },
853 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
854 };
855
856 const struct fragment_pipeline nvts_fragment_pipeline = {
857 nvts_enable,
858 nvrc_fragment_get_caps,
859 nvrc_fragment_alloc,
860 nvrc_fragment_free,
861 nvts_color_fixup_supported,
862 nvrc_fragmentstate_template,
863 FALSE /* we cannot disable projected textures. The vertex pipe has to do it */
864 };
865
866 const struct fragment_pipeline nvrc_fragment_pipeline = {
867 nvrc_enable,
868 nvrc_fragment_get_caps,
869 nvrc_fragment_alloc,
870 nvrc_fragment_free,
871 nvts_color_fixup_supported,
872 nvrc_fragmentstate_template,
873 FALSE /* we cannot disable projected textures. The vertex pipe has to do it */
874 };
A free Windows-compatible Operating System