| /*------------------------------------------------------------------------- |
| * Vulkan CTS Framework |
| * -------------------- |
| * |
| * Copyright (c) 2021 The Khronos Group Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Vulkan SC utilities |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vkSafetyCriticalUtil.hpp" |
| #include <set> |
| |
| #ifdef CTS_USES_VULKANSC |
| |
| namespace vk |
| { |
| struct MemoryArea |
| { |
| MemoryArea(const void* data_, std::size_t size_) |
| : data(data_), size(size_) |
| { |
| } |
| |
| const void* data; |
| std::size_t size; |
| }; |
| } // vk |
| |
| namespace std |
| { |
| template<> |
| struct hash<vk::MemoryArea> |
| { |
| std::size_t operator()(const vk::MemoryArea& s) const noexcept |
| { |
| std::size_t seed = 0; |
| std::hash<unsigned char> hasher; |
| for (std::size_t i = 0; i < s.size; ++i) |
| { |
| unsigned char* v = (unsigned char*)s.data + i; |
| seed ^= hasher(*v) + 0x9e3779b9 + (seed << 6) + (seed >> 2); |
| } |
| return seed; |
| } |
| }; |
| }// std |
| |
| namespace vk |
| { |
| |
| VkDeviceObjectReservationCreateInfo resetDeviceObjectReservationCreateInfo () |
| { |
| VkDeviceObjectReservationCreateInfo result = |
| { |
| VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // deUint32 pipelineCacheCreateInfoCount; |
| DE_NULL, // const VkPipelineCacheCreateInfo* pPipelineCacheCreateInfos; |
| 0u, // deUint32 pipelinePoolSizeCount; |
| DE_NULL, // const VkPipelinePoolSize* pPipelinePoolSizes; |
| 0u, // deUint32 semaphoreRequestCount; |
| 0u, // deUint32 commandBufferRequestCount; |
| 0u, // deUint32 fenceRequestCount; |
| 0u, // deUint32 deviceMemoryRequestCount; |
| 0u, // deUint32 bufferRequestCount; |
| 0u, // deUint32 imageRequestCount; |
| 0u, // deUint32 eventRequestCount; |
| 0u, // deUint32 queryPoolRequestCount; |
| 0u, // deUint32 bufferViewRequestCount; |
| 0u, // deUint32 imageViewRequestCount; |
| 0u, // deUint32 layeredImageViewRequestCount; |
| 0u, // deUint32 pipelineCacheRequestCount; |
| 0u, // deUint32 pipelineLayoutRequestCount; |
| 0u, // deUint32 renderPassRequestCount; |
| 0u, // deUint32 graphicsPipelineRequestCount; |
| 0u, // deUint32 computePipelineRequestCount; |
| 0u, // deUint32 descriptorSetLayoutRequestCount; |
| 0u, // deUint32 samplerRequestCount; |
| 0u, // deUint32 descriptorPoolRequestCount; |
| 0u, // deUint32 descriptorSetRequestCount; |
| 0u, // deUint32 framebufferRequestCount; |
| 0u, // deUint32 commandPoolRequestCount; |
| 0u, // deUint32 samplerYcbcrConversionRequestCount; |
| 0u, // deUint32 surfaceRequestCount; |
| 0u, // deUint32 swapchainRequestCount; |
| 0u, // deUint32 displayModeRequestCount; |
| 0u, // deUint32 subpassDescriptionRequestCount; |
| 0u, // deUint32 attachmentDescriptionRequestCount; |
| 0u, // deUint32 descriptorSetLayoutBindingRequestCount; |
| 0u, // deUint32 descriptorSetLayoutBindingLimit; |
| 0u, // deUint32 maxImageViewMipLevels; |
| 0u, // deUint32 maxImageViewArrayLayers; |
| 0u, // deUint32 maxLayeredImageViewMipLevels; |
| 0u, // deUint32 maxOcclusionQueriesPerPool; |
| 0u, // deUint32 maxPipelineStatisticsQueriesPerPool; |
| 0u, // deUint32 maxTimestampQueriesPerPool; |
| 0u, // deUint32 maxImmutableSamplersPerDescriptorSetLayout; |
| }; |
| return result; |
| } |
| |
| VkPipelineOfflineCreateInfo resetPipelineOfflineCreateInfo() |
| { |
| VkPipelineOfflineCreateInfo pipelineID = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| {0}, // deUint8 pipelineIdentifier[VK_UUID_SIZE]; |
| VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH, // VkPipelineMatchControl matchControl; |
| 0u // VkDeviceSize poolEntrySize; |
| |
| }; |
| for (deUint32 i = 0; i < VK_UUID_SIZE; ++i) |
| pipelineID.pipelineIdentifier[i] = 0U; |
| |
| return pipelineID; |
| } |
| |
| void applyPipelineIdentifier (VkPipelineOfflineCreateInfo& pipelineID, const std::string& value) |
| { |
| for (deUint32 i = 0; i < VK_UUID_SIZE && i < value.size(); ++i) |
| pipelineID.pipelineIdentifier[i] = deUint8(value[i]); |
| } |
| |
| VkPhysicalDeviceVulkanSC10Features createDefaultSC10Features () |
| { |
| VkPhysicalDeviceVulkanSC10Features result = |
| { |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES, // VkStructureType sType; |
| DE_NULL, // void* pNext; |
| VK_FALSE // VkBool32 shaderAtomicInstructions; |
| }; |
| return result; |
| } |
| |
| void hashPNextChain (std::size_t& seed, const void* pNext, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| VkBaseInStructure* pBase = (VkBaseInStructure*)pNext; |
| if (pNext != DE_NULL) |
| { |
| switch (pBase->sType) |
| { |
| case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: |
| { |
| VkAttachmentDescriptionStencilLayout* ptr = (VkAttachmentDescriptionStencilLayout *)pNext; |
| hash_combine(seed, deUint32(ptr->stencilInitialLayout), deUint32(ptr->stencilFinalLayout)); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: |
| { |
| VkDescriptorSetLayoutBindingFlagsCreateInfo* ptr = (VkDescriptorSetLayoutBindingFlagsCreateInfo *)pNext; |
| if (ptr->pBindingFlags != DE_NULL) |
| for (deUint32 i = 0; i < ptr->bindingCount; ++i) |
| hash_combine(seed, ptr->pBindingFlags[i]); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: |
| { |
| VkPipelineColorBlendAdvancedStateCreateInfoEXT* ptr = (VkPipelineColorBlendAdvancedStateCreateInfoEXT *)pNext; |
| hash_combine(seed, ptr->srcPremultiplied, ptr->dstPremultiplied, deUint32(ptr->blendOverlap)); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: |
| { |
| VkPipelineColorWriteCreateInfoEXT* ptr = (VkPipelineColorWriteCreateInfoEXT *)pNext; |
| if (ptr->pColorWriteEnables != DE_NULL) |
| for (deUint32 i = 0; i < ptr->attachmentCount; ++i) |
| hash_combine(seed, ptr->pColorWriteEnables[i]); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: |
| { |
| VkPipelineDiscardRectangleStateCreateInfoEXT* ptr = (VkPipelineDiscardRectangleStateCreateInfoEXT *)pNext; |
| hash_combine(seed, ptr->flags, deUint32(ptr->discardRectangleMode)); |
| if (ptr->pDiscardRectangles != DE_NULL) |
| for (deUint32 i = 0; i < ptr->discardRectangleCount; ++i) |
| hash_combine(seed, ptr->pDiscardRectangles[i].offset.x, ptr->pDiscardRectangles[i].offset.y, ptr->pDiscardRectangles[i].extent.width, ptr->pDiscardRectangles[i].extent.height); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: |
| { |
| VkPipelineFragmentShadingRateStateCreateInfoKHR* ptr = (VkPipelineFragmentShadingRateStateCreateInfoKHR *)pNext; |
| hash_combine(seed, ptr->fragmentSize.width, ptr->fragmentSize.height, deUint32(ptr->combinerOps[0]), deUint32(ptr->combinerOps[1])); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: |
| { |
| VkPipelineRasterizationConservativeStateCreateInfoEXT* ptr = (VkPipelineRasterizationConservativeStateCreateInfoEXT *)pNext; |
| hash_combine(seed, ptr->flags, deUint32(ptr->conservativeRasterizationMode), ptr->extraPrimitiveOverestimationSize); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: |
| { |
| VkPipelineRasterizationDepthClipStateCreateInfoEXT* ptr = (VkPipelineRasterizationDepthClipStateCreateInfoEXT *)pNext; |
| hash_combine(seed, ptr->flags, ptr->depthClipEnable); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: |
| { |
| VkPipelineRasterizationLineStateCreateInfoEXT* ptr = (VkPipelineRasterizationLineStateCreateInfoEXT *)pNext; |
| hash_combine(seed, deUint32(ptr->lineRasterizationMode), ptr->stippledLineEnable, ptr->lineStippleFactor, ptr->lineStipplePattern); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: |
| { |
| VkPipelineSampleLocationsStateCreateInfoEXT* ptr = (VkPipelineSampleLocationsStateCreateInfoEXT *)pNext; |
| hash_combine(seed, ptr->sampleLocationsEnable, deUint32(ptr->sampleLocationsInfo.sampleLocationsPerPixel), ptr->sampleLocationsInfo.sampleLocationGridSize.width, ptr->sampleLocationsInfo.sampleLocationGridSize.height); |
| if (ptr->sampleLocationsInfo.pSampleLocations != DE_NULL) |
| for (deUint32 i = 0; i < ptr->sampleLocationsInfo.sampleLocationsCount; ++i) |
| hash_combine(seed, ptr->sampleLocationsInfo.pSampleLocations[i].x, ptr->sampleLocationsInfo.pSampleLocations[i].y); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: |
| { |
| VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* ptr = (VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *)pNext; |
| hash_combine(seed, ptr->requiredSubgroupSize); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: |
| { |
| VkPipelineTessellationDomainOriginStateCreateInfo* ptr = (VkPipelineTessellationDomainOriginStateCreateInfo *)pNext; |
| hash_combine(seed, deUint32(ptr->domainOrigin)); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: |
| { |
| VkPipelineVertexInputDivisorStateCreateInfoEXT* ptr = (VkPipelineVertexInputDivisorStateCreateInfoEXT *)pNext; |
| if (ptr->pVertexBindingDivisors != DE_NULL) |
| for (deUint32 i = 0; i < ptr->vertexBindingDivisorCount; ++i) |
| hash_combine(seed, ptr->pVertexBindingDivisors[i].binding, ptr->pVertexBindingDivisors[i].divisor); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: |
| { |
| VkRenderPassInputAttachmentAspectCreateInfo* ptr = (VkRenderPassInputAttachmentAspectCreateInfo *)pNext; |
| if (ptr->pAspectReferences != DE_NULL) |
| for (deUint32 i = 0; i < ptr->aspectReferenceCount; ++i) |
| hash_combine(seed, ptr->pAspectReferences[i].subpass, ptr->pAspectReferences[i].inputAttachmentIndex, ptr->pAspectReferences[i].aspectMask); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: |
| { |
| VkRenderPassMultiviewCreateInfo* ptr = (VkRenderPassMultiviewCreateInfo *)pNext; |
| if (ptr->pViewMasks != DE_NULL) |
| for (deUint32 i = 0; i < ptr->subpassCount; ++i) |
| hash_combine(seed, ptr->pViewMasks[i]); |
| if (ptr->pViewOffsets != DE_NULL) |
| for (deUint32 i = 0; i < ptr->dependencyCount; ++i) |
| hash_combine(seed, ptr->pViewOffsets[i]); |
| if (ptr->pCorrelationMasks != DE_NULL) |
| for (deUint32 i = 0; i < ptr->correlationMaskCount; ++i) |
| hash_combine(seed, ptr->pCorrelationMasks[i]); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: |
| { |
| VkSamplerCustomBorderColorCreateInfoEXT* ptr = (VkSamplerCustomBorderColorCreateInfoEXT *)pNext; |
| for (deUint32 i = 0; i < 4; ++i) |
| hash_combine(seed, ptr->customBorderColor.uint32[i]); |
| hash_combine(seed, deUint32(ptr->format)); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: |
| { |
| VkSamplerReductionModeCreateInfo* ptr = (VkSamplerReductionModeCreateInfo *)pNext; |
| hash_combine(seed, deUint32(ptr->reductionMode)); |
| break; |
| } |
| case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: |
| { |
| VkSamplerYcbcrConversionInfo* ptr = (VkSamplerYcbcrConversionInfo *)pNext; |
| { |
| auto it = objectHashes.find(ptr->conversion.getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| hashPNextChain(seed, pBase->pNext, objectHashes); |
| } |
| } |
| |
| bool graphicsPipelineHasDynamicState(const VkGraphicsPipelineCreateInfo& gpCI, VkDynamicState state) |
| { |
| if (gpCI.pDynamicState == DE_NULL) |
| return false; |
| |
| if (gpCI.pDynamicState->pDynamicStates == DE_NULL) |
| return false; |
| |
| for (deUint32 i = 0; i < gpCI.pDynamicState->dynamicStateCount; ++i) |
| if (gpCI.pDynamicState->pDynamicStates[i] == state) |
| return true; |
| |
| return false; |
| } |
| |
| std::size_t calculateGraphicsPipelineHash (const VkGraphicsPipelineCreateInfo& gpCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| std::size_t seed = 0; |
| |
| hashPNextChain(seed, gpCI.pNext, objectHashes); |
| |
| hash_combine(seed, gpCI.flags); |
| |
| bool vertexInputStateRequired = false; |
| bool inputAssemblyStateRequired = false; |
| bool tessellationStateRequired = false; |
| bool viewportStateRequired = false; |
| bool viewportStateViewportsRequired = false; |
| bool viewportStateScissorsRequired = false; |
| bool multiSampleStateRequired = false; |
| bool depthStencilStateRequired = false; |
| bool colorBlendStateRequired = false; |
| |
| if (gpCI.pStages != DE_NULL) |
| { |
| for (deUint32 i = 0; i < gpCI.stageCount; ++i) |
| { |
| hashPNextChain(seed, gpCI.pStages[i].pNext, objectHashes); |
| |
| hash_combine(seed, deUint32(gpCI.pStages[i].flags), deUint32(gpCI.pStages[i].stage)); |
| auto it = objectHashes.find(gpCI.pStages[i].module.getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| |
| hash_combine(seed, std::string(gpCI.pStages[i].pName)); |
| |
| if (gpCI.pStages[i].pSpecializationInfo != DE_NULL) |
| { |
| if (gpCI.pStages[i].pSpecializationInfo->pMapEntries != DE_NULL) |
| { |
| for (deUint32 j = 0; j < gpCI.pStages[i].pSpecializationInfo->mapEntryCount; ++j) |
| hash_combine(seed, gpCI.pStages[i].pSpecializationInfo->pMapEntries[j].constantID, gpCI.pStages[i].pSpecializationInfo->pMapEntries[j].offset, gpCI.pStages[i].pSpecializationInfo->pMapEntries[j].size); |
| |
| hash_combine(seed, MemoryArea(gpCI.pStages[i].pSpecializationInfo->pData, gpCI.pStages[i].pSpecializationInfo->dataSize)); |
| } |
| } |
| if (gpCI.pStages[i].stage == VK_SHADER_STAGE_VERTEX_BIT) |
| { |
| vertexInputStateRequired = true; |
| inputAssemblyStateRequired = true; |
| } |
| if (gpCI.pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) |
| { |
| tessellationStateRequired = true; |
| } |
| } |
| } |
| if (gpCI.pDynamicState != DE_NULL) |
| { |
| if (gpCI.pDynamicState->pDynamicStates != DE_NULL) |
| for (deUint32 i = 0; i < gpCI.pDynamicState->dynamicStateCount; ++i) |
| { |
| if (gpCI.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT || gpCI.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT) |
| { |
| viewportStateRequired = true; |
| viewportStateViewportsRequired = true; |
| } |
| if (gpCI.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR || gpCI.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT) |
| { |
| viewportStateRequired = true; |
| viewportStateScissorsRequired = true; |
| } |
| if (gpCI.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT) |
| viewportStateRequired = true; |
| } |
| } |
| if (gpCI.pRasterizationState != DE_NULL) |
| { |
| if (gpCI.pRasterizationState->rasterizerDiscardEnable == VK_FALSE) |
| { |
| viewportStateRequired = true; |
| viewportStateViewportsRequired = true; |
| viewportStateScissorsRequired = true; |
| multiSampleStateRequired = true; |
| depthStencilStateRequired = true; |
| colorBlendStateRequired = true; |
| } |
| } |
| |
| if (vertexInputStateRequired && gpCI.pVertexInputState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pVertexInputState->pNext, objectHashes); |
| hash_combine(seed, gpCI.pVertexInputState->flags); |
| if (gpCI.pVertexInputState->pVertexBindingDescriptions != DE_NULL) |
| for (deUint32 i = 0; i < gpCI.pVertexInputState->vertexBindingDescriptionCount; ++i) |
| hash_combine(seed, gpCI.pVertexInputState->pVertexBindingDescriptions[i].binding, gpCI.pVertexInputState->pVertexBindingDescriptions[i].stride, deUint32(gpCI.pVertexInputState->pVertexBindingDescriptions[i].inputRate)); |
| if (gpCI.pVertexInputState->pVertexAttributeDescriptions != DE_NULL) |
| for (deUint32 i = 0; i < gpCI.pVertexInputState->vertexAttributeDescriptionCount; ++i) |
| hash_combine(seed, gpCI.pVertexInputState->pVertexAttributeDescriptions[i].location, gpCI.pVertexInputState->pVertexAttributeDescriptions[i].binding, deUint32(gpCI.pVertexInputState->pVertexAttributeDescriptions[i].format), gpCI.pVertexInputState->pVertexAttributeDescriptions[i].offset); |
| } |
| |
| if (inputAssemblyStateRequired && gpCI.pInputAssemblyState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pInputAssemblyState->pNext, objectHashes); |
| hash_combine(seed, deUint32(gpCI.pInputAssemblyState->flags), deUint32(gpCI.pInputAssemblyState->topology), gpCI.pInputAssemblyState->primitiveRestartEnable); |
| } |
| if (tessellationStateRequired && gpCI.pTessellationState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pTessellationState->pNext, objectHashes); |
| hash_combine(seed, gpCI.pTessellationState->flags, gpCI.pTessellationState->patchControlPoints); |
| } |
| if (viewportStateRequired && gpCI.pViewportState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pViewportState->pNext, objectHashes); |
| hash_combine(seed, gpCI.pViewportState->flags); |
| |
| if (viewportStateViewportsRequired && gpCI.pViewportState->pViewports != DE_NULL) |
| for (deUint32 i = 0; i < gpCI.pViewportState->viewportCount; ++i) |
| hash_combine(seed, gpCI.pViewportState->pViewports[i].x, gpCI.pViewportState->pViewports[i].y, gpCI.pViewportState->pViewports[i].width, gpCI.pViewportState->pViewports[i].height, gpCI.pViewportState->pViewports[i].minDepth, gpCI.pViewportState->pViewports[i].maxDepth); |
| |
| if (viewportStateScissorsRequired && gpCI.pViewportState->pScissors != DE_NULL) |
| for (deUint32 i = 0; i < gpCI.pViewportState->scissorCount; ++i) |
| hash_combine(seed, gpCI.pViewportState->pScissors[i].offset.x, gpCI.pViewportState->pScissors[i].offset.y, gpCI.pViewportState->pScissors[i].extent.width, gpCI.pViewportState->pScissors[i].extent.height); |
| } |
| if (gpCI.pRasterizationState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pRasterizationState->pNext, objectHashes); |
| hash_combine(seed, deUint32(gpCI.pRasterizationState->flags), gpCI.pRasterizationState->depthClampEnable, gpCI.pRasterizationState->rasterizerDiscardEnable, deUint32(gpCI.pRasterizationState->polygonMode), deUint32(gpCI.pRasterizationState->cullMode), deUint32(gpCI.pRasterizationState->frontFace), gpCI.pRasterizationState->depthBiasEnable, gpCI.pRasterizationState->depthBiasConstantFactor, gpCI.pRasterizationState->depthBiasClamp, gpCI.pRasterizationState->depthBiasSlopeFactor, gpCI.pRasterizationState->lineWidth); |
| } |
| if (multiSampleStateRequired && gpCI.pMultisampleState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pMultisampleState->pNext, objectHashes); |
| hash_combine(seed, deUint32(gpCI.pMultisampleState->flags), deUint32(gpCI.pMultisampleState->rasterizationSamples), gpCI.pMultisampleState->sampleShadingEnable, gpCI.pMultisampleState->minSampleShading); |
| if (gpCI.pMultisampleState->pSampleMask != DE_NULL) |
| for (int i = 0; i < ((gpCI.pMultisampleState->rasterizationSamples + 31) / 32); i++) |
| hash_combine(seed, gpCI.pMultisampleState->pSampleMask[i]); |
| hash_combine(seed, gpCI.pMultisampleState->alphaToCoverageEnable, gpCI.pMultisampleState->alphaToOneEnable); |
| } |
| if (depthStencilStateRequired && gpCI.pDepthStencilState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pDepthStencilState->pNext, objectHashes); |
| hash_combine(seed, deUint32(gpCI.pDepthStencilState->flags), gpCI.pDepthStencilState->depthTestEnable, gpCI.pDepthStencilState->depthWriteEnable, deUint32(gpCI.pDepthStencilState->depthCompareOp), gpCI.pDepthStencilState->depthBoundsTestEnable, gpCI.pDepthStencilState->stencilTestEnable); |
| if (gpCI.pDepthStencilState->stencilTestEnable) |
| { |
| hash_combine(seed, deUint32(gpCI.pDepthStencilState->front.failOp), deUint32(gpCI.pDepthStencilState->front.passOp), deUint32(gpCI.pDepthStencilState->front.depthFailOp), deUint32(gpCI.pDepthStencilState->front.compareOp), gpCI.pDepthStencilState->front.compareMask, gpCI.pDepthStencilState->front.writeMask, gpCI.pDepthStencilState->front.reference); |
| hash_combine(seed, deUint32(gpCI.pDepthStencilState->back.failOp), deUint32(gpCI.pDepthStencilState->back.passOp), deUint32(gpCI.pDepthStencilState->back.depthFailOp), deUint32(gpCI.pDepthStencilState->back.compareOp), gpCI.pDepthStencilState->back.compareMask, gpCI.pDepthStencilState->back.writeMask, gpCI.pDepthStencilState->back.reference); |
| } |
| hash_combine(seed, gpCI.pDepthStencilState->minDepthBounds, gpCI.pDepthStencilState->maxDepthBounds); |
| } |
| if (colorBlendStateRequired && gpCI.pColorBlendState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pColorBlendState->pNext, objectHashes); |
| hash_combine(seed, deUint32(gpCI.pColorBlendState->flags), gpCI.pColorBlendState->logicOpEnable, deUint32(gpCI.pColorBlendState->logicOp)); |
| |
| bool hashBlendConstants = false; |
| std::set<VkBlendFactor> constFactors = { VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA }; |
| if (gpCI.pColorBlendState->pAttachments != DE_NULL) |
| { |
| for (deUint32 i = 0; i < gpCI.pColorBlendState->attachmentCount; ++i) |
| { |
| hash_combine |
| ( |
| seed, |
| gpCI.pColorBlendState->pAttachments[i].blendEnable, deUint32(gpCI.pColorBlendState->pAttachments[i].srcColorBlendFactor), deUint32(gpCI.pColorBlendState->pAttachments[i].dstColorBlendFactor), deUint32(gpCI.pColorBlendState->pAttachments[i].colorBlendOp), |
| deUint32(gpCI.pColorBlendState->pAttachments[i].srcAlphaBlendFactor), deUint32(gpCI.pColorBlendState->pAttachments[i].dstAlphaBlendFactor), deUint32(gpCI.pColorBlendState->pAttachments[i].alphaBlendOp), deUint32(gpCI.pColorBlendState->pAttachments[i].colorWriteMask) |
| ); |
| if (constFactors.find(gpCI.pColorBlendState->pAttachments[i].srcColorBlendFactor) != end(constFactors)) hashBlendConstants = true; |
| if (constFactors.find(gpCI.pColorBlendState->pAttachments[i].dstColorBlendFactor) != end(constFactors)) hashBlendConstants = true; |
| if (constFactors.find(gpCI.pColorBlendState->pAttachments[i].srcAlphaBlendFactor) != end(constFactors)) hashBlendConstants = true; |
| if (constFactors.find(gpCI.pColorBlendState->pAttachments[i].dstAlphaBlendFactor) != end(constFactors)) hashBlendConstants = true; |
| } |
| } |
| // omit blendConstants when VK_DYNAMIC_STATE_BLEND_CONSTANTS is present |
| if (hashBlendConstants && !graphicsPipelineHasDynamicState(gpCI, VK_DYNAMIC_STATE_BLEND_CONSTANTS)) |
| for (deUint32 i = 0; i < 4; ++i) |
| hash_combine(seed, gpCI.pColorBlendState->blendConstants[i]); |
| } |
| if (gpCI.pDynamicState != DE_NULL) |
| { |
| hashPNextChain(seed, gpCI.pDynamicState->pNext, objectHashes); |
| hash_combine(seed, gpCI.pDynamicState->flags); |
| if (gpCI.pDynamicState->pDynamicStates != DE_NULL) |
| for (deUint32 i = 0; i < gpCI.pDynamicState->dynamicStateCount; ++i) |
| hash_combine(seed, deUint32(gpCI.pDynamicState->pDynamicStates[i])); |
| } |
| |
| { |
| auto it = objectHashes.find(gpCI.layout.getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| } |
| |
| { |
| auto it = objectHashes.find(gpCI.renderPass.getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| } |
| |
| hash_combine(seed, gpCI.subpass); |
| |
| { |
| auto it = objectHashes.find(gpCI.basePipelineHandle.getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| } |
| hash_combine(seed, gpCI.basePipelineIndex); |
| |
| return seed; |
| } |
| |
| std::size_t calculateComputePipelineHash (const VkComputePipelineCreateInfo& cpCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| std::size_t seed = 0; |
| |
| hashPNextChain(seed, cpCI.pNext, objectHashes); |
| |
| hash_combine(seed, cpCI.flags); |
| |
| { |
| hash_combine(seed, deUint32(cpCI.stage.flags), deUint32(cpCI.stage.stage)); |
| auto it = objectHashes.find(cpCI.stage.module.getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| |
| hash_combine(seed, std::string(cpCI.stage.pName)); |
| |
| if (cpCI.stage.pSpecializationInfo != DE_NULL) |
| { |
| if (cpCI.stage.pSpecializationInfo->pMapEntries != DE_NULL) |
| { |
| for (deUint32 j = 0; j < cpCI.stage.pSpecializationInfo->mapEntryCount; ++j) |
| hash_combine(seed, cpCI.stage.pSpecializationInfo->pMapEntries[j].constantID, cpCI.stage.pSpecializationInfo->pMapEntries[j].offset, cpCI.stage.pSpecializationInfo->pMapEntries[j].size); |
| |
| hash_combine(seed, MemoryArea(cpCI.stage.pSpecializationInfo->pData, cpCI.stage.pSpecializationInfo->dataSize)); |
| } |
| } |
| } |
| |
| { |
| auto it = objectHashes.find(cpCI.layout.getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| } |
| |
| { |
| auto it = objectHashes.find(cpCI.basePipelineHandle.getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| } |
| hash_combine(seed, cpCI.basePipelineIndex); |
| |
| return seed; |
| } |
| |
| std::size_t calculateSamplerYcbcrConversionHash (const VkSamplerYcbcrConversionCreateInfo& scCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| DE_UNREF(objectHashes); |
| std::size_t seed = 0; |
| hashPNextChain(seed, scCI.pNext, objectHashes); |
| hash_combine(seed, deUint32(scCI.format), deUint32(scCI.ycbcrModel), deUint32(scCI.ycbcrRange), deUint32(scCI.components.r), deUint32(scCI.components.g), deUint32(scCI.components.b), deUint32(scCI.components.a), deUint32(scCI.xChromaOffset), deUint32(scCI.yChromaOffset), deUint32(scCI.chromaFilter), scCI.forceExplicitReconstruction); |
| return seed; |
| } |
| |
| std::size_t calculateSamplerHash (const VkSamplerCreateInfo& sCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| std::size_t seed = 0; |
| hashPNextChain(seed, sCI.pNext, objectHashes); |
| hash_combine(seed, deUint32(sCI.flags), deUint32(sCI.magFilter), deUint32(sCI.minFilter), deUint32(sCI.mipmapMode), deUint32(sCI.addressModeU), deUint32(sCI.addressModeV), deUint32(sCI.addressModeW), sCI.mipLodBias, sCI.anisotropyEnable, sCI.maxAnisotropy, sCI.compareEnable, deUint32(sCI.compareOp), sCI.minLod, sCI.maxLod, deUint32(sCI.borderColor), sCI.unnormalizedCoordinates); |
| return seed; |
| } |
| |
| std::size_t calculateDescriptorSetLayoutHash (const VkDescriptorSetLayoutCreateInfo& sCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| std::size_t seed = 0; |
| |
| hashPNextChain(seed, sCI.pNext, objectHashes); |
| |
| hash_combine(seed, deUint32(sCI.flags)); |
| if (sCI.pBindings != DE_NULL) |
| { |
| for (deUint32 i = 0; i < sCI.bindingCount; ++i) |
| { |
| hash_combine(seed, sCI.pBindings[i].binding, deUint32(sCI.pBindings[i].descriptorType), sCI.pBindings[i].descriptorCount, deUint32(sCI.pBindings[i].stageFlags)); |
| if (sCI.pBindings[i].pImmutableSamplers != DE_NULL) |
| { |
| for (deUint32 j = 0; j < sCI.pBindings[i].descriptorCount; ++j) |
| { |
| auto it = objectHashes.find(sCI.pBindings[i].pImmutableSamplers[j].getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| } |
| } |
| } |
| } |
| return seed; |
| } |
| |
| std::size_t calculatePipelineLayoutHash (const VkPipelineLayoutCreateInfo& pCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| std::size_t seed = 0; |
| |
| hashPNextChain(seed, pCI.pNext, objectHashes); |
| |
| hash_combine(seed, deUint32(pCI.flags)); |
| |
| if (pCI.pSetLayouts != DE_NULL) |
| { |
| for (deUint32 i = 0; i < pCI.setLayoutCount; ++i) |
| { |
| auto it = objectHashes.find(pCI.pSetLayouts[i].getInternal()); |
| if (it != end(objectHashes)) |
| hash_combine(seed, it->second); |
| } |
| } |
| if (pCI.pPushConstantRanges != DE_NULL) |
| { |
| for (deUint32 i = 0; i < pCI.pushConstantRangeCount; ++i) |
| { |
| hash_combine(seed, deUint32(pCI.pPushConstantRanges[i].stageFlags)); |
| hash_combine(seed, pCI.pPushConstantRanges[i].offset); |
| hash_combine(seed, pCI.pPushConstantRanges[i].size); |
| } |
| } |
| |
| return seed; |
| } |
| |
| std::size_t calculateShaderModuleHash (const VkShaderModuleCreateInfo& sCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| std::size_t seed = 0; |
| |
| hashPNextChain(seed, sCI.pNext, objectHashes); |
| |
| hash_combine(seed, deUint32(sCI.flags)); |
| hash_combine(seed, MemoryArea(sCI.pCode, sCI.codeSize)); |
| |
| return seed; |
| } |
| |
| |
| std::size_t calculateRenderPassHash (const VkRenderPassCreateInfo& rCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| std::size_t seed = 0; |
| |
| hashPNextChain(seed, rCI.pNext, objectHashes); |
| |
| hash_combine(seed, deUint32(rCI.flags)); |
| |
| if (rCI.pAttachments != DE_NULL) |
| for (deUint32 i = 0; i < rCI.attachmentCount; ++i) |
| hash_combine(seed, deUint32(rCI.pAttachments[i].flags), deUint32(rCI.pAttachments[i].format), deUint32(rCI.pAttachments[i].samples), deUint32(rCI.pAttachments[i].loadOp), deUint32(rCI.pAttachments[i].storeOp), deUint32(rCI.pAttachments[i].stencilLoadOp), deUint32(rCI.pAttachments[i].stencilStoreOp), deUint32(rCI.pAttachments[i].initialLayout), deUint32(rCI.pAttachments[i].finalLayout)); |
| |
| if (rCI.pSubpasses != DE_NULL) |
| { |
| for (deUint32 i = 0; i < rCI.subpassCount; ++i) |
| { |
| hash_combine(seed, deUint32(rCI.pSubpasses[i].flags), deUint32(rCI.pSubpasses[i].pipelineBindPoint)); |
| if (rCI.pSubpasses[i].pInputAttachments != DE_NULL) |
| for (deUint32 j = 0; j < rCI.pSubpasses[i].inputAttachmentCount; ++j) |
| hash_combine(seed, rCI.pSubpasses[i].pInputAttachments[j].attachment, deUint32(rCI.pSubpasses[i].pInputAttachments[j].layout)); |
| if (rCI.pSubpasses[i].pColorAttachments != DE_NULL) |
| for (deUint32 j = 0; j < rCI.pSubpasses[i].colorAttachmentCount; ++j) |
| hash_combine(seed, rCI.pSubpasses[i].pColorAttachments[j].attachment, deUint32(rCI.pSubpasses[i].pColorAttachments[j].layout)); |
| if (rCI.pSubpasses[i].pResolveAttachments != DE_NULL) |
| for (deUint32 j = 0; j < rCI.pSubpasses[i].colorAttachmentCount; ++j) |
| hash_combine(seed, rCI.pSubpasses[i].pResolveAttachments[j].attachment, deUint32(rCI.pSubpasses[i].pResolveAttachments[j].layout)); |
| if (rCI.pSubpasses[i].pDepthStencilAttachment != DE_NULL) |
| hash_combine(seed, rCI.pSubpasses[i].pDepthStencilAttachment->attachment, deUint32(rCI.pSubpasses[i].pDepthStencilAttachment->layout)); |
| if (rCI.pSubpasses[i].pPreserveAttachments != DE_NULL) |
| for (deUint32 j = 0; j < rCI.pSubpasses[i].preserveAttachmentCount; ++j) |
| hash_combine(seed, rCI.pSubpasses[i].pPreserveAttachments[j]); |
| } |
| } |
| if (rCI.pDependencies != DE_NULL) |
| for (deUint32 i = 0; i < rCI.dependencyCount; ++i) |
| hash_combine(seed, rCI.pDependencies[i].srcSubpass, rCI.pDependencies[i].dstSubpass, deUint32(rCI.pDependencies[i].srcStageMask), deUint32(rCI.pDependencies[i].dstStageMask), deUint64(rCI.pDependencies[i].srcAccessMask), deUint64(rCI.pDependencies[i].dstAccessMask), deUint32(rCI.pDependencies[i].dependencyFlags)); |
| |
| return seed; |
| } |
| |
| std::size_t calculateRenderPass2Hash (const VkRenderPassCreateInfo2& rCI, const std::map<deUint64, std::size_t>& objectHashes) |
| { |
| std::size_t seed = 0; |
| |
| hashPNextChain(seed, rCI.pNext, objectHashes); |
| |
| hash_combine(seed, rCI.flags); |
| |
| if (rCI.pAttachments != DE_NULL) |
| for (deUint32 i = 0; i < rCI.attachmentCount; ++i) |
| hash_combine(seed, deUint32(rCI.pAttachments[i].flags), deUint32(rCI.pAttachments[i].format), deUint32(rCI.pAttachments[i].samples), deUint32(rCI.pAttachments[i].loadOp), deUint32(rCI.pAttachments[i].storeOp), deUint32(rCI.pAttachments[i].stencilLoadOp), deUint32(rCI.pAttachments[i].stencilStoreOp), deUint32(rCI.pAttachments[i].initialLayout), deUint32(rCI.pAttachments[i].finalLayout)); |
| |
| if (rCI.pSubpasses != DE_NULL) |
| { |
| for (deUint32 i = 0; i < rCI.subpassCount; ++i) |
| { |
| hash_combine(seed, deUint32(rCI.pSubpasses[i].flags), deUint32(rCI.pSubpasses[i].pipelineBindPoint)); |
| if (rCI.pSubpasses[i].pInputAttachments != DE_NULL) |
| for (deUint32 j = 0; j < rCI.pSubpasses[i].inputAttachmentCount; ++j) |
| hash_combine(seed, rCI.pSubpasses[i].pInputAttachments[j].attachment, deUint32(rCI.pSubpasses[i].pInputAttachments[j].layout)); |
| if (rCI.pSubpasses[i].pColorAttachments != DE_NULL) |
| for (deUint32 j = 0; j < rCI.pSubpasses[i].colorAttachmentCount; ++j) |
| hash_combine(seed, rCI.pSubpasses[i].pColorAttachments[j].attachment, deUint32(rCI.pSubpasses[i].pColorAttachments[j].layout)); |
| if (rCI.pSubpasses[i].pResolveAttachments != DE_NULL) |
| for (deUint32 j = 0; j < rCI.pSubpasses[i].colorAttachmentCount; ++j) |
| hash_combine(seed, rCI.pSubpasses[i].pResolveAttachments[j].attachment, deUint32(rCI.pSubpasses[i].pResolveAttachments[j].layout)); |
| if (rCI.pSubpasses[i].pDepthStencilAttachment != DE_NULL) |
| hash_combine(seed, rCI.pSubpasses[i].pDepthStencilAttachment->attachment, deUint32(rCI.pSubpasses[i].pDepthStencilAttachment->layout)); |
| if (rCI.pSubpasses[i].pPreserveAttachments != DE_NULL) |
| for (deUint32 j = 0; j < rCI.pSubpasses[i].preserveAttachmentCount; ++j) |
| hash_combine(seed, rCI.pSubpasses[i].pPreserveAttachments[j]); |
| } |
| } |
| if (rCI.pDependencies != DE_NULL) |
| for (deUint32 i = 0; i < rCI.dependencyCount; ++i) |
| hash_combine(seed, rCI.pDependencies[i].srcSubpass, rCI.pDependencies[i].dstSubpass, deUint32(rCI.pDependencies[i].srcStageMask), deUint32(rCI.pDependencies[i].dstStageMask), deUint64(rCI.pDependencies[i].srcAccessMask), deUint64(rCI.pDependencies[i].dstAccessMask), deUint32(rCI.pDependencies[i].dependencyFlags)); |
| |
| if (rCI.pCorrelatedViewMasks != DE_NULL) |
| for (deUint32 i = 0; i < rCI.correlatedViewMaskCount; ++i) |
| hash_combine(seed, rCI.pCorrelatedViewMasks[i]); |
| |
| return seed; |
| } |
| |
| VkGraphicsPipelineCreateInfo prepareSimpleGraphicsPipelineCI (VkPipelineVertexInputStateCreateInfo& vertexInputStateCreateInfo, |
| std::vector<VkPipelineShaderStageCreateInfo>& shaderStageCreateInfos, |
| VkPipelineInputAssemblyStateCreateInfo& inputAssemblyStateCreateInfo, |
| VkPipelineViewportStateCreateInfo& viewPortStateCreateInfo, |
| VkPipelineRasterizationStateCreateInfo& rasterizationStateCreateInfo, |
| VkPipelineMultisampleStateCreateInfo& multisampleStateCreateInfo, |
| VkPipelineColorBlendAttachmentState& colorBlendAttachmentState, |
| VkPipelineColorBlendStateCreateInfo& colorBlendStateCreateInfo, |
| VkPipelineDynamicStateCreateInfo& dynamicStateCreateInfo, |
| std::vector<VkDynamicState>& dynamicStates, |
| VkPipelineLayout pipelineLayout, |
| VkRenderPass renderPass) |
| { |
| vertexInputStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags; |
| 0u, // deUint32 vertexBindingDescriptionCount; |
| DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions; |
| 0u, // deUint32 vertexAttributeDescriptionCount; |
| DE_NULL // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; |
| }; |
| |
| inputAssemblyStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags; |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology topology; |
| VK_FALSE // VkBool32 primitiveRestartEnable; |
| }; |
| |
| viewPortStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags; |
| 1, // deUint32 viewportCount; |
| DE_NULL, // const VkViewport* pViewports; |
| 1, // deUint32 scissorCount; |
| DE_NULL // const VkRect2D* pScissors; |
| }; |
| |
| rasterizationStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags; |
| VK_FALSE, // VkBool32 depthClampEnable; |
| VK_FALSE, // VkBool32 rasterizerDiscardEnable; |
| VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode; |
| VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode; |
| VK_FRONT_FACE_CLOCKWISE, // VkFrontFace frontFace; |
| VK_FALSE, // VkBool32 depthBiasEnable; |
| 0.0f, // float depthBiasConstantFactor; |
| 0.0f, // float depthBiasClamp; |
| 0.0f, // float depthBiasSlopeFactor; |
| 1.0f // float lineWidth; |
| }; |
| |
| multisampleStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags; |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples; |
| VK_FALSE, // VkBool32 sampleShadingEnable; |
| 0.0f, // float minSampleShading; |
| DE_NULL, // const VkSampleMask* pSampleMask; |
| VK_FALSE, // VkBool32 alphaToCoverageEnable; |
| VK_FALSE // VkBool32 alphaToOneEnable; |
| }; |
| |
| colorBlendAttachmentState = |
| { |
| VK_FALSE, // VkBool32 blendEnable; |
| VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor; |
| VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor; |
| VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp; |
| VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor; |
| VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor; |
| VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp; |
| (VkColorComponentFlags)0xFu // VkColorComponentFlags colorWriteMask; |
| }; |
| |
| colorBlendStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags; |
| DE_FALSE, // VkBool32 logicOpEnable; |
| VK_LOGIC_OP_CLEAR, // VkLogicOp logicOp; |
| 1, // deUint32 attachmentCount; |
| &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments; |
| { 1.0f, 1.0f, 1.0f, 1.0f } // float blendConstants[4]; |
| }; |
| |
| dynamicStateCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkPipelineDynamicStateCreateFlags)0u, // VkPipelineDynamicStateCreateFlags flags; |
| deUint32(dynamicStates.size()), // deUint32 dynamicStateCount; |
| dynamicStates.data() // const VkDynamicState* pDynamicStates; |
| }; |
| |
| VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags; |
| deUint32(shaderStageCreateInfos.size()), // deUint32 stageCount; |
| shaderStageCreateInfos.data(), // const VkPipelineShaderStageCreateInfo* pStages; |
| &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; |
| &inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; |
| DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState; |
| &viewPortStateCreateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState; |
| &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState; |
| &multisampleStateCreateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; |
| DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; |
| &colorBlendStateCreateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; |
| &dynamicStateCreateInfo, // const VkPipelineDynamicStateCreateInfo* pDynamicState; |
| pipelineLayout, // VkPipelineLayout layout; |
| renderPass, // VkRenderPass renderPass; |
| 0u, // deUint32 subpass; |
| DE_NULL, // VkPipeline basePipelineHandle; |
| 0 // int basePipelineIndex; |
| }; |
| |
| return graphicsPipelineCreateInfo; |
| } |
| |
| VkComputePipelineCreateInfo prepareSimpleComputePipelineCI (const VkPipelineShaderStageCreateInfo& shaderStageCreateInfo, |
| VkPipelineLayout pipelineLayout) |
| { |
| const VkComputePipelineCreateInfo pipelineCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| 0u, // VkPipelineCreateFlags flags |
| shaderStageCreateInfo, // VkPipelineShaderStageCreateInfo stage |
| pipelineLayout, // VkPipelineLayout layout |
| (vk::VkPipeline)0, // VkPipeline basePipelineHandle |
| 0u, // deInt32 basePipelineIndex |
| }; |
| return pipelineCreateInfo; |
| } |
| |
| VkRenderPassCreateInfo prepareSimpleRenderPassCI (VkFormat format, |
| VkAttachmentDescription& attachmentDescription, |
| VkAttachmentReference& attachmentReference, |
| VkSubpassDescription& subpassDescription) |
| { |
| attachmentDescription = |
| { |
| (VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags; |
| format, // VkFormat format; |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; |
| VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; |
| VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; |
| VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; |
| VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout; |
| }; |
| |
| attachmentReference = |
| { |
| 0u, // deUint32 attachment; |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; |
| }; |
| |
| subpassDescription = |
| { |
| (VkSubpassDescriptionFlags)0u, // VkSubpassDescriptionFlags flags; |
| VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint |
| 0u, // deUint32 inputAttachmentCount |
| DE_NULL, // const VkAttachmentReference* pInputAttachments |
| 1u, // deUint32 colorAttachmentCount |
| &attachmentReference, // const VkAttachmentReference* pColorAttachments |
| DE_NULL, // const VkAttachmentReference* pResolveAttachments |
| DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment |
| 0u, // deUint32 preserveAttachmentCount |
| DE_NULL // const deUint32* pPreserveAttachments |
| }; |
| |
| const VkRenderPassCreateInfo renderPassCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkRenderPassCreateFlags)0u, // VkRenderPassCreateFlags flags; |
| 1u, // deUint32 attachmentCount |
| &attachmentDescription, // const VkAttachmentDescription* pAttachments |
| 1u, // deUint32 subpassCount |
| &subpassDescription, // const VkSubpassDescription* pSubpasses |
| 0u, // deUint32 dependencyCount |
| DE_NULL // const VkSubpassDependency* pDependencies |
| }; |
| |
| return renderPassCreateInfo; |
| } |
| |
| VkFormat getRenderTargetFormat (const InstanceInterface& vk, const VkPhysicalDevice& device) |
| { |
| const VkFormatFeatureFlags featureFlags = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; |
| VkFormatProperties formatProperties; |
| vk.getPhysicalDeviceFormatProperties(device, VK_FORMAT_B8G8R8A8_UNORM, &formatProperties); |
| if ((formatProperties.linearTilingFeatures & featureFlags) || (formatProperties.optimalTilingFeatures & featureFlags)) |
| return VK_FORMAT_B8G8R8A8_UNORM; |
| vk.getPhysicalDeviceFormatProperties(device, VK_FORMAT_R8G8B8A8_UNORM, &formatProperties); |
| if ((formatProperties.linearTilingFeatures & featureFlags) || formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) |
| return VK_FORMAT_R8G8B8A8_UNORM; |
| TCU_THROW(NotSupportedError, "Device does not support VK_FORMAT_B8G8R8A8_UNORM nor VK_FORMAT_R8G8B8A8_UNORM"); |
| return VK_FORMAT_UNDEFINED; |
| } |
| |
| } // vk |
| |
| #else |
| DE_EMPTY_CPP_FILE |
| #endif // CTS_USES_VULKANSC |
