[8/9] d3d8: Move loading local d3d8 vertex shader constants from
wined3d to d3d8
H. Verbeet
hverbeet at gmail.com
Tue Feb 13 16:12:40 CST 2007
In d3d8 local shader constants are stored in the vertex declaration.
Since this is quite specific to d3d8, it shouldn't be in wined3d.
Changelog:
- Move loading local d3d8 vertex shader constants from wined3d to d3d8
-------------- next part --------------
---
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 d35f351..2931eb7 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 04352d4..a5aa2d1 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 fa05903..3fbe6aa 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 6da40cc..86e8430 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 1388c88..dab9452 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 8022e5b..9869b9c 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 d9204e0..52101f2 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 3d8a7ad..647b093 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 8908597..d4fc8ea 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
/*****************************************************************************
More information about the wine-patches
mailing list