From efed9aea1ff7a5cf724a7a3dbe6d0c8498611a6c Mon Sep 17 00:00:00 2001 From: "H. Verbeet" Date: Tue, 13 Feb 2007 23:12:40 +0100 Subject: [PATCH] d3d8: Move loading local d3d8 vertex shader constants from wined3d to d3d8. --- dlls/d3d8/d3d8_private.h | 1 + dlls/d3d8/device.c | 2 + dlls/d3d8/vertexdeclaration.c | 156 ++++++++++++++++++++++++++++++++++++++ dlls/wined3d/arb_program_shader.c | 40 +++------- dlls/wined3d/glsl_shader.c | 56 ++++---------- dlls/wined3d/vertexdeclaration.c | 30 -------- dlls/wined3d/vertexshader.c | 29 ++++++- dlls/wined3d/wined3d_private.h | 3 - include/wine/wined3d_interface.h | 20 ++--- 9 files changed, 221 insertions(+), 116 deletions(-) diff --git a/dlls/d3d8/d3d8_private.h b/dlls/d3d8/d3d8_private.h index d35f3518d05..2931eb797c7 100644 --- a/dlls/d3d8/d3d8_private.h +++ b/dlls/d3d8/d3d8_private.h @@ -618,6 +618,7 @@ typedef struct IDirect3DPixelShader8Impl { * * to see how not defined it here */ +void load_local_constants(const DWORD *d3d8_elements, IWineD3DVertexShader *wined3d_vertex_shader); /* Callbacks */ extern HRESULT WINAPI D3D8CB_CreateSurface(IUnknown *device, IUnknown *pSuperior, UINT Width, UINT Height, diff --git a/dlls/d3d8/device.c b/dlls/d3d8/device.c index 04352d4a8cf..a5aa2d164ee 100644 --- a/dlls/d3d8/device.c +++ b/dlls/d3d8/device.c @@ -1237,6 +1237,8 @@ static HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexShader(LPDIRECT3DDEVICE8 object->handle = handle; *handle = object; *ppShader = (handle - This->shader_handles) + VS_HIGHESTFIXEDFXF + 1; + + load_local_constants(pDeclaration, object->wineD3DVertexShader); } } TRACE("(%p) : returning %p (handle %#x)\n", This, object, *ppShader); diff --git a/dlls/d3d8/vertexdeclaration.c b/dlls/d3d8/vertexdeclaration.c index 8f1e91b4979..ebf1f8b294c 100644 --- a/dlls/d3d8/vertexdeclaration.c +++ b/dlls/d3d8/vertexdeclaration.c @@ -68,6 +68,162 @@ static ULONG WINAPI IDirect3DVertexDeclaration8Impl_Release(IDirect3DVertexDecla return ref_count; } +static const char *debug_d3dvsdt_type(D3DVSDT_TYPE d3dvsdt_type) +{ + switch (d3dvsdt_type) + { +#define D3DVSDT_TYPE_TO_STR(u) case u: return #u + D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT1); + D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT2); + D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT3); + D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT4); + D3DVSDT_TYPE_TO_STR(D3DVSDT_D3DCOLOR); + D3DVSDT_TYPE_TO_STR(D3DVSDT_UBYTE4); + D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT2); + D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT4); +#undef D3DVSDT_TYPE_TO_STR + default: + FIXME("Unrecognized D3DVSDT_TYPE %#x\n", d3dvsdt_type); + return "unrecognized"; + } +} + +static const char *debug_d3dvsde_register(D3DVSDE_REGISTER d3dvsde_register) +{ + switch (d3dvsde_register) + { +#define D3DVSDE_REGISTER_TO_STR(u) case u: return #u + D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDWEIGHT); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDINDICES); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_PSIZE); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_DIFFUSE); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_SPECULAR); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD0); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD1); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD2); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD3); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD4); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD5); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD6); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD7); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION2); + D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL2); +#undef D3DVSDE_REGISTER_TO_STR + default: + FIXME("Unrecognized D3DVSDE_REGISTER %#x\n", d3dvsde_register); + return "unrecognized"; + } +} + +static size_t parse_token(const DWORD* pToken) +{ + const DWORD token = *pToken; + size_t tokenlen = 1; + + switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */ + case D3DVSD_TOKEN_NOP: + TRACE(" 0x%08x NOP()\n", token); + break; + + case D3DVSD_TOKEN_STREAM: + if (token & D3DVSD_STREAMTESSMASK) + { + TRACE(" 0x%08x STREAM_TESS()\n", token); + } else { + TRACE(" 0x%08x STREAM(%u)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT)); + } + break; + + case D3DVSD_TOKEN_STREAMDATA: + if (token & 0x10000000) + { + TRACE(" 0x%08x SKIP(%u)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT)); + } else { + DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); + DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); + TRACE(" 0x%08x REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type)); + } + break; + + case D3DVSD_TOKEN_TESSELLATOR: + if (token & 0x10000000) + { + DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); + DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); + TRACE(" 0x%08x TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type)); + } else { + DWORD type = ((token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT); + DWORD regout = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT); + DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT); + TRACE(" 0x%08x TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin), + debug_d3dvsde_register(regout), debug_d3dvsdt_type(type)); + } + break; + + case D3DVSD_TOKEN_CONSTMEM: + { + DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT); + tokenlen = (4 * count) + 1; + } + break; + + case D3DVSD_TOKEN_EXT: + { + DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT); + DWORD extinfo = ((token & D3DVSD_EXTINFOMASK) >> D3DVSD_EXTINFOSHIFT); + TRACE(" 0x%08x EXT(%u, %u)\n", token, count, extinfo); + /* todo ... print extension */ + tokenlen = count + 1; + } + break; + + case D3DVSD_TOKEN_END: + TRACE(" 0x%08x END()\n", token); + break; + + default: + TRACE(" 0x%08x UNKNOWN\n", token); + /* argg error */ + } + + return tokenlen; +} + +void load_local_constants(const DWORD *d3d8_elements, IWineD3DVertexShader *wined3d_vertex_shader) +{ + const DWORD *token = d3d8_elements; + + while (*token != D3DVSD_END()) + { + if (((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) == D3DVSD_TOKEN_CONSTMEM) + { + DWORD count = ((*token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT); + DWORD constant_idx = ((*token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT); + HRESULT hr; + + if (TRACE_ON(d3d8)) + { + DWORD i; + for (i = 0; i < count; ++i) + { + TRACE("c[%u] = (%8f, %8f, %8f, %8f)\n", + constant_idx, + *(const float *)(token + i * 4 + 1), + *(const float *)(token + i * 4 + 2), + *(const float *)(token + i * 4 + 3), + *(const float *)(token + i * 4 + 4)); + } + } + hr = IWineD3DVertexShader_SetLocalConstantsF(wined3d_vertex_shader, constant_idx, (const float *)token+1, count); + if (FAILED(hr)) ERR("Failed setting shader constants\n"); + } + + token += parse_token(token); + } +} + const IDirect3DVertexDeclaration8Vtbl Direct3DVertexDeclaration8_Vtbl = { IDirect3DVertexDeclaration8Impl_QueryInterface, diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c index 6da40cc1e77..86e8430fd7a 100644 --- a/dlls/wined3d/arb_program_shader.c +++ b/dlls/wined3d/arb_program_shader.c @@ -54,33 +54,19 @@ static void shader_arb_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL_ local_constant* lconst; int i; - if (!constant_list) { - if (TRACE_ON(d3d_shader)) { - for (i = 0; i < max_constants; ++i) { - TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i, - constants[i * 4 + 0], constants[i * 4 + 1], - constants[i * 4 + 2], constants[i * 4 + 3]); - } - } - for (i = 0; i < max_constants; ++i) { - GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, constants + (i * 4))); - } - checkGLcall("glProgramEnvParameter4fvARB()"); - } else { - if (TRACE_ON(d3d_shader)) { - LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) { - i = constant->idx; - TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i, - constants[i * 4 + 0], constants[i * 4 + 1], - constants[i * 4 + 2], constants[i * 4 + 3]); - } - } + if (TRACE_ON(d3d_shader)) { LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) { i = constant->idx; - GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, constants + (i * 4))); + TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i, + constants[i * 4 + 0], constants[i * 4 + 1], + constants[i * 4 + 2], constants[i * 4 + 3]); } - checkGLcall("glProgramEnvParameter4fvARB()"); } + LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) { + i = constant->idx; + GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, constants + (i * 4))); + } + checkGLcall("glProgramEnvParameter4fvARB()"); /* Load immediate constants */ if (TRACE_ON(d3d_shader)) { @@ -113,14 +99,6 @@ void shader_arb_load_constants( if (useVertexShader) { IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader; - IWineD3DVertexDeclarationImpl* vertexDeclaration = (IWineD3DVertexDeclarationImpl*) stateBlock->vertexDecl; - - if (NULL != vertexDeclaration && NULL != vertexDeclaration->constants) { - /* Load DirectX 8 float constants for vertex shader */ - shader_arb_load_constantsF(vshader, gl_info, GL_VERTEX_PROGRAM_ARB, - GL_LIMITS(vshader_constantsF), - vertexDeclaration->constants, NULL); - } /* Load DirectX 9 float constants for vertex shader */ shader_arb_load_constantsF(vshader, gl_info, GL_VERTEX_PROGRAM_ARB, diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 854087e8888..6387a366994 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -105,52 +105,31 @@ void shader_glsl_load_psamplers( static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL_Info *gl_info, unsigned int max_constants, float* constants, GLhandleARB *constant_locations, struct list *constant_list) { + constant_entry *constant; local_constant* lconst; GLhandleARB tmp_loc; int i; - if (!constant_list) { - if (TRACE_ON(d3d_shader)) { - for (i = 0; i < max_constants; ++i) { - tmp_loc = constant_locations[i]; - if (tmp_loc != -1) { - TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i, - constants[i * 4 + 0], constants[i * 4 + 1], - constants[i * 4 + 2], constants[i * 4 + 3]); - } - } - } - for (i = 0; i < max_constants; ++i) { - tmp_loc = constant_locations[i]; - if (tmp_loc != -1) { - /* We found this uniform name in the program - go ahead and send the data */ - GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, constants + (i * 4))); - } - } - checkGLcall("glUniform4fvARB()"); - } else { - constant_entry *constant; - if (TRACE_ON(d3d_shader)) { - LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) { - i = constant->idx; - tmp_loc = constant_locations[i]; - if (tmp_loc != -1) { - TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i, - constants[i * 4 + 0], constants[i * 4 + 1], - constants[i * 4 + 2], constants[i * 4 + 3]); - } - } - } + if (TRACE_ON(d3d_shader)) { LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) { i = constant->idx; tmp_loc = constant_locations[i]; if (tmp_loc != -1) { - /* We found this uniform name in the program - go ahead and send the data */ - GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, constants + (i * 4))); + TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i, + constants[i * 4 + 0], constants[i * 4 + 1], + constants[i * 4 + 2], constants[i * 4 + 3]); } } - checkGLcall("glUniform4fvARB()"); } + LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) { + i = constant->idx; + tmp_loc = constant_locations[i]; + if (tmp_loc != -1) { + /* We found this uniform name in the program - go ahead and send the data */ + GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, constants + (i * 4))); + } + } + checkGLcall("glUniform4fvARB()"); /* Load immediate constants */ if (TRACE_ON(d3d_shader)) { @@ -313,18 +292,11 @@ void shader_glsl_load_constants( if (useVertexShader) { IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader; - IWineD3DVertexDeclarationImpl* vertexDeclaration = (IWineD3DVertexDeclarationImpl*)stateBlock->vertexDecl; GLint pos; constant_locations = stateBlock->glsl_program->vuniformF_locations; constant_list = &stateBlock->set_vconstantsF; - if (NULL != vertexDeclaration && NULL != vertexDeclaration->constants) { - /* Load DirectX 8 float constants/uniforms for vertex shader */ - shader_glsl_load_constantsF(vshader, gl_info, GL_LIMITS(vshader_constantsF), - vertexDeclaration->constants, constant_locations, NULL); - } - /* Load DirectX 9 float constants/uniforms for vertex shader */ shader_glsl_load_constantsF(vshader, gl_info, GL_LIMITS(vshader_constantsF), stateBlock->vertexShaderConstantF, constant_locations, constant_list); diff --git a/dlls/wined3d/vertexdeclaration.c b/dlls/wined3d/vertexdeclaration.c index 019d2c90a6e..d35107153d4 100644 --- a/dlls/wined3d/vertexdeclaration.c +++ b/dlls/wined3d/vertexdeclaration.c @@ -315,35 +315,6 @@ IWineD3DVertexDeclarationImpl *This = (IWineD3DVertexDeclarationImpl *)iface; } else if (D3DVSD_TOKEN_STREAMDATA == tokentype && 0x10000000 & tokentype ) { TRACE(" 0x%08x SKIP(%u)\n", tokentype, ((tokentype & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT)); offset += sizeof(DWORD) * ((tokentype & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT); - } else if (D3DVSD_TOKEN_CONSTMEM == tokentype) { - DWORD i; - DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT); - DWORD constaddress = ((token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT); - if (This->constants == NULL ) { - This->constants = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, - ((IWineD3DImpl*)This->wineD3DDevice->wineD3D)->gl_info.max_vshader_constantsF * 4 * sizeof(float)); - } - TRACE(" 0x%08x CONST(%u, %u)\n", token, constaddress, count); - for (i = 0; i < count; ++i) { - TRACE(" c[%u] = (0x%08x, 0x%08x, 0x%08x, 0x%08x)\n", - constaddress, - *pToken, - *(pToken + 1), - *(pToken + 2), - *(pToken + 3)); - - This->constants[constaddress * 4] = *(const float*) (pToken+ i * 4 + 1); - This->constants[constaddress * 4 + 1] = *(const float *)(pToken + i * 4 + 2); - This->constants[constaddress * 4 + 2] = *(const float *)(pToken + i * 4 + 3); - This->constants[constaddress * 4 + 3] = *(const float *)(pToken + i * 4 + 4); - FIXME(" c[%u] = (%8f, %8f, %8f, %8f)\n", - constaddress, - *(const float*) (pToken+ i * 4 + 1), - *(const float*) (pToken + i * 4 + 2), - *(const float*) (pToken + i * 4 +3), - *(const float*) (pToken + i * 4 + 4)); - ++constaddress; - } } len += tokenlen; @@ -405,7 +376,6 @@ static ULONG WINAPI IWineD3DVertexDeclarationImpl_Release(IWineD3DVertexDeclarat if (ref == 0) { HeapFree(GetProcessHeap(), 0, This->pDeclaration8); HeapFree(GetProcessHeap(), 0, This->pDeclarationWine); - HeapFree(GetProcessHeap(), 0, This->constants); HeapFree(GetProcessHeap(), 0, This); } return ref; diff --git a/dlls/wined3d/vertexshader.c b/dlls/wined3d/vertexshader.c index d9204e0d5fd..52101f23d05 100644 --- a/dlls/wined3d/vertexshader.c +++ b/dlls/wined3d/vertexshader.c @@ -1221,6 +1221,32 @@ static void WINAPI IWineD3DVertexShaderImpl_FakeSemantics(IWineD3DVertexShader * } } +/* Set local constants for d3d8 shaders */ +static HRESULT WINAPI IWIneD3DVertexShaderImpl_SetLocalConstantsF(IWineD3DVertexShader *iface, + UINT start_idx, const float *src_data, UINT count) { + IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface; + UINT i, end_idx; + + TRACE("(%p) : start_idx %u, src_data %p, count %u\n", This, start_idx, src_data, count); + + end_idx = start_idx + count; + if (end_idx > GL_LIMITS(vshader_constantsF)) { + WARN("end_idx %u > float constants limit %u\n", end_idx, GL_LIMITS(vshader_constantsF)); + end_idx = GL_LIMITS(vshader_constantsF); + } + + for (i = start_idx; i < end_idx; ++i) { + local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant)); + if (!lconst) return E_OUTOFMEMORY; + + lconst->idx = i; + CopyMemory(lconst->value, src_data + i * 4, 4 * sizeof(float)); + list_add_head(&This->baseShader.constantsF, &lconst->entry); + } + + return D3D_OK; +} + static HRESULT WINAPI IWineD3DVertexShaderImpl_CompileShader(IWineD3DVertexShader *iface) { IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface; CONST DWORD *function = This->baseShader.function; @@ -1259,5 +1285,6 @@ const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl = /*** IWineD3DVertexShader methods ***/ IWineD3DVertexShaderImpl_GetDevice, IWineD3DVertexShaderImpl_GetFunction, - IWineD3DVertexShaderImpl_FakeSemantics + IWineD3DVertexShaderImpl_FakeSemantics, + IWIneD3DVertexShaderImpl_SetLocalConstantsF }; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 3d8a7ad94b9..647b093ab5c 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1122,9 +1122,6 @@ typedef struct IWineD3DVertexDeclarationImpl { WINED3DVERTEXELEMENT *pDeclarationWine; UINT declarationWNumElements; - - float *constants; - } IWineD3DVertexDeclarationImpl; extern const IWineD3DVertexDeclarationVtbl IWineD3DVertexDeclaration_Vtbl; diff --git a/include/wine/wined3d_interface.h b/include/wine/wined3d_interface.h index 89085976937..d4fc8ea33dd 100644 --- a/include/wine/wined3d_interface.h +++ b/include/wine/wined3d_interface.h @@ -1450,23 +1450,25 @@ DECLARE_INTERFACE_(IWineD3DVertexShader,IWineD3DBaseShader) STDMETHOD(GetDevice)(THIS_ IWineD3DDevice** ppDevice) PURE; STDMETHOD(GetFunction)(THIS_ VOID *pData, UINT *pSizeOfData) PURE; STDMETHOD_(void, FakeSemantics)(THIS_ struct IWineD3DVertexDeclaration *vertex_declaration) PURE; + STDMETHOD(SetLocalConstantsF)(THIS_ UINT start_idx, const float *src_data, UINT count) PURE; }; #undef INTERFACE #if !defined(__cplusplus) || defined(CINTERFACE) /*** IUnknown methods ***/ -#define IWineD3DVertexShader_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) -#define IWineD3DVertexShader_AddRef(p) (p)->lpVtbl->AddRef(p) -#define IWineD3DVertexShader_Release(p) (p)->lpVtbl->Release(p) +#define IWineD3DVertexShader_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IWineD3DVertexShader_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IWineD3DVertexShader_Release(p) (p)->lpVtbl->Release(p) /*** IWineD3DBase methods ***/ -#define IWineD3DVertexShader_GetParent(p,a) (p)->lpVtbl->GetParent(p,a) +#define IWineD3DVertexShader_GetParent(p,a) (p)->lpVtbl->GetParent(p,a) /*** IWineD3DBaseShader methods ***/ -#define IWineD3DVertexShader_SetFunction(p,a) (p)->lpVtbl->SetFunction(p,a) -#define IWineD3DVertexShader_CompileShader(p) (p)->lpVtbl->CompileShader(p) +#define IWineD3DVertexShader_SetFunction(p,a) (p)->lpVtbl->SetFunction(p,a) +#define IWineD3DVertexShader_CompileShader(p) (p)->lpVtbl->CompileShader(p) /*** IWineD3DVertexShader methods ***/ -#define IWineD3DVertexShader_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) -#define IWineD3DVertexShader_GetFunction(p,a,b) (p)->lpVtbl->GetFunction(p,a,b) -#define IWineD3DVertexShader_FakeSemantics(p,a) (p)->lpVtbl->FakeSemantics(p,a) +#define IWineD3DVertexShader_GetDevice(p,a) (p)->lpVtbl->GetDevice(p,a) +#define IWineD3DVertexShader_GetFunction(p,a,b) (p)->lpVtbl->GetFunction(p,a,b) +#define IWineD3DVertexShader_FakeSemantics(p,a) (p)->lpVtbl->FakeSemantics(p,a) +#define IWineD3DVertexShader_SetLocalConstantsF(p,a,b,c) (p)->lpVtbl->SetLocalConstantsF(p,a,b,c) #endif /***************************************************************************** -- 2.11.4.GIT