ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wined3d: Create a struct wined3d_shader_version to store version information. 

The version tokens in SM1-3 and SM4 are similar, but not the same.
This commit is contained in:
Henri Verbeet 2009-05-06 17:59:21 +02:00 committed by Alexandre Julliard
parent 5c63d93e18
commit 65622a052c
8 changed files with 349 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
dlls/wined3d/arb_program_shader.c
View File

@ -81,7 +81,6 @@ struct shader_arb_priv {
static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl* This, const WineD3D_GL_Info *gl_info, static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl* This, const WineD3D_GL_Info *gl_info,
GLuint target_type, unsigned int max_constants, const float *constants, char *dirty_consts) GLuint target_type, unsigned int max_constants, const float *constants, char *dirty_consts)
{ {
DWORD shader_version = This->baseShader.reg_maps.shader_version;
local_constant* lconst; local_constant* lconst;
DWORD i, j; DWORD i, j;
unsigned int ret; unsigned int ret;
@ -95,7 +94,7 @@ static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl* This, con
} }
} }
/* In 1.X pixel shaders constants are implicitly clamped in the range [-1;1] */ /* In 1.X pixel shaders constants are implicitly clamped in the range [-1;1] */
if (target_type == GL_FRAGMENT_PROGRAM_ARB && WINED3DSHADER_VERSION_MAJOR(shader_version) == 1) if (target_type == GL_FRAGMENT_PROGRAM_ARB && This->baseShader.reg_maps.shader_version.major == 1)
{ {
float lcl_const[4]; float lcl_const[4];
for(i = 0; i < max_constants; i++) { for(i = 0; i < max_constants; i++) {
@ -297,7 +296,7 @@ static void shader_generate_arb_declarations(IWineD3DBaseShader *iface, const sh
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface; IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device; IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
DWORD i, cur; DWORD i, cur;
char pshader = shader_is_pshader_version(reg_maps->shader_version); char pshader = shader_is_pshader_version(reg_maps->shader_version.type);
unsigned max_constantsF = min(This->baseShader.limits.constant_float, unsigned max_constantsF = min(This->baseShader.limits.constant_float,
(pshader ? GL_LIMITS(pshader_constantsF) - ARB_SHADER_RESERVED_PS_CONSTS : (pshader ? GL_LIMITS(pshader_constantsF) - ARB_SHADER_RESERVED_PS_CONSTS :
GL_LIMITS(vshader_constantsF) - ARB_SHADER_RESERVED_VS_CONSTS)); GL_LIMITS(vshader_constantsF) - ARB_SHADER_RESERVED_VS_CONSTS));
@ -422,7 +421,7 @@ static void shader_arb_get_write_mask(const struct wined3d_shader_instruction *i
const struct wined3d_shader_dst_param *dst, char *write_mask) const struct wined3d_shader_dst_param *dst, char *write_mask)
{ {
char *ptr = write_mask; char *ptr = write_mask;
char vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version); char vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
if (vshader && dst->register_type == WINED3DSPR_ADDR) if (vshader && dst->register_type == WINED3DSPR_ADDR)
{ {
@ -480,8 +479,7 @@ static void shader_arb_get_register_name(IWineD3DBaseShader *iface, WINED3DSHADE
/* oPos, oFog and oPts in D3D */ /* oPos, oFog and oPts in D3D */
static const char * const rastout_reg_names[] = {"TMP_OUT", "result.fogcoord", "result.pointsize"}; static const char * const rastout_reg_names[] = {"TMP_OUT", "result.fogcoord", "result.pointsize"};
IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface; IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)iface;
DWORD shader_version = This->baseShader.reg_maps.shader_version; BOOL pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type);
BOOL pshader = shader_is_pshader_version(shader_version);
*is_color = FALSE; *is_color = FALSE;
@ -690,7 +688,7 @@ static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD
} else { } else {
tex_type = "2D"; tex_type = "2D";
} }
if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version)) if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
{ {
const IWineD3DPixelShaderImpl* const ps = (const IWineD3DPixelShaderImpl*)This; const IWineD3DPixelShaderImpl* const ps = (const IWineD3DPixelShaderImpl*)This;
if(ps->cur_args->np2_fixup & (1 << sampler_idx)) { if(ps->cur_args->np2_fixup & (1 << sampler_idx)) {
@ -723,7 +721,7 @@ static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD
shader_addline(buffer, "TEX %s, %s, texture[%u], %s;\n", dst_str, coord_reg, sampler_idx, tex_type); shader_addline(buffer, "TEX %s, %s, texture[%u], %s;\n", dst_str, coord_reg, sampler_idx, tex_type);
} }
if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version)) if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
{ {
IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *)ins->ctx->shader; IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
gen_color_correction(buffer, dst_str, ins->dst[0].write_mask, gen_color_correction(buffer, dst_str, ins->dst[0].write_mask,
@ -858,6 +856,8 @@ static void pshader_hw_cnd(const struct wined3d_shader_instruction *ins)
BOOL sat = dst->modifiers & WINED3DSPDM_SATURATE; BOOL sat = dst->modifiers & WINED3DSPDM_SATURATE;
DWORD shift = dst->shift; DWORD shift = dst->shift;
BOOL is_color; BOOL is_color;
DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
ins->ctx->reg_maps->shader_version.minor);
/* FIXME: support output modifiers */ /* FIXME: support output modifiers */
@ -872,7 +872,7 @@ static void pshader_hw_cnd(const struct wined3d_shader_instruction *ins)
pshader_gen_input_modifier_line(ins->ctx->shader, buffer, &ins->src[2], 2, src_name[2]); pshader_gen_input_modifier_line(ins->ctx->shader, buffer, &ins->src[2], 2, src_name[2]);
/* The coissue flag changes the semantic of the cnd instruction in <= 1.3 shaders */ /* The coissue flag changes the semantic of the cnd instruction in <= 1.3 shaders */
if (ins->ctx->reg_maps->shader_version <= WINED3DPS_VERSION(1, 3) && ins->coissue) if (shader_version <= WINED3D_SHADER_VERSION(1, 3) && ins->coissue)
{ {
shader_addline(buffer, "MOV%s %s%s, %s;\n", sat ? "_SAT" : "", dst_name, dst_wmask, src_name[1]); shader_addline(buffer, "MOV%s %s%s, %s;\n", sat ? "_SAT" : "", dst_name, dst_wmask, src_name[1]);
} else { } else {
@ -983,7 +983,7 @@ static void shader_hw_map2gl(const struct wined3d_shader_instruction *ins)
break; break;
} }
if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version)) if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
{ {
/* Output token related */ /* Output token related */
const struct wined3d_shader_dst_param *dst; const struct wined3d_shader_dst_param *dst;
@ -1067,8 +1067,8 @@ static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
{ {
IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader; IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
if ((WINED3DSHADER_VERSION_MAJOR(ins->ctx->reg_maps->shader_version) == 1 if ((ins->ctx->reg_maps->shader_version.major == 1
&& !shader_is_pshader_version(ins->ctx->reg_maps->shader_version) && !shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)
&& ins->dst[0].register_type == WINED3DSPR_ADDR) && ins->dst[0].register_type == WINED3DSPR_ADDR)
|| ins->handler_idx == WINED3DSIH_MOVA) || ins->handler_idx == WINED3DSIH_MOVA)
{ {
@ -1105,7 +1105,6 @@ static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
static void pshader_hw_texkill(const struct wined3d_shader_instruction *ins) static void pshader_hw_texkill(const struct wined3d_shader_instruction *ins)
{ {
const struct wined3d_shader_dst_param *dst = &ins->dst[0]; const struct wined3d_shader_dst_param *dst = &ins->dst[0];
DWORD shader_version = ins->ctx->reg_maps->shader_version;
SHADER_BUFFER *buffer = ins->ctx->buffer; SHADER_BUFFER *buffer = ins->ctx->buffer;
char reg_dest[40]; char reg_dest[40];
BOOL is_color; BOOL is_color;
@ -1116,7 +1115,7 @@ static void pshader_hw_texkill(const struct wined3d_shader_instruction *ins)
shader_arb_get_register_name(ins->ctx->shader, dst->register_type, shader_arb_get_register_name(ins->ctx->shader, dst->register_type,
dst->register_idx, !!dst->rel_addr, reg_dest, &is_color); dst->register_idx, !!dst->rel_addr, reg_dest, &is_color);
if (shader_version >= WINED3DPS_VERSION(2,0)) if (ins->ctx->reg_maps->shader_version.major >= 2)
{ {
/* The arb backend doesn't claim ps 2.0 support, but try to eat what the app feeds to us */ /* The arb backend doesn't claim ps 2.0 support, but try to eat what the app feeds to us */
shader_addline(buffer, "KIL %s;\n", reg_dest); shader_addline(buffer, "KIL %s;\n", reg_dest);
@ -1137,7 +1136,8 @@ static void pshader_hw_tex(const struct wined3d_shader_instruction *ins)
const struct wined3d_shader_dst_param *dst = &ins->dst[0]; const struct wined3d_shader_dst_param *dst = &ins->dst[0];
BOOL is_color; BOOL is_color;
SHADER_BUFFER *buffer = ins->ctx->buffer; SHADER_BUFFER *buffer = ins->ctx->buffer;
DWORD shader_version = ins->ctx->reg_maps->shader_version; DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
ins->ctx->reg_maps->shader_version.minor);
BOOL projected = FALSE, bias = FALSE; BOOL projected = FALSE, bias = FALSE;
char reg_dest[40]; char reg_dest[40];
@ -1150,14 +1150,14 @@ static void pshader_hw_tex(const struct wined3d_shader_instruction *ins)
/* 1.0-1.3: Use destination register as coordinate source. /* 1.0-1.3: Use destination register as coordinate source.
1.4+: Use provided coordinate source register. */ 1.4+: Use provided coordinate source register. */
if (shader_version < WINED3DPS_VERSION(1,4)) if (shader_version < WINED3D_SHADER_VERSION(1,4))
strcpy(reg_coord, reg_dest); strcpy(reg_coord, reg_dest);
else else
pshader_gen_input_modifier_line(ins->ctx->shader, buffer, &ins->src[0], 0, reg_coord); pshader_gen_input_modifier_line(ins->ctx->shader, buffer, &ins->src[0], 0, reg_coord);
/* 1.0-1.4: Use destination register number as texture code. /* 1.0-1.4: Use destination register number as texture code.
2.0+: Use provided sampler number as texure code. */ 2.0+: Use provided sampler number as texure code. */
if (shader_version < WINED3DPS_VERSION(2,0)) if (shader_version < WINED3D_SHADER_VERSION(2,0))
reg_sampler_code = dst->register_idx; reg_sampler_code = dst->register_idx;
else else
reg_sampler_code = ins->src[1].register_idx; reg_sampler_code = ins->src[1].register_idx;
@ -1167,7 +1167,7 @@ static void pshader_hw_tex(const struct wined3d_shader_instruction *ins)
* 1.4: Use WINED3DSPSM_DZ or WINED3DSPSM_DW on src[0] * 1.4: Use WINED3DSPSM_DZ or WINED3DSPSM_DW on src[0]
* 2.0+: Use WINED3DSI_TEXLD_PROJECT on the opcode * 2.0+: Use WINED3DSI_TEXLD_PROJECT on the opcode
*/ */
if (shader_version < WINED3DPS_VERSION(1,4)) if (shader_version < WINED3D_SHADER_VERSION(1,4))
{ {
DWORD flags = 0; DWORD flags = 0;
if(reg_sampler_code < MAX_TEXTURES) { if(reg_sampler_code < MAX_TEXTURES) {
@ -1177,7 +1177,7 @@ static void pshader_hw_tex(const struct wined3d_shader_instruction *ins)
projected = TRUE; projected = TRUE;
} }
} }
else if (shader_version < WINED3DPS_VERSION(2,0)) else if (shader_version < WINED3D_SHADER_VERSION(2,0))
{ {
DWORD src_mod = ins->src[0].modifiers; DWORD src_mod = ins->src[0].modifiers;
if (src_mod == WINED3DSPSM_DZ) { if (src_mod == WINED3DSPSM_DZ) {
@ -1196,10 +1196,12 @@ static void pshader_hw_texcoord(const struct wined3d_shader_instruction *ins)
{ {
const struct wined3d_shader_dst_param *dst = &ins->dst[0]; const struct wined3d_shader_dst_param *dst = &ins->dst[0];
SHADER_BUFFER *buffer = ins->ctx->buffer; SHADER_BUFFER *buffer = ins->ctx->buffer;
DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
ins->ctx->reg_maps->shader_version.minor);
char tmp[20]; char tmp[20];
shader_arb_get_write_mask(ins, dst, tmp); shader_arb_get_write_mask(ins, dst, tmp);
if (ins->ctx->reg_maps->shader_version != WINED3DPS_VERSION(1,4)) if (shader_version != WINED3D_SHADER_VERSION(1,4))
{ {
DWORD reg = dst->register_idx; DWORD reg = dst->register_idx;
shader_addline(buffer, "MOV_SAT T%u%s, fragment.texcoord[%u];\n", reg, tmp, reg); shader_addline(buffer, "MOV_SAT T%u%s, fragment.texcoord[%u];\n", reg, tmp, reg);
@ -1907,7 +1909,7 @@ static void shader_arb_destroy(IWineD3DBaseShader *iface) {
IWineD3DBaseShaderImpl *baseShader = (IWineD3DBaseShaderImpl *) iface; IWineD3DBaseShaderImpl *baseShader = (IWineD3DBaseShaderImpl *) iface;
const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)baseShader->baseShader.device)->adapter->gl_info; const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)baseShader->baseShader.device)->adapter->gl_info;
if (shader_is_pshader_version(baseShader->baseShader.reg_maps.shader_version)) if (shader_is_pshader_version(baseShader->baseShader.reg_maps.shader_version.type))
{ {
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface; IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface;
UINT i; UINT i;
@ -1995,7 +1997,6 @@ static GLuint shader_arb_generate_pshader(IWineD3DPixelShader *iface,
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface; IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
const shader_reg_maps* reg_maps = &This->baseShader.reg_maps; const shader_reg_maps* reg_maps = &This->baseShader.reg_maps;
CONST DWORD *function = This->baseShader.function; CONST DWORD *function = This->baseShader.function;
DWORD shader_version = reg_maps->shader_version;
const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info; const WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info;
const local_constant *lconst; const local_constant *lconst;
GLuint retval; GLuint retval;
@ -2005,7 +2006,8 @@ static GLuint shader_arb_generate_pshader(IWineD3DPixelShader *iface,
/* Create the hw ARB shader */ /* Create the hw ARB shader */
shader_addline(buffer, "!!ARBfp1.0\n"); shader_addline(buffer, "!!ARBfp1.0\n");
if (shader_version < WINED3DPS_VERSION(3,0)) { if (reg_maps->shader_version.major < 3)
{
switch(args->fog) { switch(args->fog) {
case FOG_OFF: case FOG_OFF:
break; break;
@ -2030,7 +2032,8 @@ static GLuint shader_arb_generate_pshader(IWineD3DPixelShader *iface,
shader_addline(buffer, "PARAM coefmul = { 2, 4, 8, 16 };\n"); shader_addline(buffer, "PARAM coefmul = { 2, 4, 8, 16 };\n");
shader_addline(buffer, "PARAM one = { 1.0, 1.0, 1.0, 1.0 };\n"); shader_addline(buffer, "PARAM one = { 1.0, 1.0, 1.0, 1.0 };\n");
if (shader_version < WINED3DPS_VERSION(2,0)) { if (reg_maps->shader_version.major < 2)
{
fragcolor = "R0"; fragcolor = "R0";
} else { } else {
shader_addline(buffer, "TEMP TMP_COLOR;\n"); shader_addline(buffer, "TEMP TMP_COLOR;\n");

48
dlls/wined3d/baseshader.c
View File

@ -318,7 +318,7 @@ HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3
{ {
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface; IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
void *fe_data = This->baseShader.frontend_data; void *fe_data = This->baseShader.frontend_data;
DWORD shader_version; struct wined3d_shader_version shader_version;
unsigned int cur_loop_depth = 0, max_loop_depth = 0; unsigned int cur_loop_depth = 0, max_loop_depth = 0;
const DWORD* pToken = byte_code; const DWORD* pToken = byte_code;
char pshader; char pshader;
@ -336,7 +336,7 @@ HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3
fe->shader_read_header(fe_data, &pToken, &shader_version); fe->shader_read_header(fe_data, &pToken, &shader_version);
reg_maps->shader_version = shader_version; reg_maps->shader_version = shader_version;
pshader = shader_is_pshader_version(shader_version); pshader = shader_is_pshader_version(shader_version.type);
while (!fe->shader_is_end(fe_data, &pToken)) while (!fe->shader_is_end(fe_data, &pToken))
{ {
@ -408,7 +408,7 @@ HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3
pToken += 4; pToken += 4;
/* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */ /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
if (WINED3DSHADER_VERSION_MAJOR(shader_version) == 1 && pshader) if (shader_version.major == 1 && pshader)
{ {
float *value = (float *) lconst->value; float *value = (float *) lconst->value;
if(value[0] < -1.0) value[0] = -1.0; if(value[0] < -1.0) value[0] = -1.0;
@ -513,8 +513,7 @@ HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3
/* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and
* is used in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel * is used in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel
* shaders because TECRDOUT isn't used in them, but future register types might cause issues */ * shaders because TECRDOUT isn't used in them, but future register types might cause issues */
if (!pshader && WINED3DSHADER_VERSION_MAJOR(shader_version) < 3 if (!pshader && shader_version.major < 3 && dst_param.register_type == WINED3DSPR_TEXCRDOUT)
&& dst_param.register_type == WINED3DSPR_TEXCRDOUT)
{ {
reg_maps->texcoord_mask[dst_param.register_type] |= dst_param.write_mask; reg_maps->texcoord_mask[dst_param.register_type] |= dst_param.write_mask;
} }
@ -525,7 +524,7 @@ HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3
} }
/* Declare 1.X samplers implicitly, based on the destination reg. number */ /* Declare 1.X samplers implicitly, based on the destination reg. number */
if (WINED3DSHADER_VERSION_MAJOR(shader_version) == 1 if (shader_version.major == 1
&& pshader /* Filter different instructions with the same enum values in VS */ && pshader /* Filter different instructions with the same enum values in VS */
&& (ins.handler_idx == WINED3DSIH_TEX && (ins.handler_idx == WINED3DSIH_TEX
|| ins.handler_idx == WINED3DSIH_TEXBEM || ins.handler_idx == WINED3DSIH_TEXBEM
@ -593,7 +592,8 @@ HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3
return WINED3D_OK; return WINED3D_OK;
} }
static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semantic, DWORD shader_version) static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semantic,
const struct wined3d_shader_version *shader_version)
{ {
TRACE("dcl"); TRACE("dcl");
@ -610,7 +610,7 @@ static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semanti
else else
{ {
/* Pixel shaders 3.0 don't have usage semantics */ /* Pixel shaders 3.0 don't have usage semantics */
if (shader_is_pshader_version(shader_version) && shader_version < WINED3DPS_VERSION(3,0)) if (shader_is_pshader_version(shader_version->type) && shader_version->major < 3)
return; return;
else else
TRACE("_"); TRACE("_");
@ -667,7 +667,7 @@ static void shader_dump_decl_usage(const struct wined3d_shader_semantic *semanti
} }
static void shader_dump_register(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx, static void shader_dump_register(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx,
const struct wined3d_shader_src_param *rel_addr, DWORD shader_version) const struct wined3d_shader_src_param *rel_addr, const struct wined3d_shader_version *shader_version)
{ {
static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"}; static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
static const char * const misctype_reg_names[] = {"vPos", "vFace"}; static const char * const misctype_reg_names[] = {"vPos", "vFace"};
@ -692,7 +692,7 @@ static void shader_dump_register(WINED3DSHADER_PARAM_REGISTER_TYPE register_type
break; break;
case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */ case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
TRACE("%c", shader_is_pshader_version(shader_version) ? 't' : 'a'); TRACE("%c", shader_is_pshader_version(shader_version->type) ? 't' : 'a');
break; break;
case WINED3DSPR_RASTOUT: case WINED3DSPR_RASTOUT:
@ -714,7 +714,7 @@ static void shader_dump_register(WINED3DSHADER_PARAM_REGISTER_TYPE register_type
case WINED3DSPR_TEXCRDOUT: case WINED3DSPR_TEXCRDOUT:
/* Vertex shaders >= 3.0 use general purpose output registers /* Vertex shaders >= 3.0 use general purpose output registers
* (WINED3DSPR_OUTPUT), which can include an address token */ * (WINED3DSPR_OUTPUT), which can include an address token */
if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 3) TRACE("o"); if (shader_version->major >= 3) TRACE("o");
else TRACE("oT"); else TRACE("oT");
break; break;
@ -765,7 +765,8 @@ static void shader_dump_register(WINED3DSHADER_PARAM_REGISTER_TYPE register_type
} }
} }
void shader_dump_dst_param(const struct wined3d_shader_dst_param *param, DWORD shader_version) void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
const struct wined3d_shader_version *shader_version)
{ {
DWORD write_mask = param->write_mask; DWORD write_mask = param->write_mask;
@ -783,7 +784,8 @@ void shader_dump_dst_param(const struct wined3d_shader_dst_param *param, DWORD s
} }
} }
void shader_dump_src_param(const struct wined3d_shader_src_param *param, DWORD shader_version) void shader_dump_src_param(const struct wined3d_shader_src_param *param,
const struct wined3d_shader_version *shader_version)
{ {
DWORD src_modifier = param->modifiers; DWORD src_modifier = param->modifiers;
DWORD swizzle = param->swizzle; DWORD swizzle = param->swizzle;
@ -861,13 +863,13 @@ void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER *buffer,
void *fe_data = This->baseShader.frontend_data; void *fe_data = This->baseShader.frontend_data;
struct wined3d_shader_src_param src_rel_addr[4]; struct wined3d_shader_src_param src_rel_addr[4];
struct wined3d_shader_src_param src_param[4]; struct wined3d_shader_src_param src_param[4];
struct wined3d_shader_version shader_version;
struct wined3d_shader_src_param dst_rel_addr; struct wined3d_shader_src_param dst_rel_addr;
struct wined3d_shader_dst_param dst_param; struct wined3d_shader_dst_param dst_param;
struct wined3d_shader_instruction ins; struct wined3d_shader_instruction ins;
struct wined3d_shader_context ctx; struct wined3d_shader_context ctx;
const DWORD *pToken = pFunction; const DWORD *pToken = pFunction;
SHADER_HANDLER hw_fct; SHADER_HANDLER hw_fct;
DWORD shader_version;
DWORD i; DWORD i;
/* Initialize current parsing state */ /* Initialize current parsing state */
@ -975,16 +977,16 @@ static void shader_dump_ins_modifiers(const struct wined3d_shader_dst_param *dst
void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *pFunction) void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *pFunction)
{ {
struct wined3d_shader_version shader_version;
const DWORD* pToken = pFunction; const DWORD* pToken = pFunction;
DWORD shader_version;
DWORD i; DWORD i;
TRACE("Parsing %p\n", pFunction); TRACE("Parsing %p\n", pFunction);
fe->shader_read_header(fe_data, &pToken, &shader_version); fe->shader_read_header(fe_data, &pToken, &shader_version);
TRACE("%s_%u_%u\n", shader_is_pshader_version(shader_version) ? "ps": "vs", TRACE("%s_%u_%u\n", shader_is_pshader_version(shader_version.type) ? "ps": "vs",
WINED3DSHADER_VERSION_MAJOR(shader_version), WINED3DSHADER_VERSION_MINOR(shader_version)); shader_version.major, shader_version.minor);
while (!fe->shader_is_end(fe_data, &pToken)) while (!fe->shader_is_end(fe_data, &pToken))
{ {
@ -1014,10 +1016,10 @@ void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data,
fe->shader_read_semantic(&pToken, &semantic); fe->shader_read_semantic(&pToken, &semantic);
shader_dump_decl_usage(&semantic, shader_version); shader_dump_decl_usage(&semantic, &shader_version);
shader_dump_ins_modifiers(&semantic.reg); shader_dump_ins_modifiers(&semantic.reg);
TRACE(" "); TRACE(" ");
shader_dump_dst_param(&semantic.reg, shader_version); shader_dump_dst_param(&semantic.reg, &shader_version);
} }
else if (ins.handler_idx == WINED3DSIH_DEF) else if (ins.handler_idx == WINED3DSIH_DEF)
{ {
@ -1074,7 +1076,7 @@ void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data,
{ {
fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr); fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr);
TRACE("("); TRACE("(");
shader_dump_src_param(&src_param, shader_version); shader_dump_src_param(&src_param, &shader_version);
TRACE(") "); TRACE(") ");
} }
@ -1098,7 +1100,7 @@ void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data,
} }
} }
else if (ins.handler_idx == WINED3DSIH_TEX else if (ins.handler_idx == WINED3DSIH_TEX
&& shader_version >= WINED3DPS_VERSION(2,0) && shader_version.major >= 2
&& (ins.flags & WINED3DSI_TEXLD_PROJECT)) && (ins.flags & WINED3DSI_TEXLD_PROJECT))
{ {
TRACE("p"); TRACE("p");
@ -1109,7 +1111,7 @@ void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data,
{ {
shader_dump_ins_modifiers(&dst_param); shader_dump_ins_modifiers(&dst_param);
TRACE(" "); TRACE(" ");
shader_dump_dst_param(&dst_param, shader_version); shader_dump_dst_param(&dst_param, &shader_version);
} }
/* Other source tokens */ /* Other source tokens */
@ -1117,7 +1119,7 @@ void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data,
{ {
fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr); fe->shader_read_src_param(fe_data, &pToken, &src_param, &src_rel_addr);
TRACE(!i ? " " : ", "); TRACE(!i ? " " : ", ");
shader_dump_src_param(&src_param, shader_version); shader_dump_src_param(&src_param, &shader_version);
} }
} }
TRACE("\n"); TRACE("\n");

71
dlls/wined3d/glsl_shader.c
View File

@ -369,8 +369,8 @@ static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl *This, const Wine
const local_constant *lconst; const local_constant *lconst;
/* 1.X pshaders have the constants clamped to [-1;1] implicitly. */ /* 1.X pshaders have the constants clamped to [-1;1] implicitly. */
if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.reg_maps.shader_version) == 1 if (This->baseShader.reg_maps.shader_version.major == 1
&& shader_is_pshader_version(This->baseShader.reg_maps.shader_version)) && shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type))
walk_constant_heap_clamped(gl_info, constants, constant_locations, heap, stack, version); walk_constant_heap_clamped(gl_info, constants, constant_locations, heap, stack, version);
else else
walk_constant_heap(gl_info, constants, constant_locations, heap, stack, version); walk_constant_heap(gl_info, constants, constant_locations, heap, stack, version);
@ -434,7 +434,7 @@ static void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *This, const Wine
GLint tmp_loc; GLint tmp_loc;
unsigned int i; unsigned int i;
char tmp_name[8]; char tmp_name[8];
char is_pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version); char is_pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type);
const char* prefix = is_pshader? "PB":"VB"; const char* prefix = is_pshader? "PB":"VB";
struct list* ptr; struct list* ptr;
@ -700,12 +700,11 @@ static void shader_generate_glsl_declarations(IWineD3DBaseShader *iface, const s
{ {
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface; IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device; IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
DWORD shader_version = reg_maps->shader_version;
unsigned int i, extra_constants_needed = 0; unsigned int i, extra_constants_needed = 0;
const local_constant *lconst; const local_constant *lconst;
/* There are some minor differences between pixel and vertex shaders */ /* There are some minor differences between pixel and vertex shaders */
char pshader = shader_is_pshader_version(shader_version); char pshader = shader_is_pshader_version(reg_maps->shader_version.type);
char prefix = pshader ? 'P' : 'V'; char prefix = pshader ? 'P' : 'V';
/* Prototype the subroutines */ /* Prototype the subroutines */
@ -778,7 +777,7 @@ static void shader_generate_glsl_declarations(IWineD3DBaseShader *iface, const s
* out. The nvidia driver only does that if the parameter is inout instead of out, hence the * out. The nvidia driver only does that if the parameter is inout instead of out, hence the
* inout. * inout.
*/ */
if (shader_version >= WINED3DVS_VERSION(3, 0)) if (reg_maps->shader_version.major >= 3)
{ {
shader_addline(buffer, "void order_ps_input(in vec4[%u]);\n", MAX_REG_OUTPUT); shader_addline(buffer, "void order_ps_input(in vec4[%u]);\n", MAX_REG_OUTPUT);
} else { } else {
@ -888,7 +887,7 @@ static void shader_generate_glsl_declarations(IWineD3DBaseShader *iface, const s
/* Declare input register varyings. Only pixel shader, vertex shaders have that declared in the /* Declare input register varyings. Only pixel shader, vertex shaders have that declared in the
* helper function shader that is linked in at link time * helper function shader that is linked in at link time
*/ */
if (pshader && shader_version >= WINED3DPS_VERSION(3, 0)) if (pshader && reg_maps->shader_version.major >= 3)
{ {
if (use_vs(device->stateBlock)) if (use_vs(device->stateBlock))
{ {
@ -1053,8 +1052,7 @@ static void shader_glsl_get_register_name(WINED3DSHADER_PARAM_REGISTER_TYPE regi
IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader; IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device; IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
const WineD3D_GL_Info* gl_info = &deviceImpl->adapter->gl_info; const WineD3D_GL_Info* gl_info = &deviceImpl->adapter->gl_info;
DWORD shader_version = This->baseShader.reg_maps.shader_version; char pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type);
char pshader = shader_is_pshader_version(shader_version);
*is_color = FALSE; *is_color = FALSE;
@ -1066,7 +1064,7 @@ static void shader_glsl_get_register_name(WINED3DSHADER_PARAM_REGISTER_TYPE regi
case WINED3DSPR_INPUT: case WINED3DSPR_INPUT:
if (pshader) { if (pshader) {
/* Pixel shaders >= 3.0 */ /* Pixel shaders >= 3.0 */
if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 3) if (This->baseShader.reg_maps.shader_version.major >= 3)
{ {
DWORD in_count = GL_LIMITS(glsl_varyings) / 4; DWORD in_count = GL_LIMITS(glsl_varyings) / 4;
@ -1198,7 +1196,7 @@ static void shader_glsl_get_register_name(WINED3DSHADER_PARAM_REGISTER_TYPE regi
break; break;
case WINED3DSPR_TEXCRDOUT: case WINED3DSPR_TEXCRDOUT:
/* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */ /* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
if (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 3) sprintf(register_name, "OUT[%u]", register_idx); if (This->baseShader.reg_maps.shader_version.major >= 3) sprintf(register_name, "OUT[%u]", register_idx);
else sprintf(register_name, "gl_TexCoord[%u]", register_idx); else sprintf(register_name, "gl_TexCoord[%u]", register_idx);
break; break;
case WINED3DSPR_MISCTYPE: case WINED3DSPR_MISCTYPE:
@ -1579,7 +1577,7 @@ static void PRINTF_ATTR(8, 9) shader_glsl_gen_sample_code(const struct wined3d_s
shader_glsl_swizzle_to_str(swizzle, FALSE, ins->dst[0].write_mask, dst_swizzle); shader_glsl_swizzle_to_str(swizzle, FALSE, ins->dst[0].write_mask, dst_swizzle);
if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version)) if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
{ {
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader; IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
fixup = This->cur_args->color_fixup[sampler]; fixup = This->cur_args->color_fixup[sampler];
@ -1667,9 +1665,9 @@ static void shader_glsl_mov(const struct wined3d_shader_instruction *ins)
/* In vs_1_1 WINED3DSIO_MOV can write to the address register. In later /* In vs_1_1 WINED3DSIO_MOV can write to the address register. In later
* shader versions WINED3DSIO_MOVA is used for this. */ * shader versions WINED3DSIO_MOVA is used for this. */
if ((WINED3DSHADER_VERSION_MAJOR(ins->ctx->reg_maps->shader_version) == 1 if (ins->ctx->reg_maps->shader_version.major == 1
&& !shader_is_pshader_version(ins->ctx->reg_maps->shader_version) && !shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)
&& ins->dst[0].register_type == WINED3DSPR_ADDR)) && ins->dst[0].register_type == WINED3DSPR_ADDR)
{ {
/* This is a simple floor() */ /* This is a simple floor() */
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask); unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
@ -1845,7 +1843,7 @@ static void shader_glsl_expp(const struct wined3d_shader_instruction *ins)
shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src_param); shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src_param);
if (ins->ctx->reg_maps->shader_version < WINED3DPS_VERSION(2,0)) if (ins->ctx->reg_maps->shader_version.major < 2)
{ {
char dst_mask[6]; char dst_mask[6];
@ -2047,8 +2045,10 @@ static void shader_glsl_cnd(const struct wined3d_shader_instruction *ins)
DWORD write_mask, cmp_channel = 0; DWORD write_mask, cmp_channel = 0;
unsigned int i, j; unsigned int i, j;
DWORD dst_mask; DWORD dst_mask;
DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
ins->ctx->reg_maps->shader_version.minor);
if (ins->ctx->reg_maps->shader_version < WINED3DPS_VERSION(1, 4)) if (shader_version < WINED3D_SHADER_VERSION(1, 4))
{ {
write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins); write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param); shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
@ -2472,7 +2472,8 @@ static void pshader_glsl_tex(const struct wined3d_shader_instruction *ins)
{ {
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader; IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)ins->ctx->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device; IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
DWORD shader_version = ins->ctx->reg_maps->shader_version; DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
ins->ctx->reg_maps->shader_version.minor);
glsl_sample_function_t sample_function; glsl_sample_function_t sample_function;
DWORD sample_flags = 0; DWORD sample_flags = 0;
WINED3DSAMPLER_TEXTURE_TYPE sampler_type; WINED3DSAMPLER_TEXTURE_TYPE sampler_type;
@ -2481,11 +2482,11 @@ static void pshader_glsl_tex(const struct wined3d_shader_instruction *ins)
/* 1.0-1.4: Use destination register as sampler source. /* 1.0-1.4: Use destination register as sampler source.
* 2.0+: Use provided sampler source. */ * 2.0+: Use provided sampler source. */
if (shader_version < WINED3DPS_VERSION(2,0)) sampler_idx = ins->dst[0].register_idx; if (shader_version < WINED3D_SHADER_VERSION(2,0)) sampler_idx = ins->dst[0].register_idx;
else sampler_idx = ins->src[1].register_idx; else sampler_idx = ins->src[1].register_idx;
sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx]; sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
if (shader_version < WINED3DPS_VERSION(1,4)) if (shader_version < WINED3D_SHADER_VERSION(1,4))
{ {
DWORD flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS]; DWORD flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS];
@ -2501,7 +2502,7 @@ static void pshader_glsl_tex(const struct wined3d_shader_instruction *ins)
} }
} }
} }
else if (shader_version < WINED3DPS_VERSION(2,0)) else if (shader_version < WINED3D_SHADER_VERSION(2,0))
{ {
DWORD src_mod = ins->src[0].modifiers; DWORD src_mod = ins->src[0].modifiers;
@ -2529,12 +2530,12 @@ static void pshader_glsl_tex(const struct wined3d_shader_instruction *ins)
shader_glsl_get_sample_function(sampler_type, sample_flags, &sample_function); shader_glsl_get_sample_function(sampler_type, sample_flags, &sample_function);
mask |= sample_function.coord_mask; mask |= sample_function.coord_mask;
if (shader_version < WINED3DPS_VERSION(2,0)) swizzle = WINED3DSP_NOSWIZZLE; if (shader_version < WINED3D_SHADER_VERSION(2,0)) swizzle = WINED3DSP_NOSWIZZLE;
else swizzle = ins->src[1].swizzle; else swizzle = ins->src[1].swizzle;
/* 1.0-1.3: Use destination register as coordinate source. /* 1.0-1.3: Use destination register as coordinate source.
1.4+: Use provided coordinate source register. */ 1.4+: Use provided coordinate source register. */
if (shader_version < WINED3DPS_VERSION(1,4)) if (shader_version < WINED3D_SHADER_VERSION(1,4))
{ {
char coord_mask[6]; char coord_mask[6];
shader_glsl_write_mask_to_str(mask, coord_mask); shader_glsl_write_mask_to_str(mask, coord_mask);
@ -2611,7 +2612,7 @@ static void shader_glsl_texldl(const struct wined3d_shader_instruction *ins)
shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &lod_param); shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &lod_param);
if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version)) if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
{ {
/* The GLSL spec claims the Lod sampling functions are only supported in vertex shaders. /* The GLSL spec claims the Lod sampling functions are only supported in vertex shaders.
* However, they seem to work just fine in fragment shaders as well. */ * However, they seem to work just fine in fragment shaders as well. */
@ -2627,7 +2628,7 @@ static void pshader_glsl_texcoord(const struct wined3d_shader_instruction *ins)
SHADER_BUFFER *buffer = ins->ctx->buffer; SHADER_BUFFER *buffer = ins->ctx->buffer;
DWORD write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins); DWORD write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
if (ins->ctx->reg_maps->shader_version != WINED3DPS_VERSION(1,4)) if (!(ins->ctx->reg_maps->shader_version.major == 1 && ins->ctx->reg_maps->shader_version.minor == 4))
{ {
char dst_mask[6]; char dst_mask[6];
@ -3055,7 +3056,7 @@ static void pshader_glsl_texkill(const struct wined3d_shader_instruction *ins)
/* The argument is a destination parameter, and no writemasks are allowed */ /* The argument is a destination parameter, and no writemasks are allowed */
shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param); shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
if ((ins->ctx->reg_maps->shader_version >= WINED3DPS_VERSION(2,0))) if (ins->ctx->reg_maps->shader_version.major >= 2)
{ {
/* 2.0 shaders compare all 4 components in texkill */ /* 2.0 shaders compare all 4 components in texkill */
shader_addline(ins->ctx->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name); shader_addline(ins->ctx->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name);
@ -3346,8 +3347,8 @@ static GLhandleARB generate_param_reorder_function(IWineD3DVertexShader *vertexs
IWineD3DVertexShaderImpl *vs = (IWineD3DVertexShaderImpl *) vertexshader; IWineD3DVertexShaderImpl *vs = (IWineD3DVertexShaderImpl *) vertexshader;
IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) pixelshader; IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) pixelshader;
IWineD3DDeviceImpl *device; IWineD3DDeviceImpl *device;
DWORD vs_major = WINED3DSHADER_VERSION_MAJOR(vs->baseShader.reg_maps.shader_version); DWORD vs_major = vs->baseShader.reg_maps.shader_version.major;
DWORD ps_major = ps ? WINED3DSHADER_VERSION_MAJOR(ps->baseShader.reg_maps.shader_version) : 0; DWORD ps_major = ps ? ps->baseShader.reg_maps.shader_version.major : 0;
unsigned int i; unsigned int i;
SHADER_BUFFER buffer; SHADER_BUFFER buffer;
DWORD usage, usage_idx, writemask; DWORD usage, usage_idx, writemask;
@ -3672,7 +3673,7 @@ static void set_glsl_shader_program(IWineD3DDevice *iface, BOOL use_ps, BOOL use
checkGLcall("Find glsl program uniform locations"); checkGLcall("Find glsl program uniform locations");
if (pshader if (pshader
&& WINED3DSHADER_VERSION_MAJOR(((IWineD3DPixelShaderImpl *)pshader)->baseShader.reg_maps.shader_version) >= 3 && ((IWineD3DPixelShaderImpl *)pshader)->baseShader.reg_maps.shader_version.major >= 3
&& ((IWineD3DPixelShaderImpl *)pshader)->declared_in_count > GL_LIMITS(glsl_varyings) / 4) && ((IWineD3DPixelShaderImpl *)pshader)->declared_in_count > GL_LIMITS(glsl_varyings) / 4)
{ {
TRACE("Shader %d needs vertex color clamping disabled\n", programId); TRACE("Shader %d needs vertex color clamping disabled\n", programId);
@ -3859,7 +3860,7 @@ static void shader_glsl_destroy(IWineD3DBaseShader *iface) {
/* Note: Do not use QueryInterface here to find out which shader type this is because this code /* Note: Do not use QueryInterface here to find out which shader type this is because this code
* can be called from IWineD3DBaseShader::Release * can be called from IWineD3DBaseShader::Release
*/ */
char pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version); char pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type);
if(pshader) { if(pshader) {
ps = (IWineD3DPixelShaderImpl *) This; ps = (IWineD3DPixelShaderImpl *) This;
@ -4066,7 +4067,8 @@ static GLuint shader_glsl_generate_pshader(IWineD3DPixelShader *iface,
shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION, args); shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION, args);
/* Pack 3.0 inputs */ /* Pack 3.0 inputs */
if (reg_maps->shader_version >= WINED3DPS_VERSION(3,0) && args->vp_mode != vertexshader) { if (reg_maps->shader_version.major >= 3 && args->vp_mode != vertexshader)
{
pshader_glsl_input_pack(iface, buffer, This->semantics_in, reg_maps, args->vp_mode); pshader_glsl_input_pack(iface, buffer, This->semantics_in, reg_maps, args->vp_mode);
} }
@ -4074,7 +4076,7 @@ static GLuint shader_glsl_generate_pshader(IWineD3DPixelShader *iface,
shader_generate_main((IWineD3DBaseShader *)This, buffer, reg_maps, function); shader_generate_main((IWineD3DBaseShader *)This, buffer, reg_maps, function);
/* Pixel shaders < 2.0 place the resulting color in R0 implicitly */ /* Pixel shaders < 2.0 place the resulting color in R0 implicitly */
if (reg_maps->shader_version < WINED3DPS_VERSION(2,0)) if (reg_maps->shader_version.major < 2)
{ {
/* Some older cards like GeforceFX ones don't support multiple buffers, so also not gl_FragData */ /* Some older cards like GeforceFX ones don't support multiple buffers, so also not gl_FragData */
if(GL_SUPPORT(ARB_DRAW_BUFFERS)) if(GL_SUPPORT(ARB_DRAW_BUFFERS))
@ -4104,7 +4106,8 @@ static GLuint shader_glsl_generate_pshader(IWineD3DPixelShader *iface,
* NOTE: gl_Fog.start and gl_Fog.end don't hold fog start s and end e but * NOTE: gl_Fog.start and gl_Fog.end don't hold fog start s and end e but
* -1/(e-s) and e/(e-s) respectively. * -1/(e-s) and e/(e-s) respectively.
*/ */
if(reg_maps->shader_version < WINED3DPS_VERSION(3,0)) { if (reg_maps->shader_version.major < 3)
{
switch(args->fog) { switch(args->fog) {
case FOG_OFF: break; case FOG_OFF: break;
case FOG_LINEAR: case FOG_LINEAR:
@ -4159,7 +4162,7 @@ static GLuint shader_glsl_generate_vshader(IWineD3DVertexShader *iface,
shader_generate_main((IWineD3DBaseShader*)This, buffer, reg_maps, function); shader_generate_main((IWineD3DBaseShader*)This, buffer, reg_maps, function);
/* Unpack 3.0 outputs */ /* Unpack 3.0 outputs */
if (reg_maps->shader_version >= WINED3DVS_VERSION(3,0)) shader_addline(buffer, "order_ps_input(OUT);\n"); if (reg_maps->shader_version.major >= 3) shader_addline(buffer, "order_ps_input(OUT);\n");
else shader_addline(buffer, "order_ps_input();\n"); else shader_addline(buffer, "order_ps_input();\n");
/* The D3DRS_FOGTABLEMODE render state defines if the shader-generated fog coord is used /* The D3DRS_FOGTABLEMODE render state defines if the shader-generated fog coord is used

31
dlls/wined3d/pixelshader.c
View File

@ -122,16 +122,19 @@ static HRESULT WINAPI IWineD3DPixelShaderImpl_GetFunction(IWineD3DPixelShader*
static void pshader_set_limits(IWineD3DPixelShaderImpl *This) static void pshader_set_limits(IWineD3DPixelShaderImpl *This)
{ {
DWORD shader_version = WINED3D_SHADER_VERSION(This->baseShader.reg_maps.shader_version.major,
This->baseShader.reg_maps.shader_version.minor);
This->baseShader.limits.attributes = 0; This->baseShader.limits.attributes = 0;
This->baseShader.limits.address = 0; This->baseShader.limits.address = 0;
This->baseShader.limits.packed_output = 0; This->baseShader.limits.packed_output = 0;
switch (This->baseShader.reg_maps.shader_version) switch (shader_version)
{ {
case WINED3DPS_VERSION(1,0): case WINED3D_SHADER_VERSION(1,0):
case WINED3DPS_VERSION(1,1): case WINED3D_SHADER_VERSION(1,1):
case WINED3DPS_VERSION(1,2): case WINED3D_SHADER_VERSION(1,2):
case WINED3DPS_VERSION(1,3): case WINED3D_SHADER_VERSION(1,3):
This->baseShader.limits.temporary = 2; This->baseShader.limits.temporary = 2;
This->baseShader.limits.constant_float = 8; This->baseShader.limits.constant_float = 8;
This->baseShader.limits.constant_int = 0; This->baseShader.limits.constant_int = 0;
@ -142,7 +145,7 @@ static void pshader_set_limits(IWineD3DPixelShaderImpl *This)
This->baseShader.limits.label = 0; This->baseShader.limits.label = 0;
break; break;
case WINED3DPS_VERSION(1,4): case WINED3D_SHADER_VERSION(1,4):
This->baseShader.limits.temporary = 6; This->baseShader.limits.temporary = 6;
This->baseShader.limits.constant_float = 8; This->baseShader.limits.constant_float = 8;
This->baseShader.limits.constant_int = 0; This->baseShader.limits.constant_int = 0;
@ -154,7 +157,7 @@ static void pshader_set_limits(IWineD3DPixelShaderImpl *This)
break; break;
/* FIXME: temporaries must match D3DPSHADERCAPS2_0.NumTemps */ /* FIXME: temporaries must match D3DPSHADERCAPS2_0.NumTemps */
case WINED3DPS_VERSION(2,0): case WINED3D_SHADER_VERSION(2,0):
This->baseShader.limits.temporary = 32; This->baseShader.limits.temporary = 32;
This->baseShader.limits.constant_float = 32; This->baseShader.limits.constant_float = 32;
This->baseShader.limits.constant_int = 16; This->baseShader.limits.constant_int = 16;
@ -164,7 +167,7 @@ static void pshader_set_limits(IWineD3DPixelShaderImpl *This)
This->baseShader.limits.packed_input = 0; This->baseShader.limits.packed_input = 0;
break; break;
case WINED3DPS_VERSION(2,1): case WINED3D_SHADER_VERSION(2,1):
This->baseShader.limits.temporary = 32; This->baseShader.limits.temporary = 32;
This->baseShader.limits.constant_float = 32; This->baseShader.limits.constant_float = 32;
This->baseShader.limits.constant_int = 16; This->baseShader.limits.constant_int = 16;
@ -175,7 +178,7 @@ static void pshader_set_limits(IWineD3DPixelShaderImpl *This)
This->baseShader.limits.label = 16; This->baseShader.limits.label = 16;
break; break;
case WINED3DPS_VERSION(3,0): case WINED3D_SHADER_VERSION(3,0):
This->baseShader.limits.temporary = 32; This->baseShader.limits.temporary = 32;
This->baseShader.limits.constant_float = 224; This->baseShader.limits.constant_float = 224;
This->baseShader.limits.constant_int = 16; This->baseShader.limits.constant_int = 16;
@ -195,8 +198,9 @@ static void pshader_set_limits(IWineD3DPixelShaderImpl *This)
This->baseShader.limits.sampler = 16; This->baseShader.limits.sampler = 16;
This->baseShader.limits.packed_input = 0; This->baseShader.limits.packed_input = 0;
This->baseShader.limits.label = 0; This->baseShader.limits.label = 0;
FIXME("Unrecognized pixel shader version %#x\n", FIXME("Unrecognized pixel shader version %u.%u\n",
This->baseShader.reg_maps.shader_version); This->baseShader.reg_maps.shader_version.major,
This->baseShader.reg_maps.shader_version.minor);
} }
} }
@ -293,11 +297,10 @@ static HRESULT WINAPI IWineD3DPixelShaderImpl_SetFunction(IWineD3DPixelShader *i
static void pixelshader_update_samplers(struct shader_reg_maps *reg_maps, IWineD3DBaseTexture * const *textures) static void pixelshader_update_samplers(struct shader_reg_maps *reg_maps, IWineD3DBaseTexture * const *textures)
{ {
DWORD shader_version = reg_maps->shader_version;
WINED3DSAMPLER_TEXTURE_TYPE *sampler_type = reg_maps->sampler_type; WINED3DSAMPLER_TEXTURE_TYPE *sampler_type = reg_maps->sampler_type;
unsigned int i; unsigned int i;
if (WINED3DSHADER_VERSION_MAJOR(shader_version) != 1) return; if (reg_maps->shader_version.major != 1) return;
for (i = 0; i < max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS); ++i) for (i = 0; i < max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS); ++i)
{ {
@ -396,7 +399,7 @@ void find_ps_compile_args(IWineD3DPixelShaderImpl *shader, IWineD3DStateBlockImp
args->np2_fixup |= (1 << i); args->np2_fixup |= (1 << i);
} }
} }
if (shader->baseShader.reg_maps.shader_version >= WINED3DPS_VERSION(3,0)) if (shader->baseShader.reg_maps.shader_version.major >= 3)
{ {
if (((IWineD3DDeviceImpl *)shader->baseShader.device)->strided_streams.position_transformed) if (((IWineD3DDeviceImpl *)shader->baseShader.device)->strided_streams.position_transformed)
{ {

335
dlls/wined3d/shader_sm1.c
View File

@ -90,6 +90,9 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
#define WINED3DSP_END 0x0000ffff #define WINED3DSP_END 0x0000ffff
#define WINED3D_SM1_VERSION_MAJOR(version) (((version) >> 8) & 0xff)
#define WINED3D_SM1_VERSION_MINOR(version) (((version) >> 0) & 0xff)
enum WINED3DSHADER_ADDRESSMODE_TYPE enum WINED3DSHADER_ADDRESSMODE_TYPE
{ {
WINED3DSHADER_ADDRMODE_ABSOLUTE = 0 << WINED3DSHADER_ADDRESSMODE_SHIFT, WINED3DSHADER_ADDRMODE_ABSOLUTE = 0 << WINED3DSHADER_ADDRESSMODE_SHIFT,
@ -108,7 +111,7 @@ struct wined3d_sm1_opcode_info
struct wined3d_sm1_data struct wined3d_sm1_data
{ {
DWORD shader_version; struct wined3d_shader_version shader_version;
const struct wined3d_sm1_opcode_info *opcode_table; const struct wined3d_sm1_opcode_info *opcode_table;
}; };
@ -116,169 +119,169 @@ struct wined3d_sm1_data
static const struct wined3d_sm1_opcode_info vs_opcode_table[] = static const struct wined3d_sm1_opcode_info vs_opcode_table[] =
{ {
/* Arithmetic */ /* Arithmetic */
{WINED3DSIO_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 }, {WINED3DSIO_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 },
{WINED3DSIO_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 }, {WINED3DSIO_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 },
{WINED3DSIO_MOVA, 1, 2, WINED3DSIH_MOVA, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_MOVA, 1, 2, WINED3DSIH_MOVA, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 }, {WINED3DSIO_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 },
{WINED3DSIO_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 }, {WINED3DSIO_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 },
{WINED3DSIO_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 }, {WINED3DSIO_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 },
{WINED3DSIO_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 }, {WINED3DSIO_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 },
{WINED3DSIO_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 }, {WINED3DSIO_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 },
{WINED3DSIO_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 }, {WINED3DSIO_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 },
{WINED3DSIO_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 }, {WINED3DSIO_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 },
{WINED3DSIO_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 }, {WINED3DSIO_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 },
{WINED3DSIO_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 }, {WINED3DSIO_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 },
{WINED3DSIO_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 }, {WINED3DSIO_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 },
{WINED3DSIO_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 }, {WINED3DSIO_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 },
{WINED3DSIO_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 }, {WINED3DSIO_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 },
{WINED3DSIO_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 }, {WINED3DSIO_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 },
{WINED3DSIO_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 }, {WINED3DSIO_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 },
{WINED3DSIO_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 }, {WINED3DSIO_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 },
{WINED3DSIO_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 }, {WINED3DSIO_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 },
{WINED3DSIO_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 }, {WINED3DSIO_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 },
{WINED3DSIO_LIT, 1, 2, WINED3DSIH_LIT, 0, 0 }, {WINED3DSIO_LIT, 1, 2, WINED3DSIH_LIT, 0, 0 },
{WINED3DSIO_DST, 1, 3, WINED3DSIH_DST, 0, 0 }, {WINED3DSIO_DST, 1, 3, WINED3DSIH_DST, 0, 0 },
{WINED3DSIO_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 }, {WINED3DSIO_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 },
{WINED3DSIO_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 }, {WINED3DSIO_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 },
{WINED3DSIO_POW, 1, 3, WINED3DSIH_POW, 0, 0 }, {WINED3DSIO_POW, 1, 3, WINED3DSIH_POW, 0, 0 },
{WINED3DSIO_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 }, {WINED3DSIO_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 },
{WINED3DSIO_SGN, 1, 2, WINED3DSIH_SGN, 0, 0 }, {WINED3DSIO_SGN, 1, 2, WINED3DSIH_SGN, 0, 0 },
{WINED3DSIO_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 }, {WINED3DSIO_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 },
{WINED3DSIO_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3DVS_VERSION(2,0), WINED3DVS_VERSION(2,1)}, {WINED3DSIO_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
{WINED3DSIO_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3DVS_VERSION(3,0), -1 }, {WINED3DSIO_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(3,0), -1 },
/* Matrix */ /* Matrix */
{WINED3DSIO_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 }, {WINED3DSIO_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 },
{WINED3DSIO_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 }, {WINED3DSIO_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 },
{WINED3DSIO_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 }, {WINED3DSIO_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 },
{WINED3DSIO_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 }, {WINED3DSIO_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 },
{WINED3DSIO_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 }, {WINED3DSIO_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 },
/* Declare registers */ /* Declare registers */
{WINED3DSIO_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 }, {WINED3DSIO_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 },
/* Constant definitions */ /* Constant definitions */
{WINED3DSIO_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 }, {WINED3DSIO_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 },
{WINED3DSIO_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 }, {WINED3DSIO_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 },
{WINED3DSIO_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 }, {WINED3DSIO_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 },
/* Flow control */ /* Flow control */
{WINED3DSIO_REP, 0, 1, WINED3DSIH_REP, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_REP, 0, 1, WINED3DSIH_REP, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_IF, 0, 1, WINED3DSIH_IF, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_IF, 0, 1, WINED3DSIH_IF, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_IFC, 0, 2, WINED3DSIH_IFC, WINED3DVS_VERSION(2,1), -1 }, {WINED3DSIO_IFC, 0, 2, WINED3DSIH_IFC, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3DVS_VERSION(2,1), -1 }, {WINED3DSIO_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3DVS_VERSION(2,1), -1 }, {WINED3DSIO_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 }, {WINED3DSIO_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 },
{WINED3DSIO_CALL, 0, 1, WINED3DSIH_CALL, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_CALL, 0, 1, WINED3DSIH_CALL, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_RET, 0, 0, WINED3DSIH_RET, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_RET, 0, 0, WINED3DSIH_RET, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3DVS_VERSION(2,0), -1 }, {WINED3DSIO_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 }, {WINED3DSIO_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 },
{WINED3DSIO_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3DVS_VERSION(3,0), -1 }, {WINED3DSIO_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3D_SHADER_VERSION(3,0), -1 },
{0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 }, {0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 },
}; };
static const struct wined3d_sm1_opcode_info ps_opcode_table[] = static const struct wined3d_sm1_opcode_info ps_opcode_table[] =
{ {
/* Arithmetic */ /* Arithmetic */
{WINED3DSIO_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 }, {WINED3DSIO_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 },
{WINED3DSIO_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 }, {WINED3DSIO_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 },
{WINED3DSIO_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 }, {WINED3DSIO_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 },
{WINED3DSIO_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 }, {WINED3DSIO_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 },
{WINED3DSIO_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 }, {WINED3DSIO_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 },
{WINED3DSIO_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 }, {WINED3DSIO_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 },
{WINED3DSIO_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 }, {WINED3DSIO_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 },
{WINED3DSIO_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 }, {WINED3DSIO_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 },
{WINED3DSIO_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 }, {WINED3DSIO_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 },
{WINED3DSIO_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 }, {WINED3DSIO_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 },
{WINED3DSIO_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 }, {WINED3DSIO_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 },
{WINED3DSIO_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 }, {WINED3DSIO_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 },
{WINED3DSIO_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 }, {WINED3DSIO_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 },
{WINED3DSIO_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 }, {WINED3DSIO_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 },
{WINED3DSIO_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 }, {WINED3DSIO_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 },
{WINED3DSIO_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 }, {WINED3DSIO_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 },
{WINED3DSIO_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 }, {WINED3DSIO_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 },
{WINED3DSIO_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 }, {WINED3DSIO_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 },
{WINED3DSIO_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 }, {WINED3DSIO_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 },
{WINED3DSIO_DST, 1, 3, WINED3DSIH_DST, 0, 0 }, {WINED3DSIO_DST, 1, 3, WINED3DSIH_DST, 0, 0 },
{WINED3DSIO_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 }, {WINED3DSIO_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 },
{WINED3DSIO_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 }, {WINED3DSIO_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 },
{WINED3DSIO_CND, 1, 4, WINED3DSIH_CND, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,4)}, {WINED3DSIO_CND, 1, 4, WINED3DSIH_CND, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,4)},
{WINED3DSIO_CMP, 1, 4, WINED3DSIH_CMP, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(3,0)}, {WINED3DSIO_CMP, 1, 4, WINED3DSIH_CMP, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(3,0)},
{WINED3DSIO_POW, 1, 3, WINED3DSIH_POW, 0, 0 }, {WINED3DSIO_POW, 1, 3, WINED3DSIH_POW, 0, 0 },
{WINED3DSIO_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 }, {WINED3DSIO_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 },
{WINED3DSIO_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 }, {WINED3DSIO_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 },
{WINED3DSIO_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3DPS_VERSION(2,0), WINED3DPS_VERSION(2,1)}, {WINED3DSIO_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
{WINED3DSIO_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3DPS_VERSION(3,0), -1 }, {WINED3DSIO_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3DSIO_DP2ADD, 1, 4, WINED3DSIH_DP2ADD, WINED3DPS_VERSION(2,0), -1 }, {WINED3DSIO_DP2ADD, 1, 4, WINED3DSIH_DP2ADD, WINED3D_SHADER_VERSION(2,0), -1 },
/* Matrix */ /* Matrix */
{WINED3DSIO_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 }, {WINED3DSIO_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 },
{WINED3DSIO_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 }, {WINED3DSIO_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 },
{WINED3DSIO_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 }, {WINED3DSIO_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 },
{WINED3DSIO_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 }, {WINED3DSIO_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 },
{WINED3DSIO_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 }, {WINED3DSIO_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 },
/* Register declarations */ /* Register declarations */
{WINED3DSIO_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 }, {WINED3DSIO_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 },
/* Flow control */ /* Flow control */
{WINED3DSIO_REP, 0, 1, WINED3DSIH_REP, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_REP, 0, 1, WINED3DSIH_REP, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_IF, 0, 1, WINED3DSIH_IF, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_IF, 0, 1, WINED3DSIH_IF, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_IFC, 0, 2, WINED3DSIH_IFC, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_IFC, 0, 2, WINED3DSIH_IFC, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 }, {WINED3DSIO_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 },
{WINED3DSIO_CALL, 0, 1, WINED3DSIH_CALL, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_CALL, 0, 1, WINED3DSIH_CALL, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3DPS_VERSION(3,0), -1 }, {WINED3DSIO_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3DSIO_RET, 0, 0, WINED3DSIH_RET, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_RET, 0, 0, WINED3DSIH_RET, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3DPS_VERSION(3,0), -1 }, {WINED3DSIO_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3DSIO_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3D_SHADER_VERSION(2,1), -1 },
/* Constant definitions */ /* Constant definitions */
{WINED3DSIO_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 }, {WINED3DSIO_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 },
{WINED3DSIO_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 }, {WINED3DSIO_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 },
{WINED3DSIO_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 }, {WINED3DSIO_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 },
/* Texture */ /* Texture */
{WINED3DSIO_TEXCOORD, 1, 1, WINED3DSIH_TEXCOORD, 0, WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXCOORD, 1, 1, WINED3DSIH_TEXCOORD, 0, WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXCOORD, 1, 2, WINED3DSIH_TEXCOORD, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)}, {WINED3DSIO_TEXCOORD, 1, 2, WINED3DSIH_TEXCOORD, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
{WINED3DSIO_TEXKILL, 1, 1, WINED3DSIH_TEXKILL, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(3,0)}, {WINED3DSIO_TEXKILL, 1, 1, WINED3DSIH_TEXKILL, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(3,0)},
{WINED3DSIO_TEX, 1, 1, WINED3DSIH_TEX, 0, WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEX, 1, 1, WINED3DSIH_TEX, 0, WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEX, 1, 2, WINED3DSIH_TEX, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)}, {WINED3DSIO_TEX, 1, 2, WINED3DSIH_TEX, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
{WINED3DSIO_TEX, 1, 3, WINED3DSIH_TEX, WINED3DPS_VERSION(2,0), -1 }, {WINED3DSIO_TEX, 1, 3, WINED3DSIH_TEX, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3DSIO_TEXBEM, 1, 2, WINED3DSIH_TEXBEM, 0, WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXBEM, 1, 2, WINED3DSIH_TEXBEM, 0, WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXBEML, 1, 2, WINED3DSIH_TEXBEML, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXBEML, 1, 2, WINED3DSIH_TEXBEML, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXREG2AR, 1, 2, WINED3DSIH_TEXREG2AR, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXREG2AR, 1, 2, WINED3DSIH_TEXREG2AR, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXREG2GB, 1, 2, WINED3DSIH_TEXREG2GB, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXREG2GB, 1, 2, WINED3DSIH_TEXREG2GB, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXREG2RGB, 1, 2, WINED3DSIH_TEXREG2RGB, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXREG2RGB, 1, 2, WINED3DSIH_TEXREG2RGB, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXM3x2PAD, 1, 2, WINED3DSIH_TEXM3x2PAD, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXM3x2PAD, 1, 2, WINED3DSIH_TEXM3x2PAD, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXM3x2TEX, 1, 2, WINED3DSIH_TEXM3x2TEX, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXM3x2TEX, 1, 2, WINED3DSIH_TEXM3x2TEX, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXM3x3PAD, 1, 2, WINED3DSIH_TEXM3x3PAD, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXM3x3PAD, 1, 2, WINED3DSIH_TEXM3x3PAD, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXM3x3DIFF, 1, 2, WINED3DSIH_TEXM3x3DIFF, WINED3DPS_VERSION(0,0), WINED3DPS_VERSION(0,0)}, {WINED3DSIO_TEXM3x3DIFF, 1, 2, WINED3DSIH_TEXM3x3DIFF, WINED3D_SHADER_VERSION(0,0), WINED3D_SHADER_VERSION(0,0)},
{WINED3DSIO_TEXM3x3SPEC, 1, 3, WINED3DSIH_TEXM3x3SPEC, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXM3x3SPEC, 1, 3, WINED3DSIH_TEXM3x3SPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXM3x3VSPEC, 1, 2, WINED3DSIH_TEXM3x3VSPEC, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXM3x3VSPEC, 1, 2, WINED3DSIH_TEXM3x3VSPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXM3x3TEX, 1, 2, WINED3DSIH_TEXM3x3TEX, WINED3DPS_VERSION(1,0), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXM3x3TEX, 1, 2, WINED3DSIH_TEXM3x3TEX, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXDP3TEX, 1, 2, WINED3DSIH_TEXDP3TEX, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXDP3TEX, 1, 2, WINED3DSIH_TEXDP3TEX, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXM3x2DEPTH, 1, 2, WINED3DSIH_TEXM3x2DEPTH, WINED3DPS_VERSION(1,3), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXM3x2DEPTH, 1, 2, WINED3DSIH_TEXM3x2DEPTH, WINED3D_SHADER_VERSION(1,3), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXDP3, 1, 2, WINED3DSIH_TEXDP3, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXDP3, 1, 2, WINED3DSIH_TEXDP3, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXM3x3, 1, 2, WINED3DSIH_TEXM3x3, WINED3DPS_VERSION(1,2), WINED3DPS_VERSION(1,3)}, {WINED3DSIO_TEXM3x3, 1, 2, WINED3DSIH_TEXM3x3, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
{WINED3DSIO_TEXDEPTH, 1, 1, WINED3DSIH_TEXDEPTH, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)}, {WINED3DSIO_TEXDEPTH, 1, 1, WINED3DSIH_TEXDEPTH, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
{WINED3DSIO_BEM, 1, 3, WINED3DSIH_BEM, WINED3DPS_VERSION(1,4), WINED3DPS_VERSION(1,4)}, {WINED3DSIO_BEM, 1, 3, WINED3DSIH_BEM, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
{WINED3DSIO_DSX, 1, 2, WINED3DSIH_DSX, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_DSX, 1, 2, WINED3DSIH_DSX, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_DSY, 1, 2, WINED3DSIH_DSY, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_DSY, 1, 2, WINED3DSIH_DSY, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_TEXLDD, 1, 5, WINED3DSIH_TEXLDD, WINED3DPS_VERSION(2,1), -1 }, {WINED3DSIO_TEXLDD, 1, 5, WINED3DSIH_TEXLDD, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3DSIO_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 }, {WINED3DSIO_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 },
{WINED3DSIO_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3DPS_VERSION(3,0), -1 }, {WINED3DSIO_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3DSIO_PHASE, 0, 0, WINED3DSIH_PHASE, 0, 0 }, {WINED3DSIO_PHASE, 0, 0, WINED3DSIH_PHASE, 0, 0 },
{0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 }, {0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 },
}; };
/* Read a parameter opcode from the input stream, /* Read a parameter opcode from the input stream,
* and possibly a relative addressing token. * and possibly a relative addressing token.
* Return the number of tokens read */ * Return the number of tokens read */
static int shader_get_param(const DWORD *ptr, DWORD shader_version, DWORD *token, DWORD *addr_token) static int shader_get_param(const struct wined3d_sm1_data *priv, const DWORD *ptr, DWORD *token, DWORD *addr_token)
{ {
UINT count = 1; UINT count = 1;
@ -290,7 +293,7 @@ static int shader_get_param(const DWORD *ptr, DWORD shader_version, DWORD *token
* The version check below should work in general */ * The version check below should work in general */
if (*ptr & WINED3DSHADER_ADDRMODE_RELATIVE) if (*ptr & WINED3DSHADER_ADDRMODE_RELATIVE)
{ {
if (WINED3DSHADER_VERSION_MAJOR(shader_version) < 2) if (priv->shader_version.major < 2)
{ {
*addr_token = (1 << 31) *addr_token = (1 << 31)
| ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT2) & WINED3DSP_REGTYPE_MASK2) | ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT2) & WINED3DSP_REGTYPE_MASK2)
@ -307,9 +310,10 @@ static int shader_get_param(const DWORD *ptr, DWORD shader_version, DWORD *token
return count; return count;
} }
static const struct wined3d_sm1_opcode_info *shader_get_opcode(const struct wined3d_sm1_opcode_info *opcode_table, static const struct wined3d_sm1_opcode_info *shader_get_opcode(const struct wined3d_sm1_data *priv, DWORD code)
DWORD shader_version, DWORD code)
{ {
DWORD shader_version = WINED3D_SHADER_VERSION(priv->shader_version.major, priv->shader_version.minor);
const struct wined3d_sm1_opcode_info *opcode_table = priv->opcode_table;
DWORD i = 0; DWORD i = 0;
while (opcode_table[i].handler_idx != WINED3DSIH_TABLE_SIZE) while (opcode_table[i].handler_idx != WINED3DSIH_TABLE_SIZE)
@ -330,12 +334,12 @@ static const struct wined3d_sm1_opcode_info *shader_get_opcode(const struct wine
} }
/* Return the number of parameters to skip for an opcode */ /* Return the number of parameters to skip for an opcode */
static int shader_skip_opcode(const struct wined3d_sm1_opcode_info *opcode_info, static int shader_skip_opcode(const struct wined3d_sm1_data *priv,
DWORD opcode_token, DWORD shader_version) const struct wined3d_sm1_opcode_info *opcode_info, DWORD opcode_token)
{ {
/* Shaders >= 2.0 may contain address tokens, but fortunately they /* Shaders >= 2.0 may contain address tokens, but fortunately they
* have a useful length mask - use it here. Shaders 1.0 contain no such tokens */ * have a useful length mask - use it here. Shaders 1.0 contain no such tokens */
return (WINED3DSHADER_VERSION_MAJOR(shader_version) >= 2) return (priv->shader_version.major >= 2)
? ((opcode_token & WINED3DSI_INSTLENGTH_MASK) >> WINED3DSI_INSTLENGTH_SHIFT) : opcode_info->param_count; ? ((opcode_token & WINED3DSI_INSTLENGTH_MASK) >> WINED3DSI_INSTLENGTH_SHIFT) : opcode_info->param_count;
} }
@ -368,7 +372,7 @@ static void shader_parse_dst_param(DWORD param, const struct wined3d_shader_src_
* Note: This function assumes source or destination token format. * Note: This function assumes source or destination token format.
* It will not work with specially-formatted tokens like DEF or DCL, * It will not work with specially-formatted tokens like DEF or DCL,
* but hopefully those would be recognized */ * but hopefully those would be recognized */
static int shader_skip_unrecognized(const DWORD *ptr, DWORD shader_version) static int shader_skip_unrecognized(const struct wined3d_sm1_data *priv, const DWORD *ptr)
{ {
int tokens_read = 0; int tokens_read = 0;
int i = 0; int i = 0;
@ -379,7 +383,7 @@ static int shader_skip_unrecognized(const DWORD *ptr, DWORD shader_version)
DWORD token, addr_token = 0; DWORD token, addr_token = 0;
struct wined3d_shader_src_param rel_addr; struct wined3d_shader_src_param rel_addr;
tokens_read += shader_get_param(ptr, shader_version, &token, &addr_token); tokens_read += shader_get_param(priv, ptr, &token, &addr_token);
ptr += tokens_read; ptr += tokens_read;
FIXME("Unrecognized opcode param: token=0x%08x addr_token=0x%08x name=", token, addr_token); FIXME("Unrecognized opcode param: token=0x%08x addr_token=0x%08x name=", token, addr_token);
@ -391,14 +395,14 @@ static int shader_skip_unrecognized(const DWORD *ptr, DWORD shader_version)
struct wined3d_shader_dst_param dst; struct wined3d_shader_dst_param dst;
shader_parse_dst_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &dst); shader_parse_dst_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &dst);
shader_dump_dst_param(&dst, shader_version); shader_dump_dst_param(&dst, &priv->shader_version);
} }
else else
{ {
struct wined3d_shader_src_param src; struct wined3d_shader_src_param src;
shader_parse_src_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &src); shader_parse_src_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &src);
shader_dump_src_param(&src, shader_version); shader_dump_src_param(&src, &priv->shader_version);
} }
FIXME("\n"); FIXME("\n");
++i; ++i;
@ -418,10 +422,12 @@ static void *shader_sm1_init(const DWORD *byte_code)
switch (*byte_code >> 16) switch (*byte_code >> 16)
{ {
case WINED3D_SM1_VS: case WINED3D_SM1_VS:
priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX;
priv->opcode_table = vs_opcode_table; priv->opcode_table = vs_opcode_table;
break; break;
case WINED3D_SM1_PS: case WINED3D_SM1_PS:
priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL;
priv->opcode_table = ps_opcode_table; priv->opcode_table = ps_opcode_table;
break; break;
@ -439,14 +445,17 @@ static void shader_sm1_free(void *data)
HeapFree(GetProcessHeap(), 0, data); HeapFree(GetProcessHeap(), 0, data);
} }
static void shader_sm1_read_header(void *data, const DWORD **ptr, DWORD *shader_version) static void shader_sm1_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
{ {
struct wined3d_sm1_data *priv = data; struct wined3d_sm1_data *priv = data;
DWORD version_token;
TRACE("version: 0x%08x\n", **ptr); version_token = *(*ptr)++;
*shader_version = *(*ptr)++; TRACE("version: 0x%08x\n", version_token);
priv->shader_version = *shader_version; priv->shader_version.major = WINED3D_SM1_VERSION_MAJOR(version_token);
priv->shader_version.minor = WINED3D_SM1_VERSION_MINOR(version_token);
*shader_version = priv->shader_version;
} }
static void shader_sm1_read_opcode(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins, static void shader_sm1_read_opcode(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins,
@ -457,12 +466,12 @@ static void shader_sm1_read_opcode(void *data, const DWORD **ptr, struct wined3d
DWORD opcode_token; DWORD opcode_token;
opcode_token = *(*ptr)++; opcode_token = *(*ptr)++;
opcode_info = shader_get_opcode(priv->opcode_table, priv->shader_version, opcode_token); opcode_info = shader_get_opcode(priv, opcode_token);
if (!opcode_info) if (!opcode_info)
{ {
FIXME("Unrecognized opcode: token=0x%08x\n", opcode_token); FIXME("Unrecognized opcode: token=0x%08x\n", opcode_token);
ins->handler_idx = WINED3DSIH_TABLE_SIZE; ins->handler_idx = WINED3DSIH_TABLE_SIZE;
*param_size = shader_skip_unrecognized(*ptr, priv->shader_version); *param_size = shader_skip_unrecognized(priv, *ptr);
return; return;
} }
@ -472,7 +481,7 @@ static void shader_sm1_read_opcode(void *data, const DWORD **ptr, struct wined3d
ins->predicate = opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED; ins->predicate = opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED;
ins->dst_count = opcode_info->dst_count ? 1 : 0; ins->dst_count = opcode_info->dst_count ? 1 : 0;
ins->src_count = opcode_info->param_count - opcode_info->dst_count; ins->src_count = opcode_info->param_count - opcode_info->dst_count;
*param_size = shader_skip_opcode(opcode_info, opcode_token, priv->shader_version); *param_size = shader_skip_opcode(priv, opcode_info, opcode_token);
} }
static void shader_sm1_read_src_param(void *data, const DWORD **ptr, struct wined3d_shader_src_param *src_param, static void shader_sm1_read_src_param(void *data, const DWORD **ptr, struct wined3d_shader_src_param *src_param,
@ -481,7 +490,7 @@ static void shader_sm1_read_src_param(void *data, const DWORD **ptr, struct wine
struct wined3d_sm1_data *priv = data; struct wined3d_sm1_data *priv = data;
DWORD token, addr_token; DWORD token, addr_token;
*ptr += shader_get_param(*ptr, priv->shader_version, &token, &addr_token); *ptr += shader_get_param(priv, *ptr, &token, &addr_token);
if (token & WINED3DSHADER_ADDRMODE_RELATIVE) if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
{ {
shader_parse_src_param(addr_token, NULL, src_rel_addr); shader_parse_src_param(addr_token, NULL, src_rel_addr);
@ -499,7 +508,7 @@ static void shader_sm1_read_dst_param(void *data, const DWORD **ptr, struct wine
struct wined3d_sm1_data *priv = data; struct wined3d_sm1_data *priv = data;
DWORD token, addr_token; DWORD token, addr_token;
*ptr += shader_get_param(*ptr, priv->shader_version, &token, &addr_token); *ptr += shader_get_param(priv, *ptr, &token, &addr_token);
if (token & WINED3DSHADER_ADDRMODE_RELATIVE) if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
{ {
shader_parse_src_param(addr_token, NULL, dst_rel_addr); shader_parse_src_param(addr_token, NULL, dst_rel_addr);

36
dlls/wined3d/shader_sm4.c
View File

@ -40,6 +40,9 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
#define WINED3D_SM4_SWIZZLE_SHIFT 4 #define WINED3D_SM4_SWIZZLE_SHIFT 4
#define WINED3D_SM4_SWIZZLE_MASK (0xff << WINED3D_SM4_SWIZZLE_SHIFT) #define WINED3D_SM4_SWIZZLE_MASK (0xff << WINED3D_SM4_SWIZZLE_SHIFT)
#define WINED3D_SM4_VERSION_MAJOR(version) (((version) >> 4) & 0xf)
#define WINED3D_SM4_VERSION_MINOR(version) (((version) >> 0) & 0xf)
enum wined3d_sm4_opcode enum wined3d_sm4_opcode
{ {
WINED3D_SM4_OP_ADD = 0x00, WINED3D_SM4_OP_ADD = 0x00,
@ -66,7 +69,7 @@ enum wined3d_sm4_immconst_type
struct wined3d_sm4_data struct wined3d_sm4_data
{ {
DWORD shader_version; struct wined3d_shader_version shader_version;
const DWORD *end; const DWORD *end;
}; };
@ -126,17 +129,40 @@ static void shader_sm4_free(void *data)
HeapFree(GetProcessHeap(), 0, data); HeapFree(GetProcessHeap(), 0, data);
} }
static void shader_sm4_read_header(void *data, const DWORD **ptr, DWORD *shader_version) static void shader_sm4_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
{ {
struct wined3d_sm4_data *priv = data; struct wined3d_sm4_data *priv = data;
DWORD version_token;
priv->end = *ptr; priv->end = *ptr;
TRACE("version: 0x%08x\n", **ptr); version_token = *(*ptr)++;
*shader_version = *(*ptr)++; TRACE("version: 0x%08x\n", version_token);
TRACE("token count: %u\n", **ptr); TRACE("token count: %u\n", **ptr);
priv->end += *(*ptr)++; priv->end += *(*ptr)++;
priv->shader_version = *shader_version; switch (version_token >> 16)
{
case WINED3D_SM4_PS:
priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL;
break;
case WINED3D_SM4_VS:
priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX;
break;
case WINED3D_SM4_GS:
priv->shader_version.type = WINED3D_SHADER_TYPE_GEOMETRY;
break;
default:
FIXME("Unrecognized shader type %#x\n", version_token >> 16);
}
priv->shader_version.major = WINED3D_SM4_VERSION_MAJOR(version_token);
priv->shader_version.minor = WINED3D_SM4_VERSION_MINOR(version_token);
*shader_version = priv->shader_version;
} }
static void shader_sm4_read_opcode(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins, static void shader_sm4_read_opcode(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins,

20
dlls/wined3d/vertexshader.c
View File

@ -36,14 +36,17 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
static void vshader_set_limits(IWineD3DVertexShaderImpl *This) static void vshader_set_limits(IWineD3DVertexShaderImpl *This)
{ {
DWORD shader_version = WINED3D_SHADER_VERSION(This->baseShader.reg_maps.shader_version.major,
This->baseShader.reg_maps.shader_version.minor);
This->baseShader.limits.texcoord = 0; This->baseShader.limits.texcoord = 0;
This->baseShader.limits.attributes = 16; This->baseShader.limits.attributes = 16;
This->baseShader.limits.packed_input = 0; This->baseShader.limits.packed_input = 0;
switch (This->baseShader.reg_maps.shader_version) switch (shader_version)
{ {
case WINED3DVS_VERSION(1,0): case WINED3D_SHADER_VERSION(1,0):
case WINED3DVS_VERSION(1,1): case WINED3D_SHADER_VERSION(1,1):
This->baseShader.limits.temporary = 12; This->baseShader.limits.temporary = 12;
This->baseShader.limits.constant_bool = 0; This->baseShader.limits.constant_bool = 0;
This->baseShader.limits.constant_int = 0; This->baseShader.limits.constant_int = 0;
@ -56,8 +59,8 @@ static void vshader_set_limits(IWineD3DVertexShaderImpl *This)
This->baseShader.limits.constant_float = min(256, GL_LIMITS(vshader_constantsF)); This->baseShader.limits.constant_float = min(256, GL_LIMITS(vshader_constantsF));
break; break;
case WINED3DVS_VERSION(2,0): case WINED3D_SHADER_VERSION(2,0):
case WINED3DVS_VERSION(2,1): case WINED3D_SHADER_VERSION(2,1):
This->baseShader.limits.temporary = 12; This->baseShader.limits.temporary = 12;
This->baseShader.limits.constant_bool = 16; This->baseShader.limits.constant_bool = 16;
This->baseShader.limits.constant_int = 16; This->baseShader.limits.constant_int = 16;
@ -68,7 +71,7 @@ static void vshader_set_limits(IWineD3DVertexShaderImpl *This)
This->baseShader.limits.constant_float = min(256, GL_LIMITS(vshader_constantsF)); This->baseShader.limits.constant_float = min(256, GL_LIMITS(vshader_constantsF));
break; break;
case WINED3DVS_VERSION(3,0): case WINED3D_SHADER_VERSION(3,0):
This->baseShader.limits.temporary = 32; This->baseShader.limits.temporary = 32;
This->baseShader.limits.constant_bool = 32; This->baseShader.limits.constant_bool = 32;
This->baseShader.limits.constant_int = 32; This->baseShader.limits.constant_int = 32;
@ -92,8 +95,9 @@ static void vshader_set_limits(IWineD3DVertexShaderImpl *This)
This->baseShader.limits.sampler = 0; This->baseShader.limits.sampler = 0;
This->baseShader.limits.label = 16; This->baseShader.limits.label = 16;
This->baseShader.limits.constant_float = min(256, GL_LIMITS(vshader_constantsF)); This->baseShader.limits.constant_float = min(256, GL_LIMITS(vshader_constantsF));
FIXME("Unrecognized vertex shader version %#x\n", FIXME("Unrecognized vertex shader version %u.%u\n",
This->baseShader.reg_maps.shader_version); This->baseShader.reg_maps.shader_version.major,
This->baseShader.reg_maps.shader_version.minor);
} }
} }

38
dlls/wined3d/wined3d_private.h
View File

@ -486,8 +486,6 @@ typedef enum COMPARISON_TYPE
/* Shader version tokens, and shader end tokens */ /* Shader version tokens, and shader end tokens */
#define WINED3DPS_VERSION(major, minor) ((WINED3D_SM1_PS << 16) | ((major) << 8) | (minor)) #define WINED3DPS_VERSION(major, minor) ((WINED3D_SM1_PS << 16) | ((major) << 8) | (minor))
#define WINED3DVS_VERSION(major, minor) ((WINED3D_SM1_VS << 16) | ((major) << 8) | (minor)) #define WINED3DVS_VERSION(major, minor) ((WINED3D_SM1_VS << 16) | ((major) << 8) | (minor))
#define WINED3DSHADER_VERSION_MAJOR(version) (((version) >> 8) & 0xff)
#define WINED3DSHADER_VERSION_MINOR(version) (((version) >> 0) & 0xff)
/* Shader backends */ /* Shader backends */
@ -601,9 +599,25 @@ enum WINED3D_SHADER_INSTRUCTION_HANDLER
WINED3DSIH_TABLE_SIZE WINED3DSIH_TABLE_SIZE
}; };
enum wined3d_shader_type
{
WINED3D_SHADER_TYPE_PIXEL,
WINED3D_SHADER_TYPE_VERTEX,
WINED3D_SHADER_TYPE_GEOMETRY,
};
struct wined3d_shader_version
{
enum wined3d_shader_type type;
BYTE major;
BYTE minor;
};
#define WINED3D_SHADER_VERSION(major, minor) (((major) << 8) | (minor))
typedef struct shader_reg_maps typedef struct shader_reg_maps
{ {
DWORD shader_version; struct wined3d_shader_version shader_version;
char texcoord[MAX_REG_TEXCRD]; /* pixel < 3.0 */ char texcoord[MAX_REG_TEXCRD]; /* pixel < 3.0 */
char temporary[MAX_REG_TEMP]; /* pixel, vertex */ char temporary[MAX_REG_TEMP]; /* pixel, vertex */
char address[MAX_REG_ADDR]; /* vertex */ char address[MAX_REG_ADDR]; /* vertex */
@ -681,7 +695,7 @@ struct wined3d_shader_frontend
{ {
void *(*shader_init)(const DWORD *ptr); void *(*shader_init)(const DWORD *ptr);
void (*shader_free)(void *data); void (*shader_free)(void *data);
void (*shader_read_header)(void *data, const DWORD **ptr, DWORD *shader_version); void (*shader_read_header)(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version);
void (*shader_read_opcode)(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins, UINT *param_size); void (*shader_read_opcode)(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins, UINT *param_size);
void (*shader_read_src_param)(void *data, const DWORD **ptr, struct wined3d_shader_src_param *src_param, void (*shader_read_src_param)(void *data, const DWORD **ptr, struct wined3d_shader_src_param *src_param,
struct wined3d_shader_src_param *src_rel_addr); struct wined3d_shader_src_param *src_rel_addr);
@ -2554,8 +2568,10 @@ typedef struct IWineD3DBaseShaderImpl {
void shader_buffer_init(struct SHADER_BUFFER *buffer); void shader_buffer_init(struct SHADER_BUFFER *buffer);
void shader_buffer_free(struct SHADER_BUFFER *buffer); void shader_buffer_free(struct SHADER_BUFFER *buffer);
void shader_cleanup(IWineD3DBaseShader *iface); void shader_cleanup(IWineD3DBaseShader *iface);
void shader_dump_src_param(const struct wined3d_shader_src_param *param, DWORD shader_version); void shader_dump_src_param(const struct wined3d_shader_src_param *param,
void shader_dump_dst_param(const struct wined3d_shader_dst_param *param, DWORD shader_version); const struct wined3d_shader_version *shader_version);
void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
const struct wined3d_shader_version *shader_version);
void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER *buffer, void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER *buffer,
const shader_reg_maps *reg_maps, const DWORD *pFunction); const shader_reg_maps *reg_maps, const DWORD *pFunction);
HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3d_shader_frontend *fe, HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3d_shader_frontend *fe,
@ -2565,12 +2581,14 @@ void shader_init(struct IWineD3DBaseShaderClass *shader, IWineD3DDevice *device)
const struct wined3d_shader_frontend *shader_select_frontend(DWORD version_token); const struct wined3d_shader_frontend *shader_select_frontend(DWORD version_token);
void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *pFunction); void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *pFunction);
static inline BOOL shader_is_pshader_version(DWORD token) { static inline BOOL shader_is_pshader_version(enum wined3d_shader_type type)
return 0xFFFF0000 == (token & 0xFFFF0000); {
return type == WINED3D_SHADER_TYPE_PIXEL;
} }
static inline BOOL shader_is_vshader_version(DWORD token) { static inline BOOL shader_is_vshader_version(enum wined3d_shader_type type)
return 0xFFFE0000 == (token & 0xFFFF0000); {
return type == WINED3D_SHADER_TYPE_VERTEX;
} }
static inline BOOL shader_is_scalar(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx) static inline BOOL shader_is_scalar(WINED3DSHADER_PARAM_REGISTER_TYPE register_type, UINT register_idx)