[PATCH 1/5] wined3d: Introduce wined3d_vertex_declaration_desc.
Józef Kucia
jkucia at codeweavers.com
Mon May 30 07:24:09 CDT 2016
Signed-off-by: Józef Kucia <jkucia at codeweavers.com>
---
dlls/d3d11/inputlayout.c | 26 ++++++++---------
dlls/d3d8/vertexdeclaration.c | 50 +++++++++++++++++++++-----------
dlls/d3d9/vertexdeclaration.c | 62 +++++++++++++++++++---------------------
dlls/wined3d/vertexdeclaration.c | 57 ++++++++++++++++++------------------
dlls/wined3d/wined3d.spec | 2 +-
dlls/wined3d/wined3d_private.h | 2 +-
include/wine/wined3d.h | 8 +++++-
7 files changed, 113 insertions(+), 94 deletions(-)
diff --git a/dlls/d3d11/inputlayout.c b/dlls/d3d11/inputlayout.c
index 69ef985..e7ba9fd 100644
--- a/dlls/d3d11/inputlayout.c
+++ b/dlls/d3d11/inputlayout.c
@@ -41,31 +41,31 @@ static HRESULT isgn_handler(const char *data, DWORD data_size, DWORD tag, void *
static HRESULT d3d11_input_layout_to_wined3d_declaration(const D3D11_INPUT_ELEMENT_DESC *element_descs,
UINT element_count, const void *shader_byte_code, SIZE_T shader_byte_code_length,
- struct wined3d_vertex_element **wined3d_elements)
+ struct wined3d_vertex_declaration_desc *wined3d_desc)
{
struct wined3d_shader_signature is;
+ unsigned int i;
HRESULT hr;
- UINT i;
- hr = parse_dxbc(shader_byte_code, shader_byte_code_length, isgn_handler, &is);
- if (FAILED(hr))
+ if (FAILED(hr = parse_dxbc(shader_byte_code, shader_byte_code_length, isgn_handler, &is)))
{
ERR("Failed to parse input signature.\n");
return E_FAIL;
}
- if (!(*wined3d_elements = d3d11_calloc(element_count, sizeof(**wined3d_elements))))
+ if (!(wined3d_desc->elements = d3d11_calloc(element_count, sizeof(*wined3d_desc->elements))))
{
ERR("Failed to allocate wined3d vertex element array memory.\n");
- HeapFree(GetProcessHeap(), 0, is.elements);
+ shader_free_signature(&is);
return E_OUTOFMEMORY;
}
+ wined3d_desc->element_count = element_count;
for (i = 0; i < element_count; ++i)
{
- struct wined3d_vertex_element *e = &(*wined3d_elements)[i];
+ struct wined3d_vertex_element *e = &wined3d_desc->elements[i];
const D3D11_INPUT_ELEMENT_DESC *f = &element_descs[i];
- UINT j;
+ unsigned int j;
e->format = wined3dformat_from_dxgi_format(f->Format);
e->input_slot = f->InputSlot;
@@ -319,7 +319,7 @@ static HRESULT d3d_input_layout_init(struct d3d_input_layout *layout, struct d3d
const D3D11_INPUT_ELEMENT_DESC *element_descs, UINT element_count,
const void *shader_byte_code, SIZE_T shader_byte_code_length)
{
- struct wined3d_vertex_element *wined3d_elements;
+ struct wined3d_vertex_declaration_desc wined3d_desc;
HRESULT hr;
layout->ID3D11InputLayout_iface.lpVtbl = &d3d11_input_layout_vtbl;
@@ -329,17 +329,17 @@ static HRESULT d3d_input_layout_init(struct d3d_input_layout *layout, struct d3d
wined3d_private_store_init(&layout->private_store);
if (FAILED(hr = d3d11_input_layout_to_wined3d_declaration(element_descs, element_count,
- shader_byte_code, shader_byte_code_length, &wined3d_elements)))
+ shader_byte_code, shader_byte_code_length, &wined3d_desc)))
{
- WARN("Failed to create wined3d vertex declaration elements, hr %#x.\n", hr);
+ WARN("Failed to convert to wined3d vertex declaration desc, hr %#x.\n", hr);
wined3d_private_store_cleanup(&layout->private_store);
wined3d_mutex_unlock();
return hr;
}
- hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, element_count,
+ hr = wined3d_vertex_declaration_create(device->wined3d_device, &wined3d_desc,
layout, &d3d_input_layout_wined3d_parent_ops, &layout->wined3d_decl);
- HeapFree(GetProcessHeap(), 0, wined3d_elements);
+ HeapFree(GetProcessHeap(), 0, wined3d_desc.elements);
if (FAILED(hr))
{
WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
diff --git a/dlls/d3d8/vertexdeclaration.c b/dlls/d3d8/vertexdeclaration.c
index 7900325..d6a1e81 100644
--- a/dlls/d3d8/vertexdeclaration.c
+++ b/dlls/d3d8/vertexdeclaration.c
@@ -253,8 +253,8 @@ wined3d_usage_lookup[] =
};
/* TODO: find out where rhw (or positionT) is for declaration8 */
-static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3d8_elements_size,
- struct wined3d_vertex_element **wined3d_elements)
+static HRESULT convert_to_wined3d_declaration_desc(const DWORD *d3d8_elements, DWORD *d3d8_elements_size,
+ struct wined3d_vertex_declaration_desc *wined3d_desc)
{
struct wined3d_vertex_element *element;
const DWORD *token = d3d8_elements;
@@ -263,10 +263,17 @@ static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3
WORD stream = 0;
int offset = 0;
- TRACE("d3d8_elements %p, d3d8_elements_size %p, wined3d_elements %p\n", d3d8_elements, d3d8_elements_size, wined3d_elements);
+ TRACE("d3d8_elements %p, d3d8_elements_size %p, wined3d_desc %p.\n",
+ d3d8_elements, d3d8_elements_size, wined3d_desc);
/* 128 should be enough for anyone... */
- *wined3d_elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 128 * sizeof(**wined3d_elements));
+ if (!(wined3d_desc->elements = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+ 128 * sizeof(*wined3d_desc->elements))))
+ {
+ ERR("Out of memory.\n");
+ return E_OUTOFMEMORY;
+ }
+
while (D3DVSD_END() != *token)
{
token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
@@ -275,13 +282,15 @@ static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3
{
stream = ((*token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
offset = 0;
- } else if (token_type == D3DVSD_TOKEN_STREAMDATA && !(*token & D3DVSD_DATALOADTYPEMASK)) {
+ }
+ else if (token_type == D3DVSD_TOKEN_STREAMDATA && !(*token & D3DVSD_DATALOADTYPEMASK))
+ {
DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
DWORD reg = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
TRACE("Adding element %d:\n", element_count);
- element = *wined3d_elements + element_count++;
+ element = wined3d_desc->elements + element_count++;
element->format = wined3d_format_lookup[type];
element->input_slot = stream;
element->offset = offset;
@@ -293,12 +302,15 @@ static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3
element->usage_idx = wined3d_usage_lookup[reg].usage_idx;
offset += wined3d_type_sizes[type];
- } else if (token_type == D3DVSD_TOKEN_STREAMDATA && (*token & D3DVSD_DATALOADTYPEMASK)) {
+ }
+ else if (token_type == D3DVSD_TOKEN_STREAMDATA && (*token & D3DVSD_DATALOADTYPEMASK))
+ {
TRACE(" 0x%08x SKIP(%u)\n", token_type, ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
offset += sizeof(DWORD) * ((token_type & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
}
- if (element_count >= 127) {
+ if (element_count >= 127)
+ {
ERR("More than 127 elements?\n");
break;
}
@@ -307,8 +319,9 @@ static UINT convert_to_wined3d_declaration(const DWORD *d3d8_elements, DWORD *d3
}
*d3d8_elements_size = (++token - d3d8_elements) * sizeof(DWORD);
+ wined3d_desc->element_count = element_count;
- return element_count;
+ return D3D_OK;
}
static void STDMETHODCALLTYPE d3d8_vertexdeclaration_wined3d_object_destroyed(void *parent)
@@ -335,28 +348,31 @@ static const struct wined3d_parent_ops d3d8_vertexdeclaration_wined3d_parent_ops
HRESULT d3d8_vertex_declaration_init(struct d3d8_vertex_declaration *declaration,
struct d3d8_device *device, const DWORD *elements, DWORD shader_handle)
{
- struct wined3d_vertex_element *wined3d_elements;
- UINT wined3d_element_count;
+ struct wined3d_vertex_declaration_desc wined3d_desc;
HRESULT hr;
declaration->shader_handle = shader_handle;
- wined3d_element_count = convert_to_wined3d_declaration(elements, &declaration->elements_size, &wined3d_elements);
- declaration->elements = HeapAlloc(GetProcessHeap(), 0, declaration->elements_size);
- if (!declaration->elements)
+ if (FAILED(hr = convert_to_wined3d_declaration_desc(elements, &declaration->elements_size, &wined3d_desc)))
+ {
+ WARN("Failed to convert to wined3d vertex declaration desc, hr %#x.\n", hr);
+ return hr;
+ }
+
+ if (!(declaration->elements = HeapAlloc(GetProcessHeap(), 0, declaration->elements_size)))
{
ERR("Failed to allocate vertex declaration elements memory.\n");
- HeapFree(GetProcessHeap(), 0, wined3d_elements);
+ HeapFree(GetProcessHeap(), 0, wined3d_desc.elements);
return E_OUTOFMEMORY;
}
memcpy(declaration->elements, elements, declaration->elements_size);
wined3d_mutex_lock();
- hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count,
+ hr = wined3d_vertex_declaration_create(device->wined3d_device, &wined3d_desc,
declaration, &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
wined3d_mutex_unlock();
- HeapFree(GetProcessHeap(), 0, wined3d_elements);
+ HeapFree(GetProcessHeap(), 0, wined3d_desc.elements);
if (FAILED(hr))
{
WARN("Failed to create wined3d vertex declaration, hr %#x.\n", hr);
diff --git a/dlls/d3d9/vertexdeclaration.c b/dlls/d3d9/vertexdeclaration.c
index 914de24..4510544 100644
--- a/dlls/d3d9/vertexdeclaration.c
+++ b/dlls/d3d9/vertexdeclaration.c
@@ -319,76 +319,72 @@ static const struct wined3d_parent_ops d3d9_vertexdeclaration_wined3d_parent_ops
d3d9_vertexdeclaration_wined3d_object_destroyed,
};
-static HRESULT convert_to_wined3d_declaration(const D3DVERTEXELEMENT9 *d3d9_elements,
- struct wined3d_vertex_element **wined3d_elements, UINT *element_count)
+static HRESULT convert_to_wined3d_declaration_desc(const D3DVERTEXELEMENT9 *d3d9_elements,
+ struct wined3d_vertex_declaration_desc *wined3d_desc)
{
const D3DVERTEXELEMENT9* element;
- UINT count = 1;
- UINT i;
+ unsigned int i, count = 1;
- TRACE("d3d9_elements %p, wined3d_elements %p, element_count %p\n", d3d9_elements, wined3d_elements, element_count);
+ TRACE("d3d9_elements %p, wined3d_desc %p.\n", d3d9_elements, wined3d_desc);
element = d3d9_elements;
while (element++->Stream != 0xff && count++ < 128);
- if (count == 128) return E_FAIL;
+ if (count == 128)
+ return E_FAIL;
/* Skip the END element */
--count;
- *wined3d_elements = HeapAlloc(GetProcessHeap(), 0, count * sizeof(**wined3d_elements));
- if (!*wined3d_elements) {
- FIXME("Memory allocation failed\n");
+ if (!(wined3d_desc->elements = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*wined3d_desc->elements))))
+ {
+ FIXME("Memory allocation failed.\n");
return D3DERR_OUTOFVIDEOMEMORY;
}
+ wined3d_desc->element_count = count;
for (i = 0; i < count; ++i)
{
if (d3d9_elements[i].Type >= (sizeof(d3d_dtype_lookup) / sizeof(*d3d_dtype_lookup)))
{
WARN("Invalid element type %#x.\n", d3d9_elements[i].Type);
- HeapFree(GetProcessHeap(), 0, *wined3d_elements);
+ HeapFree(GetProcessHeap(), 0, wined3d_desc->elements);
return E_FAIL;
}
- (*wined3d_elements)[i].format = d3d_dtype_lookup[d3d9_elements[i].Type].format;
- (*wined3d_elements)[i].input_slot = d3d9_elements[i].Stream;
- (*wined3d_elements)[i].offset = d3d9_elements[i].Offset;
- (*wined3d_elements)[i].output_slot = WINED3D_OUTPUT_SLOT_SEMANTIC;
- (*wined3d_elements)[i].input_slot_class = WINED3D_INPUT_PER_VERTEX_DATA;
- (*wined3d_elements)[i].instance_data_step_rate = 0;
- (*wined3d_elements)[i].method = d3d9_elements[i].Method;
- (*wined3d_elements)[i].usage = d3d9_elements[i].Usage;
- (*wined3d_elements)[i].usage_idx = d3d9_elements[i].UsageIndex;
+ wined3d_desc->elements[i].format = d3d_dtype_lookup[d3d9_elements[i].Type].format;
+ wined3d_desc->elements[i].input_slot = d3d9_elements[i].Stream;
+ wined3d_desc->elements[i].offset = d3d9_elements[i].Offset;
+ wined3d_desc->elements[i].output_slot = WINED3D_OUTPUT_SLOT_SEMANTIC;
+ wined3d_desc->elements[i].input_slot_class = WINED3D_INPUT_PER_VERTEX_DATA;
+ wined3d_desc->elements[i].instance_data_step_rate = 0;
+ wined3d_desc->elements[i].method = d3d9_elements[i].Method;
+ wined3d_desc->elements[i].usage = d3d9_elements[i].Usage;
+ wined3d_desc->elements[i].usage_idx = d3d9_elements[i].UsageIndex;
}
- *element_count = count;
-
return D3D_OK;
}
static HRESULT vertexdeclaration_init(struct d3d9_vertex_declaration *declaration,
struct d3d9_device *device, const D3DVERTEXELEMENT9 *elements)
{
- struct wined3d_vertex_element *wined3d_elements;
- UINT wined3d_element_count;
- UINT element_count;
+ struct wined3d_vertex_declaration_desc wined3d_desc;
+ unsigned int element_count;
HRESULT hr;
- hr = convert_to_wined3d_declaration(elements, &wined3d_elements, &wined3d_element_count);
- if (FAILED(hr))
+ if (FAILED(hr = convert_to_wined3d_declaration_desc(elements, &wined3d_desc)))
{
- WARN("Failed to create wined3d vertex declaration elements, hr %#x.\n", hr);
+ WARN("Failed to convert to wined3d vertex declaration desc, hr %#x.\n", hr);
return hr;
}
declaration->IDirect3DVertexDeclaration9_iface.lpVtbl = &d3d9_vertex_declaration_vtbl;
declaration->refcount = 1;
- element_count = wined3d_element_count + 1;
- declaration->elements = HeapAlloc(GetProcessHeap(), 0, element_count * sizeof(*declaration->elements));
- if (!declaration->elements)
+ element_count = wined3d_desc.element_count + 1;
+ if (!(declaration->elements = HeapAlloc(GetProcessHeap(), 0, element_count * sizeof(*declaration->elements))))
{
- HeapFree(GetProcessHeap(), 0, wined3d_elements);
+ HeapFree(GetProcessHeap(), 0, wined3d_desc.elements);
ERR("Failed to allocate vertex declaration elements memory.\n");
return D3DERR_OUTOFVIDEOMEMORY;
}
@@ -396,10 +392,10 @@ static HRESULT vertexdeclaration_init(struct d3d9_vertex_declaration *declaratio
declaration->element_count = element_count;
wined3d_mutex_lock();
- hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count,
+ hr = wined3d_vertex_declaration_create(device->wined3d_device, &wined3d_desc,
declaration, &d3d9_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_declaration);
wined3d_mutex_unlock();
- HeapFree(GetProcessHeap(), 0, wined3d_elements);
+ HeapFree(GetProcessHeap(), 0, wined3d_desc.elements);
if (FAILED(hr))
{
HeapFree(GetProcessHeap(), 0, declaration->elements);
diff --git a/dlls/wined3d/vertexdeclaration.c b/dlls/wined3d/vertexdeclaration.c
index febd695..ce2ccad 100644
--- a/dlls/wined3d/vertexdeclaration.c
+++ b/dlls/wined3d/vertexdeclaration.c
@@ -161,35 +161,34 @@ static BOOL declaration_element_valid_ffp(const struct wined3d_vertex_element *e
}
}
-static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declaration,
- struct wined3d_device *device, const struct wined3d_vertex_element *elements, UINT element_count,
+static HRESULT vertex_declaration_init(struct wined3d_vertex_declaration *declaration,
+ struct wined3d_device *device, const struct wined3d_vertex_declaration_desc *desc,
void *parent, const struct wined3d_parent_ops *parent_ops)
{
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
+ const struct wined3d_vertex_element *elements = desc->elements;
unsigned int i;
if (TRACE_ON(d3d_decl))
{
- for (i = 0; i < element_count; ++i)
- {
+ for (i = 0; i < desc->element_count; ++i)
dump_wined3d_vertex_element(elements + i);
- }
}
declaration->ref = 1;
declaration->parent = parent;
declaration->parent_ops = parent_ops;
declaration->device = device;
- if (!(declaration->elements = wined3d_calloc(element_count, sizeof(*declaration->elements))))
+ if (!(declaration->elements = wined3d_calloc(desc->element_count, sizeof(*declaration->elements))))
{
ERR("Failed to allocate elements memory.\n");
return E_OUTOFMEMORY;
}
- declaration->element_count = element_count;
+ declaration->element_count = desc->element_count;
/* Do some static analysis on the elements to make reading the
* declaration more comfortable for the drawing code. */
- for (i = 0; i < element_count; ++i)
+ for (i = 0; i < desc->element_count; ++i)
{
struct wined3d_vertex_declaration_element *e = &declaration->elements[i];
@@ -238,7 +237,7 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara
if (e->offset & 0x3)
{
- WARN("Declaration element %u is not 4 byte aligned(%u), returning E_FAIL.\n", i, e->offset);
+ WARN("Declaration element %u is not 4 byte aligned (%u), returning E_FAIL.\n", i, e->offset);
HeapFree(GetProcessHeap(), 0, declaration->elements);
return E_FAIL;
}
@@ -253,21 +252,19 @@ static HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declara
}
HRESULT CDECL wined3d_vertex_declaration_create(struct wined3d_device *device,
- const struct wined3d_vertex_element *elements, UINT element_count, void *parent,
+ const struct wined3d_vertex_declaration_desc *desc, void *parent,
const struct wined3d_parent_ops *parent_ops, struct wined3d_vertex_declaration **declaration)
{
struct wined3d_vertex_declaration *object;
HRESULT hr;
- TRACE("device %p, elements %p, element_count %u, parent %p, parent_ops %p, declaration %p.\n",
- device, elements, element_count, parent, parent_ops, declaration);
+ TRACE("device %p, desc %p, parent %p, parent_ops %p, declaration %p.\n",
+ device, desc, parent, parent_ops, declaration);
- object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
- if(!object)
+ if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
return E_OUTOFMEMORY;
- hr = vertexdeclaration_init(object, device, elements, element_count, parent, parent_ops);
- if (FAILED(hr))
+ if (FAILED(hr = vertex_declaration_init(object, device, desc, parent, parent_ops)))
{
WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, object);
@@ -311,8 +308,8 @@ static void append_decl_element(struct wined3d_fvf_convert_state *state,
++state->idx;
}
-static unsigned int convert_fvf_to_declaration(const struct wined3d_gl_info *gl_info,
- DWORD fvf, struct wined3d_vertex_element **elements)
+static HRESULT convert_fvf_to_declaration(const struct wined3d_gl_info *gl_info,
+ DWORD fvf, struct wined3d_vertex_declaration_desc *desc)
{
BOOL has_pos = !!(fvf & WINED3DFVF_POSITION_MASK);
BOOL has_blend = (fvf & WINED3DFVF_XYZB5) > WINED3DFVF_XYZRHW;
@@ -339,7 +336,7 @@ static unsigned int convert_fvf_to_declaration(const struct wined3d_gl_info *gl_
state.gl_info = gl_info;
if (!(state.elements = wined3d_calloc(size, sizeof(*state.elements))))
- return ~0u;
+ return E_OUTOFMEMORY;
state.offset = 0;
state.idx = 0;
@@ -418,25 +415,29 @@ static unsigned int convert_fvf_to_declaration(const struct wined3d_gl_info *gl_
}
}
- *elements = state.elements;
- return size;
+ desc->elements = state.elements;
+ desc->element_count = size;
+
+ return WINED3D_OK;
}
HRESULT CDECL wined3d_vertex_declaration_create_from_fvf(struct wined3d_device *device,
DWORD fvf, void *parent, const struct wined3d_parent_ops *parent_ops,
struct wined3d_vertex_declaration **declaration)
{
- struct wined3d_vertex_element *elements;
- unsigned int size;
- DWORD hr;
+ struct wined3d_vertex_declaration_desc desc;
+ HRESULT hr;
TRACE("device %p, fvf %#x, parent %p, parent_ops %p, declaration %p.\n",
device, fvf, parent, parent_ops, declaration);
- size = convert_fvf_to_declaration(&device->adapter->gl_info, fvf, &elements);
- if (size == ~0U) return E_OUTOFMEMORY;
+ if (FAILED(hr = convert_fvf_to_declaration(&device->adapter->gl_info, fvf, &desc)))
+ {
+ WARN("Failed to convert FVF to vertex declaration desc, hr %#x.\n", hr);
+ return hr;
+ }
- hr = wined3d_vertex_declaration_create(device, elements, size, parent, parent_ops, declaration);
- HeapFree(GetProcessHeap(), 0, elements);
+ hr = wined3d_vertex_declaration_create(device, &desc, parent, parent_ops, declaration);
+ HeapFree(GetProcessHeap(), 0, desc.elements);
return hr;
}
diff --git a/dlls/wined3d/wined3d.spec b/dlls/wined3d/wined3d.spec
index 01699df..304918e 100644
--- a/dlls/wined3d/wined3d.spec
+++ b/dlls/wined3d/wined3d.spec
@@ -266,7 +266,7 @@
@ cdecl wined3d_texture_update_desc(ptr long long long long long ptr long)
@ cdecl wined3d_texture_update_overlay(ptr long ptr ptr long ptr long)
-@ cdecl wined3d_vertex_declaration_create(ptr ptr long ptr ptr ptr)
+@ cdecl wined3d_vertex_declaration_create(ptr ptr ptr ptr ptr)
@ cdecl wined3d_vertex_declaration_create_from_fvf(ptr long ptr ptr ptr)
@ cdecl wined3d_vertex_declaration_decref(ptr)
@ cdecl wined3d_vertex_declaration_get_parent(ptr)
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 6a8bbcb..04f67f2 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -2781,7 +2781,7 @@ struct wined3d_vertex_declaration
struct wined3d_device *device;
struct wined3d_vertex_declaration_element *elements;
- UINT element_count;
+ unsigned int element_count;
BOOL position_transformed;
BOOL half_float_conv_needed;
diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h
index d5415e0..d411b8c 100644
--- a/include/wine/wined3d.h
+++ b/include/wine/wined3d.h
@@ -1681,6 +1681,12 @@ struct wined3d_vertex_element
BYTE usage_idx;
};
+struct wined3d_vertex_declaration_desc
+{
+ struct wined3d_vertex_element *elements;
+ unsigned int element_count;
+};
+
struct wined3d_device_creation_parameters
{
UINT adapter_idx;
@@ -2495,7 +2501,7 @@ HRESULT __cdecl wined3d_texture_update_overlay(struct wined3d_texture *texture,
const RECT *dst_rect, DWORD flags);
HRESULT __cdecl wined3d_vertex_declaration_create(struct wined3d_device *device,
- const struct wined3d_vertex_element *elements, UINT element_count, void *parent,
+ const struct wined3d_vertex_declaration_desc *desc, void *parent,
const struct wined3d_parent_ops *parent_ops, struct wined3d_vertex_declaration **declaration);
HRESULT __cdecl wined3d_vertex_declaration_create_from_fvf(struct wined3d_device *device,
DWORD fvf, void *parent, const struct wined3d_parent_ops *parent_ops,
--
2.7.3
More information about the wine-patches
mailing list