- wine-devel - winehq.org

[PATCH 1/2] hostname: Use GetComputerNameW to get hostname.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- programs/hostname/Makefile.in | 1 - programs/hostname/hostname.c | 31 +++++++++++++------------------ programs/hostname/hostname.h | 3 ++- programs/hostname/hostname.rc | 1 + 4 files changed, 16 insertions(+), 20 deletions(-)

1 0

[PATCH 3/3] wined3d: Drop support for pre-parsed shader DXBC chunks.
by Józef Kucia 05 Oct '18

05 Oct '18

Accept only full DXBC. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/shader.c | 6 -- dlls/d3d8/shader.c | 8 -- dlls/d3d9/shader.c | 8 -- dlls/wined3d/shader.c | 195 +++++++++++------------------------------ dlls/wined3d/wined3d_private.h | 7 +- include/wine/wined3d.h | 11 --- 6 files changed, 55 insertions(+), 180 deletions(-) diff --git a/dlls/d3d11/shader.c b/dlls/d3d11/shader.c index 4b4969135387..3f5c6e147482 100644 --- a/dlls/d3d11/shader.c +++ b/dlls/d3d11/shader.c @@ -394,7 +394,6 @@ static HRESULT d3d_vertex_shader_init(struct d3d_vertex_shader *shader, struct d desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader))) { @@ -598,7 +597,6 @@ static HRESULT d3d11_hull_shader_init(struct d3d11_hull_shader *shader, struct d desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader, &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader))) { @@ -792,7 +790,6 @@ static HRESULT d3d11_domain_shader_init(struct d3d11_domain_shader *shader, stru desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader, &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader))) { @@ -1293,7 +1290,6 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; memset(&so_desc, 0, sizeof(so_desc)); if (so_entries) @@ -1645,7 +1641,6 @@ static HRESULT d3d_pixel_shader_init(struct d3d_pixel_shader *shader, struct d3d desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader))) { @@ -1847,7 +1842,6 @@ static HRESULT d3d11_compute_shader_init(struct d3d11_compute_shader *shader, st desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_cs(device->wined3d_device, &desc, shader, &d3d11_compute_shader_wined3d_parent_ops, &shader->wined3d_shader))) { diff --git a/dlls/d3d8/shader.c b/dlls/d3d8/shader.c index 8a6881200e8b..2a4fbde88c09 100644 --- a/dlls/d3d8/shader.c +++ b/dlls/d3d8/shader.c @@ -117,10 +117,6 @@ HRESULT d3d8_vertex_shader_init(struct d3d8_vertex_shader *shader, struct d3d8_d desc.byte_code = byte_code; desc.byte_code_size = ~(size_t)0; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - desc.input_signature.element_count = 0; - desc.output_signature.element_count = 0; - desc.patch_constant_signature.element_count = 0; wined3d_mutex_lock(); hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, @@ -168,10 +164,6 @@ HRESULT d3d8_pixel_shader_init(struct d3d8_pixel_shader *shader, struct d3d8_dev desc.byte_code = byte_code; desc.byte_code_size = ~(size_t)0; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - desc.input_signature.element_count = 0; - desc.output_signature.element_count = 0; - desc.patch_constant_signature.element_count = 0; wined3d_mutex_lock(); hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, diff --git a/dlls/d3d9/shader.c b/dlls/d3d9/shader.c index 5fc356c8e8af..bc347386b85d 100644 --- a/dlls/d3d9/shader.c +++ b/dlls/d3d9/shader.c @@ -144,10 +144,6 @@ HRESULT vertexshader_init(struct d3d9_vertexshader *shader, struct d3d9_device * desc.byte_code = byte_code; desc.byte_code_size = ~(size_t)0; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - desc.input_signature.element_count = 0; - desc.output_signature.element_count = 0; - desc.patch_constant_signature.element_count = 0; wined3d_mutex_lock(); hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, @@ -297,10 +293,6 @@ HRESULT pixelshader_init(struct d3d9_pixelshader *shader, struct d3d9_device *de desc.byte_code = byte_code; desc.byte_code_size = ~(size_t)0; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - desc.input_signature.element_count = 0; - desc.output_signature.element_count = 0; - desc.patch_constant_signature.element_count = 0; wined3d_mutex_lock(); hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index ecff0bc299a6..ce45298b539d 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -3150,7 +3150,6 @@ static void shader_cleanup(struct wined3d_shader *shader) heap_free(shader->patch_constant_signature.elements); heap_free(shader->output_signature.elements); heap_free(shader->input_signature.elements); - heap_free(shader->signature_strings); shader->device->shader_backend->shader_destroy(shader); shader_cleanup_reg_maps(&shader->reg_maps); heap_free(shader->byte_code); @@ -3598,107 +3597,12 @@ BOOL vshader_get_input(const struct wined3d_shader *shader, return FALSE; } -static HRESULT shader_signature_calculate_strings_length(const struct wined3d_shader_signature *signature, - SIZE_T *total) -{ - struct wined3d_shader_signature_element *e; - unsigned int i; - SIZE_T len; - - for (i = 0; i < signature->element_count; ++i) - { - e = &signature->elements[i]; - len = strlen(e->semantic_name); - if (len >= ~(SIZE_T)0 - *total) - return E_OUTOFMEMORY; - - *total += len + 1; - } - return WINED3D_OK; -} - -static HRESULT shader_signature_copy(struct wined3d_shader_signature *dst, - const struct wined3d_shader_signature *src, char **signature_strings) -{ - struct wined3d_shader_signature_element *e; - unsigned int i; - SIZE_T len; - char *ptr; - - if (!src->element_count) - return WINED3D_OK; - - ptr = *signature_strings; - - dst->element_count = src->element_count; - if (!(dst->elements = heap_calloc(dst->element_count, sizeof(*dst->elements)))) - return E_OUTOFMEMORY; - - for (i = 0; i < src->element_count; ++i) - { - e = &src->elements[i]; - dst->elements[i] = *e; - - len = strlen(e->semantic_name); - memcpy(ptr, e->semantic_name, len + 1); - dst->elements[i].semantic_name = ptr; - ptr += len + 1; - } - - *signature_strings = ptr; - - return WINED3D_OK; -} - -static HRESULT shader_copy_signatures_from_shader_desc(struct wined3d_shader *shader, - const struct wined3d_shader_desc *desc) -{ - SIZE_T total; - HRESULT hr; - char *ptr; - - total = 0; - if (FAILED(hr = shader_signature_calculate_strings_length(&desc->input_signature, &total))) - return hr; - if (FAILED(hr = shader_signature_calculate_strings_length(&desc->output_signature, &total))) - return hr; - if (FAILED(hr = shader_signature_calculate_strings_length(&desc->patch_constant_signature, &total))) - return hr; - if (total && !(shader->signature_strings = heap_alloc(total))) - return E_OUTOFMEMORY; - ptr = shader->signature_strings; - - if (FAILED(hr = shader_signature_copy(&shader->input_signature, &desc->input_signature, &ptr))) - { - heap_free(shader->signature_strings); - return hr; - } - if (FAILED(hr = shader_signature_copy(&shader->output_signature, &desc->output_signature, &ptr))) - { - heap_free(shader->input_signature.elements); - heap_free(shader->signature_strings); - return hr; - } - if (FAILED(hr = shader_signature_copy(&shader->patch_constant_signature, &desc->patch_constant_signature, &ptr))) - { - heap_free(shader->output_signature.elements); - heap_free(shader->input_signature.elements); - heap_free(shader->signature_strings); - return hr; - } - - return S_OK; -} - static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops) { - enum wined3d_shader_byte_code_format format; - unsigned int max_version; HRESULT hr; - TRACE("byte_code %p, byte_code_size %#lx, format %#x.\n", - desc->byte_code, (long)desc->byte_code_size, desc->format); + TRACE("byte_code %p, byte_code_size %#lx.\n", desc->byte_code, (long)desc->byte_code_size); if (!desc->byte_code) return WINED3DERR_INVALIDCALL; @@ -3716,74 +3620,73 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device list_init(&shader->reg_maps.indexable_temps); list_init(&shader->shader_list_entry); - format = desc->format; - if (format == WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC) + if (desc->byte_code_size == ~(size_t)0) { - if (!(shader->byte_code = heap_alloc(desc->byte_code_size))) + struct wined3d_shader_version shader_version; + const struct wined3d_shader_frontend *fe; + struct wined3d_shader_instruction ins; + const DWORD *ptr; + void *fe_data; + + if (!(shader->frontend = shader_select_frontend(WINED3D_SHADER_BYTE_CODE_FORMAT_SM1))) { - hr = E_OUTOFMEMORY; + FIXME("Unable to find frontend for shader.\n"); + hr = WINED3DERR_INVALIDCALL; goto fail; } - memcpy(shader->byte_code, desc->byte_code, desc->byte_code_size); - shader->byte_code_size = desc->byte_code_size; - - max_version = shader_max_version_from_feature_level(device->feature_level); - if (FAILED(hr = shader_extract_from_dxbc(shader, max_version, &format))) - goto fail; - } - else if (FAILED(hr = shader_copy_signatures_from_shader_desc(shader, desc))) - { - goto fail; - } - - if (!(shader->frontend = shader_select_frontend(format))) - { - FIXME("Unable to find frontend for shader.\n"); - hr = WINED3DERR_INVALIDCALL; - goto fail; - } - - if (!shader->byte_code) - { - size_t byte_code_size = desc->byte_code_size; - if (byte_code_size == ~(size_t)0) + fe = shader->frontend; + if (!(fe_data = fe->shader_init(desc->byte_code, desc->byte_code_size, &shader->output_signature))) { - const struct wined3d_shader_frontend *fe = shader->frontend; - struct wined3d_shader_version shader_version; - struct wined3d_shader_instruction ins; - const DWORD *ptr; - void *fe_data; + WARN("Failed to initialise frontend data.\n"); + hr = WINED3DERR_INVALIDCALL; + goto fail; + } - if (!(fe_data = fe->shader_init(desc->byte_code, byte_code_size, &shader->output_signature))) - { - WARN("Failed to initialise frontend data.\n"); - hr = WINED3DERR_INVALIDCALL; - goto fail; - } + fe->shader_read_header(fe_data, &ptr, &shader_version); + while (!fe->shader_is_end(fe_data, &ptr)) + fe->shader_read_instruction(fe_data, &ptr, &ins); - fe->shader_read_header(fe_data, &ptr, &shader_version); - while (!fe->shader_is_end(fe_data, &ptr)) - fe->shader_read_instruction(fe_data, &ptr, &ins); + fe->shader_free(fe_data); - fe->shader_free(fe_data); + shader->byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr); - byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr); - } - - if (!(shader->byte_code = heap_alloc(byte_code_size))) + if (!(shader->byte_code = heap_alloc(shader->byte_code_size))) { hr = E_OUTOFMEMORY; goto fail; } - memcpy(shader->byte_code, desc->byte_code, byte_code_size); - shader->byte_code_size = byte_code_size; + memcpy(shader->byte_code, desc->byte_code, shader->byte_code_size); shader->function = shader->byte_code; shader->functionLength = shader->byte_code_size; } + else + { + enum wined3d_shader_byte_code_format format; + unsigned int max_version; - return hr; + if (!(shader->byte_code = heap_alloc(desc->byte_code_size))) + { + hr = E_OUTOFMEMORY; + goto fail; + } + memcpy(shader->byte_code, desc->byte_code, desc->byte_code_size); + shader->byte_code_size = desc->byte_code_size; + + max_version = shader_max_version_from_feature_level(device->feature_level); + if (FAILED(hr = shader_extract_from_dxbc(shader, max_version, &format))) + goto fail; + + if (!(shader->frontend = shader_select_frontend(format))) + { + FIXME("Unable to find frontend for shader.\n"); + hr = WINED3DERR_INVALIDCALL; + goto fail; + } + } + + return WINED3D_OK; fail: shader_cleanup(shader); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 221b9472aa67..b5e3c79d4fc2 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -397,6 +397,12 @@ struct wined3d_settings extern struct wined3d_settings wined3d_settings DECLSPEC_HIDDEN; +enum wined3d_shader_byte_code_format +{ + WINED3D_SHADER_BYTE_CODE_FORMAT_SM1, + WINED3D_SHADER_BYTE_CODE_FORMAT_SM4, +}; + enum wined3d_shader_resource_type { WINED3D_SHADER_RESOURCE_NONE, @@ -4108,7 +4114,6 @@ struct wined3d_shader struct wined3d_shader_signature input_signature; struct wined3d_shader_signature output_signature; struct wined3d_shader_signature patch_constant_signature; - char *signature_strings; /* Pointer to the parent device */ struct wined3d_device *device; diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 297192f7c703..8197a8682ae5 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -854,13 +854,6 @@ enum wined3d_display_rotation WINED3D_DISPLAY_ROTATION_270 = 4, }; -enum wined3d_shader_byte_code_format -{ - WINED3D_SHADER_BYTE_CODE_FORMAT_SM1 = 0, - WINED3D_SHADER_BYTE_CODE_FORMAT_SM4 = 1, - WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC = 2, -}; - enum wined3d_shader_type { WINED3D_SHADER_TYPE_PIXEL, @@ -2062,10 +2055,6 @@ struct wined3d_shader_desc { const DWORD *byte_code; size_t byte_code_size; - enum wined3d_shader_byte_code_format format; - struct wined3d_shader_signature input_signature; - struct wined3d_shader_signature output_signature; - struct wined3d_shader_signature patch_constant_signature; }; struct wined3d_stream_output_element -- 2.16.4

2 1

[PATCH 2/3] d3d11: Pass full DXBC to wined3d.
by Józef Kucia 05 Oct '18

05 Oct '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/shader.c | 264 ++++++++++------------------------------------------ 1 file changed, 49 insertions(+), 215 deletions(-) diff --git a/dlls/d3d11/shader.c b/dlls/d3d11/shader.c index a1da9effc2b8..4b4969135387 100644 --- a/dlls/d3d11/shader.c +++ b/dlls/d3d11/shader.c @@ -24,156 +24,19 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d11); -struct aon9_header +static HRESULT osgn_handler(const char *data, DWORD data_size, DWORD tag, void *context) { - DWORD chunk_size; - DWORD shader_version; - DWORD unknown; - DWORD byte_code_offset; -}; - -struct shader_handler_context -{ - D3D_FEATURE_LEVEL feature_level; - struct wined3d_shader_desc *desc; -}; - -static HRESULT shdr_handler(const char *data, DWORD data_size, DWORD tag, void *context) -{ - const struct shader_handler_context *ctx = context; - struct wined3d_shader_desc *desc = ctx->desc; - HRESULT hr; - - switch (tag) - { - case TAG_ISGN: - if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3) - { - TRACE("Skipping shader input signature on feature level %#x.\n", ctx->feature_level); - break; - } - if (desc->input_signature.elements) - { - FIXME("Multiple input signatures.\n"); - break; - } - if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->input_signature))) - return hr; - break; - - case TAG_OSGN: - case TAG_OSG5: - if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3) - { - TRACE("Skipping shader output signature on feature level %#x.\n", ctx->feature_level); - break; - } - if (desc->output_signature.elements) - { - FIXME("Multiple output signatures.\n"); - break; - } - if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->output_signature))) - return hr; - break; - - case TAG_PCSG: - if (desc->patch_constant_signature.elements) - { - FIXME("Multiple patch constant signatures.\n"); - break; - } - if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->patch_constant_signature))) - return hr; - break; - - case TAG_SHDR: - case TAG_SHEX: - if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3) - { - TRACE("Skipping SM4+ shader code on feature level %#x.\n", ctx->feature_level); - break; - } - if (desc->byte_code) - FIXME("Multiple shader code chunks.\n"); - desc->byte_code = (const DWORD *)data; - desc->byte_code_size = data_size; - desc->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM4; - break; - - case TAG_AON9: - if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3) - { - const struct aon9_header *header = (const struct aon9_header *)data; - unsigned int unknown_dword_count; - const char *byte_code; - - if (data_size < sizeof(*header)) - { - WARN("Invalid Aon9 data size %#x.\n", data_size); - return E_FAIL; - } - byte_code = data + header->byte_code_offset; - unknown_dword_count = (header->byte_code_offset - sizeof(*header)) / sizeof(DWORD); - - if (data_size - 2 * sizeof(DWORD) < header->byte_code_offset) - { - WARN("Invalid byte code offset %#x (size %#x).\n", header->byte_code_offset, data_size); - return E_FAIL; - } - FIXME("Skipping %u unknown DWORDs.\n", unknown_dword_count); - - if (desc->byte_code) - FIXME("Multiple shader code chunks.\n"); - desc->byte_code = (const DWORD *)byte_code; - desc->byte_code_size = data_size - header->byte_code_offset; - desc->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - TRACE("Feature level 9 shader version 0%08x, 0%08x.\n", header->shader_version, *desc->byte_code); - } - else - { - TRACE("Skipping feature level 9 shader code on feature level %#x.\n", ctx->feature_level); - } - break; - - default: - TRACE("Skipping chunk %s.\n", debugstr_an((const char *)&tag, 4)); - break; - } - - return S_OK; -} - -static void free_shader_desc(struct wined3d_shader_desc *desc) -{ - shader_free_signature(&desc->input_signature); - shader_free_signature(&desc->output_signature); - shader_free_signature(&desc->patch_constant_signature); -} - -static HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length, - struct wined3d_shader_desc *desc, D3D_FEATURE_LEVEL feature_level) -{ - struct shader_handler_context ctx = {feature_level, desc}; - HRESULT hr; - - desc->byte_code = NULL; - desc->byte_code_size = 0; - memset(&desc->input_signature, 0, sizeof(desc->input_signature)); - memset(&desc->output_signature, 0, sizeof(desc->output_signature)); - memset(&desc->patch_constant_signature, 0, sizeof(desc->patch_constant_signature)); + struct wined3d_shader_signature *signature = context; - hr = parse_dxbc(dxbc, dxbc_length, shdr_handler, &ctx); - if (!desc->byte_code) - hr = E_INVALIDARG; + if (tag != TAG_OSGN && tag != TAG_OSG5) + return S_OK; - if (FAILED(hr)) + if (signature->elements) { - FIXME("Failed to parse shader, hr %#x.\n", hr); - free_shader_desc(desc); + FIXME("Multiple input signatures.\n"); + shader_free_signature(signature); } - - return hr; + return shader_parse_signature(tag, data, data_size, signature); } static const char *shader_get_string(const char *data, size_t data_size, DWORD offset) @@ -529,18 +392,11 @@ static HRESULT d3d_vertex_shader_init(struct d3d_vertex_shader *shader, struct d wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, - &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, + &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); @@ -740,18 +596,11 @@ static HRESULT d3d11_hull_shader_init(struct d3d11_hull_shader *shader, struct d wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader, - &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader, + &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d hull shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); @@ -941,18 +790,11 @@ static HRESULT d3d11_domain_shader_init(struct d3d11_domain_shader *shader, stru wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader, - &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader, + &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d domain shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); @@ -1412,6 +1254,7 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, unsigned int rasterizer_stream) { struct wined3d_stream_output_desc so_desc; + struct wined3d_shader_signature signature; struct wined3d_shader_desc desc; unsigned int i; HRESULT hr; @@ -1448,11 +1291,9 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, } } - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - return hr; - } + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; memset(&so_desc, 0, sizeof(so_desc)); if (so_entries) @@ -1466,15 +1307,23 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, if (!(so_desc.elements = heap_calloc(so_entry_count, sizeof(*so_desc.elements)))) { ERR("Failed to allocate wined3d stream output element array memory.\n"); - free_shader_desc(&desc); return E_OUTOFMEMORY; } - if (FAILED(hr = wined3d_so_elements_from_d3d11_so_entries(so_desc.elements, + + memset(&signature, 0, sizeof(signature)); + if (FAILED(hr = parse_dxbc(byte_code, byte_code_length, osgn_handler, &signature))) + { + ERR("Failed to parse input signature.\n"); + heap_free(so_desc.elements); + return E_FAIL; + } + hr = wined3d_so_elements_from_d3d11_so_entries(so_desc.elements, so_entries, so_entry_count, buffer_strides, buffer_stride_count, - &desc.output_signature, device->feature_level))) + &signature, device->feature_level); + shader_free_signature(&signature); + if (FAILED(hr)) { heap_free(so_desc.elements); - free_shader_desc(&desc); return hr; } } @@ -1488,7 +1337,6 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, hr = wined3d_shader_create_gs(device->wined3d_device, &desc, so_entries ? &so_desc : NULL, shader, &d3d_geometry_shader_wined3d_parent_ops, &shader->wined3d_shader); heap_free(so_desc.elements); - free_shader_desc(&desc); if (FAILED(hr)) { WARN("Failed to create wined3d geometry shader, hr %#x.\n", hr); @@ -1795,18 +1643,11 @@ static HRESULT d3d_pixel_shader_init(struct d3d_pixel_shader *shader, struct d3d wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, - &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, + &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); @@ -2004,18 +1845,11 @@ static HRESULT d3d11_compute_shader_init(struct d3d11_compute_shader *shader, st wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_cs(device->wined3d_device, &desc, shader, - &d3d11_compute_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_cs(device->wined3d_device, &desc, shader, + &d3d11_compute_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d compute shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); -- 2.16.4

2 1

[PATCH 1/3] wined3d: Accept full DXBC.
by Józef Kucia 05 Oct '18

05 Oct '18

In order to make it easier to add shader backends based on external libraries, e.g. vkd3d-shader. Additionally, allows us to easily parse additional DXBC chunks in wined3d. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/shader.c | 105 ++++++++----- dlls/wined3d/shader_sm4.c | 329 +++++++++++++++++++++++++++++++++++++++++ dlls/wined3d/wined3d_private.h | 9 +- include/wine/wined3d.h | 1 + 4 files changed, 404 insertions(+), 40 deletions(-) diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index 9524757470eb..ecff0bc299a6 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -3153,7 +3153,7 @@ static void shader_cleanup(struct wined3d_shader *shader) heap_free(shader->signature_strings); shader->device->shader_backend->shader_destroy(shader); shader_cleanup_reg_maps(&shader->reg_maps); - heap_free(shader->function); + heap_free(shader->byte_code); shader_delete_constant_list(&shader->constantsF); shader_delete_constant_list(&shader->constantsB); shader_delete_constant_list(&shader->constantsI); @@ -3461,11 +3461,11 @@ HRESULT CDECL wined3d_shader_get_byte_code(const struct wined3d_shader *shader, if (!byte_code) { - *byte_code_size = shader->functionLength; + *byte_code_size = shader->byte_code_size; return WINED3D_OK; } - if (*byte_code_size < shader->functionLength) + if (*byte_code_size < shader->byte_code_size) { /* MSDN claims (for d3d8 at least) that if *byte_code_size is smaller * than the required size we should write the required size and @@ -3473,7 +3473,7 @@ HRESULT CDECL wined3d_shader_get_byte_code(const struct wined3d_shader *shader, return WINED3DERR_INVALIDCALL; } - memcpy(byte_code, shader->function, shader->functionLength); + memcpy(byte_code, shader->byte_code, shader->byte_code_size); return WINED3D_OK; } @@ -3693,7 +3693,8 @@ static HRESULT shader_copy_signatures_from_shader_desc(struct wined3d_shader *sh static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops) { - size_t byte_code_size; + enum wined3d_shader_byte_code_format format; + unsigned int max_version; HRESULT hr; TRACE("byte_code %p, byte_code_size %#lx, format %#x.\n", @@ -3702,20 +3703,11 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device if (!desc->byte_code) return WINED3DERR_INVALIDCALL; - if (!(shader->frontend = shader_select_frontend(desc->format))) - { - FIXME("Unable to find frontend for shader.\n"); - return WINED3DERR_INVALIDCALL; - } - shader->ref = 1; shader->device = device; shader->parent = parent; shader->parent_ops = parent_ops; - if (FAILED(hr = shader_copy_signatures_from_shader_desc(shader, desc))) - return hr; - list_init(&shader->linked_programs); list_init(&shader->constantsF); list_init(&shader->constantsB); @@ -3724,40 +3716,78 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device list_init(&shader->reg_maps.indexable_temps); list_init(&shader->shader_list_entry); - byte_code_size = desc->byte_code_size; - if (byte_code_size == ~(size_t)0) + format = desc->format; + if (format == WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC) { - const struct wined3d_shader_frontend *fe = shader->frontend; - struct wined3d_shader_version shader_version; - struct wined3d_shader_instruction ins; - const DWORD *ptr; - void *fe_data; - - if (!(fe_data = fe->shader_init(desc->byte_code, byte_code_size, &shader->output_signature))) + if (!(shader->byte_code = heap_alloc(desc->byte_code_size))) { - WARN("Failed to initialise frontend data.\n"); - shader_cleanup(shader); - return WINED3DERR_INVALIDCALL; + hr = E_OUTOFMEMORY; + goto fail; } + memcpy(shader->byte_code, desc->byte_code, desc->byte_code_size); + shader->byte_code_size = desc->byte_code_size; - fe->shader_read_header(fe_data, &ptr, &shader_version); - while (!fe->shader_is_end(fe_data, &ptr)) - fe->shader_read_instruction(fe_data, &ptr, &ins); - - fe->shader_free(fe_data); + max_version = shader_max_version_from_feature_level(device->feature_level); + if (FAILED(hr = shader_extract_from_dxbc(shader, max_version, &format))) + goto fail; + } + else if (FAILED(hr = shader_copy_signatures_from_shader_desc(shader, desc))) + { + goto fail; + } - byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr); + if (!(shader->frontend = shader_select_frontend(format))) + { + FIXME("Unable to find frontend for shader.\n"); + hr = WINED3DERR_INVALIDCALL; + goto fail; } - if (!(shader->function = heap_alloc(byte_code_size))) + if (!shader->byte_code) { - shader_cleanup(shader); - return E_OUTOFMEMORY; + size_t byte_code_size = desc->byte_code_size; + + if (byte_code_size == ~(size_t)0) + { + const struct wined3d_shader_frontend *fe = shader->frontend; + struct wined3d_shader_version shader_version; + struct wined3d_shader_instruction ins; + const DWORD *ptr; + void *fe_data; + + if (!(fe_data = fe->shader_init(desc->byte_code, byte_code_size, &shader->output_signature))) + { + WARN("Failed to initialise frontend data.\n"); + hr = WINED3DERR_INVALIDCALL; + goto fail; + } + + fe->shader_read_header(fe_data, &ptr, &shader_version); + while (!fe->shader_is_end(fe_data, &ptr)) + fe->shader_read_instruction(fe_data, &ptr, &ins); + + fe->shader_free(fe_data); + + byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr); + } + + if (!(shader->byte_code = heap_alloc(byte_code_size))) + { + hr = E_OUTOFMEMORY; + goto fail; + } + memcpy(shader->byte_code, desc->byte_code, byte_code_size); + shader->byte_code_size = byte_code_size; + + shader->function = shader->byte_code; + shader->functionLength = shader->byte_code_size; } - memcpy(shader->function, desc->byte_code, byte_code_size); - shader->functionLength = byte_code_size; return hr; + +fail: + shader_cleanup(shader); + return hr; } static HRESULT vertex_shader_init(struct wined3d_shader *shader, struct wined3d_device *device, @@ -3820,7 +3850,6 @@ static HRESULT geometry_shader_init_stream_output(struct wined3d_shader *shader, { case WINED3D_SHADER_TYPE_VERTEX: case WINED3D_SHADER_TYPE_DOMAIN: - heap_free(shader->function); shader->function = NULL; shader->functionLength = 0; break; diff --git a/dlls/wined3d/shader_sm4.c b/dlls/wined3d/shader_sm4.c index 7841686b8b4b..5f9dbecfebaa 100644 --- a/dlls/wined3d/shader_sm4.c +++ b/dlls/wined3d/shader_sm4.c @@ -1774,3 +1774,332 @@ const struct wined3d_shader_frontend sm4_shader_frontend = shader_sm4_read_instruction, shader_sm4_is_end, }; + +#define TAG_AON9 WINEMAKEFOURCC('A', 'o', 'n', '9') +#define TAG_DXBC WINEMAKEFOURCC('D', 'X', 'B', 'C') +#define TAG_ISGN WINEMAKEFOURCC('I', 'S', 'G', 'N') +#define TAG_OSG5 WINEMAKEFOURCC('O', 'S', 'G', '5') +#define TAG_OSGN WINEMAKEFOURCC('O', 'S', 'G', 'N') +#define TAG_PCSG WINEMAKEFOURCC('P', 'C', 'S', 'G') +#define TAG_SHDR WINEMAKEFOURCC('S', 'H', 'D', 'R') +#define TAG_SHEX WINEMAKEFOURCC('S', 'H', 'E', 'X') + +struct aon9_header +{ + DWORD chunk_size; + DWORD shader_version; + DWORD unknown; + DWORD byte_code_offset; +}; + +struct shader_handler_context +{ + struct wined3d_shader *shader; + enum wined3d_shader_byte_code_format *format; + unsigned int max_version; +}; + +static void read_dword(const char **ptr, DWORD *d) +{ + memcpy(d, *ptr, sizeof(*d)); + *ptr += sizeof(*d); +} + +static BOOL require_space(size_t offset, size_t count, size_t size, size_t data_size) +{ + return !count || (data_size - offset) / count >= size; +} + +static void skip_dword_unknown(const char **ptr, unsigned int count) +{ + unsigned int i; + DWORD d; + + WARN("Skipping %u unknown DWORDs:\n", count); + for (i = 0; i < count; ++i) + { + read_dword(ptr, &d); + WARN("\t0x%08x\n", d); + } +} + +static HRESULT parse_dxbc(const char *data, SIZE_T data_size, + HRESULT (*chunk_handler)(const char *data, DWORD data_size, DWORD tag, void *ctx), void *ctx) +{ + const char *ptr = data; + HRESULT hr = S_OK; + DWORD chunk_count; + DWORD total_size; + unsigned int i; + DWORD version; + DWORD tag; + + read_dword(&ptr, &tag); + TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4)); + + if (tag != TAG_DXBC) + { + WARN("Wrong tag.\n"); + return E_INVALIDARG; + } + + WARN("Ignoring DXBC checksum.\n"); + skip_dword_unknown(&ptr, 4); + + read_dword(&ptr, &version); + TRACE("version: %#x.\n", version); + if (version != 0x00000001) + { + WARN("Got unexpected DXBC version %#x.\n", version); + return E_INVALIDARG; + } + + read_dword(&ptr, &total_size); + TRACE("total size: %#x\n", total_size); + + read_dword(&ptr, &chunk_count); + TRACE("chunk count: %#x\n", chunk_count); + + for (i = 0; i < chunk_count; ++i) + { + DWORD chunk_tag, chunk_size; + const char *chunk_ptr; + DWORD chunk_offset; + + read_dword(&ptr, &chunk_offset); + TRACE("chunk %u at offset %#x\n", i, chunk_offset); + + if (chunk_offset >= data_size || !require_space(chunk_offset, 2, sizeof(DWORD), data_size)) + { + WARN("Invalid chunk offset %#x (data size %#lx).\n", chunk_offset, data_size); + return E_FAIL; + } + + chunk_ptr = data + chunk_offset; + + read_dword(&chunk_ptr, &chunk_tag); + read_dword(&chunk_ptr, &chunk_size); + + if (!require_space(chunk_ptr - data, 1, chunk_size, data_size)) + { + WARN("Invalid chunk size %#x (data size %#lx, chunk offset %#x).\n", + chunk_size, data_size, chunk_offset); + return E_FAIL; + } + + if (FAILED(hr = chunk_handler(chunk_ptr, chunk_size, chunk_tag, ctx))) + break; + } + + return hr; +} + +static const char *shader_get_string(const char *data, size_t data_size, DWORD offset) +{ + size_t len, max_len; + + if (offset >= data_size) + { + WARN("Invalid offset %#x (data size %#lx).\n", offset, (long)data_size); + return NULL; + } + + max_len = data_size - offset; + len = strnlen(data + offset, max_len); + + if (len == max_len) + return NULL; + + return data + offset; +} + +static HRESULT shader_parse_signature(DWORD tag, const char *data, DWORD data_size, + struct wined3d_shader_signature *s) +{ + struct wined3d_shader_signature_element *e; + const char *ptr = data; + unsigned int i; + DWORD count; + + if (!require_space(0, 2, sizeof(DWORD), data_size)) + { + WARN("Invalid data size %#x.\n", data_size); + return E_INVALIDARG; + } + + read_dword(&ptr, &count); + TRACE("%u elements.\n", count); + + skip_dword_unknown(&ptr, 1); /* It seems to always be 0x00000008. */ + + if (!require_space(ptr - data, count, 6 * sizeof(DWORD), data_size)) + { + WARN("Invalid count %#x (data size %#x).\n", count, data_size); + return E_INVALIDARG; + } + + if (!(e = heap_calloc(count, sizeof(*e)))) + { + ERR("Failed to allocate input signature memory.\n"); + return E_OUTOFMEMORY; + } + + for (i = 0; i < count; ++i) + { + DWORD name_offset; + + if (tag == TAG_OSG5) + read_dword(&ptr, &e[i].stream_idx); + else + e[i].stream_idx = 0; + read_dword(&ptr, &name_offset); + if (!(e[i].semantic_name = shader_get_string(data, data_size, name_offset))) + { + WARN("Invalid name offset %#x (data size %#x).\n", name_offset, data_size); + heap_free(e); + return E_INVALIDARG; + } + read_dword(&ptr, &e[i].semantic_idx); + read_dword(&ptr, &e[i].sysval_semantic); + read_dword(&ptr, &e[i].component_type); + read_dword(&ptr, &e[i].register_idx); + read_dword(&ptr, &e[i].mask); + + TRACE("Stream: %u, semantic: %s, semantic idx: %u, sysval_semantic %#x, " + "type %u, register idx: %u, use_mask %#x, input_mask %#x.\n", + e[i].stream_idx, debugstr_a(e[i].semantic_name), e[i].semantic_idx, e[i].sysval_semantic, + e[i].component_type, e[i].register_idx, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff); + } + + s->elements = e; + s->element_count = count; + + return S_OK; +} + +static HRESULT shader_dxbc_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *context) +{ + struct shader_handler_context *ctx = context; + struct wined3d_shader *shader = ctx->shader; + HRESULT hr; + + switch (tag) + { + case TAG_ISGN: + if (ctx->max_version < 4) + { + TRACE("Skipping shader input signature.\n"); + break; + } + if (shader->input_signature.elements) + { + FIXME("Multiple input signatures.\n"); + break; + } + if (FAILED(hr = shader_parse_signature(tag, data, data_size, &shader->input_signature))) + return hr; + break; + + case TAG_OSGN: + case TAG_OSG5: + if (ctx->max_version < 4) + { + TRACE("Skipping shader output signature.\n"); + break; + } + if (shader->output_signature.elements) + { + FIXME("Multiple output signatures.\n"); + break; + } + if (FAILED(hr = shader_parse_signature(tag, data, data_size, &shader->output_signature))) + return hr; + break; + + case TAG_PCSG: + if (shader->patch_constant_signature.elements) + { + FIXME("Multiple patch constant signatures.\n"); + break; + } + if (FAILED(hr = shader_parse_signature(tag, data, data_size, &shader->patch_constant_signature))) + return hr; + break; + + case TAG_SHDR: + case TAG_SHEX: + if (ctx->max_version < 4) + { + TRACE("Skipping SM4+ shader.\n"); + break; + } + if (shader->function) + FIXME("Multiple shader code chunks.\n"); + shader->function = (const DWORD *)data; + shader->functionLength = data_size; + *ctx->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM4; + break; + + case TAG_AON9: + if (ctx->max_version < 4) + { + const struct aon9_header *header = (const struct aon9_header *)data; + unsigned int unknown_dword_count; + const char *byte_code; + + if (data_size < sizeof(*header)) + { + WARN("Invalid Aon9 data size %#x.\n", data_size); + return E_FAIL; + } + byte_code = data + header->byte_code_offset; + unknown_dword_count = (header->byte_code_offset - sizeof(*header)) / sizeof(DWORD); + + if (data_size - 2 * sizeof(DWORD) < header->byte_code_offset) + { + WARN("Invalid byte code offset %#x (size %#x).\n", header->byte_code_offset, data_size); + return E_FAIL; + } + FIXME("Skipping %u unknown DWORDs.\n", unknown_dword_count); + + if (shader->function) + FIXME("Multiple shader code chunks.\n"); + shader->function = (const DWORD *)byte_code; + shader->functionLength = data_size - header->byte_code_offset; + *ctx->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; + TRACE("Feature level 9 shader version 0%08x, 0%08x.\n", + header->shader_version, *shader->function); + } + else + { + TRACE("Skipping feature level 9 shader code.\n"); + } + break; + + default: + TRACE("Skipping chunk %s.\n", debugstr_an((const char *)&tag, 4)); + break; + } + + return S_OK; +} + +HRESULT shader_extract_from_dxbc(struct wined3d_shader *shader, + unsigned int max_shader_version, enum wined3d_shader_byte_code_format *format) +{ + struct shader_handler_context ctx; + HRESULT hr; + + ctx.shader = shader; + ctx.format = format; + ctx.max_version = max_shader_version; + + hr = parse_dxbc(shader->byte_code, shader->byte_code_size, shader_dxbc_chunk_handler, &ctx); + if (!shader->function) + hr = E_INVALIDARG; + + if (FAILED(hr)) + WARN("Failed to parse DXBC, hr %#x.\n", hr); + + return hr; +} diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 9baefa6184dd..221b9472aa67 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1253,6 +1253,9 @@ struct wined3d_shader_frontend extern const struct wined3d_shader_frontend sm1_shader_frontend DECLSPEC_HIDDEN; extern const struct wined3d_shader_frontend sm4_shader_frontend DECLSPEC_HIDDEN; +HRESULT shader_extract_from_dxbc(struct wined3d_shader *shader, + unsigned int max_shader_version, enum wined3d_shader_byte_code_format *format); + typedef void (*SHADER_HANDLER)(const struct wined3d_shader_instruction *); #define WINED3D_SHADER_CAP_VS_CLIPPING 0x00000001 @@ -4080,8 +4083,10 @@ struct wined3d_shader { LONG ref; const struct wined3d_shader_limits *limits; - DWORD *function; - UINT functionLength; + const DWORD *function; + unsigned int functionLength; + void *byte_code; + unsigned int byte_code_size; BOOL load_local_constsF; const struct wined3d_shader_frontend *frontend; void *frontend_data; diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index cf44ca64a409..297192f7c703 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -858,6 +858,7 @@ enum wined3d_shader_byte_code_format { WINED3D_SHADER_BYTE_CODE_FORMAT_SM1 = 0, WINED3D_SHADER_BYTE_CODE_FORMAT_SM4 = 1, + WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC = 2, }; enum wined3d_shader_type -- 2.16.4

2 1

[PATCH 1/2] d2d1: Add a helper to set error state.
by Nikolay Sivov 05 Oct '18

05 Oct '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/device.c | 47 ++++++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 22 deletions(-) diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index bfd14948b0..1e420514a8 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -195,6 +195,13 @@ static void d2d_device_context_draw(struct d2d_device_context *render_target, en WARN("Failed to apply stateblock, hr %#x.\n", hr); } +static void d2d_device_context_set_error(struct d2d_device_context *context, HRESULT code) +{ + context->error.code = code; + context->error.tag1 = context->drawing_state.tag1; + context->error.tag2 = context->drawing_state.tag2; +} + static inline struct d2d_device_context *impl_from_IUnknown(IUnknown *iface) { return CONTAINING_RECORD(iface, struct d2d_device_context, IUnknown_iface); @@ -969,23 +976,21 @@ static void STDMETHODCALLTYPE d2d_device_context_FillGeometry(ID2D1DeviceContext { const struct d2d_geometry *geometry_impl = unsafe_impl_from_ID2D1Geometry(geometry); struct d2d_brush *opacity_brush_impl = unsafe_impl_from_ID2D1Brush(opacity_brush); - struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); struct d2d_brush *brush_impl = unsafe_impl_from_ID2D1Brush(brush); TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush); - if (FAILED(render_target->error.code)) + if (FAILED(context->error.code)) return; if (opacity_brush && brush_impl->type != D2D_BRUSH_TYPE_BITMAP) { - render_target->error.code = D2DERR_INCOMPATIBLE_BRUSH_TYPES; - render_target->error.tag1 = render_target->drawing_state.tag1; - render_target->error.tag2 = render_target->drawing_state.tag2; + d2d_device_context_set_error(context, D2DERR_INCOMPATIBLE_BRUSH_TYPES); return; } - d2d_device_context_fill_geometry(render_target, geometry_impl, brush_impl, opacity_brush_impl); + d2d_device_context_fill_geometry(context, geometry_impl, brush_impl, opacity_brush_impl); } static void STDMETHODCALLTYPE d2d_device_context_FillMesh(ID2D1DeviceContext *iface, @@ -1076,7 +1081,7 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawBitmap(ID2D1DeviceContext * if (interpolation_mode != D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR && interpolation_mode != D2D1_BITMAP_INTERPOLATION_MODE_LINEAR) { - context->error.code = E_INVALIDARG; + d2d_device_context_set_error(context, E_INVALIDARG); return; } @@ -1341,7 +1346,7 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush, DWRITE_MEASURING_MODE measuring_mode) { - struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); DWRITE_TEXT_ANTIALIAS_MODE antialias_mode = DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE; IDWriteRenderingParams *rendering_params; DWRITE_RENDERING_MODE rendering_mode; @@ -1350,12 +1355,12 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); - rendering_params = render_target->text_rendering_params ? render_target->text_rendering_params - : render_target->default_text_rendering_params; + rendering_params = context->text_rendering_params ? context->text_rendering_params + : context->default_text_rendering_params; rendering_mode = IDWriteRenderingParams_GetRenderingMode(rendering_params); - switch (render_target->drawing_state.textAntialiasMode) + switch (context->drawing_state.textAntialiasMode) { case D2D1_TEXT_ANTIALIAS_MODE_ALIASED: if (rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL @@ -1363,29 +1368,29 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC) { - render_target->error.code = E_INVALIDARG; + d2d_device_context_set_error(context, E_INVALIDARG); } break; case D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE: if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED || rendering_mode == DWRITE_RENDERING_MODE_OUTLINE) { - render_target->error.code = E_INVALIDARG; + d2d_device_context_set_error(context, E_INVALIDARG); } break; case D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE: if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED) - render_target->error.code = E_INVALIDARG; + d2d_device_context_set_error(context, E_INVALIDARG); break; default: ; } - if (FAILED(render_target->error.code)) + if (FAILED(context->error.code)) return; rendering_mode = DWRITE_RENDERING_MODE_DEFAULT; - switch (render_target->drawing_state.textAntialiasMode) + switch (context->drawing_state.textAntialiasMode) { case D2D1_TEXT_ANTIALIAS_MODE_DEFAULT: if (IDWriteRenderingParams_GetClearTypeLevel(rendering_params) > 0.0f) @@ -1404,7 +1409,7 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext if (rendering_mode == DWRITE_RENDERING_MODE_DEFAULT) { if (FAILED(hr = IDWriteFontFace_GetRecommendedRenderingMode(glyph_run->fontFace, glyph_run->fontEmSize, - max(render_target->desc.dpiX, render_target->desc.dpiY) / 96.0f, + max(context->desc.dpiX, context->desc.dpiY) / 96.0f, measuring_mode, rendering_params, &rendering_mode))) { ERR("Failed to get recommended rendering mode, hr %#x.\n", hr); @@ -1413,9 +1418,9 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext } if (rendering_mode == DWRITE_RENDERING_MODE_OUTLINE) - d2d_device_context_draw_glyph_run_outline(render_target, baseline_origin, glyph_run, brush); + d2d_device_context_draw_glyph_run_outline(context, baseline_origin, glyph_run, brush); else - d2d_device_context_draw_glyph_run_bitmap(render_target, baseline_origin, glyph_run, brush, + d2d_device_context_draw_glyph_run_bitmap(context, baseline_origin, glyph_run, brush, rendering_mode, measuring_mode, antialias_mode); } @@ -2053,9 +2058,7 @@ static void STDMETHODCALLTYPE d2d_device_context_SetTarget(ID2D1DeviceContext *i if (!(bitmap_impl->options & D2D1_BITMAP_OPTIONS_TARGET)) { - context->error.code = D2DERR_INVALID_TARGET; - context->error.tag1 = context->drawing_state.tag1; - context->error.tag2 = context->drawing_state.tag2; + d2d_device_context_set_error(context, D2DERR_INVALID_TARGET); return; } -- 2.19.0

2 2

[PATCH 2/2] msvcrt: Use memmove to copy memory in memcpy_s.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/msvcrt/heap.c | 2 +- dlls/msvcrt/tests/string.c | 14 +++++++++++++- 2 files changed, 14 insertions(+), 2 deletions(-)

2 1

[PATCH 1/2] msvcrt: Use memmove to copy memory in wmemcpy_s.
by Jacek Caban 05 Oct '18

05 Oct '18

Fixes memory corruption in Outlook 2016. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/msvcr100/tests/msvcr100.c | 14 +++++++++++++- dlls/msvcrt/heap.c | 2 +- 2 files changed, 14 insertions(+), 2 deletions(-)

2 1

[v2 PATCH 1/2] wincodecs: Add IWICImagingFactory2 stub.
by Nikolay Sivov 05 Oct '18

05 Oct '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/windowscodecs/clsfactory.c | 3 +- dlls/windowscodecs/imgfactory.c | 330 +++++++++++++++++++++---- dlls/windowscodecs/pngformat.c | 2 +- dlls/windowscodecs/proxy.c | 2 +- dlls/windowscodecs/tests/info.c | 33 +++ dlls/windowscodecs/wincodecs_private.h | 2 +- 6 files changed, 322 insertions(+), 50 deletions(-) diff --git a/dlls/windowscodecs/clsfactory.c b/dlls/windowscodecs/clsfactory.c index 77eeedc428..32083a2a3f 100644 --- a/dlls/windowscodecs/clsfactory.c +++ b/dlls/windowscodecs/clsfactory.c @@ -43,7 +43,8 @@ typedef struct { } classinfo; static const classinfo wic_classes[] = { - {&CLSID_WICImagingFactory, ComponentFactory_CreateInstance}, + {&CLSID_WICImagingFactory, ImagingFactory_CreateInstance}, + {&CLSID_WICImagingFactory2, ImagingFactory_CreateInstance}, {&CLSID_WICBmpDecoder, BmpDecoder_CreateInstance}, {&CLSID_WICPngDecoder, PngDecoder_CreateInstance}, {&CLSID_WICPngEncoder, PngEncoder_CreateInstance}, diff --git a/dlls/windowscodecs/imgfactory.c b/dlls/windowscodecs/imgfactory.c index 06e3f6aceb..dbcc5f5923 100644 --- a/dlls/windowscodecs/imgfactory.c +++ b/dlls/windowscodecs/imgfactory.c @@ -36,19 +36,25 @@ WINE_DEFAULT_DEBUG_CHANNEL(wincodecs); typedef struct { + IWICImagingFactory2 IWICImagingFactory2_iface; IWICComponentFactory IWICComponentFactory_iface; LONG ref; -} ComponentFactory; +} ImagingFactory; -static inline ComponentFactory *impl_from_IWICComponentFactory(IWICComponentFactory *iface) +static inline ImagingFactory *impl_from_IWICComponentFactory(IWICComponentFactory *iface) { - return CONTAINING_RECORD(iface, ComponentFactory, IWICComponentFactory_iface); + return CONTAINING_RECORD(iface, ImagingFactory, IWICComponentFactory_iface); } -static HRESULT WINAPI ComponentFactory_QueryInterface(IWICComponentFactory *iface, REFIID iid, +static inline ImagingFactory *impl_from_IWICImagingFactory2(IWICImagingFactory2 *iface) +{ + return CONTAINING_RECORD(iface, ImagingFactory, IWICImagingFactory2_iface); +} + +static HRESULT WINAPI ImagingFactory_QueryInterface(IWICImagingFactory2 *iface, REFIID iid, void **ppv) { - ComponentFactory *This = impl_from_IWICComponentFactory(iface); + ImagingFactory *This = impl_from_IWICImagingFactory2(iface); TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv); if (!ppv) return E_INVALIDARG; @@ -59,6 +65,10 @@ static HRESULT WINAPI ComponentFactory_QueryInterface(IWICComponentFactory *ifac { *ppv = &This->IWICComponentFactory_iface; } + else if (IsEqualIID(&IID_IWICImagingFactory2, iid)) + { + *ppv = &This->IWICImagingFactory2_iface; + } else { *ppv = NULL; @@ -69,9 +79,9 @@ static HRESULT WINAPI ComponentFactory_QueryInterface(IWICComponentFactory *ifac return S_OK; } -static ULONG WINAPI ComponentFactory_AddRef(IWICComponentFactory *iface) +static ULONG WINAPI ImagingFactory_AddRef(IWICImagingFactory2 *iface) { - ComponentFactory *This = impl_from_IWICComponentFactory(iface); + ImagingFactory *This = impl_from_IWICImagingFactory2(iface); ULONG ref = InterlockedIncrement(&This->ref); TRACE("(%p) refcount=%u\n", iface, ref); @@ -79,9 +89,9 @@ static ULONG WINAPI ComponentFactory_AddRef(IWICComponentFactory *iface) return ref; } -static ULONG WINAPI ComponentFactory_Release(IWICComponentFactory *iface) +static ULONG WINAPI ImagingFactory_Release(IWICImagingFactory2 *iface) { - ComponentFactory *This = impl_from_IWICComponentFactory(iface); + ImagingFactory *This = impl_from_IWICImagingFactory2(iface); ULONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) refcount=%u\n", iface, ref); @@ -92,8 +102,8 @@ static ULONG WINAPI ComponentFactory_Release(IWICComponentFactory *iface) return ref; } -static HRESULT WINAPI ComponentFactory_CreateDecoderFromFilename( - IWICComponentFactory *iface, LPCWSTR wzFilename, const GUID *pguidVendor, +static HRESULT WINAPI ImagingFactory_CreateDecoderFromFilename( + IWICImagingFactory2 *iface, LPCWSTR wzFilename, const GUID *pguidVendor, DWORD dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder) { @@ -110,7 +120,7 @@ static HRESULT WINAPI ComponentFactory_CreateDecoderFromFilename( if (SUCCEEDED(hr)) { - hr = IWICComponentFactory_CreateDecoderFromStream(iface, (IStream*)stream, + hr = IWICImagingFactory2_CreateDecoderFromStream(iface, (IStream*)stream, pguidVendor, metadataOptions, ppIDecoder); } @@ -190,8 +200,8 @@ static IWICBitmapDecoder *find_decoder(IStream *pIStream, const GUID *pguidVendo return decoder; } -static HRESULT WINAPI ComponentFactory_CreateDecoderFromStream( - IWICComponentFactory *iface, IStream *pIStream, const GUID *pguidVendor, +static HRESULT WINAPI ImagingFactory_CreateDecoderFromStream( + IWICImagingFactory2 *iface, IStream *pIStream, const GUID *pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder) { HRESULT res; @@ -232,8 +242,8 @@ static HRESULT WINAPI ComponentFactory_CreateDecoderFromStream( } } -static HRESULT WINAPI ComponentFactory_CreateDecoderFromFileHandle( - IWICComponentFactory *iface, ULONG_PTR hFile, const GUID *pguidVendor, +static HRESULT WINAPI ImagingFactory_CreateDecoderFromFileHandle( + IWICImagingFactory2 *iface, ULONG_PTR hFile, const GUID *pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder) { IWICStream *stream; @@ -248,7 +258,7 @@ static HRESULT WINAPI ComponentFactory_CreateDecoderFromFileHandle( hr = stream_initialize_from_filehandle(stream, (HANDLE)hFile); if (SUCCEEDED(hr)) { - hr = IWICComponentFactory_CreateDecoderFromStream(iface, (IStream*)stream, + hr = IWICImagingFactory2_CreateDecoderFromStream(iface, (IStream*)stream, pguidVendor, metadataOptions, ppIDecoder); } IWICStream_Release(stream); @@ -256,14 +266,14 @@ static HRESULT WINAPI ComponentFactory_CreateDecoderFromFileHandle( return hr; } -static HRESULT WINAPI ComponentFactory_CreateComponentInfo(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateComponentInfo(IWICImagingFactory2 *iface, REFCLSID clsidComponent, IWICComponentInfo **ppIInfo) { TRACE("(%p,%s,%p)\n", iface, debugstr_guid(clsidComponent), ppIInfo); return CreateComponentInfo(clsidComponent, ppIInfo); } -static HRESULT WINAPI ComponentFactory_CreateDecoder(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateDecoder(IWICImagingFactory2 *iface, REFGUID guidContainerFormat, const GUID *pguidVendor, IWICBitmapDecoder **ppIDecoder) { @@ -346,7 +356,7 @@ static HRESULT WINAPI ComponentFactory_CreateDecoder(IWICComponentFactory *iface return WINCODEC_ERR_COMPONENTNOTFOUND; } -static HRESULT WINAPI ComponentFactory_CreateEncoder(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateEncoder(IWICImagingFactory2 *iface, REFGUID guidContainerFormat, const GUID *pguidVendor, IWICBitmapEncoder **ppIEncoder) { @@ -411,20 +421,20 @@ static HRESULT WINAPI ComponentFactory_CreateEncoder(IWICComponentFactory *iface } } -static HRESULT WINAPI ComponentFactory_CreatePalette(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreatePalette(IWICImagingFactory2 *iface, IWICPalette **ppIPalette) { TRACE("(%p,%p)\n", iface, ppIPalette); return PaletteImpl_Create(ppIPalette); } -static HRESULT WINAPI ComponentFactory_CreateFormatConverter(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateFormatConverter(IWICImagingFactory2 *iface, IWICFormatConverter **ppIFormatConverter) { return FormatConverter_CreateInstance(&IID_IWICFormatConverter, (void**)ppIFormatConverter); } -static HRESULT WINAPI ComponentFactory_CreateBitmapScaler(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmapScaler(IWICImagingFactory2 *iface, IWICBitmapScaler **ppIBitmapScaler) { TRACE("(%p,%p)\n", iface, ppIBitmapScaler); @@ -432,42 +442,42 @@ static HRESULT WINAPI ComponentFactory_CreateBitmapScaler(IWICComponentFactory * return BitmapScaler_Create(ppIBitmapScaler); } -static HRESULT WINAPI ComponentFactory_CreateBitmapClipper(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmapClipper(IWICImagingFactory2 *iface, IWICBitmapClipper **ppIBitmapClipper) { TRACE("(%p,%p)\n", iface, ppIBitmapClipper); return BitmapClipper_Create(ppIBitmapClipper); } -static HRESULT WINAPI ComponentFactory_CreateBitmapFlipRotator(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmapFlipRotator(IWICImagingFactory2 *iface, IWICBitmapFlipRotator **ppIBitmapFlipRotator) { TRACE("(%p,%p)\n", iface, ppIBitmapFlipRotator); return FlipRotator_Create(ppIBitmapFlipRotator); } -static HRESULT WINAPI ComponentFactory_CreateStream(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateStream(IWICImagingFactory2 *iface, IWICStream **ppIWICStream) { TRACE("(%p,%p)\n", iface, ppIWICStream); return StreamImpl_Create(ppIWICStream); } -static HRESULT WINAPI ComponentFactory_CreateColorContext(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateColorContext(IWICImagingFactory2 *iface, IWICColorContext **ppIColorContext) { TRACE("(%p,%p)\n", iface, ppIColorContext); return ColorContext_Create(ppIColorContext); } -static HRESULT WINAPI ComponentFactory_CreateColorTransformer(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateColorTransformer(IWICImagingFactory2 *iface, IWICColorTransform **ppIColorTransform) { TRACE("(%p,%p)\n", iface, ppIColorTransform); return ColorTransform_Create(ppIColorTransform); } -static HRESULT WINAPI ComponentFactory_CreateBitmap(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmap(IWICImagingFactory2 *iface, UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap) { @@ -476,7 +486,7 @@ static HRESULT WINAPI ComponentFactory_CreateBitmap(IWICComponentFactory *iface, return BitmapImpl_Create(uiWidth, uiHeight, 0, 0, NULL, 0, pixelFormat, option, ppIBitmap); } -static HRESULT WINAPI ComponentFactory_CreateBitmapFromSource(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmapFromSource(IWICImagingFactory2 *iface, IWICBitmapSource *piBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap) { @@ -582,7 +592,7 @@ static HRESULT WINAPI ComponentFactory_CreateBitmapFromSource(IWICComponentFacto return hr; } -static HRESULT WINAPI ComponentFactory_CreateBitmapFromSourceRect(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmapFromSourceRect(IWICImagingFactory2 *iface, IWICBitmapSource *piBitmapSource, UINT x, UINT y, UINT width, UINT height, IWICBitmap **ppIBitmap) { @@ -591,7 +601,7 @@ static HRESULT WINAPI ComponentFactory_CreateBitmapFromSourceRect(IWICComponentF return E_NOTIMPL; } -static HRESULT WINAPI ComponentFactory_CreateBitmapFromMemory(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmapFromMemory(IWICImagingFactory2 *iface, UINT width, UINT height, REFWICPixelFormatGUID format, UINT stride, UINT size, BYTE *buffer, IWICBitmap **bitmap) { @@ -667,7 +677,7 @@ static BOOL get_16bpp_format(HBITMAP hbm, WICPixelFormatGUID *format) return ret; } -static HRESULT WINAPI ComponentFactory_CreateBitmapFromHBITMAP(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmapFromHBITMAP(IWICImagingFactory2 *iface, HBITMAP hbm, HPALETTE hpal, WICBitmapAlphaChannelOption option, IWICBitmap **bitmap) { BITMAP bm; @@ -790,7 +800,7 @@ static HRESULT WINAPI ComponentFactory_CreateBitmapFromHBITMAP(IWICComponentFact return hr; } -static HRESULT WINAPI ComponentFactory_CreateBitmapFromHICON(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateBitmapFromHICON(IWICImagingFactory2 *iface, HICON hicon, IWICBitmap **bitmap) { IWICBitmapLock *lock; @@ -927,30 +937,30 @@ failed: return hr; } -static HRESULT WINAPI ComponentFactory_CreateComponentEnumerator(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateComponentEnumerator(IWICImagingFactory2 *iface, DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown) { TRACE("(%p,%u,%u,%p)\n", iface, componentTypes, options, ppIEnumUnknown); return CreateComponentEnumerator(componentTypes, options, ppIEnumUnknown); } -static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromDecoder( - IWICComponentFactory *iface, IWICBitmapDecoder *pIDecoder, +static HRESULT WINAPI ImagingFactory_CreateFastMetadataEncoderFromDecoder( + IWICImagingFactory2 *iface, IWICBitmapDecoder *pIDecoder, IWICFastMetadataEncoder **ppIFastEncoder) { FIXME("(%p,%p,%p): stub\n", iface, pIDecoder, ppIFastEncoder); return E_NOTIMPL; } -static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromFrameDecode( - IWICComponentFactory *iface, IWICBitmapFrameDecode *pIFrameDecoder, +static HRESULT WINAPI ImagingFactory_CreateFastMetadataEncoderFromFrameDecode( + IWICImagingFactory2 *iface, IWICBitmapFrameDecode *pIFrameDecoder, IWICFastMetadataEncoder **ppIFastEncoder) { FIXME("(%p,%p,%p): stub\n", iface, pIFrameDecoder, ppIFastEncoder); return E_NOTIMPL; } -static HRESULT WINAPI ComponentFactory_CreateQueryWriter(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateQueryWriter(IWICImagingFactory2 *iface, REFGUID guidMetadataFormat, const GUID *pguidVendor, IWICMetadataQueryWriter **ppIQueryWriter) { @@ -959,7 +969,7 @@ static HRESULT WINAPI ComponentFactory_CreateQueryWriter(IWICComponentFactory *i return E_NOTIMPL; } -static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromReader(IWICComponentFactory *iface, +static HRESULT WINAPI ImagingFactory_CreateQueryWriterFromReader(IWICImagingFactory2 *iface, IWICMetadataQueryReader *pIQueryReader, const GUID *pguidVendor, IWICMetadataQueryWriter **ppIQueryWriter) { @@ -968,6 +978,233 @@ static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromReader(IWICComponent return E_NOTIMPL; } +static HRESULT WINAPI ImagingFactory_CreateImageEncoder(IWICImagingFactory2 *iface, ID2D1Device *device, IWICImageEncoder **encoder) +{ + FIXME("%p,%p,%p stub.\n", iface, device, encoder); + return E_NOTIMPL; +} + +static const IWICImagingFactory2Vtbl ImagingFactory_Vtbl = { + ImagingFactory_QueryInterface, + ImagingFactory_AddRef, + ImagingFactory_Release, + ImagingFactory_CreateDecoderFromFilename, + ImagingFactory_CreateDecoderFromStream, + ImagingFactory_CreateDecoderFromFileHandle, + ImagingFactory_CreateComponentInfo, + ImagingFactory_CreateDecoder, + ImagingFactory_CreateEncoder, + ImagingFactory_CreatePalette, + ImagingFactory_CreateFormatConverter, + ImagingFactory_CreateBitmapScaler, + ImagingFactory_CreateBitmapClipper, + ImagingFactory_CreateBitmapFlipRotator, + ImagingFactory_CreateStream, + ImagingFactory_CreateColorContext, + ImagingFactory_CreateColorTransformer, + ImagingFactory_CreateBitmap, + ImagingFactory_CreateBitmapFromSource, + ImagingFactory_CreateBitmapFromSourceRect, + ImagingFactory_CreateBitmapFromMemory, + ImagingFactory_CreateBitmapFromHBITMAP, + ImagingFactory_CreateBitmapFromHICON, + ImagingFactory_CreateComponentEnumerator, + ImagingFactory_CreateFastMetadataEncoderFromDecoder, + ImagingFactory_CreateFastMetadataEncoderFromFrameDecode, + ImagingFactory_CreateQueryWriter, + ImagingFactory_CreateQueryWriterFromReader, + ImagingFactory_CreateImageEncoder, +}; + +static HRESULT WINAPI ComponentFactory_QueryInterface(IWICComponentFactory *iface, REFIID iid, void **ppv) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_QueryInterface(&This->IWICImagingFactory2_iface, iid, ppv); +} + +static ULONG WINAPI ComponentFactory_AddRef(IWICComponentFactory *iface) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_AddRef(&This->IWICImagingFactory2_iface); +} + +static ULONG WINAPI ComponentFactory_Release(IWICComponentFactory *iface) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_Release(&This->IWICImagingFactory2_iface); +} + +static HRESULT WINAPI ComponentFactory_CreateDecoderFromFilename(IWICComponentFactory *iface, LPCWSTR filename, + const GUID *vendor, DWORD desired_access, WICDecodeOptions options, IWICBitmapDecoder **decoder) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateDecoderFromFilename(&This->IWICImagingFactory2_iface, filename, vendor, + desired_access, options, decoder); +} + +static HRESULT WINAPI ComponentFactory_CreateDecoderFromStream(IWICComponentFactory *iface, IStream *stream, + const GUID *vendor, WICDecodeOptions options, IWICBitmapDecoder **decoder) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateDecoderFromStream(&This->IWICImagingFactory2_iface, stream, vendor, + options, decoder); +} + +static HRESULT WINAPI ComponentFactory_CreateDecoderFromFileHandle(IWICComponentFactory *iface, ULONG_PTR hFile, + const GUID *vendor, WICDecodeOptions options, IWICBitmapDecoder **decoder) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateDecoderFromFileHandle(&This->IWICImagingFactory2_iface, hFile, vendor, + options, decoder); +} + +static HRESULT WINAPI ComponentFactory_CreateComponentInfo(IWICComponentFactory *iface, REFCLSID component, + IWICComponentInfo **info) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateComponentInfo(&This->IWICImagingFactory2_iface, component, info); +} + +static HRESULT WINAPI ComponentFactory_CreateDecoder(IWICComponentFactory *iface, REFGUID format, const GUID *vendor, + IWICBitmapDecoder **decoder) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateDecoder(&This->IWICImagingFactory2_iface, format, vendor, decoder); +} + +static HRESULT WINAPI ComponentFactory_CreateEncoder(IWICComponentFactory *iface, REFGUID format, const GUID *vendor, + IWICBitmapEncoder **encoder) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateEncoder(&This->IWICImagingFactory2_iface, format, vendor, encoder); +} + +static HRESULT WINAPI ComponentFactory_CreatePalette(IWICComponentFactory *iface, IWICPalette **palette) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreatePalette(&This->IWICImagingFactory2_iface, palette); +} + +static HRESULT WINAPI ComponentFactory_CreateFormatConverter(IWICComponentFactory *iface, IWICFormatConverter **converter) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateFormatConverter(&This->IWICImagingFactory2_iface, converter); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmapScaler(IWICComponentFactory *iface, IWICBitmapScaler **scaler) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmapScaler(&This->IWICImagingFactory2_iface, scaler); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmapClipper(IWICComponentFactory *iface, IWICBitmapClipper **clipper) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmapClipper(&This->IWICImagingFactory2_iface, clipper); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmapFlipRotator(IWICComponentFactory *iface, IWICBitmapFlipRotator **fliprotator) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmapFlipRotator(&This->IWICImagingFactory2_iface, fliprotator); +} + +static HRESULT WINAPI ComponentFactory_CreateStream(IWICComponentFactory *iface, IWICStream **stream) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateStream(&This->IWICImagingFactory2_iface, stream); +} + +static HRESULT WINAPI ComponentFactory_CreateColorContext(IWICComponentFactory *iface, IWICColorContext **context) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateColorContext(&This->IWICImagingFactory2_iface, context); +} + +static HRESULT WINAPI ComponentFactory_CreateColorTransformer(IWICComponentFactory *iface, IWICColorTransform **transformer) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateColorTransformer(&This->IWICImagingFactory2_iface, transformer); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmap(IWICComponentFactory *iface, UINT width, UINT height, REFWICPixelFormatGUID pixel_format, + WICBitmapCreateCacheOption option, IWICBitmap **bitmap) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmap(&This->IWICImagingFactory2_iface, width, height, pixel_format, option, bitmap); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmapFromSource(IWICComponentFactory *iface, IWICBitmapSource *source, + WICBitmapCreateCacheOption option, IWICBitmap **bitmap) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmapFromSource(&This->IWICImagingFactory2_iface, source, option, bitmap); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmapFromSourceRect(IWICComponentFactory *iface, IWICBitmapSource *source, + UINT x, UINT y, UINT width, UINT height, IWICBitmap **bitmap) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmapFromSourceRect(&This->IWICImagingFactory2_iface, source, x, y, width, height, bitmap); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmapFromMemory(IWICComponentFactory *iface, UINT width, UINT height, + REFWICPixelFormatGUID format, UINT stride, UINT size, BYTE *buffer, IWICBitmap **bitmap) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmapFromMemory(&This->IWICImagingFactory2_iface, width, height, format, stride, + size, buffer, bitmap); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmapFromHBITMAP(IWICComponentFactory *iface, HBITMAP hbm, HPALETTE hpal, + WICBitmapAlphaChannelOption option, IWICBitmap **bitmap) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmapFromHBITMAP(&This->IWICImagingFactory2_iface, hbm, hpal, option, bitmap); +} + +static HRESULT WINAPI ComponentFactory_CreateBitmapFromHICON(IWICComponentFactory *iface, HICON hicon, IWICBitmap **bitmap) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateBitmapFromHICON(&This->IWICImagingFactory2_iface, hicon, bitmap); +} + +static HRESULT WINAPI ComponentFactory_CreateComponentEnumerator(IWICComponentFactory *iface, DWORD component_types, + DWORD options, IEnumUnknown **enumerator) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateComponentEnumerator(&This->IWICImagingFactory2_iface, component_types, + options, enumerator); +} + +static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromDecoder(IWICComponentFactory *iface, IWICBitmapDecoder *decoder, + IWICFastMetadataEncoder **encoder) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateFastMetadataEncoderFromDecoder(&This->IWICImagingFactory2_iface, decoder, encoder); +} + +static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromFrameDecode(IWICComponentFactory *iface, + IWICBitmapFrameDecode *frame_decode, IWICFastMetadataEncoder **encoder) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateFastMetadataEncoderFromFrameDecode(&This->IWICImagingFactory2_iface, frame_decode, encoder); +} + +static HRESULT WINAPI ComponentFactory_CreateQueryWriter(IWICComponentFactory *iface, REFGUID format, const GUID *vendor, + IWICMetadataQueryWriter **writer) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateQueryWriter(&This->IWICImagingFactory2_iface, format, vendor, writer); +} + +static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromReader(IWICComponentFactory *iface, IWICMetadataQueryReader *reader, + const GUID *vendor, IWICMetadataQueryWriter **writer) +{ + ImagingFactory *This = impl_from_IWICComponentFactory(iface); + return IWICImagingFactory2_CreateQueryWriterFromReader(&This->IWICImagingFactory2_iface, reader, vendor, writer); +} + static HRESULT WINAPI ComponentFactory_CreateMetadataReader(IWICComponentFactory *iface, REFGUID format, const GUID *vendor, DWORD options, IStream *stream, IWICMetadataReader **reader) { @@ -1181,23 +1418,24 @@ static const IWICComponentFactoryVtbl ComponentFactory_Vtbl = { ComponentFactory_CreateEncoderPropertyBag }; -HRESULT ComponentFactory_CreateInstance(REFIID iid, void** ppv) +HRESULT ImagingFactory_CreateInstance(REFIID iid, void** ppv) { - ComponentFactory *This; + ImagingFactory *This; HRESULT ret; TRACE("(%s,%p)\n", debugstr_guid(iid), ppv); *ppv = NULL; - This = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentFactory)); + This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); if (!This) return E_OUTOFMEMORY; + This->IWICImagingFactory2_iface.lpVtbl = &ImagingFactory_Vtbl; This->IWICComponentFactory_iface.lpVtbl = &ComponentFactory_Vtbl; This->ref = 1; - ret = IWICComponentFactory_QueryInterface(&This->IWICComponentFactory_iface, iid, ppv); - IWICComponentFactory_Release(&This->IWICComponentFactory_iface); + ret = IWICImagingFactory2_QueryInterface(&This->IWICImagingFactory2_iface, iid, ppv); + IWICImagingFactory2_Release(&This->IWICImagingFactory2_iface); return ret; } diff --git a/dlls/windowscodecs/pngformat.c b/dlls/windowscodecs/pngformat.c index 6b13112130..42a1f2f515 100644 --- a/dlls/windowscodecs/pngformat.c +++ b/dlls/windowscodecs/pngformat.c @@ -1240,7 +1240,7 @@ static HRESULT WINAPI PngDecoder_Block_GetReaderByIndex(IWICMetadataBlockReader This->metadata_blocks[nIndex].ofs, This->metadata_blocks[nIndex].len); if (SUCCEEDED(hr)) - hr = ComponentFactory_CreateInstance(&IID_IWICComponentFactory, (void**)&factory); + hr = ImagingFactory_CreateInstance(&IID_IWICComponentFactory, (void**)&factory); if (SUCCEEDED(hr)) { diff --git a/dlls/windowscodecs/proxy.c b/dlls/windowscodecs/proxy.c index a28b38681e..d53059e65b 100644 --- a/dlls/windowscodecs/proxy.c +++ b/dlls/windowscodecs/proxy.c @@ -637,7 +637,7 @@ HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT SDKVersion, IWICImagingFactory { TRACE("%x, %p\n", SDKVersion, ppIImagingFactory); - return ComponentFactory_CreateInstance(&IID_IWICImagingFactory, (void**)ppIImagingFactory); + return ImagingFactory_CreateInstance(&IID_IWICImagingFactory, (void**)ppIImagingFactory); } HRESULT WINAPI WICSetEncoderFormat_Proxy(IWICBitmapSource *pSourceIn, diff --git a/dlls/windowscodecs/tests/info.c b/dlls/windowscodecs/tests/info.c index b647601495..ee95784166 100644 --- a/dlls/windowscodecs/tests/info.c +++ b/dlls/windowscodecs/tests/info.c @@ -637,6 +637,38 @@ todo_wine IWICImagingFactory_Release(factory); } +static void test_imagingfactory_interfaces(void) +{ + IWICComponentFactory *component_factory; + IWICImagingFactory2 *factory2; + IWICImagingFactory *factory; + HRESULT hr; + + hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, + &IID_IWICImagingFactory2, (void **)&factory2); + if (FAILED(hr)) + { + win_skip("IWICImagingFactory2 is not supported.\n"); + return; + } + + hr = IWICImagingFactory2_QueryInterface(factory2, &IID_IWICComponentFactory, (void **)&component_factory); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IWICComponentFactory_QueryInterface(component_factory, &IID_IWICImagingFactory, (void **)&factory); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(factory == (IWICImagingFactory *)component_factory, "Unexpected factory pointer.\n"); + IWICImagingFactory_Release(factory); + + hr = IWICImagingFactory2_QueryInterface(factory2, &IID_IWICImagingFactory, (void **)&factory); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(factory == (IWICImagingFactory *)component_factory, "Unexpected factory pointer.\n"); + + IWICComponentFactory_Release(component_factory); + IWICImagingFactory2_Release(factory2); + IWICImagingFactory_Release(factory); +} + START_TEST(info) { CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); @@ -644,6 +676,7 @@ START_TEST(info) test_decoder_info(); test_reader_info(); test_pixelformat_info(); + test_imagingfactory_interfaces(); CoUninitialize(); } diff --git a/dlls/windowscodecs/wincodecs_private.h b/dlls/windowscodecs/wincodecs_private.h index b29fc1fa4d..f7950c4105 100644 --- a/dlls/windowscodecs/wincodecs_private.h +++ b/dlls/windowscodecs/wincodecs_private.h @@ -75,7 +75,7 @@ HRESULT create_instance(CLSID *clsid, const IID *iid, void **ppv) DECLSPEC_HIDDE typedef HRESULT(*class_constructor)(REFIID,void**); extern HRESULT FormatConverter_CreateInstance(REFIID riid, void** ppv) DECLSPEC_HIDDEN; -extern HRESULT ComponentFactory_CreateInstance(REFIID riid, void** ppv) DECLSPEC_HIDDEN; +extern HRESULT ImagingFactory_CreateInstance(REFIID riid, void** ppv) DECLSPEC_HIDDEN; extern HRESULT BmpDecoder_CreateInstance(REFIID riid, void** ppv) DECLSPEC_HIDDEN; extern HRESULT PngDecoder_CreateInstance(REFIID iid, void** ppv) DECLSPEC_HIDDEN; extern HRESULT PngEncoder_CreateInstance(REFIID iid, void** ppv) DECLSPEC_HIDDEN; -- 2.19.0

2 3

[PATCH 4/4] winevulkan: Update vk.xml to 1.1.86.
by Józef Kucia 05 Oct '18

05 Oct '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 2 +- dlls/winevulkan/vulkan_thunks.c | 151 +++ dlls/winevulkan/vulkan_thunks.h | 47 + include/wine/vulkan.h | 2673 +++++++++++++++++++++++---------------- 4 files changed, 1811 insertions(+), 1062 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index cb55a303ef18..ec861bda7d7c 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -64,7 +64,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler()) -VK_XML_VERSION = "1.1.76" +VK_XML_VERSION = "1.1.86" WINE_VK_VERSION = (1, 0) # Filenames to create. diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index f5cadd8c72b6..8d7249e1c514 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -176,6 +176,17 @@ static inline void free_VkBindImageMemoryInfo_array(VkBindImageMemoryInfo_host * heap_free(in); } +static inline void convert_VkConditionalRenderingBeginInfoEXT_win_to_host(const VkConditionalRenderingBeginInfoEXT *in, VkConditionalRenderingBeginInfoEXT_host *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->buffer = in->buffer; + out->offset = in->offset; + out->flags = in->flags; +} + static inline void convert_VkRenderPassBeginInfo_win_to_host(const VkRenderPassBeginInfo *in, VkRenderPassBeginInfo_host *out) { if (!in) return; @@ -1293,6 +1304,21 @@ static VkResult WINAPI wine_vkBindImageMemory2KHR(VkDevice device, uint32_t bind #endif } +static void WINAPI wine_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin) +{ +#if defined(USE_STRUCT_CONVERSION) + VkConditionalRenderingBeginInfoEXT_host pConditionalRenderingBegin_host; + TRACE("%p, %p\n", commandBuffer, pConditionalRenderingBegin); + + convert_VkConditionalRenderingBeginInfoEXT_win_to_host(pConditionalRenderingBegin, &pConditionalRenderingBegin_host); + commandBuffer->device->funcs.p_vkCmdBeginConditionalRenderingEXT(commandBuffer->command_buffer, &pConditionalRenderingBegin_host); + +#else + TRACE("%p, %p\n", commandBuffer, pConditionalRenderingBegin); + commandBuffer->device->funcs.p_vkCmdBeginConditionalRenderingEXT(commandBuffer->command_buffer, pConditionalRenderingBegin); +#endif +} + void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { TRACE("%p, 0x%s, %u, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags); @@ -1314,6 +1340,21 @@ void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRen #endif } +static void WINAPI wine_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfoKHR *pSubpassBeginInfo) +{ +#if defined(USE_STRUCT_CONVERSION) + VkRenderPassBeginInfo_host pRenderPassBegin_host; + TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + + convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host); + commandBuffer->device->funcs.p_vkCmdBeginRenderPass2KHR(commandBuffer->command_buffer, &pRenderPassBegin_host, pSubpassBeginInfo); + +#else + TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + commandBuffer->device->funcs.p_vkCmdBeginRenderPass2KHR(commandBuffer->command_buffer, pRenderPassBegin, pSubpassBeginInfo); +#endif +} + void WINAPI wine_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) { TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); @@ -1332,6 +1373,12 @@ void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBind commandBuffer->device->funcs.p_vkCmdBindPipeline(commandBuffer->command_buffer, pipelineBindPoint, pipeline); } +static void WINAPI wine_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(imageView), imageLayout); + commandBuffer->device->funcs.p_vkCmdBindShadingRateImageNV(commandBuffer->command_buffer, imageView, imageLayout); +} + void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) { TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); @@ -1494,6 +1541,30 @@ static void WINAPI wine_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, commandBuffer->device->funcs.p_vkCmdDrawIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } +static void WINAPI wine_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride); + commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +static void WINAPI wine_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride); + commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(commandBuffer->command_buffer, buffer, offset, drawCount, stride); +} + +static void WINAPI wine_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) +{ + TRACE("%p, %u, %u\n", commandBuffer, taskCount, firstTask); + commandBuffer->device->funcs.p_vkCmdDrawMeshTasksNV(commandBuffer->command_buffer, taskCount, firstTask); +} + +static void WINAPI wine_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) +{ + TRACE("%p\n", commandBuffer); + commandBuffer->device->funcs.p_vkCmdEndConditionalRenderingEXT(commandBuffer->command_buffer); +} + void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { TRACE("%p, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query); @@ -1506,6 +1577,12 @@ void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) commandBuffer->device->funcs.p_vkCmdEndRenderPass(commandBuffer->command_buffer); } +static void WINAPI wine_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo) +{ + TRACE("%p, %p\n", commandBuffer, pSubpassEndInfo); + commandBuffer->device->funcs.p_vkCmdEndRenderPass2KHR(commandBuffer->command_buffer, pSubpassEndInfo); +} + void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data); @@ -1518,6 +1595,12 @@ void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassConten commandBuffer->device->funcs.p_vkCmdNextSubpass(commandBuffer->command_buffer, contents); } +static void WINAPI wine_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const VkSubpassEndInfoKHR *pSubpassEndInfo) +{ + TRACE("%p, %p, %p\n", commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + commandBuffer->device->funcs.p_vkCmdNextSubpass2KHR(commandBuffer->command_buffer, pSubpassBeginInfo, pSubpassEndInfo); +} + void WINAPI wine_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { #if defined(USE_STRUCT_CONVERSION) @@ -1589,6 +1672,18 @@ void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const flo commandBuffer->device->funcs.p_vkCmdSetBlendConstants(commandBuffer->command_buffer, blendConstants); } +static void WINAPI wine_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker) +{ + TRACE("%p, %p\n", commandBuffer, pCheckpointMarker); + commandBuffer->device->funcs.p_vkCmdSetCheckpointNV(commandBuffer->command_buffer, pCheckpointMarker); +} + +static void WINAPI wine_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders) +{ + TRACE("%p, %#x, %u, %p\n", commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); + commandBuffer->device->funcs.p_vkCmdSetCoarseSampleOrderNV(commandBuffer->command_buffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); +} + void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { TRACE("%p, %f, %f, %f\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); @@ -1625,6 +1720,12 @@ void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkP commandBuffer->device->funcs.p_vkCmdSetEvent(commandBuffer->command_buffer, event, stageMask); } +static void WINAPI wine_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors) +{ + TRACE("%p, %u, %u, %p\n", commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); + commandBuffer->device->funcs.p_vkCmdSetExclusiveScissorNV(commandBuffer->command_buffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); +} + void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { TRACE("%p, %f\n", commandBuffer, lineWidth); @@ -1667,6 +1768,12 @@ void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstV commandBuffer->device->funcs.p_vkCmdSetViewport(commandBuffer->command_buffer, firstViewport, viewportCount, pViewports); } +static void WINAPI wine_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes) +{ + TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); + commandBuffer->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(commandBuffer->command_buffer, firstViewport, viewportCount, pShadingRatePalettes); +} + static void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings) { TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewportWScalings); @@ -1902,6 +2009,12 @@ VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreat return device->funcs.p_vkCreateRenderPass(device->device, pCreateInfo, NULL, pRenderPass); } +static VkResult WINAPI wine_vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) +{ + TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass); + return device->funcs.p_vkCreateRenderPass2KHR(device->device, pCreateInfo, NULL, pRenderPass); +} + VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) { TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSampler); @@ -2633,6 +2746,12 @@ VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPoo return device->funcs.p_vkGetQueryPoolResults(device->device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); } +static void WINAPI wine_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData) +{ + TRACE("%p, %p, %p\n", queue, pCheckpointDataCount, pCheckpointData); + queue->device->funcs.p_vkGetQueueCheckpointDataNV(queue->queue, pCheckpointDataCount, pCheckpointData); +} + void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) { TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pGranularity); @@ -2828,11 +2947,14 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkBindImageMemory", &wine_vkBindImageMemory}, {"vkBindImageMemory2", &wine_vkBindImageMemory2}, {"vkBindImageMemory2KHR", &wine_vkBindImageMemory2KHR}, + {"vkCmdBeginConditionalRenderingEXT", &wine_vkCmdBeginConditionalRenderingEXT}, {"vkCmdBeginQuery", &wine_vkCmdBeginQuery}, {"vkCmdBeginRenderPass", &wine_vkCmdBeginRenderPass}, + {"vkCmdBeginRenderPass2KHR", &wine_vkCmdBeginRenderPass2KHR}, {"vkCmdBindDescriptorSets", &wine_vkCmdBindDescriptorSets}, {"vkCmdBindIndexBuffer", &wine_vkCmdBindIndexBuffer}, {"vkCmdBindPipeline", &wine_vkCmdBindPipeline}, + {"vkCmdBindShadingRateImageNV", &wine_vkCmdBindShadingRateImageNV}, {"vkCmdBindVertexBuffers", &wine_vkCmdBindVertexBuffers}, {"vkCmdBlitImage", &wine_vkCmdBlitImage}, {"vkCmdClearAttachments", &wine_vkCmdClearAttachments}, @@ -2855,11 +2977,17 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdDrawIndirect", &wine_vkCmdDrawIndirect}, {"vkCmdDrawIndirectCountAMD", &wine_vkCmdDrawIndirectCountAMD}, {"vkCmdDrawIndirectCountKHR", &wine_vkCmdDrawIndirectCountKHR}, + {"vkCmdDrawMeshTasksIndirectCountNV", &wine_vkCmdDrawMeshTasksIndirectCountNV}, + {"vkCmdDrawMeshTasksIndirectNV", &wine_vkCmdDrawMeshTasksIndirectNV}, + {"vkCmdDrawMeshTasksNV", &wine_vkCmdDrawMeshTasksNV}, + {"vkCmdEndConditionalRenderingEXT", &wine_vkCmdEndConditionalRenderingEXT}, {"vkCmdEndQuery", &wine_vkCmdEndQuery}, {"vkCmdEndRenderPass", &wine_vkCmdEndRenderPass}, + {"vkCmdEndRenderPass2KHR", &wine_vkCmdEndRenderPass2KHR}, {"vkCmdExecuteCommands", &wine_vkCmdExecuteCommands}, {"vkCmdFillBuffer", &wine_vkCmdFillBuffer}, {"vkCmdNextSubpass", &wine_vkCmdNextSubpass}, + {"vkCmdNextSubpass2KHR", &wine_vkCmdNextSubpass2KHR}, {"vkCmdPipelineBarrier", &wine_vkCmdPipelineBarrier}, {"vkCmdPushConstants", &wine_vkCmdPushConstants}, {"vkCmdPushDescriptorSetKHR", &wine_vkCmdPushDescriptorSetKHR}, @@ -2868,12 +2996,15 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdResetQueryPool", &wine_vkCmdResetQueryPool}, {"vkCmdResolveImage", &wine_vkCmdResolveImage}, {"vkCmdSetBlendConstants", &wine_vkCmdSetBlendConstants}, + {"vkCmdSetCheckpointNV", &wine_vkCmdSetCheckpointNV}, + {"vkCmdSetCoarseSampleOrderNV", &wine_vkCmdSetCoarseSampleOrderNV}, {"vkCmdSetDepthBias", &wine_vkCmdSetDepthBias}, {"vkCmdSetDepthBounds", &wine_vkCmdSetDepthBounds}, {"vkCmdSetDeviceMask", &wine_vkCmdSetDeviceMask}, {"vkCmdSetDeviceMaskKHR", &wine_vkCmdSetDeviceMaskKHR}, {"vkCmdSetDiscardRectangleEXT", &wine_vkCmdSetDiscardRectangleEXT}, {"vkCmdSetEvent", &wine_vkCmdSetEvent}, + {"vkCmdSetExclusiveScissorNV", &wine_vkCmdSetExclusiveScissorNV}, {"vkCmdSetLineWidth", &wine_vkCmdSetLineWidth}, {"vkCmdSetSampleLocationsEXT", &wine_vkCmdSetSampleLocationsEXT}, {"vkCmdSetScissor", &wine_vkCmdSetScissor}, @@ -2881,6 +3012,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdSetStencilReference", &wine_vkCmdSetStencilReference}, {"vkCmdSetStencilWriteMask", &wine_vkCmdSetStencilWriteMask}, {"vkCmdSetViewport", &wine_vkCmdSetViewport}, + {"vkCmdSetViewportShadingRatePaletteNV", &wine_vkCmdSetViewportShadingRatePaletteNV}, {"vkCmdSetViewportWScalingNV", &wine_vkCmdSetViewportWScalingNV}, {"vkCmdUpdateBuffer", &wine_vkCmdUpdateBuffer}, {"vkCmdWaitEvents", &wine_vkCmdWaitEvents}, @@ -2904,6 +3036,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreatePipelineLayout", &wine_vkCreatePipelineLayout}, {"vkCreateQueryPool", &wine_vkCreateQueryPool}, {"vkCreateRenderPass", &wine_vkCreateRenderPass}, + {"vkCreateRenderPass2KHR", &wine_vkCreateRenderPass2KHR}, {"vkCreateSampler", &wine_vkCreateSampler}, {"vkCreateSamplerYcbcrConversion", &wine_vkCreateSamplerYcbcrConversion}, {"vkCreateSamplerYcbcrConversionKHR", &wine_vkCreateSamplerYcbcrConversionKHR}, @@ -2966,6 +3099,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetImageSubresourceLayout", &wine_vkGetImageSubresourceLayout}, {"vkGetPipelineCacheData", &wine_vkGetPipelineCacheData}, {"vkGetQueryPoolResults", &wine_vkGetQueryPoolResults}, + {"vkGetQueueCheckpointDataNV", &wine_vkGetQueueCheckpointDataNV}, {"vkGetRenderAreaGranularity", &wine_vkGetRenderAreaGranularity}, {"vkGetShaderInfoAMD", &wine_vkGetShaderInfoAMD}, {"vkGetSwapchainImagesKHR", &wine_vkGetSwapchainImagesKHR}, @@ -3080,12 +3214,15 @@ static const char * const vk_device_extensions[] = "VK_AMD_shader_info", "VK_AMD_shader_trinary_minmax", "VK_AMD_texture_gather_bias_lod", + "VK_EXT_astc_decode_mode", "VK_EXT_blend_operation_advanced", + "VK_EXT_conditional_rendering", "VK_EXT_conservative_rasterization", "VK_EXT_depth_range_unrestricted", "VK_EXT_descriptor_indexing", "VK_EXT_discard_rectangles", "VK_EXT_global_priority", + "VK_EXT_inline_uniform_block", "VK_EXT_post_depth_coverage", "VK_EXT_sample_locations", "VK_EXT_sampler_filter_minmax", @@ -3098,11 +3235,14 @@ static const char * const vk_device_extensions[] = "VK_IMG_filter_cubic", "VK_IMG_format_pvrtc", "VK_KHR_16bit_storage", + "VK_KHR_8bit_storage", "VK_KHR_bind_memory2", + "VK_KHR_create_renderpass2", "VK_KHR_dedicated_allocation", "VK_KHR_descriptor_update_template", "VK_KHR_device_group", "VK_KHR_draw_indirect_count", + "VK_KHR_driver_properties", "VK_KHR_get_memory_requirements2", "VK_KHR_image_format_list", "VK_KHR_incremental_present", @@ -3114,20 +3254,31 @@ static const char * const vk_device_extensions[] = "VK_KHR_relaxed_block_layout", "VK_KHR_sampler_mirror_clamp_to_edge", "VK_KHR_sampler_ycbcr_conversion", + "VK_KHR_shader_atomic_int64", "VK_KHR_shader_draw_parameters", "VK_KHR_storage_buffer_storage_class", "VK_KHR_swapchain", "VK_KHR_variable_pointers", + "VK_KHR_vulkan_memory_model", "VK_NV_clip_space_w_scaling", + "VK_NV_compute_shader_derivatives", + "VK_NV_corner_sampled_image", "VK_NV_dedicated_allocation", + "VK_NV_device_diagnostic_checkpoints", "VK_NV_external_memory", "VK_NV_fill_rectangle", "VK_NV_fragment_coverage_to_color", + "VK_NV_fragment_shader_barycentric", "VK_NV_framebuffer_mixed_samples", "VK_NV_geometry_shader_passthrough", "VK_NV_glsl_shader", + "VK_NV_mesh_shader", + "VK_NV_representative_fragment_test", "VK_NV_sample_mask_override_coverage", + "VK_NV_scissor_exclusive", + "VK_NV_shader_image_footprint", "VK_NV_shader_subgroup_partitioned", + "VK_NV_shading_rate_image", "VK_NV_viewport_array2", "VK_NV_viewport_swizzle", }; diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 21f9b4817800..38c45386c747 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -133,6 +133,15 @@ typedef struct VkBindImageMemoryInfo_host VkDeviceSize memoryOffset; } VkBindImageMemoryInfo_host; +typedef struct VkConditionalRenderingBeginInfoEXT_host +{ + VkStructureType sType; + const void *pNext; + VkBuffer buffer; + VkDeviceSize offset; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfoEXT_host; + typedef struct VkRenderPassBeginInfo_host { VkStructureType sType; @@ -685,16 +694,27 @@ struct vulkan_device_funcs VkResult (*p_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo_host *); #else VkResult (*p_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); +#endif +#if defined(USE_STRUCT_CONVERSION) + void (*p_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer, const VkConditionalRenderingBeginInfoEXT_host *); +#else + void (*p_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer, const VkConditionalRenderingBeginInfoEXT *); #endif void (*p_vkCmdBeginQuery)(VkCommandBuffer, VkQueryPool, uint32_t, VkQueryControlFlags); #if defined(USE_STRUCT_CONVERSION) void (*p_vkCmdBeginRenderPass)(VkCommandBuffer, const VkRenderPassBeginInfo_host *, VkSubpassContents); #else void (*p_vkCmdBeginRenderPass)(VkCommandBuffer, const VkRenderPassBeginInfo *, VkSubpassContents); +#endif +#if defined(USE_STRUCT_CONVERSION) + void (*p_vkCmdBeginRenderPass2KHR)(VkCommandBuffer, const VkRenderPassBeginInfo_host *, const VkSubpassBeginInfoKHR *); +#else + void (*p_vkCmdBeginRenderPass2KHR)(VkCommandBuffer, const VkRenderPassBeginInfo *, const VkSubpassBeginInfoKHR *); #endif void (*p_vkCmdBindDescriptorSets)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkDescriptorSet *, uint32_t, const uint32_t *); void (*p_vkCmdBindIndexBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkIndexType); void (*p_vkCmdBindPipeline)(VkCommandBuffer, VkPipelineBindPoint, VkPipeline); + void (*p_vkCmdBindShadingRateImageNV)(VkCommandBuffer, VkImageView, VkImageLayout); void (*p_vkCmdBindVertexBuffers)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *); void (*p_vkCmdBlitImage)(VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, uint32_t, const VkImageBlit *, VkFilter); void (*p_vkCmdClearAttachments)(VkCommandBuffer, uint32_t, const VkClearAttachment *, uint32_t, const VkClearRect *); @@ -729,11 +749,17 @@ struct vulkan_device_funcs void (*p_vkCmdDrawIndirect)(VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, uint32_t); void (*p_vkCmdDrawIndirectCountAMD)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkBuffer, VkDeviceSize, uint32_t, uint32_t); void (*p_vkCmdDrawIndirectCountKHR)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkBuffer, VkDeviceSize, uint32_t, uint32_t); + void (*p_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkBuffer, VkDeviceSize, uint32_t, uint32_t); + void (*p_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, uint32_t); + void (*p_vkCmdDrawMeshTasksNV)(VkCommandBuffer, uint32_t, uint32_t); + void (*p_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer); void (*p_vkCmdEndQuery)(VkCommandBuffer, VkQueryPool, uint32_t); void (*p_vkCmdEndRenderPass)(VkCommandBuffer); + void (*p_vkCmdEndRenderPass2KHR)(VkCommandBuffer, const VkSubpassEndInfoKHR *); void (*p_vkCmdExecuteCommands)(VkCommandBuffer, uint32_t, const VkCommandBuffer *); void (*p_vkCmdFillBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, uint32_t); void (*p_vkCmdNextSubpass)(VkCommandBuffer, VkSubpassContents); + void (*p_vkCmdNextSubpass2KHR)(VkCommandBuffer, const VkSubpassBeginInfoKHR *, const VkSubpassEndInfoKHR *); #if defined(USE_STRUCT_CONVERSION) void (*p_vkCmdPipelineBarrier)(VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, const VkBufferMemoryBarrier_host *, uint32_t, const VkImageMemoryBarrier_host *); #else @@ -750,12 +776,15 @@ struct vulkan_device_funcs void (*p_vkCmdResetQueryPool)(VkCommandBuffer, VkQueryPool, uint32_t, uint32_t); void (*p_vkCmdResolveImage)(VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, uint32_t, const VkImageResolve *); void (*p_vkCmdSetBlendConstants)(VkCommandBuffer, const float[4]); + void (*p_vkCmdSetCheckpointNV)(VkCommandBuffer, const void *); + void (*p_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer, VkCoarseSampleOrderTypeNV, uint32_t, const VkCoarseSampleOrderCustomNV *); void (*p_vkCmdSetDepthBias)(VkCommandBuffer, float, float, float); void (*p_vkCmdSetDepthBounds)(VkCommandBuffer, float, float); void (*p_vkCmdSetDeviceMask)(VkCommandBuffer, uint32_t); void (*p_vkCmdSetDeviceMaskKHR)(VkCommandBuffer, uint32_t); void (*p_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *); void (*p_vkCmdSetEvent)(VkCommandBuffer, VkEvent, VkPipelineStageFlags); + void (*p_vkCmdSetExclusiveScissorNV)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *); void (*p_vkCmdSetLineWidth)(VkCommandBuffer, float); void (*p_vkCmdSetSampleLocationsEXT)(VkCommandBuffer, const VkSampleLocationsInfoEXT *); void (*p_vkCmdSetScissor)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *); @@ -763,6 +792,7 @@ struct vulkan_device_funcs void (*p_vkCmdSetStencilReference)(VkCommandBuffer, VkStencilFaceFlags, uint32_t); void (*p_vkCmdSetStencilWriteMask)(VkCommandBuffer, VkStencilFaceFlags, uint32_t); void (*p_vkCmdSetViewport)(VkCommandBuffer, uint32_t, uint32_t, const VkViewport *); + void (*p_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer, uint32_t, uint32_t, const VkShadingRatePaletteNV *); void (*p_vkCmdSetViewportWScalingNV)(VkCommandBuffer, uint32_t, uint32_t, const VkViewportWScalingNV *); void (*p_vkCmdUpdateBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, const void *); #if defined(USE_STRUCT_CONVERSION) @@ -822,6 +852,7 @@ struct vulkan_device_funcs VkResult (*p_vkCreatePipelineLayout)(VkDevice, const VkPipelineLayoutCreateInfo *, const VkAllocationCallbacks *, VkPipelineLayout *); VkResult (*p_vkCreateQueryPool)(VkDevice, const VkQueryPoolCreateInfo *, const VkAllocationCallbacks *, VkQueryPool *); VkResult (*p_vkCreateRenderPass)(VkDevice, const VkRenderPassCreateInfo *, const VkAllocationCallbacks *, VkRenderPass *); + VkResult (*p_vkCreateRenderPass2KHR)(VkDevice, const VkRenderPassCreateInfo2KHR *, const VkAllocationCallbacks *, VkRenderPass *); VkResult (*p_vkCreateSampler)(VkDevice, const VkSamplerCreateInfo *, const VkAllocationCallbacks *, VkSampler *); VkResult (*p_vkCreateSamplerYcbcrConversion)(VkDevice, const VkSamplerYcbcrConversionCreateInfo *, const VkAllocationCallbacks *, VkSamplerYcbcrConversion *); VkResult (*p_vkCreateSamplerYcbcrConversionKHR)(VkDevice, const VkSamplerYcbcrConversionCreateInfo *, const VkAllocationCallbacks *, VkSamplerYcbcrConversion *); @@ -927,6 +958,7 @@ struct vulkan_device_funcs #endif VkResult (*p_vkGetPipelineCacheData)(VkDevice, VkPipelineCache, size_t *, void *); VkResult (*p_vkGetQueryPoolResults)(VkDevice, VkQueryPool, uint32_t, uint32_t, size_t, void *, VkDeviceSize, VkQueryResultFlags); + void (*p_vkGetQueueCheckpointDataNV)(VkQueue, uint32_t *, VkCheckpointDataNV *); void (*p_vkGetRenderAreaGranularity)(VkDevice, VkRenderPass, VkExtent2D *); VkResult (*p_vkGetShaderInfoAMD)(VkDevice, VkPipeline, VkShaderStageFlagBits, VkShaderInfoTypeAMD, size_t *, void *); VkResult (*p_vkGetSwapchainImagesKHR)(VkDevice, VkSwapchainKHR, uint32_t *, VkImage *); @@ -1056,11 +1088,14 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkBindImageMemory) \ USE_VK_FUNC(vkBindImageMemory2) \ USE_VK_FUNC(vkBindImageMemory2KHR) \ + USE_VK_FUNC(vkCmdBeginConditionalRenderingEXT) \ USE_VK_FUNC(vkCmdBeginQuery) \ USE_VK_FUNC(vkCmdBeginRenderPass) \ + USE_VK_FUNC(vkCmdBeginRenderPass2KHR) \ USE_VK_FUNC(vkCmdBindDescriptorSets) \ USE_VK_FUNC(vkCmdBindIndexBuffer) \ USE_VK_FUNC(vkCmdBindPipeline) \ + USE_VK_FUNC(vkCmdBindShadingRateImageNV) \ USE_VK_FUNC(vkCmdBindVertexBuffers) \ USE_VK_FUNC(vkCmdBlitImage) \ USE_VK_FUNC(vkCmdClearAttachments) \ @@ -1083,11 +1118,17 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdDrawIndirect) \ USE_VK_FUNC(vkCmdDrawIndirectCountAMD) \ USE_VK_FUNC(vkCmdDrawIndirectCountKHR) \ + USE_VK_FUNC(vkCmdDrawMeshTasksIndirectCountNV) \ + USE_VK_FUNC(vkCmdDrawMeshTasksIndirectNV) \ + USE_VK_FUNC(vkCmdDrawMeshTasksNV) \ + USE_VK_FUNC(vkCmdEndConditionalRenderingEXT) \ USE_VK_FUNC(vkCmdEndQuery) \ USE_VK_FUNC(vkCmdEndRenderPass) \ + USE_VK_FUNC(vkCmdEndRenderPass2KHR) \ USE_VK_FUNC(vkCmdExecuteCommands) \ USE_VK_FUNC(vkCmdFillBuffer) \ USE_VK_FUNC(vkCmdNextSubpass) \ + USE_VK_FUNC(vkCmdNextSubpass2KHR) \ USE_VK_FUNC(vkCmdPipelineBarrier) \ USE_VK_FUNC(vkCmdPushConstants) \ USE_VK_FUNC(vkCmdPushDescriptorSetKHR) \ @@ -1096,12 +1137,15 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdResetQueryPool) \ USE_VK_FUNC(vkCmdResolveImage) \ USE_VK_FUNC(vkCmdSetBlendConstants) \ + USE_VK_FUNC(vkCmdSetCheckpointNV) \ + USE_VK_FUNC(vkCmdSetCoarseSampleOrderNV) \ USE_VK_FUNC(vkCmdSetDepthBias) \ USE_VK_FUNC(vkCmdSetDepthBounds) \ USE_VK_FUNC(vkCmdSetDeviceMask) \ USE_VK_FUNC(vkCmdSetDeviceMaskKHR) \ USE_VK_FUNC(vkCmdSetDiscardRectangleEXT) \ USE_VK_FUNC(vkCmdSetEvent) \ + USE_VK_FUNC(vkCmdSetExclusiveScissorNV) \ USE_VK_FUNC(vkCmdSetLineWidth) \ USE_VK_FUNC(vkCmdSetSampleLocationsEXT) \ USE_VK_FUNC(vkCmdSetScissor) \ @@ -1109,6 +1153,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdSetStencilReference) \ USE_VK_FUNC(vkCmdSetStencilWriteMask) \ USE_VK_FUNC(vkCmdSetViewport) \ + USE_VK_FUNC(vkCmdSetViewportShadingRatePaletteNV) \ USE_VK_FUNC(vkCmdSetViewportWScalingNV) \ USE_VK_FUNC(vkCmdUpdateBuffer) \ USE_VK_FUNC(vkCmdWaitEvents) \ @@ -1132,6 +1177,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCreatePipelineLayout) \ USE_VK_FUNC(vkCreateQueryPool) \ USE_VK_FUNC(vkCreateRenderPass) \ + USE_VK_FUNC(vkCreateRenderPass2KHR) \ USE_VK_FUNC(vkCreateSampler) \ USE_VK_FUNC(vkCreateSamplerYcbcrConversion) \ USE_VK_FUNC(vkCreateSamplerYcbcrConversionKHR) \ @@ -1193,6 +1239,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetImageSubresourceLayout) \ USE_VK_FUNC(vkGetPipelineCacheData) \ USE_VK_FUNC(vkGetQueryPoolResults) \ + USE_VK_FUNC(vkGetQueueCheckpointDataNV) \ USE_VK_FUNC(vkGetRenderAreaGranularity) \ USE_VK_FUNC(vkGetShaderInfoAMD) \ USE_VK_FUNC(vkGetSwapchainImagesKHR) \ diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 31e8e5cfdefe..1145fa84bd56 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -81,9 +81,10 @@ #define VK_SUBPASS_EXTERNAL (~0U) #define VK_MAX_DEVICE_GROUP_SIZE 32 #define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE +#define VK_MAX_DRIVER_NAME_SIZE_KHR 256 +#define VK_MAX_DRIVER_INFO_SIZE_KHR 256 #define VK_KHR_SURFACE_SPEC_VERSION 25 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" -#define VK_COLORSPACE_SRGB_NONLINEAR_KHR VK_COLOR_SPACE_SRGB_NONLINEAR_KHR #define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 @@ -120,6 +121,8 @@ #define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" +#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2 +#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image" #define VK_KHR_MULTIVIEW_SPEC_VERSION 1 #define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 @@ -136,12 +139,16 @@ #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" +#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 +#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" #define VK_KHR_MAINTENANCE1_SPEC_VERSION 2 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1" #define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 #define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" +#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1 +#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 @@ -162,6 +169,8 @@ #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" #define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" +#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1 +#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2" #define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 @@ -178,6 +187,8 @@ #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" #define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 #define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" +#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block" #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 @@ -204,25 +215,48 @@ #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" -#define VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT #define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 #define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" +#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3 +#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image" +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" #define VK_KHR_MAINTENANCE3_SPEC_VERSION 1 #define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3" #define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 #define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" +#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" #define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 #define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" +#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64" #define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 #define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" -#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" +#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1 +#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties" #define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives" +#define VK_NV_MESH_SHADER_SPEC_VERSION 1 +#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader" +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" +#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" +#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1 +#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints" +#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 2 +#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" #define VK_MAKE_VERSION(major, minor, patch) \ (((major) << 22) | ((minor) << 12) | (patch)) @@ -231,7 +265,7 @@ #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0) #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0) -#define VK_HEADER_VERSION 76 +#define VK_HEADER_VERSION 86 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; #define VK_NULL_HANDLE 0 @@ -280,6 +314,7 @@ typedef VkFlags VkAttachmentDescriptionFlags; typedef VkFlags VkBufferCreateFlags; typedef VkFlags VkBufferUsageFlags; typedef VkFlags VkBufferViewCreateFlags; +typedef VkFlags VkBuildAccelerationStructureFlagsNVX; typedef VkFlags VkColorComponentFlags; typedef VkFlags VkCommandBufferResetFlags; typedef VkFlags VkCommandBufferUsageFlags; @@ -288,6 +323,7 @@ typedef VkFlags VkCommandPoolResetFlags; typedef VkFlags VkCommandPoolTrimFlags; typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; typedef VkFlags VkCompositeAlphaFlagsKHR; +typedef VkFlags VkConditionalRenderingFlagsEXT; typedef VkFlags VkCullModeFlags; typedef VkFlags VkDebugReportFlagsEXT; typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; @@ -327,6 +363,8 @@ typedef VkFlags VkFenceImportFlags; typedef VkFenceImportFlags VkFenceImportFlagsKHR; typedef VkFlags VkFormatFeatureFlags; typedef VkFlags VkFramebufferCreateFlags; +typedef VkFlags VkGeometryFlagsNVX; +typedef VkFlags VkGeometryInstanceFlagsNVX; typedef VkFlags VkIOSSurfaceCreateFlagsMVK; typedef VkFlags VkImageAspectFlags; typedef VkFlags VkImageCreateFlags; @@ -411,6 +449,8 @@ typedef enum VkAccessFlagBits VK_ACCESS_MEMORY_READ_BIT = 0x00008000, VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, + VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000, VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkAccessFlagBits; @@ -554,6 +594,7 @@ typedef enum VkBufferUsageFlagBits VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, + VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkBufferUsageFlagBits; @@ -564,6 +605,15 @@ typedef enum VkChromaLocation VK_CHROMA_LOCATION_MAX_ENUM = 0x7fffffff, } VkChromaLocation; +typedef enum VkCoarseSampleOrderTypeNV +{ + VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, + VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, + VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, + VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, + VK_COARSE_SAMPLE_ORDER_TYPE_NV_MAX_ENUM = 0x7fffffff, +} VkCoarseSampleOrderTypeNV; + typedef enum VkColorComponentFlagBits { VK_COLOR_COMPONENT_R_BIT = 0x00000001, @@ -576,6 +626,7 @@ typedef enum VkColorComponentFlagBits typedef enum VkColorSpaceKHR { VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, VK_COLOR_SPACE_KHR_MAX_ENUM = 0x7fffffff, } VkColorSpaceKHR; @@ -636,6 +687,12 @@ typedef enum VkCompositeAlphaFlagBitsKHR VK_COMPOSITE_ALPHA_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkCompositeAlphaFlagBitsKHR; +typedef enum VkConditionalRenderingFlagBitsEXT +{ + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, + VK_CONDITIONAL_RENDERING_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} VkConditionalRenderingFlagBitsEXT; + typedef enum VkConservativeRasterizationModeEXT { VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, @@ -697,6 +754,7 @@ typedef enum VkDescriptorType VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000, VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7fffffff, } VkDescriptorType; @@ -729,6 +787,20 @@ typedef enum VkDiscardRectangleModeEXT VK_DISCARD_RECTANGLE_MODE_EXT_MAX_ENUM = 0x7fffffff, } VkDiscardRectangleModeEXT; +typedef enum VkDriverIdKHR +{ + VK_DRIVER_ID_AMD_PROPRIETARY_KHR = 1, + VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = 2, + VK_DRIVER_ID_MESA_RADV_KHR = 3, + VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = 4, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = 5, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = 6, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = 7, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = 8, + VK_DRIVER_ID_ARM_PROPRIETARY_KHR = 9, + VK_DRIVER_ID_KHR_MAX_ENUM = 0x7fffffff, +} VkDriverIdKHR; + typedef enum VkDynamicState { VK_DYNAMIC_STATE_VIEWPORT = 0, @@ -743,6 +815,9 @@ typedef enum VkDynamicState VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, VK_DYNAMIC_STATE_MAX_ENUM = 0x7fffffff, } VkDynamicState; @@ -1114,6 +1189,7 @@ typedef enum VkImageCreateFlagBits VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkImageCreateFlagBits; @@ -1131,6 +1207,7 @@ typedef enum VkImageLayout VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003, VK_IMAGE_LAYOUT_MAX_ENUM = 0x7fffffff, } VkImageLayout; @@ -1159,6 +1236,7 @@ typedef enum VkImageUsageFlagBits VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100, VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkImageUsageFlagBits; @@ -1329,6 +1407,10 @@ typedef enum VkPipelineStageFlagBits VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, + VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000, VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkPipelineStageFlagBits; @@ -1538,10 +1620,29 @@ typedef enum VkShaderStageFlagBits VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001f, VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040, + VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080, VK_SHADER_STAGE_ALL = 0x7fffffff, VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkShaderStageFlagBits; +typedef enum VkShadingRatePaletteEntryNV +{ + VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, + VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, + VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, + VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, + VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, + VK_SHADING_RATE_PALETTE_ENTRY_NV_MAX_ENUM = 0x7fffffff, +} VkShadingRatePaletteEntryNV; + typedef enum VkSharingMode { VK_SHARING_MODE_EXCLUSIVE = 0, @@ -1635,6 +1736,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, @@ -1663,6 +1765,8 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, @@ -1677,6 +1781,9 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, @@ -1687,6 +1794,13 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, @@ -1699,6 +1813,10 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003, VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, @@ -1734,12 +1852,32 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000, VK_STRUCTURE_TYPE_MAX_ENUM = 0x7fffffff, } VkStructureType; @@ -1813,6 +1951,14 @@ typedef enum VkValidationCacheHeaderVersionEXT VK_VALIDATION_CACHE_HEADER_VERSION_EXT_MAX_ENUM = 0x7fffffff, } VkValidationCacheHeaderVersionEXT; +typedef enum VkVendorId +{ + VK_VENDOR_ID_VIV = 0x00010001, + VK_VENDOR_ID_VSI = 0x00010002, + VK_VENDOR_ID_KAZAN = 0x00010003, + VK_VENDOR_ID_MAX_ENUM = 0x7fffffff, +} VkVendorId; + typedef enum VkVertexInputRate { VK_VERTEX_INPUT_RATE_VERTEX = 0, @@ -1882,34 +2028,35 @@ typedef struct VkApplicationInfo uint32_t apiVersion; } VkApplicationInfo; -typedef struct VkAttachmentReference -{ - uint32_t attachment; - VkImageLayout layout; -} VkAttachmentReference; - -typedef struct VkBaseInStructure +typedef struct VkAttachmentDescription2KHR { VkStructureType sType; - const struct VkBaseInStructure *pNext; -} VkBaseInStructure; + const void *pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2KHR; -typedef struct VkBindBufferMemoryDeviceGroupInfo +typedef struct VkAttachmentReference2KHR { VkStructureType sType; const void *pNext; - uint32_t deviceIndexCount; - const uint32_t *pDeviceIndices; -} VkBindBufferMemoryDeviceGroupInfo; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2KHR; -typedef struct VkBindBufferMemoryInfo +typedef struct VkBaseInStructure { VkStructureType sType; - const void *pNext; - VkBuffer WINE_VK_ALIGN(8) buffer; - VkDeviceMemory WINE_VK_ALIGN(8) memory; - VkDeviceSize WINE_VK_ALIGN(8) memoryOffset; -} VkBindBufferMemoryInfo; + const struct VkBaseInStructure *pNext; +} VkBaseInStructure; typedef struct VkBindImagePlaneMemoryInfo { @@ -1938,6 +2085,14 @@ typedef struct VkBufferMemoryBarrier VkDeviceSize WINE_VK_ALIGN(8) size; } VkBufferMemoryBarrier; +typedef struct VkCheckpointDataNV +{ + VkStructureType sType; + void *pNext; + VkPipelineStageFlagBits stage; + void *pCheckpointMarker; +} VkCheckpointDataNV; + typedef union VkClearColorValue { float float32[4]; @@ -1945,6 +2100,13 @@ typedef union VkClearColorValue uint32_t uint32[4]; } VkClearColorValue; +typedef struct VkCoarseSampleLocationNV +{ + uint32_t pixelX; + uint32_t pixelY; + uint32_t sample; +} VkCoarseSampleLocationNV; + typedef struct VkCommandBufferAllocateInfo { VkStructureType sType; @@ -1954,25 +2116,29 @@ typedef struct VkCommandBufferAllocateInfo uint32_t commandBufferCount; } VkCommandBufferAllocateInfo; -typedef struct VkCommandBufferInheritanceInfo +typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { VkStructureType sType; const void *pNext; - VkRenderPass WINE_VK_ALIGN(8) renderPass; - uint32_t subpass; - VkFramebuffer WINE_VK_ALIGN(8) framebuffer; - VkBool32 occlusionQueryEnable; - VkQueryControlFlags queryFlags; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkCommandBufferInheritanceInfo; + VkBool32 conditionalRenderingEnable; +} VkCommandBufferInheritanceConditionalRenderingInfoEXT; -typedef struct VkComponentMapping +typedef struct VkCommandPoolCreateInfo { - VkComponentSwizzle r; - VkComponentSwizzle g; - VkComponentSwizzle b; - VkComponentSwizzle a; -} VkComponentMapping; + VkStructureType sType; + const void *pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkConditionalRenderingBeginInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkBuffer WINE_VK_ALIGN(8) buffer; + VkDeviceSize WINE_VK_ALIGN(8) offset; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfoEXT; typedef struct VkCopyDescriptorSet { @@ -1994,43 +2160,51 @@ typedef struct VkDedicatedAllocationImageCreateInfoNV VkBool32 dedicatedAllocation; } VkDedicatedAllocationImageCreateInfoNV; -typedef struct VkDescriptorBufferInfo +typedef struct VkDescriptorImageInfo { - VkBuffer WINE_VK_ALIGN(8) buffer; - VkDeviceSize WINE_VK_ALIGN(8) offset; - VkDeviceSize WINE_VK_ALIGN(8) range; -} VkDescriptorBufferInfo; + VkSampler WINE_VK_ALIGN(8) sampler; + VkImageView WINE_VK_ALIGN(8) imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; -typedef struct VkDescriptorPoolSize +typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT { - VkDescriptorType type; - uint32_t descriptorCount; -} VkDescriptorPoolSize; + VkStructureType sType; + const void *pNext; + uint32_t maxInlineUniformBlockBindings; +} VkDescriptorPoolInlineUniformBlockCreateInfoEXT; -typedef struct VkDescriptorSetLayoutBinding +typedef struct VkDescriptorSetAllocateInfo { - uint32_t binding; - VkDescriptorType descriptorType; - uint32_t descriptorCount; - VkShaderStageFlags stageFlags; - const VkSampler *pImmutableSamplers; -} VkDescriptorSetLayoutBinding; + VkStructureType sType; + const void *pNext; + VkDescriptorPool WINE_VK_ALIGN(8) descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout *pSetLayouts; +} VkDescriptorSetAllocateInfo; -typedef struct VkDescriptorSetLayoutCreateInfo +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT { VkStructureType sType; const void *pNext; - VkDescriptorSetLayoutCreateFlags flags; uint32_t bindingCount; - const VkDescriptorSetLayoutBinding *pBindings; -} VkDescriptorSetLayoutCreateInfo; + const VkDescriptorBindingFlagsEXT *pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; -typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT +typedef struct VkDescriptorSetLayoutSupport { VkStructureType sType; void *pNext; - uint32_t maxVariableDescriptorCount; -} VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t descriptorSetCount; + const uint32_t *pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; typedef struct VkDeviceGroupPresentInfoKHR { @@ -2068,25 +2242,39 @@ typedef struct VkDrawIndirectCommand uint32_t firstInstance; } VkDrawIndirectCommand; -typedef struct VkExportFenceCreateInfo +typedef struct VkEventCreateInfo { VkStructureType sType; const void *pNext; - VkExternalFenceHandleTypeFlags handleTypes; -} VkExportFenceCreateInfo; + VkEventCreateFlags flags; +} VkEventCreateInfo; -typedef struct VkExportSemaphoreCreateInfo +typedef struct VkExportMemoryAllocateInfo { VkStructureType sType; const void *pNext; - VkExternalSemaphoreHandleTypeFlags handleTypes; -} VkExportSemaphoreCreateInfo; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; -typedef struct VkExtent2D +typedef struct VkExportMemoryAllocateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExportMemoryAllocateInfoNV; + +typedef struct VkExtensionProperties +{ + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkExtent3D { uint32_t width; uint32_t height; -} VkExtent2D; + uint32_t depth; +} VkExtent3D; typedef struct VkExternalMemoryBufferCreateInfo { @@ -2116,6 +2304,25 @@ typedef struct VkFormatProperties VkFormatFeatureFlags bufferFeatures; } VkFormatProperties; +typedef struct VkImageCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t *pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + typedef struct VkImageFormatListCreateInfoKHR { VkStructureType sType; @@ -2161,88 +2368,130 @@ typedef struct VkImageSubresourceRange uint32_t layerCount; } VkImageSubresourceRange; -typedef struct VkImageViewCreateInfo +typedef struct VkImageViewASTCDecodeModeEXT { VkStructureType sType; const void *pNext; - VkImageViewCreateFlags flags; - VkImage WINE_VK_ALIGN(8) image; - VkImageViewType viewType; - VkFormat format; - VkComponentMapping components; - VkImageSubresourceRange subresourceRange; -} VkImageViewCreateInfo; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT; -typedef struct VkLayerProperties +typedef struct VkImageViewUsageCreateInfo { - char layerName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; - uint32_t implementationVersion; - char description[VK_MAX_DESCRIPTION_SIZE]; -} VkLayerProperties; + VkStructureType sType; + const void *pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; -typedef struct VkMappedMemoryRange +typedef struct VkInputAttachmentAspectReference +{ + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkInstanceCreateInfo { VkStructureType sType; const void *pNext; - VkDeviceMemory WINE_VK_ALIGN(8) memory; - VkDeviceSize WINE_VK_ALIGN(8) offset; - VkDeviceSize WINE_VK_ALIGN(8) size; -} VkMappedMemoryRange; + VkInstanceCreateFlags flags; + const VkApplicationInfo *pApplicationInfo; + uint32_t enabledLayerCount; + const char * const*ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char * const*ppEnabledExtensionNames; +} VkInstanceCreateInfo; -typedef struct VkMemoryBarrier +typedef struct VkMemoryAllocateFlagsInfo { VkStructureType sType; const void *pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; -} VkMemoryBarrier; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; -typedef struct VkMultisamplePropertiesEXT +typedef struct VkMemoryAllocateInfo { VkStructureType sType; - void *pNext; - VkExtent2D maxSampleLocationGridSize; -} VkMultisamplePropertiesEXT; + const void *pNext; + VkDeviceSize WINE_VK_ALIGN(8) allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; -typedef struct VkOffset3D +typedef struct VkMemoryDedicatedAllocateInfo { - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; + VkStructureType sType; + const void *pNext; + VkImage WINE_VK_ALIGN(8) image; + VkBuffer WINE_VK_ALIGN(8) buffer; +} VkMemoryDedicatedAllocateInfo; -typedef struct VkPhysicalDevice16BitStorageFeatures +typedef struct VkMemoryDedicatedRequirements { VkStructureType sType; void *pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; -} VkPhysicalDevice16BitStorageFeatures; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; -typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT +typedef struct VkMemoryHeap { - VkStructureType sType; + VkDeviceSize WINE_VK_ALIGN(8) size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkMemoryRequirements +{ + VkDeviceSize WINE_VK_ALIGN(8) size; + VkDeviceSize WINE_VK_ALIGN(8) alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkMemoryRequirements2KHR +{ + VkStructureType sType; void *pNext; - VkBool32 advancedBlendCoherentOperations; -} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + VkMemoryRequirements WINE_VK_ALIGN(8) memoryRequirements; +} VkMemoryRequirements2KHR; -typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT +typedef struct VkOffset2D +{ + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { VkStructureType sType; void *pNext; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - VkBool32 primitiveUnderestimation; - VkBool32 conservativePointAndLineRasterization; - VkBool32 degenerateTrianglesRasterized; - VkBool32 degenerateLinesRasterized; - VkBool32 fullyCoveredFragmentShaderInputVariable; - VkBool32 conservativeRasterizationPostDepthCoverage; -} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 conditionalRendering; + VkBool32 inheritedConditionalRendering; +} VkPhysicalDeviceConditionalRenderingFeaturesEXT; + +typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV +{ + VkStructureType sType; + void *pNext; + VkBool32 cornerSampledImage; +} VkPhysicalDeviceCornerSampledImageFeaturesNV; typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT { @@ -2273,28 +2522,109 @@ typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; } VkPhysicalDeviceDescriptorIndexingPropertiesEXT; -typedef struct VkPhysicalDeviceExternalBufferInfo +typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { VkStructureType sType; - const void *pNext; - VkBufferCreateFlags flags; - VkBufferUsageFlags usage; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalBufferInfo; + void *pNext; + VkBool32 exclusiveScissor; +} VkPhysicalDeviceExclusiveScissorFeaturesNV; -typedef struct VkPhysicalDeviceExternalFenceInfo +typedef struct VkPhysicalDeviceExternalSemaphoreInfo { VkStructureType sType; const void *pNext; - VkExternalFenceHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalFenceInfo; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; -typedef struct VkPhysicalDeviceExternalImageFormatInfo +typedef struct VkPhysicalDeviceFeatures +{ + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkPhysicalDeviceGroupProperties { VkStructureType sType; - const void *pNext; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalImageFormatInfo; + void *pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + +typedef struct VkPhysicalDeviceIDProperties +{ + VkStructureType sType; + void *pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + +typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; +} VkPhysicalDeviceInlineUniformBlockPropertiesEXT; typedef struct VkPhysicalDeviceMaintenance3Properties { @@ -2304,6 +2634,25 @@ typedef struct VkPhysicalDeviceMaintenance3Properties VkDeviceSize WINE_VK_ALIGN(8) maxMemoryAllocationSize; } VkPhysicalDeviceMaintenance3Properties; +typedef struct VkPhysicalDeviceMeshShaderPropertiesNV +{ + VkStructureType sType; + void *pNext; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; +} VkPhysicalDeviceMeshShaderPropertiesNV; + typedef struct VkPhysicalDeviceMultiviewProperties { VkStructureType sType; @@ -2326,23 +2675,13 @@ typedef struct VkPhysicalDeviceProtectedMemoryProperties VkBool32 protectedNoFault; } VkPhysicalDeviceProtectedMemoryProperties; -typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT -{ - VkStructureType sType; - void *pNext; - VkSampleCountFlags sampleLocationSampleCounts; - VkExtent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - VkBool32 variableSampleLocations; -} VkPhysicalDeviceSampleLocationsPropertiesEXT; - -typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures +typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { VkStructureType sType; void *pNext; - VkBool32 samplerYcbcrConversion; -} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { @@ -2364,6 +2703,13 @@ typedef struct VkPhysicalDeviceShaderCorePropertiesAMD uint32_t vgprAllocationGranularity; } VkPhysicalDeviceShaderCorePropertiesAMD; +typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV +{ + VkStructureType sType; + void *pNext; + VkBool32 imageFootprint; +} VkPhysicalDeviceShaderImageFootprintFeaturesNV; + typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { VkStructureType sType; @@ -2384,6 +2730,13 @@ typedef struct VkPhysicalDeviceSparseProperties VkBool32 residencyNonResidentStrict; } VkPhysicalDeviceSparseProperties; +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + typedef struct VkPipelineCacheCreateInfo { VkStructureType sType; @@ -2455,6 +2808,13 @@ typedef struct VkPipelineRasterizationStateCreateInfo float lineWidth; } VkPipelineRasterizationStateCreateInfo; +typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkBool32 representativeFragmentTestEnable; +} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; + typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { VkStructureType sType; @@ -2499,6 +2859,34 @@ typedef struct VkQueryPoolCreateInfo VkQueryPipelineStatisticFlags pipelineStatistics; } VkQueryPoolCreateInfo; +typedef struct VkQueueFamilyProperties +{ + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference *pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t subpassCount; + const uint32_t *pViewMasks; + uint32_t dependencyCount; + const int32_t *pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t *pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + typedef struct VkSampleLocationEXT { float x; @@ -2527,47 +2915,45 @@ typedef struct VkSamplerCreateInfo VkBool32 unnormalizedCoordinates; } VkSamplerCreateInfo; -typedef struct VkSamplerYcbcrConversionCreateInfo +typedef struct VkShaderModuleCreateInfo { VkStructureType sType; const void *pNext; - VkFormat format; - VkSamplerYcbcrModelConversion ycbcrModel; - VkSamplerYcbcrRange ycbcrRange; - VkComponentMapping components; - VkChromaLocation xChromaOffset; - VkChromaLocation yChromaOffset; - VkFilter chromaFilter; - VkBool32 forceExplicitReconstruction; -} VkSamplerYcbcrConversionCreateInfo; - -typedef struct VkSamplerYcbcrConversionImageFormatProperties -{ - VkStructureType sType; - void *pNext; - uint32_t combinedImageSamplerDescriptorCount; -} VkSamplerYcbcrConversionImageFormatProperties; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t *pCode; +} VkShaderModuleCreateInfo; -typedef struct VkSamplerYcbcrConversionInfo +typedef struct VkShaderResourceUsageAMD { - VkStructureType sType; - const void *pNext; - VkSamplerYcbcrConversion WINE_VK_ALIGN(8) conversion; -} VkSamplerYcbcrConversionInfo; + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; +} VkShaderResourceUsageAMD; -typedef struct VkSemaphoreCreateInfo +typedef struct VkShadingRatePaletteNV { - VkStructureType sType; - const void *pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo; + uint32_t shadingRatePaletteEntryCount; + const VkShadingRatePaletteEntryNV *pShadingRatePaletteEntries; +} VkShadingRatePaletteNV; -typedef struct VkShaderModuleValidationCacheCreateInfoEXT +typedef struct VkSparseImageFormatProperties { - VkStructureType sType; - const void *pNext; - VkValidationCacheEXT WINE_VK_ALIGN(8) validationCache; -} VkShaderModuleValidationCacheCreateInfoEXT; + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct VkSparseImageMemoryRequirements +{ + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize WINE_VK_ALIGN(8) imageMipTailSize; + VkDeviceSize WINE_VK_ALIGN(8) imageMipTailOffset; + VkDeviceSize WINE_VK_ALIGN(8) imageMipTailStride; +} VkSparseImageMemoryRequirements; typedef struct VkSparseMemoryBind { @@ -2598,19 +2984,33 @@ typedef struct VkSubmitInfo const VkSemaphore *pSignalSemaphores; } VkSubmitInfo; -typedef struct VkSubpassDescription +typedef struct VkSubpassDependency +{ + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkSubpassDescription2KHR { + VkStructureType sType; + const void *pNext; VkSubpassDescriptionFlags flags; VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; uint32_t inputAttachmentCount; - const VkAttachmentReference *pInputAttachments; + const VkAttachmentReference2KHR *pInputAttachments; uint32_t colorAttachmentCount; - const VkAttachmentReference *pColorAttachments; - const VkAttachmentReference *pResolveAttachments; - const VkAttachmentReference *pDepthStencilAttachment; + const VkAttachmentReference2KHR *pColorAttachments; + const VkAttachmentReference2KHR *pResolveAttachments; + const VkAttachmentReference2KHR *pDepthStencilAttachment; uint32_t preserveAttachmentCount; const uint32_t *pPreserveAttachments; -} VkSubpassDescription; +} VkSubpassDescription2KHR; typedef struct VkSubresourceLayout { @@ -2643,15 +3043,26 @@ typedef struct VkViewportSwizzleNV VkViewportCoordinateSwizzleNV w; } VkViewportSwizzleNV; -typedef struct VkAllocationCallbacks +typedef struct VkWriteDescriptorSetInlineUniformBlockEXT { - void *pUserData; - PFN_vkAllocationFunction pfnAllocation; - PFN_vkReallocationFunction pfnReallocation; - PFN_vkFreeFunction pfnFree; - PFN_vkInternalAllocationNotification pfnInternalAllocation; - PFN_vkInternalFreeNotification pfnInternalFree; -} VkAllocationCallbacks; + VkStructureType sType; + const void *pNext; + uint32_t dataSize; + const void *pData; +} VkWriteDescriptorSetInlineUniformBlockEXT; + +typedef struct VkAttachmentDescription +{ + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; typedef struct VkBaseOutStructure { @@ -2659,6 +3070,15 @@ typedef struct VkBaseOutStructure struct VkBaseOutStructure *pNext; } VkBaseOutStructure; +typedef struct VkBindBufferMemoryInfo +{ + VkStructureType sType; + const void *pNext; + VkBuffer WINE_VK_ALIGN(8) buffer; + VkDeviceMemory WINE_VK_ALIGN(8) memory; + VkDeviceSize WINE_VK_ALIGN(8) memoryOffset; +} VkBindBufferMemoryInfo; + typedef struct VkBindImageMemoryInfo { VkStructureType sType; @@ -2699,47 +3119,53 @@ typedef union VkClearValue VkClearDepthStencilValue depthStencil; } VkClearValue; -typedef struct VkCommandBufferBeginInfo +typedef struct VkCoarseSampleOrderCustomNV { - VkStructureType sType; - const void *pNext; - VkCommandBufferUsageFlags flags; - const VkCommandBufferInheritanceInfo *pInheritanceInfo; -} VkCommandBufferBeginInfo; + VkShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + const VkCoarseSampleLocationNV *pSampleLocations; +} VkCoarseSampleOrderCustomNV; -typedef struct VkDedicatedAllocationMemoryAllocateInfoNV +typedef struct VkCommandBufferInheritanceInfo { VkStructureType sType; const void *pNext; - VkImage WINE_VK_ALIGN(8) image; - VkBuffer WINE_VK_ALIGN(8) buffer; -} VkDedicatedAllocationMemoryAllocateInfoNV; + VkRenderPass WINE_VK_ALIGN(8) renderPass; + uint32_t subpass; + VkFramebuffer WINE_VK_ALIGN(8) framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; -typedef struct VkDescriptorPoolCreateInfo +typedef struct VkConformanceVersionKHR { - VkStructureType sType; - const void *pNext; - VkDescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const VkDescriptorPoolSize *pPoolSizes; -} VkDescriptorPoolCreateInfo; + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; +} VkConformanceVersionKHR; -typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT +typedef struct VkDedicatedAllocationBufferCreateInfoNV { VkStructureType sType; const void *pNext; - uint32_t bindingCount; - const VkDescriptorBindingFlagsEXT *pBindingFlags; -} VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV; -typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT +typedef struct VkDescriptorBufferInfo { - VkStructureType sType; - const void *pNext; - uint32_t descriptorSetCount; - const uint32_t *pDescriptorCounts; -} VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; + VkBuffer WINE_VK_ALIGN(8) buffer; + VkDeviceSize WINE_VK_ALIGN(8) offset; + VkDeviceSize WINE_VK_ALIGN(8) range; +} VkDescriptorBufferInfo; + +typedef struct VkDescriptorPoolSize +{ + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; typedef struct VkDescriptorUpdateTemplateEntry { @@ -2785,25 +3211,31 @@ typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT VkQueueGlobalPriorityEXT globalPriority; } VkDeviceQueueGlobalPriorityCreateInfoEXT; -typedef struct VkEventCreateInfo +typedef struct VkDrawMeshTasksIndirectCommandNV +{ + uint32_t taskCount; + uint32_t firstTask; +} VkDrawMeshTasksIndirectCommandNV; + +typedef struct VkExportFenceCreateInfo { VkStructureType sType; const void *pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; -typedef struct VkExportMemoryAllocateInfo +typedef struct VkExportSemaphoreCreateInfo { VkStructureType sType; const void *pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExportMemoryAllocateInfo; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; -typedef struct VkExtensionProperties +typedef struct VkExtent2D { - char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; -} VkExtensionProperties; + uint32_t width; + uint32_t height; +} VkExtent2D; typedef struct VkExternalFenceProperties { @@ -2836,6 +3268,15 @@ typedef struct VkFramebufferCreateInfo uint32_t layers; } VkFramebufferCreateInfo; +typedef struct VkImageFormatProperties +{ + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize WINE_VK_ALIGN(8) maxResourceSize; +} VkImageFormatProperties; + typedef struct VkImageMemoryBarrier { VkStructureType sType; @@ -2857,161 +3298,104 @@ typedef struct VkImageSwapchainCreateInfoKHR VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; } VkImageSwapchainCreateInfoKHR; -typedef struct VkInputAttachmentAspectReference +typedef struct VkLayerProperties { - uint32_t subpass; - uint32_t inputAttachmentIndex; - VkImageAspectFlags aspectMask; -} VkInputAttachmentAspectReference; + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; -typedef struct VkMemoryAllocateInfo +typedef struct VkMemoryType { - VkStructureType sType; - const void *pNext; - VkDeviceSize WINE_VK_ALIGN(8) allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocateInfo; + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; -typedef struct VkMemoryDedicatedRequirements +typedef struct VkMultisamplePropertiesEXT { VkStructureType sType; void *pNext; - VkBool32 prefersDedicatedAllocation; - VkBool32 requiresDedicatedAllocation; -} VkMemoryDedicatedRequirements; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; -typedef struct VkMemoryRequirements +typedef struct VkPhysicalDevice16BitStorageFeatures { - VkDeviceSize WINE_VK_ALIGN(8) size; - VkDeviceSize WINE_VK_ALIGN(8) alignment; - uint32_t memoryTypeBits; -} VkMemoryRequirements; + VkStructureType sType; + void *pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; -typedef struct VkMemoryType +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { - VkMemoryPropertyFlags propertyFlags; - uint32_t heapIndex; -} VkMemoryType; + VkStructureType sType; + void *pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; -typedef struct VkOffset2D +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { - int32_t x; - int32_t y; -} VkOffset2D; + VkStructureType sType; + void *pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; -typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { VkStructureType sType; void *pNext; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; -} VkPhysicalDeviceDescriptorIndexingFeaturesEXT; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; -typedef struct VkPhysicalDeviceFeatures +typedef struct VkPhysicalDeviceExternalBufferInfo { - VkBool32 robustBufferAccess; - VkBool32 fullDrawIndexUint32; - VkBool32 imageCubeArray; - VkBool32 independentBlend; - VkBool32 geometryShader; - VkBool32 tessellationShader; - VkBool32 sampleRateShading; - VkBool32 dualSrcBlend; - VkBool32 logicOp; - VkBool32 multiDrawIndirect; - VkBool32 drawIndirectFirstInstance; - VkBool32 depthClamp; - VkBool32 depthBiasClamp; - VkBool32 fillModeNonSolid; - VkBool32 depthBounds; - VkBool32 wideLines; - VkBool32 largePoints; - VkBool32 alphaToOne; - VkBool32 multiViewport; - VkBool32 samplerAnisotropy; - VkBool32 textureCompressionETC2; - VkBool32 textureCompressionASTC_LDR; - VkBool32 textureCompressionBC; - VkBool32 occlusionQueryPrecise; - VkBool32 pipelineStatisticsQuery; - VkBool32 vertexPipelineStoresAndAtomics; - VkBool32 fragmentStoresAndAtomics; - VkBool32 shaderTessellationAndGeometryPointSize; - VkBool32 shaderImageGatherExtended; - VkBool32 shaderStorageImageExtendedFormats; - VkBool32 shaderStorageImageMultisample; - VkBool32 shaderStorageImageReadWithoutFormat; - VkBool32 shaderStorageImageWriteWithoutFormat; - VkBool32 shaderUniformBufferArrayDynamicIndexing; - VkBool32 shaderSampledImageArrayDynamicIndexing; - VkBool32 shaderStorageBufferArrayDynamicIndexing; - VkBool32 shaderStorageImageArrayDynamicIndexing; - VkBool32 shaderClipDistance; - VkBool32 shaderCullDistance; - VkBool32 shaderFloat64; - VkBool32 shaderInt64; - VkBool32 shaderInt16; - VkBool32 shaderResourceResidency; - VkBool32 shaderResourceMinLod; - VkBool32 sparseBinding; - VkBool32 sparseResidencyBuffer; - VkBool32 sparseResidencyImage2D; - VkBool32 sparseResidencyImage3D; - VkBool32 sparseResidency2Samples; - VkBool32 sparseResidency4Samples; - VkBool32 sparseResidency8Samples; - VkBool32 sparseResidency16Samples; - VkBool32 sparseResidencyAliased; - VkBool32 variableMultisampleRate; - VkBool32 inheritedQueries; -} VkPhysicalDeviceFeatures; + VkStructureType sType; + const void *pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; -typedef struct VkPhysicalDeviceGroupProperties +typedef struct VkPhysicalDeviceExternalImageFormatInfo +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + +typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV { VkStructureType sType; void *pNext; - uint32_t physicalDeviceCount; - VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; - VkBool32 subsetAllocation; -} VkPhysicalDeviceGroupProperties; + VkBool32 fragmentShaderBarycentric; +} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; -typedef struct VkPhysicalDeviceImageFormatInfo2 +typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT { VkStructureType sType; - const void *pNext; - VkFormat format; - VkImageType type; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; -} VkPhysicalDeviceImageFormatInfo2; + void *pNext; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; +} VkPhysicalDeviceInlineUniformBlockFeaturesEXT; -typedef struct VkPhysicalDeviceMultiviewFeatures +typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { VkStructureType sType; void *pNext; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; -} VkPhysicalDeviceMultiviewFeatures; + VkBool32 taskShader; + VkBool32 meshShader; +} VkPhysicalDeviceMeshShaderFeaturesNV; typedef struct VkPhysicalDeviceProtectedMemoryFeatures { @@ -3020,13 +3404,19 @@ typedef struct VkPhysicalDeviceProtectedMemoryFeatures VkBool32 protectedMemory; } VkPhysicalDeviceProtectedMemoryFeatures; -typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT +typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { VkStructureType sType; void *pNext; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; -} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + VkBool32 representativeFragmentTest; +} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; typedef struct VkPhysicalDeviceShaderDrawParameterFeatures { @@ -3035,6 +3425,15 @@ typedef struct VkPhysicalDeviceShaderDrawParameterFeatures VkBool32 shaderDrawParameters; } VkPhysicalDeviceShaderDrawParameterFeatures; +typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV +{ + VkStructureType sType; + void *pNext; + VkExtent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; +} VkPhysicalDeviceShadingRateImagePropertiesNV; + typedef struct VkPhysicalDeviceSubgroupProperties { VkStructureType sType; @@ -3045,24 +3444,31 @@ typedef struct VkPhysicalDeviceSubgroupProperties VkBool32 quadOperationsInAllStages; } VkPhysicalDeviceSubgroupProperties; -typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { VkStructureType sType; void *pNext; - uint32_t maxVertexAttribDivisor; -} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; -typedef struct VkPipelineColorBlendStateCreateInfo +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { VkStructureType sType; const void *pNext; - VkPipelineColorBlendStateCreateFlags flags; - VkBool32 logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - const VkPipelineColorBlendAttachmentState *pAttachments; - float blendConstants[4]; -} VkPipelineColorBlendStateCreateInfo; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + +typedef struct VkPipelineCoverageToColorStateCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; typedef struct VkPipelineInputAssemblyStateCreateInfo { @@ -3082,6 +3488,24 @@ typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT float extraPrimitiveOverestimationSize; } VkPipelineRasterizationConservativeStateCreateInfoEXT; +typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const VkCoarseSampleOrderCustomNV *pCustomSampleOrders; +} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; + +typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkBool32 shadingRateImageEnable; + uint32_t viewportCount; + const VkShadingRatePaletteNV *pShadingRatePalettes; +} VkPipelineViewportShadingRateImageStateCreateInfoNV; + typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { VkStructureType sType; @@ -3091,30 +3515,19 @@ typedef struct VkPipelineViewportSwizzleStateCreateInfoNV const VkViewportSwizzleNV *pViewportSwizzles; } VkPipelineViewportSwizzleStateCreateInfoNV; -typedef struct VkRect2D -{ - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - -typedef struct VkRenderPassBeginInfo +typedef struct VkQueueFamilyCheckpointPropertiesNV { VkStructureType sType; - const void *pNext; - VkRenderPass WINE_VK_ALIGN(8) renderPass; - VkFramebuffer WINE_VK_ALIGN(8) framebuffer; - VkRect2D renderArea; - uint32_t clearValueCount; - const VkClearValue *pClearValues; -} VkRenderPassBeginInfo; + void *pNext; + VkPipelineStageFlags checkpointExecutionStageMask; +} VkQueueFamilyCheckpointPropertiesNV; -typedef struct VkRenderPassInputAttachmentAspectCreateInfo +typedef struct VkRectLayerKHR { - VkStructureType sType; - const void *pNext; - uint32_t aspectReferenceCount; - const VkInputAttachmentAspectReference *pAspectReferences; -} VkRenderPassInputAttachmentAspectCreateInfo; + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; typedef struct VkSampleLocationsInfoEXT { @@ -3126,115 +3539,129 @@ typedef struct VkSampleLocationsInfoEXT const VkSampleLocationEXT *pSampleLocations; } VkSampleLocationsInfoEXT; -typedef struct VkShaderModuleCreateInfo +typedef struct VkSamplerYcbcrConversionImageFormatProperties +{ + VkStructureType sType; + void *pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkSemaphoreCreateInfo { VkStructureType sType; const void *pNext; - VkShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t *pCode; -} VkShaderModuleCreateInfo; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; -typedef struct VkSparseBufferMemoryBindInfo +typedef struct VkShaderModuleValidationCacheCreateInfoEXT { - VkBuffer WINE_VK_ALIGN(8) buffer; - uint32_t bindCount; - const VkSparseMemoryBind *pBinds; -} VkSparseBufferMemoryBindInfo; + VkStructureType sType; + const void *pNext; + VkValidationCacheEXT WINE_VK_ALIGN(8) validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT; -typedef struct VkSparseImageOpaqueMemoryBindInfo +typedef struct VkSparseImageFormatProperties2 { - VkImage WINE_VK_ALIGN(8) image; - uint32_t bindCount; - const VkSparseMemoryBind *pBinds; -} VkSparseImageOpaqueMemoryBindInfo; + VkStructureType sType; + void *pNext; + VkSparseImageFormatProperties properties; +} VkSparseImageFormatProperties2; -typedef struct VkStencilOpState +typedef struct VkSparseImageMemoryRequirements2 { - VkStencilOp failOp; - VkStencilOp passOp; - VkStencilOp depthFailOp; - VkCompareOp compareOp; - uint32_t compareMask; - uint32_t writeMask; - uint32_t reference; -} VkStencilOpState; + VkStructureType sType; + void *pNext; + VkSparseImageMemoryRequirements WINE_VK_ALIGN(8) memoryRequirements; +} VkSparseImageMemoryRequirements2; -typedef struct VkSubpassSampleLocationsEXT +typedef struct VkSpecializationInfo { - uint32_t subpassIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkSubpassSampleLocationsEXT; + uint32_t mapEntryCount; + const VkSpecializationMapEntry *pMapEntries; + size_t dataSize; + const void *pData; +} VkSpecializationInfo; -typedef struct VkSurfaceCapabilitiesKHR +typedef struct VkSubpassBeginInfoKHR { - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; -} VkSurfaceCapabilitiesKHR; + VkStructureType sType; + const void *pNext; + VkSubpassContents contents; +} VkSubpassBeginInfoKHR; -typedef struct VkSwapchainCreateInfoKHR +typedef struct VkSubpassEndInfoKHR { VkStructureType sType; const void *pNext; - VkSwapchainCreateFlagsKHR flags; - VkSurfaceKHR WINE_VK_ALIGN(8) surface; - uint32_t minImageCount; - VkFormat imageFormat; - VkColorSpaceKHR imageColorSpace; - VkExtent2D imageExtent; - uint32_t imageArrayLayers; - VkImageUsageFlags imageUsage; - VkSharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t *pQueueFamilyIndices; - VkSurfaceTransformFlagBitsKHR preTransform; - VkCompositeAlphaFlagBitsKHR compositeAlpha; - VkPresentModeKHR presentMode; - VkBool32 clipped; - VkSwapchainKHR WINE_VK_ALIGN(8) oldSwapchain; -} VkSwapchainCreateInfoKHR; +} VkSubpassEndInfoKHR; -typedef struct VkVertexInputAttributeDescription +typedef struct VkSurfaceFormatKHR { - uint32_t location; - uint32_t binding; VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; -typedef struct VkViewport +typedef struct VkValidationCacheCreateInfoEXT { - float x; - float y; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; + VkStructureType sType; + const void *pNext; + VkValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void *pInitialData; +} VkValidationCacheCreateInfoEXT; -typedef struct VkAttachmentSampleLocationsEXT +typedef struct VkVertexInputBindingDivisorDescriptionEXT { - uint32_t attachmentIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkAttachmentSampleLocationsEXT; + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescriptionEXT; -typedef struct VkBindImageMemoryDeviceGroupInfo +typedef struct VkViewportWScalingNV +{ + float xcoeff; + float ycoeff; +} VkViewportWScalingNV; + +typedef struct VkWin32SurfaceCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkWin32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; +} VkWin32SurfaceCreateInfoKHR; + +typedef struct VkAllocationCallbacks +{ + void *pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkAttachmentReference +{ + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkBindBufferMemoryDeviceGroupInfo { VkStructureType sType; const void *pNext; uint32_t deviceIndexCount; const uint32_t *pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - const VkRect2D *pSplitInstanceBindRegions; -} VkBindImageMemoryDeviceGroupInfo; +} VkBindBufferMemoryDeviceGroupInfo; + +typedef struct VkBindImageMemorySwapchainInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; typedef struct VkBufferViewCreateInfo { @@ -3247,97 +3674,59 @@ typedef struct VkBufferViewCreateInfo VkDeviceSize WINE_VK_ALIGN(8) range; } VkBufferViewCreateInfo; -typedef struct VkClearRect -{ - VkRect2D rect; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkClearRect; - -typedef struct VkCommandPoolCreateInfo -{ - VkStructureType sType; - const void *pNext; - VkCommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; -} VkCommandPoolCreateInfo; - -typedef struct VkDedicatedAllocationBufferCreateInfoNV +typedef struct VkComponentMapping { - VkStructureType sType; - const void *pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationBufferCreateInfoNV; + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; -typedef struct VkDescriptorSetAllocateInfo +typedef struct VkDescriptorPoolCreateInfo { VkStructureType sType; const void *pNext; - VkDescriptorPool WINE_VK_ALIGN(8) descriptorPool; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout *pSetLayouts; -} VkDescriptorSetAllocateInfo; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize *pPoolSizes; +} VkDescriptorPoolCreateInfo; -typedef struct VkDescriptorUpdateTemplateCreateInfo +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT { VkStructureType sType; void *pNext; - VkDescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const VkDescriptorUpdateTemplateEntry *pDescriptorUpdateEntries; - VkDescriptorUpdateTemplateType templateType; - VkDescriptorSetLayout WINE_VK_ALIGN(8) descriptorSetLayout; - VkPipelineBindPoint pipelineBindPoint; - VkPipelineLayout WINE_VK_ALIGN(8) pipelineLayout; - uint32_t set; -} VkDescriptorUpdateTemplateCreateInfo; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; -typedef struct VkDeviceGroupBindSparseInfo +typedef struct VkDeviceCreateInfo { VkStructureType sType; const void *pNext; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; -} VkDeviceGroupBindSparseInfo; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo *pQueueCreateInfos; + uint32_t enabledLayerCount; + const char * const*ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char * const*ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures *pEnabledFeatures; +} VkDeviceCreateInfo; -typedef struct VkDeviceGroupRenderPassBeginInfo +typedef struct VkDeviceGroupDeviceCreateInfo { VkStructureType sType; const void *pNext; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const VkRect2D *pDeviceRenderAreas; -} VkDeviceGroupRenderPassBeginInfo; - -typedef struct VkDispatchIndirectCommand -{ - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCommand; - -typedef struct VkDrawIndexedIndirectCommand -{ - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCommand; + uint32_t physicalDeviceCount; + const VkPhysicalDevice *pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; -typedef struct VkExportMemoryAllocateInfoNV +typedef struct VkDeviceGroupSwapchainCreateInfoKHR { VkStructureType sType; const void *pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExportMemoryAllocateInfoNV; - -typedef struct VkExtent3D -{ - uint32_t width; - uint32_t height; - uint32_t depth; -} VkExtent3D; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; typedef struct VkFenceCreateInfo { @@ -3346,25 +3735,6 @@ typedef struct VkFenceCreateInfo VkFenceCreateFlags flags; } VkFenceCreateInfo; -typedef struct VkImageCreateInfo -{ - VkStructureType sType; - const void *pNext; - VkImageCreateFlags flags; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - VkSampleCountFlagBits samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t *pQueueFamilyIndices; - VkImageLayout initialLayout; -} VkImageCreateInfo; - typedef struct VkImageSubresourceLayers { VkImageAspectFlags aspectMask; @@ -3373,13 +3743,14 @@ typedef struct VkImageSubresourceLayers uint32_t layerCount; } VkImageSubresourceLayers; -typedef struct VkMemoryAllocateFlagsInfo +typedef struct VkMappedMemoryRange { VkStructureType sType; const void *pNext; - VkMemoryAllocateFlags flags; - uint32_t deviceMask; -} VkMemoryAllocateFlagsInfo; + VkDeviceMemory WINE_VK_ALIGN(8) memory; + VkDeviceSize WINE_VK_ALIGN(8) offset; + VkDeviceSize WINE_VK_ALIGN(8) size; +} VkMappedMemoryRange; typedef struct VkMemoryRequirements2 { @@ -3388,80 +3759,212 @@ typedef struct VkMemoryRequirements2 VkMemoryRequirements WINE_VK_ALIGN(8) memoryRequirements; } VkMemoryRequirements2; -typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT -{ - VkStructureType sType; - void *pNext; - uint32_t maxDiscardRectangles; -} VkPhysicalDeviceDiscardRectanglePropertiesEXT; - -typedef struct VkPhysicalDeviceExternalSemaphoreInfo +typedef struct VkOffset3D { - VkStructureType sType; - const void *pNext; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalSemaphoreInfo; + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; -typedef struct VkPhysicalDeviceIDProperties +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { VkStructureType sType; void *pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; -} VkPhysicalDeviceIDProperties; + VkBool32 computeDerivativeGroupQuads; + VkBool32 computeDerivativeGroupLinear; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; -typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR +typedef struct VkPhysicalDeviceDriverPropertiesKHR { VkStructureType sType; void *pNext; - uint32_t maxPushDescriptors; -} VkPhysicalDevicePushDescriptorPropertiesKHR; - -typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT -{ - VkStructureType sType; - const void *pNext; - VkBool32 srcPremultiplied; - VkBool32 dstPremultiplied; - VkBlendOverlapEXT blendOverlap; -} VkPipelineColorBlendAdvancedStateCreateInfoEXT; - -typedef struct VkPipelineDepthStencilStateCreateInfo -{ - VkStructureType sType; - const void *pNext; - VkPipelineDepthStencilStateCreateFlags flags; - VkBool32 depthTestEnable; - VkBool32 depthWriteEnable; - VkCompareOp depthCompareOp; - VkBool32 depthBoundsTestEnable; - VkBool32 stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; - float minDepthBounds; - float maxDepthBounds; -} VkPipelineDepthStencilStateCreateInfo; - -typedef struct VkPipelineRasterizationStateRasterizationOrderAMD -{ - VkStructureType sType; - const void *pNext; - VkRasterizationOrderAMD rasterizationOrder; -} VkPipelineRasterizationStateRasterizationOrderAMD; + uint32_t driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; + VkConformanceVersionKHR conformanceVersion; +} VkPhysicalDeviceDriverPropertiesKHR; -typedef struct VkPipelineVertexInputStateCreateInfo +typedef struct VkPhysicalDeviceLimits { - VkStructureType sType; - const void *pNext; - VkPipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const VkVertexInputBindingDescription *pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const VkVertexInputAttributeDescription *pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize WINE_VK_ALIGN(8) bufferImageGranularity; + VkDeviceSize WINE_VK_ALIGN(8) sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize WINE_VK_ALIGN(8) minTexelBufferOffsetAlignment; + VkDeviceSize WINE_VK_ALIGN(8) minUniformBufferOffsetAlignment; + VkDeviceSize WINE_VK_ALIGN(8) minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyOffsetAlignment; + VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyRowPitchAlignment; + VkDeviceSize WINE_VK_ALIGN(8) nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceMultiviewFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceProperties +{ + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits WINE_VK_ALIGN(8) limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR +{ + VkStructureType sType; + void *pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorPropertiesKHR; + +typedef struct VkPhysicalDeviceShaderAtomicInt64FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; + +typedef struct VkPhysicalDeviceVulkanMemoryModelFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; +} VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; + +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD +{ + VkStructureType sType; + const void *pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; + +typedef struct VkPipelineShaderStageCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule WINE_VK_ALIGN(8) module; + const char *pName; + const VkSpecializationInfo *pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV *pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; typedef struct VkPushConstantRange { @@ -3470,38 +3973,36 @@ typedef struct VkPushConstantRange uint32_t size; } VkPushConstantRange; -typedef struct VkRectLayerKHR +typedef struct VkRect2D { VkOffset2D offset; VkExtent2D extent; - uint32_t layer; -} VkRectLayerKHR; +} VkRect2D; -typedef struct VkRenderPassMultiviewCreateInfo +typedef struct VkSamplerReductionModeCreateInfoEXT { VkStructureType sType; const void *pNext; - uint32_t subpassCount; - const uint32_t *pViewMasks; - uint32_t dependencyCount; - const int32_t *pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t *pCorrelationMasks; -} VkRenderPassMultiviewCreateInfo; + VkSamplerReductionModeEXT reductionMode; +} VkSamplerReductionModeCreateInfoEXT; -typedef struct VkSamplerReductionModeCreateInfoEXT +typedef struct VkSamplerYcbcrConversionInfo { VkStructureType sType; const void *pNext; - VkSamplerReductionModeEXT reductionMode; -} VkSamplerReductionModeCreateInfoEXT; + VkSamplerYcbcrConversion WINE_VK_ALIGN(8) conversion; +} VkSamplerYcbcrConversionInfo; -typedef struct VkSparseImageFormatProperties +typedef struct VkShaderStatisticsInfoAMD { - VkImageAspectFlags aspectMask; - VkExtent3D imageGranularity; - VkSparseImageFormatFlags flags; -} VkSparseImageFormatProperties; + VkShaderStageFlags shaderStageMask; + VkShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; +} VkShaderStatisticsInfoAMD; typedef struct VkSparseImageMemoryBind { @@ -3513,58 +4014,88 @@ typedef struct VkSparseImageMemoryBind VkSparseMemoryBindFlags flags; } VkSparseImageMemoryBind; -typedef struct VkSparseImageMemoryRequirements -{ - VkSparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - VkDeviceSize WINE_VK_ALIGN(8) imageMipTailSize; - VkDeviceSize WINE_VK_ALIGN(8) imageMipTailOffset; - VkDeviceSize WINE_VK_ALIGN(8) imageMipTailStride; -} VkSparseImageMemoryRequirements; - -typedef struct VkSpecializationInfo +typedef struct VkSparseImageOpaqueMemoryBindInfo { - uint32_t mapEntryCount; - const VkSpecializationMapEntry *pMapEntries; - size_t dataSize; - const void *pData; -} VkSpecializationInfo; + VkImage WINE_VK_ALIGN(8) image; + uint32_t bindCount; + const VkSparseMemoryBind *pBinds; +} VkSparseImageOpaqueMemoryBindInfo; -typedef struct VkValidationCacheCreateInfoEXT +typedef struct VkSubpassDependency2KHR { VkStructureType sType; const void *pNext; - VkValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void *pInitialData; -} VkValidationCacheCreateInfoEXT; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2KHR; -typedef struct VkViewportWScalingNV +typedef struct VkSubpassSampleLocationsEXT { - float xcoeff; - float ycoeff; -} VkViewportWScalingNV; + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; -typedef struct VkAttachmentDescription +typedef struct VkSwapchainCreateInfoKHR { - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription; + VkStructureType sType; + const void *pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR WINE_VK_ALIGN(8) surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t *pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR WINE_VK_ALIGN(8) oldSwapchain; +} VkSwapchainCreateInfoKHR; -typedef struct VkBindImageMemorySwapchainInfoKHR +typedef struct VkViewport +{ + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkWriteDescriptorSet { VkStructureType sType; const void *pNext; - VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; - uint32_t imageIndex; -} VkBindImageMemorySwapchainInfoKHR; + VkDescriptorSet WINE_VK_ALIGN(8) dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo *pImageInfo; + const VkDescriptorBufferInfo *pBufferInfo; + const VkBufferView *pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkBindImageMemoryDeviceGroupInfo +{ + VkStructureType sType; + const void *pNext; + uint32_t deviceIndexCount; + const uint32_t *pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const VkRect2D *pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; typedef struct VkBufferImageCopy { @@ -3576,20 +4107,54 @@ typedef struct VkBufferImageCopy VkExtent3D imageExtent; } VkBufferImageCopy; -typedef struct VkDescriptorSetLayoutSupport +typedef struct VkClearRect +{ + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkComputePipelineCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo WINE_VK_ALIGN(8) stage; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + VkPipeline WINE_VK_ALIGN(8) basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkImage WINE_VK_ALIGN(8) image; + VkBuffer WINE_VK_ALIGN(8) buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV; + +typedef struct VkDescriptorUpdateTemplateCreateInfo { VkStructureType sType; void *pNext; - VkBool32 supported; -} VkDescriptorSetLayoutSupport; + VkDescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntry *pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout WINE_VK_ALIGN(8) descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout WINE_VK_ALIGN(8) pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfo; -typedef struct VkDeviceGroupDeviceCreateInfo +typedef struct VkDeviceGroupRenderPassBeginInfo { VkStructureType sType; const void *pNext; - uint32_t physicalDeviceCount; - const VkPhysicalDevice *pPhysicalDevices; -} VkDeviceGroupDeviceCreateInfo; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D *pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; typedef struct VkExternalMemoryProperties { @@ -3606,43 +4171,50 @@ typedef struct VkImageBlit VkOffset3D dstOffsets[2]; } VkImageBlit; -typedef struct VkImageFormatProperties -{ - VkExtent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - VkSampleCountFlags sampleCounts; - VkDeviceSize WINE_VK_ALIGN(8) maxResourceSize; -} VkImageFormatProperties; - -typedef struct VkImageResolve +typedef struct VkImageFormatProperties2 { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve; + VkStructureType sType; + void *pNext; + VkImageFormatProperties WINE_VK_ALIGN(8) imageFormatProperties; +} VkImageFormatProperties2; -typedef struct VkMemoryDedicatedAllocateInfo +typedef struct VkImageViewCreateInfo { VkStructureType sType; const void *pNext; + VkImageViewCreateFlags flags; VkImage WINE_VK_ALIGN(8) image; - VkBuffer WINE_VK_ALIGN(8) buffer; -} VkMemoryDedicatedAllocateInfo; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; -typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT +typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT { VkStructureType sType; void *pNext; - uint32_t advancedBlendMaxColorAttachments; - VkBool32 advancedBlendIndependentBlend; - VkBool32 advancedBlendNonPremultipliedSrcColor; - VkBool32 advancedBlendNonPremultipliedDstColor; - VkBool32 advancedBlendCorrelatedOverlap; - VkBool32 advancedBlendAllOperations; -} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeaturesEXT; typedef struct VkPhysicalDeviceFeatures2 { @@ -3651,47 +4223,58 @@ typedef struct VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures features; } VkPhysicalDeviceFeatures2; -typedef struct VkPipelineCoverageToColorStateCreateInfoNV +typedef struct VkPhysicalDeviceMemoryProperties +{ + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap WINE_VK_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { VkStructureType sType; - const void *pNext; - VkPipelineCoverageToColorStateCreateFlagsNV flags; - VkBool32 coverageToColorEnable; - uint32_t coverageToColorLocation; -} VkPipelineCoverageToColorStateCreateInfoNV; + void *pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; -typedef struct VkPipelineLayoutCreateInfo +typedef struct VkPhysicalDeviceVariablePointerFeatures +{ + VkStructureType sType; + void *pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { VkStructureType sType; const void *pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const VkDescriptorSetLayout *pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange *pPushConstantRanges; -} VkPipelineLayoutCreateInfo; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D *pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; -typedef struct VkPipelineShaderStageCreateInfo +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { VkStructureType sType; const void *pNext; - VkPipelineShaderStageCreateFlags flags; - VkShaderStageFlagBits stage; - VkShaderModule WINE_VK_ALIGN(8) module; - const char *pName; - const VkSpecializationInfo *pSpecializationInfo; -} VkPipelineShaderStageCreateInfo; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; -typedef struct VkPipelineViewportStateCreateInfo +typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { VkStructureType sType; const void *pNext; - VkPipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const VkViewport *pViewports; - uint32_t scissorCount; - const VkRect2D *pScissors; -} VkPipelineViewportStateCreateInfo; + uint32_t exclusiveScissorCount; + const VkRect2D *pExclusiveScissors; +} VkPipelineViewportExclusiveScissorStateCreateInfoNV; typedef struct VkPresentRegionKHR { @@ -3699,61 +4282,79 @@ typedef struct VkPresentRegionKHR const VkRectLayerKHR *pRectangles; } VkPresentRegionKHR; -typedef struct VkQueueFamilyProperties +typedef struct VkQueueFamilyProperties2 { - VkQueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - VkExtent3D minImageTransferGranularity; -} VkQueueFamilyProperties; + VkStructureType sType; + void *pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2; -typedef struct VkRenderPassSampleLocationsBeginInfoEXT +typedef struct VkRenderPassCreateInfo2KHR { VkStructureType sType; const void *pNext; - uint32_t attachmentInitialSampleLocationsCount; - const VkAttachmentSampleLocationsEXT *pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const VkSubpassSampleLocationsEXT *pPostSubpassSampleLocations; -} VkRenderPassSampleLocationsBeginInfoEXT; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription2KHR *pAttachments; + uint32_t subpassCount; + const VkSubpassDescription2KHR *pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency2KHR *pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t *pCorrelatedViewMasks; +} VkRenderPassCreateInfo2KHR; -typedef struct VkShaderResourceUsageAMD +typedef struct VkSamplerYcbcrConversionCreateInfo { - uint32_t numUsedVgprs; - uint32_t numUsedSgprs; - uint32_t ldsSizePerLocalWorkGroup; - size_t ldsUsageSizeInBytes; - size_t scratchMemUsageInBytes; -} VkShaderResourceUsageAMD; + VkStructureType sType; + const void *pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; -typedef struct VkSparseImageFormatProperties2 +typedef struct VkSparseBufferMemoryBindInfo { - VkStructureType sType; - void *pNext; - VkSparseImageFormatProperties properties; -} VkSparseImageFormatProperties2; + VkBuffer WINE_VK_ALIGN(8) buffer; + uint32_t bindCount; + const VkSparseMemoryBind *pBinds; +} VkSparseBufferMemoryBindInfo; -typedef struct VkSparseImageMemoryRequirements2 +typedef struct VkStencilOpState { - VkStructureType sType; - void *pNext; - VkSparseImageMemoryRequirements WINE_VK_ALIGN(8) memoryRequirements; -} VkSparseImageMemoryRequirements2; + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; -typedef struct VkSurfaceFormatKHR +typedef struct VkSurfaceCapabilitiesKHR { - VkFormat format; - VkColorSpaceKHR colorSpace; -} VkSurfaceFormatKHR; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; -typedef struct VkWin32SurfaceCreateInfoKHR +typedef struct VkAttachmentSampleLocationsEXT { - VkStructureType sType; - const void *pNext; - VkWin32SurfaceCreateFlagsKHR flags; - HINSTANCE hinstance; - HWND hwnd; -} VkWin32SurfaceCreateInfoKHR; + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; typedef struct VkClearAttachment { @@ -3762,223 +4363,123 @@ typedef struct VkClearAttachment VkClearValue clearValue; } VkClearAttachment; -typedef struct VkDescriptorImageInfo -{ - VkSampler WINE_VK_ALIGN(8) sampler; - VkImageView WINE_VK_ALIGN(8) imageView; - VkImageLayout imageLayout; -} VkDescriptorImageInfo; - -typedef struct VkDeviceGroupSwapchainCreateInfoKHR +typedef struct VkDeviceGroupBindSparseInfo { VkStructureType sType; const void *pNext; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupSwapchainCreateInfoKHR; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfo; -typedef struct VkExternalImageFormatProperties +typedef struct VkDrawIndexedIndirectCommand +{ + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkExternalBufferProperties { VkStructureType sType; void *pNext; VkExternalMemoryProperties externalMemoryProperties; -} VkExternalImageFormatProperties; +} VkExternalBufferProperties; -typedef struct VkGraphicsPipelineCreateInfo +typedef struct VkFormatProperties2 { VkStructureType sType; - const void *pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo *pStages; - const VkPipelineVertexInputStateCreateInfo *pVertexInputState; - const VkPipelineInputAssemblyStateCreateInfo *pInputAssemblyState; - const VkPipelineTessellationStateCreateInfo *pTessellationState; - const VkPipelineViewportStateCreateInfo *pViewportState; - const VkPipelineRasterizationStateCreateInfo *pRasterizationState; - const VkPipelineMultisampleStateCreateInfo *pMultisampleState; - const VkPipelineDepthStencilStateCreateInfo *pDepthStencilState; - const VkPipelineColorBlendStateCreateInfo *pColorBlendState; - const VkPipelineDynamicStateCreateInfo *pDynamicState; - VkPipelineLayout WINE_VK_ALIGN(8) layout; - VkRenderPass WINE_VK_ALIGN(8) renderPass; - uint32_t subpass; - VkPipeline WINE_VK_ALIGN(8) basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo; + void *pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; -typedef struct VkImageFormatProperties2 +typedef struct VkImageCopy { - VkStructureType sType; - void *pNext; - VkImageFormatProperties WINE_VK_ALIGN(8) imageFormatProperties; -} VkImageFormatProperties2; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; -typedef struct VkInstanceCreateInfo +typedef struct VkPhysicalDeviceExternalFenceInfo { VkStructureType sType; const void *pNext; - VkInstanceCreateFlags flags; - const VkApplicationInfo *pApplicationInfo; - uint32_t enabledLayerCount; - const char * const*ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char * const*ppEnabledExtensionNames; -} VkInstanceCreateInfo; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; -typedef struct VkPhysicalDeviceLimits +typedef struct VkPhysicalDeviceMemoryProperties2 { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - VkDeviceSize WINE_VK_ALIGN(8) bufferImageGranularity; - VkDeviceSize WINE_VK_ALIGN(8) sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - size_t minMemoryMapAlignment; - VkDeviceSize WINE_VK_ALIGN(8) minTexelBufferOffsetAlignment; - VkDeviceSize WINE_VK_ALIGN(8) minUniformBufferOffsetAlignment; - VkDeviceSize WINE_VK_ALIGN(8) minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - VkSampleCountFlags framebufferColorSampleCounts; - VkSampleCountFlags framebufferDepthSampleCounts; - VkSampleCountFlags framebufferStencilSampleCounts; - VkSampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - VkSampleCountFlags sampledImageColorSampleCounts; - VkSampleCountFlags sampledImageIntegerSampleCounts; - VkSampleCountFlags sampledImageDepthSampleCounts; - VkSampleCountFlags sampledImageStencilSampleCounts; - VkSampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - VkBool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - VkBool32 strictLines; - VkBool32 standardSampleLocations; - VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyOffsetAlignment; - VkDeviceSize WINE_VK_ALIGN(8) optimalBufferCopyRowPitchAlignment; - VkDeviceSize WINE_VK_ALIGN(8) nonCoherentAtomSize; -} VkPhysicalDeviceLimits; + VkStructureType sType; + void *pNext; + VkPhysicalDeviceMemoryProperties WINE_VK_ALIGN(8) memoryProperties; +} VkPhysicalDeviceMemoryProperties2; -typedef struct VkPhysicalDeviceProperties +typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - VkPhysicalDeviceLimits WINE_VK_ALIGN(8) limits; - VkPhysicalDeviceSparseProperties sparseProperties; -} VkPhysicalDeviceProperties; + VkStructureType sType; + void *pNext; + VkBool32 shadingRateImage; + VkBool32 shadingRateCoarseSampleOrder; +} VkPhysicalDeviceShadingRateImageFeaturesNV; + +typedef struct VkPipelineDepthStencilStateCreateInfo +{ + VkStructureType sType; + const void *pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; -typedef struct VkPhysicalDeviceVariablePointerFeatures +typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { VkStructureType sType; - void *pNext; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; -} VkPhysicalDeviceVariablePointerFeatures; + const void *pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionEXT *pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoEXT; -typedef struct VkPipelineSampleLocationsStateCreateInfoEXT +typedef struct VkPipelineViewportStateCreateInfo { VkStructureType sType; const void *pNext; - VkBool32 sampleLocationsEnable; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkPipelineSampleLocationsStateCreateInfoEXT; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport *pViewports; + uint32_t scissorCount; + const VkRect2D *pScissors; +} VkPipelineViewportStateCreateInfo; -typedef struct VkPipelineViewportWScalingStateCreateInfoNV +typedef struct VkRenderPassBeginInfo { VkStructureType sType; const void *pNext; - VkBool32 viewportWScalingEnable; - uint32_t viewportCount; - const VkViewportWScalingNV *pViewportWScalings; -} VkPipelineViewportWScalingStateCreateInfoNV; + VkRenderPass WINE_VK_ALIGN(8) renderPass; + VkFramebuffer WINE_VK_ALIGN(8) framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue *pClearValues; +} VkRenderPassBeginInfo; -typedef struct VkQueueFamilyProperties2 +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { VkStructureType sType; - void *pNext; - VkQueueFamilyProperties queueFamilyProperties; -} VkQueueFamilyProperties2; + const void *pNext; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT *pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT *pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; typedef struct VkSparseImageMemoryBindInfo { @@ -3987,11 +4488,13 @@ typedef struct VkSparseImageMemoryBindInfo const VkSparseImageMemoryBind *pBinds; } VkSparseImageMemoryBindInfo; -typedef struct VkVertexInputBindingDivisorDescriptionEXT +typedef struct VkVertexInputAttributeDescription { + uint32_t location; uint32_t binding; - uint32_t divisor; -} VkVertexInputBindingDivisorDescriptionEXT; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; typedef struct VkBindSparseInfo { @@ -4009,49 +4512,46 @@ typedef struct VkBindSparseInfo const VkSemaphore *pSignalSemaphores; } VkBindSparseInfo; -typedef struct VkDeviceCreateInfo +typedef struct VkDescriptorSetLayoutBinding { - VkStructureType sType; - const void *pNext; - VkDeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const VkDeviceQueueCreateInfo *pQueueCreateInfos; - uint32_t enabledLayerCount; - const char * const*ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char * const*ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures *pEnabledFeatures; -} VkDeviceCreateInfo; + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler *pImmutableSamplers; +} VkDescriptorSetLayoutBinding; -typedef struct VkExternalBufferProperties +typedef struct VkDispatchIndirectCommand +{ + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkExternalImageFormatProperties { VkStructureType sType; void *pNext; VkExternalMemoryProperties externalMemoryProperties; -} VkExternalBufferProperties; +} VkExternalImageFormatProperties; -typedef struct VkImageCopy +typedef struct VkImageResolve { VkImageSubresourceLayers srcSubresource; VkOffset3D srcOffset; VkImageSubresourceLayers dstSubresource; VkOffset3D dstOffset; VkExtent3D extent; -} VkImageCopy; - -typedef struct VkMemoryHeap -{ - VkDeviceSize WINE_VK_ALIGN(8) size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; +} VkImageResolve; -typedef struct VkPhysicalDeviceMemoryProperties +typedef struct VkPhysicalDevice8BitStorageFeaturesKHR { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap WINE_VK_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; + VkStructureType sType; + void *pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeaturesKHR; typedef struct VkPhysicalDeviceProperties2 { @@ -4060,84 +4560,86 @@ typedef struct VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties WINE_VK_ALIGN(8) properties; } VkPhysicalDeviceProperties2; -typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT +typedef struct VkPipelineLayoutCreateInfo { VkStructureType sType; const void *pNext; - uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescriptionEXT *pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfoEXT; - -typedef struct VkShaderStatisticsInfoAMD -{ - VkShaderStageFlags shaderStageMask; - VkShaderResourceUsageAMD resourceUsage; - uint32_t numPhysicalVgprs; - uint32_t numPhysicalSgprs; - uint32_t numAvailableVgprs; - uint32_t numAvailableSgprs; - uint32_t computeWorkGroupSize[3]; -} VkShaderStatisticsInfoAMD; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout *pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange *pPushConstantRanges; +} VkPipelineLayoutCreateInfo; -typedef struct VkWriteDescriptorSet +typedef struct VkPresentRegionsKHR { VkStructureType sType; const void *pNext; - VkDescriptorSet WINE_VK_ALIGN(8) dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - const VkDescriptorImageInfo *pImageInfo; - const VkDescriptorBufferInfo *pBufferInfo; - const VkBufferView *pTexelBufferView; -} VkWriteDescriptorSet; + uint32_t swapchainCount; + const VkPresentRegionKHR *pRegions; +} VkPresentRegionsKHR; -typedef struct VkComputePipelineCreateInfo +typedef struct VkCommandBufferBeginInfo { VkStructureType sType; const void *pNext; - VkPipelineCreateFlags flags; - VkPipelineShaderStageCreateInfo WINE_VK_ALIGN(8) stage; - VkPipelineLayout WINE_VK_ALIGN(8) layout; - VkPipeline WINE_VK_ALIGN(8) basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo *pInheritanceInfo; +} VkCommandBufferBeginInfo; -typedef struct VkFormatProperties2 +typedef struct VkMemoryBarrier { VkStructureType sType; - void *pNext; - VkFormatProperties formatProperties; -} VkFormatProperties2; + const void *pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; -typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT +typedef struct VkPipelineColorBlendStateCreateInfo { VkStructureType sType; const void *pNext; - VkPipelineDiscardRectangleStateCreateFlagsEXT flags; - VkDiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const VkRect2D *pDiscardRectangles; -} VkPipelineDiscardRectangleStateCreateInfoEXT; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState *pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; -typedef struct VkSubpassDependency +typedef struct VkSubpassDescription { - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; -} VkSubpassDependency; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference *pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference *pColorAttachments; + const VkAttachmentReference *pResolveAttachments; + const VkAttachmentReference *pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t *pPreserveAttachments; +} VkSubpassDescription; -typedef struct VkPhysicalDeviceMemoryProperties2 +typedef struct VkDescriptorSetLayoutCreateInfo { VkStructureType sType; - void *pNext; - VkPhysicalDeviceMemoryProperties WINE_VK_ALIGN(8) memoryProperties; -} VkPhysicalDeviceMemoryProperties2; + const void *pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding *pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkPhysicalDeviceImageFormatInfo2 +{ + VkStructureType sType; + const void *pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2; typedef struct VkRenderPassCreateInfo { @@ -4152,20 +4654,39 @@ typedef struct VkRenderPassCreateInfo const VkSubpassDependency *pDependencies; } VkRenderPassCreateInfo; -typedef struct VkImageViewUsageCreateInfo +typedef struct VkPipelineVertexInputStateCreateInfo { VkStructureType sType; const void *pNext; - VkImageUsageFlags usage; -} VkImageViewUsageCreateInfo; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription *pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription *pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; -typedef struct VkPresentRegionsKHR +typedef struct VkGraphicsPipelineCreateInfo { VkStructureType sType; const void *pNext; - uint32_t swapchainCount; - const VkPresentRegionKHR *pRegions; -} VkPresentRegionsKHR; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo *pStages; + const VkPipelineVertexInputStateCreateInfo *pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo *pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo *pTessellationState; + const VkPipelineViewportStateCreateInfo *pViewportState; + const VkPipelineRasterizationStateCreateInfo *pRasterizationState; + const VkPipelineMultisampleStateCreateInfo *pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo *pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo *pColorBlendState; + const VkPipelineDynamicStateCreateInfo *pDynamicState; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + VkRenderPass WINE_VK_ALIGN(8) renderPass; + uint32_t subpass; + VkPipeline WINE_VK_ALIGN(8) basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice, const VkAcquireNextImageInfoKHR *, uint32_t *); typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, uint32_t *); @@ -4179,11 +4700,14 @@ typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice, uint32_t, con typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice, VkImage, VkDeviceMemory, VkDeviceSize); typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); +typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer, const VkConditionalRenderingBeginInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer, VkQueryPool, uint32_t, VkQueryControlFlags); typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer, const VkRenderPassBeginInfo *, VkSubpassContents); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer, const VkRenderPassBeginInfo *, const VkSubpassBeginInfoKHR *); typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkDescriptorSet *, uint32_t, const uint32_t *); typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkIndexType); typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer, VkPipelineBindPoint, VkPipeline); +typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer, VkImageView, VkImageLayout); typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *); typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, uint32_t, const VkImageBlit *, VkFilter); typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer, uint32_t, const VkClearAttachment *, uint32_t, const VkClearRect *); @@ -4206,11 +4730,17 @@ typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer, typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkBuffer, VkDeviceSize, uint32_t, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkBuffer, VkDeviceSize, uint32_t, uint32_t); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkBuffer, VkDeviceSize, uint32_t, uint32_t); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, uint32_t); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer, uint32_t, uint32_t); +typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer); typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer, VkQueryPool, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer, const VkSubpassEndInfoKHR *); typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer, uint32_t, const VkCommandBuffer *); typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer, VkSubpassContents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer, const VkSubpassBeginInfoKHR *, const VkSubpassEndInfoKHR *); typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, const VkBufferMemoryBarrier *, uint32_t, const VkImageMemoryBarrier *); typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, uint32_t, uint32_t, const void *); typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkWriteDescriptorSet *); @@ -4219,12 +4749,15 @@ typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer, VkEvent, VkPipeli typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer, VkQueryPool, uint32_t, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, uint32_t, const VkImageResolve *); typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer, const float[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer, const void *); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer, VkCoarseSampleOrderTypeNV, uint32_t, const VkCoarseSampleOrderCustomNV *); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer, float, float, float); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer, float, float); typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *); typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer, VkEvent, VkPipelineStageFlags); +typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *); typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer, float); typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer, const VkSampleLocationsInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer, uint32_t, uint32_t, const VkRect2D *); @@ -4232,6 +4765,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer, VkSten typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer, VkStencilFaceFlags, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer, VkStencilFaceFlags, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer, uint32_t, uint32_t, const VkViewport *); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer, uint32_t, uint32_t, const VkShadingRatePaletteNV *); typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer, uint32_t, uint32_t, const VkViewportWScalingNV *); typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, const void *); typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer, uint32_t, const VkEvent *, VkPipelineStageFlags, VkPipelineStageFlags, uint32_t, const VkMemoryBarrier *, uint32_t, const VkBufferMemoryBarrier *, uint32_t, const VkImageMemoryBarrier *); @@ -4257,6 +4791,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice, const VkPipeli typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice, const VkPipelineLayoutCreateInfo *, const VkAllocationCallbacks *, VkPipelineLayout *); typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice, const VkQueryPoolCreateInfo *, const VkAllocationCallbacks *, VkQueryPool *); typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice, const VkRenderPassCreateInfo *, const VkAllocationCallbacks *, VkRenderPass *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice, const VkRenderPassCreateInfo2KHR *, const VkAllocationCallbacks *, VkRenderPass *); typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice, const VkSamplerCreateInfo *, const VkAllocationCallbacks *, VkSampler *); typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice, const VkSamplerYcbcrConversionCreateInfo *, const VkAllocationCallbacks *, VkSamplerYcbcrConversion *); typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice, const VkSamplerYcbcrConversionCreateInfo *, const VkAllocationCallbacks *, VkSamplerYcbcrConversion *); @@ -4359,6 +4894,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysica typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice, uint32_t); typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice, VkPipelineCache, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice, VkQueryPool, uint32_t, uint32_t, size_t, void *, VkDeviceSize, VkQueryResultFlags); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue, uint32_t *, VkCheckpointDataNV *); typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice, VkRenderPass, VkExtent2D *); typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice, VkPipeline, VkShaderStageFlagBits, VkShaderInfoTypeAMD, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice, VkSwapchainKHR, uint32_t *, VkImage *); @@ -4398,11 +4934,14 @@ VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCou VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos); VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos); +void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin); void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents); +void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfoKHR *pSubpassBeginInfo); void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets); void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets); void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter); void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects); @@ -4425,11 +4964,17 @@ void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer); void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer); +void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo); void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers); void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents); +void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const VkSubpassEndInfoKHR *pSubpassEndInfo); void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers); void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues); void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites); @@ -4438,12 +4983,15 @@ void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, Vk void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions); void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]); +void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker); +void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders); void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask); void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles); void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors); void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth); void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo); void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors); @@ -4451,6 +4999,7 @@ void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkSten void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports); +void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes); void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings); void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData); void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers); @@ -4476,6 +5025,7 @@ VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCache VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout); VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool); VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass); +VkResult VKAPI_CALL vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass); VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler); VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion); VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion); @@ -4578,6 +5128,7 @@ VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physic VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData); VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags); +void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData); void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity); VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo); VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages); -- 2.16.4

1 0

[PATCH 3/4] winevulkan: Parse enum value aliases.
by Józef Kucia 05 Oct '18

05 Oct '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index ce14c78e7685..cb55a303ef18 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -322,22 +322,26 @@ class VkEnum(object): for v in enum.findall("enum"): # Value is either a value or a bitpos, only one can exist. value = v.attrib.get("value") - if value is None: - # bitmask - value = 1 << int(v.attrib.get("bitpos")) - values.append(VkEnumValue(v.attrib.get("name"), value, hex=True)) - else: + alias_name = v.attrib.get("alias") + if alias_name: + alias = next(x for x in values if x.name == alias_name) + values.append(VkEnumValue(v.attrib.get("name"), alias.value, alias.hex)) + elif value: # Some values are in hex form. We want to preserve the hex representation # at least when we convert back to a string. Internally we want to use int. if "0x" in value: values.append(VkEnumValue(v.attrib.get("name"), int(value, 0), hex=True)) else: values.append(VkEnumValue(v.attrib.get("name"), int(value, 0))) + else: + # bitmask + value = 1 << int(v.attrib.get("bitpos")) + values.append(VkEnumValue(v.attrib.get("name"), value, hex=True)) # vulkan.h contains a *_MAX_ENUM value set to 32-bit at the time of writing, # which is to prepare for extensions as they can add values and hence affect # the size definition. - max_name = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2',name).upper() + "_MAX_ENUM" + max_name = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2', name).upper() + "_MAX_ENUM" values.append(VkEnumValue(max_name, 0x7fffffff, hex=True)) return VkEnum(name, values) -- 2.16.4

1 0

[PATCH 2/4] winevulkan: Check if conversion is required for pNext chains.
by Józef Kucia 05 Oct '18

05 Oct '18

Unhandled conversions are only logged for now. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 41 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 37 insertions(+), 4 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index ae90905245ec..ce14c78e7685 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -1028,9 +1028,12 @@ class VkMember(object): # Collect any conversion for any member structs. struct = self.type_info["data"] for m in struct: + m.needs_struct_extensions_conversion() if m.needs_conversion(): conversions.extend(m.get_conversions()) + struct.needs_struct_extensions_conversion() + struct = self.type_info["data"] direction = Direction.OUTPUT if struct.returnedonly else Direction.INPUT if self.is_dynamic_array(): @@ -1119,6 +1122,13 @@ class VkMember(object): # though none of this type have been encountered yet. return False + def needs_struct_extensions_conversion(self): + if not self.is_struct(): + return False + + struct = self.type_info["data"] + return struct.needs_struct_extensions_conversion() + def set_type_info(self, type_info): """ Helper function to set type information from the type registry. This is needed, because not all type data is available at time of @@ -1356,6 +1366,10 @@ class VkParam(object): if not self.is_struct(): return None + self.struct.needs_struct_extensions_conversion() + for m in self.struct: + m.needs_struct_extensions_conversion() + if not self.needs_conversion(): return None @@ -1485,14 +1499,16 @@ class VkParam(object): class VkStruct(Sequence): """ Class which represents the type union and struct. """ - def __init__(self, name, members, returnedonly, alias=None, union=False): + def __init__(self, name, members, returnedonly, structextends, alias=None, union=False): self.name = name self.members = members self.returnedonly = returnedonly + self.structextends = structextends self.required = False self.alias = alias self.union = union self.type_info = None # To be set later. + self.struct_extensions = [] def __getitem__(self, i): return self.members[i] @@ -1503,7 +1519,7 @@ class VkStruct(Sequence): @staticmethod def from_alias(struct, alias): name = struct.attrib.get("name") - return VkStruct(name, alias.members, alias.returnedonly, alias=alias) + return VkStruct(name, alias.members, alias.returnedonly, alias.structextends, alias=alias) @staticmethod def from_xml(struct): @@ -1511,18 +1527,21 @@ class VkStruct(Sequence): # know which one we are dealing with later on for code generation. union = True if struct.attrib["category"] == "union" else False - name = struct.attrib.get("name", None) + name = struct.attrib.get("name") # 'Output' structures for which data is filled in by the API are # marked as 'returnedonly'. returnedonly = True if struct.attrib.get("returnedonly") else False + structextends = struct.attrib.get("structextends") + structextends = structextends.split(",") if structextends else [] + members = [] for member in struct.findall("member"): vk_member = VkMember.from_xml(member) members.append(vk_member) - return VkStruct(name, members, returnedonly, union=union) + return VkStruct(name, members, returnedonly, structextends, union=union) @staticmethod def decouple_structs(structs): @@ -1648,6 +1667,16 @@ class VkStruct(Sequence): return False + def needs_struct_extensions_conversion(self): + """ Checks if structure extensions in pNext chain need conversion. """ + + for e in self.struct_extensions: + if e.required and e.needs_conversion(): + LOGGER.error("Unhandled pNext chain conversion for {0}".format(e.name)) + return True + + return False + def set_type_info(self, types): """ Helper function to set type information from the type registry. This is needed, because not all type data is available at time of @@ -2756,6 +2785,10 @@ class VkRegistry(object): for struct in structs: struct.set_type_info(self.types) + for structextend in struct.structextends: + s = self.types[structextend]["data"] + s.struct_extensions.append(struct) + # Guarantee everything is sorted, so code generation doesn't have # to deal with this. self.base_types = sorted(base_types, key=lambda base_type: base_type.name) -- 2.16.4

1 0

[PATCH 1/4] winevulkan: Remove parsing of validextensionstructs.
by Józef Kucia 05 Oct '18

05 Oct '18

It was replaced by structextends. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 8e7d88ad7dec..ae90905245ec 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -869,7 +869,7 @@ class VkHandle(object): class VkMember(object): def __init__(self, const=False, struct_fwd_decl=False,_type=None, pointer=None, name=None, array_len=None, - dyn_array_len=None, optional=False, extension_structs=None): + dyn_array_len=None, optional=False): self.const = const self.struct_fwd_decl = struct_fwd_decl self.name = name @@ -879,7 +879,6 @@ class VkMember(object): self.array_len = array_len self.dyn_array_len = dyn_array_len self.optional = optional - self.extension_structs = extension_structs def __eq__(self, other): """ Compare member based on name against a string. @@ -927,12 +926,7 @@ class VkMember(object): # Name of other member within, which stores the number of # elements pointed to be by this member. - dyn_array_len = member.get("len", None) - - if "validextensionstructs" in member.attrib: - extension_structs = member.get("validextensionstructs").split(",") - else: - extension_structs = None + dyn_array_len = member.get("len") # Some members are optional, which is important for conversion code e.g. not dereference NULL pointer. optional = True if member.get("optional") else False @@ -956,7 +950,7 @@ class VkMember(object): array_len = name_elem.tail.strip("[]") return VkMember(const=const, struct_fwd_decl=struct_fwd_decl, _type=member_type, pointer=pointer, name=name_elem.text, - array_len=array_len, dyn_array_len=dyn_array_len, optional=optional, extension_structs=extension_structs) + array_len=array_len, dyn_array_len=dyn_array_len, optional=optional) def copy(self, input, output, direction): """ Helper method for use by conversion logic to generate a C-code statement to copy this member. """ -- 2.16.4

1 0

[PATCH] gdiplus: Fix input string tracing in GdipMeasureCharacterRanges().
by Nikolay Sivov 05 Oct '18

05 Oct '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/gdiplus/graphics.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/gdiplus/graphics.c b/dlls/gdiplus/graphics.c index 2d23085e8a..3216a3ea43 100644 --- a/dlls/gdiplus/graphics.c +++ b/dlls/gdiplus/graphics.c @@ -5298,7 +5298,7 @@ GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics, RectF scaled_rect; REAL margin_x; - TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_w(string), + TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_wn(string, length), length, font, debugstr_rectf(layoutRect), stringFormat, regionCount, regions); if (!(graphics && string && font && layoutRect && stringFormat && regions)) -- 2.19.0

2 1

[PATCH] services/tests: Change pipe type from byte to message.
by Bernhard Übelacker 05 Oct '18

05 Oct '18

Signed-off-by: Bernhard Übelacker <bernhardu(a)mailbox.org> --- The line length or amount of messages introduced in the last patches may cause partial reads in the test process that show therefore the error: Test failed: malformed service message: 1 Changing the type from BYTE to MESSAGE should make ReadFile receive only complete messages. --- programs/services/tests/service.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/programs/services/tests/service.c b/programs/services/tests/service.c index c68d37acdd..aaae6801f6 100644 --- a/programs/services/tests/service.c +++ b/programs/services/tests/service.c @@ -589,7 +589,7 @@ static void test_runner(void (*p_run_test)(void)) sprintf(named_pipe_name, "\\\\.\\pipe\\%s_pipe", service_name); pipe_handle = CreateNamedPipeA(named_pipe_name, PIPE_ACCESS_INBOUND, - PIPE_TYPE_BYTE|PIPE_READMODE_BYTE|PIPE_WAIT, 10, 2048, 2048, 10000, NULL); + PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE|PIPE_WAIT, 10, 2048, 2048, 10000, NULL); ok(pipe_handle != INVALID_HANDLE_VALUE, "CreateNamedPipe failed: %u\n", GetLastError()); if(pipe_handle == INVALID_HANDLE_VALUE) return; -- 2.19.0

2 1

[PATCH 3/3] winhttp: Make accessing session credential handle thread safe.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/request.c | 24 ++++++++++++++++-------- dlls/winhttp/session.c | 2 ++ 2 files changed, 18 insertions(+), 8 deletions(-)

2 1

[PATCH 2/3 v2] winhttp: Make cookie access thread safe.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/cookie.c | 32 ++++++++++++++++++++++---------- dlls/winhttp/session.c | 4 ++++ dlls/winhttp/winhttp_private.h | 1 + 3 files changed, 27 insertions(+), 10 deletions(-)

2 1

[PATCH 1/3] winhttp: Move cookie_t declaration to cookie.c.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/cookie.c | 8 ++++++++ dlls/winhttp/winhttp_private.h | 8 -------- 2 files changed, 8 insertions(+), 8 deletions(-)

2 1

[PATCH] include: Add check macros needed for VS2017.
by Stefan Dösinger 05 Oct '18

05 Oct '18

Signed-off-by: Stefan Dösinger <stefan(a)codeweavers.com> --- These are necessary to use Visual Studio 2017 / Windows SDK 10.0.17134.0 CRT headers on top of Wine's Win32 headers. I am not sure if this patch is exhaustive for all possible headers in this SDK version, but it is enough to compile wined3d, the d3d client libs and tests. --- include/sal.h | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/include/sal.h b/include/sal.h index 6eb0a6c02d..c8b4491fbc 100644 --- a/include/sal.h +++ b/include/sal.h @@ -19,6 +19,11 @@ #ifndef __WINE_SAL_H__ #define __WINE_SAL_H__ + +#define _Always_(exp) + +#define _At_buffer_(a, b, c, d) + #define _Check_return_ #define _Deref_out_ @@ -26,6 +31,11 @@ #define _Deref_out_opt_z_ #define _Deref_post_opt_cap_(count) #define _Deref_post_opt_valid_ +#define _Deref_post_valid_ +#define _Deref_post_z_ +#define _Deref_prepost_opt_z_ + +#define _Field_range_(min, max) #define _In_ #define _In_bytecount_(count) @@ -33,15 +43,23 @@ #define _In_opt_ #define _In_opt_count_(count) #define _In_opt_z_ +#define _In_range_(min, max) #define _In_reads_(count) #define _In_reads_bytes_(count) +#define _In_reads_bytes_opt_(count) #define _In_reads_opt_z_(count) +#define _In_reads_or_z_(count) +#define _In_reads_or_z_opt_(count) #define _In_reads_z_(count) #define _In_z_ #define _Inout_ #define _Inout_cap_(count) #define _Inout_opt_ +#define _Inout_opt_z_ +#define _Inout_updates_(count) +#define _Inout_updates_bytes_(count) +#define _Inout_updates_opt_(count) #define _Inout_updates_z_(count) #define _Inout_z_ #define _Inout_z_bytecap_(count) @@ -60,35 +78,61 @@ #define _Out_opt_z_cap_(count) #define _Out_opt_z_cap_post_count_(count1, count2) #define _Out_writes_(count) +#define _Out_writes_bytes_(count) +#define _Out_writes_bytes_all_(count) +#define _Out_writes_bytes_all_opt_(count) +#define _Out_writes_bytes_opt_(count) #define _Out_writes_bytes_to_(count1, count2) +#define _Out_writes_bytes_to_opt_(count1, count2) #define _Out_writes_opt_(count) #define _Out_writes_opt_z_(count) #define _Out_writes_to_(count1, count2) +#define _Out_writes_to_opt_(count1, count2) #define _Out_writes_z_(count) #define _Out_z_cap_(count) #define _Out_z_cap_c_(count) #define _Out_z_cap_post_count_(count1, count2) #define _Outptr_result_buffer_(count) +#define _Outptr_result_buffer_maybenull_(count) +#define _Outptr_result_maybenull_ #define _Outptr_result_maybenull_z_ +#define _Outptr_result_z_ +#define _Param_(p) + +#define _Post_equal_to_(exp) #define _Post_invalid_ +#define _Post_maybez_ +#define _Post_readable_size_(count) +#define _Post_satisfies_(exp) #define _Post_writable_byte_size_(count) #define _Post_z_ #define _Pre_maybenull_ #define _Pre_notnull_ +#define _Pre_opt_z_ #define _Pre_writable_size_(count) +#define _Pre_z_ #define _Printf_format_string_ +#define _Printf_format_string_params_(count) #define _Ret_maybenull_ #define _Ret_maybenull_z_ +#define _Ret_notnull_ #define _Ret_opt_ #define _Ret_opt_z_cap_(count) #define _Ret_writes_bytes_maybenull_(count) #define _Ret_z_ +#define _Scanf_format_string_ +#define _Scanf_format_string_params_(count) +#define _Scanf_s_format_string_ +#define _Scanf_s_format_string_params_(count) + #define _Success_(exp) +#define _When_(exp1, exp2) + #endif -- 2.17.1 (Apple Git-112)

1 0

[PATCH 4/4] crypt32: Read OID information from the registry.
by Dmitry Timoshkov 05 Oct '18

05 Oct '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/crypt32/oid.c | 133 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 127 insertions(+), 6 deletions(-) diff --git a/dlls/crypt32/oid.c b/dlls/crypt32/oid.c index 6a6df95132..1eb82829d2 100644 --- a/dlls/crypt32/oid.c +++ b/dlls/crypt32/oid.c @@ -73,6 +73,13 @@ static const WCHAR DISALLOWED[] = {'D','i','s','a','l','l','o','w','e','d',0}; static const LPCWSTR LocalizedKeys[] = {ROOT,MY,CA,ADDRESSBOOK,TRUSTEDPUBLISHER,DISALLOWED}; static WCHAR LocalizedNames[ARRAY_SIZE(LocalizedKeys)][256]; +static const WCHAR nameW[] = { 'N','a','m','e',0 }; +static const WCHAR algidW[] = { 'A','l','g','i','d',0 }; +static const WCHAR extraW[] = { 'E','x','t','r','a','I','n','f','o',0 }; +static const WCHAR cngalgidW[] = { 'C','N','G','A','l','g','i','d',0 }; +static const WCHAR cngextraalgidW[] = { 'C','N','G','E','x','t','r','a','A','l','g','i','d',0 }; +static const WCHAR flagsW[] = { 'F','l','a','g','s',0 }; + static void free_function_sets(void) { struct OIDFunctionSet *setCursor, *setNext; @@ -700,12 +707,6 @@ BOOL WINAPI CryptUnregisterOIDInfo(PCCRYPT_OID_INFO info) */ BOOL WINAPI CryptRegisterOIDInfo(PCCRYPT_OID_INFO info, DWORD flags) { - static const WCHAR nameW[] = { 'N','a','m','e',0 }; - static const WCHAR algidW[] = { 'A','l','g','i','d',0 }; - static const WCHAR extraW[] = { 'E','x','t','r','a','I','n','f','o',0 }; - static const WCHAR cngalgidW[] = { 'C','N','G','A','l','g','i','d',0 }; - static const WCHAR cngextraalgidW[] = { 'C','N','G','E','x','t','r','a','A','l','g','i','d',0 }; - static const WCHAR flagsW[] = { 'F','l','a','g','s',0 }; char *key_name; HKEY root = 0, key = 0; DWORD err; @@ -1525,6 +1526,125 @@ struct OIDInfo { struct list entry; }; +static struct OIDInfo *read_oid_info(HKEY root, char *key_name, DWORD *flags) +{ + HKEY key; + DWORD len, oid_len, name_len = 0, extra_len = 0, cngalgid_len = 0, cngextra_len = 0, group_id = 0; + struct OIDInfo *info; + char *p; + + if (RegOpenKeyExA(root, key_name, 0, KEY_READ, &key)) + return NULL; + + p = strchr(key_name, '!'); + if (p) + { + group_id = strtol(p + 1, NULL, 10); + *p = 0; + } + + oid_len = strlen(key_name) + 1; + + RegQueryValueExW(key, nameW, NULL, NULL, NULL, &name_len); + RegQueryValueExW(key, extraW, NULL, NULL, NULL, &extra_len); + RegQueryValueExW(key, cngalgidW, NULL, NULL, NULL, &cngalgid_len); + RegQueryValueExW(key, cngextraalgidW, NULL, NULL, NULL, &cngextra_len); + + info = CryptMemAlloc(sizeof(*info) + oid_len + name_len + extra_len + cngalgid_len + cngextra_len); + if (info) + { + *flags = 0; + len = sizeof(*flags); + RegQueryValueExW(key, flagsW, NULL, NULL, (BYTE *)flags, &len); + + memset(info, 0, sizeof(*info)); + info->info.cbSize = sizeof(info->info); + + p = (char *)(info + 1); + + info->info.pszOID = p; + strcpy((char *)info->info.pszOID, key_name); + p += oid_len; + + if (name_len) + { + info->info.pwszName = (WCHAR *)p; + RegQueryValueExW(key, nameW, NULL, NULL, (BYTE *)info->info.pwszName, &name_len); + p += name_len; + } + + info->info.dwGroupId = group_id; + + len = sizeof(info->info.u.Algid); + RegQueryValueExW(key, algidW, NULL, NULL, (BYTE *)&info->info.u.Algid, &len); + + if (extra_len) + { + info->info.ExtraInfo.cbData = extra_len; + info->info.ExtraInfo.pbData = (BYTE *)p; + RegQueryValueExW(key, extraW, NULL, NULL, info->info.ExtraInfo.pbData, &extra_len); + p += extra_len; + } + + if (cngalgid_len) + { + info->info.pwszCNGAlgid = (WCHAR *)p; + RegQueryValueExW(key, cngalgidW, NULL, NULL, (BYTE *)info->info.pwszCNGAlgid, &cngalgid_len); + p += cngalgid_len; + } + + if (cngextra_len) + { + info->info.pwszCNGExtraAlgid = (WCHAR *)p; + RegQueryValueExW(key, cngextraalgidW, NULL, NULL, (BYTE *)info->info.pwszCNGExtraAlgid, &cngalgid_len); + } + } + + RegCloseKey(key); + + return info; +} + +static void init_registered_oid_info(void) +{ + DWORD err, idx; + HKEY root; + + err = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo", + 0, KEY_ALL_ACCESS, &root); + if (err != ERROR_SUCCESS) return; + + idx = 0; + for (;;) + { + char key_name[MAX_PATH]; + struct OIDInfo *info; + DWORD flags; + + err = RegEnumKeyA(root, idx++, key_name, MAX_PATH); + if (err == ERROR_NO_MORE_ITEMS) + break; + + if (err == ERROR_SUCCESS) + { + if ((info = read_oid_info(root, key_name, &flags))) + { + TRACE("adding oid %s, name %s, groupid %u, algid %u, extra %u, CNG algid %s, CNG extra %s\n", + debugstr_a(info->info.pszOID), debugstr_w(info->info.pwszName), + info->info.dwGroupId, info->info.u.Algid, info->info.ExtraInfo.cbData, + debugstr_w(info->info.pwszCNGAlgid), debugstr_w(info->info.pwszCNGExtraAlgid)); + + if (flags & CRYPT_INSTALL_OID_INFO_BEFORE_FLAG) + list_add_head(&oidInfo, &info->entry); + else + list_add_tail(&oidInfo, &info->entry); + } + } + } + + RegCloseKey(root); +} + static void init_oid_info(void) { DWORD i; @@ -1752,6 +1872,7 @@ DWORD WINAPI CertOIDToAlgId(LPCSTR pszObjId) void crypt_oid_init(void) { init_oid_info(); + init_registered_oid_info(); } void crypt_oid_free(void) -- 2.17.1

1 0

[PATCH 3/4] crypt32/tests: Add some tests for registering OID info.
by Dmitry Timoshkov 05 Oct '18

05 Oct '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/crypt32/tests/oid.c | 93 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/dlls/crypt32/tests/oid.c b/dlls/crypt32/tests/oid.c index d6a03c5d1d..5247a4aad5 100644 --- a/dlls/crypt32/tests/oid.c +++ b/dlls/crypt32/tests/oid.c @@ -2,6 +2,7 @@ * Unit test suite for crypt32.dll's OID support functions. * * Copyright 2005 Juan Lang + * Copyright 2018 Dmitry Timoshkov * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -614,6 +615,97 @@ static void test_findOIDInfo(void) win_skip("Host does not support ECDSA_SHA256, skipping test\n"); } +static void test_registerOIDInfo(void) +{ + static const WCHAR winetestW[] = { 'w','i','n','e','t','e','s','t',0 }; + static char test_oid[] = "1.2.3.4.5.6.7.8.9.10"; + CRYPT_OID_INFO info1; + const CRYPT_OID_INFO *info2; + HKEY key; + DWORD ret, size, type, value; + char buf[256]; + + SetLastError(0xdeadbeef); + ret = CryptUnregisterOIDInfo(NULL); + ok(!ret, "should fail\n"); + ok(GetLastError() == E_INVALIDARG, "got %#x\n", GetLastError()); + + memset(&info1, 0, sizeof(info1)); + SetLastError(0xdeadbeef); + ret = CryptUnregisterOIDInfo(&info1); + ok(!ret, "should fail\n"); + ok(GetLastError() == E_INVALIDARG, "got %#x\n", GetLastError()); + + info1.cbSize = sizeof(info1); + SetLastError(0xdeadbeef); + ret = CryptUnregisterOIDInfo(&info1); + ok(!ret, "should fail\n"); + ok(GetLastError() == E_INVALIDARG, "got %#x\n", GetLastError()); + + info1.pszOID = test_oid; + SetLastError(0xdeadbeef); + ret = CryptUnregisterOIDInfo(&info1); + ok(!ret, "should fail\n"); + ok(GetLastError() == ERROR_FILE_NOT_FOUND, "got %u\n", GetLastError()); + + info2 = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, (void *)test_oid, 0); + ok(!info2, "should fail\n"); + + SetLastError(0xdeadbeef); + /* while succeeds next call does't write anything to registry under Windows + * because of dwGroupId == 0. + */ + ret = CryptRegisterOIDInfo(&info1, 0); + ok(ret, "got %u\n", GetLastError()); + + ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo\\1.2.3.4.5.6.7.8.9.10!1", &key); + ok(ret == ERROR_FILE_NOT_FOUND, "got %u\n", ret); + + info2 = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, (void *)test_oid, 0); + ok(!info2, "should fail\n"); + + info1.pwszName = winetestW; + info1.dwGroupId = CRYPT_HASH_ALG_OID_GROUP_ID; + SetLastError(0xdeadbeef); + ret = CryptRegisterOIDInfo(&info1, CRYPT_INSTALL_OID_INFO_BEFORE_FLAG); + if (!ret && GetLastError() == ERROR_ACCESS_DENIED) + { + skip("Need admin rights\n"); + return; + } + ok(ret, "got %u\n", GetLastError()); + + /* It looks like crypt32 reads the OID info from registry only on load, + * and CryptFindOIDInfo will find the registered OID on next run + */ + info2 = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, (void *)test_oid, 0); + ok(!info2, "should fail\n"); + + ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo\\1.2.3.4.5.6.7.8.9.10!1", &key); + ok(!ret, "got %u\n", ret); + + memset(buf, 0, sizeof(buf)); + size = sizeof(buf); + ret = RegQueryValueExA(key, "Name", NULL, &type, (BYTE *)buf, &size); + ok(!ret, "got %u\n", ret); + ok(type == REG_SZ, "got %u\n", type); + ok(!strcmp(buf, "winetest"), "got %s\n", buf); + + value = 0xdeadbeef; + size = sizeof(value); + ret = RegQueryValueExA(key, "Flags", NULL, &type, (BYTE *)&value, &size); + ok(!ret, "got %u\n", ret); + ok(type == REG_DWORD, "got %u\n", type); + ok(value == 1, "got %u\n", value); + + RegCloseKey(key); + + CryptUnregisterOIDInfo(&info1); + + ret = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo\\1.2.3.4.5.6.7.8.9.10!1", &key); + ok(ret == ERROR_FILE_NOT_FOUND, "got %u\n", ret); +} + START_TEST(oid) { HMODULE hCrypt32 = GetModuleHandleA("crypt32.dll"); @@ -623,6 +715,7 @@ START_TEST(oid) testAlgIDToOID(); test_enumOIDInfo(); test_findOIDInfo(); + test_registerOIDInfo(); test_oidFunctionSet(); test_installOIDFunctionAddress(); test_registerOIDFunction(); -- 2.17.1

1 0

[PATCH 2/4] crypt32: Implement CryptRegisterOIDInfo.
by Dmitry Timoshkov 05 Oct '18

05 Oct '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/crypt32/oid.c | 85 +++++++++++++++++++++++++++++++++++++++++++--- include/wincrypt.h | 1 + 2 files changed, 82 insertions(+), 4 deletions(-) diff --git a/dlls/crypt32/oid.c b/dlls/crypt32/oid.c index e9ccab7494..6a6df95132 100644 --- a/dlls/crypt32/oid.c +++ b/dlls/crypt32/oid.c @@ -698,11 +698,88 @@ BOOL WINAPI CryptUnregisterOIDInfo(PCCRYPT_OID_INFO info) /*********************************************************************** * CryptRegisterOIDInfo (CRYPT32.@) */ -BOOL WINAPI CryptRegisterOIDInfo(PCCRYPT_OID_INFO pInfo, DWORD dwFlags) +BOOL WINAPI CryptRegisterOIDInfo(PCCRYPT_OID_INFO info, DWORD flags) { - FIXME("(%p, %x): stub\n", pInfo, dwFlags ); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + static const WCHAR nameW[] = { 'N','a','m','e',0 }; + static const WCHAR algidW[] = { 'A','l','g','i','d',0 }; + static const WCHAR extraW[] = { 'E','x','t','r','a','I','n','f','o',0 }; + static const WCHAR cngalgidW[] = { 'C','N','G','A','l','g','i','d',0 }; + static const WCHAR cngextraalgidW[] = { 'C','N','G','E','x','t','r','a','A','l','g','i','d',0 }; + static const WCHAR flagsW[] = { 'F','l','a','g','s',0 }; + char *key_name; + HKEY root = 0, key = 0; + DWORD err; + + TRACE("(%p, %x)\n", info, flags ); + + if (!info || info->cbSize != sizeof(*info) || !info->pszOID) + { + SetLastError(E_INVALIDARG); + return FALSE; + } + + if (!info->dwGroupId) return TRUE; + + key_name = CryptMemAlloc(strlen(info->pszOID) + 16); + if (!key_name) + { + err = ERROR_OUTOFMEMORY; + goto done; + } + + err = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo", + 0, NULL, 0, KEY_ALL_ACCESS, NULL, &root, NULL); + if (err != ERROR_SUCCESS) goto done; + + sprintf(key_name, "%s!%u", info->pszOID, info->dwGroupId); + err = RegCreateKeyA(root, key_name, &key); + if (err != ERROR_SUCCESS) goto done; + + if (flags) + { + err = RegSetValueExW(key, flagsW, 0, REG_DWORD, (const BYTE *)&flags, sizeof(flags)); + if (err != ERROR_SUCCESS) goto done; + } + + if (info->pwszName) + { + err = RegSetValueExW(key, nameW, 0, REG_SZ, (const BYTE *)info->pwszName, (lstrlenW(info->pwszName) + 1) * sizeof(WCHAR)); + if (err != ERROR_SUCCESS) goto done; + } + + if (info->u.Algid) + { + err = RegSetValueExW(key, algidW, 0, REG_DWORD, (const BYTE *)&info->u.Algid, sizeof(info->u.Algid)); + if (err != ERROR_SUCCESS) goto done; + } + + if (info->ExtraInfo.cbData && info->ExtraInfo.pbData) + { + err = RegSetValueExW(key, extraW, 0, REG_BINARY, info->ExtraInfo.pbData, info->ExtraInfo.cbData); + if (err != ERROR_SUCCESS) goto done; + } + + if (info->pwszCNGAlgid) + { + err = RegSetValueExW(key, cngalgidW, 0, REG_SZ, (const BYTE *)info->pwszCNGAlgid, (lstrlenW(info->pwszCNGAlgid) + 1) * sizeof(WCHAR)); + if (err != ERROR_SUCCESS) goto done; + } + + if (info->pwszCNGExtraAlgid) + { + err = RegSetValueExW(key, cngextraalgidW, 0, REG_SZ, (const BYTE *)info->pwszCNGExtraAlgid, (lstrlenW(info->pwszCNGExtraAlgid) + 1) * sizeof(WCHAR)); + if (err != ERROR_SUCCESS) goto done; + } + +done: + CryptMemFree(key_name); + if (key) RegCloseKey(key); + if (root) RegCloseKey(root); + + if (err) + SetLastError(err); + + return !err; } /*********************************************************************** diff --git a/include/wincrypt.h b/include/wincrypt.h index 8e8c258157..0ba3b5ef79 100644 --- a/include/wincrypt.h +++ b/include/wincrypt.h @@ -2374,6 +2374,7 @@ static const WCHAR CRYPT_OID_REG_FLAGS_VALUE_NAME[] = #define CRYPT_DEFAULT_OID "DEFAULT" #define CRYPT_INSTALL_OID_FUNC_BEFORE_FLAG 1 +#define CRYPT_INSTALL_OID_INFO_BEFORE_FLAG 1 #define CRYPT_GET_INSTALLED_OID_FUNC_FLAG 0x1 -- 2.17.1

1 0

[PATCH 1/4] crypt32: Implement CryptUnregisterOIDInfo.
by Dmitry Timoshkov 05 Oct '18

05 Oct '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/crypt32/crypt32.spec | 2 +- dlls/crypt32/oid.c | 43 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 1 deletion(-) diff --git a/dlls/crypt32/crypt32.spec b/dlls/crypt32/crypt32.spec index 0bc78a158d..64d5aa93fd 100644 --- a/dlls/crypt32/crypt32.spec +++ b/dlls/crypt32/crypt32.spec @@ -194,7 +194,7 @@ @ stdcall CryptUnprotectMemory(ptr long long) @ stdcall CryptUnregisterDefaultOIDFunction(long str wstr) @ stdcall CryptUnregisterOIDFunction(long str str) -@ stub CryptUnregisterOIDInfo +@ stdcall CryptUnregisterOIDInfo(ptr) @ stdcall CryptVerifyCertificateSignature(long long ptr long ptr) @ stdcall CryptVerifyCertificateSignatureEx(long long long ptr long ptr long ptr) @ stdcall CryptVerifyDetachedMessageHash(ptr ptr long long ptr ptr ptr ptr) diff --git a/dlls/crypt32/oid.c b/dlls/crypt32/oid.c index c9b0b412cf..e9ccab7494 100644 --- a/dlls/crypt32/oid.c +++ b/dlls/crypt32/oid.c @@ -1,6 +1,7 @@ /* * Copyright 2002 Mike McCormack for CodeWeavers * Copyright 2005-2006 Juan Lang + * Copyright 2018 Dmitry Timoshkov * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -652,6 +653,48 @@ error_close_key: return TRUE; } +/*********************************************************************** + * CryptUnregisterOIDInfo (CRYPT32.@) + */ +BOOL WINAPI CryptUnregisterOIDInfo(PCCRYPT_OID_INFO info) +{ + char *key_name; + HKEY root; + DWORD err; + + TRACE("(%p)\n", info); + + if (!info || info->cbSize != sizeof(*info) || !info->pszOID) + { + SetLastError(E_INVALIDARG); + return FALSE; + } + + err = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo", 0, KEY_ALL_ACCESS, &root); + if (err != ERROR_SUCCESS) + { + SetLastError(err); + return FALSE; + } + + key_name = CryptMemAlloc(strlen(info->pszOID) + 16); + if (key_name) + { + sprintf(key_name, "%s!%u", info->pszOID, info->dwGroupId); + err = RegDeleteKeyA(root, key_name); + } + else + err = ERROR_OUTOFMEMORY; + + CryptMemFree(key_name); + RegCloseKey(root); + + if (err) + SetLastError(err); + + return !err; +} + /*********************************************************************** * CryptRegisterOIDInfo (CRYPT32.@) */ -- 2.17.1

1 0

[PATCH 3/3] winhttp: Make accessing session credential handle thread safe.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/request.c | 24 ++++++++++++++++-------- dlls/winhttp/session.c | 2 ++ 2 files changed, 18 insertions(+), 8 deletions(-)

2 1

[PATCH 2/3] winhttp: Make cookie access thread safe.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/cookie.c | 7 +++++++ dlls/winhttp/session.c | 4 ++++ dlls/winhttp/winhttp_private.h | 1 + 3 files changed, 12 insertions(+)

2 1

[PATCH 1/3] winhttp: Move cookie_t declaration to cookie.c.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/cookie.c | 8 ++++++++ dlls/winhttp/winhttp_private.h | 8 -------- 2 files changed, 8 insertions(+), 8 deletions(-)

2 1

[PATCH] ntdll: Add RtlSetUnhandledExceptionFilter stub.
by Alistair Leslie-Hughes 05 Oct '18

05 Oct '18

From: Andrew Wesie <awesie(a)gmail.com> Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45566 Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/ntdll/exception.c | 5 +++++ dlls/ntdll/ntdll.spec | 1 + 2 files changed, 6 insertions(+) diff --git a/dlls/ntdll/exception.c b/dlls/ntdll/exception.c index f853810..f82b6b4 100644 --- a/dlls/ntdll/exception.c +++ b/dlls/ntdll/exception.c @@ -325,3 +325,8 @@ void __wine_spec_unimplemented_stub( const char *module, const char *function ) record.ExceptionInformation[1] = (ULONG_PTR)function; for (;;) RtlRaiseException( &record ); } + +void WINAPI RtlSetUnhandledExceptionFilter( void *handler ) +{ + FIXME( "(%p) stub!\n", handler ); +} diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index b7cbff3..fbc1ac4 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -903,6 +903,7 @@ # @ stub RtlSetThreadPoolStartFunc @ stdcall RtlSetTimeZoneInformation(ptr) # @ stub RtlSetTimer +@ stdcall RtlSetUnhandledExceptionFilter(ptr) @ stub RtlSetUnicodeCallouts @ stub RtlSetUserFlagsHeap @ stub RtlSetUserValueHeap -- 1.9.1

2 1

[PATCH] opengl32: Add wrappers for glDebugMessageCallback to handle calling convention differences.
by Alistair Leslie-Hughes 05 Oct '18

05 Oct '18

From: Sebastian Lackner <sebastian(a)fds-team.de> Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=38402 Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/opengl32/make_opengl | 3 +++ dlls/opengl32/opengl_ext.c | 24 +++---------------- dlls/opengl32/tests/opengl.c | 44 ++++++++++++++++++++++++++++++++++ dlls/opengl32/wgl.c | 57 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 107 insertions(+), 21 deletions(-) diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl index ebdca67..ff50f8a 100755 --- a/dlls/opengl32/make_opengl +++ b/dlls/opengl32/make_opengl @@ -415,6 +415,9 @@ sub needs_wrapper($$) my %funcs = ( "glDebugEntry" => 1, + "glDebugMessageCallback" => 1, + "glDebugMessageCallbackAMD" => 1, + "glDebugMessageCallbackARB" => 1, "glGetIntegerv" => 1, "glGetString" => 1, "glGetStringi" => 1, diff --git a/dlls/opengl32/opengl_ext.c b/dlls/opengl32/opengl_ext.c index e6f949f..e55c1f7 100644 --- a/dlls/opengl32/opengl_ext.c +++ b/dlls/opengl32/opengl_ext.c @@ -2313,27 +2313,6 @@ static void WINAPI glCurrentPaletteMatrixARB( GLint index ) funcs->ext.p_glCurrentPaletteMatrixARB( index ); } -static void WINAPI glDebugMessageCallback( GLDEBUGPROC callback, const void *userParam ) -{ - const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; - TRACE( "(%p, %p)\n", callback, userParam ); - funcs->ext.p_glDebugMessageCallback( callback, userParam ); -} - -static void WINAPI glDebugMessageCallbackAMD( GLDEBUGPROCAMD callback, void *userParam ) -{ - const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; - TRACE( "(%p, %p)\n", callback, userParam ); - funcs->ext.p_glDebugMessageCallbackAMD( callback, userParam ); -} - -static void WINAPI glDebugMessageCallbackARB( GLDEBUGPROCARB callback, const void *userParam ) -{ - const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; - TRACE( "(%p, %p)\n", callback, userParam ); - funcs->ext.p_glDebugMessageCallbackARB( callback, userParam ); -} - static void WINAPI glDebugMessageControl( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) { const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; @@ -18518,6 +18497,9 @@ static BOOL WINAPI wglSwapIntervalEXT( int interval ) return funcs->ext.p_wglSwapIntervalEXT( interval ); } +extern void WINAPI glDebugMessageCallback( GLDEBUGPROC callback, const void *userParam ) DECLSPEC_HIDDEN; +extern void WINAPI glDebugMessageCallbackAMD( GLDEBUGPROCAMD callback, void *userParam ) DECLSPEC_HIDDEN; +extern void WINAPI glDebugMessageCallbackARB( GLDEBUGPROCARB callback, const void *userParam ) DECLSPEC_HIDDEN; extern const GLubyte * WINAPI glGetStringi( GLenum name, GLuint index ) DECLSPEC_HIDDEN; extern BOOL WINAPI wglBindTexImageARB( HPBUFFERARB hPbuffer, int iBuffer ) DECLSPEC_HIDDEN; extern HGLRC WINAPI wglCreateContextAttribsARB( HDC hDC, HGLRC hShareContext, const int *attribList ) DECLSPEC_HIDDEN; diff --git a/dlls/opengl32/tests/opengl.c b/dlls/opengl32/tests/opengl.c index 8105201..65a5914 100644 --- a/dlls/opengl32/tests/opengl.c +++ b/dlls/opengl32/tests/opengl.c @@ -48,6 +48,11 @@ static HDC (WINAPI *pwglGetPbufferDCARB)(HPBUFFERARB); static BOOL (WINAPI *pwglSwapIntervalEXT)(int interval); static int (WINAPI *pwglGetSwapIntervalEXT)(void); +/* GL_ARB_debug_output */ +static void (WINAPI *pglDebugMessageCallbackARB)(void *, void *); +static void (WINAPI *pglDebugMessageControlARB)(GLenum, GLenum, GLenum, GLsizei, const GLuint *, GLboolean); +static void (WINAPI *pglDebugMessageInsertARB)(GLenum, GLenum, GLuint, GLenum, GLsizei, const char *); + static const char* wgl_extensions = NULL; static void init_functions(void) @@ -80,6 +85,11 @@ static void init_functions(void) GET_PROC(wglSwapIntervalEXT) GET_PROC(wglGetSwapIntervalEXT) + /* GL_ARB_debug_output */ + GET_PROC(glDebugMessageCallbackARB) + GET_PROC(glDebugMessageControlARB) + GET_PROC(glDebugMessageInsertARB) + #undef GET_PROC } @@ -305,6 +315,39 @@ static void test_choosepixelformat(void) pfd.cAuxBuffers = 0; } +static void WINAPI gl_debug_message_callback(GLenum source, GLenum type, GLuint id, GLenum severity, + GLsizei length, const GLchar *message, const void *userParam) +{ + DWORD *count = (DWORD *)userParam; + (*count)++; +} + +static void test_debug_message_callback(void) +{ + static const char testmsg[] = "Hello World"; + DWORD count; + + if (!pglDebugMessageCallbackARB) + { + skip("glDebugMessageCallbackARB not supported\n"); + return; + } + + glEnable(GL_DEBUG_OUTPUT); + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + + pglDebugMessageCallbackARB(gl_debug_message_callback, &count); + pglDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE); + + count = 0; + pglDebugMessageInsertARB(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, 0x42424242, + GL_DEBUG_SEVERITY_LOW, sizeof(testmsg), testmsg); + ok(count == 1, "expected count == 1, got %u\n", count); + + glDisable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + glDisable(GL_DEBUG_OUTPUT); +} + static void test_setpixelformat(HDC winhdc) { int res = 0; @@ -1786,6 +1829,7 @@ START_TEST(opengl) } test_choosepixelformat(); + test_debug_message_callback(); test_setpixelformat(hdc); test_destroy(hdc); test_sharelists(hdc); diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c index 04ace8e..9241005 100644 --- a/dlls/opengl32/wgl.c +++ b/dlls/opengl32/wgl.c @@ -58,6 +58,9 @@ struct opengl_context DWORD tid; /* thread that the context is current in */ HDC draw_dc; /* current drawing DC */ HDC read_dc; /* current reading DC */ + void (CALLBACK *debug_callback)(GLenum, GLenum, GLuint, GLenum, + GLsizei, const GLchar *, const void *); /* debug callback */ + const void *debug_user; /* debug user parameter */ GLubyte *extensions; /* extension string */ GLuint *disabled_exts; /* indices of disabled extensions */ struct wgl_context *drv_ctx; /* driver context */ @@ -1746,6 +1749,60 @@ const GLubyte * WINAPI glGetString( GLenum name ) return ret; } +/* wrapper for glDebugMessageCallback* functions */ +static void gl_debug_message_callback( GLenum source, GLenum type, GLuint id, GLenum severity, + GLsizei length, const GLchar *message,const void *userParam ) +{ + struct wgl_handle *ptr = (struct wgl_handle *)userParam; + if (!ptr->u.context->debug_callback) return; + ptr->u.context->debug_callback( source, type, id, severity, length, message, ptr->u.context->debug_user ); +} + +/*********************************************************************** + * glDebugMessageCallback + */ +void WINAPI glDebugMessageCallback( GLDEBUGPROC callback, const void *userParam ) +{ + struct wgl_handle *ptr = get_current_context_ptr(); + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; + + TRACE( "(%p, %p)\n", callback, userParam ); + + ptr->u.context->debug_callback = callback; + ptr->u.context->debug_user = userParam; + funcs->ext.p_glDebugMessageCallback( gl_debug_message_callback, ptr ); +} + +/*********************************************************************** + * glDebugMessageCallbackAMD + */ +void WINAPI glDebugMessageCallbackAMD( GLDEBUGPROCAMD callback, void *userParam ) +{ + struct wgl_handle *ptr = get_current_context_ptr(); + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; + + TRACE( "(%p, %p)\n", callback, userParam ); + + ptr->u.context->debug_callback = callback; + ptr->u.context->debug_user = userParam; + funcs->ext.p_glDebugMessageCallbackAMD( gl_debug_message_callback, ptr ); +} + +/*********************************************************************** + * glDebugMessageCallbackARB + */ +void WINAPI glDebugMessageCallbackARB( GLDEBUGPROCARB callback, const void *userParam ) +{ + struct wgl_handle *ptr = get_current_context_ptr(); + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; + + TRACE( "(%p, %p)\n", callback, userParam ); + + ptr->u.context->debug_callback = callback; + ptr->u.context->debug_user = userParam; + funcs->ext.p_glDebugMessageCallbackARB( gl_debug_message_callback, ptr ); +} + /*********************************************************************** * OpenGL initialisation routine */ -- 1.9.1

1 0

[PATCH v4 1/2] ntoskrnl.exe: Implement IoRegisterDeviceInterface
by Aric Stewart 05 Oct '18

05 Oct '18

ver 4: More comments from Zebediah Figura and Dmitry Timoshkov Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/ntoskrnl.exe/Makefile.in | 2 +- dlls/ntoskrnl.exe/ntoskrnl.c | 137 ++++++++++++++++++++++++++++++++++++ dlls/ntoskrnl.exe/ntoskrnl.exe.spec | 2 +- include/ddk/wdm.h | 1 + 4 files changed, 140 insertions(+), 2 deletions(-)

2 1

[PATCH] server: copy_context(): Copy only valid information from source context.
by Joachim Priesner 04 Oct '18

04 Oct '18

A thread's context may be incomplete. For example, the i386 RtlCaptureContext() function does not save floating-point registers, setting the context's flags accordingly. Signed-off-by: Joachim Priesner <joachim.priesner(a)web.de> --- I'd like some feedback on whether this patch goes in the right direction. In particular, it breaks the functionality introduced in 03d31ea8 ("Only update the modified parts of the context on thread suspend") because the flags field is now used both to state what part of the context is valid and what part has changed. I found the issue when a program that manually raised an exception using RaiseException() was run under winedbg. The copy_context() invocation copied the zeroed-out floating point status from the suspended thread's context and set the SERVER_CTX_FLOATING_POINT flag. When winedbg wrote back the context after handling the exception, it overwrote the floating-point registers with zeroes. --- server/thread.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/server/thread.c b/server/thread.c index 2cf5054738..dfd2f61104 100644 --- a/server/thread.c +++ b/server/thread.c @@ -1129,6 +1129,7 @@ void kill_thread( struct thread *thread, int violent_death ) static void copy_context( context_t *to, const context_t *from, unsigned int flags ) { assert( to->cpu == from->cpu ); + flags &= from->flags; to->flags |= flags; if (flags & SERVER_CTX_CONTROL) to->ctl = from->ctl; if (flags & SERVER_CTX_INTEGER) to->integer = from->integer; @@ -1754,7 +1755,6 @@ DECL_HANDLER(set_suspend_context) else if ((current->suspend_context = mem_alloc( sizeof(context_t) ))) { memcpy( current->suspend_context, get_req_data(), sizeof(context_t) ); - current->suspend_context->flags = 0; /* to keep track of what is modified */ current->context = current->suspend_context; if (current->debug_break) break_thread( current ); } -- 2.19.0

2 1

[PATCH 4/6] kernel32: Reimplement RemoveDirectory() by setting a delete disposition.
by Dmitry Timoshkov 04 Oct '18

04 Oct '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/kernel32/path.c | 17 ++++++++--------- dlls/ntdll/tests/file.c | 8 +++++--- 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/dlls/kernel32/path.c b/dlls/kernel32/path.c index 48a3e336ec..5318a94388 100644 --- a/dlls/kernel32/path.c +++ b/dlls/kernel32/path.c @@ -1656,11 +1656,10 @@ BOOL WINAPI RemoveDirectoryW( LPCWSTR path ) { OBJECT_ATTRIBUTES attr; UNICODE_STRING nt_name; - ANSI_STRING unix_name; IO_STATUS_BLOCK io; NTSTATUS status; HANDLE handle; - BOOL ret = FALSE; + FILE_DISPOSITION_INFORMATION fdi; TRACE( "%s\n", debugstr_w(path) ); @@ -1686,19 +1685,19 @@ BOOL WINAPI RemoveDirectoryW( LPCWSTR path ) return FALSE; } - status = wine_nt_to_unix_file_name( &nt_name, &unix_name, FILE_OPEN, FALSE ); RtlFreeUnicodeString( &nt_name ); + + fdi.DoDeleteFile = TRUE; + status = NtSetInformationFile( handle, &io, &fdi, sizeof(fdi), FileDispositionInformation); + + NtClose( handle ); + if (status != STATUS_SUCCESS) { SetLastError( RtlNtStatusToDosError(status) ); - NtClose( handle ); return FALSE; } - - if (!(ret = (rmdir( unix_name.Buffer ) != -1))) FILE_SetDosError(); - RtlFreeAnsiString( &unix_name ); - NtClose( handle ); - return ret; + return TRUE; } diff --git a/dlls/ntdll/tests/file.c b/dlls/ntdll/tests/file.c index 286873d657..e83b88e79b 100644 --- a/dlls/ntdll/tests/file.c +++ b/dlls/ntdll/tests/file.c @@ -2934,16 +2934,18 @@ todo_wine fileDeleted = RemoveDirectoryA( buffer ); ok( fileDeleted, "Directory should have been deleted\n" ); fileDeleted = GetFileAttributesA( buffer ) == INVALID_FILE_ATTRIBUTES && GetLastError() == ERROR_FILE_NOT_FOUND; -todo_wine ok( !fileDeleted, "Directory shouldn't have been deleted\n" ); res = nt_get_file_attrs( buffer, &fdi2 ); todo_wine ok( res == STATUS_DELETE_PENDING, "got %#x\n", res ); /* can't open the deleted directory */ handle2 = CreateFileA(buffer, DELETE, FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); +todo_wine ok( handle2 == INVALID_HANDLE_VALUE, "CreateFile should fail\n" ); todo_wine ok(GetLastError() == ERROR_ACCESS_DENIED, "got %u\n", GetLastError()); +if (handle2 != INVALID_HANDLE_VALUE) + CloseHandle( handle2 ); CloseHandle( handle ); fileDeleted = GetFileAttributesA( buffer ) == INVALID_FILE_ATTRIBUTES && GetLastError() == ERROR_FILE_NOT_FOUND; ok( fileDeleted, "Directory should have been deleted\n" ); @@ -2966,10 +2968,10 @@ todo_wine handle3 = CreateFileA(buffer, DELETE, FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); todo_wine ok( handle3 == INVALID_HANDLE_VALUE, "CreateFile should fail\n" ); -if (handle3 != INVALID_HANDLE_VALUE) - CloseHandle( handle3 ); todo_wine ok(GetLastError() == ERROR_ACCESS_DENIED, "got %u\n", GetLastError()); +if (handle3 != INVALID_HANDLE_VALUE) + CloseHandle( handle3 ); /* can't open the deleted directory (wrong sharing mode) */ handle3 = CreateFileA(buffer, DELETE, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0); ok( handle3 == INVALID_HANDLE_VALUE, "CreateFile should fail\n" ); -- 2.17.1

3 2

[PATCH 2/3] winhttp: Make accessing session credential handle thread safe.
by Jacek Caban 04 Oct '18

04 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/request.c | 24 ++++++++++++++++-------- dlls/winhttp/session.c | 2 ++ 2 files changed, 18 insertions(+), 8 deletions(-)

2 2

[PATCH 3/3] winhttp: Make accessing session credential handle thread safe.
by Jacek Caban 04 Oct '18

04 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/request.c | 24 ++++++++++++++++-------- dlls/winhttp/session.c | 2 ++ 2 files changed, 18 insertions(+), 8 deletions(-)

1 0

[PATCH 3/3] winhttp: Make cookie access thread safe.
by Jacek Caban 04 Oct '18

04 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/cookie.c | 7 +++++++ dlls/winhttp/session.c | 4 ++++ dlls/winhttp/winhttp_private.h | 1 + 3 files changed, 12 insertions(+)

1 0

[PATCH 1/3] winhttp: Move cookie_t declaration to cookie.c.
by Jacek Caban 04 Oct '18

04 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winhttp/cookie.c | 8 ++++++++ dlls/winhttp/winhttp_private.h | 8 -------- 2 files changed, 8 insertions(+), 8 deletions(-)

1 0

[PATCH v4 2/2] hidclass.sys: use IoRegisterDeviceInterface
by Aric Stewart 04 Oct '18

04 Oct '18

Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/hidclass.sys/device.c | 60 ++++++++++++++++------------------------------ dlls/hidclass.sys/hid.h | 2 +- dlls/hidclass.sys/pnp.c | 4 +--- 3 files changed, 22 insertions(+), 44 deletions(-)

1 0

[PATCH v3 1/2] ntoskrnl.exe: Implement IoRegisterDeviceInterface
by Aric Stewart 04 Oct '18

04 Oct '18

ver 3: More comments from Zebediah Figura Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/ntoskrnl.exe/Makefile.in | 2 +- dlls/ntoskrnl.exe/ntoskrnl.c | 133 ++++++++++++++++++++++++++++++++++++ dlls/ntoskrnl.exe/ntoskrnl.exe.spec | 2 +- include/ddk/wdm.h | 1 + 4 files changed, 136 insertions(+), 2 deletions(-)

2 2

[PATCH v3 2/2] hidclass.sys: use IoRegisterDeviceInterface
by Aric Stewart 04 Oct '18

04 Oct '18

Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/hidclass.sys/device.c | 60 ++++++++++++++++------------------------------ dlls/hidclass.sys/hid.h | 2 +- dlls/hidclass.sys/pnp.c | 4 +--- 3 files changed, 22 insertions(+), 44 deletions(-)

1 0

[PATCH] rpcrt4: Handle absense of RPC flags in call_stubless_func() thunk.
by Zebediah Figura 04 Oct '18

04 Oct '18

If Oi_HAS_RPCFLAGS is not set, then the stack size is at offset 4, not 8. Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/rpcrt4/cproxy.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/dlls/rpcrt4/cproxy.c b/dlls/rpcrt4/cproxy.c index 2f49bb5..39dd34e 100644 --- a/dlls/rpcrt4/cproxy.c +++ b/dlls/rpcrt4/cproxy.c @@ -64,7 +64,13 @@ __ASM_GLOBAL_FUNC(call_stubless_func, "movl 8(%ecx),%edx\n\t" /* info->FormatStringOffset */ "movzwl (%edx,%eax,2),%edx\n\t" /* FormatStringOffset[index] */ "addl 4(%ecx),%edx\n\t" /* info->ProcFormatString + offset */ + "testb $0x08,1(%edx)\n\t" /* Oi_HAS_RPCFLAGS */ + "jz 1f\n\t" "movzwl 8(%edx),%eax\n\t" /* arguments size */ + "jmp 2f\n\t" + "1:\n\t" + "movzwl 4(%edx),%eax\n\t" + "2:\n\t" "pushl %eax\n\t" __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t") "leal 8(%esp),%eax\n\t" /* &This */ -- 2.7.4

2 3

[PATCH 1/3] d2d1: Use correct interpolation mode enum type member.
by Nikolay Sivov 04 Oct '18

04 Oct '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/brush.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/d2d1/brush.c b/dlls/d2d1/brush.c index 9c73ae1d88..dd3da32610 100644 --- a/dlls/d2d1/brush.c +++ b/dlls/d2d1/brush.c @@ -1113,7 +1113,7 @@ HRESULT d2d_bitmap_brush_create(ID2D1Factory *factory, ID2D1Bitmap *bitmap, { (*brush)->u.bitmap.extend_mode_x = D2D1_EXTEND_MODE_CLAMP; (*brush)->u.bitmap.extend_mode_y = D2D1_EXTEND_MODE_CLAMP; - (*brush)->u.bitmap.interpolation_mode = D2D1_BITMAP_INTERPOLATION_MODE_LINEAR; + (*brush)->u.bitmap.interpolation_mode = D2D1_INTERPOLATION_MODE_LINEAR; } TRACE("Created brush %p.\n", *brush); -- 2.19.0

3 6

[PATCH v2] wined3d: Add fast-path for texture download blit.
by Andrew Wesie 04 Oct '18

04 Oct '18

Signed-off-by: Andrew Wesie <awesie(a)gmail.com> --- dlls/wined3d/surface.c | 28 +++++++++++++++++++++++++--- dlls/wined3d/texture.c | 22 ++++++++++++++++++++++ dlls/wined3d/wined3d_private.h | 2 ++ 3 files changed, 49 insertions(+), 3 deletions(-) diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 4942177..71693ad 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -3257,6 +3257,29 @@ HRESULT texture2d_blt(struct wined3d_texture *dst_texture, unsigned int dst_sub_ return WINED3D_OK; } } + else if (!(src_sub_resource->locations & surface_simple_locations) + && (dst_sub_resource->locations & dst_texture->resource.map_binding)) + { + /* Download */ + if (scale) + TRACE("Not doing download because of scaling.\n"); + else if (convert) + TRACE("Not doing download because of format conversion.\n"); + else if (src_texture->resource.format->conv_byte_count) + TRACE("Not doing download because the source format needs conversion.\n"); + else if (is_multisample_location(src_texture, WINED3D_LOCATION_TEXTURE_RGB)) + TRACE("Not doing download because of multisample source.\n"); + else if (!texture2d_is_full_rect(src_texture, src_sub_resource_idx % src_texture->level_count, &src_rect)) + TRACE("Not doing download because of partial download (src).\n"); + else if (!texture2d_is_full_rect(dst_texture, dst_sub_resource_idx % dst_texture->level_count, &dst_rect)) + TRACE("Not doing download because of partial download (dst).\n"); + else + { + wined3d_texture_download_from_texture(dst_texture, dst_sub_resource_idx, src_texture, + src_sub_resource_idx); + return WINED3D_OK; + } + } else if (dst_swapchain && dst_swapchain->back_buffers && dst_texture == dst_swapchain->front_buffer && src_texture == dst_swapchain->back_buffers[0]) @@ -3280,10 +3303,9 @@ HRESULT texture2d_blt(struct wined3d_texture *dst_texture, unsigned int dst_sub_ return WINED3D_OK; } - else if ((flags & WINED3D_BLT_RAW) || (!scale && !convert && !resolve)) - { + + if ((flags & WINED3D_BLT_RAW) || (blit_op == WINED3D_BLIT_OP_COLOR_BLIT && !scale && !convert && !resolve)) blit_op = WINED3D_BLIT_OP_RAW_BLIT; - } if (dst_texture->resource.access & WINED3D_RESOURCE_ACCESS_GPU) dst_location = dst_texture->resource.draw_binding; diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 6711e83..78e9364 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -3802,3 +3802,25 @@ void wined3d_texture_upload_from_texture(struct wined3d_texture *dst_texture, un wined3d_texture_validate_location(dst_texture, dst_sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB); wined3d_texture_invalidate_location(dst_texture, dst_sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB); } + +/* Partial downloads are not supported. */ +void wined3d_texture_download_from_texture(struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx, + struct wined3d_texture *src_texture, unsigned int src_sub_resource_idx) +{ + struct wined3d_context *context; + struct wined3d_bo_address data; + DWORD dst_location = dst_texture->resource.map_binding; + + context = context_acquire(src_texture->resource.device, NULL, 0); + + wined3d_texture_prepare_location(dst_texture, dst_sub_resource_idx, context, dst_location); + wined3d_texture_get_memory(dst_texture, dst_sub_resource_idx, &data, dst_location); + wined3d_texture_bind_and_dirtify(src_texture, context, + !(src_texture->sub_resources[src_sub_resource_idx].locations & WINED3D_LOCATION_TEXTURE_RGB)); + wined3d_texture_download_data(src_texture, src_sub_resource_idx, context, &data); + + context_release(context); + + wined3d_texture_validate_location(dst_texture, dst_sub_resource_idx, dst_location); + wined3d_texture_invalidate_location(dst_texture, dst_sub_resource_idx, ~dst_location); +} diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index a2dcbb0..4812fa5 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -3352,6 +3352,8 @@ HRESULT wined3d_texture_check_box_dimensions(const struct wined3d_texture *textu unsigned int level, const struct wined3d_box *box) DECLSPEC_HIDDEN; void wined3d_texture_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, const struct wined3d_bo_address *data) DECLSPEC_HIDDEN; +void wined3d_texture_download_from_texture(struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx, + struct wined3d_texture *src_texture, unsigned int src_sub_resource_idx) DECLSPEC_HIDDEN; GLenum wined3d_texture_get_gl_buffer(const struct wined3d_texture *texture) DECLSPEC_HIDDEN; void wined3d_texture_get_memory(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_bo_address *data, DWORD locations) DECLSPEC_HIDDEN; -- 2.7.4

2 1

[PATCH 1/2] gdi32: Support the subpixel rendering for FreeType >= 2.8.1 .
by Byeongsik Jeon 04 Oct '18

04 Oct '18

FreeType >= 2.8.1 support LCD-optimized rendering without LCD filters. It works regardless of FT_Err_Unimplemented_Feature check. Signed-off-by: Byeongsik Jeon <bsjeon(a)hanmail.net> --- dlls/gdi32/freetype.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/dlls/gdi32/freetype.c b/dlls/gdi32/freetype.c index b7e2413753..468c1951b6 100644 --- a/dlls/gdi32/freetype.c +++ b/dlls/gdi32/freetype.c @@ -993,18 +993,22 @@ static BOOL is_hinting_enabled(void) static BOOL is_subpixel_rendering_enabled( void ) { -#ifdef FT_LCD_FILTER_H static int enabled = -1; if (enabled == -1) { - enabled = (pFT_Library_SetLcdFilter && - pFT_Library_SetLcdFilter( NULL, 0 ) != FT_Err_Unimplemented_Feature); + /* FreeType >= 2.8.1 offers LCD-optimezed rendering without lcd filters. */ + if ( FT_SimpleVersion >= ((2 << 16) | (8 << 8) | (1 << 0))) + enabled = TRUE; +#ifdef FT_LCD_FILTER_H + else if ( pFT_Library_SetLcdFilter && + pFT_Library_SetLcdFilter( NULL, 0 ) != FT_Err_Unimplemented_Feature ) + enabled = TRUE; +#endif + else enabled = FALSE; + TRACE("subpixel rendering is %senabled\n", enabled ? "" : "NOT "); } return enabled; -#else - return FALSE; -#endif } @@ -7274,7 +7278,6 @@ static DWORD get_glyph_outline(GdiFont *incoming_font, UINT glyph, UINT format, case WINE_GGO_HBGR_BITMAP: case WINE_GGO_VRGB_BITMAP: case WINE_GGO_VBGR_BITMAP: -#ifdef FT_LCD_FILTER_H { switch (ft_face->glyph->format) { @@ -7360,8 +7363,11 @@ static DWORD get_glyph_outline(GdiFont *incoming_font, UINT glyph, UINT format, if ( needsTransform ) pFT_Outline_Transform (&ft_face->glyph->outline, &transMatTategaki); - if ( pFT_Library_SetLcdFilter ) +#ifdef FT_LCD_FILTER_H + if ( FT_SimpleVersion < ((2 << 16) | (8 << 8) | (1 << 0)) && + pFT_Library_SetLcdFilter ) pFT_Library_SetLcdFilter( library, FT_LCD_FILTER_DEFAULT ); +#endif pFT_Render_Glyph (ft_face->glyph, render_mode); src = ft_face->glyph->bitmap.buffer; @@ -7442,9 +7448,6 @@ static DWORD get_glyph_outline(GdiFont *incoming_font, UINT glyph, UINT format, break; } -#else - return GDI_ERROR; -#endif case GGO_NATIVE: { -- 2.19.0

1 1

[PATCH] winhttp: Implement the WINHTTP_FLAG_ESCAPE_* flags.
by Hans Leidekker 04 Oct '18

04 Oct '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=42677 Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/winhttp/request.c | 12 ++-- dlls/winhttp/session.c | 67 +++++++++++++++------- dlls/winhttp/tests/url.c | 29 +++++++++- dlls/winhttp/tests/winhttp.c | 60 +++++++++++++++----- dlls/winhttp/url.c | 122 +++++++++++++++++------------------------ dlls/winhttp/winhttp_private.h | 10 +++- 6 files changed, 188 insertions(+), 112 deletions(-) diff --git a/dlls/winhttp/request.c b/dlls/winhttp/request.c index a365cdba48..960c755f8a 100644 --- a/dlls/winhttp/request.c +++ b/dlls/winhttp/request.c @@ -2535,18 +2535,18 @@ static BOOL handle_redirect( request_t *request, DWORD status ) if (location[0] == '/') { - len = escape_string( NULL, location, len_loc ); + len = escape_string( NULL, location, len_loc, 0 ); if (!(path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end; - escape_string( path, location, len_loc ); + escape_string( path, location, len_loc, 0 ); } else { if ((p = strrchrW( request->path, '/' ))) *p = 0; - len = strlenW( request->path ) + 1 + escape_string( NULL, location, len_loc ); + len = strlenW( request->path ) + 1 + escape_string( NULL, location, len_loc, 0 ); if (!(path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end; strcpyW( path, request->path ); strcatW( path, slashW ); - escape_string( path + strlenW(path), location, len_loc ); + escape_string( path + strlenW(path), location, len_loc, 0 ); } heap_free( request->path ); request->path = path; @@ -2597,9 +2597,9 @@ static BOOL handle_redirect( request_t *request, DWORD status ) request->path = NULL; if (uc.dwUrlPathLength) { - len = escape_string( NULL, uc.lpszUrlPath, uc.dwUrlPathLength + uc.dwExtraInfoLength ); + len = escape_string( NULL, uc.lpszUrlPath, uc.dwUrlPathLength + uc.dwExtraInfoLength, 0 ); if (!(request->path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end; - escape_string( request->path, uc.lpszUrlPath, uc.dwUrlPathLength + uc.dwExtraInfoLength ); + escape_string( request->path, uc.lpszUrlPath, uc.dwUrlPathLength + uc.dwExtraInfoLength, 0 ); } else request->path = strdupW( slashW ); } diff --git a/dlls/winhttp/session.c b/dlls/winhttp/session.c index 959cafa209..061091547a 100644 --- a/dlls/winhttp/session.c +++ b/dlls/winhttp/session.c @@ -1090,6 +1090,50 @@ static BOOL store_accept_types( request_t *request, const WCHAR **accept_types ) return TRUE; } +static WCHAR *get_request_path( const WCHAR *object, DWORD flags ) +{ + DWORD len, path_len = 0, query_len = 0; + const WCHAR *p = object, *q = NULL; + enum escape_flags path_flags, query_flags; + WCHAR *ret; + + if (flags & WINHTTP_FLAG_ESCAPE_DISABLE) path_flags = ESCAPE_FLAG_SPACE_ONLY|ESCAPE_FLAG_REMOVE_CRLF; + else if (flags & WINHTTP_FLAG_ESCAPE_PERCENT) path_flags = ESCAPE_FLAG_PERCENT; + else path_flags = 0; + + if (flags & WINHTTP_FLAG_ESCAPE_DISABLE_QUERY) query_flags = ESCAPE_FLAG_SPACE_ONLY|ESCAPE_FLAG_REMOVE_CRLF; + else query_flags = path_flags; + + if (object) + { + path_len = strlenW( object ); + if (object[0] == '/') + { + path_len--; + p++; + } + if ((q = strchrW( p, '?' ))) + { + q++; + query_len = path_len - (q - p); + path_len -= query_len + 1; + } + } + + len = escape_string( NULL, p, path_len, path_flags ); + len += escape_string( NULL, q, query_len, query_flags ); + if (!(ret = heap_alloc( (len + 3) * sizeof(WCHAR) ))) return NULL; + + ret[0] = '/'; + len = escape_string( ret + 1, p, path_len, path_flags ) + 1; + if (q) + { + ret[len] = '?'; + escape_string( ret + 1 + len, q, query_len, query_flags ); + } + return ret; +} + /*********************************************************************** * WinHttpOpenRequest (winhttp.@) */ @@ -1103,12 +1147,11 @@ HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR o TRACE("%p, %s, %s, %s, %s, %p, 0x%08x\n", hconnect, debugstr_w(verb), debugstr_w(object), debugstr_w(version), debugstr_w(referrer), types, flags); - if(types && TRACE_ON(winhttp)) { + if (types && TRACE_ON(winhttp)) + { const WCHAR **iter; - TRACE("accept types:\n"); - for(iter = types; *iter; iter++) - TRACE(" %s\n", debugstr_w(*iter)); + for (iter = types; *iter; iter++) TRACE(" %s\n", debugstr_w(*iter)); } if (!(connect = (connect_t *)grab_object( hconnect ))) @@ -1150,21 +1193,7 @@ HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR o if (!verb || !verb[0]) verb = getW; if (!(request->verb = strdupW( verb ))) goto end; - - if (object) - { - WCHAR *path, *p; - unsigned int len, len_object = strlenW(object); - - len = escape_string( NULL, object, len_object ); - if (object[0] != '/') len++; - if (!(p = path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end; - - if (object[0] != '/') *p++ = '/'; - escape_string( p, object, len_object ); - request->path = path; - } - else if (!(request->path = strdupW( slashW ))) goto end; + if (!(request->path = get_request_path( object, flags ))) goto end; if (!version || !version[0]) version = http1_1; if (!(request->version = strdupW( version ))) goto end; diff --git a/dlls/winhttp/tests/url.c b/dlls/winhttp/tests/url.c index 214b7f34cf..1980ad4da2 100644 --- a/dlls/winhttp/tests/url.c +++ b/dlls/winhttp/tests/url.c @@ -34,6 +34,7 @@ static WCHAR password[] = {'p','a','s','s','w','o','r','d',0}; static WCHAR about[] = {'/','s','i','t','e','/','a','b','o','u','t',0}; static WCHAR query[] = {'?','q','u','e','r','y',0}; static WCHAR escape[] = {' ','!','"','#','$','%','&','\'','(',')','*','+',',','-','.','/',':',';','<','=','>','?','@','[','\\',']','^','_','`','{','|','}','~',0}; +static WCHAR escape2[] = {'\r',0x1f,' ','\n',0x7f,'\r','\n',0}; static const WCHAR url1[] = {'h','t','t','p',':','/','/','u','s','e','r','n','a','m','e',':','p','a','s','s','w','o','r','d', @@ -72,6 +73,8 @@ static const WCHAR url14[] = {'h','t','t','p',':','/','/','w','w','w','.','w','i static const WCHAR url15[] = {'h','t','t','p',':','/','/','w','i','n','e','h','q','.','o','r','g',':','6','5','5','3','6',0}; static const WCHAR url16[] = {'h','t','t','p',':','/','/','w','i','n','e','h','q','.','o','r','g',':','0',0}; static const WCHAR url17[] = {'h','t','t','p',':','/','/','w','i','n','e','h','q','.','o','r','g',':',0}; +static const WCHAR url18[] = + {'h','t','t','p',':','/','/','%','0','D','%','1','F','%','2','0','%','0','A','%','7','F','%','0','D','%','0','A',0}; static const WCHAR url_k1[] = {'h','t','t','p',':','/','/','u','s','e','r','n','a','m','e',':','p','a','s','s','w','o','r','d', @@ -301,7 +304,31 @@ static void WinHttpCreateUrl_test( void ) ret = WinHttpCreateUrl( &uc, ICU_ESCAPE, url, &len ); ok( ret, "expected success\n" ); ok( len == 113, "expected len 113 got %u\n", len ); - ok( !lstrcmpW( url, url7 ), "url doesn't match\n" ); + ok( !lstrcmpW( url, url7 ), "url doesn't match %s\n", wine_dbgstr_w(url) ); + + /* escape extra info */ + memset( &uc, 0, sizeof(uc) ); + uc.dwStructSize = sizeof(uc); + uc.lpszExtraInfo = escape2; + uc.dwExtraInfoLength = lstrlenW( uc.lpszExtraInfo ); + url[0] = 0; + len = 256; + ret = WinHttpCreateUrl( &uc, ICU_ESCAPE, url, &len ); + ok( ret, "expected success\n" ); + ok( len == lstrlenW(url18), "expected len %u got %u\n", lstrlenW(url18), len ); + ok( !lstrcmpW( url, url18 ), "url doesn't match\n" ); + + /* escape path */ + memset( &uc, 0, sizeof(uc) ); + uc.dwStructSize = sizeof(uc); + uc.lpszUrlPath = escape2; + uc.dwUrlPathLength = lstrlenW( uc.lpszUrlPath ); + url[0] = 0; + len = 256; + ret = WinHttpCreateUrl( &uc, ICU_ESCAPE, url, &len ); + ok( ret, "expected success\n" ); + ok( len == lstrlenW(url18), "expected len %u got %u\n", lstrlenW(url18), len ); + ok( !lstrcmpW( url, url18 ), "url doesn't match\n" ); /* NULL lpszScheme, 0 nScheme and nPort */ fill_url_components( &uc ); diff --git a/dlls/winhttp/tests/winhttp.c b/dlls/winhttp/tests/winhttp.c index 9138d6ad98..e13f95057b 100644 --- a/dlls/winhttp/tests/winhttp.c +++ b/dlls/winhttp/tests/winhttp.c @@ -2362,7 +2362,15 @@ static DWORD CALLBACK server_thread(LPVOID param) } else if (strstr(buffer, "GET /escape")) { - if (strstr(buffer, "GET /escape?one%20two%0D%0A HTTP/1.1")) send(c, okmsg, sizeof(okmsg) - 1, 0); + static const char res[] = "%0D%0A%1F%7F%3C%20%one?%1F%7F%20!%22%23$%&'()*+,-./:;%3C=%3E?@%5B%5C%5D" + "%5E_%60%7B%7C%7D~%0D%0A "; + static const char res2[] = "%0D%0A%1F%7F%3C%20%25two?%1F%7F%20!%22%23$%25&'()*+,-./:;%3C=%3E?@%5B%5C%5D" + "%5E_%60%7B%7C%7D~%0D%0A "; + static const char res3[] = "\x1f\x7f<%20%three?\x1f\x7f%20!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ "; + static const char res4[] = "%0D%0A%1F%7F%3C%20%four?\x1f\x7f%20!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ "; + + if (strstr(buffer + 11, res) || strstr(buffer + 11, res2) || strstr(buffer + 11, res3) || + strstr(buffer + 11, res4 )) send(c, okmsg, sizeof(okmsg) - 1, 0); else send(c, notokmsg, sizeof(notokmsg) - 1, 0); } if (strstr(buffer, "GET /quit")) @@ -3340,21 +3348,13 @@ static void test_cookies( int port ) WinHttpCloseHandle( ses ); } -static void test_request_path_escapes( int port ) +static void do_request( HINTERNET con, const WCHAR *obj, DWORD flags ) { - static const WCHAR objW[] = - {'/','e','s','c','a','p','e','?','o','n','e',' ','t','w','o','\r','\n',0}; - HINTERNET ses, con, req; + HINTERNET req; DWORD status, size; BOOL ret; - ses = WinHttpOpen( test_useragent, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0 ); - ok( ses != NULL, "failed to open session %u\n", GetLastError() ); - - con = WinHttpConnect( ses, localhostW, port, 0 ); - ok( con != NULL, "failed to open a connection %u\n", GetLastError() ); - - req = WinHttpOpenRequest( con, NULL, objW, NULL, NULL, NULL, 0 ); + req = WinHttpOpenRequest( con, NULL, obj, NULL, NULL, NULL, flags ); ok( req != NULL, "failed to open a request %u\n", GetLastError() ); ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 ); @@ -3367,9 +3367,41 @@ static void test_request_path_escapes( int port ) size = sizeof(status); ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE|WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL ); ok( ret, "failed to query status code %u\n", GetLastError() ); - ok( status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status ); - + ok( status == HTTP_STATUS_OK, "request %s with flags %08x failed %u\n", wine_dbgstr_w(obj), flags, status ); WinHttpCloseHandle( req ); +} + +static void test_request_path_escapes( int port ) +{ + static const WCHAR objW[] = + {'/','e','s','c','a','p','e','\r','\n',0x1f,0x7f,'<',' ','%','o','n','e','?',0x1f,0x7f,' ','!','"','#', + '$','%','&','\'','(',')','*','+',',','-','.','/',':',';','<','=','>','?','@','[','\\',']','^','_','`', + '{','|','}','~','\r','\n',0}; + static const WCHAR obj2W[] = + {'/','e','s','c','a','p','e','\r','\n',0x1f,0x7f,'<',' ','%','t','w','o','?',0x1f,0x7f,' ','!','"','#', + '$','%','&','\'','(',')','*','+',',','-','.','/',':',';','<','=','>','?','@','[','\\',']','^','_','`', + '{','|','}','~','\r','\n',0}; + static const WCHAR obj3W[] = + {'/','e','s','c','a','p','e','\r','\n',0x1f,0x7f,'<',' ','%','t','h','r','e','e','?',0x1f,0x7f,' ','!', + '"','#','$','%','&','\'','(',')','*','+',',','-','.','/',':',';','<','=','>','?','@','[','\\',']','^', + '_','`','{','|','}','~','\r','\n',0}; + static const WCHAR obj4W[] = + {'/','e','s','c','a','p','e','\r','\n',0x1f,0x7f,'<',' ','%','f','o','u','r','?',0x1f,0x7f,' ','!','"', + '#','$','%','&','\'','(',')','*','+',',','-','.','/',':',';','<','=','>','?','@','[','\\',']','^','_', + '`','{','|','}','~','\r','\n',0}; + HINTERNET ses, con; + + ses = WinHttpOpen( test_useragent, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0 ); + ok( ses != NULL, "failed to open session %u\n", GetLastError() ); + + con = WinHttpConnect( ses, localhostW, port, 0 ); + ok( con != NULL, "failed to open a connection %u\n", GetLastError() ); + + do_request( con, objW, 0 ); + do_request( con, obj2W, WINHTTP_FLAG_ESCAPE_PERCENT ); + do_request( con, obj3W, WINHTTP_FLAG_ESCAPE_DISABLE ); + do_request( con, obj4W, WINHTTP_FLAG_ESCAPE_DISABLE_QUERY ); + WinHttpCloseHandle( con ); WinHttpCloseHandle( ses ); } diff --git a/dlls/winhttp/url.c b/dlls/winhttp/url.c index 1e481d7dec..2019305ab3 100644 --- a/dlls/winhttp/url.c +++ b/dlls/winhttp/url.c @@ -87,59 +87,52 @@ static WCHAR *decode_url( LPCWSTR url, DWORD *len ) return ret; } -static BOOL need_escape( WCHAR c ) + +static BOOL need_escape( WCHAR ch, enum escape_flags flags ) { - if (isalnumW( c )) return FALSE; + static const WCHAR escapes[] = {' ','"','#','<','>','[','\\',']','^','`','{','|','}',0}; + const WCHAR *p = escapes; - if (c <= 31 || c >= 127) return TRUE; - else + if (ch != ' ' && (flags & ESCAPE_FLAG_SPACE_ONLY)) return FALSE; + if (ch == '%' && (flags & ESCAPE_FLAG_PERCENT)) return TRUE; + if (ch == '~' && (flags & ESCAPE_FLAG_TILDE)) return TRUE; + + if (ch <= 31 || ch >= 127) return TRUE; + while (*p) { - switch (c) - { - case ' ': - case '"': - case '#': - case '%': - case '<': - case '>': - case ']': - case '\\': - case '[': - case '^': - case '`': - case '{': - case '|': - case '}': - case '~': - return TRUE; - default: - return FALSE; - } + if (ch == *p++) return TRUE; } + return FALSE; } -DWORD escape_string( WCHAR *dst, const WCHAR *src, DWORD len ) +DWORD escape_string( WCHAR *dst, const WCHAR *src, DWORD len, enum escape_flags flags ) { static const WCHAR hex[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; DWORD ret = len; unsigned int i; WCHAR *p = dst; - for (i = 0; i < len; i++, p++) + for (i = 0; i < len; i++) { - if (need_escape( src[i] )) + if ((flags & ESCAPE_FLAG_REMOVE_CRLF) && (src[i] == '\r' || src[i] == '\n')) + { + ret--; + continue; + } + if (need_escape( src[i], flags )) { if (dst) { p[0] = '%'; p[1] = hex[(src[i] >> 4) & 0xf]; p[2] = hex[src[i] & 0xf]; - p += 2; + p += 3; } ret += 2; } - else if (dst) *p = src[i]; + else if (dst) *p++ = src[i]; } + if (dst) dst[ret] = 0; return ret; } @@ -153,7 +146,7 @@ static WCHAR *escape_url( const WCHAR *url, DWORD *len ) if ((p = strrchrW( url, '/' ))) { len_base = p - url; - len_path = escape_string( NULL, p, *len - len_base ); + len_path = escape_string( NULL, p, *len - len_base, ESCAPE_FLAG_PERCENT|ESCAPE_FLAG_TILDE ); } else { @@ -164,7 +157,7 @@ static WCHAR *escape_url( const WCHAR *url, DWORD *len ) if (!(ret = heap_alloc( (len_base + len_path + 1) * sizeof(WCHAR) ))) return NULL; memcpy( ret, url, len_base * sizeof(WCHAR) ); - if (p) escape_string( ret + len_base, p, *len - (p - url) ); + if (p) escape_string( ret + len_base, p, *len - (p - url), ESCAPE_FLAG_PERCENT|ESCAPE_FLAG_TILDE ); ret[len_base + len_path] = 0; *len = len_base + len_path; @@ -349,18 +342,18 @@ static BOOL uses_default_port( INTERNET_SCHEME scheme, INTERNET_PORT port ) return FALSE; } -static DWORD comp_length( DWORD len, DWORD flags, WCHAR *comp ) +static DWORD get_comp_length( DWORD len, DWORD flags, WCHAR *comp ) { DWORD ret; unsigned int i; ret = len ? len : strlenW( comp ); if (!(flags & ICU_ESCAPE)) return ret; - for (i = 0; i < len; i++) if (need_escape( comp[i] )) ret += 2; + for (i = 0; i < len; i++) if (need_escape( comp[i], ESCAPE_FLAG_PERCENT|ESCAPE_FLAG_TILDE )) ret += 2; return ret; } -static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len ) +static BOOL get_url_length( URL_COMPONENTS *uc, DWORD flags, DWORD *len ) { static const WCHAR formatW[] = {'%','u',0}; INTERNET_SCHEME scheme; @@ -368,7 +361,7 @@ static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len ) *len = 0; if (uc->lpszScheme) { - DWORD scheme_len = comp_length( uc->dwSchemeLength, 0, uc->lpszScheme ); + DWORD scheme_len = get_comp_length( uc->dwSchemeLength, 0, uc->lpszScheme ); *len += scheme_len; scheme = get_scheme( uc->lpszScheme, scheme_len ); } @@ -378,12 +371,11 @@ static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len ) if (!scheme) scheme = INTERNET_SCHEME_HTTP; *len += strlenW( get_scheme_string( scheme ) ); } - *len += 1; /* ':' */ - if (uc->lpszHostName) *len += 2; /* "//" */ + *len += 3; /* "://" */ if (uc->lpszUserName) { - *len += comp_length( uc->dwUserNameLength, 0, uc->lpszUserName ); + *len += get_comp_length( uc->dwUserNameLength, 0, uc->lpszUserName ); *len += 1; /* "@" */ } else @@ -397,11 +389,11 @@ static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len ) if (uc->lpszPassword) { *len += 1; /* ":" */ - *len += comp_length( uc->dwPasswordLength, 0, uc->lpszPassword ); + *len += get_comp_length( uc->dwPasswordLength, 0, uc->lpszPassword ); } if (uc->lpszHostName) { - *len += comp_length( uc->dwHostNameLength, 0, uc->lpszHostName ); + *len += get_comp_length( uc->dwHostNameLength, 0, uc->lpszHostName ); if (!uses_default_port( scheme, uc->nPort )) { @@ -412,8 +404,8 @@ static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len ) } if (uc->lpszUrlPath && *uc->lpszUrlPath != '/') *len += 1; /* '/' */ } - if (uc->lpszUrlPath) *len += comp_length( uc->dwUrlPathLength, flags, uc->lpszUrlPath ); - if (uc->lpszExtraInfo) *len += comp_length( uc->dwExtraInfoLength, flags, uc->lpszExtraInfo ); + if (uc->lpszUrlPath) *len += get_comp_length( uc->dwUrlPathLength, flags, uc->lpszUrlPath ); + if (uc->lpszExtraInfo) *len += get_comp_length( uc->dwExtraInfoLength, flags, uc->lpszExtraInfo ); return TRUE; } @@ -423,7 +415,6 @@ static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len ) BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDWORD required ) { static const WCHAR formatW[] = {'%','u',0}; - static const WCHAR twoslashW[] = {'/','/'}; DWORD len; INTERNET_SCHEME scheme; @@ -435,7 +426,7 @@ BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDW return FALSE; } - if (!calc_length( uc, flags, &len )) return FALSE; + if (!get_url_length( uc, flags, &len )) return FALSE; if (*required < len) { @@ -453,7 +444,7 @@ BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDW *required = len; if (uc->lpszScheme) { - len = comp_length( uc->dwSchemeLength, 0, uc->lpszScheme ); + len = get_comp_length( uc->dwSchemeLength, 0, uc->lpszScheme ); memcpy( url, uc->lpszScheme, len * sizeof(WCHAR) ); url += len; @@ -472,58 +463,47 @@ BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDW url += len; } - /* all schemes are followed by at least a colon */ - *url = ':'; - url++; + *url++ = ':'; + *url++ = '/'; + *url++ = '/'; - if (uc->lpszHostName) - { - memcpy( url, twoslashW, sizeof(twoslashW) ); - url += ARRAY_SIZE( twoslashW ); - } if (uc->lpszUserName) { - len = comp_length( uc->dwUserNameLength, 0, uc->lpszUserName ); + len = get_comp_length( uc->dwUserNameLength, 0, uc->lpszUserName ); memcpy( url, uc->lpszUserName, len * sizeof(WCHAR) ); url += len; if (uc->lpszPassword) { - *url = ':'; - url++; - - len = comp_length( uc->dwPasswordLength, 0, uc->lpszPassword ); + *url++ = ':'; + len = get_comp_length( uc->dwPasswordLength, 0, uc->lpszPassword ); memcpy( url, uc->lpszPassword, len * sizeof(WCHAR) ); url += len; } - *url = '@'; - url++; + *url++ = '@'; } if (uc->lpszHostName) { - len = comp_length( uc->dwHostNameLength, 0, uc->lpszHostName ); + len = get_comp_length( uc->dwHostNameLength, 0, uc->lpszHostName ); memcpy( url, uc->lpszHostName, len * sizeof(WCHAR) ); url += len; if (!uses_default_port( scheme, uc->nPort )) { - *url = ':'; - url++; - + *url++ = ':'; url += sprintfW( url, formatW, uc->nPort ); } /* add slash between hostname and path if necessary */ if (uc->lpszUrlPath && *uc->lpszUrlPath != '/') { - *url = '/'; - url++; + *url++ = '/'; } } if (uc->lpszUrlPath) { - len = comp_length( uc->dwUrlPathLength, 0, uc->lpszUrlPath ); - if (flags & ICU_ESCAPE) url += escape_string( url, uc->lpszUrlPath, len ); + len = get_comp_length( uc->dwUrlPathLength, 0, uc->lpszUrlPath ); + if (flags & ICU_ESCAPE) url += escape_string( url, uc->lpszUrlPath, len, ESCAPE_FLAG_PERCENT|ESCAPE_FLAG_TILDE ); else { memcpy( url, uc->lpszUrlPath, len * sizeof(WCHAR) ); @@ -532,8 +512,8 @@ BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDW } if (uc->lpszExtraInfo) { - len = comp_length( uc->dwExtraInfoLength, 0, uc->lpszExtraInfo ); - if (flags & ICU_ESCAPE) url += escape_string( url, uc->lpszExtraInfo, len ); + len = get_comp_length( uc->dwExtraInfoLength, 0, uc->lpszExtraInfo ); + if (flags & ICU_ESCAPE) url += escape_string( url, uc->lpszExtraInfo, len, ESCAPE_FLAG_PERCENT|ESCAPE_FLAG_TILDE ); else { memcpy( url, uc->lpszExtraInfo, len * sizeof(WCHAR) ); diff --git a/dlls/winhttp/winhttp_private.h b/dlls/winhttp/winhttp_private.h index 6b4e3b0405..53b3c163df 100644 --- a/dlls/winhttp/winhttp_private.h +++ b/dlls/winhttp/winhttp_private.h @@ -307,7 +307,15 @@ BOOL set_server_for_hostname( connect_t *, LPCWSTR, INTERNET_PORT ) DECLSPEC_HID void destroy_authinfo( struct authinfo * ) DECLSPEC_HIDDEN; void release_host( hostdata_t *host ) DECLSPEC_HIDDEN; -DWORD escape_string( WCHAR *, const WCHAR *, DWORD ) DECLSPEC_HIDDEN; + +enum escape_flags +{ + ESCAPE_FLAG_REMOVE_CRLF = 0x01, + ESCAPE_FLAG_SPACE_ONLY = 0x02, + ESCAPE_FLAG_PERCENT = 0x04, + ESCAPE_FLAG_TILDE = 0x08, +}; +DWORD escape_string( WCHAR *, const WCHAR *, DWORD, enum escape_flags ) DECLSPEC_HIDDEN; extern HRESULT WinHttpRequest_create( void ** ) DECLSPEC_HIDDEN; void release_typelib( void ) DECLSPEC_HIDDEN; -- 2.11.0

1 0

[PATCH] devenum: Zero-initialize REGFILTERPINS struct.
by Zebediah Figura 04 Oct '18

04 Oct '18

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=45923 Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/devenum/createdevenum.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/devenum/createdevenum.c b/dlls/devenum/createdevenum.c index e44e6ec..8a3160c 100644 --- a/dlls/devenum/createdevenum.c +++ b/dlls/devenum/createdevenum.c @@ -778,7 +778,7 @@ static void register_avicap_devices(void) WCHAR friendlyname[] = {'v','i','d','e','o','0',0}; IPropertyBag *prop_bag = NULL; WCHAR name[32], version[32]; - REGFILTERPINS2 rgpins; + REGFILTERPINS2 rgpins = {0}; REGPINTYPES rgtypes; REGFILTER2 rgf; VARIANT var; -- 2.7.4

1 0

[PATCH v2 1/2] ntoskrnl.exe: Implement IoRegisterDeviceInterface
by Aric Stewart 04 Oct '18

04 Oct '18

v2: use setupapi functions as suggested by Zebediah Figura Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/ntoskrnl.exe/Makefile.in | 2 +- dlls/ntoskrnl.exe/ntoskrnl.c | 125 ++++++++++++++++++++++++++++++++++++ dlls/ntoskrnl.exe/ntoskrnl.exe.spec | 2 +- include/ddk/wdm.h | 1 + 4 files changed, 128 insertions(+), 2 deletions(-)

2 1

[PATCH v2] mshtml: Support retrieving command output in Exec(OLECMDID_OPTICAL_ZOOM).
by Piotr Caban 03 Oct '18

03 Oct '18

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- v2: - fixed test failures on IE6 and output parameter assignment (spotted by Jacek) dlls/mshtml/mshtml_private.h | 1 + dlls/mshtml/nsembed.c | 23 +++++++++++++++++++++++ dlls/mshtml/olecmd.c | 9 +++++++-- dlls/mshtml/tests/htmldoc.c | 17 +++++++++++++++-- 4 files changed, 46 insertions(+), 4 deletions(-)

3 2

[PATCH] mshtml: Support retrieving command output in Exec(OLECMDID_OPTICAL_ZOOM).
by Piotr Caban 03 Oct '18

03 Oct '18

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/mshtml/mshtml_private.h | 1 + dlls/mshtml/nsembed.c | 23 +++++++++++++++++++++++ dlls/mshtml/olecmd.c | 9 +++++++-- dlls/mshtml/tests/htmldoc.c | 16 ++++++++++++++-- 4 files changed, 45 insertions(+), 4 deletions(-)

2 1

[v2 PATCH 1/4] include: Add ID2D1CommandList and ID2D1CommandSink definition.
by Nikolay Sivov 03 Oct '18

03 Oct '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- include/d2d1_1.idl | 124 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 123 insertions(+), 1 deletion(-) diff --git a/include/d2d1_1.idl b/include/d2d1_1.idl index c6cd9c7398..4a644ffd4c 100644 --- a/include/d2d1_1.idl +++ b/include/d2d1_1.idl @@ -32,7 +32,6 @@ interface ID2D1Effect; interface ID2D1GradientStopCollection1; interface ID2D1ImageBrush; interface ID2D1BitmapBrush1; -interface ID2D1CommandList; cpp_quote("#ifndef __dwrite_h__") /* already defined in dwrite.h but needed for WIDL */ @@ -429,6 +428,129 @@ interface ID2D1Device : ID2D1Resource ); } +[ + object, + uuid(54d7898a-a061-40a7-bec7-e465bcba2c4f), + local, +] +interface ID2D1CommandSink : IUnknown +{ + HRESULT BeginDraw(); + HRESULT EndDraw(); + HRESULT SetAntialiasMode( + [in] D2D1_ANTIALIAS_MODE antialias_mode + ); + HRESULT SetTags( + [in] D2D1_TAG tag1, + [in] D2D1_TAG tag2 + ); + HRESULT SetTextAntialiasMode( + [in] D2D1_TEXT_ANTIALIAS_MODE antialias_mode + ); + HRESULT SetTextRenderingParams( + [in] IDWriteRenderingParams *text_rendering_params + ); + HRESULT SetTransform( + [in] D2D1_MATRIX_3X2_F *transform + ); + HRESULT SetPrimitiveBlend( + [in] D2D1_PRIMITIVE_BLEND primitive_blend + ); + HRESULT SetUnitMode( + [in] D2D1_UNIT_MODE unit_mode + ); + HRESULT Clear( + [in] const D2D1_COLOR_F *color + ); + HRESULT DrawGlyphRun( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, + [in] ID2D1Brush *brush, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + HRESULT DrawLine( + [in] D2D1_POINT_2F p0, + [in] D2D1_POINT_2F p1, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + HRESULT DrawGeometry( + [in] ID2D1Geometry *geometry, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + HRESULT DrawRectangle( + [in] const D2D1_RECT_F *rect, + [in] ID2D1Brush *brush, + [in] float stroke_width, + [in] ID2D1StrokeStyle *stroke_style + ); + HRESULT DrawBitmap( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_RECT_F *dst_rect, + [in] float opacity, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] const D2D1_RECT_F *src_rect, + [in] const D2D1_MATRIX_4X4_F *perspective_transform + ); + HRESULT DrawImage( + [in] ID2D1Image *image, + [in] const D2D1_POINT_2F *target_offset, + [in] const D2D1_POINT_2F *image_rect, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] D2D1_COMPOSITE_MODE composite_mode + ); + HRESULT DrawGdiMetafile( + [in] ID2D1GdiMetafile *metafile, + [in] const D2D1_POINT_2F *target_offset + ); + HRESULT FillMesh( + [in] ID2D1Mesh *mesh, + [in] ID2D1Brush *brush + ); + HRESULT FillOpacityMask( + [in] ID2D1Bitmap *bitmap, + [in] ID2D1Brush *brush, + [in] const D2D1_RECT_F *dst_rect, + [in] const D2D1_RECT_F *src_rect + ); + HRESULT FillGeometry( + [in] ID2D1Geometry *geometry, + [in] ID2D1Brush *brush, + [in] ID2D1Brush *opacity_brush + ); + HRESULT FillRectangle( + [in] const D2D1_RECT_F *rect, + [in] ID2D1Brush *brush + ); + HRESULT PushAxisAlignedClip( + [in] const D2D1_RECT_F *clip_rect, + [in] D2D1_ANTIALIAS_MODE antialias_mode + ); + HRESULT PushLayer( + [in] const D2D1_LAYER_PARAMETERS1 *layer_parameters, + [in] ID2D1Layer *layer + ); + HRESULT PopAxisAlignedClip(); + HRESULT PopLayer(); +} + +[ + object, + uuid(b4f34a19-2383-4d76-94f6-ec343657c3dc), + local, +] +interface ID2D1CommandList : ID2D1Image +{ + HRESULT Stream( + [in] ID2D1CommandSink *sink + ); + HRESULT Close(); +} + [ object, uuid(e8f7fe7a-191c-466d-ad95-975678bda998), -- 2.19.0

3 8

[PATCH 1/4] wined3d: Unify texture download functions.
by Andrew Wesie 03 Oct '18

03 Oct '18

Signed-off-by: Andrew Wesie <awesie(a)gmail.com> --- dlls/wined3d/surface.c | 233 +------------------------- dlls/wined3d/texture.c | 359 +++++++++++++++++++++++++++++++++-------- dlls/wined3d/wined3d_private.h | 2 + 3 files changed, 295 insertions(+), 299 deletions(-) diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 8b69720..4942177 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -342,235 +342,6 @@ static BOOL fbo_blitter_supported(enum wined3d_blit_op blit_op, const struct win return TRUE; } -/* This call just downloads data, the caller is responsible for binding the - * correct texture. */ -/* Context activation is done by the caller. */ -static void texture2d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, - const struct wined3d_context *context, DWORD dst_location) -{ - const struct wined3d_gl_info *gl_info = context->gl_info; - struct wined3d_texture_sub_resource *sub_resource; - unsigned int dst_row_pitch, dst_slice_pitch; - unsigned int src_row_pitch, src_slice_pitch; - const struct wined3d_format_gl *format_gl; - struct wined3d_bo_address data; - BYTE *temporary_mem = NULL; - unsigned int level; - GLenum target; - void *mem; - - format_gl = wined3d_format_gl(texture->resource.format); - - /* Only support read back of converted P8 textures. */ - if (texture->flags & WINED3D_TEXTURE_CONVERTED && format_gl->f.id != WINED3DFMT_P8_UINT && !format_gl->f.download) - { - ERR("Trying to read back converted texture %p, %u with format %s.\n", - texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); - return; - } - - sub_resource = &texture->sub_resources[sub_resource_idx]; - target = wined3d_texture_get_sub_resource_target(texture, sub_resource_idx); - level = sub_resource_idx % texture->level_count; - - if (target == GL_TEXTURE_2D_ARRAY) - { - if (format_gl->f.download) - { - FIXME("Reading back converted array texture %p is not supported.\n", texture); - return; - } - - /* NP2 emulation is not allowed on array textures. */ - if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) - ERR("Array texture %p uses NP2 emulation.\n", texture); - - WARN_(d3d_perf)("Downloading all miplevel layers to get the data for a single sub-resource.\n"); - - if (!(temporary_mem = heap_calloc(texture->layer_count, sub_resource->size))) - { - ERR("Out of memory.\n"); - return; - } - } - - wined3d_texture_get_memory(texture, sub_resource_idx, &data, dst_location); - - if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) - { - if (format_gl->f.download) - { - FIXME("Reading back converted texture %p with NP2 emulation is not supported.\n", texture); - return; - } - - wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); - wined3d_format_calculate_pitch(&format_gl->f, texture->resource.device->surface_alignment, - wined3d_texture_get_level_pow2_width(texture, level), - wined3d_texture_get_level_pow2_height(texture, level), - &src_row_pitch, &src_slice_pitch); - if (!(temporary_mem = heap_alloc(src_slice_pitch))) - { - ERR("Out of memory.\n"); - return; - } - - if (data.buffer_object) - ERR("NP2 emulated texture uses PBO unexpectedly.\n"); - if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) - ERR("Unexpected compressed format for NP2 emulated texture.\n"); - } - - if (format_gl->f.download) - { - struct wined3d_format f; - - if (data.buffer_object) - ERR("Converted texture %p uses PBO unexpectedly.\n", texture); - - WARN_(d3d_perf)("Downloading converted texture %p, %u with format %s.\n", - texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); - - f = format_gl->f; - f.byte_count = format_gl->f.conv_byte_count; - wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); - wined3d_format_calculate_pitch(&f, texture->resource.device->surface_alignment, - wined3d_texture_get_level_width(texture, level), - wined3d_texture_get_level_height(texture, level), - &src_row_pitch, &src_slice_pitch); - - if (!(temporary_mem = heap_alloc(src_slice_pitch))) - { - ERR("Failed to allocate memory.\n"); - return; - } - } - - if (temporary_mem) - { - mem = temporary_mem; - } - else if (data.buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data.buffer_object)); - checkGLcall("glBindBuffer"); - mem = data.addr; - } - else - { - mem = data.addr; - } - - if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) - { - TRACE("Downloading compressed texture %p, %u, level %u, format %#x, type %#x, data %p.\n", - texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); - - GL_EXTCALL(glGetCompressedTexImage(target, level, mem)); - checkGLcall("glGetCompressedTexImage"); - } - else - { - TRACE("Downloading texture %p, %u, level %u, format %#x, type %#x, data %p.\n", - texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); - - gl_info->gl_ops.gl.p_glGetTexImage(target, level, format_gl->format, format_gl->type, mem); - checkGLcall("glGetTexImage"); - } - - if (format_gl->f.download) - { - format_gl->f.download(mem, data.addr, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, - wined3d_texture_get_level_width(texture, level), - wined3d_texture_get_level_height(texture, level), 1); - } - else if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) - { - const BYTE *src_data; - unsigned int h, y; - BYTE *dst_data; - /* - * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing - * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to - * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width. - * - * We're doing this... - * - * instead of boxing the texture : - * |<-texture width ->| -->pow2width| /\ - * |111111111111111111| | | - * |222 Texture 222222| boxed empty | texture height - * |3333 Data 33333333| | | - * |444444444444444444| | \/ - * ----------------------------------- | - * | boxed empty | boxed empty | pow2height - * | | | \/ - * ----------------------------------- - * - * - * we're repacking the data to the expected texture width - * - * |<-texture width ->| -->pow2width| /\ - * |111111111111111111222222222222222| | - * |222333333333333333333444444444444| texture height - * |444444 | | - * | | \/ - * | | | - * | empty | pow2height - * | | \/ - * ----------------------------------- - * - * == is the same as - * - * |<-texture width ->| /\ - * |111111111111111111| - * |222222222222222222|texture height - * |333333333333333333| - * |444444444444444444| \/ - * -------------------- - * - * This also means that any references to surface memory should work with the data as if it were a - * standard texture with a non-power2 width instead of a texture boxed up to be a power2 texture. - * - * internally the texture is still stored in a boxed format so any references to textureName will - * get a boxed texture with width pow2width and not a texture of width resource.width. */ - src_data = mem; - dst_data = data.addr; - TRACE("Repacking the surface data from pitch %u to pitch %u.\n", src_row_pitch, dst_row_pitch); - h = wined3d_texture_get_level_height(texture, level); - for (y = 0; y < h; ++y) - { - memcpy(dst_data, src_data, dst_row_pitch); - src_data += src_row_pitch; - dst_data += dst_row_pitch; - } - } - else if (temporary_mem) - { - unsigned int layer = sub_resource_idx / texture->level_count; - void *src_data = temporary_mem + layer * sub_resource->size; - if (data.buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data.buffer_object)); - checkGLcall("glBindBuffer"); - GL_EXTCALL(glBufferSubData(GL_PIXEL_PACK_BUFFER, 0, sub_resource->size, src_data)); - checkGLcall("glBufferSubData"); - } - else - { - memcpy(data.addr, src_data, sub_resource->size); - } - } - - if (data.buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); - checkGLcall("glBindBuffer"); - } - - heap_free(temporary_mem); -} - /* See also float_16_to_32() in wined3d_private.h */ static inline unsigned short float_32_to_16(const float *in) { @@ -1666,9 +1437,11 @@ BOOL texture2d_load_sysmem(struct wined3d_texture *texture, unsigned int sub_res /* Download the sub-resource to system memory. */ if (sub_resource->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB)) { + struct wined3d_bo_address data; wined3d_texture_bind_and_dirtify(texture, context, !(sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)); - texture2d_download_data(texture, sub_resource_idx, context, dst_location); + wined3d_texture_get_memory(texture, sub_resource_idx, &data, dst_location); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); ++texture->download_count; return TRUE; } diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 9589e49..29bbdd7 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -2136,6 +2136,291 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s } } +static void texture2d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, + struct wined3d_context *context, const struct wined3d_bo_address *data) +{ + const struct wined3d_gl_info *gl_info = context->gl_info; + struct wined3d_texture_sub_resource *sub_resource; + unsigned int dst_row_pitch, dst_slice_pitch; + unsigned int src_row_pitch, src_slice_pitch; + const struct wined3d_format_gl *format_gl; + BYTE *temporary_mem = NULL; + unsigned int level; + GLenum target; + void *mem; + + format_gl = wined3d_format_gl(texture->resource.format); + + /* Only support read back of converted P8 textures. */ + if (texture->flags & WINED3D_TEXTURE_CONVERTED && format_gl->f.id != WINED3DFMT_P8_UINT && !format_gl->f.download) + { + ERR("Trying to read back converted texture %p, %u with format %s.\n", + texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); + return; + } + + sub_resource = &texture->sub_resources[sub_resource_idx]; + target = wined3d_texture_get_sub_resource_target(texture, sub_resource_idx); + level = sub_resource_idx % texture->level_count; + + if (target == GL_TEXTURE_2D_ARRAY) + { + if (format_gl->f.download) + { + FIXME("Reading back converted array texture %p is not supported.\n", texture); + return; + } + + /* NP2 emulation is not allowed on array textures. */ + if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) + ERR("Array texture %p uses NP2 emulation.\n", texture); + + WARN_(d3d_perf)("Downloading all miplevel layers to get the data for a single sub-resource.\n"); + + if (!(temporary_mem = heap_calloc(texture->layer_count, sub_resource->size))) + { + ERR("Out of memory.\n"); + return; + } + } + + if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) + { + if (format_gl->f.download) + { + FIXME("Reading back converted texture %p with NP2 emulation is not supported.\n", texture); + return; + } + + wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); + wined3d_format_calculate_pitch(&format_gl->f, texture->resource.device->surface_alignment, + wined3d_texture_get_level_pow2_width(texture, level), + wined3d_texture_get_level_pow2_height(texture, level), + &src_row_pitch, &src_slice_pitch); + if (!(temporary_mem = heap_alloc(src_slice_pitch))) + { + ERR("Out of memory.\n"); + return; + } + + if (data->buffer_object) + ERR("NP2 emulated texture uses PBO unexpectedly.\n"); + if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) + ERR("Unexpected compressed format for NP2 emulated texture.\n"); + } + + if (format_gl->f.download) + { + struct wined3d_format f; + + if (data->buffer_object) + ERR("Converted texture %p uses PBO unexpectedly.\n", texture); + + WARN_(d3d_perf)("Downloading converted texture %p, %u with format %s.\n", + texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); + + f = format_gl->f; + f.byte_count = format_gl->f.conv_byte_count; + wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); + wined3d_format_calculate_pitch(&f, texture->resource.device->surface_alignment, + wined3d_texture_get_level_width(texture, level), + wined3d_texture_get_level_height(texture, level), + &src_row_pitch, &src_slice_pitch); + + if (!(temporary_mem = heap_alloc(src_slice_pitch))) + { + ERR("Failed to allocate memory.\n"); + return; + } + } + + if (temporary_mem) + { + mem = temporary_mem; + } + else if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); + checkGLcall("glBindBuffer"); + mem = data->addr; + } + else + { + mem = data->addr; + } + + if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) + { + TRACE("Downloading compressed texture %p, %u, level %u, format %#x, type %#x, data %p.\n", + texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); + + GL_EXTCALL(glGetCompressedTexImage(target, level, mem)); + checkGLcall("glGetCompressedTexImage"); + } + else + { + TRACE("Downloading texture %p, %u, level %u, format %#x, type %#x, data %p.\n", + texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); + + gl_info->gl_ops.gl.p_glGetTexImage(target, level, format_gl->format, format_gl->type, mem); + checkGLcall("glGetTexImage"); + } + + if (format_gl->f.download) + { + format_gl->f.download(mem, data->addr, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, + wined3d_texture_get_level_width(texture, level), + wined3d_texture_get_level_height(texture, level), 1); + } + else if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) + { + const BYTE *src_data; + unsigned int h, y; + BYTE *dst_data; + /* + * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing + * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to + * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width. + * + * We're doing this... + * + * instead of boxing the texture : + * |<-texture width ->| -->pow2width| /\ + * |111111111111111111| | | + * |222 Texture 222222| boxed empty | texture height + * |3333 Data 33333333| | | + * |444444444444444444| | \/ + * ----------------------------------- | + * | boxed empty | boxed empty | pow2height + * | | | \/ + * ----------------------------------- + * + * + * we're repacking the data to the expected texture width + * + * |<-texture width ->| -->pow2width| /\ + * |111111111111111111222222222222222| | + * |222333333333333333333444444444444| texture height + * |444444 | | + * | | \/ + * | | | + * | empty | pow2height + * | | \/ + * ----------------------------------- + * + * == is the same as + * + * |<-texture width ->| /\ + * |111111111111111111| + * |222222222222222222|texture height + * |333333333333333333| + * |444444444444444444| \/ + * -------------------- + * + * This also means that any references to surface memory should work with the data as if it were a + * standard texture with a non-power2 width instead of a texture boxed up to be a power2 texture. + * + * internally the texture is still stored in a boxed format so any references to textureName will + * get a boxed texture with width pow2width and not a texture of width resource.width. */ + src_data = mem; + dst_data = data->addr; + TRACE("Repacking the surface data from pitch %u to pitch %u.\n", src_row_pitch, dst_row_pitch); + h = wined3d_texture_get_level_height(texture, level); + for (y = 0; y < h; ++y) + { + memcpy(dst_data, src_data, dst_row_pitch); + src_data += src_row_pitch; + dst_data += dst_row_pitch; + } + } + else if (temporary_mem) + { + unsigned int layer = sub_resource_idx / texture->level_count; + void *src_data = temporary_mem + layer * sub_resource->size; + if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); + checkGLcall("glBindBuffer"); + GL_EXTCALL(glBufferSubData(GL_PIXEL_PACK_BUFFER, 0, sub_resource->size, src_data)); + checkGLcall("glBufferSubData"); + } + else + { + memcpy(data->addr, src_data, sub_resource->size); + } + } + + if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); + checkGLcall("glBindBuffer"); + } + + heap_free(temporary_mem); +} + +/* This call just downloads data, the caller is responsible for binding the + * correct texture. Partial downloads are not supported. */ +/* Context activation is done by the caller. */ +void wined3d_texture_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, + struct wined3d_context *context, const struct wined3d_bo_address *data) +{ + const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_format_gl *format_gl; + unsigned int level; + GLenum target; + + format_gl = wined3d_format_gl(texture->resource.format); + target = wined3d_texture_get_sub_resource_target(texture, sub_resource_idx); + level = sub_resource_idx % texture->level_count; + + if (texture->resource.type == WINED3D_RTYPE_TEXTURE_2D + && (target == GL_TEXTURE_2D_ARRAY || format_gl->f.conv_byte_count + || texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED)) + { + /* 2D-specific special cases. */ + texture2d_download_data(texture, sub_resource_idx, context, data); + return; + } + + if (format_gl->f.conv_byte_count) + { + FIXME("Attempting to download a converted texture, type %s format %s.\n", + debug_d3dresourcetype(texture->resource.type), + debug_d3dformat(format_gl->f.id)); + return; + } + + if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); + checkGLcall("glBindBuffer"); + } + + if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) + { + TRACE("Downloading compressed texture %p, %u, level %u, format %#x, type %#x, data %p.\n", + texture, sub_resource_idx, level, format_gl->format, format_gl->type, data->addr); + + GL_EXTCALL(glGetCompressedTexImage(target, level, data->addr)); + checkGLcall("glGetCompressedTexImage"); + } + else + { + TRACE("Downloading texture %p, %u, level %u, format %#x, type %#x, data %p.\n", + texture, sub_resource_idx, level, format_gl->format, format_gl->type, data->addr); + + gl_info->gl_ops.gl.p_glGetTexImage(target, level, format_gl->format, format_gl->type, data->addr); + checkGLcall("glGetTexImage"); + } + + if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); + checkGLcall("glBindBuffer"); + } +} + /* Context activation is done by the caller. Context may be NULL in ddraw-only mode. */ static BOOL texture2d_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location) @@ -2441,38 +2726,6 @@ static const struct wined3d_resource_ops texture_resource_ops = }; /* Context activation is done by the caller. */ -static void texture1d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, - const struct wined3d_context *context, const struct wined3d_bo_address *data) -{ - const struct wined3d_gl_info *gl_info = context->gl_info; - const struct wined3d_format_gl *format_gl; - - format_gl = wined3d_format_gl(texture->resource.format); - if (format_gl->f.conv_byte_count) - { - FIXME("Attempting to download a converted texture, format %s.\n", - debug_d3dformat(format_gl->f.id)); - return; - } - - if (data->buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); - checkGLcall("glBindBuffer"); - } - - gl_info->gl_ops.gl.p_glGetTexImage(texture->target, sub_resource_idx, - format_gl->format, format_gl->type, data->addr); - checkGLcall("glGetTexImage"); - - if (data->buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); - checkGLcall("glBindBuffer"); - } -} - -/* Context activation is done by the caller. */ static BOOL texture1d_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location) { @@ -2532,7 +2785,7 @@ static BOOL texture1d_load_location(struct wined3d_texture *texture, unsigned in else wined3d_texture_bind_and_dirtify(texture, context, TRUE); - texture1d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); ++texture->download_count; } else @@ -2553,7 +2806,7 @@ static BOOL texture1d_load_location(struct wined3d_texture *texture, unsigned in else wined3d_texture_bind_and_dirtify(texture, context, TRUE); - texture1d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); } else { @@ -2914,38 +3167,6 @@ static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struc } /* Context activation is done by the caller. */ -static void texture3d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, - const struct wined3d_context *context, const struct wined3d_bo_address *data) -{ - const struct wined3d_gl_info *gl_info = context->gl_info; - const struct wined3d_format_gl *format_gl; - - format_gl = wined3d_format_gl(texture->resource.format); - if (format_gl->f.conv_byte_count) - { - FIXME("Attempting to download a converted volume, format %s.\n", - debug_d3dformat(format_gl->f.id)); - return; - } - - if (data->buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); - checkGLcall("glBindBuffer"); - } - - gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_3D, sub_resource_idx, - format_gl->format, format_gl->type, data->addr); - checkGLcall("glGetTexImage"); - - if (data->buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); - checkGLcall("glBindBuffer"); - } -} - -/* Context activation is done by the caller. */ static void texture3d_srgb_transfer(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, BOOL dest_is_srgb) { @@ -2968,7 +3189,7 @@ static void texture3d_srgb_transfer(struct wined3d_texture *texture, unsigned in wined3d_texture_get_pitch(texture, sub_resource_idx, &row_pitch, &slice_pitch); wined3d_texture_get_level_box(texture, sub_resource_idx % texture->level_count, &src_box); wined3d_texture_bind_and_dirtify(texture, context, !dest_is_srgb); - texture3d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); wined3d_texture_bind_and_dirtify(texture, context, dest_is_srgb); wined3d_texture_upload_data(texture, sub_resource_idx, context, texture->resource.format, &src_box, wined3d_const_bo_address(&data), row_pitch, slice_pitch, 0, 0, 0, FALSE); @@ -3041,7 +3262,7 @@ static BOOL texture3d_load_location(struct wined3d_texture *texture, unsigned in else wined3d_texture_bind_and_dirtify(texture, context, TRUE); - texture3d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); ++texture->download_count; } else @@ -3062,7 +3283,7 @@ static BOOL texture3d_load_location(struct wined3d_texture *texture, unsigned in else wined3d_texture_bind_and_dirtify(texture, context, TRUE); - texture3d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); } else { diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 8cfa4c3..7d35e55 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -3348,6 +3348,8 @@ void wined3d_texture_bind_and_dirtify(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN; HRESULT wined3d_texture_check_box_dimensions(const struct wined3d_texture *texture, unsigned int level, const struct wined3d_box *box) DECLSPEC_HIDDEN; +void wined3d_texture_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, + struct wined3d_context *context, const struct wined3d_bo_address *data) DECLSPEC_HIDDEN; GLenum wined3d_texture_get_gl_buffer(const struct wined3d_texture *texture) DECLSPEC_HIDDEN; void wined3d_texture_get_memory(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_bo_address *data, DWORD locations) DECLSPEC_HIDDEN; -- 2.7.4

3 8

[PATCH] ucrtbase: add version resource
by Louis Lenders 03 Oct '18

03 Oct '18

fix https://bugs.winehq.org/show_bug.cgi?id=45928 Signed-off-by: Louis Lenders <xerox.xerox2000x(a)gmail.com> --- dlls/ucrtbase/Makefile.in | 2 ++ dlls/ucrtbase/version.rc | 26 ++++++++++++++++++++++++++ 2 files changed, 28 insertions(+) create mode 100644 dlls/ucrtbase/version.rc diff --git a/dlls/ucrtbase/Makefile.in b/dlls/ucrtbase/Makefile.in index d44b17a2dd..23d8292a53 100644 --- a/dlls/ucrtbase/Makefile.in +++ b/dlls/ucrtbase/Makefile.in @@ -33,3 +33,5 @@ C_SRCS = \ time.c \ undname.c \ wcs.c + +RC_SRCS = version.rc diff --git a/dlls/ucrtbase/version.rc b/dlls/ucrtbase/version.rc new file mode 100644 index 0000000000..f034bc39ef --- /dev/null +++ b/dlls/ucrtbase/version.rc @@ -0,0 +1,26 @@ +/* + * Copyright 2018 Louis Lenders + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define WINE_FILEDESCRIPTION_STR "Wine runtime library" +#define WINE_FILENAME_STR "ucrtbase.dll" +#define WINE_FILEVERSION 10,0,14393,2247 +#define WINE_FILEVERSION_STR "10.0.14393.2247" +#define WINE_PRODUCTVERSION 10,0,14393,2247 +#define WINE_PRODUCTVERSION_STR "10.0.14393.2247" + +#include "wine/wine_common_ver.rc" -- 2.17.1

2 1

[PATCH] wined3d: Unify the texture download functions.
by Henri Verbeet 03 Oct '18

03 Oct '18

From: Andrew Wesie <awesie(a)gmail.com> Signed-off-by: Andrew Wesie <awesie(a)gmail.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/surface.c | 233 +------------------------- dlls/wined3d/texture.c | 363 +++++++++++++++++++++++++++++++++-------- dlls/wined3d/wined3d_private.h | 2 + 3 files changed, 299 insertions(+), 299 deletions(-) diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 8b69720693e..494217726a5 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -342,235 +342,6 @@ static BOOL fbo_blitter_supported(enum wined3d_blit_op blit_op, const struct win return TRUE; } -/* This call just downloads data, the caller is responsible for binding the - * correct texture. */ -/* Context activation is done by the caller. */ -static void texture2d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, - const struct wined3d_context *context, DWORD dst_location) -{ - const struct wined3d_gl_info *gl_info = context->gl_info; - struct wined3d_texture_sub_resource *sub_resource; - unsigned int dst_row_pitch, dst_slice_pitch; - unsigned int src_row_pitch, src_slice_pitch; - const struct wined3d_format_gl *format_gl; - struct wined3d_bo_address data; - BYTE *temporary_mem = NULL; - unsigned int level; - GLenum target; - void *mem; - - format_gl = wined3d_format_gl(texture->resource.format); - - /* Only support read back of converted P8 textures. */ - if (texture->flags & WINED3D_TEXTURE_CONVERTED && format_gl->f.id != WINED3DFMT_P8_UINT && !format_gl->f.download) - { - ERR("Trying to read back converted texture %p, %u with format %s.\n", - texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); - return; - } - - sub_resource = &texture->sub_resources[sub_resource_idx]; - target = wined3d_texture_get_sub_resource_target(texture, sub_resource_idx); - level = sub_resource_idx % texture->level_count; - - if (target == GL_TEXTURE_2D_ARRAY) - { - if (format_gl->f.download) - { - FIXME("Reading back converted array texture %p is not supported.\n", texture); - return; - } - - /* NP2 emulation is not allowed on array textures. */ - if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) - ERR("Array texture %p uses NP2 emulation.\n", texture); - - WARN_(d3d_perf)("Downloading all miplevel layers to get the data for a single sub-resource.\n"); - - if (!(temporary_mem = heap_calloc(texture->layer_count, sub_resource->size))) - { - ERR("Out of memory.\n"); - return; - } - } - - wined3d_texture_get_memory(texture, sub_resource_idx, &data, dst_location); - - if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) - { - if (format_gl->f.download) - { - FIXME("Reading back converted texture %p with NP2 emulation is not supported.\n", texture); - return; - } - - wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); - wined3d_format_calculate_pitch(&format_gl->f, texture->resource.device->surface_alignment, - wined3d_texture_get_level_pow2_width(texture, level), - wined3d_texture_get_level_pow2_height(texture, level), - &src_row_pitch, &src_slice_pitch); - if (!(temporary_mem = heap_alloc(src_slice_pitch))) - { - ERR("Out of memory.\n"); - return; - } - - if (data.buffer_object) - ERR("NP2 emulated texture uses PBO unexpectedly.\n"); - if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) - ERR("Unexpected compressed format for NP2 emulated texture.\n"); - } - - if (format_gl->f.download) - { - struct wined3d_format f; - - if (data.buffer_object) - ERR("Converted texture %p uses PBO unexpectedly.\n", texture); - - WARN_(d3d_perf)("Downloading converted texture %p, %u with format %s.\n", - texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); - - f = format_gl->f; - f.byte_count = format_gl->f.conv_byte_count; - wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); - wined3d_format_calculate_pitch(&f, texture->resource.device->surface_alignment, - wined3d_texture_get_level_width(texture, level), - wined3d_texture_get_level_height(texture, level), - &src_row_pitch, &src_slice_pitch); - - if (!(temporary_mem = heap_alloc(src_slice_pitch))) - { - ERR("Failed to allocate memory.\n"); - return; - } - } - - if (temporary_mem) - { - mem = temporary_mem; - } - else if (data.buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data.buffer_object)); - checkGLcall("glBindBuffer"); - mem = data.addr; - } - else - { - mem = data.addr; - } - - if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) - { - TRACE("Downloading compressed texture %p, %u, level %u, format %#x, type %#x, data %p.\n", - texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); - - GL_EXTCALL(glGetCompressedTexImage(target, level, mem)); - checkGLcall("glGetCompressedTexImage"); - } - else - { - TRACE("Downloading texture %p, %u, level %u, format %#x, type %#x, data %p.\n", - texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); - - gl_info->gl_ops.gl.p_glGetTexImage(target, level, format_gl->format, format_gl->type, mem); - checkGLcall("glGetTexImage"); - } - - if (format_gl->f.download) - { - format_gl->f.download(mem, data.addr, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, - wined3d_texture_get_level_width(texture, level), - wined3d_texture_get_level_height(texture, level), 1); - } - else if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) - { - const BYTE *src_data; - unsigned int h, y; - BYTE *dst_data; - /* - * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing - * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to - * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width. - * - * We're doing this... - * - * instead of boxing the texture : - * |<-texture width ->| -->pow2width| /\ - * |111111111111111111| | | - * |222 Texture 222222| boxed empty | texture height - * |3333 Data 33333333| | | - * |444444444444444444| | \/ - * ----------------------------------- | - * | boxed empty | boxed empty | pow2height - * | | | \/ - * ----------------------------------- - * - * - * we're repacking the data to the expected texture width - * - * |<-texture width ->| -->pow2width| /\ - * |111111111111111111222222222222222| | - * |222333333333333333333444444444444| texture height - * |444444 | | - * | | \/ - * | | | - * | empty | pow2height - * | | \/ - * ----------------------------------- - * - * == is the same as - * - * |<-texture width ->| /\ - * |111111111111111111| - * |222222222222222222|texture height - * |333333333333333333| - * |444444444444444444| \/ - * -------------------- - * - * This also means that any references to surface memory should work with the data as if it were a - * standard texture with a non-power2 width instead of a texture boxed up to be a power2 texture. - * - * internally the texture is still stored in a boxed format so any references to textureName will - * get a boxed texture with width pow2width and not a texture of width resource.width. */ - src_data = mem; - dst_data = data.addr; - TRACE("Repacking the surface data from pitch %u to pitch %u.\n", src_row_pitch, dst_row_pitch); - h = wined3d_texture_get_level_height(texture, level); - for (y = 0; y < h; ++y) - { - memcpy(dst_data, src_data, dst_row_pitch); - src_data += src_row_pitch; - dst_data += dst_row_pitch; - } - } - else if (temporary_mem) - { - unsigned int layer = sub_resource_idx / texture->level_count; - void *src_data = temporary_mem + layer * sub_resource->size; - if (data.buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data.buffer_object)); - checkGLcall("glBindBuffer"); - GL_EXTCALL(glBufferSubData(GL_PIXEL_PACK_BUFFER, 0, sub_resource->size, src_data)); - checkGLcall("glBufferSubData"); - } - else - { - memcpy(data.addr, src_data, sub_resource->size); - } - } - - if (data.buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); - checkGLcall("glBindBuffer"); - } - - heap_free(temporary_mem); -} - /* See also float_16_to_32() in wined3d_private.h */ static inline unsigned short float_32_to_16(const float *in) { @@ -1666,9 +1437,11 @@ BOOL texture2d_load_sysmem(struct wined3d_texture *texture, unsigned int sub_res /* Download the sub-resource to system memory. */ if (sub_resource->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB)) { + struct wined3d_bo_address data; wined3d_texture_bind_and_dirtify(texture, context, !(sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)); - texture2d_download_data(texture, sub_resource_idx, context, dst_location); + wined3d_texture_get_memory(texture, sub_resource_idx, &data, dst_location); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); ++texture->download_count; return TRUE; } diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 282c428c071..0b11c94d5b5 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -2140,6 +2140,295 @@ void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int s } } +static void texture2d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, + struct wined3d_context *context, const struct wined3d_bo_address *data) +{ + const struct wined3d_gl_info *gl_info = context->gl_info; + struct wined3d_texture_sub_resource *sub_resource; + unsigned int dst_row_pitch, dst_slice_pitch; + unsigned int src_row_pitch, src_slice_pitch; + const struct wined3d_format_gl *format_gl; + BYTE *temporary_mem = NULL; + unsigned int level; + GLenum target; + void *mem; + + format_gl = wined3d_format_gl(texture->resource.format); + + /* Only support read back of converted P8 textures. */ + if (texture->flags & WINED3D_TEXTURE_CONVERTED && format_gl->f.id != WINED3DFMT_P8_UINT && !format_gl->f.download) + { + ERR("Trying to read back converted texture %p, %u with format %s.\n", + texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); + return; + } + + sub_resource = &texture->sub_resources[sub_resource_idx]; + target = wined3d_texture_get_sub_resource_target(texture, sub_resource_idx); + level = sub_resource_idx % texture->level_count; + + if (target == GL_TEXTURE_2D_ARRAY) + { + if (format_gl->f.download) + { + FIXME("Reading back converted array texture %p is not supported.\n", texture); + return; + } + + /* NP2 emulation is not allowed on array textures. */ + if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) + ERR("Array texture %p uses NP2 emulation.\n", texture); + + WARN_(d3d_perf)("Downloading all miplevel layers to get the data for a single sub-resource.\n"); + + if (!(temporary_mem = heap_calloc(texture->layer_count, sub_resource->size))) + { + ERR("Out of memory.\n"); + return; + } + } + + if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) + { + if (format_gl->f.download) + { + FIXME("Reading back converted texture %p with NP2 emulation is not supported.\n", texture); + return; + } + + wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); + wined3d_format_calculate_pitch(&format_gl->f, texture->resource.device->surface_alignment, + wined3d_texture_get_level_pow2_width(texture, level), + wined3d_texture_get_level_pow2_height(texture, level), + &src_row_pitch, &src_slice_pitch); + if (!(temporary_mem = heap_alloc(src_slice_pitch))) + { + ERR("Out of memory.\n"); + return; + } + + if (data->buffer_object) + ERR("NP2 emulated texture uses PBO unexpectedly.\n"); + if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) + ERR("Unexpected compressed format for NP2 emulated texture.\n"); + } + + if (format_gl->f.download) + { + struct wined3d_format f; + + if (data->buffer_object) + ERR("Converted texture %p uses PBO unexpectedly.\n", texture); + + WARN_(d3d_perf)("Downloading converted texture %p, %u with format %s.\n", + texture, sub_resource_idx, debug_d3dformat(format_gl->f.id)); + + f = format_gl->f; + f.byte_count = format_gl->f.conv_byte_count; + wined3d_texture_get_pitch(texture, level, &dst_row_pitch, &dst_slice_pitch); + wined3d_format_calculate_pitch(&f, texture->resource.device->surface_alignment, + wined3d_texture_get_level_width(texture, level), + wined3d_texture_get_level_height(texture, level), + &src_row_pitch, &src_slice_pitch); + + if (!(temporary_mem = heap_alloc(src_slice_pitch))) + { + ERR("Failed to allocate memory.\n"); + return; + } + } + + if (temporary_mem) + { + mem = temporary_mem; + } + else if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); + checkGLcall("glBindBuffer"); + mem = data->addr; + } + else + { + mem = data->addr; + } + + if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) + { + TRACE("Downloading compressed texture %p, %u, level %u, format %#x, type %#x, data %p.\n", + texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); + + GL_EXTCALL(glGetCompressedTexImage(target, level, mem)); + checkGLcall("glGetCompressedTexImage"); + } + else + { + TRACE("Downloading texture %p, %u, level %u, format %#x, type %#x, data %p.\n", + texture, sub_resource_idx, level, format_gl->format, format_gl->type, mem); + + gl_info->gl_ops.gl.p_glGetTexImage(target, level, format_gl->format, format_gl->type, mem); + checkGLcall("glGetTexImage"); + } + + if (format_gl->f.download) + { + format_gl->f.download(mem, data->addr, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, + wined3d_texture_get_level_width(texture, level), + wined3d_texture_get_level_height(texture, level), 1); + } + else if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED) + { + const BYTE *src_data; + unsigned int h, y; + BYTE *dst_data; + /* Some games (e.g. Warhammer 40,000) don't properly handle texture + * pitches, preventing us from using the texture pitch to box NPOT + * textures. Instead, we repack the texture's CPU copy so that its + * pitch equals bpp * width instead of bpp * pow2width. + * + * Instead of boxing the texture: + * + * │<── texture width ──>│ pow2 width ──>│ + * ├─────────────────────┼───────────────┼─ + * │111111111111111111111│ │ʌ + * │222222222222222222222│ ││ + * │333333333333333333333│ padding │texture height + * │444444444444444444444│ ││ + * │555555555555555555555│ │v + * ├─────────────────────┘ ├─ + * │ │pow2 height + * │ padding padding ││ + * │ │v + * └─────────────────────────────────────┴─ + * + * we're repacking the data to the expected texture width + * + * │<── texture width ──>│ pow2 width ──>│ + * ├─────────────────────┴───────────────┼─ + * │1111111111111111111112222222222222222│ʌ + * │2222233333333333333333333344444444444││ + * │4444444444555555555555555555555 │texture height + * │ ││ + * │ padding padding │v + * │ ├─ + * │ │pow2 height + * │ padding padding ││ + * │ │v + * └─────────────────────────────────────┴─ + * + * == is the same as + * + * │<── texture width ──>│ + * ├─────────────────────┼─ + * │111111111111111111111│ʌ + * │222222222222222222222││ + * │333333333333333333333│texture height + * │444444444444444444444││ + * │555555555555555555555│v + * └─────────────────────┴─ + * + * This also means that any references to surface memory should work + * with the data as if it were a standard texture with a NPOT width + * instead of a texture boxed up to be a power-of-two texture. */ + src_data = mem; + dst_data = data->addr; + TRACE("Repacking the surface data from pitch %u to pitch %u.\n", src_row_pitch, dst_row_pitch); + h = wined3d_texture_get_level_height(texture, level); + for (y = 0; y < h; ++y) + { + memcpy(dst_data, src_data, dst_row_pitch); + src_data += src_row_pitch; + dst_data += dst_row_pitch; + } + } + else if (temporary_mem) + { + unsigned int layer = sub_resource_idx / texture->level_count; + void *src_data = temporary_mem + layer * sub_resource->size; + if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); + checkGLcall("glBindBuffer"); + GL_EXTCALL(glBufferSubData(GL_PIXEL_PACK_BUFFER, 0, sub_resource->size, src_data)); + checkGLcall("glBufferSubData"); + } + else + { + memcpy(data->addr, src_data, sub_resource->size); + } + } + + if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); + checkGLcall("glBindBuffer"); + } + + heap_free(temporary_mem); +} + +/* This call just downloads data, the caller is responsible for binding the + * correct texture. Partial downloads are not supported. */ +/* Context activation is done by the caller. */ +void wined3d_texture_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, + struct wined3d_context *context, const struct wined3d_bo_address *data) +{ + const struct wined3d_gl_info *gl_info = context->gl_info; + const struct wined3d_format_gl *format_gl; + unsigned int level; + GLenum target; + + format_gl = wined3d_format_gl(texture->resource.format); + target = wined3d_texture_get_sub_resource_target(texture, sub_resource_idx); + level = sub_resource_idx % texture->level_count; + + if (texture->resource.type == WINED3D_RTYPE_TEXTURE_2D + && (target == GL_TEXTURE_2D_ARRAY || format_gl->f.conv_byte_count + || texture->flags & (WINED3D_TEXTURE_CONVERTED | WINED3D_TEXTURE_COND_NP2_EMULATED))) + { + /* 2D-specific special cases. */ + texture2d_download_data(texture, sub_resource_idx, context, data); + return; + } + + if (format_gl->f.conv_byte_count) + { + FIXME("Attempting to download a converted texture, type %s format %s.\n", + debug_d3dresourcetype(texture->resource.type), + debug_d3dformat(format_gl->f.id)); + return; + } + + if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); + checkGLcall("glBindBuffer"); + } + + if (texture->resource.format_flags & WINED3DFMT_FLAG_COMPRESSED) + { + TRACE("Downloading compressed texture %p, %u, level %u, format %#x, type %#x, data %p.\n", + texture, sub_resource_idx, level, format_gl->format, format_gl->type, data->addr); + + GL_EXTCALL(glGetCompressedTexImage(target, level, data->addr)); + checkGLcall("glGetCompressedTexImage"); + } + else + { + TRACE("Downloading texture %p, %u, level %u, format %#x, type %#x, data %p.\n", + texture, sub_resource_idx, level, format_gl->format, format_gl->type, data->addr); + + gl_info->gl_ops.gl.p_glGetTexImage(target, level, format_gl->format, format_gl->type, data->addr); + checkGLcall("glGetTexImage"); + } + + if (data->buffer_object) + { + GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); + checkGLcall("glBindBuffer"); + } +} + /* Context activation is done by the caller. Context may be NULL in ddraw-only mode. */ static BOOL texture2d_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location) @@ -2445,38 +2734,6 @@ static const struct wined3d_resource_ops texture_resource_ops = }; /* Context activation is done by the caller. */ -static void texture1d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, - const struct wined3d_context *context, const struct wined3d_bo_address *data) -{ - const struct wined3d_gl_info *gl_info = context->gl_info; - const struct wined3d_format_gl *format_gl; - - format_gl = wined3d_format_gl(texture->resource.format); - if (format_gl->f.conv_byte_count) - { - FIXME("Attempting to download a converted texture, format %s.\n", - debug_d3dformat(format_gl->f.id)); - return; - } - - if (data->buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); - checkGLcall("glBindBuffer"); - } - - gl_info->gl_ops.gl.p_glGetTexImage(texture->target, sub_resource_idx, - format_gl->format, format_gl->type, data->addr); - checkGLcall("glGetTexImage"); - - if (data->buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); - checkGLcall("glBindBuffer"); - } -} - -/* Context activation is done by the caller. */ static BOOL texture1d_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location) { @@ -2536,7 +2793,7 @@ static BOOL texture1d_load_location(struct wined3d_texture *texture, unsigned in else wined3d_texture_bind_and_dirtify(texture, context, TRUE); - texture1d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); ++texture->download_count; } else @@ -2557,7 +2814,7 @@ static BOOL texture1d_load_location(struct wined3d_texture *texture, unsigned in else wined3d_texture_bind_and_dirtify(texture, context, TRUE); - texture1d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); } else { @@ -2918,38 +3175,6 @@ static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struc } /* Context activation is done by the caller. */ -static void texture3d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, - const struct wined3d_context *context, const struct wined3d_bo_address *data) -{ - const struct wined3d_gl_info *gl_info = context->gl_info; - const struct wined3d_format_gl *format_gl; - - format_gl = wined3d_format_gl(texture->resource.format); - if (format_gl->f.conv_byte_count) - { - FIXME("Attempting to download a converted volume, format %s.\n", - debug_d3dformat(format_gl->f.id)); - return; - } - - if (data->buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object)); - checkGLcall("glBindBuffer"); - } - - gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_3D, sub_resource_idx, - format_gl->format, format_gl->type, data->addr); - checkGLcall("glGetTexImage"); - - if (data->buffer_object) - { - GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0)); - checkGLcall("glBindBuffer"); - } -} - -/* Context activation is done by the caller. */ static void texture3d_srgb_transfer(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, BOOL dest_is_srgb) { @@ -2972,7 +3197,7 @@ static void texture3d_srgb_transfer(struct wined3d_texture *texture, unsigned in wined3d_texture_get_pitch(texture, sub_resource_idx, &row_pitch, &slice_pitch); wined3d_texture_get_level_box(texture, sub_resource_idx % texture->level_count, &src_box); wined3d_texture_bind_and_dirtify(texture, context, !dest_is_srgb); - texture3d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); wined3d_texture_bind_and_dirtify(texture, context, dest_is_srgb); wined3d_texture_upload_data(texture, sub_resource_idx, context, texture->resource.format, &src_box, wined3d_const_bo_address(&data), row_pitch, slice_pitch, 0, 0, 0, FALSE); @@ -3045,7 +3270,7 @@ static BOOL texture3d_load_location(struct wined3d_texture *texture, unsigned in else wined3d_texture_bind_and_dirtify(texture, context, TRUE); - texture3d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); ++texture->download_count; } else @@ -3066,7 +3291,7 @@ static BOOL texture3d_load_location(struct wined3d_texture *texture, unsigned in else wined3d_texture_bind_and_dirtify(texture, context, TRUE); - texture3d_download_data(texture, sub_resource_idx, context, &data); + wined3d_texture_download_data(texture, sub_resource_idx, context, &data); } else { diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 5f7f6fd3979..a2dcbb06fd7 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -3350,6 +3350,8 @@ void wined3d_texture_bind_and_dirtify(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN; HRESULT wined3d_texture_check_box_dimensions(const struct wined3d_texture *texture, unsigned int level, const struct wined3d_box *box) DECLSPEC_HIDDEN; +void wined3d_texture_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx, + struct wined3d_context *context, const struct wined3d_bo_address *data) DECLSPEC_HIDDEN; GLenum wined3d_texture_get_gl_buffer(const struct wined3d_texture *texture) DECLSPEC_HIDDEN; void wined3d_texture_get_memory(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_bo_address *data, DWORD locations) DECLSPEC_HIDDEN; -- 2.11.0

1 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel