X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=external%2Fvulkancts%2Fmodules%2Fvulkan%2Fimage%2FvktImageTestsUtil.cpp;h=a2db54eb38744e5f1a057070a2c643a1c68e91c8;hb=6cbd0fdde04085a6b91e8bd31964708473bbefa8;hp=1d70427682a0fddc3890572c9d129b348790c535;hpb=551ac0e858232244a916242ac580d0f75eebb572;p=platform%2Fupstream%2FVK-GL-CTS.git diff --git a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp index 1d70427..a2db54e 100644 --- a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp +++ b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp @@ -55,6 +55,102 @@ Image::Image (const DeviceInterface& vk, VK_CHECK(vk.bindImageMemory(device, *m_image, m_allocation->getMemory(), m_allocation->getOffset())); } +struct CompressedFormatParameters +{ + VkFormat format; + deUint32 blockBytes; + deUint32 blockWidth; + deUint32 blockHeight; +}; + +CompressedFormatParameters compressedFormatParameters[VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_BC1_RGB_UNORM_BLOCK + 1] = +{ + { VK_FORMAT_BC1_RGB_UNORM_BLOCK, 8, 4, 4 }, + { VK_FORMAT_BC1_RGB_SRGB_BLOCK, 8, 4, 4 }, + { VK_FORMAT_BC1_RGBA_UNORM_BLOCK, 8, 4, 4 }, + { VK_FORMAT_BC1_RGBA_SRGB_BLOCK, 8, 4, 4 }, + { VK_FORMAT_BC2_UNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC2_SRGB_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC3_UNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC3_SRGB_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC4_UNORM_BLOCK, 8, 4, 4 }, + { VK_FORMAT_BC4_SNORM_BLOCK, 8, 4, 4 }, + { VK_FORMAT_BC5_UNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC5_SNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC6H_UFLOAT_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC6H_SFLOAT_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC7_UNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_BC7_SRGB_BLOCK, 16, 4, 4 }, + { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, 8, 4, 4 }, + { VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, 8, 4, 4 }, + { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, 8, 4, 4 }, + { VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, 8, 4, 4 }, + { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, 16, 4, 4 }, + { VK_FORMAT_EAC_R11_UNORM_BLOCK, 8, 4, 4 }, + { VK_FORMAT_EAC_R11_SNORM_BLOCK, 8, 4, 4 }, + { VK_FORMAT_EAC_R11G11_UNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_EAC_R11G11_SNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_ASTC_4x4_UNORM_BLOCK, 16, 4, 4 }, + { VK_FORMAT_ASTC_4x4_SRGB_BLOCK, 16, 4, 4 }, + { VK_FORMAT_ASTC_5x4_UNORM_BLOCK, 16, 5, 4 }, + { VK_FORMAT_ASTC_5x4_SRGB_BLOCK, 16, 5, 4 }, + { VK_FORMAT_ASTC_5x5_UNORM_BLOCK, 16, 5, 5 }, + { VK_FORMAT_ASTC_5x5_SRGB_BLOCK, 16, 5, 5 }, + { VK_FORMAT_ASTC_6x5_UNORM_BLOCK, 16, 6, 5 }, + { VK_FORMAT_ASTC_6x5_SRGB_BLOCK, 16, 6, 5 }, + { VK_FORMAT_ASTC_6x6_UNORM_BLOCK, 16, 6, 6 }, + { VK_FORMAT_ASTC_6x6_SRGB_BLOCK, 16, 6, 6 }, + { VK_FORMAT_ASTC_8x5_UNORM_BLOCK, 16, 8, 5 }, + { VK_FORMAT_ASTC_8x5_SRGB_BLOCK, 16, 8, 5 }, + { VK_FORMAT_ASTC_8x6_UNORM_BLOCK, 16, 8, 6 }, + { VK_FORMAT_ASTC_8x6_SRGB_BLOCK, 16, 8, 6 }, + { VK_FORMAT_ASTC_8x8_UNORM_BLOCK, 16, 8, 8 }, + { VK_FORMAT_ASTC_8x8_SRGB_BLOCK, 16, 8, 8 }, + { VK_FORMAT_ASTC_10x5_UNORM_BLOCK, 16, 10, 5 }, + { VK_FORMAT_ASTC_10x5_SRGB_BLOCK, 16, 10, 5 }, + { VK_FORMAT_ASTC_10x6_UNORM_BLOCK, 16, 10, 6 }, + { VK_FORMAT_ASTC_10x6_SRGB_BLOCK, 16, 10, 6 }, + { VK_FORMAT_ASTC_10x8_UNORM_BLOCK, 16, 10, 8 }, + { VK_FORMAT_ASTC_10x8_SRGB_BLOCK, 16, 10, 8 }, + { VK_FORMAT_ASTC_10x10_UNORM_BLOCK, 16, 10, 10 }, + { VK_FORMAT_ASTC_10x10_SRGB_BLOCK, 16, 10, 10 }, + { VK_FORMAT_ASTC_12x10_UNORM_BLOCK, 16, 12, 10 }, + { VK_FORMAT_ASTC_12x10_SRGB_BLOCK, 16, 12, 10 }, + { VK_FORMAT_ASTC_12x12_UNORM_BLOCK, 16, 12, 12 }, + { VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 16, 12, 12 }, +}; + +deUint32 getBlockSizeInBytes(const VkFormat compressedFormat) +{ + deUint32 formatNdx = static_cast(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK); + + DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters))); + DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat); + + return compressedFormatParameters[formatNdx].blockBytes; +} + +deUint32 getBlockWidth(const VkFormat compressedFormat) +{ + deUint32 formatNdx = static_cast(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK); + + DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters))); + DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat); + + return compressedFormatParameters[formatNdx].blockWidth; +} + +deUint32 getBlockHeight(const VkFormat compressedFormat) +{ + deUint32 formatNdx = static_cast(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK); + + DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters))); + DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat); + + return compressedFormatParameters[formatNdx].blockHeight; +} + tcu::UVec3 getShaderGridSize (const ImageType imageType, const tcu::UVec3& imageSize) { switch (imageType) @@ -267,6 +363,316 @@ Move makeComputePipeline (const DeviceInterface& vk, return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo); } +Move makeGraphicsPipeline (const DeviceInterface& vk, + const VkDevice device, + const VkPipelineLayout pipelineLayout, + const VkRenderPass renderPass, + const VkShaderModule vertexModule, + const VkShaderModule fragmentModule, + const VkExtent2D renderSize, + const deUint32 colorAttachmentCount, + const bool dynamicSize) +{ + const VkFormat vertexFormatPosition = VK_FORMAT_R32G32B32A32_SFLOAT; + const deUint32 vertexSizePosition = tcu::getPixelSize(mapVkFormat(vertexFormatPosition)); + const deUint32 vertexBufferOffsetPosition = 0u; + const deUint32 vertexDataStride = vertexSizePosition; + + const VkVertexInputBindingDescription vertexBinding = + { + 0u, // deUint32 binding; + vertexDataStride, // deUint32 stride; + VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate; + }; + + const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] = + { + // position + { + 0u, // deUint32 location; + 0u, // deUint32 binding; + vertexFormatPosition, // VkFormat format; + vertexBufferOffsetPosition, // deUint32 offset; + }, + }; + + const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags; + 1u, // uint32_t vertexBindingDescriptionCount; + &vertexBinding, // const VkVertexInputBindingDescription* pVertexBindingDescriptions; + DE_LENGTH_OF_ARRAY(vertexInputAttributeDescriptions), // uint32_t vertexAttributeDescriptionCount; + vertexInputAttributeDescriptions, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; + }; + + const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags; + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology; + VK_FALSE, // VkBool32 primitiveRestartEnable; + }; + + const VkViewport viewport = + { + 0.0f, // float originX; + 0.0f, // float originY; + (float)renderSize.width, // float width; + (float)renderSize.height, // float height; + 0.0f, // float minDepth; + 1.0f // float maxDepth; + }; + + const VkRect2D scissor = + { + { 0u, 0u }, // VkOffset2D offset; + renderSize // VkExtent2D extent; + }; + + const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags; + 1u, // uint32_t viewportCount; + &viewport, // dynamic state // const VkViewport* pViewports; + 1u, // uint32_t scissorCount; + &scissor, // dynamic state // const VkRect2D* pScissors; + }; + + const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo = + { + 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_NONE, // VkCullModeFlags cullMode; + VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace; + VK_FALSE, // VkBool32 depthBiasEnable; + 0.0f, // float depthBiasConstantFactor; + 0.0f, // float depthBiasClamp; + 0.0f, // float depthBiasSlopeFactor; + 1.0f, // float lineWidth; + }; + + const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo = + { + 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; + }; + + const VkColorComponentFlags colorComponentsAll = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; + const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = + { + VK_FALSE, // VkBool32 blendEnable; + VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor; + VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor; + VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp; + VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor; + VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor; + VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp; + colorComponentsAll, // VkColorComponentFlags colorWriteMask; + }; + std::vector colorAttachments(colorAttachmentCount, colorBlendAttachmentState); + + const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags; + VK_FALSE, // VkBool32 logicOpEnable; + VK_LOGIC_OP_COPY, // VkLogicOp logicOp; + (deUint32)colorAttachments.size(), // deUint32 attachmentCount; + colorAttachments.size() != 0 ? &colorAttachments[0] : DE_NULL, // const VkPipelineColorBlendAttachmentState* pAttachments; + { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4]; + }; + + const VkPipelineShaderStageCreateInfo pShaderStages[] = + { + { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; + VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage; + vertexModule, // VkShaderModule module; + "main", // const char* pName; + DE_NULL, // const VkSpecializationInfo* pSpecializationInfo; + }, + { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; + VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage; + fragmentModule, // VkShaderModule module; + "main", // const char* pName; + DE_NULL, // const VkSpecializationInfo* pSpecializationInfo; + } + }; + const deUint32 numActiveShaderStages = DE_LENGTH_OF_ARRAY(pShaderStages); + + const VkDynamicState dynamicStates[] = + { + VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_SCISSOR, + }; + + const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineDynamicStateCreateFlags)0, // VkPipelineDynamicStateCreateFlags flags; + DE_LENGTH_OF_ARRAY(dynamicStates), // deUint32 dynamicStateCount; + dynamicStates, // const VkDynamicState* pDynamicStates; + }; + + const VkGraphicsPipelineCreateInfo graphicsPipelineInfo = + { + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags; + numActiveShaderStages, // deUint32 stageCount; + pShaderStages, // const VkPipelineShaderStageCreateInfo* pStages; + &vertexInputStateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + &pipelineInputAssemblyStateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState; + &pipelineViewportStateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState; + &pipelineRasterizationStateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + &pipelineMultisampleStateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + &pipelineColorBlendStateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + dynamicSize ? &dynamicStateCreateInfo : DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState; + pipelineLayout, // VkPipelineLayout layout; + renderPass, // VkRenderPass renderPass; + 0u, // deUint32 subpass; + DE_NULL, // VkPipeline basePipelineHandle; + 0, // deInt32 basePipelineIndex; + }; + + return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo); +} + +//! A single-subpass render pass. +Move makeRenderPass (const DeviceInterface& vk, + const VkDevice device, + const VkFormat inputFormat, + const VkFormat colorFormat) +{ + const VkAttachmentReference inputAttachmentRef = + { + 0u, // deUint32 attachment; + VK_IMAGE_LAYOUT_GENERAL // VkImageLayout layout; + }; + + const VkAttachmentReference colorAttachmentRef = + { + 1u, // deUint32 attachment; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; + }; + + const VkSubpassDescription subpassDescription = + { + (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags; + VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; + 1u, // deUint32 inputAttachmentCount; + &inputAttachmentRef, // const VkAttachmentReference* pInputAttachments; + 1u, // deUint32 colorAttachmentCount; + &colorAttachmentRef, // const VkAttachmentReference* pColorAttachments; + DE_NULL, // const VkAttachmentReference* pResolveAttachments; + DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; + 0u, // deUint32 preserveAttachmentCount; + DE_NULL // const deUint32* pPreserveAttachments; + }; + + const VkAttachmentDescription attachmentsDescriptions[] = + { + //inputAttachmentDescription, + { + (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags; + inputFormat, // VkFormat format; + VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; + VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp; + VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp; + VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; + VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; + VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout; + VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout; + }, + //colorAttachmentDescription + { + (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags; + colorFormat, // 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_GENERAL, // VkImageLayout finalLayout; + } + }; + + const VkRenderPassCreateInfo renderPassInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags; + DE_LENGTH_OF_ARRAY(attachmentsDescriptions), // deUint32 attachmentCount; + attachmentsDescriptions, // const VkAttachmentDescription* pAttachments; + 1u, // deUint32 subpassCount; + &subpassDescription, // const VkSubpassDescription* pSubpasses; + 0u, // deUint32 dependencyCount; + DE_NULL // const VkSubpassDependency* pDependencies; + }; + + return createRenderPass(vk, device, &renderPassInfo); +} + +//! A single-subpass render pass. +Move makeRenderPass (const DeviceInterface& vk, + const VkDevice device) +{ + const VkSubpassDescription subpassDescription = + { + (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags; + VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; + 0u, // deUint32 inputAttachmentCount; + DE_NULL, // const VkAttachmentReference* pInputAttachments; + 0u, // deUint32 colorAttachmentCount; + DE_NULL, // const VkAttachmentReference* pColorAttachments; + DE_NULL, // const VkAttachmentReference* pResolveAttachments; + DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; + 0u, // deUint32 preserveAttachmentCount; + DE_NULL // const deUint32* pPreserveAttachments; + }; + + const VkRenderPassCreateInfo renderPassInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags; + 0, // deUint32 attachmentCount; + DE_NULL, // const VkAttachmentDescription* pAttachments; + 1u, // deUint32 subpassCount; + &subpassDescription, // const VkSubpassDescription* pSubpasses; + 0u, // deUint32 dependencyCount; + DE_NULL // const VkSubpassDependency* pDependencies; + }; + + return createRenderPass(vk, device, &renderPassInfo); +} + Move makeBufferView (const DeviceInterface& vk, const VkDevice vkDevice, const VkBuffer buffer, @@ -287,17 +693,18 @@ Move makeBufferView (const DeviceInterface& vk, return createBufferView(vk, vkDevice, &bufferViewParams); } -Move makeImageView (const DeviceInterface& vk, - const VkDevice vkDevice, - const VkImage image, - const VkImageViewType imageViewType, - const VkFormat format, - const VkImageSubresourceRange subresourceRange) +Move makeImageView (const DeviceInterface& vk, + const VkDevice vkDevice, + const VkImage image, + const VkImageViewType imageViewType, + const VkFormat format, + const VkImageSubresourceRange subresourceRange, + const VkImageViewUsageCreateInfoKHR* ImageUsageCreateInfoKHR) { const VkImageViewCreateInfo imageViewParams = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; - DE_NULL, // const void* pNext; + ImageUsageCreateInfoKHR, // const void* pNext; 0u, // VkImageViewCreateFlags flags; image, // VkImage image; imageViewType, // VkImageViewType viewType; @@ -356,8 +763,8 @@ VkImageMemoryBarrier makeImageMemoryBarrier (const VkAccessFlags srcAccessMask { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; DE_NULL, // const void* pNext; - srcAccessMask, // VkAccessFlags outputMask; - dstAccessMask, // VkAccessFlags inputMask; + srcAccessMask, // VkAccessFlags srcAccessMask; + dstAccessMask, // VkAccessFlags dstAccessMask; oldLayout, // VkImageLayout oldLayout; newLayout, // VkImageLayout newLayout; VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; @@ -368,6 +775,45 @@ VkImageMemoryBarrier makeImageMemoryBarrier (const VkAccessFlags srcAccessMask return barrier; } +VkImageViewUsageCreateInfoKHR makeImageViewUsageCreateInfo (const VkImageUsageFlags imageUsageFlags) +{ + VkImageViewUsageCreateInfoKHR imageViewUsageCreateInfoKHR = + { + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType; + DE_NULL, //const void* pNext; + imageUsageFlags, //VkImageUsageFlags usage; + }; + + return imageViewUsageCreateInfoKHR; +} + +VkSamplerCreateInfo makeSamplerCreateInfo () +{ + const VkSamplerCreateInfo defaultSamplerParams = + { + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkSamplerCreateFlags flags; + VK_FILTER_NEAREST, // VkFilter magFilter; + VK_FILTER_NEAREST, // VkFilter minFilter; + VK_SAMPLER_MIPMAP_MODE_NEAREST, // VkSamplerMipmapMode mipmapMode; + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU; + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV; + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW; + 0.0f, // float mipLodBias; + VK_FALSE, // VkBool32 anisotropyEnable; + 1.0f, // float maxAnisotropy; + VK_FALSE, // VkBool32 compareEnable; + VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; + 0.0f, // float minLod; + 0.25f, // float maxLod; + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor; + VK_FALSE // VkBool32 unnormalizedCoordinates; + }; + + return defaultSamplerParams; +} + void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer) { const VkCommandBufferBeginInfo commandBufBeginParams = @@ -393,21 +839,66 @@ void submitCommandsAndWait (const DeviceInterface& vk, const VkSubmitInfo submitInfo = { - VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; - DE_NULL, // const void* pNext; - 0u, // deUint32 waitSemaphoreCount; - DE_NULL, // const VkSemaphore* pWaitSemaphores; - (const VkPipelineStageFlags*)DE_NULL, - 1u, // deUint32 commandBufferCount; - &commandBuffer, // const VkCommandBuffer* pCommandBuffers; - 0u, // deUint32 signalSemaphoreCount; - DE_NULL, // const VkSemaphore* pSignalSemaphores; + VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // deUint32 waitSemaphoreCount; + DE_NULL, // const VkSemaphore* pWaitSemaphores; + (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask; + 1u, // deUint32 commandBufferCount; + &commandBuffer, // const VkCommandBuffer* pCommandBuffers; + 0u, // deUint32 signalSemaphoreCount; + DE_NULL, // const VkSemaphore* pSignalSemaphores; }; VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence)); VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull)); } +tcu::UVec3 getCompressedImageResolutionInBlocks (const vk::VkFormat format, const tcu::UVec3& size) +{ + deUint32 blockWidth = getBlockWidth(format); + deUint32 blockHeight = getBlockHeight(format); + + DE_ASSERT(size[2] == 1); + DE_ASSERT(blockWidth != 0 && blockHeight != 0); + + deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth; + deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight; + + return tcu::UVec3(widthInBlocks, heightInBlocks, 1); +} + +tcu::UVec3 getCompressedImageResolutionBlockCeil (const vk::VkFormat format, const tcu::UVec3& size) +{ + deUint32 blockWidth = getBlockWidth(format); + deUint32 blockHeight = getBlockHeight(format); + + DE_ASSERT(size[2] == 1); + DE_ASSERT(blockWidth != 0 && blockHeight != 0); + + deUint32 widthInBlocks = (size[0] + blockWidth - 1) / blockWidth; + deUint32 heightInBlocks = (size[1] + blockHeight - 1) / blockHeight; + + return tcu::UVec3(blockWidth * widthInBlocks, blockHeight * heightInBlocks, 1); +} + +VkDeviceSize getCompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size) +{ + tcu::UVec3 sizeInBlocks = getCompressedImageResolutionInBlocks(format, size); + deUint32 blockBytes = getBlockSizeInBytes(format); + VkDeviceSize sizeBytes = sizeInBlocks[0] * sizeInBlocks[1] * sizeInBlocks[2] * blockBytes; + + return sizeBytes; +} + +VkDeviceSize getUncompressedImageSizeInBytes (const vk::VkFormat format, const tcu::UVec3& size) +{ + const tcu::IVec3 sizeAsIVec3 = tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z()); + const VkDeviceSize sizeBytes = getImageSizeBytes(sizeAsIVec3, format); + + return sizeBytes; +} + VkImageType mapImageType (const ImageType imageType) { switch (imageType) @@ -551,6 +1042,206 @@ std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format) return std::string() + orderPart + typePart; } +std::string getGlslSamplerType (const tcu::TextureFormat& format, VkImageViewType type) +{ + const char* typePart = DE_NULL; + const char* formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" : + tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : ""; + + switch (type) + { + case VK_IMAGE_VIEW_TYPE_1D: typePart = "sampler1D"; break; + case VK_IMAGE_VIEW_TYPE_1D_ARRAY: typePart = "sampler1DArray"; break; + case VK_IMAGE_VIEW_TYPE_2D: typePart = "sampler2D"; break; + case VK_IMAGE_VIEW_TYPE_2D_ARRAY: typePart = "sampler2DArray"; break; + case VK_IMAGE_VIEW_TYPE_3D: typePart = "sampler3D"; break; + case VK_IMAGE_VIEW_TYPE_CUBE: typePart = "samplerCube"; break; + case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: typePart = "samplerCubeArray"; break; + + default: + DE_FATAL("Unknown image view type"); + break; + } + + return std::string(formatPart) + typePart; +} + + +const char* getGlslInputFormatType (const vk::VkFormat format) +{ + switch (format) + { + // 64-bit + case VK_FORMAT_R16G16B16A16_UNORM: return "subpassInput"; + case VK_FORMAT_R16G16B16A16_SNORM: return "subpassInput"; + case VK_FORMAT_R16G16B16A16_USCALED: return "subpassInput"; + case VK_FORMAT_R16G16B16A16_SSCALED: return "subpassInput"; + case VK_FORMAT_R16G16B16A16_UINT: return "usubpassInput"; + case VK_FORMAT_R16G16B16A16_SINT: return "isubpassInput"; + case VK_FORMAT_R16G16B16A16_SFLOAT: return "subpassInput"; + case VK_FORMAT_R32G32_UINT: return "usubpassInput"; + case VK_FORMAT_R32G32_SINT: return "isubpassInput"; + case VK_FORMAT_R32G32_SFLOAT: return "subpassInput"; + // TODO: case VK_FORMAT_R64_UINT: return "usubpassInput"; + // TODO: case VK_FORMAT_R64_SINT: return "isubpassInput"; + // TODO: case VK_FORMAT_R64_SFLOAT: return "subpassInput"; + + // 128-bit + case VK_FORMAT_R32G32B32A32_UINT: return "usubpassInput"; + case VK_FORMAT_R32G32B32A32_SINT: return "isubpassInput"; + case VK_FORMAT_R32G32B32A32_SFLOAT: return "subpassInput"; + // TODO: case VK_FORMAT_R64G64_UINT: return "usubpassInput"; + // TODO: case VK_FORMAT_R64G64_SINT: return "isubpassInput"; + // TODO: case VK_FORMAT_R64G64_SFLOAT: return "subpassInput"; + + default: TCU_THROW(InternalError, "Unknown format"); + } +} + +const char* getGlslFormatType (const vk::VkFormat format) +{ + switch (format) + { + // 64-bit + case VK_FORMAT_R16G16B16A16_UNORM: return "vec4"; + case VK_FORMAT_R16G16B16A16_SNORM: return "vec4"; + case VK_FORMAT_R16G16B16A16_USCALED: return "vec4"; + case VK_FORMAT_R16G16B16A16_SSCALED: return "vec4"; + case VK_FORMAT_R16G16B16A16_UINT: return "uvec4"; + case VK_FORMAT_R16G16B16A16_SINT: return "ivec4"; + case VK_FORMAT_R16G16B16A16_SFLOAT: return "vec4"; + case VK_FORMAT_R32G32_UINT: return "uvec2"; + case VK_FORMAT_R32G32_SINT: return "ivec2"; + case VK_FORMAT_R32G32_SFLOAT: return "vec2"; + // TODO: case VK_FORMAT_R64_UINT: return "uint64"; + // TODO: case VK_FORMAT_R64_SINT: return "int64"; + // TODO: case VK_FORMAT_R64_SFLOAT: return "double"; + + // 128-bit + case VK_FORMAT_R32G32B32A32_UINT: return "uvec4"; + case VK_FORMAT_R32G32B32A32_SINT: return "ivec4"; + case VK_FORMAT_R32G32B32A32_SFLOAT: return "vec4"; + // TODO: case VK_FORMAT_R64G64_UINT: return "ulvec2"; + // TODO: case VK_FORMAT_R64G64_SINT: return "ilvec2"; + // TODO: case VK_FORMAT_R64G64_SFLOAT: return "dvec2"; + + default: TCU_THROW(InternalError, "Unknown format"); + } +} + +const char* getGlslAttachmentType (const vk::VkFormat format) +{ + const tcu::TextureFormat textureFormat = mapVkFormat(format); + const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(textureFormat.type); + + switch (channelClass) + { + case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: + return "ivec4"; + + case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: + return "uvec4"; + + case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: + case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: + case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: + return "vec4"; + + default: + DE_FATAL("Unknown channel class"); + return ""; + } +} + +const char* getGlslInputAttachmentType (const vk::VkFormat format) +{ + const tcu::TextureFormat textureFormat = mapVkFormat(format); + const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(textureFormat.type); + + switch (channelClass) + { + case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: + return "isubpassInput"; + + case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: + return "usubpassInput"; + + case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: + case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: + case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: + return "subpassInput"; + + default: + DE_FATAL("Unknown channel class"); + return ""; + } +} + +bool isPackedType (const vk::VkFormat format) +{ + const tcu::TextureFormat textureFormat = mapVkFormat(format); + + DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST == 40); + + switch (textureFormat.type) + { + case tcu::TextureFormat::UNORM_BYTE_44: + case tcu::TextureFormat::UNORM_SHORT_565: + case tcu::TextureFormat::UNORM_SHORT_555: + case tcu::TextureFormat::UNORM_SHORT_4444: + case tcu::TextureFormat::UNORM_SHORT_5551: + case tcu::TextureFormat::UNORM_SHORT_1555: + case tcu::TextureFormat::UNORM_INT_101010: + case tcu::TextureFormat::SNORM_INT_1010102_REV: + case tcu::TextureFormat::UNORM_INT_1010102_REV: + case tcu::TextureFormat::UNSIGNED_BYTE_44: + case tcu::TextureFormat::UNSIGNED_SHORT_565: + case tcu::TextureFormat::UNSIGNED_SHORT_4444: + case tcu::TextureFormat::UNSIGNED_SHORT_5551: + case tcu::TextureFormat::SIGNED_INT_1010102_REV: + case tcu::TextureFormat::UNSIGNED_INT_1010102_REV: + case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: + case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV: + case tcu::TextureFormat::UNSIGNED_INT_16_8_8: + case tcu::TextureFormat::UNSIGNED_INT_24_8: + case tcu::TextureFormat::UNSIGNED_INT_24_8_REV: + return true; + + default: + return false; + } +} + +bool isComponentSwizzled (const vk::VkFormat format) +{ + const tcu::TextureFormat textureFormat = mapVkFormat(format); + + DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21); + + switch (textureFormat.order) + { + case tcu::TextureFormat::ARGB: + case tcu::TextureFormat::BGR: + case tcu::TextureFormat::BGRA: + case tcu::TextureFormat::sBGR: + case tcu::TextureFormat::sBGRA: + return true; + + default: + return false; + } +} + +int getNumUsedChannels (const vk::VkFormat format) +{ + // make sure this function will be checked if type table is updated + DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21); + + const tcu::TextureFormat textureFormat = mapVkFormat(format); + + return getNumUsedChannels(textureFormat.order); +} + std::string getFormatShortString (const VkFormat format) { const std::string fullName = getFormatName(format); @@ -560,5 +1251,140 @@ std::string getFormatShortString (const VkFormat format) return de::toLower(fullName.substr(10)); } +std::vector createFullscreenQuad (void) +{ + const tcu::Vec4 lowerLeftVertex (-1.0f, -1.0f, 0.0f, 1.0f); + const tcu::Vec4 upperLeftVertex (-1.0f, 1.0f, 0.0f, 1.0f); + const tcu::Vec4 lowerRightVertex (1.0f, -1.0f, 0.0f, 1.0f); + const tcu::Vec4 upperRightVertex (1.0f, 1.0f, 0.0f, 1.0f); + + const tcu::Vec4 vertices[6] = + { + lowerLeftVertex, + lowerRightVertex, + upperLeftVertex, + + upperLeftVertex, + lowerRightVertex, + upperRightVertex + }; + + return std::vector(vertices, vertices + DE_LENGTH_OF_ARRAY(vertices)); +} + +vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer) +{ + const VkBufferImageCopy copyParams = + { + (VkDeviceSize)0u, // bufferOffset + imageWidth, // bufferRowLength + imageHeight, // bufferImageHeight + { + VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask + mipLevel, // mipLevel + layer, // baseArrayLayer + 1u, // layerCount + }, // imageSubresource + { 0u, 0u, 0u }, // imageOffset + { + imageWidth, + imageHeight, + 1u + } // imageExtent + }; + + return copyParams; +} + +vk::VkBufferImageCopy makeBufferImageCopy (const deUint32 imageWidth, const deUint32 imageHeight, const deUint32 mipLevel, const deUint32 layer, const deUint32 bufferRowLength, const deUint32 bufferImageHeight) +{ + const VkBufferImageCopy copyParams = + { + (VkDeviceSize)0u, // bufferOffset + bufferRowLength, // bufferRowLength + bufferImageHeight, // bufferImageHeight + { + VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask + mipLevel, // mipLevel + layer, // baseArrayLayer + 1u, // layerCount + }, // imageSubresource + { 0u, 0u, 0u }, // imageOffset + { + imageWidth, + imageHeight, + 1u + } // imageExtent + }; + + return copyParams; +} + +void beginRenderPass (const DeviceInterface& vk, + const VkCommandBuffer commandBuffer, + const VkRenderPass renderPass, + const VkFramebuffer framebuffer, + const VkExtent2D& renderSize) +{ + const VkClearValue clearValues[] = + { + makeClearValueColorF32(0.0, 0.0, 0.0, 0.0), + makeClearValueColorF32(0.0, 0.0, 0.0, 0.0), + }; + const VkRect2D renderArea = + { + {0, 0}, // VkOffset2D offset; + renderSize, // VkExtent2D extent; + }; + const VkRenderPassBeginInfo renderPassBeginInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + renderPass, // VkRenderPass renderPass; + framebuffer, // VkFramebuffer framebuffer; + renderArea, // VkRect2D renderArea; + DE_LENGTH_OF_ARRAY(clearValues), // uint32_t clearValueCount; + clearValues, // const VkClearValue* pClearValues; + }; + + vk.cmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); +} + +Move makeFramebuffer (const DeviceInterface& vk, + const VkDevice device, + const VkRenderPass renderPass, + const deUint32 attachmentCount, + const VkImageView* pAttachments, + const VkExtent2D& size, + const deUint32 layersCount) +{ + const vk::VkFramebufferCreateInfo framebufferInfo = + { + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags; + renderPass, // VkRenderPass renderPass; + attachmentCount, // uint32_t attachmentCount; + pAttachments, // const VkImageView* pAttachments; + static_cast(size.width), // uint32_t width; + static_cast(size.height), // uint32_t height; + layersCount, // uint32_t layers; + }; + + return createFramebuffer(vk, device, &framebufferInfo); +} + +VkRect2D makeScissor (const deUint32 width, + const deUint32 height) +{ + const VkRect2D scissor = + { + { 0u, 0u }, // VkOffset2D offset; + { width, height } // VkExtent2D extent; + }; + + return scissor; +} + } // image } // vkt