ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/wined3d/nvidia_texture_shader.c

875 lines
56 KiB
C
Raw Normal View History

wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
/*
* Fixed function pipeline replacement using GL_NV_register_combiners
* and GL_NV_texture_shader
*
* Copyright 2006 Henri Verbeet
wined3d: Convert source files to utf-8.
2008-10-18 19:21:20 +02:00
* Copyright 2008 Stefan Dösinger(for CodeWeavers)
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include <math.h>
#include <stdio.h>
#include "wined3d_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
wined3d: Document functions that depend on the caller to do GL locking.
2009-05-14 19:40:56 +02:00
/* GL locking for state handlers is done by the caller. */
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
static void nvts_activate_dimensions(const struct wined3d_state *state, DWORD stage, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Separate texture_activate_dimensions. This creates an nvts version of this function, and removes the nvts code from the original one. The nvts version is used by the nvts pipeline implementation, the original one by the nvrc-only, atifs and ffp one.
2008-07-05 00:25:23 +02:00
BOOL bumpmap = FALSE;
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
if (stage > 0 && (state->texture_states[stage - 1][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAPLUMINANCE
|| state->texture_states[stage - 1][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAP))
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
{
wined3d: Separate texture_activate_dimensions. This creates an nvts version of this function, and removes the nvts code from the original one. The nvts version is used by the nvts pipeline implementation, the original one by the nvrc-only, atifs and ffp one.
2008-07-05 00:25:23 +02:00
bumpmap = TRUE;
context->texShaderBumpMap |= (1 << stage);
} else {
context->texShaderBumpMap &= ~(1 << stage);
}
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
if (state->textures[stage])
wined3d: Remove IWineD3DBaseTexture::GetTextureDimensions() from the public wined3d interface.
2010-09-17 11:59:39 +02:00
{
wined3d: Get rid of IWineD3DBaseTextureClass.
2011-03-28 21:58:42 +02:00
switch (state->textures[stage]->target)
wined3d: Remove IWineD3DBaseTexture::GetTextureDimensions() from the public wined3d interface.
2010-09-17 11:59:39 +02:00
{
wined3d: Separate texture_activate_dimensions. This creates an nvts version of this function, and removes the nvts code from the original one. The nvts version is used by the nvts pipeline implementation, the original one by the nvrc-only, atifs and ffp one.
2008-07-05 00:25:23 +02:00
case GL_TEXTURE_2D:
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_2D);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)");
break;
case GL_TEXTURE_RECTANGLE_ARB:
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, ...)");
break;
case GL_TEXTURE_3D:
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D)");
break;
case GL_TEXTURE_CUBE_MAP_ARB:
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB)");
break;
}
} else {
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE)");
}
}
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
typedef struct {
GLenum input[3];
GLenum mapping[3];
GLenum component_usage[3];
} tex_op_args;
static GLenum d3dta_to_combiner_input(DWORD d3dta, DWORD stage, INT texture_idx) {
switch (d3dta) {
case WINED3DTA_DIFFUSE:
return GL_PRIMARY_COLOR_NV;
case WINED3DTA_CURRENT:
if (stage) return GL_SPARE0_NV;
else return GL_PRIMARY_COLOR_NV;
case WINED3DTA_TEXTURE:
if (texture_idx > -1) return GL_TEXTURE0_ARB + texture_idx;
else return GL_PRIMARY_COLOR_NV;
case WINED3DTA_TFACTOR:
return GL_CONSTANT_COLOR0_NV;
case WINED3DTA_SPECULAR:
return GL_SECONDARY_COLOR_NV;
case WINED3DTA_TEMP:
return GL_SPARE1_NV;
case WINED3DTA_CONSTANT:
/* TODO: Support per stage constants (WINED3DTSS_CONSTANT, NV_register_combiners2) */
FIXME("WINED3DTA_CONSTANT, not properly supported.\n");
return GL_CONSTANT_COLOR1_NV;
default:
FIXME("Unrecognized texture arg %#x\n", d3dta);
return GL_TEXTURE;
}
}
static GLenum invert_mapping(GLenum mapping) {
d3d9: Test for fixed function value clamping.
2008-08-14 23:29:47 +02:00
if (mapping == GL_UNSIGNED_INVERT_NV) return GL_UNSIGNED_IDENTITY_NV;
else if (mapping == GL_UNSIGNED_IDENTITY_NV) return GL_UNSIGNED_INVERT_NV;
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
FIXME("Unhandled mapping %#x\n", mapping);
return mapping;
}
static void get_src_and_opr_nvrc(DWORD stage, DWORD arg, BOOL is_alpha, GLenum* input, GLenum* mapping, GLenum *component_usage, INT texture_idx) {
/* The WINED3DTA_COMPLEMENT flag specifies the complement of the input should
* be used. */
if (arg & WINED3DTA_COMPLEMENT) *mapping = GL_UNSIGNED_INVERT_NV;
d3d9: Test for fixed function value clamping.
2008-08-14 23:29:47 +02:00
else *mapping = GL_UNSIGNED_IDENTITY_NV; /* Clamp all values to positive ranges */
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
/* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the input
* should be used for all input components. */
if (is_alpha || arg & WINED3DTA_ALPHAREPLICATE) *component_usage = GL_ALPHA;
else *component_usage = GL_RGB;
*input = d3dta_to_combiner_input(arg & WINED3DTA_SELECTMASK, stage, texture_idx);
}
wined3d: Pass a wined3d_state structure to set_tex_op_nvrc().
2010-09-23 11:48:03 +02:00
void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state, BOOL is_alpha,
int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx, DWORD dst)
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
tex_op_args tex_op_args = {{0}, {0}, {0}};
GLenum portion = is_alpha ? GL_ALPHA : GL_RGB;
GLenum target = GL_COMBINER0_NV + stage;
GLenum output;
TRACE("stage %d, is_alpha %d, op %s, arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
stage, is_alpha, debug_d3dtop(op), arg1, arg2, arg3, texture_idx);
/* If a texture stage references an invalid texture unit the stage just
* passes through the result from the previous stage */
wined3d: Pass a wined3d_state structure to set_tex_op_nvrc().
2010-09-23 11:48:03 +02:00
if (is_invalid_op(state, stage, op, arg1, arg2, arg3))
wined3d: Pass a wined3d_state structure to is_invalid_op(). Instead of an entire device.
2010-09-23 11:48:02 +02:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
arg1 = WINED3DTA_CURRENT;
op = WINED3DTOP_SELECTARG1;
}
get_src_and_opr_nvrc(stage, arg1, is_alpha, &tex_op_args.input[0],
&tex_op_args.mapping[0], &tex_op_args.component_usage[0], texture_idx);
get_src_and_opr_nvrc(stage, arg2, is_alpha, &tex_op_args.input[1],
&tex_op_args.mapping[1], &tex_op_args.component_usage[1], texture_idx);
get_src_and_opr_nvrc(stage, arg3, is_alpha, &tex_op_args.input[2],
&tex_op_args.mapping[2], &tex_op_args.component_usage[2], texture_idx);
if(dst == WINED3DTA_TEMP) {
output = GL_SPARE1_NV;
} else {
output = GL_SPARE0_NV;
}
/* This is called by a state handler which has the gl lock held and a context for the thread */
switch(op)
{
case WINED3DTOP_DISABLE:
/* Only for alpha */
if (!is_alpha) ERR("Shouldn't be called for WINED3DTSS_COLOROP (WINED3DTOP_DISABLE)\n");
/* Input, prev_alpha*1 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_SELECTARG1:
case WINED3DTOP_SELECTARG2:
/* Input, arg*1 */
if (op == WINED3DTOP_SELECTARG1) {
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
} else {
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
}
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_MODULATE:
case WINED3DTOP_MODULATE2X:
case WINED3DTOP_MODULATE4X:
/* Input, arg1*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
/* Output */
if (op == WINED3DTOP_MODULATE) {
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
} else if (op == WINED3DTOP_MODULATE2X) {
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
GL_DISCARD_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
} else if (op == WINED3DTOP_MODULATE4X) {
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
GL_DISCARD_NV, GL_SCALE_BY_FOUR_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
}
break;
case WINED3DTOP_ADD:
case WINED3DTOP_ADDSIGNED:
case WINED3DTOP_ADDSIGNED2X:
/* Input, arg1*1+arg2*1 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
if (op == WINED3DTOP_ADD) {
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
} else if (op == WINED3DTOP_ADDSIGNED) {
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
} else if (op == WINED3DTOP_ADDSIGNED2X) {
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_SCALE_BY_TWO_NV, GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_FALSE, GL_FALSE, GL_FALSE));
}
break;
case WINED3DTOP_SUBTRACT:
/* Input, arg1*1+-arg2*1 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[1], GL_SIGNED_NEGATE_NV, tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_ADDSMOOTH:
/* Input, arg1*1+(1-arg1)*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_BLENDDIFFUSEALPHA:
case WINED3DTOP_BLENDTEXTUREALPHA:
case WINED3DTOP_BLENDFACTORALPHA:
case WINED3DTOP_BLENDTEXTUREALPHAPM:
case WINED3DTOP_BLENDCURRENTALPHA:
{
GLenum alpha_src = GL_PRIMARY_COLOR_NV;
if (op == WINED3DTOP_BLENDDIFFUSEALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_DIFFUSE, stage, texture_idx);
else if (op == WINED3DTOP_BLENDTEXTUREALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
else if (op == WINED3DTOP_BLENDFACTORALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_TFACTOR, stage, texture_idx);
else if (op == WINED3DTOP_BLENDTEXTUREALPHAPM) alpha_src = d3dta_to_combiner_input(WINED3DTA_TEXTURE, stage, texture_idx);
else if (op == WINED3DTOP_BLENDCURRENTALPHA) alpha_src = d3dta_to_combiner_input(WINED3DTA_CURRENT, stage, texture_idx);
else FIXME("Unhandled WINED3DTOP %s, shouldn't happen\n", debug_d3dtop(op));
/* Input, arg1*alpha_src+arg2*(1-alpha_src) */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
if (op == WINED3DTOP_BLENDTEXTUREALPHAPM)
{
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
} else {
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
alpha_src, GL_UNSIGNED_IDENTITY_NV, GL_ALPHA));
}
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
alpha_src, GL_UNSIGNED_INVERT_NV, GL_ALPHA));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
}
case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
/* Input, arg1_alpha*arg2_rgb+arg1_rgb*1 */
if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEALPHA_ADDCOLOR)\n");
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_MODULATECOLOR_ADDALPHA:
/* Input, arg1_rgb*arg2_rgb+arg1_alpha*1 */
if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATECOLOR_ADDALPHA)\n");
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
/* Input, (1-arg1_alpha)*arg2_rgb+arg1_rgb*1 */
if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVALPHA_ADDCOLOR)\n");
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
/* Input, (1-arg1_rgb)*arg2_rgb+arg1_alpha*1 */
if (is_alpha) ERR("Only supported for WINED3DTSS_COLOROP (WINED3DTOP_MODULATEINVCOLOR_ADDALPHA)\n");
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], invert_mapping(tex_op_args.mapping[0]), tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], GL_ALPHA));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_DOTPRODUCT3:
/* Input, arg1 . arg2 */
/* FIXME: DX7 uses a different calculation? */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[0], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[1], GL_EXPAND_NORMAL_NV, tex_op_args.component_usage[1]));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, output, GL_DISCARD_NV,
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_TRUE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_MULTIPLYADD:
/* Input, arg3*1+arg1*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_LERP:
/* Input, arg3*arg1+(1-arg3)*arg2 */
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[2], tex_op_args.mapping[2], tex_op_args.component_usage[2]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
tex_op_args.input[0], tex_op_args.mapping[0], tex_op_args.component_usage[0]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_C_NV,
tex_op_args.input[2], invert_mapping(tex_op_args.mapping[2]), tex_op_args.component_usage[2]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_D_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
/* Output */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_DISCARD_NV, GL_DISCARD_NV,
output, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
case WINED3DTOP_BUMPENVMAPLUMINANCE:
case WINED3DTOP_BUMPENVMAP:
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (gl_info->supported[NV_TEXTURE_SHADER])
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
/* The bump map stage itself isn't exciting, just read the texture. But tell the next stage to
* perform bump mapping and source from the current stage. Pretty much a SELECTARG2.
* ARG2 is passed through unmodified(apps will most likely use D3DTA_CURRENT for arg2, arg1
* (which will most likely be D3DTA_TEXTURE) is available as a texture shader input for the next stage
*/
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_A_NV,
tex_op_args.input[1], tex_op_args.mapping[1], tex_op_args.component_usage[1]));
GL_EXTCALL(glCombinerInputNV(target, portion, GL_VARIABLE_B_NV,
GL_ZERO, GL_UNSIGNED_INVERT_NV, portion));
/* Always pass through to CURRENT, ignore temp arg */
GL_EXTCALL(glCombinerOutputNV(target, portion, GL_SPARE0_NV, GL_DISCARD_NV,
GL_DISCARD_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE));
break;
}
default:
FIXME("Unhandled WINED3DTOP: stage %d, is_alpha %d, op %s (%#x), arg1 %#x, arg2 %#x, arg3 %#x, texture_idx %d\n",
stage, is_alpha, debug_d3dtop(op), op, arg1, arg2, arg3, texture_idx);
}
wined3d: checkGLcall() doesn't need a \n.
2009-07-07 11:08:02 +02:00
checkGLcall("set_tex_op_nvrc()");
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void nvrc_colorop(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
BOOL tex_used = stateblock->device->fixed_function_usage_map & (1 << stage);
DWORD mapped_stage = stateblock->device->texUnitMap[stage];
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
TRACE("Setting color op for stage %u.\n", stage);
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
wined3d: Shaders will never have a NULL function.
2008-12-15 16:35:14 +01:00
/* Using a pixel shader? Don't care for anything here, the shader applying does it */
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
if (use_ps(state)) return;
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage != WINED3D_UNMAPPED_STAGE)
{
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (tex_used && mapped_stage >= gl_info->limits.textures)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
FIXME("Attempt to enable unsupported stage!\n");
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
return;
}
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("glActiveTextureARB");
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
}
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
if (state->lowest_disabled_stage > 0)
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
glEnable(GL_REGISTER_COMBINERS_NV);
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, state->lowest_disabled_stage));
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
}
else
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
glDisable(GL_REGISTER_COMBINERS_NV);
}
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
if (stage >= state->lowest_disabled_stage)
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
TRACE("Stage disabled\n");
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage != WINED3D_UNMAPPED_STAGE)
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
/* Disable everything here */
glDisable(GL_TEXTURE_2D);
checkGLcall("glDisable(GL_TEXTURE_2D)");
glDisable(GL_TEXTURE_3D);
checkGLcall("glDisable(GL_TEXTURE_3D)");
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
}
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
glDisable(GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
}
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (gl_info->supported[NV_TEXTURE_SHADER2] && mapped_stage < gl_info->limits.textures)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
}
}
/* All done */
return;
}
/* The sampler will also activate the correct texture dimensions, so no need to do it here
* if the sampler for this stage is dirty
*/
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (!isStateDirty(context, STATE_SAMPLER(stage)))
{
if (tex_used)
{
if (gl_info->supported[NV_TEXTURE_SHADER2])
{
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
nvts_activate_dimensions(state, stage, context);
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
}
else
{
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
texture_activate_dimensions(state->textures[stage], gl_info);
wined3d: Separate texture_activate_dimensions. This creates an nvts version of this function, and removes the nvts code from the original one. The nvts version is used by the nvts pipeline implementation, the original one by the nvrc-only, atifs and ffp one.
2008-07-05 00:25:23 +02:00
}
}
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
}
/* Set the texture combiners */
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
set_tex_op_nvrc(gl_info, state, FALSE, stage,
state->texture_states[stage][WINED3DTSS_COLOROP],
state->texture_states[stage][WINED3DTSS_COLORARG1],
state->texture_states[stage][WINED3DTSS_COLORARG2],
state->texture_states[stage][WINED3DTSS_COLORARG0],
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
mapped_stage,
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
state->texture_states[stage][WINED3DTSS_RESULTARG]);
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
/* In register combiners bump mapping is done in the stage AFTER the one that has the bump map operation set,
* thus the texture shader may have to be updated
*/
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (gl_info->supported[NV_TEXTURE_SHADER2])
{
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
BOOL usesBump = (state->texture_states[stage][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAPLUMINANCE
|| state->texture_states[stage][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAP);
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
BOOL usedBump = !!(context->texShaderBumpMap & 1 << (stage + 1));
if (usesBump != usedBump)
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage + 1));
checkGLcall("glActiveTextureARB");
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
nvts_activate_dimensions(state, stage + 1, context);
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("glActiveTextureARB");
}
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void nvts_texdim(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
DWORD sampler = state_id - STATE_SAMPLER(0);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
DWORD mapped_stage = stateblock->device->texUnitMap[sampler];
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Separate texture_activate_dimensions. This creates an nvts version of this function, and removes the nvts code from the original one. The nvts version is used by the nvts pipeline implementation, the original one by the nvrc-only, atifs and ffp one.
2008-07-05 00:25:23 +02:00
/* No need to enable / disable anything here for unused samplers. The tex_colorop
* handler takes care. Also no action is needed with pixel shaders, or if tex_colorop
* will take care of this business
*/
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (mapped_stage == WINED3D_UNMAPPED_STAGE || mapped_stage >= context->gl_info->limits.textures) return;
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
if (sampler >= state->lowest_disabled_stage) return;
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
if (isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) return;
wined3d: Separate texture_activate_dimensions. This creates an nvts version of this function, and removes the nvts code from the original one. The nvts version is used by the nvts pipeline implementation, the original one by the nvrc-only, atifs and ffp one.
2008-07-05 00:25:23 +02:00
wined3d: Pass a wined3d_state structure to nvts_activate_dimensions().
2010-10-01 12:25:48 +02:00
nvts_activate_dimensions(state, sampler, context);
wined3d: Separate texture_activate_dimensions. This creates an nvts version of this function, and removes the nvts code from the original one. The nvts version is used by the nvts pipeline implementation, the original one by the nvrc-only, atifs and ffp one.
2008-07-05 00:25:23 +02:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void nvts_bumpenvmat(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Renumber WINED3DTEXTURESTAGESTATETYPE enum elements. Saves some space by not having unused entries is the arrays tracking these states.
2009-01-06 11:43:45 +01:00
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
DWORD mapped_stage = stateblock->device->texUnitMap[stage + 1];
wined3d: Set the nvidia_texture_shader.c GLINFO_LOCATION to *gl_info.
2010-05-24 09:56:37 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
float mat[2][2];
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
/* Direct3D sets the matrix in the stage reading the perturbation map. The result is used to
* offset the destination stage(always stage + 1 in d3d). In GL_NV_texture_shader, the bump
* map offsetting is done in the stage reading the bump mapped texture, and the perturbation
* map is read from a specified source stage(always stage - 1 for d3d). Thus set the matrix
* for stage + 1. Keep the nvrc tex unit mapping in mind too
*/
wined3d: Set the nvidia_texture_shader.c GLINFO_LOCATION to *gl_info.
2010-05-24 09:56:37 +02:00
if (mapped_stage < gl_info->limits.textures)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage))");
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
/* We can't just pass a pointer to the stateblock to GL due to the
* different matrix format (column major vs row major). */
mat[0][0] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVMAT00]);
mat[1][0] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVMAT01]);
mat[0][1] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVMAT10]);
mat[1][1] = *((float *)&stateblock->state.texture_states[stage][WINED3DTSS_BUMPENVMAT11]);
glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, (float *)mat);
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
checkGLcall("glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, mat)");
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void nvrc_texfactor(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Set the nvidia_texture_shader.c GLINFO_LOCATION to *gl_info.
2010-05-24 09:56:37 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
float col[4];
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
D3DCOLORTOGLFLOAT4(stateblock->state.render_states[WINED3DRS_TEXTUREFACTOR], col);
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
}
wined3d: Document GL context dependencies.
2009-06-26 10:07:12 +02:00
/* Context activation is done by the caller. */
wined3d: Remove a redundant parameter to enable_extension().
2010-12-01 20:50:45 +01:00
static void nvrc_enable(BOOL enable) {}
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
wined3d: Call frag_pipe->enable_extension under the GL lock.
2011-05-24 23:36:16 +02:00
/* Context activation and GL locking are done by the caller. */
wined3d: Remove a redundant parameter to enable_extension().
2010-12-01 20:50:45 +01:00
static void nvts_enable(BOOL enable)
{
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
if(enable) {
glEnable(GL_TEXTURE_SHADER_NV);
checkGLcall("glEnable(GL_TEXTURE_SHADER_NV)");
} else {
glDisable(GL_TEXTURE_SHADER_NV);
checkGLcall("glDisable(GL_TEXTURE_SHADER_NV)");
}
}
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
static void nvrc_fragment_get_caps(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps)
wined3d: Const correctness fixes for arb_program_shader.c.
2008-11-25 14:36:09 +01:00
{
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_TSSARGTEMP;
wined3d: Make sure all fields of the fragment pipe caps are always initialized.
2010-04-29 23:41:28 +02:00
/* The caps below can be supported but aren't handled yet in utils.c
* 'd3dta_to_combiner_input', disable them until support is fixed */
#if 0
if (gl_info->supported[NV_REGISTER_COMBINERS2])
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_PERSTAGECONSTANT;
wined3d: Make sure all fields of the fragment pipe caps are always initialized.
2010-04-29 23:41:28 +02:00
#endif
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->TextureOpCaps = WINED3DTEXOPCAPS_ADD
| WINED3DTEXOPCAPS_ADDSIGNED
| WINED3DTEXOPCAPS_ADDSIGNED2X
| WINED3DTEXOPCAPS_MODULATE
| WINED3DTEXOPCAPS_MODULATE2X
| WINED3DTEXOPCAPS_MODULATE4X
| WINED3DTEXOPCAPS_SELECTARG1
| WINED3DTEXOPCAPS_SELECTARG2
| WINED3DTEXOPCAPS_DISABLE
| WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
| WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
| WINED3DTEXOPCAPS_BLENDFACTORALPHA
| WINED3DTEXOPCAPS_BLENDCURRENTALPHA
| WINED3DTEXOPCAPS_LERP
| WINED3DTEXOPCAPS_SUBTRACT
| WINED3DTEXOPCAPS_ADDSMOOTH
| WINED3DTEXOPCAPS_MULTIPLYADD
| WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
| WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
| WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
| WINED3DTEXOPCAPS_DOTPRODUCT3
| WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
| WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA;
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (gl_info->supported[NV_TEXTURE_SHADER2])
{
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
/* Bump mapping is supported already in NV_TEXTURE_SHADER, but that extension does
* not support 3D textures. This asks for trouble if an app uses both bump mapping
* and 3D textures. It also allows us to keep the code simpler by having texture
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
* shaders constantly enabled. */
caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAP;
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
/* TODO: Luminance bump map? */
}
#if 0
/* FIXME: Add
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
WINED3DTEXOPCAPS_PREMODULATE */
#endif
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->MaxTextureBlendStages = min(MAX_TEXTURES, gl_info->limits.general_combiners);
caps->MaxSimultaneousTextures = gl_info->limits.textures;
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
}
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
static HRESULT nvrc_fragment_alloc(struct wined3d_device *device) { return WINED3D_OK; }
wined3d: Document GL context dependencies.
2009-06-26 10:07:12 +02:00
/* Context activation is done by the caller. */
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
static void nvrc_fragment_free(struct wined3d_device *device) {}
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
/* Two fixed function pipeline implementations using GL_NV_register_combiners and
* GL_NV_texture_shader. The nvts_fragment_pipeline assumes that both extensions
* are available(geforce 3 and newer), while nvrc_fragment_pipeline uses only the
* register combiners extension(Pre-GF3).
*/
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
wined3d: Make shader texture format fixups more generic. Based on a patch by Stefan Dösinger. This is more flexible, and allows the shader backend implementation to be simpler, since it doesn't have to know about specific formats. The next patch makes use of this.
2008-12-03 14:53:43 +01:00
static BOOL nvts_color_fixup_supported(struct color_fixup_desc fixup)
{
if (TRACE_ON(d3d))
{
TRACE("Checking support for fixup:\n");
dump_color_fixup_desc(fixup);
}
/* We only support identity conversions. */
if (is_identity_fixup(fixup))
{
TRACE("[OK]\n");
return TRUE;
}
TRACE("[FAILED]\n");
wined3d: Ask the ffp/shader/blit implementation about format support. If a format is not supported natively by opengl, a shader may be able to convert it. Up to now, CheckDeviceFormat had magic knowldge which GL extensions lead to which supported format. This patch adds functions that allow CheckDeviceFormat to ask the actual implementation for its capabilities.
2008-08-07 21:51:35 +02:00
return FALSE;
}
wined3d: Make some functions and variables static.
2008-12-02 15:31:17 +01:00
static const struct StateEntryTemplate nvrc_fragmentstate_template[] = {
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), nvrc_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move an extension check into the state template.
2008-07-05 22:23:47 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), nvts_bumpenvmat }, NV_TEXTURE_SHADER2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, NV_TEXTURE_SHADER2 },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_PIXELSHADER, { STATE_PIXELSHADER, apply_pixelshader }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), nvrc_texfactor }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), nvts_texdim }, NV_TEXTURE_SHADER2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE },
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
{ STATE_SAMPLER(1), { STATE_SAMPLER(1), nvts_texdim }, NV_TEXTURE_SHADER2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, WINED3D_GL_EXT_NONE },
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
{ STATE_SAMPLER(2), { STATE_SAMPLER(2), nvts_texdim }, NV_TEXTURE_SHADER2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, WINED3D_GL_EXT_NONE },
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
{ STATE_SAMPLER(3), { STATE_SAMPLER(3), nvts_texdim }, NV_TEXTURE_SHADER2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim }, WINED3D_GL_EXT_NONE },
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
{ STATE_SAMPLER(4), { STATE_SAMPLER(4), nvts_texdim }, NV_TEXTURE_SHADER2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim }, WINED3D_GL_EXT_NONE },
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
{ STATE_SAMPLER(5), { STATE_SAMPLER(5), nvts_texdim }, NV_TEXTURE_SHADER2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim }, WINED3D_GL_EXT_NONE },
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
{ STATE_SAMPLER(6), { STATE_SAMPLER(6), nvts_texdim }, NV_TEXTURE_SHADER2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim }, WINED3D_GL_EXT_NONE },
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
{ STATE_SAMPLER(7), { STATE_SAMPLER(7), nvts_texdim }, NV_TEXTURE_SHADER2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim }, WINED3D_GL_EXT_NONE },
{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
};
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
const struct fragment_pipeline nvts_fragment_pipeline = {
nvts_enable,
nvrc_fragment_get_caps,
nvrc_fragment_alloc,
nvrc_fragment_free,
wined3d: Make shader texture format fixups more generic. Based on a patch by Stefan Dösinger. This is more flexible, and allows the shader backend implementation to be simpler, since it doesn't have to know about specific formats. The next patch makes use of this.
2008-12-03 14:53:43 +01:00
nvts_color_fixup_supported,
wined3d: Handle projected textures properly in arbfp and atifs. GL_ARB_fragment_program and GL_ATI_fragment_shader can disable projected textures properly, and they can also handle D3DTTFF_PROJECTED | D3DTTFF_COUNT3 properly.
2008-08-23 22:41:51 +02:00
nvrc_fragmentstate_template,
FALSE /* we cannot disable projected textures. The vertex pipe has to do it */
wined3d: Coalesce the nvrc and nvts+nvrc state template.
2008-07-05 22:20:10 +02:00
};
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
const struct fragment_pipeline nvrc_fragment_pipeline = {
nvrc_enable,
nvrc_fragment_get_caps,
nvrc_fragment_alloc,
nvrc_fragment_free,
wined3d: Make shader texture format fixups more generic. Based on a patch by Stefan Dösinger. This is more flexible, and allows the shader backend implementation to be simpler, since it doesn't have to know about specific formats. The next patch makes use of this.
2008-12-03 14:53:43 +01:00
nvts_color_fixup_supported,
wined3d: Handle projected textures properly in arbfp and atifs. GL_ARB_fragment_program and GL_ATI_fragment_shader can disable projected textures properly, and they can also handle D3DTTFF_PROJECTED | D3DTTFF_COUNT3 properly.
2008-08-23 22:41:51 +02:00
nvrc_fragmentstate_template,
FALSE /* we cannot disable projected textures. The vertex pipe has to do it */
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
};