From 17b0d26c1e06cf78d93cfc9bdbe618f456e196b1 Mon Sep 17 00:00:00 2001 From: Ivan Gyurdiev Date: Mon, 12 Jun 2006 02:54:30 -0400 Subject: [PATCH] wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early] --- dlls/wined3d/baseshader.c | 147 ++++++++++++++++++++++++- dlls/wined3d/glsl_shader.c | 18 ++-- dlls/wined3d/pixelshader.c | 192 +++++---------------------------- dlls/wined3d/vertexshader.c | 165 +++------------------------- dlls/wined3d/wined3d_private.h | 9 +- 5 files changed, 197 insertions(+), 334 deletions(-) diff --git a/dlls/wined3d/baseshader.c b/dlls/wined3d/baseshader.c index 21ec9442d3e..774c313119f 100644 --- a/dlls/wined3d/baseshader.c +++ b/dlls/wined3d/baseshader.c @@ -68,7 +68,6 @@ const SHADER_OPCODE* shader_get_opcode( IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl*) iface; DWORD i = 0; - DWORD version = This->baseShader.version; DWORD hex_version = This->baseShader.hex_version; const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins; @@ -81,8 +80,8 @@ const SHADER_OPCODE* shader_get_opcode( } ++i; } - FIXME("Unsupported opcode %lx(%ld) masked %lx version %ld\n", - code, code, code & D3DSI_OPCODE_MASK, version); + FIXME("Unsupported opcode %#lx(%ld) masked %#lx, shader version %#lx\n", + code, code, code & D3DSI_OPCODE_MASK, hex_version); return NULL; } @@ -392,7 +391,7 @@ void shader_get_registers_used( } } -void shader_program_dump_decl_usage( +static void shader_dump_decl_usage( DWORD decl, DWORD param) { @@ -897,4 +896,144 @@ void shader_hw_def(SHADER_OPCODE_ARG* arg) { arg->reg_maps->constantsF[reg] = 1; } +/* First pass: trace shader, initialize length and version */ +void shader_trace_init( + IWineD3DBaseShader *iface, + const DWORD* pFunction) { + + IWineD3DBaseShaderImpl *This =(IWineD3DBaseShaderImpl *)iface; + + const DWORD* pToken = pFunction; + const SHADER_OPCODE* curOpcode = NULL; + DWORD opcode_token; + unsigned int len = 0; + DWORD i; + + TRACE("(%p) : Parsing programme\n", This); + + if (NULL != pToken) { + while (D3DVS_END() != *pToken) { + if (shader_is_version_token(*pToken)) { /** version */ + This->baseShader.hex_version = *pToken; + TRACE("%s_%lu_%lu\n", shader_is_pshader_version(This->baseShader.hex_version)? "ps": "vs", + D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version), + D3DSHADER_VERSION_MINOR(This->baseShader.hex_version)); + ++pToken; + ++len; + continue; + } + if (shader_is_comment(*pToken)) { /** comment */ + DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT; + ++pToken; + TRACE("//%s\n", (char*)pToken); + pToken += comment_len; + len += comment_len + 1; + continue; + } + opcode_token = *pToken++; + curOpcode = shader_get_opcode(iface, opcode_token); + len++; + + if (NULL == curOpcode) { + int tokens_read; + FIXME("Unrecognized opcode: token=%08lX\n", opcode_token); + tokens_read = shader_skip_unrecognized(iface, pToken); + pToken += tokens_read; + len += tokens_read; + + } else { + if (curOpcode->opcode == D3DSIO_DCL) { + + DWORD usage = *pToken; + DWORD param = *(pToken + 1); + + shader_dump_decl_usage(usage, param); + shader_dump_ins_modifiers(param); + TRACE(" "); + shader_dump_param(iface, param, 0, 0); + pToken += 2; + len += 2; + + } else if (curOpcode->opcode == D3DSIO_DEF) { + + unsigned int offset = shader_get_float_offset(*pToken); + + TRACE("def c%u = %f, %f, %f, %f", offset, + *(float *)(pToken + 1), + *(float *)(pToken + 2), + *(float *)(pToken + 3), + *(float *)(pToken + 4)); + + pToken += 5; + len += 5; + } else if (curOpcode->opcode == D3DSIO_DEFI) { + + TRACE("defi i%lu = %ld, %ld, %ld, %ld", *pToken & D3DSP_REGNUM_MASK, + (long) *(pToken + 1), + (long) *(pToken + 2), + (long) *(pToken + 3), + (long) *(pToken + 4)); + + pToken += 5; + len += 5; + + } else if (curOpcode->opcode == D3DSIO_DEFB) { + + TRACE("defb b%lu = %s", *pToken & D3DSP_REGNUM_MASK, + *(pToken + 1)? "true": "false"); + + pToken += 2; + len += 2; + + } else { + + DWORD param, addr_token; + int tokens_read; + + /* Print out predication source token first - it follows + * the destination token. */ + if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) { + TRACE("("); + shader_dump_param(iface, *(pToken + 2), 0, 1); + TRACE(") "); + } + + TRACE("%s", curOpcode->name); + if (curOpcode->num_params > 0) { + + /* Destination token */ + tokens_read = shader_get_param(iface, pToken, ¶m, &addr_token); + pToken += tokens_read; + len += tokens_read; + + shader_dump_ins_modifiers(param); + TRACE(" "); + shader_dump_param(iface, param, addr_token, 0); + + /* Predication token - already printed out, just skip it */ + if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) { + pToken++; + len++; + } + /* Other source tokens */ + for (i = 1; i < curOpcode->num_params; ++i) { + + tokens_read = shader_get_param(iface, pToken, ¶m, &addr_token); + pToken += tokens_read; + len += tokens_read; + + TRACE(", "); + shader_dump_param(iface, param, addr_token, 1); + } + } + } + TRACE("\n"); + } + } + This->baseShader.functionLength = (len + 1) * sizeof(DWORD); + } else { + This->baseShader.functionLength = 1; /* no Function defined use fixed function vertex processing */ + } +} + /* TODO: Move other shared code here */ diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 59a0b0589ba..afcec1cf84a 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -217,7 +217,7 @@ static void shader_glsl_get_register_name( if (param & D3DVS_ADDRMODE_RELATIVE) { /* Relative addressing on shaders 2.0+ have a relative address token, * prior to that, it was hard-coded as "A0.x" because there's only 1 register */ - if (This->baseShader.version >= 20) { + if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2) { char relStr[100], relReg[50], relMask[6]; shader_glsl_add_param(arg, addr_token, 0, TRUE, relReg, relMask, relStr); sprintf(tmpStr, "C[%s + %lu]", relStr, reg); @@ -713,7 +713,7 @@ void pshader_glsl_tex(SHADER_OPCODE_ARG* arg) { IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader; SHADER_BUFFER* buffer = arg->buffer; - DWORD version = This->baseShader.version; + DWORD hex_version = This->baseShader.hex_version; char dst_str[100], dst_reg[50], dst_mask[6]; char src0_str[100], src0_reg[50], src0_mask[6]; @@ -724,18 +724,18 @@ void pshader_glsl_tex(SHADER_OPCODE_ARG* arg) { shader_glsl_add_param(arg, arg->dst, 0, FALSE, dst_reg, dst_mask, dst_str); /* 1.0-1.3: Use destination register as coordinate source. - 2.0+: Use provided coordinate source register. */ - if (version == 14) { + * 2.0+: Use provided coordinate source register. */ + if (hex_version == D3DPS_VERSION(1,4)) { shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str); sprintf(src1_str, "mytex%lu", reg_dest_code); - } else if (version > 14) { + } else if (hex_version > D3DPS_VERSION(1,4)) { shader_glsl_add_param(arg, arg->src[0], arg->src_addr[0], TRUE, src0_reg, src0_mask, src0_str); shader_glsl_add_param(arg, arg->src[1], arg->src_addr[1], TRUE, src1_reg, src1_mask, src1_str); } /* 1.0-1.4: Use destination register number as texture code. - 2.0+: Use provided sampler number as texure code. */ - if (version < 14) { + * 2.0+: Use provided sampler number as texure code. */ + if (hex_version < D3DPS_VERSION(1,4)) { shader_addline(buffer, "%s = texture2D(mytex%lu, gl_TexCoord[%lu].st);\n", dst_str, reg_dest_code, reg_dest_code); } else { @@ -749,7 +749,7 @@ void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg) { IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader; SHADER_BUFFER* buffer = arg->buffer; - DWORD version = This->baseShader.version; + DWORD hex_version = This->baseShader.hex_version; char tmpStr[100]; char tmpReg[50]; @@ -758,7 +758,7 @@ void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg) { shader_glsl_add_param(arg, arg->dst, 0, FALSE, tmpReg, tmpMask, tmpStr); - if (version != 14) { + if (hex_version != D3DPS_VERSION(1,4)) { DWORD reg = arg->dst & D3DSP_REGNUM_MASK; shader_addline(buffer, "%s = gl_TexCoord[%lu];\n", tmpReg, reg); } else { diff --git a/dlls/wined3d/pixelshader.c b/dlls/wined3d/pixelshader.c index 455124ae8f8..055cf0d35df 100644 --- a/dlls/wined3d/pixelshader.c +++ b/dlls/wined3d/pixelshader.c @@ -937,32 +937,26 @@ static void pshader_gen_input_modifier_line ( sprintf(outregstr, "T%c%s", 'A' + tmpreg, swzstr); } -static void pshader_set_version( - IWineD3DPixelShaderImpl *This, - DWORD version) { - - DWORD major = (version >> 8) & 0x0F; - DWORD minor = version & 0x0F; - - This->baseShader.hex_version = version; - This->baseShader.version = major * 10 + minor; - TRACE("ps_%lu_%lu\n", major, minor); +static void pshader_set_limits( + IWineD3DPixelShaderImpl *This) { This->baseShader.limits.attributes = 0; This->baseShader.limits.address = 0; - switch (This->baseShader.version) { - case 10: - case 11: - case 12: - case 13: This->baseShader.limits.temporary = 2; + switch (This->baseShader.hex_version) { + case D3DPS_VERSION(1,0): + case D3DPS_VERSION(1,1): + case D3DPS_VERSION(1,2): + case D3DPS_VERSION(1,3): + This->baseShader.limits.temporary = 2; This->baseShader.limits.constant_float = 8; This->baseShader.limits.constant_int = 0; This->baseShader.limits.constant_bool = 0; This->baseShader.limits.texture = 4; break; - case 14: This->baseShader.limits.temporary = 6; + case D3DPS_VERSION(1,4): + This->baseShader.limits.temporary = 6; This->baseShader.limits.constant_float = 8; This->baseShader.limits.constant_int = 0; This->baseShader.limits.constant_bool = 0; @@ -970,15 +964,17 @@ static void pshader_set_version( break; /* FIXME: temporaries must match D3DPSHADERCAPS2_0.NumTemps */ - case 20: - case 21: This->baseShader.limits.temporary = 32; + case D3DPS_VERSION(2,0): + case D3DPS_VERSION(2,1): + This->baseShader.limits.temporary = 32; This->baseShader.limits.constant_float = 32; This->baseShader.limits.constant_int = 16; This->baseShader.limits.constant_bool = 16; This->baseShader.limits.texture = 8; break; - case 30: This->baseShader.limits.temporary = 32; + case D3DPS_VERSION(3,0): + This->baseShader.limits.temporary = 32; This->baseShader.limits.constant_float = 224; This->baseShader.limits.constant_int = 16; This->baseShader.limits.constant_bool = 16; @@ -990,7 +986,8 @@ static void pshader_set_version( This->baseShader.limits.constant_int = 0; This->baseShader.limits.constant_bool = 0; This->baseShader.limits.texture = 8; - FIXME("Unrecognized pixel shader version %lx!\n", version); + FIXME("Unrecognized pixel shader version %#lx\n", + This->baseShader.hex_version); } } @@ -1115,7 +1112,7 @@ static void pshader_hw_tex(SHADER_OPCODE_ARG* arg) { DWORD dst = arg->dst; DWORD* src = arg->src; SHADER_BUFFER* buffer = arg->buffer; - DWORD version = This->baseShader.version; + DWORD hex_version = This->baseShader.hex_version; char reg_dest[40]; char reg_coord[40]; @@ -1128,14 +1125,14 @@ static void pshader_hw_tex(SHADER_OPCODE_ARG* arg) { /* 1.0-1.3: Use destination register as coordinate source. 2.0+: Use provided coordinate source register. */ - if (version < 14) + if (hex_version < D3DPS_VERSION(1,4)) strcpy(reg_coord, reg_dest); else pshader_gen_input_modifier_line(buffer, src[0], 0, reg_coord, arg->reg_maps->constantsF); /* 1.0-1.4: Use destination register number as texture code. 2.0+: Use provided sampler number as texure code. */ - if (version < 20) + if (hex_version < D3DPS_VERSION(2,0)) reg_sampler_code = reg_dest_code; else reg_sampler_code = src[1] & D3DSP_REGNUM_MASK; @@ -1150,11 +1147,11 @@ static void pshader_hw_texcoord(SHADER_OPCODE_ARG* arg) { DWORD dst = arg->dst; DWORD* src = arg->src; SHADER_BUFFER* buffer = arg->buffer; - DWORD version = This->baseShader.version; + DWORD hex_version = This->baseShader.hex_version; char tmp[20]; get_write_mask(dst, tmp); - if (version != 14) { + if (hex_version != D3DPS_VERSION(1,4)) { DWORD reg = dst & D3DSP_REGNUM_MASK; shader_addline(buffer, "MOV T%lu%s, fragment.texcoord[%lu];\n", reg, tmp, reg); } else { @@ -1398,158 +1395,19 @@ inline static VOID IWineD3DPixelShaderImpl_GenerateShader( } static HRESULT WINAPI IWineD3DPixelShaderImpl_SetFunction(IWineD3DPixelShader *iface, CONST DWORD *pFunction) { - IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface; - const DWORD* pToken = pFunction; - const SHADER_OPCODE *curOpcode = NULL; - DWORD opcode_token; - DWORD len = 0; - DWORD i; - TRACE("(%p) : Parsing programme\n", This); - if (NULL != pToken) { - while (D3DPS_END() != *pToken) { - if (shader_is_pshader_version(*pToken)) { /** version */ - pshader_set_version(This, *pToken); - ++pToken; - ++len; - continue; - } - if (shader_is_comment(*pToken)) { /** comment */ - DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT; - ++pToken; - TRACE("//%s\n", (char*)pToken); - pToken += comment_len; - len += comment_len + 1; - continue; - } - if (!This->baseShader.version) { - WARN("(%p) : pixel shader doesn't have a valid version identifier\n", This); - } - opcode_token = *pToken++; - curOpcode = shader_get_opcode((IWineD3DBaseShader*) This, opcode_token); - len++; - if (NULL == curOpcode) { - int tokens_read; + IWineD3DPixelShaderImpl *This =(IWineD3DPixelShaderImpl *)iface; - FIXME("Unrecognized opcode: token=%08lX\n", opcode_token); - tokens_read = shader_skip_unrecognized((IWineD3DBaseShader*) This, pToken); - pToken += tokens_read; - len += tokens_read; - - } else { - if (curOpcode->opcode == D3DSIO_DCL) { - DWORD usage = *pToken; - DWORD param = *(pToken + 1); - DWORD regtype = shader_get_regtype(param); - - /* Only print extended declaration for samplers or 3.0 input registers */ - if (regtype == D3DSPR_SAMPLER || - (This->baseShader.version >= 30 && regtype == D3DSPR_INPUT)) - shader_program_dump_decl_usage(usage, param); - else - TRACE("dcl"); - - shader_dump_ins_modifiers(param); - TRACE(" "); - shader_dump_param((IWineD3DBaseShader*) This, param, 0, 0); - pToken += 2; - len += 2; - - } else if (curOpcode->opcode == D3DSIO_DEF) { - - unsigned int offset = shader_get_float_offset(*pToken); - - TRACE("def c%u = %f, %f, %f, %f", offset, - *(float *)(pToken + 1), - *(float *)(pToken + 2), - *(float *)(pToken + 3), - *(float *)(pToken + 4)); - - pToken += 5; - len += 5; - - } else if (curOpcode->opcode == D3DSIO_DEFI) { - - TRACE("defi i%lu = %ld, %ld, %ld, %ld", *pToken & D3DSP_REGNUM_MASK, - (long) *(pToken + 1), - (long) *(pToken + 2), - (long) *(pToken + 3), - (long) *(pToken + 4)); - - pToken += 5; - len += 5; - - } else if (curOpcode->opcode == D3DSIO_DEFB) { - - TRACE("defb b%lu = %s", *pToken & D3DSP_REGNUM_MASK, - *(pToken + 1)? "true": "false"); - - pToken += 2; - len += 2; - - } else { - - DWORD param, addr_token; - int tokens_read; - - /* Print out predication source token first - it follows - * the destination token. */ - if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) { - TRACE("("); - shader_dump_param((IWineD3DBaseShader*) This, *(pToken + 2), 0, 1); - TRACE(") "); - } - - TRACE("%s", curOpcode->name); - if (curOpcode->num_params > 0) { - - /* Destination token */ - tokens_read = shader_get_param((IWineD3DBaseShader*) This, - pToken, ¶m, &addr_token); - pToken += tokens_read; - len += tokens_read; - - shader_dump_ins_modifiers(param); - TRACE(" "); - shader_dump_param((IWineD3DBaseShader*) This, param, addr_token, 0); - - /* Predication token - already printed out, just skip it */ - if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) { - pToken++; - len++; - } - - /* Other source tokens */ - for (i = 1; i < curOpcode->num_params; ++i) { - - tokens_read = shader_get_param((IWineD3DBaseShader*) This, - pToken, ¶m, &addr_token); - pToken += tokens_read; - len += tokens_read; - - TRACE(", "); - shader_dump_param((IWineD3DBaseShader*) This, param, addr_token, 1); - } - } - } - TRACE("\n"); - } - } - This->baseShader.functionLength = (len + 1) * sizeof(DWORD); - } else { - This->baseShader.functionLength = 1; /* no Function defined use fixed function vertex processing */ - } + shader_trace_init((IWineD3DBaseShader*) This, pFunction); + pshader_set_limits(This); /* Generate HW shader in needed */ if (NULL != pFunction && wined3d_settings.vs_mode == VS_HW) { TRACE("(%p) : Generating hardware program\n", This); -#if 1 IWineD3DPixelShaderImpl_GenerateShader(iface, pFunction); -#endif } TRACE("(%p) : Copying the function\n", This); - /* copy the function ... because it will certainly be released by application */ if (NULL != pFunction) { This->baseShader.function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->baseShader.functionLength); memcpy((void *)This->baseShader.function, pFunction, This->baseShader.functionLength); diff --git a/dlls/wined3d/vertexshader.c b/dlls/wined3d/vertexshader.c index 17f364b219f..3d7db4d0595 100644 --- a/dlls/wined3d/vertexshader.c +++ b/dlls/wined3d/vertexshader.c @@ -709,16 +709,8 @@ inline static void vshader_program_add_param(SHADER_OPCODE_ARG *arg, const DWORD } } -static void vshader_set_version( - IWineD3DVertexShaderImpl *This, - DWORD version) { - - DWORD major = (version >> 8) & 0x0F; - DWORD minor = version & 0x0F; - - This->baseShader.hex_version = version; - This->baseShader.version = major * 10 + minor; - TRACE("vs_%lu_%lu\n", major, minor); +static void vshader_set_limits( + IWineD3DVertexShaderImpl *This) { This->baseShader.limits.texture = 0; This->baseShader.limits.attributes = 16; @@ -726,22 +718,25 @@ static void vshader_set_version( /* Must match D3DCAPS9.MaxVertexShaderConst: at least 256 for vs_2_0 */ This->baseShader.limits.constant_float = WINED3D_VSHADER_MAX_CONSTANTS; - switch (This->baseShader.version) { - case 10: - case 11: This->baseShader.limits.temporary = 12; + switch (This->baseShader.hex_version) { + case D3DVS_VERSION(1,0): + case D3DVS_VERSION(1,1): + This->baseShader.limits.temporary = 12; This->baseShader.limits.constant_bool = 0; This->baseShader.limits.constant_int = 0; This->baseShader.limits.address = 1; break; - case 20: - case 21: This->baseShader.limits.temporary = 12; + case D3DVS_VERSION(2,0): + case D3DVS_VERSION(2,1): + This->baseShader.limits.temporary = 12; This->baseShader.limits.constant_bool = 16; This->baseShader.limits.constant_int = 16; This->baseShader.limits.address = 1; break; - case 30: This->baseShader.limits.temporary = 32; + case D3DVS_VERSION(3,0): + This->baseShader.limits.temporary = 32; This->baseShader.limits.constant_bool = 32; This->baseShader.limits.constant_int = 32; This->baseShader.limits.address = 1; @@ -751,7 +746,8 @@ static void vshader_set_version( This->baseShader.limits.constant_bool = 0; This->baseShader.limits.constant_int = 0; This->baseShader.limits.address = 1; - FIXME("Unrecognized vertex shader version %lx!\n", version); + FIXME("Unrecognized vertex shader version %#lx\n", + This->baseShader.hex_version); } } @@ -1316,140 +1312,11 @@ static HRESULT WINAPI IWineD3DVertexShaderImpl_GetFunction(IWineD3DVertexShader* } static HRESULT WINAPI IWineD3DVertexShaderImpl_SetFunction(IWineD3DVertexShader *iface, CONST DWORD *pFunction) { + IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface; - const DWORD* pToken = pFunction; - const SHADER_OPCODE* curOpcode = NULL; - DWORD opcode_token; - DWORD len = 0; - DWORD i; - TRACE("(%p) : Parsing programme\n", This); - if (NULL != pToken) { - while (D3DVS_END() != *pToken) { - if (shader_is_vshader_version(*pToken)) { /** version */ - vshader_set_version(This, *pToken); - ++pToken; - ++len; - continue; - } - if (shader_is_comment(*pToken)) { /** comment */ - DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT; - ++pToken; - TRACE("//%s\n", (char*)pToken); - pToken += comment_len; - len += comment_len + 1; - continue; - } - - opcode_token = *pToken++; - curOpcode = shader_get_opcode((IWineD3DBaseShader*) This, opcode_token); - len++; - - if (NULL == curOpcode) { - int tokens_read; - - FIXME("Unrecognized opcode: token=%08lX\n", opcode_token); - tokens_read = shader_skip_unrecognized((IWineD3DBaseShader*) This, pToken); - pToken += tokens_read; - len += tokens_read; - - } else { - if (curOpcode->opcode == D3DSIO_DCL) { - - DWORD usage = *pToken; - DWORD param = *(pToken + 1); - - shader_program_dump_decl_usage(usage, param); - shader_dump_ins_modifiers(param); - TRACE(" "); - shader_dump_param((IWineD3DBaseShader*) This, param, 0, 0); - pToken += 2; - len += 2; - - } else if (curOpcode->opcode == D3DSIO_DEF) { - - unsigned int offset = shader_get_float_offset(*pToken); - - TRACE("def c%u = %f, %f, %f, %f", offset, - *(float *)(pToken + 1), - *(float *)(pToken + 2), - *(float *)(pToken + 3), - *(float *)(pToken + 4)); - - pToken += 5; - len += 5; - - } else if (curOpcode->opcode == D3DSIO_DEFI) { - - TRACE("defi i%lu = %ld, %ld, %ld, %ld", *pToken & D3DSP_REGNUM_MASK, - (long) *(pToken + 1), - (long) *(pToken + 2), - (long) *(pToken + 3), - (long) *(pToken + 4)); - - pToken += 5; - len += 5; - - } else if (curOpcode->opcode == D3DSIO_DEFB) { - - TRACE("defb b%lu = %s", *pToken & D3DSP_REGNUM_MASK, - *(pToken + 1)? "true": "false"); - - pToken += 2; - len += 2; - - } else { - - DWORD param, addr_token; - int tokens_read; - - /* Print out predication source token first - it follows - * the destination token. */ - if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) { - TRACE("("); - shader_dump_param((IWineD3DBaseShader*) This, *(pToken + 2), 0, 1); - TRACE(") "); - } - - TRACE("%s", curOpcode->name); - if (curOpcode->num_params > 0) { - - /* Destination token */ - tokens_read = shader_get_param((IWineD3DBaseShader*) This, - pToken, ¶m, &addr_token); - pToken += tokens_read; - len += tokens_read; - - shader_dump_ins_modifiers(param); - TRACE(" "); - shader_dump_param((IWineD3DBaseShader*) This, param, addr_token, 0); - - /* Predication token - already printed out, just skip it */ - if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) { - pToken++; - len++; - } - - /* Other source tokens */ - for (i = 1; i < curOpcode->num_params; ++i) { - - tokens_read = shader_get_param((IWineD3DBaseShader*) This, - pToken, ¶m, &addr_token); - pToken += tokens_read; - len += tokens_read; - - TRACE(", "); - shader_dump_param((IWineD3DBaseShader*) This, param, addr_token, 1); - } - } - } - TRACE("\n"); - } - } - This->baseShader.functionLength = (len + 1) * sizeof(DWORD); - } else { - This->baseShader.functionLength = 1; /* no Function defined use fixed function vertex processing */ - } + shader_trace_init((IWineD3DBaseShader*) This, pFunction); + vshader_set_limits(This); /* Generate HW shader in needed */ if (NULL != pFunction && wined3d_settings.vs_mode == VS_HW) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index a44e883d34f..fa10bc7ab7b 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1349,7 +1349,6 @@ extern void pshader_glsl_texm3x2tex(SHADER_OPCODE_ARG* arg); */ typedef struct IWineD3DBaseShaderClass { - DWORD version; DWORD hex_version; SHADER_LIMITS limits; SHADER_PARSE_STATE parse_state; @@ -1368,10 +1367,6 @@ typedef struct IWineD3DBaseShaderImpl { IWineD3DBaseShaderClass baseShader; } IWineD3DBaseShaderImpl; -extern void shader_program_dump_decl_usage( - DWORD dcl, - DWORD param); - extern void shader_get_registers_used( IWineD3DBaseShader *iface, shader_reg_maps* reg_maps, @@ -1392,6 +1387,10 @@ extern void shader_dump_param( const DWORD addr_token, int input); +extern void shader_trace_init( + IWineD3DBaseShader *iface, + const DWORD* pFunction); + extern int shader_get_param( IWineD3DBaseShader* iface, const DWORD* pToken,