From: Józef Kucia Subject: [PATCH 1/5] wined3d: Introduce wined3d_vertex_declaration_desc. Message-Id: <1464611053-9504-1-git-send-email-jkucia@codeweavers.com> Date: Mon, 30 May 2016 14:24:09 +0200 Signed-off-by: Józef Kucia --- 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