wine-devel October 2018

wine-devel@winehq.org

60 participants
608 discussions

[PATCH 2/4] crypt32: Make it clear that LocalAlloc should return a pointer.
by Dmitry Timoshkov 25 Oct '18

25 Oct '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/crypt32/decode.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/crypt32/decode.c b/dlls/crypt32/decode.c index 080feeca0a..b1778720cd 100644 --- a/dlls/crypt32/decode.c +++ b/dlls/crypt32/decode.c @@ -215,7 +215,7 @@ static BOOL CRYPT_DecodeEnsureSpace(DWORD dwFlags, if (pDecodePara && pDecodePara->pfnAlloc) *(BYTE **)pvStructInfo = pDecodePara->pfnAlloc(bytesNeeded); else - *(BYTE **)pvStructInfo = LocalAlloc(0, bytesNeeded); + *(BYTE **)pvStructInfo = LocalAlloc(LPTR, bytesNeeded); if (!*(BYTE **)pvStructInfo) ret = FALSE; else -- 2.17.1

1 0

[PATCH 1/4] crypt32/tests: Get rid of win9x specific checks.
by Dmitry Timoshkov 25 Oct '18

25 Oct '18

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/crypt32/tests/cert.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/dlls/crypt32/tests/cert.c b/dlls/crypt32/tests/cert.c index bb0cc525e7..d6c249c6f3 100644 --- a/dlls/crypt32/tests/cert.c +++ b/dlls/crypt32/tests/cert.c @@ -3232,15 +3232,11 @@ static void testComparePublicKeyInfo(void) ret = CertComparePublicKeyInfo(0, &info1, &info2); ok(!ret, "CertComparePublicKeyInfo: as raw binary: keys should be unequal\n"); ret = CertComparePublicKeyInfo(X509_ASN_ENCODING, &info1, &info2); - ok(ret || - broken(!ret), /* win9x */ - "CertComparePublicKeyInfo: as ASN.1 encoded: keys should be equal\n"); + ok(ret, "CertComparePublicKeyInfo: as ASN.1 encoded: keys should be equal\n"); info1.PublicKey.cUnusedBits = 1; info2.PublicKey.cUnusedBits = 5; ret = CertComparePublicKeyInfo(X509_ASN_ENCODING, &info1, &info2); - ok(ret || - broken(!ret), /* win9x */ - "CertComparePublicKeyInfo: ASN.1 encoding should ignore cUnusedBits\n"); + ok(ret, "CertComparePublicKeyInfo: ASN.1 encoding should ignore cUnusedBits\n"); info1.PublicKey.cUnusedBits = 0; info2.PublicKey.cUnusedBits = 0; info1.PublicKey.cbData--; /* kill one byte, make ASN.1 encoded data invalid */ -- 2.17.1

1 0

[PATCH vkd3d 07/10] vkd3d: Trace VK_EXT_vertex_attribute_divisor features.
by Józef Kucia 25 Oct '18

25 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 87 +++++++++++++++++++++++++++++++++----- libs/vkd3d/vkd3d_private.h | 2 + 2 files changed, 78 insertions(+), 11 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index be8c15e394cb..9ae65f023a0e 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -41,6 +41,26 @@ static const void *vkd3d_find_struct_(const struct vkd3d_struct *chain, return NULL; } +struct vk_struct +{ + VkStructureType sType; + struct vk_struct *pNext; +}; + +#define vk_find_struct(c, t) vk_find_struct_(c, VK_STRUCTURE_TYPE_##t) +static const void *vk_find_struct_(struct vk_struct *chain, VkStructureType sType) +{ + while (chain) + { + if (chain->sType == sType) + return chain; + + chain = chain->pNext; + } + + return NULL; +} + struct vkd3d_optional_extension_info { const char *extension_name; @@ -68,6 +88,19 @@ static const struct vkd3d_optional_extension_info optional_device_extensions[] = offsetof(struct vkd3d_vulkan_info, EXT_vertex_attribute_divisor)}, }; +static unsigned int get_spec_version(const VkExtensionProperties *extensions, + unsigned int count, const char *extension_name) +{ + unsigned int i; + + for (i = 0; i < count; ++i) + { + if (!strcmp(extensions[i].extensionName, extension_name)) + return extensions[i].specVersion; + } + return 0; +} + static bool is_extension_disabled(const char *extension_name) { const char *disabled_extensions; @@ -705,6 +738,7 @@ static void vkd3d_trace_physical_device(VkPhysicalDevice device, static void vkd3d_trace_physical_device_features(const VkPhysicalDeviceFeatures2KHR *features2) { + const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *divisor_features; const VkPhysicalDeviceFeatures *features = &features2->features; TRACE("Device features:\n"); @@ -763,16 +797,26 @@ static void vkd3d_trace_physical_device_features(const VkPhysicalDeviceFeatures2 TRACE(" sparseResidencyAliased: %#x.\n", features->sparseResidencyAliased); TRACE(" variableMultisampleRate: %#x.\n", features->variableMultisampleRate); TRACE(" inheritedQueries: %#x.\n", features->inheritedQueries); + + divisor_features = vk_find_struct(features2->pNext, PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT); + if (divisor_features) + { + TRACE(" VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT:\n"); + TRACE(" vertexAttributeInstanceRateDivisor: %#x.\n", + divisor_features->vertexAttributeInstanceRateDivisor); + TRACE(" vertexAttributeInstanceRateZeroDivisor: %#x.\n", + divisor_features->vertexAttributeInstanceRateZeroDivisor); + } } -static void vkd3d_check_feature_level_11_requirements(const VkPhysicalDeviceLimits *limits, +static void vkd3d_check_feature_level_11_requirements(const struct vkd3d_vulkan_info *vk_info, const VkPhysicalDeviceFeatures *features) { #define CHECK_MIN_REQUIREMENT(name, value) \ - if (limits->name < value) \ + if (vk_info->device_limits.name < value) \ WARN(#name " does not meet feature level 11_0 requirements.\n"); #define CHECK_MAX_REQUIREMENT(name, value) \ - if (limits->name > value) \ + if (vk_info->device_limits.name > value) \ WARN(#name " does not meet feature level 11_0 requirements.\n"); #define CHECK_FEATURE(name) \ if (!features->name) \ @@ -807,6 +851,11 @@ static void vkd3d_check_feature_level_11_requirements(const VkPhysicalDeviceLimi CHECK_FEATURE(shaderClipDistance); CHECK_FEATURE(shaderCullDistance); + if (!vk_info->EXT_vertex_attribute_divisor) + WARN("Vertex attribute instance rate divisor is not supported.\n"); + else if (!vk_info->vertex_attrib_zero_divisor) + WARN("Vertex attribute instance rate zero divisor is not supported.\n"); + #undef CHECK_MIN_REQUIREMENT #undef CHECK_MAX_REQUIREMENT #undef CHECK_FEATURE @@ -814,10 +863,12 @@ static void vkd3d_check_feature_level_11_requirements(const VkPhysicalDeviceLimi static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, const struct vkd3d_device_create_info *create_info, - const VkPhysicalDeviceFeatures *features, uint32_t *device_extension_count) + VkPhysicalDeviceFeatures2KHR *features2, uint32_t *device_extension_count) { const struct vkd3d_vk_instance_procs *vk_procs = &device->vkd3d_instance->vk_procs; + const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *divisor_features; VkPhysicalDevice physical_device = device->vk_physical_device; + VkPhysicalDeviceFeatures *features = &features2->features; struct vkd3d_vulkan_info *vulkan_info = &device->vk_info; VkPhysicalDeviceProperties device_properties; VkExtensionProperties *vk_extensions; @@ -826,12 +877,12 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, *device_extension_count = 0; + vkd3d_trace_physical_device_features(features2); + VK_CALL(vkGetPhysicalDeviceProperties(physical_device, &device_properties)); vulkan_info->device_limits = device_properties.limits; vulkan_info->sparse_properties = device_properties.sparseProperties; - vkd3d_check_feature_level_11_requirements(&device_properties.limits, features); - device->feature_options.DoublePrecisionFloatShaderOps = features->shaderFloat64; device->feature_options.OutputMergerLogicOp = features->logicOp; /* SPV_KHR_16bit_storage */ @@ -895,6 +946,24 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, NULL, 0, NULL, vulkan_info, "device"); vkd3d_free(vk_extensions); + + divisor_features = vk_find_struct(features2->pNext, PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT); + if (get_spec_version(vk_extensions, count, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME) >= 3 + && divisor_features) + { + if (!divisor_features->vertexAttributeInstanceRateDivisor) + vulkan_info->EXT_vertex_attribute_divisor = false; + vulkan_info->vertex_attrib_zero_divisor = divisor_features->vertexAttributeInstanceRateZeroDivisor; + } + else + { + vulkan_info->vertex_attrib_zero_divisor = false; + } + + vkd3d_check_feature_level_11_requirements(vulkan_info, features); + + features->shaderTessellationAndGeometryPointSize = VK_FALSE; + return S_OK; } @@ -1098,13 +1167,9 @@ static HRESULT vkd3d_create_vk_device(struct d3d12_device *device, else VK_CALL(vkGetPhysicalDeviceFeatures(physical_device, &features2.features)); - vkd3d_trace_physical_device_features(&features2); - - if (FAILED(hr = vkd3d_init_device_caps(device, create_info, &features2.features, &extension_count))) + if (FAILED(hr = vkd3d_init_device_caps(device, create_info, &features2, &extension_count))) goto done; - features2.features.shaderTessellationAndGeometryPointSize = VK_FALSE; - if (!(extensions = vkd3d_calloc(extension_count, sizeof(*extensions)))) { hr = E_OUTOFMEMORY; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index e4e1e118cc0a..3f539805785e 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -85,6 +85,8 @@ struct vkd3d_vulkan_info bool KHR_push_descriptor; bool EXT_vertex_attribute_divisor; + bool vertex_attrib_zero_divisor; + VkPhysicalDeviceLimits device_limits; VkPhysicalDeviceSparseProperties sparse_properties; }; -- 2.18.1

2 3

[PATCH vkd3d 08/10] vkd3d: Trace VK_EXT_vertex_attribute_divisor properties.
by Józef Kucia 25 Oct '18

25 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 35 +++++++++++++++++++++++++++++------ libs/vkd3d/vulkan_procs.h | 1 + 2 files changed, 30 insertions(+), 6 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 9ae65f023a0e..abb991942199 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -575,7 +575,6 @@ static void vkd3d_trace_physical_device(VkPhysicalDevice device, VkPhysicalDeviceMemoryProperties memory_properties; VkPhysicalDeviceProperties device_properties; VkQueueFamilyProperties *queue_properties; - VkPhysicalDeviceLimits *limits; unsigned int i, j; uint32_t count; @@ -616,8 +615,13 @@ static void vkd3d_trace_physical_device(VkPhysicalDevice device, TRACE(" Memory type [%u]: flags %s.\n", j, debug_vk_memory_property_flags(type->propertyFlags)); } } +} + +static void vkd3d_trace_physical_device_limits(const VkPhysicalDeviceProperties2KHR *properties2) +{ + const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *divisor_properties; + const VkPhysicalDeviceLimits *limits = &properties2->properties.limits; - limits = &device_properties.limits; TRACE("Device limits:\n"); TRACE(" maxImageDimension1D: %u.\n", limits->maxImageDimension1D); TRACE(" maxImageDimension2D: %u.\n", limits->maxImageDimension2D); @@ -734,6 +738,14 @@ static void vkd3d_trace_physical_device(VkPhysicalDevice device, TRACE(" optimalBufferCopyOffsetAlignment: %#"PRIx64".\n", limits->optimalBufferCopyOffsetAlignment); TRACE(" optimalBufferCopyRowPitchAlignment: %#"PRIx64".\n", limits->optimalBufferCopyRowPitchAlignment); TRACE(" nonCoherentAtomSize: %#"PRIx64".\n", limits->nonCoherentAtomSize); + + divisor_properties + = vk_find_struct(properties2->pNext, PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT); + if (divisor_properties) + { + TRACE(" VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT:\n"); + TRACE(" maxVertexAttribDivisor: %u.\n", divisor_properties->maxVertexAttribDivisor); + } } static void vkd3d_trace_physical_device_features(const VkPhysicalDeviceFeatures2KHR *features2) @@ -866,11 +878,12 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, VkPhysicalDeviceFeatures2KHR *features2, uint32_t *device_extension_count) { const struct vkd3d_vk_instance_procs *vk_procs = &device->vkd3d_instance->vk_procs; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT vertex_divisor_properties; const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *divisor_features; VkPhysicalDevice physical_device = device->vk_physical_device; VkPhysicalDeviceFeatures *features = &features2->features; struct vkd3d_vulkan_info *vulkan_info = &device->vk_info; - VkPhysicalDeviceProperties device_properties; + VkPhysicalDeviceProperties2KHR device_properties2; VkExtensionProperties *vk_extensions; uint32_t count; VkResult vr; @@ -879,9 +892,19 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, vkd3d_trace_physical_device_features(features2); - VK_CALL(vkGetPhysicalDeviceProperties(physical_device, &device_properties)); - vulkan_info->device_limits = device_properties.limits; - vulkan_info->sparse_properties = device_properties.sparseProperties; + memset(&vertex_divisor_properties, 0, sizeof(vertex_divisor_properties)); + vertex_divisor_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; + device_properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; + device_properties2.pNext = &vertex_divisor_properties; + if (vulkan_info->KHR_get_physical_device_properties2) + VK_CALL(vkGetPhysicalDeviceProperties2KHR(physical_device, &device_properties2)); + else + VK_CALL(vkGetPhysicalDeviceProperties(physical_device, &device_properties2.properties)); + + vkd3d_trace_physical_device_limits(&device_properties2); + + vulkan_info->device_limits = device_properties2.properties.limits; + vulkan_info->sparse_properties = device_properties2.properties.sparseProperties; device->feature_options.DoublePrecisionFloatShaderOps = features->shaderFloat64; device->feature_options.OutputMergerLogicOp = features->logicOp; diff --git a/libs/vkd3d/vulkan_procs.h b/libs/vkd3d/vulkan_procs.h index e14121c1a76b..ac03b3f89ff8 100644 --- a/libs/vkd3d/vulkan_procs.h +++ b/libs/vkd3d/vulkan_procs.h @@ -48,6 +48,7 @@ VK_INSTANCE_PFN(vkGetPhysicalDeviceQueueFamilyProperties) VK_INSTANCE_PFN(vkGetPhysicalDeviceSparseImageFormatProperties) /* VK_KHR_get_physical_device_properties2 */ VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceFeatures2KHR) +VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceProperties2KHR) /* VK_EXT_debug_report */ VK_INSTANCE_EXT_PFN(vkCreateDebugReportCallbackEXT) VK_INSTANCE_EXT_PFN(vkDestroyDebugReportCallbackEXT) -- 2.18.1

2 1

[PATCH vkd3d 06/10] vkd3d: Do not trace features for all available physical devices.
by Józef Kucia 25 Oct '18

25 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 119 +++++++++++++++++++++++--------------------- 1 file changed, 62 insertions(+), 57 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index fca446160db8..be8c15e394cb 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -542,7 +542,6 @@ static void vkd3d_trace_physical_device(VkPhysicalDevice device, VkPhysicalDeviceMemoryProperties memory_properties; VkPhysicalDeviceProperties device_properties; VkQueueFamilyProperties *queue_properties; - VkPhysicalDeviceFeatures features; VkPhysicalDeviceLimits *limits; unsigned int i, j; uint32_t count; @@ -702,64 +701,68 @@ static void vkd3d_trace_physical_device(VkPhysicalDevice device, TRACE(" optimalBufferCopyOffsetAlignment: %#"PRIx64".\n", limits->optimalBufferCopyOffsetAlignment); TRACE(" optimalBufferCopyRowPitchAlignment: %#"PRIx64".\n", limits->optimalBufferCopyRowPitchAlignment); TRACE(" nonCoherentAtomSize: %#"PRIx64".\n", limits->nonCoherentAtomSize); +} + +static void vkd3d_trace_physical_device_features(const VkPhysicalDeviceFeatures2KHR *features2) +{ + const VkPhysicalDeviceFeatures *features = &features2->features; - VK_CALL(vkGetPhysicalDeviceFeatures(device, &features)); TRACE("Device features:\n"); - TRACE(" robustBufferAccess: %#x.\n", features.robustBufferAccess); - TRACE(" fullDrawIndexUint32: %#x.\n", features.fullDrawIndexUint32); - TRACE(" imageCubeArray: %#x.\n", features.imageCubeArray); - TRACE(" independentBlend: %#x.\n", features.independentBlend); - TRACE(" geometryShader: %#x.\n", features.geometryShader); - TRACE(" tessellationShader: %#x.\n", features.tessellationShader); - TRACE(" sampleRateShading: %#x.\n", features.sampleRateShading); - TRACE(" dualSrcBlend: %#x.\n", features.dualSrcBlend); - TRACE(" logicOp: %#x.\n", features.logicOp); - TRACE(" multiDrawIndirect: %#x.\n", features.multiDrawIndirect); - TRACE(" drawIndirectFirstInstance: %#x.\n", features.drawIndirectFirstInstance); - TRACE(" depthClamp: %#x.\n", features.depthClamp); - TRACE(" depthBiasClamp: %#x.\n", features.depthBiasClamp); - TRACE(" fillModeNonSolid: %#x.\n", features.fillModeNonSolid); - TRACE(" depthBounds: %#x.\n", features.depthBounds); - TRACE(" wideLines: %#x.\n", features.wideLines); - TRACE(" largePoints: %#x.\n", features.largePoints); - TRACE(" alphaToOne: %#x.\n", features.alphaToOne); - TRACE(" multiViewport: %#x.\n", features.multiViewport); - TRACE(" samplerAnisotropy: %#x.\n", features.samplerAnisotropy); - TRACE(" textureCompressionETC2: %#x.\n", features.textureCompressionETC2); - TRACE(" textureCompressionASTC_LDR: %#x.\n", features.textureCompressionASTC_LDR); - TRACE(" textureCompressionBC: %#x.\n", features.textureCompressionBC); - TRACE(" occlusionQueryPrecise: %#x.\n", features.occlusionQueryPrecise); - TRACE(" pipelineStatisticsQuery: %#x.\n", features.pipelineStatisticsQuery); - TRACE(" vertexOipelineStoresAndAtomics: %#x.\n", features.vertexPipelineStoresAndAtomics); - TRACE(" fragmentStoresAndAtomics: %#x.\n", features.fragmentStoresAndAtomics); - TRACE(" shaderTessellationAndGeometryPointSize: %#x.\n", features.shaderTessellationAndGeometryPointSize); - TRACE(" shaderImageGatherExtended: %#x.\n", features.shaderImageGatherExtended); - TRACE(" shaderStorageImageExtendedFormats: %#x.\n", features.shaderStorageImageExtendedFormats); - TRACE(" shaderStorageImageMultisample: %#x.\n", features.shaderStorageImageMultisample); - TRACE(" shaderStorageImageReadWithoutFormat: %#x.\n", features.shaderStorageImageReadWithoutFormat); - TRACE(" shaderStorageImageWriteWithoutFormat: %#x.\n", features.shaderStorageImageWriteWithoutFormat); - TRACE(" shaderUniformBufferArrayDynamicIndexing: %#x.\n", features.shaderUniformBufferArrayDynamicIndexing); - TRACE(" shaderSampledImageArrayDynamicIndexing: %#x.\n", features.shaderSampledImageArrayDynamicIndexing); - TRACE(" shaderStorageBufferArrayDynamicIndexing: %#x.\n", features.shaderStorageBufferArrayDynamicIndexing); - TRACE(" shaderStorageImageArrayDynamicIndexing: %#x.\n", features.shaderStorageImageArrayDynamicIndexing); - TRACE(" shaderClipDistance: %#x.\n", features.shaderClipDistance); - TRACE(" shaderCullDistance: %#x.\n", features.shaderCullDistance); - TRACE(" shaderFloat64: %#x.\n", features.shaderFloat64); - TRACE(" shaderInt64: %#x.\n", features.shaderInt64); - TRACE(" shaderInt16: %#x.\n", features.shaderInt16); - TRACE(" shaderResourceResidency: %#x.\n", features.shaderResourceResidency); - TRACE(" shaderResourceMinLod: %#x.\n", features.shaderResourceMinLod); - TRACE(" sparseBinding: %#x.\n", features.sparseBinding); - TRACE(" sparseResidencyBuffer: %#x.\n", features.sparseResidencyBuffer); - TRACE(" sparseResidencyImage2D: %#x.\n", features.sparseResidencyImage2D); - TRACE(" sparseResidencyImage3D: %#x.\n", features.sparseResidencyImage3D); - TRACE(" sparseResidency2Samples: %#x.\n", features.sparseResidency2Samples); - TRACE(" sparseResidency4Samples: %#x.\n", features.sparseResidency4Samples); - TRACE(" sparseResidency8Samples: %#x.\n", features.sparseResidency8Samples); - TRACE(" sparseResidency16Samples: %#x.\n", features.sparseResidency16Samples); - TRACE(" sparseResidencyAliased: %#x.\n", features.sparseResidencyAliased); - TRACE(" variableMultisampleRate: %#x.\n", features.variableMultisampleRate); - TRACE(" inheritedQueries: %#x.\n", features.inheritedQueries); + TRACE(" robustBufferAccess: %#x.\n", features->robustBufferAccess); + TRACE(" fullDrawIndexUint32: %#x.\n", features->fullDrawIndexUint32); + TRACE(" imageCubeArray: %#x.\n", features->imageCubeArray); + TRACE(" independentBlend: %#x.\n", features->independentBlend); + TRACE(" geometryShader: %#x.\n", features->geometryShader); + TRACE(" tessellationShader: %#x.\n", features->tessellationShader); + TRACE(" sampleRateShading: %#x.\n", features->sampleRateShading); + TRACE(" dualSrcBlend: %#x.\n", features->dualSrcBlend); + TRACE(" logicOp: %#x.\n", features->logicOp); + TRACE(" multiDrawIndirect: %#x.\n", features->multiDrawIndirect); + TRACE(" drawIndirectFirstInstance: %#x.\n", features->drawIndirectFirstInstance); + TRACE(" depthClamp: %#x.\n", features->depthClamp); + TRACE(" depthBiasClamp: %#x.\n", features->depthBiasClamp); + TRACE(" fillModeNonSolid: %#x.\n", features->fillModeNonSolid); + TRACE(" depthBounds: %#x.\n", features->depthBounds); + TRACE(" wideLines: %#x.\n", features->wideLines); + TRACE(" largePoints: %#x.\n", features->largePoints); + TRACE(" alphaToOne: %#x.\n", features->alphaToOne); + TRACE(" multiViewport: %#x.\n", features->multiViewport); + TRACE(" samplerAnisotropy: %#x.\n", features->samplerAnisotropy); + TRACE(" textureCompressionETC2: %#x.\n", features->textureCompressionETC2); + TRACE(" textureCompressionASTC_LDR: %#x.\n", features->textureCompressionASTC_LDR); + TRACE(" textureCompressionBC: %#x.\n", features->textureCompressionBC); + TRACE(" occlusionQueryPrecise: %#x.\n", features->occlusionQueryPrecise); + TRACE(" pipelineStatisticsQuery: %#x.\n", features->pipelineStatisticsQuery); + TRACE(" vertexOipelineStoresAndAtomics: %#x.\n", features->vertexPipelineStoresAndAtomics); + TRACE(" fragmentStoresAndAtomics: %#x.\n", features->fragmentStoresAndAtomics); + TRACE(" shaderTessellationAndGeometryPointSize: %#x.\n", features->shaderTessellationAndGeometryPointSize); + TRACE(" shaderImageGatherExtended: %#x.\n", features->shaderImageGatherExtended); + TRACE(" shaderStorageImageExtendedFormats: %#x.\n", features->shaderStorageImageExtendedFormats); + TRACE(" shaderStorageImageMultisample: %#x.\n", features->shaderStorageImageMultisample); + TRACE(" shaderStorageImageReadWithoutFormat: %#x.\n", features->shaderStorageImageReadWithoutFormat); + TRACE(" shaderStorageImageWriteWithoutFormat: %#x.\n", features->shaderStorageImageWriteWithoutFormat); + TRACE(" shaderUniformBufferArrayDynamicIndexing: %#x.\n", features->shaderUniformBufferArrayDynamicIndexing); + TRACE(" shaderSampledImageArrayDynamicIndexing: %#x.\n", features->shaderSampledImageArrayDynamicIndexing); + TRACE(" shaderStorageBufferArrayDynamicIndexing: %#x.\n", features->shaderStorageBufferArrayDynamicIndexing); + TRACE(" shaderStorageImageArrayDynamicIndexing: %#x.\n", features->shaderStorageImageArrayDynamicIndexing); + TRACE(" shaderClipDistance: %#x.\n", features->shaderClipDistance); + TRACE(" shaderCullDistance: %#x.\n", features->shaderCullDistance); + TRACE(" shaderFloat64: %#x.\n", features->shaderFloat64); + TRACE(" shaderInt64: %#x.\n", features->shaderInt64); + TRACE(" shaderInt16: %#x.\n", features->shaderInt16); + TRACE(" shaderResourceResidency: %#x.\n", features->shaderResourceResidency); + TRACE(" shaderResourceMinLod: %#x.\n", features->shaderResourceMinLod); + TRACE(" sparseBinding: %#x.\n", features->sparseBinding); + TRACE(" sparseResidencyBuffer: %#x.\n", features->sparseResidencyBuffer); + TRACE(" sparseResidencyImage2D: %#x.\n", features->sparseResidencyImage2D); + TRACE(" sparseResidencyImage3D: %#x.\n", features->sparseResidencyImage3D); + TRACE(" sparseResidency2Samples: %#x.\n", features->sparseResidency2Samples); + TRACE(" sparseResidency4Samples: %#x.\n", features->sparseResidency4Samples); + TRACE(" sparseResidency8Samples: %#x.\n", features->sparseResidency8Samples); + TRACE(" sparseResidency16Samples: %#x.\n", features->sparseResidency16Samples); + TRACE(" sparseResidencyAliased: %#x.\n", features->sparseResidencyAliased); + TRACE(" variableMultisampleRate: %#x.\n", features->variableMultisampleRate); + TRACE(" inheritedQueries: %#x.\n", features->inheritedQueries); } static void vkd3d_check_feature_level_11_requirements(const VkPhysicalDeviceLimits *limits, @@ -1095,6 +1098,8 @@ static HRESULT vkd3d_create_vk_device(struct d3d12_device *device, else VK_CALL(vkGetPhysicalDeviceFeatures(physical_device, &features2.features)); + vkd3d_trace_physical_device_features(&features2); + if (FAILED(hr = vkd3d_init_device_caps(device, create_info, &features2.features, &extension_count))) goto done; -- 2.18.1

2 1

[PATCH vkd3d 10/10] tests: Add test for instance data step rate.
by Józef Kucia 25 Oct '18

25 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 196 ++++++++++++++++++++++++++++++-------------------- 1 file changed, 119 insertions(+), 77 deletions(-) diff --git a/tests/d3d12.c b/tests/d3d12.c index 6801b3b80f3b..b9e4a7004837 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -17692,24 +17692,24 @@ static void test_instance_id(void) ID3D12GraphicsCommandList *command_list; D3D12_INPUT_LAYOUT_DESC input_layout; D3D12_CPU_DESCRIPTOR_HANDLE rtvs[2]; - D3D12_VERTEX_BUFFER_VIEW vbv[2]; + D3D12_VERTEX_BUFFER_VIEW vbv[3]; ID3D12Resource *argument_buffer; ID3D12Resource *render_target; struct test_context_desc desc; struct test_context context; struct resource_readback rb; ID3D12CommandQueue *queue; - ID3D12Resource *vb[2]; - unsigned int i; + ID3D12Resource *vb[3]; + unsigned int i, j; HRESULT hr; - static const D3D12_INPUT_ELEMENT_DESC layout_desc[] = + D3D12_INPUT_ELEMENT_DESC layout_desc[] = { {"position", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, {"color", 0, DXGI_FORMAT_R8_UNORM, 1, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, 1}, - {"v_offset", 0, DXGI_FORMAT_R32_FLOAT, 1, D3D12_APPEND_ALIGNED_ELEMENT, + {"v_offset", 0, DXGI_FORMAT_R32_FLOAT, 2, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, 1}, }; static const DWORD vs_code[] = @@ -17799,22 +17799,29 @@ static void test_instance_id(void) {-0.75f, -1.0f, 0.0f, 1.0f}, {-0.75f, 0.0f, 0.0f, 1.0f}, }; - static const struct + static const BYTE stream1[] = { - BYTE color; - float v_offset; - } - stream1[] = + 0xf0, + 0x80, + 0x10, + 0x40, + + 0xaa, + 0xbb, + 0xcc, + 0x90, + }; + static const float stream2[] = { - {0xf0, 0.00f}, - {0x80, 0.25f}, - {0x10, 0.50f}, - {0x40, 0.75f}, + 0.00f, + 0.25f, + 0.50f, + 0.75f, - {0xaa, 1.00f}, - {0xbb, 1.25f}, - {0xcc, 1.50f}, - {0x90, 1.75f}, + 1.00f, + 1.25f, + 1.50f, + 1.75f, }; static const D3D12_DRAW_ARGUMENTS argument_data[] = { @@ -17822,33 +17829,48 @@ static void test_instance_id(void) {4, 4, 4, 4}, }; static const struct + { + unsigned int color_step_rate; + unsigned int expected_colors[16]; + } + tests[] = + { + {0, {0xfff0f0f0, 0xfff0f0f0, 0xfff0f0f0, 0xfff0f0f0, 0xffaaaaaa, 0xffaaaaaa, 0xffaaaaaa, 0xffaaaaaa, + 0xfff0f0f0, 0xfff0f0f0, 0xfff0f0f0, 0xfff0f0f0, 0xffaaaaaa, 0xffaaaaaa, 0xffaaaaaa, 0xffaaaaaa}}, + {1, {0xfff0f0f0, 0xff808080, 0xff101010, 0xff404040, 0xffaaaaaa, 0xffbbbbbb, 0xffcccccc, 0xff909090, + 0xfff0f0f0, 0xff808080, 0xff101010, 0xff404040, 0xffaaaaaa, 0xffbbbbbb, 0xffcccccc, 0xff909090}}, + {2, {0xfff0f0f0, 0xfff0f0f0, 0xff808080, 0xff808080, 0xffaaaaaa, 0xffaaaaaa, 0xffbbbbbb, 0xffbbbbbb, + 0xfff0f0f0, 0xfff0f0f0, 0xff808080, 0xff808080, 0xffaaaaaa, 0xffaaaaaa, 0xffbbbbbb, 0xffbbbbbb}}, + }; + static const struct { D3D12_BOX box; - unsigned int color; unsigned int instance_id; } expected_results[] = { - {{ 0, 0, 0, 10, 10, 1}, 0xfff0f0f0, 0}, - {{10, 0, 0, 20, 10, 1}, 0xff808080, 1}, - {{20, 0, 0, 30, 10, 1}, 0xff101010, 2}, - {{30, 0, 0, 40, 10, 1}, 0xff404040, 3}, - {{40, 0, 0, 50, 10, 1}, 0xffaaaaaa, 0}, - {{50, 0, 0, 60, 10, 1}, 0xffbbbbbb, 1}, - {{60, 0, 0, 70, 10, 1}, 0xffcccccc, 2}, - {{70, 0, 0, 80, 10, 1}, 0xff909090, 3}, + {{ 0, 0, 0, 10, 10, 1}, 0}, + {{10, 0, 0, 20, 10, 1}, 1}, + {{20, 0, 0, 30, 10, 1}, 2}, + {{30, 0, 0, 40, 10, 1}, 3}, + {{40, 0, 0, 50, 10, 1}, 0}, + {{50, 0, 0, 60, 10, 1}, 1}, + {{60, 0, 0, 70, 10, 1}, 2}, + {{70, 0, 0, 80, 10, 1}, 3}, /* indirect draws results */ - {{ 0, 10, 0, 10, 20, 1}, 0xfff0f0f0, 0}, - {{10, 10, 0, 20, 20, 1}, 0xff808080, 1}, - {{20, 10, 0, 30, 20, 1}, 0xff101010, 2}, - {{30, 10, 0, 40, 20, 1}, 0xff404040, 3}, - {{40, 10, 0, 50, 20, 1}, 0xffaaaaaa, 0}, - {{50, 10, 0, 60, 20, 1}, 0xffbbbbbb, 1}, - {{60, 10, 0, 70, 20, 1}, 0xffcccccc, 2}, - {{70, 10, 0, 80, 20, 1}, 0xff909090, 3}, + {{ 0, 10, 0, 10, 20, 1}, 0}, + {{10, 10, 0, 20, 20, 1}, 1}, + {{20, 10, 0, 30, 20, 1}, 2}, + {{30, 10, 0, 40, 20, 1}, 3}, + {{40, 10, 0, 50, 20, 1}, 0}, + {{50, 10, 0, 60, 20, 1}, 1}, + {{60, 10, 0, 70, 20, 1}, 2}, + {{70, 10, 0, 80, 20, 1}, 3}, }; static const float white[] = {1.0f, 1.0f, 1.0f, 1.0f}; + assert(ARRAY_SIZE(tests->expected_colors) == ARRAY_SIZE(expected_results)); + memset(&desc, 0, sizeof(desc)); desc.rt_width = 80; desc.rt_height = 20; @@ -17859,24 +17881,15 @@ static void test_instance_id(void) command_list = context.list; queue = context.queue; + context.root_signature = create_empty_root_signature(context.device, + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT); + rtvs[0] = context.rtv; rtvs[1] = get_cpu_rtv_handle(&context, context.rtv_heap, 1); desc.rt_format = DXGI_FORMAT_R32_UINT; create_render_target(&context, &desc, &render_target, &rtvs[1]); - context.root_signature = create_empty_root_signature(context.device, - D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT); - input_layout.pInputElementDescs = layout_desc; - input_layout.NumElements = ARRAY_SIZE(layout_desc); - init_pipeline_state_desc(&pso_desc, context.root_signature, 0, &vs, &ps, &input_layout); - pso_desc.NumRenderTargets = 2; - pso_desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; - pso_desc.RTVFormats[1] = DXGI_FORMAT_R32_UINT; - hr = ID3D12Device_CreateGraphicsPipelineState(context.device, &pso_desc, - &IID_ID3D12PipelineState, (void **)&context.pipeline_state); - ok(SUCCEEDED(hr), "Failed to create graphics pipeline state, hr %#x.\n", hr); - vb[0] = create_upload_buffer(context.device, sizeof(stream0), stream0); vbv[0].BufferLocation = ID3D12Resource_GetGPUVirtualAddress(vb[0]); vbv[0].StrideInBytes = sizeof(*stream0); @@ -17887,18 +17900,10 @@ static void test_instance_id(void) vbv[1].StrideInBytes = sizeof(*stream1); vbv[1].SizeInBytes = sizeof(stream1); - ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, rtvs[0], white, 0, NULL); - ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, rtvs[1], white, 0, NULL); - - ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 2, rtvs, FALSE, NULL); - ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); - ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); - ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); - ID3D12GraphicsCommandList_IASetVertexBuffers(command_list, 0, ARRAY_SIZE(vbv), vbv); - ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); - ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); - ID3D12GraphicsCommandList_DrawInstanced(command_list, 4, 4, 0, 0); - ID3D12GraphicsCommandList_DrawInstanced(command_list, 4, 4, 0, 4); + vb[2] = create_upload_buffer(context.device, sizeof(stream2), stream2); + vbv[2].BufferLocation = ID3D12Resource_GetGPUVirtualAddress(vb[2]); + vbv[2].StrideInBytes = sizeof(*stream2); + vbv[2].SizeInBytes = sizeof(stream2); argument_desc.Type = D3D12_INDIRECT_ARGUMENT_TYPE_DRAW; signature_desc.ByteStride = sizeof(D3D12_DRAW_ARGUMENTS); @@ -17907,31 +17912,68 @@ static void test_instance_id(void) signature_desc.NodeMask = 0; hr = ID3D12Device_CreateCommandSignature(context.device, &signature_desc, NULL, &IID_ID3D12CommandSignature, (void **)&command_signature); - ok(SUCCEEDED(hr), "Failed to create command signature, hr %#x.\n", hr); + ok(hr == S_OK, "Failed to create command signature, hr %#x.\n", hr); argument_buffer = create_upload_buffer(context.device, sizeof(argument_data), &argument_data); - ID3D12GraphicsCommandList_ExecuteIndirect(command_list, command_signature, - 2, argument_buffer, 0, NULL, 0); - transition_resource_state(command_list, context.render_target, - D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); - get_texture_readback_with_command_list(context.render_target, 0, &rb, queue, command_list); - for (i = 0; i < ARRAY_SIZE(expected_results); ++i) - check_readback_data_uint(&rb, &expected_results[i].box, expected_results[i].color, 1); - release_resource_readback(&rb); - reset_command_list(command_list, context.allocator); - transition_resource_state(command_list, render_target, - D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); - get_texture_readback_with_command_list(render_target, 0, &rb, queue, command_list); - for (i = 0; i < ARRAY_SIZE(expected_results); ++i) - check_readback_data_uint(&rb, &expected_results[i].box, expected_results[i].instance_id, 0); - release_resource_readback(&rb); + for (i = 0; i < ARRAY_SIZE(tests); ++i) + { + layout_desc[1].InstanceDataStepRate = tests[i].color_step_rate; + input_layout.pInputElementDescs = layout_desc; + input_layout.NumElements = ARRAY_SIZE(layout_desc); + init_pipeline_state_desc(&pso_desc, context.root_signature, 0, &vs, &ps, &input_layout); + pso_desc.NumRenderTargets = 2; + pso_desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; + pso_desc.RTVFormats[1] = DXGI_FORMAT_R32_UINT; + hr = ID3D12Device_CreateGraphicsPipelineState(context.device, &pso_desc, + &IID_ID3D12PipelineState, (void **)&context.pipeline_state); + ok(hr == S_OK, "Failed to create graphics pipeline state, hr %#x.\n", hr); + + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, rtvs[0], white, 0, NULL); + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, rtvs[1], white, 0, NULL); + + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 2, rtvs, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + ID3D12GraphicsCommandList_IASetVertexBuffers(command_list, 0, ARRAY_SIZE(vbv), vbv); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 4, 4, 0, 0); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 4, 4, 0, 4); + + ID3D12GraphicsCommandList_ExecuteIndirect(command_list, command_signature, + 2, argument_buffer, 0, NULL, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + get_texture_readback_with_command_list(context.render_target, 0, &rb, queue, command_list); + for (j = 0; j < ARRAY_SIZE(expected_results); ++j) + check_readback_data_uint(&rb, &expected_results[j].box, tests[i].expected_colors[j], 1); + release_resource_readback(&rb); + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + get_texture_readback_with_command_list(render_target, 0, &rb, queue, command_list); + for (j = 0; j < ARRAY_SIZE(expected_results); ++j) + check_readback_data_uint(&rb, &expected_results[j].box, expected_results[j].instance_id, 0); + release_resource_readback(&rb); + + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET); + transition_resource_state(command_list, render_target, + D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET); + + ID3D12PipelineState_Release(context.pipeline_state); + context.pipeline_state = NULL; + } ID3D12CommandSignature_Release(command_signature); ID3D12Resource_Release(argument_buffer); ID3D12Resource_Release(render_target); - ID3D12Resource_Release(vb[0]); - ID3D12Resource_Release(vb[1]); + for (i = 0; i < ARRAY_SIZE(vb); ++i) + ID3D12Resource_Release(vb[i]); destroy_test_context(&context); } -- 2.18.1

2 1

[PATCH vkd3d 09/10] vkd3d: Implement instance data step rate.
by Józef Kucia 25 Oct '18

25 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 1 + libs/vkd3d/state.c | 45 +++++++++++++++++++++++++++++++++----- libs/vkd3d/vkd3d_private.h | 4 +++- 3 files changed, 43 insertions(+), 7 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index abb991942199..7a7f7f36d187 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -905,6 +905,7 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, vulkan_info->device_limits = device_properties2.properties.limits; vulkan_info->sparse_properties = device_properties2.properties.sparseProperties; + vulkan_info->max_vertex_attrib_divisor = max(vertex_divisor_properties.maxVertexAttribDivisor, 1); device->feature_options.DoublePrecisionFloatShaderOps = features->shaderFloat64; device->feature_options.OutputMergerLogicOp = features->logicOp; diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index 0deea28edb6b..7e0b1eeea553 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -1866,7 +1866,10 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s unsigned int ps_output_swizzle[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT]; struct d3d12_graphics_pipeline_state *graphics = &state->u.graphics; const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + VkVertexInputBindingDivisorDescriptionEXT *binding_divisor; + const struct vkd3d_vulkan_info *vk_info = &device->vk_info; const struct vkd3d_shader_compile_arguments *compile_args; + uint32_t instance_divisors[D3D12_VS_INPUT_REGISTER_COUNT]; uint32_t aligned_offsets[D3D12_VS_INPUT_REGISTER_COUNT]; struct vkd3d_shader_compile_arguments ps_compile_args; const struct d3d12_root_signature *root_signature; @@ -1877,6 +1880,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s VkSampleCountFlagBits sample_count; const struct vkd3d_format *format; enum VkVertexInputRate input_rate; + unsigned int instance_divisor; unsigned int i, j; size_t rt_count; uint32_t mask; @@ -2106,6 +2110,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s if (FAILED(hr = compute_input_layout_offsets(&desc->InputLayout, aligned_offsets))) goto fail; + graphics->instance_divisor_count = 0; for (i = 0, j = 0, mask = 0; i < graphics->attribute_count; ++i) { const D3D12_INPUT_ELEMENT_DESC *e = &desc->InputLayout.pInputElementDescs[i]; @@ -2118,7 +2123,8 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s goto fail; } - if (e->InputSlot >= ARRAY_SIZE(graphics->input_rates)) + if (e->InputSlot >= ARRAY_SIZE(graphics->input_rates) + || e->InputSlot >= ARRAY_SIZE(instance_divisors)) { WARN("Invalid input slot %#x.\n", e->InputSlot); hr = E_INVALIDARG; @@ -2145,12 +2151,18 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s { case D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA: input_rate = VK_VERTEX_INPUT_RATE_VERTEX; + instance_divisor = 1; break; case D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA: - if (e->InstanceDataStepRate != 1) - FIXME("Ignoring step rate %#x on input element %u.\n", e->InstanceDataStepRate, i); input_rate = VK_VERTEX_INPUT_RATE_INSTANCE; + instance_divisor = e->InstanceDataStepRate; + if (instance_divisor > vk_info->max_vertex_attrib_divisor + || (!instance_divisor && !vk_info->vertex_attrib_zero_divisor)) + { + FIXME("Instance divisor %u not supported by Vulkan implementation.\n", instance_divisor); + instance_divisor = 1; + } break; default: @@ -2159,14 +2171,25 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s goto fail; } - if (mask & (1u << e->InputSlot) && graphics->input_rates[e->InputSlot] != input_rate) + if (mask & (1u << e->InputSlot) && (graphics->input_rates[e->InputSlot] != input_rate + || instance_divisors[e->InputSlot] != instance_divisor)) { - FIXME("Input slot class %#x on input element %u conflicts with earlier input slot class %#x.\n", - e->InputSlotClass, e->InputSlot, graphics->input_rates[e->InputSlot]); + FIXME("Input slot rate %#x, instance divisor %u on input element %u conflicts " + "with earlier input slot rate %#x, instance divisor %u.\n", + input_rate, instance_divisor, e->InputSlot, + graphics->input_rates[e->InputSlot], instance_divisors[e->InputSlot]); hr = E_INVALIDARG; goto fail; } + graphics->input_rates[e->InputSlot] = input_rate; + instance_divisors[e->InputSlot] = instance_divisor; + if (instance_divisor != 1 && !(mask & (1u << e->InputSlot))) + { + binding_divisor = &graphics->instance_divisors[graphics->instance_divisor_count++]; + binding_divisor->binding = e->InputSlot; + binding_divisor->divisor = instance_divisor; + } mask |= 1u << e->InputSlot; } graphics->attribute_count = j; @@ -2331,6 +2354,7 @@ VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_sta struct VkVertexInputBindingDescription bindings[D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT]; const struct vkd3d_vk_device_procs *vk_procs = &state->device->vk_procs; struct d3d12_graphics_pipeline_state *graphics = &state->u.graphics; + VkPipelineVertexInputDivisorStateCreateInfoEXT input_divisor_info; struct VkPipelineVertexInputStateCreateInfo input_desc; struct VkPipelineInputAssemblyStateCreateInfo ia_desc; struct VkPipelineColorBlendStateCreateInfo blend_desc; @@ -2414,6 +2438,15 @@ VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_sta input_desc.vertexAttributeDescriptionCount = graphics->attribute_count; input_desc.pVertexAttributeDescriptions = graphics->attributes; + if (graphics->instance_divisor_count) + { + input_desc.pNext = &input_divisor_info; + input_divisor_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT; + input_divisor_info.pNext = NULL; + input_divisor_info.vertexBindingDivisorCount = graphics->instance_divisor_count; + input_divisor_info.pVertexBindingDivisors = graphics->instance_divisors; + } + ia_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; ia_desc.pNext = NULL; ia_desc.flags = 0; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 3f539805785e..a2bf4048aebb 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -86,6 +86,7 @@ struct vkd3d_vulkan_info bool EXT_vertex_attribute_divisor; bool vertex_attrib_zero_divisor; + unsigned int max_vertex_attrib_divisor; VkPhysicalDeviceLimits device_limits; VkPhysicalDeviceSparseProperties sparse_properties; @@ -513,6 +514,8 @@ struct d3d12_graphics_pipeline_state struct VkVertexInputAttributeDescription attributes[D3D12_VS_INPUT_REGISTER_COUNT]; enum VkVertexInputRate input_rates[D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT]; + VkVertexInputBindingDivisorDescriptionEXT instance_divisors[D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT]; + size_t instance_divisor_count; size_t attribute_count; struct VkAttachmentDescription attachments[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT + 1]; @@ -767,7 +770,6 @@ struct d3d12_device struct vkd3d_fence_worker fence_worker; pthread_mutex_t pipeline_cache_mutex; - struct rb_tree pipeline_cache; VkPipelineCache vk_pipeline_cache; /* A sampler used for SpvOpImageFetch. */ -- 2.18.1

2 1

[PATCH vkd3d 04/10] tests: Add test for multisample rendering.
by Józef Kucia 25 Oct '18

25 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 177 +++++++++++++++++++++++++++++++++++++++ tests/vkd3d_d3d12_test.h | 5 +- 2 files changed, 180 insertions(+), 2 deletions(-) diff --git a/tests/d3d12.c b/tests/d3d12.c index f5104a5e1cd7..6801b3b80f3b 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -20605,6 +20605,182 @@ static void test_blend_factor(void) destroy_test_context(&context); } +static void test_multisample_rendering(void) +{ + static const float white[] = {1.0f, 1.0f, 1.0f, 1.0f}; + D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc; + ID3D12GraphicsCommandList *command_list; + ID3D12PipelineState *ms_pipeline_state; + D3D12_CPU_DESCRIPTOR_HANDLE ms_rtv; + ID3D12Resource *ms_render_target; + struct test_context_desc desc; + struct test_context context; + ID3D12DescriptorHeap *heap; + ID3D12CommandQueue *queue; + uint32_t sample; + unsigned int i; + HRESULT hr; + + static const DWORD ps_color_code[] = + { +#if 0 + float4 main(uint id : SV_SampleIndex) : SV_Target + { + switch (id) + { + case 0: return float4(1.0f, 0.0f, 0.0f, 1.0f); + case 1: return float4(0.0f, 1.0f, 0.0f, 1.0f); + case 2: return float4(0.0f, 0.0f, 1.0f, 1.0f); + default: return float4(0.0f, 0.0f, 0.0f, 1.0f); + } + } +#endif + 0x43425844, 0x94c35f48, 0x04c6b0f7, 0x407d8214, 0xc24f01e5, 0x00000001, 0x00000194, 0x00000003, + 0x0000002c, 0x00000064, 0x00000098, 0x4e475349, 0x00000030, 0x00000001, 0x00000008, 0x00000020, + 0x00000000, 0x0000000a, 0x00000001, 0x00000000, 0x00000101, 0x535f5653, 0x6c706d61, 0x646e4965, + 0xab007865, 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, + 0x00000003, 0x00000000, 0x0000000f, 0x545f5653, 0x65677261, 0xabab0074, 0x58454853, 0x000000f4, + 0x00000050, 0x0000003d, 0x0100086a, 0x04000863, 0x00101012, 0x00000000, 0x0000000a, 0x03000065, + 0x001020f2, 0x00000000, 0x0300004c, 0x0010100a, 0x00000000, 0x03000006, 0x00004001, 0x00000000, + 0x08000036, 0x001020f2, 0x00000000, 0x00004002, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, + 0x0100003e, 0x03000006, 0x00004001, 0x00000001, 0x08000036, 0x001020f2, 0x00000000, 0x00004002, + 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, 0x0100003e, 0x03000006, 0x00004001, 0x00000002, + 0x08000036, 0x001020f2, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, + 0x0100003e, 0x0100000a, 0x08000036, 0x001020f2, 0x00000000, 0x00004002, 0x00000000, 0x00000000, + 0x00000000, 0x3f800000, 0x0100003e, 0x01000017, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps_color = {ps_color_code, sizeof(ps_color_code)}; + static const DWORD ps_resolve_code[] = + { +#if 0 + Texture2DMS<float4> t; + + uint sample; + uint rt_size; + + float4 main(float4 position : SV_Position) : SV_Target + { + float3 p; + t.GetDimensions(p.x, p.y, p.z); + p *= float3(position.x / rt_size, position.y / rt_size, 0); + return t.Load((int2)p.xy, sample); + } +#endif + 0x43425844, 0x68a4590b, 0xc1ec3070, 0x1b957c43, 0x0c080741, 0x00000001, 0x000001c8, 0x00000003, + 0x0000002c, 0x00000060, 0x00000094, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, + 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000030f, 0x505f5653, 0x7469736f, 0x006e6f69, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, + 0x00000000, 0x0000000f, 0x545f5653, 0x65677261, 0xabab0074, 0x58454853, 0x0000012c, 0x00000050, + 0x0000004b, 0x0100086a, 0x04000059, 0x00208e46, 0x00000000, 0x00000001, 0x04002058, 0x00107000, + 0x00000000, 0x00005555, 0x04002064, 0x00101032, 0x00000000, 0x00000001, 0x03000065, 0x001020f2, + 0x00000000, 0x02000068, 0x00000001, 0x06000056, 0x00100012, 0x00000000, 0x0020801a, 0x00000000, + 0x00000000, 0x0700000e, 0x00100032, 0x00000000, 0x00101046, 0x00000000, 0x00100006, 0x00000000, + 0x8900003d, 0x80000102, 0x00155543, 0x001000c2, 0x00000000, 0x00004001, 0x00000000, 0x001074e6, + 0x00000000, 0x07000038, 0x00100032, 0x00000000, 0x00100046, 0x00000000, 0x00100ae6, 0x00000000, + 0x0500001b, 0x00100032, 0x00000000, 0x00100046, 0x00000000, 0x08000036, 0x001000c2, 0x00000000, + 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8c00002e, 0x80000102, 0x00155543, + 0x001020f2, 0x00000000, 0x00100e46, 0x00000000, 0x00107e46, 0x00000000, 0x0020800a, 0x00000000, + 0x00000000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps_resolve = {ps_resolve_code, sizeof(ps_resolve_code)}; + static const unsigned int expected_colors[] = {0xff0000ff, 0xff00ff00, 0xffff0000, 0xff000000}; + + if (use_warp_device) + { + skip("Sample shading tests fail on WARP.\n"); + return; + } + + memset(&desc, 0, sizeof(desc)); + desc.rt_width = desc.rt_height = 32; + desc.rt_descriptor_count = 2; + desc.no_root_signature = true; + if (!init_test_context(&context, &desc)) + return; + command_list = context.list; + queue = context.queue; + + context.root_signature = create_texture_root_signature(context.device, + D3D12_SHADER_VISIBILITY_PIXEL, 2, 0); + + init_pipeline_state_desc(&pso_desc, context.root_signature, + context.render_target_desc.Format, NULL, &ps_resolve, NULL); + hr = ID3D12Device_CreateGraphicsPipelineState(context.device, &pso_desc, + &IID_ID3D12PipelineState, (void **)&context.pipeline_state); + ok(hr == S_OK, "Failed to create pipeline, hr %#x.\n", hr); + + pso_desc.PS = ps_color; + pso_desc.SampleDesc.Count = 4; + hr = ID3D12Device_CreateGraphicsPipelineState(context.device, &pso_desc, + &IID_ID3D12PipelineState, (void **)&ms_pipeline_state); + ok(hr == S_OK, "Failed to create pipeline, hr %#x.\n", hr); + + ms_rtv = get_cpu_rtv_handle(&context, context.rtv_heap, 1); + desc.sample_desc.Count = 4; + create_render_target(&context, &desc, &ms_render_target, &ms_rtv); + + heap = create_gpu_descriptor_heap(context.device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1); + ID3D12Device_CreateShaderResourceView(context.device, ms_render_target, NULL, + get_cpu_descriptor_handle(&context, heap, 0)); + + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, context.rtv, white, 0, NULL); + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, ms_rtv, white, 0, NULL); + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &ms_rtv, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, ms_pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_SetDescriptorHeaps(command_list, 1, &heap); + ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, 0, + get_gpu_descriptor_handle(&context, heap, 0)); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 3, 1, 0, 0); + + transition_resource_state(command_list, ms_render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_RESOLVE_SOURCE); + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_RESOLVE_DEST); + ID3D12GraphicsCommandList_ResolveSubresource(command_list, + context.render_target, 0, ms_render_target, 0, context.render_target_desc.Format); + transition_resource_state(command_list, ms_render_target, + D3D12_RESOURCE_STATE_RESOLVE_SOURCE, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RESOLVE_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_uint(context.render_target, 0, queue, command_list, 0xff404040, 2); + + for (i = 0; i < ARRAY_SIZE(expected_colors); ++i) + { + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET); + + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, context.rtv, white, 0, NULL); + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &context.rtv, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_SetDescriptorHeaps(command_list, 1, &heap); + ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, 0, + get_gpu_descriptor_handle(&context, heap, 0)); + ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstants(command_list, 1, 1, &desc.rt_width, 1); + + sample = i; + ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstants(command_list, 1, 1, &sample, 0); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 3, 1, 0, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_uint(context.render_target, 0, queue, command_list, expected_colors[i], 0); + } + + ID3D12DescriptorHeap_Release(heap); + ID3D12Resource_Release(ms_render_target); + ID3D12PipelineState_Release(ms_pipeline_state); + destroy_test_context(&context); +} + START_TEST(d3d12) { bool enable_debug_layer = false; @@ -20731,4 +20907,5 @@ START_TEST(d3d12) run_test(test_suballocate_small_textures); run_test(test_command_list_initial_pipeline_state); run_test(test_blend_factor); + run_test(test_multisample_rendering); } diff --git a/tests/vkd3d_d3d12_test.h b/tests/vkd3d_d3d12_test.h index b7fd5ebcc4eb..596a9b8b272f 100644 --- a/tests/vkd3d_d3d12_test.h +++ b/tests/vkd3d_d3d12_test.h @@ -513,6 +513,7 @@ struct test_context_desc { unsigned int rt_width, rt_height, rt_array_size; DXGI_FORMAT rt_format; + DXGI_SAMPLE_DESC sample_desc; unsigned int rt_descriptor_count; unsigned int root_signature_flags; bool no_render_target; @@ -562,8 +563,8 @@ static void create_render_target_(unsigned int line, struct test_context *contex resource_desc.DepthOrArraySize = desc && desc->rt_array_size ? desc->rt_array_size : 1; resource_desc.MipLevels = 1; resource_desc.Format = desc && desc->rt_format ? desc->rt_format : DXGI_FORMAT_R8G8B8A8_UNORM; - resource_desc.SampleDesc.Count = 1; - resource_desc.SampleDesc.Quality = 0; + resource_desc.SampleDesc.Count = desc && desc->sample_desc.Count ? desc->sample_desc.Count : 1; + resource_desc.SampleDesc.Quality = desc ? desc->sample_desc.Quality : 0; resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; resource_desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; clear_value.Format = resource_desc.Format; -- 2.18.1

2 1

[PATCH vkd3d 02/10] vkd3d: Set the numer of samples for clears.
by Józef Kucia 25 Oct '18

25 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 4 ++-- libs/vkd3d/resource.c | 2 ++ libs/vkd3d/vkd3d_private.h | 2 ++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 7e7b3ee5d9c7..542c484f4bd4 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -3677,7 +3677,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_ClearDepthStencilView(ID3D12Gra attachment_desc.flags = 0; attachment_desc.format = dsv_desc->format; - attachment_desc.samples = VK_SAMPLE_COUNT_1_BIT; + attachment_desc.samples = dsv_desc->sample_count; if (flags & D3D12_CLEAR_FLAG_DEPTH) { attachment_desc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; @@ -3725,7 +3725,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_ClearRenderTargetView(ID3D12Gra attachment_desc.flags = 0; attachment_desc.format = rtv_desc->format; - attachment_desc.samples = VK_SAMPLE_COUNT_1_BIT; + attachment_desc.samples = rtv_desc->sample_count; attachment_desc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; attachment_desc.storeOp = VK_ATTACHMENT_STORE_OP_STORE; attachment_desc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 55abd50c2c67..cb1427f94a4a 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -2058,6 +2058,7 @@ void d3d12_rtv_desc_create_rtv(struct d3d12_rtv_desc *rtv_desc, struct d3d12_dev rtv_desc->magic = VKD3D_DESCRIPTOR_MAGIC_RTV; rtv_desc->format = vkd3d_desc.format->vk_format; + rtv_desc->sample_count = vk_samples_from_dxgi_sample_desc(&resource->desc.SampleDesc); rtv_desc->width = d3d12_resource_desc_get_width(&resource->desc, vkd3d_desc.miplevel_idx); rtv_desc->height = d3d12_resource_desc_get_height(&resource->desc, vkd3d_desc.miplevel_idx); rtv_desc->layer_count = vkd3d_desc.layer_count; @@ -2130,6 +2131,7 @@ void d3d12_dsv_desc_create_dsv(struct d3d12_dsv_desc *dsv_desc, struct d3d12_dev dsv_desc->magic = VKD3D_DESCRIPTOR_MAGIC_DSV; dsv_desc->format = vkd3d_desc.format->vk_format; + dsv_desc->sample_count = vk_samples_from_dxgi_sample_desc(&resource->desc.SampleDesc); dsv_desc->width = d3d12_resource_desc_get_width(&resource->desc, vkd3d_desc.miplevel_idx); dsv_desc->height = d3d12_resource_desc_get_height(&resource->desc, vkd3d_desc.miplevel_idx); dsv_desc->layer_count = vkd3d_desc.layer_count; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 5f5798852290..4be160b89b9c 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -337,6 +337,7 @@ struct d3d12_rtv_desc { uint32_t magic; VkFormat format; + VkSampleCountFlagBits sample_count; uint64_t width; unsigned int height; unsigned int layer_count; @@ -356,6 +357,7 @@ struct d3d12_dsv_desc { uint32_t magic; VkFormat format; + VkSampleCountFlagBits sample_count; uint64_t width; unsigned int height; unsigned int layer_count; -- 2.18.1

2 1

[PATCH vkd3d 03/10] vkd3d: Implement d3d12_command_list_ResolveSubresource().
by Józef Kucia 25 Oct '18

25 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 70 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 65 insertions(+), 5 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 542c484f4bd4..5ccf492e663d 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -1409,6 +1409,7 @@ static bool vk_barrier_parameters_from_d3d12_resource_state(unsigned int state, break; case D3D12_RESOURCE_STATE_COPY_SOURCE: + case D3D12_RESOURCE_STATE_RESOLVE_SOURCE: *access_mask = 0; *stage_flags = 0; if (image_layout) @@ -2463,6 +2464,8 @@ static HRESULT d3d12_command_list_allocate_transfer_buffer(struct d3d12_command_ /* In Vulkan, each depth/stencil format is only compatible with itself. * This means that we are not allowed to copy texture regions directly between * depth/stencil and color formats. + * + * FIXME: Implement color <-> depth/stencil blits in shaders. */ static void d3d12_command_list_copy_incompatible_texture_region(struct d3d12_command_list *list, struct d3d12_resource *dst_resource, unsigned int dst_sub_resource_idx, @@ -2736,12 +2739,69 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTiles(ID3D12GraphicsCommand } static void STDMETHODCALLTYPE d3d12_command_list_ResolveSubresource(ID3D12GraphicsCommandList *iface, - ID3D12Resource *dst_resource, UINT dst_sub_resource, - ID3D12Resource *src_resource, UINT src_sub_resource, DXGI_FORMAT format) + ID3D12Resource *dst, UINT dst_sub_resource_idx, + ID3D12Resource *src, UINT src_sub_resource_idx, DXGI_FORMAT format) { - FIXME("iface %p, dst_resource %p, dst_sub_resource %u, src_resource %p, src_sub_resource %u, " - "format %#x stub!\n", - iface, dst_resource, dst_sub_resource, src_resource, src_sub_resource, format); + struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList(iface); + struct d3d12_resource *dst_resource, *src_resource; + const struct vkd3d_format *src_format, *dst_format; + const struct vkd3d_vk_device_procs *vk_procs; + VkImageResolve vk_image_resolve; + + TRACE("iface %p, dst_resource %p, dst_sub_resource_idx %u, src_resource %p, src_sub_resource_idx %u, " + "format %#x.\n", iface, dst, dst_sub_resource_idx, src, src_sub_resource_idx, format); + + vk_procs = &list->device->vk_procs; + + dst_resource = unsafe_impl_from_ID3D12Resource(dst); + src_resource = unsafe_impl_from_ID3D12Resource(src); + + assert(d3d12_resource_is_texture(dst_resource)); + assert(d3d12_resource_is_texture(src_resource)); + + d3d12_command_list_track_resource_usage(list, dst_resource); + d3d12_command_list_track_resource_usage(list, src_resource); + + d3d12_command_list_end_current_render_pass(list); + + if (dxgi_format_is_typeless(dst_resource->desc.Format) + || dxgi_format_is_typeless(src_resource->desc.Format)) + { + FIXME("Not implemented for typeless resources.\n"); + return; + } + + if (!(dst_format = vkd3d_format_from_d3d12_resource_desc(&dst_resource->desc, DXGI_FORMAT_UNKNOWN))) + { + WARN("Invalid format %#x.\n", dst_resource->desc.Format); + return; + } + if (!(src_format = vkd3d_format_from_d3d12_resource_desc(&src_resource->desc, DXGI_FORMAT_UNKNOWN))) + { + WARN("Invalid format %#x.\n", src_resource->desc.Format); + return; + } + + /* Resolve of depth/stencil images is not supported in Vulkan. */ + if ((dst_format->vk_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) + || (src_format->vk_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) + { + FIXME("Resolve of depth/stencil images is not implemented yet.\n"); + return; + } + + vk_image_subresource_layers_from_d3d12(&vk_image_resolve.srcSubresource, + src_format, src_sub_resource_idx, src_resource->desc.MipLevels); + memset(&vk_image_resolve.srcOffset, 0, sizeof(vk_image_resolve.srcOffset)); + vk_image_subresource_layers_from_d3d12(&vk_image_resolve.dstSubresource, + dst_format, dst_sub_resource_idx, dst_resource->desc.MipLevels); + memset(&vk_image_resolve.dstOffset, 0, sizeof(vk_image_resolve.dstOffset)); + vk_extent_3d_from_d3d12_miplevel(&vk_image_resolve.extent, + &dst_resource->desc, vk_image_resolve.dstSubresource.mipLevel); + + VK_CALL(vkCmdResolveImage(list->vk_command_buffer, src_resource->u.vk_image, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_resource->u.vk_image, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vk_image_resolve)); } static enum VkPrimitiveTopology vk_topology_from_d3d12_topology(D3D12_PRIMITIVE_TOPOLOGY topology) -- 2.18.1

2 1

← Newer
1
...
14
15
16
17
18
19
20
...
61
Older →

Jump to page:

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 October 2018