From db4efd02b79d71e0d0b1122d01d1a20b37760527 Mon Sep 17 00:00:00 2001 From: scygan Date: Wed, 16 Dec 2015 19:14:34 +0100 Subject: [PATCH] Fixup review comments --- .../modules/vulkan/dynamic_state/CMakeLists.txt | 1 + .../dynamic_state/vktDynamicStateBaseClass.cpp | 280 ++++++++++++++ .../dynamic_state/vktDynamicStateBaseClass.hpp | 313 ++-------------- .../vktDynamicStateBufferObjectUtil.cpp | 22 +- .../vktDynamicStateBufferObjectUtil.hpp | 19 +- .../dynamic_state/vktDynamicStateCBTests.cpp | 58 +-- .../dynamic_state/vktDynamicStateCBTests.hpp | 15 +- .../vktDynamicStateCreateInfoUtil.cpp | 57 ++- .../vktDynamicStateCreateInfoUtil.hpp | 408 ++++++++++----------- .../dynamic_state/vktDynamicStateDSTests.cpp | 177 ++++----- .../dynamic_state/vktDynamicStateDSTests.hpp | 14 +- .../dynamic_state/vktDynamicStateGeneralTests.cpp | 166 ++++----- .../dynamic_state/vktDynamicStateGeneralTests.hpp | 18 +- .../vktDynamicStateImageObjectUtil.cpp | 67 ++-- .../vktDynamicStateImageObjectUtil.hpp | 36 +- .../dynamic_state/vktDynamicStateRSTests.cpp | 220 ++++++----- .../dynamic_state/vktDynamicStateRSTests.hpp | 11 +- .../dynamic_state/vktDynamicStateTestCaseUtil.hpp | 16 +- .../vulkan/dynamic_state/vktDynamicStateTests.cpp | 2 +- .../vulkan/dynamic_state/vktDynamicStateTests.hpp | 4 +- .../dynamic_state/vktDynamicStateVPTests.cpp | 89 ++--- .../dynamic_state/vktDynamicStateVPTests.hpp | 15 +- .../vulkancts/modules/vulkan/vktTestPackage.cpp | 1 - 23 files changed, 1002 insertions(+), 1007 deletions(-) create mode 100644 external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.cpp diff --git a/external/vulkancts/modules/vulkan/dynamic_state/CMakeLists.txt b/external/vulkancts/modules/vulkan/dynamic_state/CMakeLists.txt index 80da533..6870be1 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/CMakeLists.txt +++ b/external/vulkancts/modules/vulkan/dynamic_state/CMakeLists.txt @@ -3,6 +3,7 @@ include_directories(..) set(DEQP_VK_DYNAMIC_STATE_SRCS vktDynamicStateTestCaseUtil.hpp vktDynamicStateBaseClass.hpp + vktDynamicStateBaseClass.cpp vktDynamicStateCBTests.cpp vktDynamicStateCBTests.hpp vktDynamicStateDSTests.cpp diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.cpp new file mode 100644 index 0000000..6124017 --- /dev/null +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.cpp @@ -0,0 +1,280 @@ +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2015 The Khronos Group Inc. + * Copyright (c) 2015 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice(s) and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * The Materials are Confidential Information as defined by the + * Khronos Membership Agreement until designated non-confidential by Khronos, + * at which point this condition clause shall be removed. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + * + *//*! + * \file + * \brief Dynamic State Tests - Base Class + *//*--------------------------------------------------------------------*/ + +#include "vktDynamicStateBaseClass.hpp" + +#include "vkPrograms.hpp" + +namespace vkt +{ +namespace DynamicState +{ + +DynamicStateBaseClass::DynamicStateBaseClass (Context& context, const char* vertexShaderName, const char* fragmentShaderName) + : TestInstance (context) + , m_colorAttachmentFormat (vk::VK_FORMAT_R8G8B8A8_UNORM) + , m_topology (vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP) + , m_vertexShaderName (vertexShaderName) + , m_fragmentShaderName (fragmentShaderName) + , m_vk (context.getDeviceInterface()) +{ +} + +void DynamicStateBaseClass::initialize (void) +{ + tcu::TestLog& log = m_context.getTestContext().getLog(); + const vk::VkDevice device = m_context.getDevice(); + const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); + + const PipelineLayoutCreateInfo pipelineLayoutCreateInfo; + m_pipelineLayout = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo); + + const vk::VkExtent3D targetImageExtent = { WIDTH, HEIGHT, 1 }; + const ImageCreateInfo targetImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, targetImageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, + vk::VK_IMAGE_TILING_OPTIMAL, vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT); + + m_colorTargetImage = Image::createAndAlloc(m_vk, device, targetImageCreateInfo, m_context.getDefaultAllocator()); + + const ImageViewCreateInfo colorTargetViewInfo(m_colorTargetImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat); + m_colorTargetView = vk::createImageView(m_vk, device, &colorTargetViewInfo); + + RenderPassCreateInfo renderPassCreateInfo; + renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat, + vk::VK_SAMPLE_COUNT_1_BIT, + vk::VK_ATTACHMENT_LOAD_OP_LOAD, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_IMAGE_LAYOUT_GENERAL, + vk::VK_IMAGE_LAYOUT_GENERAL)); + + const vk::VkAttachmentReference colorAttachmentReference = + { + 0, + vk::VK_IMAGE_LAYOUT_GENERAL + }; + + renderPassCreateInfo.addSubpass(SubpassDescription( + vk::VK_PIPELINE_BIND_POINT_GRAPHICS, + 0, + 0, + DE_NULL, + 1, + &colorAttachmentReference, + DE_NULL, + AttachmentReference(), + 0, + DE_NULL + ) + ); + + m_renderPass = vk::createRenderPass(m_vk, device, &renderPassCreateInfo); + + std::vector colorAttachments(1); + colorAttachments[0] = *m_colorTargetView; + + const FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, colorAttachments, WIDTH, HEIGHT, 1); + + m_framebuffer = vk::createFramebuffer(m_vk, device, &framebufferCreateInfo); + + const vk::VkVertexInputBindingDescription vertexInputBindingDescription = + { + 0, + sizeof(tcu::Vec4) * 2, + vk::VK_VERTEX_INPUT_RATE_VERTEX, + }; + + const vk::VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] = + { + { + 0u, + 0u, + vk::VK_FORMAT_R32G32B32A32_SFLOAT, + 0u + }, + { + 1u, + 0u, + vk::VK_FORMAT_R32G32B32A32_SFLOAT, + (deUint32)(sizeof(float)* 4), + } + }; + + m_vertexInputState = PipelineCreateInfo::VertexInputState( + 1, + &vertexInputBindingDescription, + 2, + vertexInputAttributeDescriptions); + + const vk::VkDeviceSize dataSize = m_data.size() * sizeof(PositionColorVertex); + m_vertexBuffer = Buffer::createAndAlloc(m_vk, device, BufferCreateInfo(dataSize, vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), + m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible); + + deUint8* ptr = reinterpret_cast(m_vertexBuffer->getBoundMemory().getHostPtr()); + deMemcpy(ptr, &m_data[0], dataSize); + + vk::flushMappedMemoryRange(m_vk, device, + m_vertexBuffer->getBoundMemory().getMemory(), + m_vertexBuffer->getBoundMemory().getOffset(), + dataSize); + + const CmdPoolCreateInfo cmdPoolCreateInfo(queueFamilyIndex); + m_cmdPool = vk::createCommandPool(m_vk, device, &cmdPoolCreateInfo); + + const vk::VkCommandBufferAllocateInfo cmdBufferAllocateInfo = + { + vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *m_cmdPool, // VkCommandPool commandPool; + vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level; + 1u, // deUint32 bufferCount; + }; + m_cmdBuffer = vk::allocateCommandBuffer(m_vk, device, &cmdBufferAllocateInfo); + + initPipeline(device); +} + +void DynamicStateBaseClass::initPipeline (const vk::VkDevice device) +{ + const vk::Unique vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0)); + const vk::Unique fs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_fragmentShaderName), 0)); + + const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState; + + PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, 0); + pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", vk::VK_SHADER_STAGE_VERTEX_BIT)); + pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", vk::VK_SHADER_STAGE_FRAGMENT_BIT)); + pipelineCreateInfo.addState(PipelineCreateInfo::VertexInputState(m_vertexInputState)); + pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(m_topology)); + pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &vkCbAttachmentState)); + pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1)); + pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState()); + pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState()); + pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState()); + pipelineCreateInfo.addState(PipelineCreateInfo::DynamicState()); + + m_pipeline = vk::createGraphicsPipeline(m_vk, device, DE_NULL, &pipelineCreateInfo); +} + +tcu::TestStatus DynamicStateBaseClass::iterate (void) +{ + DE_ASSERT(false); + return tcu::TestStatus::fail("Implement iterate() method!"); +} + +void DynamicStateBaseClass::beginRenderPass (void) +{ + const vk::VkClearColorValue clearColor = { { 0.0f, 0.0f, 0.0f, 1.0f } }; + beginRenderPassWithClearColor(clearColor); +} + +void DynamicStateBaseClass::beginRenderPassWithClearColor (const vk::VkClearColorValue& clearColor) +{ + const CmdBufferBeginInfo beginInfo; + m_vk.beginCommandBuffer(*m_cmdBuffer, &beginInfo); + + initialTransitionColor2DImage(m_vk, *m_cmdBuffer, m_colorTargetImage->object(), vk::VK_IMAGE_LAYOUT_GENERAL); + + const ImageSubresourceRange subresourceRange(vk::VK_IMAGE_ASPECT_COLOR_BIT); + m_vk.cmdClearColorImage(*m_cmdBuffer, m_colorTargetImage->object(), + vk::VK_IMAGE_LAYOUT_GENERAL, &clearColor, 1, &subresourceRange); + + const vk::VkRect2D renderArea = { { 0, 0 }, { WIDTH, HEIGHT } }; + const RenderPassBeginInfo renderPassBegin(*m_renderPass, *m_framebuffer, renderArea); + + m_vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE); +} + +void DynamicStateBaseClass::setDynamicViewportState (const deUint32 width, const deUint32 height) +{ + vk::VkViewport viewport; + viewport.x = 0; + viewport.y = 0; + viewport.width = static_cast(width); + viewport.height = static_cast(height); + viewport.minDepth = 0.0f; + viewport.maxDepth = 1.0f; + + m_vk.cmdSetViewport(*m_cmdBuffer, 1, &viewport); + + vk::VkRect2D scissor; + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent.width = width; + scissor.extent.height = height; + m_vk.cmdSetScissor(*m_cmdBuffer, 1, &scissor); +} + +void DynamicStateBaseClass::setDynamicViewportState (deUint32 viewportCount, const vk::VkViewport* pViewports, const vk::VkRect2D* pScissors) +{ + m_vk.cmdSetViewport(*m_cmdBuffer, viewportCount, pViewports); + m_vk.cmdSetScissor(*m_cmdBuffer, viewportCount, pScissors); +} + +void DynamicStateBaseClass::setDynamicRasterizationState (const float lineWidth, + const float depthBiasConstantFactor, + const float depthBiasClamp, + const float depthBiasSlopeFactor) +{ + m_vk.cmdSetLineWidth(*m_cmdBuffer, lineWidth); + m_vk.cmdSetDepthBias(*m_cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); +} + +void DynamicStateBaseClass::setDynamicBlendState (const float const1, const float const2, const float const3, const float const4) +{ + float blendConstantsants[4] = { const1, const2, const3, const4 }; + m_vk.cmdSetBlendConstants(*m_cmdBuffer, blendConstantsants); +} + +void DynamicStateBaseClass::setDynamicDepthStencilState (const float minDepthBounds, + const float maxDepthBounds, + const deUint32 stencilFrontCompareMask, + const deUint32 stencilFrontWriteMask, + const deUint32 stencilFrontReference, + const deUint32 stencilBackCompareMask, + const deUint32 stencilBackWriteMask, + const deUint32 stencilBackReference) +{ + m_vk.cmdSetDepthBounds(*m_cmdBuffer, minDepthBounds, maxDepthBounds); + m_vk.cmdSetStencilCompareMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontCompareMask); + m_vk.cmdSetStencilWriteMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontWriteMask); + m_vk.cmdSetStencilReference(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontReference); + m_vk.cmdSetStencilCompareMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackCompareMask); + m_vk.cmdSetStencilWriteMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackWriteMask); + m_vk.cmdSetStencilReference(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackReference); +} + +} // DynamicState +} // vkt diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.hpp index e5187e8..03877f0 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBaseClass.hpp @@ -37,64 +37,55 @@ #include "vktTestCase.hpp" -#include "tcuTestLog.hpp" -#include "tcuResource.hpp" -#include "tcuImageCompare.hpp" -#include "tcuCommandLine.hpp" - -#include "vkRefUtil.hpp" -#include "vkImageUtil.hpp" - -#include "vktDynamicStateCreateInfoUtil.hpp" +#include "vktDynamicStateTestCaseUtil.hpp" #include "vktDynamicStateImageObjectUtil.hpp" #include "vktDynamicStateBufferObjectUtil.hpp" -#include "vkPrograms.hpp" +#include "vktDynamicStateCreateInfoUtil.hpp" namespace vkt { namespace DynamicState { - -inline tcu::Vec4 vec4Red (void) -{ - return tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f); -} - -inline tcu::Vec4 vec4Green (void) -{ - return tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f); -} - -inline tcu::Vec4 vec4Blue (void) -{ - return tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f); -} - -struct Vec4RGBA -{ - Vec4RGBA(tcu::Vec4 p, tcu::Vec4 c) - : position(p) - , color(c) - {} - tcu::Vec4 position; - tcu::Vec4 color; -}; class DynamicStateBaseClass : public TestInstance { public: - DynamicStateBaseClass(Context &context, const char* vertexShaderName, const char* fragmentShaderName) - : TestInstance (context) - , m_colorAttachmentFormat (vk::VK_FORMAT_R8G8B8A8_UNORM) - , m_topology (vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP) - , m_vertexShaderName (vertexShaderName) - , m_fragmentShaderName (fragmentShaderName) - , m_vk (context.getDeviceInterface()) - { - } + DynamicStateBaseClass (Context& context, const char* vertexShaderName, const char* fragmentShaderName); protected: + void initialize (void); + + virtual void initPipeline (const vk::VkDevice device); + + virtual tcu::TestStatus iterate (void); + + void beginRenderPass (void); + + void beginRenderPassWithClearColor (const vk::VkClearColorValue& clearColor); + void setDynamicViewportState (const deUint32 width, + const deUint32 height); + + void setDynamicViewportState (deUint32 viewportCount, + const vk::VkViewport* pViewports, + const vk::VkRect2D* pScissors); + + void setDynamicRasterizationState (const float lineWidth = 1.0f, + const float depthBiasConstantFactor = 0.0f, + const float depthBiasClamp = 0.0f, + const float depthBiasSlopeFactor = 0.0f); + + void setDynamicBlendState (const float const1 = 0.0f, const float const2 = 0.0f, + const float const3 = 0.0f, const float const4 = 0.0f); + + void setDynamicDepthStencilState (const float minDepthBounds = -1.0f, + const float maxDepthBounds = 1.0f, + const deUint32 stencilFrontCompareMask = 0xffffffffu, + const deUint32 stencilFrontWriteMask = 0xffffffffu, + const deUint32 stencilFrontReference = 0, + const deUint32 stencilBackCompareMask = 0xffffffffu, + const deUint32 stencilBackWriteMask = 0xffffffffu, + const deUint32 stencilBackReference = 0); enum { WIDTH = 128, @@ -124,238 +115,10 @@ protected: const std::string m_vertexShaderName; const std::string m_fragmentShaderName; - - std::vector m_data; - - void initialize (void) - { - tcu::TestLog &log = m_context.getTestContext().getLog(); - const vk::VkDevice device = m_context.getDevice(); - const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); - - const PipelineLayoutCreateInfo pipelineLayoutCreateInfo; - m_pipelineLayout = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo); - - const vk::VkExtent3D targetImageExtent = { WIDTH, HEIGHT, 1 }; - const ImageCreateInfo targetImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, targetImageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, - vk::VK_IMAGE_TILING_OPTIMAL, vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT); - - m_colorTargetImage = Image::createAndAlloc(m_vk, device, targetImageCreateInfo, m_context.getDefaultAllocator()); - - const ImageViewCreateInfo colorTargetViewInfo(m_colorTargetImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat); - m_colorTargetView = vk::createImageView(m_vk, device, &colorTargetViewInfo); - - RenderPassCreateInfo renderPassCreateInfo; - renderPassCreateInfo.addAttachment(AttachmentDescription( - m_colorAttachmentFormat, - vk::VK_SAMPLE_COUNT_1_BIT, - vk::VK_ATTACHMENT_LOAD_OP_LOAD, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_IMAGE_LAYOUT_GENERAL, - vk::VK_IMAGE_LAYOUT_GENERAL - ) - ); - - const vk::VkAttachmentReference colorAttachmentReference = - { - 0, - vk::VK_IMAGE_LAYOUT_GENERAL - }; - - renderPassCreateInfo.addSubpass(SubpassDescription( - vk::VK_PIPELINE_BIND_POINT_GRAPHICS, - 0, - 0, - DE_NULL, - 1, - &colorAttachmentReference, - DE_NULL, - AttachmentReference(), - 0, - DE_NULL - ) - ); - - m_renderPass = vk::createRenderPass(m_vk, device, &renderPassCreateInfo); - - std::vector colorAttachments(1); - colorAttachments[0] = *m_colorTargetView; - - const FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, colorAttachments, WIDTH, HEIGHT, 1); - - m_framebuffer = vk::createFramebuffer(m_vk, device, &framebufferCreateInfo); - - const vk::VkVertexInputBindingDescription vertexInputBindingDescription = - { - 0, - sizeof(tcu::Vec4) * 2, - vk::VK_VERTEX_INPUT_RATE_VERTEX, - }; - - const vk::VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] = - { - { - 0u, - 0u, - vk::VK_FORMAT_R32G32B32A32_SFLOAT, - 0u - }, - { - 1u, - 0u, - vk::VK_FORMAT_R32G32B32A32_SFLOAT, - (deUint32)(sizeof(float)* 4), - } - }; - - m_vertexInputState = PipelineCreateInfo::VertexInputState( - 1, - &vertexInputBindingDescription, - 2, - vertexInputAttributeDescriptions); - - const vk::VkDeviceSize dataSize = m_data.size() * sizeof(Vec4RGBA); - m_vertexBuffer = Buffer::createAndAlloc(m_vk, device, BufferCreateInfo(dataSize, - vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible); - - unsigned char *ptr = reinterpret_cast(m_vertexBuffer->getBoundMemory().getHostPtr()); - deMemcpy(ptr, &m_data[0], dataSize); - - vk::flushMappedMemoryRange(m_vk, device, - m_vertexBuffer->getBoundMemory().getMemory(), - m_vertexBuffer->getBoundMemory().getOffset(), - dataSize); - - const CmdPoolCreateInfo cmdPoolCreateInfo(queueFamilyIndex); - m_cmdPool = vk::createCommandPool(m_vk, device, &cmdPoolCreateInfo); - - const vk::VkCommandBufferAllocateInfo cmdBufferAllocateInfo = - { - vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType; - DE_NULL, // const void* pNext; - *m_cmdPool, // VkCommandPool commandPool; - vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level; - 1u, // deUint32 bufferCount; - }; - m_cmdBuffer = vk::allocateCommandBuffer(m_vk, device, &cmdBufferAllocateInfo); - - initPipeline(device); - } - - virtual void initPipeline (const vk::VkDevice device) - { - const vk::Unique vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0)); - const vk::Unique fs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_fragmentShaderName), 0)); - - const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState; - - PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, 0); - pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", vk::VK_SHADER_STAGE_VERTEX_BIT)); - pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", vk::VK_SHADER_STAGE_FRAGMENT_BIT)); - pipelineCreateInfo.addState(PipelineCreateInfo::VertexInputState(m_vertexInputState)); - pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(m_topology)); - pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &vkCbAttachmentState)); - pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1)); - pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState()); - pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState()); - pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState()); - pipelineCreateInfo.addState(PipelineCreateInfo::DynamicState()); - - m_pipeline = vk::createGraphicsPipeline(m_vk, device, DE_NULL, &pipelineCreateInfo); - } - - virtual tcu::TestStatus iterate (void) - { - TCU_FAIL("Implement iterate() method!"); - } - - void beginRenderPass (void) - { - const vk::VkClearColorValue clearColor = { { 0.0f, 0.0f, 0.0f, 1.0f } }; - beginRenderPassWithClearColor(clearColor); - } - - void beginRenderPassWithClearColor (const vk::VkClearColorValue &clearColor) - { - const CmdBufferBeginInfo beginInfo; - m_vk.beginCommandBuffer(*m_cmdBuffer, &beginInfo); - - initialTransitionColor2DImage(m_vk, *m_cmdBuffer, m_colorTargetImage->object(), vk::VK_IMAGE_LAYOUT_GENERAL); - - const ImageSubresourceRange subresourceRange(vk::VK_IMAGE_ASPECT_COLOR_BIT); - m_vk.cmdClearColorImage(*m_cmdBuffer, m_colorTargetImage->object(), - vk::VK_IMAGE_LAYOUT_GENERAL, &clearColor, 1, &subresourceRange); - - const vk::VkRect2D renderArea = { { 0, 0 }, { WIDTH, HEIGHT } }; - const RenderPassBeginInfo renderPassBegin(*m_renderPass, *m_framebuffer, renderArea); - - m_vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE); - } - - void setDynamicViewportState (const deUint32 width, const deUint32 height) - { - vk::VkViewport viewport; - viewport.x = 0; - viewport.y = 0; - viewport.width = static_cast(width); - viewport.height = static_cast(height); - viewport.minDepth = 0.0f; - viewport.maxDepth = 1.0f; - - m_vk.cmdSetViewport(*m_cmdBuffer, 1, &viewport); - - vk::VkRect2D scissor; - scissor.offset.x = 0; - scissor.offset.y = 0; - scissor.extent.width = width; - scissor.extent.height = height; - m_vk.cmdSetScissor(*m_cmdBuffer, 1, &scissor); - } - - void setDynamicViewportState (deUint32 viewportCount, const vk::VkViewport* pViewports, const vk::VkRect2D* pScissors) - { - m_vk.cmdSetViewport(*m_cmdBuffer, viewportCount, pViewports); - m_vk.cmdSetScissor(*m_cmdBuffer, viewportCount, pScissors); - } - - void setDynamicRasterizationState (const float lineWidth = 1.0f, - const float depthBiasConstantFactor = 0.0f, - const float depthBiasClamp = 0.0f, - const float depthBiasSlopeFactor = 0.0f) - { - m_vk.cmdSetLineWidth(*m_cmdBuffer, lineWidth); - m_vk.cmdSetDepthBias(*m_cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); - } - - void setDynamicBlendState (const float const1 = 0.0f, const float const2 = 0.0f, - const float const3 = 0.0f, const float const4 = 0.0f) - { - float blendConstantsants[4] = { const1, const2, const3, const4 }; - m_vk.cmdSetBlendConstants(*m_cmdBuffer, blendConstantsants); - } - - void setDynamicDepthStencilState (const float minDepthBounds = -1.0f, - const float maxDepthBounds = 1.0f, - const deUint32 stencilFrontCompareMask = 0xffffffffu, - const deUint32 stencilFrontWriteMask = 0xffffffffu, - const deUint32 stencilFrontReference = 0, - const deUint32 stencilBackCompareMask = 0xffffffffu, - const deUint32 stencilBackWriteMask = 0xffffffffu, - const deUint32 stencilBackReference = 0) - { - m_vk.cmdSetDepthBounds(*m_cmdBuffer, minDepthBounds, maxDepthBounds); - m_vk.cmdSetStencilCompareMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontCompareMask); - m_vk.cmdSetStencilWriteMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontWriteMask); - m_vk.cmdSetStencilReference(*m_cmdBuffer, vk::VK_STENCIL_FACE_FRONT_BIT, stencilFrontReference); - m_vk.cmdSetStencilCompareMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackCompareMask); - m_vk.cmdSetStencilWriteMask(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackWriteMask); - m_vk.cmdSetStencilReference(*m_cmdBuffer, vk::VK_STENCIL_FACE_BACK_BIT, stencilBackReference); - } + std::vector m_data; }; -} //DynamicState -} //vkt +} // DynamicState +} // vkt #endif // _VKTDYNAMICSTATEBASECLASS_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBufferObjectUtil.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBufferObjectUtil.cpp index a1ad86e..41a1463 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBufferObjectUtil.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBufferObjectUtil.cpp @@ -35,16 +35,14 @@ #include "vktDynamicStateBufferObjectUtil.hpp" - #include "vkQueryUtil.hpp" - namespace vkt { namespace DynamicState { -Buffer::Buffer (const vk::DeviceInterface &vk, vk::VkDevice device, vk::Move object) +Buffer::Buffer (const vk::DeviceInterface& vk, vk::VkDevice device, vk::Move object) : m_object (object) , m_allocation (DE_NULL) , m_vk (vk) @@ -61,11 +59,11 @@ void Buffer::bindMemory (de::MovePtr allocation) m_allocation = allocation; } -de::SharedPtr Buffer::createAndAlloc (const vk::DeviceInterface &vk, - vk::VkDevice device, - const vk::VkBufferCreateInfo &createInfo, - vk::Allocator &allocator, - vk::MemoryRequirement memoryRequirement) +de::SharedPtr Buffer::createAndAlloc (const vk::DeviceInterface& vk, + vk::VkDevice device, + const vk::VkBufferCreateInfo &createInfo, + vk::Allocator &allocator, + vk::MemoryRequirement memoryRequirement) { de::SharedPtr ret = create(vk, device, createInfo); @@ -74,12 +72,12 @@ de::SharedPtr Buffer::createAndAlloc (const vk::DeviceInterface &vk, return ret; } -de::SharedPtr Buffer::create (const vk::DeviceInterface &vk, +de::SharedPtr Buffer::create (const vk::DeviceInterface& vk, vk::VkDevice device, - const vk::VkBufferCreateInfo &createInfo) + const vk::VkBufferCreateInfo& createInfo) { return de::SharedPtr(new Buffer(vk, device, vk::createBuffer(vk, device, &createInfo))); } -} //DynamicState -} //vkt +} // DynamicState +} // vkt diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBufferObjectUtil.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBufferObjectUtil.hpp index 4465741..b01d459 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBufferObjectUtil.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateBufferObjectUtil.hpp @@ -1,5 +1,5 @@ -#ifndef _VKT_DYNAMIC_STATE_BUFFEROBJECTUTIL_HPP -#define _VKT_DYNAMIC_STATE_BUFFEROBJECTUTIL_HPP +#ifndef _VKTDYNAMICSTATEBUFFEROBJECTUTIL_HPP +#define _VKTDYNAMICSTATEBUFFEROBJECTUTIL_HPP /*------------------------------------------------------------------------ * Vulkan Conformance Tests * ------------------------ @@ -60,27 +60,24 @@ public: Buffer (const vk::DeviceInterface &vk, vk::VkDevice device, vk::Move object); - void bindMemory (de::MovePtr allocation); - vk::VkBuffer object (void) const { return *m_object; } vk::Allocation getBoundMemory (void) const { return *m_allocation; } private: Buffer (const Buffer& other); // Not allowed! - Buffer &operator= (const Buffer& other); // Not allowed! - + Buffer& operator= (const Buffer& other); // Not allowed! de::MovePtr m_allocation; vk::Unique m_object; - const vk::DeviceInterface& m_vk; - vk::VkDevice m_device; + const vk::DeviceInterface& m_vk; + vk::VkDevice m_device; }; -} //DynamicState -} //vkt +} // DynamicState +} // vkt -#endif // _VKT_DYNAMIC_STATE_BUFFEROBJECTUTIL_HPP +#endif // _VKTDYNAMICSTATEBUFFEROBJECTUTIL_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCBTests.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCBTests.cpp index 904eef7..ca7d760 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCBTests.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCBTests.cpp @@ -34,12 +34,15 @@ *//*--------------------------------------------------------------------*/ #include "vktDynamicStateCBTests.hpp" + #include "vktDynamicStateBaseClass.hpp" +#include "vktDynamicStateTestCaseUtil.hpp" -#include "vktTestCaseUtil.hpp" -#include "tcuTextureUtil.hpp" +#include "vkImageUtil.hpp" -#include "vktDynamicStateTestCaseUtil.hpp" +#include "tcuImageCompare.hpp" +#include "tcuTextureUtil.hpp" +#include "tcuRGBA.hpp" namespace vkt { @@ -51,15 +54,15 @@ namespace class BlendConstantsTestInstance : public DynamicStateBaseClass { public: - BlendConstantsTestInstance (Context &context, ShaderMap shaders) - : DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) + BlendConstantsTestInstance (Context& context, ShaderMap shaders) + : DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { m_topology = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); DynamicStateBaseClass::initialize(); } @@ -70,10 +73,9 @@ public: const vk::Unique fs (createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_fragmentShaderName), 0)); const vk::VkPipelineColorBlendAttachmentState VkPipelineColorBlendAttachmentState = - PipelineCreateInfo::ColorBlendState::Attachment( - vk::VK_TRUE, - vk::VK_BLEND_FACTOR_SRC_ALPHA, vk::VK_BLEND_FACTOR_CONSTANT_COLOR, vk::VK_BLEND_OP_ADD, - vk::VK_BLEND_FACTOR_SRC_ALPHA, vk::VK_BLEND_FACTOR_CONSTANT_ALPHA, vk::VK_BLEND_OP_ADD); + PipelineCreateInfo::ColorBlendState::Attachment(vk::VK_TRUE, + vk::VK_BLEND_FACTOR_SRC_ALPHA, vk::VK_BLEND_FACTOR_CONSTANT_COLOR, vk::VK_BLEND_OP_ADD, + vk::VK_BLEND_FACTOR_SRC_ALPHA, vk::VK_BLEND_FACTOR_CONSTANT_ALPHA, vk::VK_BLEND_OP_ADD); PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, 0); pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", vk::VK_SHADER_STAGE_VERTEX_BIT)); @@ -117,14 +119,14 @@ public: vk::VkSubmitInfo submitInfo = { - vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; - DE_NULL, // const void* pNext; - 0, // deUint32 waitSemaphoreCount; - DE_NULL, // const VkSemaphore* pWaitSemaphores; - 1, // deUint32 commandBufferCount; - &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; - 0, // deUint32 signalSemaphoreCount; - DE_NULL // const VkSemaphore* pSignalSemaphores; + vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0, // deUint32 waitSemaphoreCount; + DE_NULL, // const VkSemaphore* pWaitSemaphores; + 1, // deUint32 commandBufferCount; + &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; + 0, // deUint32 signalSemaphoreCount; + DE_NULL // const VkSemaphore* pSignalSemaphores; }; m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL); VK_CHECK(m_vk.queueWaitIdle(queue)); @@ -154,25 +156,23 @@ public: const vk::VkOffset3D zeroOffset = { 0, 0, 0 }; const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), - vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - - qpTestResult res = QP_TEST_RESULT_PASS; + vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; } //anonymous -DynamicStateCBTests::DynamicStateCBTests (tcu::TestContext &testCtx) +DynamicStateCBTests::DynamicStateCBTests (tcu::TestContext& testCtx) : TestCaseGroup (testCtx, "cb_state", "Tests for color blend state") { /* Left blank on purpose */ @@ -188,5 +188,5 @@ void DynamicStateCBTests::init (void) addChild(new InstanceFactory(m_testCtx, "blend_constants", "Check if blend constants are working properly", shaderPaths)); } -} //DynamicState -} //vkt +} // DynamicState +} // vkt diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCBTests.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCBTests.hpp index 723e176..19f81b9 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCBTests.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCBTests.hpp @@ -45,17 +45,16 @@ namespace DynamicState class DynamicStateCBTests : public tcu::TestCaseGroup { public: - DynamicStateCBTests (tcu::TestContext &testCtx); - ~DynamicStateCBTests (void); - void init (void); + DynamicStateCBTests (tcu::TestContext& testCtx); + ~DynamicStateCBTests (void); + void init (void); private: - DynamicStateCBTests (const DynamicStateCBTests &other); - DynamicStateCBTests &operator=(const DynamicStateCBTests &other); + DynamicStateCBTests (const DynamicStateCBTests &other); + DynamicStateCBTests& operator= (const DynamicStateCBTests &other); }; -} //DynamicState -} //vkt - +} // DynamicState +} // vkt #endif // _VKTDYNAMICSTATECBTESTS_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.cpp index c25d9f5..284ec18 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.cpp @@ -141,7 +141,6 @@ BufferViewCreateInfo::BufferViewCreateInfo (vk::VkBuffer _buffer, range = _range; } - BufferCreateInfo::BufferCreateInfo (vk::VkDeviceSize _size, vk::VkBufferUsageFlags _usage, vk::VkSharingMode _sharingMode, @@ -228,7 +227,7 @@ ImageCreateInfo::ImageCreateInfo (vk::VkImageType _imageType, vk::VkImageUsageFlags _usage, vk::VkSharingMode _sharingMode, deUint32 _queueFamilyIndexCount, - const deUint32* _pQueueFamilyIndices, + const deUint32* _pQueueFamilyIndices, vk::VkImageCreateFlags _flags, vk::VkImageLayout _initialLayout) { @@ -263,7 +262,7 @@ ImageCreateInfo::ImageCreateInfo (vk::VkImageType _imageType, } FramebufferCreateInfo::FramebufferCreateInfo (vk::VkRenderPass _renderPass, - const std::vector& atachments, + const std::vector& atachments, deUint32 _width, deUint32 _height, deUint32 _layers) @@ -393,7 +392,7 @@ RenderPassCreateInfo::addDependency (vk::VkSubpassDependency dependency) RenderPassBeginInfo::RenderPassBeginInfo (vk::VkRenderPass _renderPass, vk::VkFramebuffer _framebuffer, vk::VkRect2D _renderArea, - const std::vector& _clearValues) + const std::vector& _clearValues) { m_clearValues = _clearValues; @@ -436,7 +435,7 @@ AttachmentDescription::AttachmentDescription (vk::VkFormat _format, finalLayout = _finalLayout; } -AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription &rhs) +AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription& rhs) { flags = rhs.flags; format = rhs.format; @@ -603,7 +602,7 @@ SubpassDependency::SubpassDependency (deUint32 _srcSubpass, dependencyFlags = _dependencyFlags; } -SubpassDependency::SubpassDependency (const vk::VkSubpassDependency &rhs) +SubpassDependency::SubpassDependency (const vk::VkSubpassDependency& rhs) { srcSubpass = rhs.srcSubpass; dstSubpass = rhs.dstSubpass; @@ -680,7 +679,6 @@ DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo (deUint32 _bindingC pBinding = _pBindings; } - PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32 _descriptorSetCount, const vk::VkDescriptorSetLayout* _pSetLayouts, deUint32 _pushConstantRangeCount, @@ -737,7 +735,6 @@ PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (const std::vector _blendConstants) +PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState& createInfo, std::vector _blendConstants) : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount) { sType = createInfo.sType; @@ -1062,7 +1059,7 @@ PipelineCreateInfo::DynamicState::DynamicState (const DynamicState &other) pDynamicStates = &m_dynamicStates[0]; } -PipelineCreateInfo::DynamicState & PipelineCreateInfo::DynamicState::operator= (const DynamicState &other) +PipelineCreateInfo::DynamicState& PipelineCreateInfo::DynamicState::operator= (const DynamicState& other) { sType = other.sType; pNext = other.pNext; @@ -1094,7 +1091,7 @@ PipelineCreateInfo::PipelineCreateInfo (vk::VkPipelineLayout _layout, pDynamicState = DE_NULL; } -PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo &shader) +PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo& shader) { m_shaders.push_back(shader); @@ -1187,19 +1184,19 @@ PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDynamicSta } SamplerCreateInfo::SamplerCreateInfo (vk::VkFilter _magFilter, - vk::VkFilter _minFilter, - vk::VkSamplerMipmapMode _mipmapMode, - vk::VkSamplerAddressMode _addressModeU, - vk::VkSamplerAddressMode _addressModeV, - vk::VkSamplerAddressMode _addressModeW, - float _mipLodBias, - float _maxAnisotropy, - vk::VkBool32 _compareEnable, - vk::VkCompareOp _compareOp, - float _minLod, - float _maxLod, - vk::VkBorderColor _borderColor, - vk::VkBool32 _unnormalizedCoordinates) + vk::VkFilter _minFilter, + vk::VkSamplerMipmapMode _mipmapMode, + vk::VkSamplerAddressMode _addressModeU, + vk::VkSamplerAddressMode _addressModeV, + vk::VkSamplerAddressMode _addressModeW, + float _mipLodBias, + float _maxAnisotropy, + vk::VkBool32 _compareEnable, + vk::VkCompareOp _compareOp, + float _minLod, + float _maxLod, + vk::VkBorderColor _borderColor, + vk::VkBool32 _unnormalizedCoordinates) { sType = vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; pNext = DE_NULL; diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.hpp index 3f9d037..93035f5 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.hpp @@ -1,5 +1,5 @@ -#ifndef _VKT_DYNAMIC_STATE_CREATEINFO_UTIL_HPP -#define _VKT_DYNAMIC_STATE_CREATEINFO_UTIL_HPP +#ifndef _VKTDYNAMICSTATECREATEINFOUTIL_HPP +#define _VKTDYNAMICSTATECREATEINFOUTIL_HPP /*------------------------------------------------------------------------ * Vulkan Conformance Tests * ------------------------ @@ -50,86 +50,85 @@ namespace DynamicState class ImageSubresourceRange : public vk::VkImageSubresourceRange { public: - ImageSubresourceRange ( vk::VkImageAspectFlags aspectMask, - deUint32 baseMipLevel = 0, - deUint32 levelCount = 1, - deUint32 baseArrayLayer = 0, - deUint32 layerCount = 1); + ImageSubresourceRange (vk::VkImageAspectFlags aspectMask, + deUint32 baseMipLevel = 0, + deUint32 levelCount = 1, + deUint32 baseArrayLayer = 0, + deUint32 layerCount = 1); }; class ComponentMapping : public vk::VkComponentMapping { public: - ComponentMapping ( vk::VkComponentSwizzle r = vk::VK_COMPONENT_SWIZZLE_R, - vk::VkComponentSwizzle g = vk::VK_COMPONENT_SWIZZLE_G, - vk::VkComponentSwizzle b = vk::VK_COMPONENT_SWIZZLE_B, - vk::VkComponentSwizzle a = vk::VK_COMPONENT_SWIZZLE_A); + ComponentMapping (vk::VkComponentSwizzle r = vk::VK_COMPONENT_SWIZZLE_R, + vk::VkComponentSwizzle g = vk::VK_COMPONENT_SWIZZLE_G, + vk::VkComponentSwizzle b = vk::VK_COMPONENT_SWIZZLE_B, + vk::VkComponentSwizzle a = vk::VK_COMPONENT_SWIZZLE_A); }; class ImageViewCreateInfo : public vk::VkImageViewCreateInfo { public: - ImageViewCreateInfo ( vk::VkImage image, - vk::VkImageViewType viewType, - vk::VkFormat format, - const vk::VkImageSubresourceRange& subresourceRange, - const vk::VkComponentMapping& components = ComponentMapping(), - vk::VkImageViewCreateFlags flags = 0); - - ImageViewCreateInfo ( vk::VkImage image, - vk::VkImageViewType viewType, - vk::VkFormat format, - const vk::VkComponentMapping& components = ComponentMapping(), - vk::VkImageViewCreateFlags flags = 0); + ImageViewCreateInfo (vk::VkImage image, + vk::VkImageViewType viewType, + vk::VkFormat format, + const vk::VkImageSubresourceRange& subresourceRange, + const vk::VkComponentMapping& components = ComponentMapping(), + vk::VkImageViewCreateFlags flags = 0); + + ImageViewCreateInfo (vk::VkImage image, + vk::VkImageViewType viewType, + vk::VkFormat format, + const vk::VkComponentMapping& components = ComponentMapping(), + vk::VkImageViewCreateFlags flags = 0); }; class BufferViewCreateInfo : public vk::VkBufferViewCreateInfo { public: - BufferViewCreateInfo ( vk::VkBuffer buffer, - vk::VkFormat format, - vk::VkDeviceSize offset, - vk::VkDeviceSize range); + BufferViewCreateInfo (vk::VkBuffer buffer, + vk::VkFormat format, + vk::VkDeviceSize offset, + vk::VkDeviceSize range); }; class BufferCreateInfo : public vk::VkBufferCreateInfo { public: - BufferCreateInfo ( vk::VkDeviceSize size, - vk::VkBufferCreateFlags usage, - vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE, - deUint32 queueFamilyIndexCount = 0, - const deUint32* pQueueFamilyIndices = DE_NULL, - vk::VkBufferCreateFlags flags = 0); + BufferCreateInfo (vk::VkDeviceSize size, + vk::VkBufferCreateFlags usage, + vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE, + deUint32 queueFamilyIndexCount = 0, + const deUint32* pQueueFamilyIndices = DE_NULL, + vk::VkBufferCreateFlags flags = 0); - BufferCreateInfo (const BufferCreateInfo &other); - BufferCreateInfo &operator= (const BufferCreateInfo &other); + BufferCreateInfo (const BufferCreateInfo& other); + BufferCreateInfo& operator= (const BufferCreateInfo& other); private: std::vector m_queueFamilyIndices; }; - class ImageCreateInfo : public vk::VkImageCreateInfo { public: - ImageCreateInfo ( vk::VkImageType imageType, - vk::VkFormat format, - vk::VkExtent3D extent, - deUint32 mipLevels, - deUint32 arrayLayers, - vk::VkSampleCountFlagBits samples, - vk::VkImageTiling tiling, - vk::VkImageUsageFlags usage, - vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE, - deUint32 queueFamilyIndexCount = 0, - const deUint32* pQueueFamilyIndices = DE_NULL, - vk::VkImageCreateFlags flags = 0, - vk::VkImageLayout initialLayout = vk::VK_IMAGE_LAYOUT_UNDEFINED); + ImageCreateInfo (vk::VkImageType imageType, + vk::VkFormat format, + vk::VkExtent3D extent, + deUint32 mipLevels, + deUint32 arrayLayers, + vk::VkSampleCountFlagBits samples, + vk::VkImageTiling tiling, + vk::VkImageUsageFlags usage, + vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE, + deUint32 queueFamilyIndexCount = 0, + const deUint32* pQueueFamilyIndices = DE_NULL, + vk::VkImageCreateFlags flags = 0, + vk::VkImageLayout initialLayout = vk::VK_IMAGE_LAYOUT_UNDEFINED); private: - ImageCreateInfo (const ImageCreateInfo &other); - ImageCreateInfo &operator= (const ImageCreateInfo &other); + ImageCreateInfo (const ImageCreateInfo& other); + ImageCreateInfo& operator= (const ImageCreateInfo& other); std::vector m_queueFamilyIndices; }; @@ -137,52 +136,52 @@ private: class FramebufferCreateInfo : public vk::VkFramebufferCreateInfo { public: - FramebufferCreateInfo ( vk::VkRenderPass renderPass, - const std::vector& attachments, - deUint32 width, - deUint32 height, - deUint32 layers); + FramebufferCreateInfo (vk::VkRenderPass renderPass, + const std::vector& attachments, + deUint32 width, + deUint32 height, + deUint32 layers); }; class AttachmentDescription : public vk::VkAttachmentDescription { public: - AttachmentDescription ( vk::VkFormat format, - vk::VkSampleCountFlagBits samples, - vk::VkAttachmentLoadOp loadOp, - vk::VkAttachmentStoreOp storeOp, - vk::VkAttachmentLoadOp stencilLoadOp, - vk::VkAttachmentStoreOp stencilStoreOp, - vk::VkImageLayout initialLayout, - vk::VkImageLayout finalLayout); - - AttachmentDescription (const vk::VkAttachmentDescription &); + AttachmentDescription (vk::VkFormat format, + vk::VkSampleCountFlagBits samples, + vk::VkAttachmentLoadOp loadOp, + vk::VkAttachmentStoreOp storeOp, + vk::VkAttachmentLoadOp stencilLoadOp, + vk::VkAttachmentStoreOp stencilStoreOp, + vk::VkImageLayout initialLayout, + vk::VkImageLayout finalLayout); + + AttachmentDescription (const vk::VkAttachmentDescription &); }; class AttachmentReference : public vk::VkAttachmentReference { public: - AttachmentReference (deUint32 attachment, vk::VkImageLayout layout); - AttachmentReference (void); + AttachmentReference (deUint32 attachment, vk::VkImageLayout layout); + AttachmentReference (void); }; class SubpassDescription : public vk::VkSubpassDescription { public: - SubpassDescription ( vk::VkPipelineBindPoint pipelineBindPoint, - vk::VkSubpassDescriptionFlags flags, - deUint32 inputAttachmentCount, - const vk::VkAttachmentReference* inputAttachments, - deUint32 colorAttachmentCount, - const vk::VkAttachmentReference* colorAttachments, - const vk::VkAttachmentReference* resolveAttachments, - vk::VkAttachmentReference depthStencilAttachment, - deUint32 preserveAttachmentCount, - const vk::VkAttachmentReference* preserveAttachments); - - SubpassDescription (const vk::VkSubpassDescription& other); - SubpassDescription (const SubpassDescription& other); - SubpassDescription& operator= (const SubpassDescription& other); + SubpassDescription (vk::VkPipelineBindPoint pipelineBindPoint, + vk::VkSubpassDescriptionFlags flags, + deUint32 inputAttachmentCount, + const vk::VkAttachmentReference* inputAttachments, + deUint32 colorAttachmentCount, + const vk::VkAttachmentReference* colorAttachments, + const vk::VkAttachmentReference* resolveAttachments, + vk::VkAttachmentReference depthStencilAttachment, + deUint32 preserveAttachmentCount, + const vk::VkAttachmentReference* preserveAttachments); + + SubpassDescription (const vk::VkSubpassDescription& other); + SubpassDescription (const SubpassDescription& other); + SubpassDescription& operator= (const SubpassDescription& other); private: std::vector m_inputAttachments; @@ -210,20 +209,20 @@ public: class RenderPassCreateInfo : public vk::VkRenderPassCreateInfo { public: - RenderPassCreateInfo ( const std::vector& attachments, - const std::vector& subpasses, - const std::vector& dependiences = std::vector()); + RenderPassCreateInfo (const std::vector& attachments, + const std::vector& subpasses, + const std::vector& dependiences = std::vector()); - RenderPassCreateInfo ( deUint32 attachmentCount = 0, - const vk::VkAttachmentDescription* pAttachments = DE_NULL, - deUint32 subpassCount = 0, - const vk::VkSubpassDescription* pSubpasses = DE_NULL, - deUint32 dependencyCount = 0, - const vk::VkSubpassDependency* pDependiences = DE_NULL); + RenderPassCreateInfo (deUint32 attachmentCount = 0, + const vk::VkAttachmentDescription* pAttachments = DE_NULL, + deUint32 subpassCount = 0, + const vk::VkSubpassDescription* pSubpasses = DE_NULL, + deUint32 dependencyCount = 0, + const vk::VkSubpassDependency* pDependiences = DE_NULL); - void addAttachment (vk::VkAttachmentDescription attachment); - void addSubpass (vk::VkSubpassDescription subpass); - void addDependency (vk::VkSubpassDependency dependency); + void addAttachment (vk::VkAttachmentDescription attachment); + void addSubpass (vk::VkSubpassDescription subpass); + void addDependency (vk::VkSubpassDependency dependency); private: std::vector m_attachments; @@ -235,35 +234,35 @@ private: std::vector m_dependiencesStructs; RenderPassCreateInfo (const RenderPassCreateInfo &other); //Not allowed! - RenderPassCreateInfo &operator= (const RenderPassCreateInfo &other); //Not allowed! + RenderPassCreateInfo& operator= (const RenderPassCreateInfo &other); //Not allowed! }; class RenderPassBeginInfo : public vk::VkRenderPassBeginInfo { public: - RenderPassBeginInfo ( vk::VkRenderPass renderPass, - vk::VkFramebuffer framebuffer, - vk::VkRect2D renderArea, - const std::vector& clearValues = std::vector()); + RenderPassBeginInfo (vk::VkRenderPass renderPass, + vk::VkFramebuffer framebuffer, + vk::VkRect2D renderArea, + const std::vector& clearValues = std::vector()); private: std::vector m_clearValues; - RenderPassBeginInfo (const RenderPassBeginInfo &other); //Not allowed! - RenderPassBeginInfo &operator= (const RenderPassBeginInfo &other); //Not allowed! + RenderPassBeginInfo (const RenderPassBeginInfo& other); //Not allowed! + RenderPassBeginInfo& operator= (const RenderPassBeginInfo& other); //Not allowed! }; class CmdPoolCreateInfo : public vk::VkCommandPoolCreateInfo { public: - CmdPoolCreateInfo (deUint32 queueFamilyIndex, - vk::VkCommandPoolCreateFlags flags = vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT); + CmdPoolCreateInfo (deUint32 queueFamilyIndex, + vk::VkCommandPoolCreateFlags flags = vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT); }; class CmdBufferBeginInfo : public vk::VkCommandBufferBeginInfo { public: - CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags flags = 0); + CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags flags = 0); CmdBufferBeginInfo (vk::VkRenderPass renderPass, deUint32 subpass, vk::VkFramebuffer framebuffer, @@ -273,7 +272,6 @@ public: vk::VkQueryPipelineStatisticFlags pipelineStatistics = 0u); }; - class DescriptorPoolSize : public vk::VkDescriptorPoolSize { public: @@ -287,9 +285,9 @@ public: class DescriptorPoolCreateInfo : public vk::VkDescriptorPoolCreateInfo { public: - DescriptorPoolCreateInfo ( const std::vector& poolSizeCounts, - vk::VkDescriptorPoolCreateFlags flags, - deUint32 maxSets); + DescriptorPoolCreateInfo (const std::vector& poolSizeCounts, + vk::VkDescriptorPoolCreateFlags flags, + deUint32 maxSets); DescriptorPoolCreateInfo& addDescriptors (vk::VkDescriptorType type, deUint32 count); @@ -297,25 +295,23 @@ private: std::vector m_poolSizeCounts; }; - class DescriptorSetLayoutCreateInfo : public vk::VkDescriptorSetLayoutCreateInfo { public: DescriptorSetLayoutCreateInfo (deUint32 bindingCount, const vk::VkDescriptorSetLayoutBinding* pBindings); }; - class PipelineLayoutCreateInfo : public vk::VkPipelineLayoutCreateInfo { public: - PipelineLayoutCreateInfo ( deUint32 descriptorSetCount, - const vk::VkDescriptorSetLayout* pSetLayouts, - deUint32 pushConstantRangeCount = 0, - const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL); + PipelineLayoutCreateInfo (deUint32 descriptorSetCount, + const vk::VkDescriptorSetLayout* pSetLayouts, + deUint32 pushConstantRangeCount = 0, + const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL); - PipelineLayoutCreateInfo ( const std::vector& setLayouts = std::vector(), - deUint32 pushConstantRangeCount = 0, - const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL); + PipelineLayoutCreateInfo (const std::vector& setLayouts = std::vector(), + deUint32 pushConstantRangeCount = 0, + const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL); private: std::vector m_setLayouts; @@ -328,10 +324,10 @@ public: class VertexInputState : public vk::VkPipelineVertexInputStateCreateInfo { public: - VertexInputState ( deUint32 vertexBindingDescriptionCount = 0, - const vk::VkVertexInputBindingDescription* pVertexBindingDescriptions = NULL, - deUint32 vertexAttributeDescriptionCount = 0, - const vk::VkVertexInputAttributeDescription* pVertexAttributeDescriptions = NULL); + VertexInputState (deUint32 vertexBindingDescriptionCount = 0, + const vk::VkVertexInputBindingDescription* pVertexBindingDescriptions = NULL, + deUint32 vertexAttributeDescriptionCount = 0, + const vk::VkVertexInputAttributeDescription* pVertexAttributeDescriptions = NULL); }; class InputAssemblerState : public vk::VkPipelineInputAssemblyStateCreateInfo @@ -349,12 +345,12 @@ public: class ViewportState : public vk::VkPipelineViewportStateCreateInfo { public: - ViewportState ( deUint32 viewportCount, - std::vector viewports = std::vector(0), - std::vector scissors = std::vector(0)); + ViewportState (deUint32 viewportCount, + std::vector viewports = std::vector(0), + std::vector scissors = std::vector(0)); - ViewportState (const ViewportState &other); - ViewportState &operator= (const ViewportState &other); + ViewportState (const ViewportState& other); + ViewportState& operator= (const ViewportState& other); std::vector m_viewports; std::vector m_scissors; @@ -363,30 +359,30 @@ public: class RasterizerState : public vk::VkPipelineRasterizationStateCreateInfo { public: - RasterizerState ( vk::VkBool32 depthClampEnable = false, - vk::VkBool32 rasterizerDiscardEnable = false, - vk::VkPolygonMode polygonMode = vk::VK_POLYGON_MODE_FILL, - vk::VkCullModeFlags cullMode = vk::VK_CULL_MODE_NONE, - vk::VkFrontFace frontFace = vk::VK_FRONT_FACE_CLOCKWISE, - vk::VkBool32 depthBiasEnable = true, - float depthBiasConstantFactor = 0.0f, - float depthBiasClamp = 0.0f, - float depthBiasSlopeFactor = 0.0f, - float lineWidth = 1.0f); + RasterizerState (vk::VkBool32 depthClampEnable = false, + vk::VkBool32 rasterizerDiscardEnable = false, + vk::VkPolygonMode polygonMode = vk::VK_POLYGON_MODE_FILL, + vk::VkCullModeFlags cullMode = vk::VK_CULL_MODE_NONE, + vk::VkFrontFace frontFace = vk::VK_FRONT_FACE_CLOCKWISE, + vk::VkBool32 depthBiasEnable = true, + float depthBiasConstantFactor = 0.0f, + float depthBiasClamp = 0.0f, + float depthBiasSlopeFactor = 0.0f, + float lineWidth = 1.0f); }; class MultiSampleState : public vk::VkPipelineMultisampleStateCreateInfo { public: - MultiSampleState ( vk::VkSampleCountFlagBits rasterizationSamples = vk::VK_SAMPLE_COUNT_1_BIT, - vk::VkBool32 sampleShadingEnable = false, - float minSampleShading = 0.0f, - const std::vector& sampleMask = std::vector(1, 0xffffffff), - bool alphaToCoverageEnable = false, - bool alphaToOneEnable = false); + MultiSampleState (vk::VkSampleCountFlagBits rasterizationSamples = vk::VK_SAMPLE_COUNT_1_BIT, + vk::VkBool32 sampleShadingEnable = false, + float minSampleShading = 0.0f, + const std::vector& sampleMask = std::vector(1, 0xffffffff), + bool alphaToCoverageEnable = false, + bool alphaToOneEnable = false); - MultiSampleState (const MultiSampleState &other); - MultiSampleState &operator= (const MultiSampleState &other); + MultiSampleState (const MultiSampleState& other); + MultiSampleState& operator= (const MultiSampleState& other); private: std::vector m_sampleMask; @@ -405,20 +401,21 @@ public: vk::VkBlendFactor srcAlphaBlendFactor = vk::VK_BLEND_FACTOR_SRC_COLOR, vk::VkBlendFactor dstAlphaBlendFactor = vk::VK_BLEND_FACTOR_DST_COLOR, vk::VkBlendOp alphaBlendOp = vk::VK_BLEND_OP_ADD, - deUint8 colorWriteMask = 0xff); + deUint8 colorWriteMask = 0xff); }; - ColorBlendState ( const std::vector& attachments, - vk::VkBool32 alphaToCoverageEnable = false, - vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY); + ColorBlendState (const std::vector& attachments, + vk::VkBool32 alphaToCoverageEnable = false, + vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY); - ColorBlendState ( deUint32 attachmentCount, - const vk::VkPipelineColorBlendAttachmentState* attachments, - vk::VkBool32 logicOpEnable = false, - vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY); + ColorBlendState (deUint32 attachmentCount, + const vk::VkPipelineColorBlendAttachmentState* attachments, + vk::VkBool32 logicOpEnable = false, + vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY); - ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo &createInfo); - ColorBlendState (const ColorBlendState &createInfo, std::vector blendConstants = std::vector(4)); + ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo); + ColorBlendState (const ColorBlendState& createInfo, + std::vector blendConstants = std::vector(4)); private: std::vector m_attachments; @@ -430,56 +427,59 @@ public: class StencilOpState : public vk::VkStencilOpState { public: - StencilOpState (vk::VkStencilOp failOp = vk::VK_STENCIL_OP_REPLACE, - vk::VkStencilOp passOp = vk::VK_STENCIL_OP_REPLACE, - vk::VkStencilOp depthFailOp = vk::VK_STENCIL_OP_REPLACE, - vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS, - deUint32 compareMask = 0xffffffffu, - deUint32 writeMask = 0xffffffffu, - deUint32 reference = 0); + StencilOpState (vk::VkStencilOp failOp = vk::VK_STENCIL_OP_REPLACE, + vk::VkStencilOp passOp = vk::VK_STENCIL_OP_REPLACE, + vk::VkStencilOp depthFailOp = vk::VK_STENCIL_OP_REPLACE, + vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS, + deUint32 compareMask = 0xffffffffu, + deUint32 writeMask = 0xffffffffu, + deUint32 reference = 0); }; - DepthStencilState ( vk::VkBool32 depthTestEnable = false, - vk::VkBool32 depthWriteEnable = false, - vk::VkCompareOp depthCompareOp = vk::VK_COMPARE_OP_ALWAYS, - vk::VkBool32 depthBoundsTestEnable = false, - vk::VkBool32 stencilTestEnable = false, - StencilOpState front = StencilOpState(), - StencilOpState back = StencilOpState(), - float minDepthBounds = -1.0f, - float maxDepthBounds = 1.0f); + DepthStencilState (vk::VkBool32 depthTestEnable = false, + vk::VkBool32 depthWriteEnable = false, + vk::VkCompareOp depthCompareOp = vk::VK_COMPARE_OP_ALWAYS, + vk::VkBool32 depthBoundsTestEnable = false, + vk::VkBool32 stencilTestEnable = false, + StencilOpState front = StencilOpState(), + StencilOpState back = StencilOpState(), + float minDepthBounds = -1.0f, + float maxDepthBounds = 1.0f); }; class PipelineShaderStage : public vk::VkPipelineShaderStageCreateInfo { public: - PipelineShaderStage (vk::VkShaderModule shaderModule, const char* _pName, vk::VkShaderStageFlagBits stage); + PipelineShaderStage (vk::VkShaderModule shaderModule, const char* pName, vk::VkShaderStageFlagBits stage); }; class DynamicState : public vk::VkPipelineDynamicStateCreateInfo { public: - DynamicState (const std::vector& dynamicStates = std::vector(0)); + DynamicState (const std::vector& dynamicStates = std::vector(0)); - DynamicState (const DynamicState &other); - DynamicState &operator= (const DynamicState &other); + DynamicState (const DynamicState& other); + DynamicState& operator= (const DynamicState& other); std::vector m_dynamicStates; }; - PipelineCreateInfo(vk::VkPipelineLayout layout, vk::VkRenderPass renderPass, int subpass, vk::VkPipelineCreateFlags flags); + PipelineCreateInfo (vk::VkPipelineLayout layout, + vk::VkRenderPass renderPass, + int subpass, + vk::VkPipelineCreateFlags flags); - PipelineCreateInfo& addShader (const vk::VkPipelineShaderStageCreateInfo& shader); + PipelineCreateInfo& addShader (const vk::VkPipelineShaderStageCreateInfo& shader); - PipelineCreateInfo& addState (const vk::VkPipelineVertexInputStateCreateInfo& state); - PipelineCreateInfo& addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state); - PipelineCreateInfo& addState (const vk::VkPipelineColorBlendStateCreateInfo& state); - PipelineCreateInfo& addState (const vk::VkPipelineViewportStateCreateInfo& state); - PipelineCreateInfo& addState (const vk::VkPipelineDepthStencilStateCreateInfo& state); - PipelineCreateInfo& addState (const vk::VkPipelineTessellationStateCreateInfo& state); - PipelineCreateInfo& addState (const vk::VkPipelineRasterizationStateCreateInfo& state); - PipelineCreateInfo& addState (const vk::VkPipelineMultisampleStateCreateInfo& state); - PipelineCreateInfo& addState (const vk::VkPipelineDynamicStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineVertexInputStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineColorBlendStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineViewportStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineDepthStencilStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineTessellationStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineRasterizationStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineMultisampleStateCreateInfo& state); + PipelineCreateInfo& addState (const vk::VkPipelineDynamicStateCreateInfo& state); private: std::vector m_shaders; @@ -495,34 +495,34 @@ private: vk::VkPipelineMultisampleStateCreateInfo m_multisampleState; vk::VkPipelineDynamicStateCreateInfo m_dynamicState; - std::vector m_dynamicStates; + std::vector m_dynamicStates; - std::vector m_viewports; - std::vector m_scissors; + std::vector m_viewports; + std::vector m_scissors; - std::vector m_multisampleStateSampleMask; + std::vector m_multisampleStateSampleMask; }; class SamplerCreateInfo : public vk::VkSamplerCreateInfo { public: - SamplerCreateInfo ( vk::VkFilter magFilter = vk::VK_FILTER_NEAREST, - vk::VkFilter minFilter = vk::VK_FILTER_NEAREST, - vk::VkSamplerMipmapMode mipmapMode = vk::VK_SAMPLER_MIPMAP_MODE_NEAREST, - vk::VkSamplerAddressMode addressU = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, - vk::VkSamplerAddressMode addressV = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, - vk::VkSamplerAddressMode addressW = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, - float mipLodBias = 0.0f, - float maxAnisotropy = 1.0f, - vk::VkBool32 compareEnable = false, - vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS, - float minLod = 0.0f, - float maxLod = 16.0f, - vk::VkBorderColor borderColor = vk::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, - vk::VkBool32 unnormalizedCoordinates = false); + SamplerCreateInfo (vk::VkFilter magFilter = vk::VK_FILTER_NEAREST, + vk::VkFilter minFilter = vk::VK_FILTER_NEAREST, + vk::VkSamplerMipmapMode mipmapMode = vk::VK_SAMPLER_MIPMAP_MODE_NEAREST, + vk::VkSamplerAddressMode addressU = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, + vk::VkSamplerAddressMode addressV = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, + vk::VkSamplerAddressMode addressW = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, + float mipLodBias = 0.0f, + float maxAnisotropy = 1.0f, + vk::VkBool32 compareEnable = false, + vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS, + float minLod = 0.0f, + float maxLod = 16.0f, + vk::VkBorderColor borderColor = vk::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, + vk::VkBool32 unnormalizedCoordinates = false); }; } // DynamicState } // vkt -#endif // _VKT_DYNAMIC_STATE_CREATEINFO_UTIL_HPP +#endif // _VKTDYNAMICSTATECREATEINFOUTIL_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.cpp index 1fcefc6..7b6c923 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.cpp @@ -43,6 +43,7 @@ #include "tcuImageCompare.hpp" #include "tcuCommandLine.hpp" #include "tcuTextureUtil.hpp" +#include "tcuRGBA.hpp" #include "vkRefUtil.hpp" #include "vkImageUtil.hpp" @@ -57,38 +58,13 @@ namespace vkt namespace DynamicState { -inline tcu::Vec4 vec4Red (void) -{ - return tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f); -} - -inline tcu::Vec4 vec4Green (void) -{ - return tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f); -} - -inline tcu::Vec4 vec4Blue (void) -{ - return tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f); -} - namespace { -struct Vec4RGBA -{ - Vec4RGBA(tcu::Vec4 p, tcu::Vec4 c) - : position(p) - , color(c) - {} - tcu::Vec4 position; - tcu::Vec4 color; -}; - class DepthStencilBaseCase : public TestInstance { public: - DepthStencilBaseCase (Context &context, const char* vertexShaderName, const char* fragmentShaderName) + DepthStencilBaseCase (Context& context, const char* vertexShaderName, const char* fragmentShaderName) : TestInstance (context) , m_colorAttachmentFormat (vk::VK_FORMAT_R8G8B8A8_UNORM) , m_depthStencilAttachmentFormat (vk::VK_FORMAT_D24_UNORM_S8_UINT) @@ -136,7 +112,7 @@ protected: const std::string m_vertexShaderName; const std::string m_fragmentShaderName; - std::vector m_data; + std::vector m_data; PipelineCreateInfo::DepthStencilState m_depthStencilState_1; PipelineCreateInfo::DepthStencilState m_depthStencilState_2; @@ -154,14 +130,13 @@ protected: const vk::VkExtent3D imageExtent = { WIDTH, HEIGHT, 1 }; const ImageCreateInfo targetImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, - vk::VK_IMAGE_TILING_OPTIMAL, vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT); + vk::VK_IMAGE_TILING_OPTIMAL, vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT); m_colorTargetImage = Image::createAndAlloc(m_vk, device, targetImageCreateInfo, m_context.getDefaultAllocator()); - const ImageCreateInfo depthStencilImageCreateInfo( - vk::VK_IMAGE_TYPE_2D, m_depthStencilAttachmentFormat, imageExtent, - 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL, - vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT); + const ImageCreateInfo depthStencilImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_depthStencilAttachmentFormat, imageExtent, + 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL, + vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT); m_depthStencilImage = Image::createAndAlloc(m_vk, device, depthStencilImageCreateInfo, m_context.getDefaultAllocator()); @@ -172,25 +147,23 @@ protected: m_attachmentView = vk::createImageView(m_vk, device, &attachmentViewInfo); RenderPassCreateInfo renderPassCreateInfo; - renderPassCreateInfo.addAttachment(AttachmentDescription( - m_colorAttachmentFormat, - vk::VK_SAMPLE_COUNT_1_BIT, - vk::VK_ATTACHMENT_LOAD_OP_LOAD, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_IMAGE_LAYOUT_GENERAL, - vk::VK_IMAGE_LAYOUT_GENERAL)); - - renderPassCreateInfo.addAttachment(AttachmentDescription( - m_depthStencilAttachmentFormat, - vk::VK_SAMPLE_COUNT_1_BIT, - vk::VK_ATTACHMENT_LOAD_OP_LOAD, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); + renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat, + vk::VK_SAMPLE_COUNT_1_BIT, + vk::VK_ATTACHMENT_LOAD_OP_LOAD, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_IMAGE_LAYOUT_GENERAL, + vk::VK_IMAGE_LAYOUT_GENERAL)); + + renderPassCreateInfo.addAttachment(AttachmentDescription(m_depthStencilAttachmentFormat, + vk::VK_SAMPLE_COUNT_1_BIT, + vk::VK_ATTACHMENT_LOAD_OP_LOAD, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); const vk::VkAttachmentReference colorAttachmentReference = { @@ -284,12 +257,11 @@ protected: m_framebuffer = vk::createFramebuffer(m_vk, device, &framebufferCreateInfo); - const vk::VkDeviceSize dataSize = m_data.size() * sizeof(Vec4RGBA); - m_vertexBuffer = Buffer::createAndAlloc(m_vk, device, BufferCreateInfo(dataSize, - vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), - m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible); + const vk::VkDeviceSize dataSize = m_data.size() * sizeof(PositionColorVertex); + m_vertexBuffer = Buffer::createAndAlloc(m_vk, device, BufferCreateInfo(dataSize, vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), + m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible); - unsigned char *ptr = reinterpret_cast(m_vertexBuffer->getBoundMemory().getHostPtr()); + deUint8* ptr = reinterpret_cast(m_vertexBuffer->getBoundMemory().getHostPtr()); deMemcpy(ptr, &m_data[0], dataSize); vk::flushMappedMemoryRange(m_vk, device, @@ -313,7 +285,8 @@ protected: virtual tcu::TestStatus iterate (void) { - TCU_FAIL("Implement iterate() method!"); + DE_ASSERT(false); + return tcu::TestStatus::fail("Implement iterate() method!"); } void beginRenderPass (void) @@ -413,20 +386,20 @@ public: DepthBoundsParamTestInstance (Context &context, ShaderMap shaders) : DepthStencilBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 0.375f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.0f, 1.0f, 0.375f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 0.375f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.0f, -1.0f, 0.375f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 0.375f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.0f, 1.0f, 0.375f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 0.375f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.0f, -1.0f, 0.375f, 1.0f), tcu::RGBA::green().toVec())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.0f, 1.0f, 0.625f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 0.625f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.0f, -1.0f, 0.625f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 0.625f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.0f, 1.0f, 0.625f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 0.625f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.0f, -1.0f, 0.625f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 0.625f, 1.0f), tcu::RGBA::green().toVec())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); m_depthStencilState_1 = PipelineCreateInfo::DepthStencilState( vk::VK_TRUE, vk::VK_TRUE, vk::VK_COMPARE_OP_ALWAYS, vk::VK_FALSE); @@ -515,16 +488,14 @@ public: const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; @@ -538,7 +509,7 @@ protected: tcu::Vec4 m_expectedColor; public: - StencilParamsBasicTestInstance (Context &context, const char* vertexShaderName, const char* fragmentShaderName, + StencilParamsBasicTestInstance (Context& context, const char* vertexShaderName, const char* fragmentShaderName, const deUint32 writeMask, const deUint32 readMask, const deUint32 expectedValue, const tcu::Vec4 expectedColor) : DepthStencilBaseCase (context, vertexShaderName, fragmentShaderName) @@ -549,15 +520,15 @@ public: m_expectedValue = expectedValue; m_expectedColor = expectedColor; - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); const PipelineCreateInfo::DepthStencilState::StencilOpState frontState_1 = PipelineCreateInfo::DepthStencilState::StencilOpState( @@ -664,16 +635,14 @@ public: const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; @@ -702,7 +671,7 @@ protected: tcu::Vec4 m_expectedColor; public: - StencilParamsBasicTestCase (tcu::TestContext &context, const char *name, const char *description, + StencilParamsBasicTestCase (tcu::TestContext& context, const char *name, const char *description, const deUint32 writeMask, const deUint32 readMask, const deUint32 expectedValue, const tcu::Vec4 expectedColor) : TestCase (context, name, description) @@ -717,18 +686,18 @@ public: class StencilParamsAdvancedTestInstance : public DepthStencilBaseCase { public: - StencilParamsAdvancedTestInstance (Context &context, ShaderMap shaders) + StencilParamsAdvancedTestInstance (Context& context, ShaderMap shaders) : DepthStencilBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { - m_data.push_back(Vec4RGBA(tcu::Vec4(-0.5f, 0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-0.5f, -0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.5f, -0.5f, 1.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, 0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, -0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, -0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); const PipelineCreateInfo::DepthStencilState::StencilOpState frontState_1 = PipelineCreateInfo::DepthStencilState::StencilOpState( @@ -837,29 +806,29 @@ public: const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; } //anonymous -DynamicStateDSTests::DynamicStateDSTests (tcu::TestContext &testCtx) +DynamicStateDSTests::DynamicStateDSTests (tcu::TestContext& testCtx) : TestCaseGroup (testCtx, "ds_state", "Tests for depth stencil state") { /* Left blank on purpose */ } -DynamicStateDSTests::~DynamicStateDSTests () {} +DynamicStateDSTests::~DynamicStateDSTests () +{ +} void DynamicStateDSTests::init (void) { @@ -873,5 +842,5 @@ void DynamicStateDSTests::init (void) addChild(new InstanceFactory(m_testCtx, "stencil_params_advanced", "Perform advanced stencil test", shaderPaths)); } -} //DynamicState -} //vkt +} // DynamicState +} // vkt diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.hpp index 759a4f9..acb0ae6 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateDSTests.hpp @@ -45,16 +45,16 @@ namespace DynamicState class DynamicStateDSTests : public tcu::TestCaseGroup { public: - DynamicStateDSTests (tcu::TestContext &testCtx); - ~DynamicStateDSTests (void); - void init (void); + DynamicStateDSTests (tcu::TestContext& testCtx); + ~DynamicStateDSTests (void); + void init (void); private: - DynamicStateDSTests (const DynamicStateDSTests &other); - DynamicStateDSTests &operator=(const DynamicStateDSTests &other); + DynamicStateDSTests (const DynamicStateDSTests& other); + DynamicStateDSTests& operator= (const DynamicStateDSTests& other); }; -} //DynamicState -} //vkt +} // DynamicState +} // vkt #endif // _VKTDYNAMICSTATEDSTESTS_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateGeneralTests.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateGeneralTests.cpp index d1d3a56..061ef66 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateGeneralTests.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateGeneralTests.cpp @@ -42,10 +42,13 @@ #include "vktDynamicStateImageObjectUtil.hpp" #include "vktDynamicStateBufferObjectUtil.hpp" +#include "vkImageUtil.hpp" + #include "tcuTestLog.hpp" #include "tcuResource.hpp" #include "tcuImageCompare.hpp" #include "tcuTextureUtil.hpp" +#include "tcuRGBA.hpp" #include "vkDefs.hpp" @@ -64,25 +67,25 @@ public: { m_topology = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); DynamicStateBaseClass::initialize(); } virtual tcu::TestStatus iterate (void) { - tcu::TestLog &log = m_context.getTestContext().getLog(); + tcu::TestLog& log = m_context.getTestContext().getLog(); const vk::VkQueue queue = m_context.getUniversalQueue(); beginRenderPass(); // bind states here vk::VkViewport viewport = { 0, 0, (float)WIDTH, (float)HEIGHT, 0.0f, 0.0f }; - vk::VkRect2D scissor_1 = { { 0, 0 }, { WIDTH / 2, HEIGHT / 2 } }; - vk::VkRect2D scissor_2 = { { WIDTH / 2, HEIGHT / 2 }, { WIDTH / 2, HEIGHT / 2 } }; + vk::VkRect2D scissor_1 = { { 0, 0 }, { WIDTH / 2, HEIGHT / 2 } }; + vk::VkRect2D scissor_2 = { { WIDTH / 2, HEIGHT / 2 }, { WIDTH / 2, HEIGHT / 2 } }; setDynamicRasterizationState(); setDynamicBlendState(); @@ -90,8 +93,8 @@ public: m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline); - const vk::VkDeviceSize vertexBufferOffset = 0; - const vk::VkBuffer vertexBuffer = m_vertexBuffer->object(); + const vk::VkDeviceSize vertexBufferOffset = 0; + const vk::VkBuffer vertexBuffer = m_vertexBuffer->object(); m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset); // bind first state @@ -107,14 +110,14 @@ public: vk::VkSubmitInfo submitInfo = { - vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; - DE_NULL, // const void* pNext; - 0, // deUint32 waitSemaphoreCount; - DE_NULL, // const VkSemaphore* pWaitSemaphores; - 1, // deUint32 commandBufferCount; - &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; - 0, // deUint32 signalSemaphoreCount; - DE_NULL // const VkSemaphore* pSignalSemaphores; + vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0, // deUint32 waitSemaphoreCount; + DE_NULL, // const VkSemaphore* pWaitSemaphores; + 1, // deUint32 commandBufferCount; + &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; + 0, // deUint32 signalSemaphoreCount; + DE_NULL // const VkSemaphore* pSignalSemaphores; }; m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL); @@ -124,8 +127,8 @@ public: tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT)); referenceFrame.allocLevel(0); - const deInt32 frameWidth = referenceFrame.getWidth(); - const deInt32 frameHeight = referenceFrame.getHeight(); + const deInt32 frameWidth = referenceFrame.getWidth(); + const deInt32 frameHeight = referenceFrame.getHeight(); tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); @@ -143,49 +146,50 @@ public: } } - const vk::VkOffset3D zeroOffset = { 0, 0, 0 }; + const vk::VkOffset3D zeroOffset = { 0, 0, 0 }; const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), - vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - - qpTestResult res = QP_TEST_RESULT_PASS; + vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, + vk::VK_IMAGE_ASPECT_COLOR_BIT); if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, - tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + tcu::COMPARE_LOG_RESULT)) + { + + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } }; class BindOrderTestInstance : public DynamicStateBaseClass { public: - BindOrderTestInstance (Context &context, ShaderMap shaders) + BindOrderTestInstance (Context& context, ShaderMap shaders) : DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { m_topology = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); DynamicStateBaseClass::initialize(); } virtual tcu::TestStatus iterate (void) { - tcu::TestLog &log = m_context.getTestContext().getLog(); + tcu::TestLog &log = m_context.getTestContext().getLog(); const vk::VkQueue queue = m_context.getUniversalQueue(); beginRenderPass(); // bind states here vk::VkViewport viewport = { 0.0f, 0.0f, (float)WIDTH, (float)HEIGHT, 0.0f, 0.0f }; - vk::VkRect2D scissor_1 = { { 0, 0 }, { WIDTH / 2, HEIGHT / 2 } }; - vk::VkRect2D scissor_2 = { { WIDTH / 2, HEIGHT / 2 }, { WIDTH / 2, HEIGHT / 2 } }; + vk::VkRect2D scissor_1 = { { 0, 0 }, { WIDTH / 2, HEIGHT / 2 } }; + vk::VkRect2D scissor_2 = { { WIDTH / 2, HEIGHT / 2 }, { WIDTH / 2, HEIGHT / 2 } }; setDynamicRasterizationState(); setDynamicBlendState(); @@ -215,14 +219,14 @@ public: vk::VkSubmitInfo submitInfo = { - vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; - DE_NULL, // const void* pNext; - 0, // deUint32 waitSemaphoreCount; - DE_NULL, // const VkSemaphore* pWaitSemaphores; - 1, // deUint32 commandBufferCount; - &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; - 0, // deUint32 signalSemaphoreCount; - DE_NULL // const VkSemaphore* pSignalSemaphores; + vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0, // deUint32 waitSemaphoreCount; + DE_NULL, // const VkSemaphore* pWaitSemaphores; + 1, // deUint32 commandBufferCount; + &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; + 0, // deUint32 signalSemaphoreCount; + DE_NULL // const VkSemaphore* pSignalSemaphores; }; m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL); @@ -255,15 +259,14 @@ public: const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, - tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + tcu::COMPARE_LOG_RESULT)) + { + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } }; @@ -273,20 +276,20 @@ protected: vk::Move m_pipelineAdditional; public: - StatePersistenceTestInstance (Context &context, ShaderMap shaders) + StatePersistenceTestInstance (Context& context, ShaderMap shaders) : DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Green())); - - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), vec4Blue())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec())); DynamicStateBaseClass::initialize(); } @@ -328,15 +331,15 @@ public: virtual tcu::TestStatus iterate(void) { - tcu::TestLog &log = m_context.getTestContext().getLog(); - const vk::VkQueue queue = m_context.getUniversalQueue(); + tcu::TestLog &log = m_context.getTestContext().getLog(); + const vk::VkQueue queue = m_context.getUniversalQueue(); beginRenderPass(); // bind states here - const vk::VkViewport viewport = { 0.0f, 0.0f, (float)WIDTH, (float)HEIGHT, 0.0f, 0.0f }; - const vk::VkRect2D scissor_1 = { { 0, 0 }, { WIDTH / 2, HEIGHT / 2 } }; - const vk::VkRect2D scissor_2 = { { WIDTH / 2, HEIGHT / 2 }, { WIDTH / 2, HEIGHT / 2 } }; + const vk::VkViewport viewport = { 0.0f, 0.0f, (float)WIDTH, (float)HEIGHT, 0.0f, 0.0f }; + const vk::VkRect2D scissor_1 = { { 0, 0 }, { WIDTH / 2, HEIGHT / 2 } }; + const vk::VkRect2D scissor_2 = { { WIDTH / 2, HEIGHT / 2 }, { WIDTH / 2, HEIGHT / 2 } }; setDynamicRasterizationState(); setDynamicBlendState(); @@ -365,14 +368,14 @@ public: vk::VkSubmitInfo submitInfo = { - vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; - DE_NULL, // const void* pNext; - 0, // deUint32 waitSemaphoreCount; - DE_NULL, // const VkSemaphore* pWaitSemaphores; - 1, // deUint32 commandBufferCount; - &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; - 0, // deUint32 signalSemaphoreCount; - DE_NULL // const VkSemaphore* pSignalSemaphores; + vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0, // deUint32 waitSemaphoreCount; + DE_NULL, // const VkSemaphore* pWaitSemaphores; + 1, // deUint32 commandBufferCount; + &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; + 0, // deUint32 signalSemaphoreCount; + DE_NULL // const VkSemaphore* pSignalSemaphores; }; m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL); @@ -382,8 +385,8 @@ public: tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT)); referenceFrame.allocLevel(0); - const deInt32 frameWidth = referenceFrame.getWidth(); - const deInt32 frameHeight = referenceFrame.getHeight(); + const deInt32 frameWidth = referenceFrame.getWidth(); + const deInt32 frameHeight = referenceFrame.getHeight(); tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); @@ -406,21 +409,20 @@ public: const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, - tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + tcu::COMPARE_LOG_RESULT)) + { + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } }; } //anonymous -DynamicStateGeneralTests::DynamicStateGeneralTests (tcu::TestContext &testCtx) +DynamicStateGeneralTests::DynamicStateGeneralTests (tcu::TestContext& testCtx) : TestCaseGroup (testCtx, "general_state", "General tests for dynamic states") { /* Left blank on purpose */ @@ -439,5 +441,5 @@ void DynamicStateGeneralTests::init (void) addChild(new InstanceFactory(m_testCtx, "state_persistence", "Check if bound states are persistent across pipelines", shaderPaths)); } -} //DynamicState -} //vkt +} // DynamicState +} // vkt diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateGeneralTests.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateGeneralTests.hpp index 49cd727..4adf974 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateGeneralTests.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateGeneralTests.hpp @@ -45,16 +45,16 @@ namespace DynamicState class DynamicStateGeneralTests : public tcu::TestCaseGroup { public: - DynamicStateGeneralTests (tcu::TestContext &testCtx); - ~DynamicStateGeneralTests (void); - void init (void); - -private: - DynamicStateGeneralTests (const DynamicStateGeneralTests &other); - DynamicStateGeneralTests &operator=(const DynamicStateGeneralTests &other); + DynamicStateGeneralTests (tcu::TestContext& testCtx); + ~DynamicStateGeneralTests (void); + void init (void); + +private: + DynamicStateGeneralTests (const DynamicStateGeneralTests& other); + DynamicStateGeneralTests& operator= (const DynamicStateGeneralTests& other); }; -} //DynamicState -} //vkt +} // DynamicState +} // vkt #endif // _VKTDYNAMICSTATEGENERALTESTS_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.cpp index 7faea30..3697487 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.cpp @@ -55,11 +55,14 @@ void MemoryOp::pack (int pixelSize, int width, int height, int depth, - vk::VkDeviceSize rowPitch, - vk::VkDeviceSize depthPitch, + vk::VkDeviceSize rowPitchOrZero, + vk::VkDeviceSize depthPitchOrZero, const void * srcBuffer, void * destBuffer) { + vk::VkDeviceSize rowPitch = rowPitchOrZero; + vk::VkDeviceSize depthPitch = depthPitchOrZero; + if (rowPitch == 0) rowPitch = width * pixelSize; @@ -104,11 +107,14 @@ void MemoryOp::unpack (int pixelSize, int width, int height, int depth, - vk::VkDeviceSize rowPitch, - vk::VkDeviceSize depthPitch, + vk::VkDeviceSize rowPitchOrZero, + vk::VkDeviceSize depthPitchOrZero, const void * srcBuffer, void * destBuffer) { + vk::VkDeviceSize rowPitch = rowPitchOrZero; + vk::VkDeviceSize depthPitch = depthPitchOrZero; + if (rowPitch == 0) rowPitch = width * pixelSize; @@ -148,10 +154,10 @@ void MemoryOp::unpack (int pixelSize, } } -Image::Image (const vk::DeviceInterface &vk, +Image::Image (const vk::DeviceInterface& vk, vk::VkDevice device, vk::VkFormat format, - const vk::VkExtent3D &extend, + const vk::VkExtent3D& extend, deUint32 levelCount, deUint32 layerCount, vk::Move object) @@ -252,8 +258,7 @@ void Image::read (vk::VkQueue queue, vk::VkImageType type, void * data) { - if (layout != vk::VK_IMAGE_LAYOUT_GENERAL && layout != vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) - TCU_FAIL("Image::uploadFromSurface usage error: this function is not going to change Image layout!"); + DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); de::SharedPtr stagingResource = copyToLinearImage(queue, allocator, layout, offset, width, height, depth, mipLevel, arrayElement, aspect, type); @@ -273,8 +278,7 @@ void Image::readUsingBuffer (vk::VkQueue queue, vk::VkImageAspectFlagBits aspect, void * data) { - if (layout != vk::VK_IMAGE_LAYOUT_GENERAL && layout != vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) - TCU_FAIL("Image::uploadFromSurface usage error: this function is not going to change Image layout!"); + DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);; de::SharedPtr stagingResource; @@ -307,7 +311,7 @@ void Image::readUsingBuffer (vk::VkQueue queue, stagingResource = Buffer::createAndAlloc(m_vk, m_device, stagingBufferResourceCreateInfo, allocator, vk::MemoryRequirement::HostVisible); { - #pragma message("Get queue family index") + //todo [scygan] get proper queueFamilyIndex CmdPoolCreateInfo copyCmdPoolCreateInfo(0); vk::Unique copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo)); @@ -433,14 +437,13 @@ de::SharedPtr Image::copyToLinearImage (vk::VkQueue queue, de::SharedPtr stagingResource; { vk::VkExtent3D stagingExtent = {width, height, depth}; - ImageCreateInfo stagingResourceCreateInfo( - type, m_format, stagingExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, - vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT); + ImageCreateInfo stagingResourceCreateInfo(type, m_format, stagingExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, + vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT); stagingResource = Image::createAndAlloc(m_vk, m_device, stagingResourceCreateInfo, allocator, - vk::MemoryRequirement::HostVisible); + vk::MemoryRequirement::HostVisible); - #pragma message("Get queue family index") + //todo [scygan] get proper queueFamilyIndex CmdPoolCreateInfo copyCmdPoolCreateInfo(0); vk::Unique copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo)); @@ -575,13 +578,7 @@ void Image::upload (vk::VkQueue queue, vk::VkImageType type, const void * data) { - - if (layout != vk::VK_IMAGE_LAYOUT_UNDEFINED - && layout != vk::VK_IMAGE_LAYOUT_GENERAL - && layout != vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) - { - TCU_FAIL("Image::uploadFromRaw usage error: this function is not going to change Image layout!"); - } + DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_UNDEFINED || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); de::SharedPtr stagingResource; vk::VkExtent3D extent = {width, height, depth}; @@ -596,7 +593,7 @@ void Image::upload (vk::VkQueue queue, stagingResource->uploadLinear(zeroOffset, width, height, depth, 0, 0, aspect, data); { - #pragma message("Get queue family index") + //todo [scygan] get proper queueFamilyIndex CmdPoolCreateInfo copyCmdPoolCreateInfo(0); vk::Unique copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo)); @@ -682,12 +679,7 @@ void Image::uploadUsingBuffer (vk::VkQueue queue, vk::VkImageAspectFlagBits aspect, const void * data) { - if (layout != vk::VK_IMAGE_LAYOUT_UNDEFINED - && layout != vk::VK_IMAGE_LAYOUT_GENERAL - && layout != vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) - { - TCU_FAIL("Image::uploadFromRaw usage error: this function is not going to change Image layout!"); - } + DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_UNDEFINED || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); de::SharedPtr stagingResource; bool isCombinedType = isCombinedDepthStencilType(vk::mapVkFormat(m_format).type); @@ -718,7 +710,7 @@ void Image::uploadUsingBuffer (vk::VkQueue queue, deMemcpy(destPtr, data, bufferSize); vk::flushMappedMemoryRange(m_vk, m_device, stagingResource->getBoundMemory().getMemory(), stagingResource->getBoundMemory().getOffset(), bufferSize); { - #pragma message("Get queue family index") + //todo [scygan] get proper queueFamilyIndex CmdPoolCreateInfo copyCmdPoolCreateInfo(0); vk::Unique copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo)); @@ -790,7 +782,6 @@ void Image::uploadUsingBuffer (vk::VkQueue queue, } } - void Image::uploadLinear (vk::VkOffset3D offset, int width, int height, @@ -821,11 +812,8 @@ vk::VkDeviceSize Image::getPixelOffset (vk::VkOffset3D offset, unsigned int level, unsigned int layer) { - if (level >= m_levelCount) - TCU_FAIL("mip level too large"); - - if (layer >= m_layerCount) - TCU_FAIL("array element too large"); + DE_ASSERT(level < m_levelCount); + DE_ASSERT(layer < m_layerCount); vk::VkDeviceSize mipLevelSizes[32]; vk::VkDeviceSize mipLevelRectSizes[32]; @@ -913,7 +901,6 @@ void transition2DImage (const vk::DeviceInterface& vk, vk.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers); } - void initialTransitionColor2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout) { transition2DImage(vk, cmdBuffer, image, vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, layout); @@ -934,5 +921,5 @@ void initialTransitionDepthStencil2DImage (const vk::DeviceInterface &vk, vk::Vk transition2DImage(vk, cmdBuffer, image, vk::VK_IMAGE_ASPECT_DEPTH_BIT | vk::VK_IMAGE_ASPECT_STENCIL_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, layout); } -} //DynamicState -} //vkt +} // DynamicState +} // vkt diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.hpp index d65075d..4515b1a 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateImageObjectUtil.hpp @@ -1,5 +1,5 @@ -#ifndef _VKT_DYNAMIC_STATE_IMAGEOBJECTUTIL_HPP -#define _VKT_DYNAMIC_STATE_IMAGEOBJECTUTIL_HPP +#ifndef _VKTDYNAMICSTATEIMAGEOBJECTUTIL_HPP +#define _VKTDYNAMICSTATEIMAGEOBJECTUTIL_HPP /*------------------------------------------------------------------------ * Vulkan Conformance Tests * ------------------------ @@ -55,8 +55,8 @@ public: int width, int height, int depth, - vk::VkDeviceSize rowPitch, - vk::VkDeviceSize depthPitch, + vk::VkDeviceSize rowPitchOrZero, + vk::VkDeviceSize depthPitchOrZero, const void * srcBuffer, void * destBuffer); @@ -64,17 +64,16 @@ public: int width, int height, int depth, - vk::VkDeviceSize rowPitch, - vk::VkDeviceSize depthPitch, + vk::VkDeviceSize rowPitchOrZero, + vk::VkDeviceSize depthPitchOrZero, const void * srcBuffer, void * destBuffer); }; - class Image { public: - static de::SharedPtr create (const vk::DeviceInterface &vk, vk::VkDevice device, const vk::VkImageCreateInfo &createInfo); + static de::SharedPtr create (const vk::DeviceInterface& vk, vk::VkDevice device, const vk::VkImageCreateInfo& createInfo); static de::SharedPtr createAndAlloc (const vk::DeviceInterface& vk, vk::VkDevice device, @@ -112,7 +111,6 @@ public: unsigned int mipLevel = 0, unsigned int arrayElement = 0); - tcu::ConstPixelBufferAccess readSurfaceLinear (vk::VkOffset3D offset, int width, int height, @@ -257,8 +255,8 @@ private: deUint32 layerCount, vk::Move object); - Image (const Image &other); // Not allowed! - Image &operator= (const Image &other); // Not allowed! + Image (const Image& other); // Not allowed! + Image& operator= (const Image& other); // Not allowed! de::MovePtr m_allocation; vk::Unique m_object; @@ -274,17 +272,17 @@ private: vk::VkDevice m_device; }; -void transition2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageAspectFlags aspectMask, vk::VkImageLayout oldLayout, vk::VkImageLayout newLayout); +void transition2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageAspectFlags aspectMask, vk::VkImageLayout oldLayout, vk::VkImageLayout newLayout); -void initialTransitionColor2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout); +void initialTransitionColor2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout); -void initialTransitionDepth2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout); +void initialTransitionDepth2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout); -void initialTransitionStencil2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout); +void initialTransitionStencil2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout); -void initialTransitionDepthStencil2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout); +void initialTransitionDepthStencil2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout); -} //DynamicState -} //vkt +} // DynamicState +} // vkt -#endif // _VKT_DYNAMIC_STATE_IMAGEOBJECTUTIL_HPP +#endif // _VKTDYNAMICSTATEIMAGEOBJECTUTIL_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp index 04a3c81..ebb373e 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.cpp @@ -34,10 +34,15 @@ *//*--------------------------------------------------------------------*/ #include "vktDynamicStateRSTests.hpp" -#include "vktDynamicStateBaseClass.hpp" +#include "vktDynamicStateBaseClass.hpp" #include "vktDynamicStateTestCaseUtil.hpp" + +#include "vkImageUtil.hpp" + #include "tcuTextureUtil.hpp" +#include "tcuImageCompare.hpp" +#include "tcuRGBA.hpp" #include "deMath.h" @@ -51,7 +56,7 @@ namespace class DepthBiasBaseCase : public TestInstance { public: - DepthBiasBaseCase (Context &context, const char* vertexShaderName, const char* fragmentShaderName) + DepthBiasBaseCase (Context& context, const char* vertexShaderName, const char* fragmentShaderName) : TestInstance (context) , m_colorAttachmentFormat (vk::VK_FORMAT_R8G8B8A8_UNORM) , m_depthStencilAttachmentFormat (vk::VK_FORMAT_D24_UNORM_S8_UINT) @@ -98,32 +103,30 @@ protected: std::string m_vertexShaderName; std::string m_fragmentShaderName; - std::vector m_data; + std::vector m_data; - PipelineCreateInfo::DepthStencilState m_depthStencilState; + PipelineCreateInfo::DepthStencilState m_depthStencilState; void initialize (void) { - tcu::TestLog &log = m_context.getTestContext().getLog(); - const vk::VkDevice device = m_context.getDevice(); + tcu::TestLog &log = m_context.getTestContext().getLog(); + const vk::VkDevice device = m_context.getDevice(); const PipelineLayoutCreateInfo pipelineLayoutCreateInfo; - m_pipelineLayout = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo); + m_pipelineLayout = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo); const vk::Unique vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0)); const vk::Unique fs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_fragmentShaderName), 0)); const vk::VkExtent3D imageExtent = { WIDTH, HEIGHT, 1 }; - ImageCreateInfo targetImageCreateInfo( - vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL, - vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT); + ImageCreateInfo targetImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL, + vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT); m_colorTargetImage = Image::createAndAlloc(m_vk, device, targetImageCreateInfo, m_context.getDefaultAllocator()); - const ImageCreateInfo depthStencilImageCreateInfo( - vk::VK_IMAGE_TYPE_2D, m_depthStencilAttachmentFormat, imageExtent, - 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL, - vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT); + const ImageCreateInfo depthStencilImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_depthStencilAttachmentFormat, imageExtent, + 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL, + vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT); m_depthStencilImage = Image::createAndAlloc(m_vk, device, depthStencilImageCreateInfo, m_context.getDefaultAllocator()); @@ -134,25 +137,23 @@ protected: m_attachmentView = vk::createImageView(m_vk, device, &attachmentViewInfo); RenderPassCreateInfo renderPassCreateInfo; - renderPassCreateInfo.addAttachment(AttachmentDescription( - m_colorAttachmentFormat, - vk::VK_SAMPLE_COUNT_1_BIT, - vk::VK_ATTACHMENT_LOAD_OP_LOAD, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_IMAGE_LAYOUT_GENERAL, - vk::VK_IMAGE_LAYOUT_GENERAL)); - - renderPassCreateInfo.addAttachment(AttachmentDescription( - m_depthStencilAttachmentFormat, - vk::VK_SAMPLE_COUNT_1_BIT, - vk::VK_ATTACHMENT_LOAD_OP_LOAD, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, - vk::VK_ATTACHMENT_STORE_OP_STORE, - vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); + renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat, + vk::VK_SAMPLE_COUNT_1_BIT, + vk::VK_ATTACHMENT_LOAD_OP_LOAD, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_IMAGE_LAYOUT_GENERAL, + vk::VK_IMAGE_LAYOUT_GENERAL)); + + renderPassCreateInfo.addAttachment(AttachmentDescription(m_depthStencilAttachmentFormat, + vk::VK_SAMPLE_COUNT_1_BIT, + vk::VK_ATTACHMENT_LOAD_OP_LOAD, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, + vk::VK_ATTACHMENT_STORE_OP_STORE, + vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); const vk::VkAttachmentReference colorAttachmentReference = { @@ -166,17 +167,16 @@ protected: vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }; - renderPassCreateInfo.addSubpass(SubpassDescription( - vk::VK_PIPELINE_BIND_POINT_GRAPHICS, - 0, - 0, - DE_NULL, - 1, - &colorAttachmentReference, - DE_NULL, - depthAttachmentReference, - 0, - DE_NULL)); + renderPassCreateInfo.addSubpass(SubpassDescription(vk::VK_PIPELINE_BIND_POINT_GRAPHICS, + 0, + 0, + DE_NULL, + 1, + &colorAttachmentReference, + DE_NULL, + depthAttachmentReference, + 0, + DE_NULL)); m_renderPass = vk::createRenderPass(m_vk, device, &renderPassCreateInfo); @@ -203,11 +203,10 @@ protected: } }; - m_vertexInputState = PipelineCreateInfo::VertexInputState( - 1, - &vertexInputBindingDescription, - 2, - vertexInputAttributeDescriptions); + m_vertexInputState = PipelineCreateInfo::VertexInputState(1, + &vertexInputBindingDescription, + 2, + vertexInputAttributeDescriptions); const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState; @@ -233,18 +232,18 @@ protected: m_framebuffer = vk::createFramebuffer(m_vk, device, &framebufferCreateInfo); - const vk::VkDeviceSize dataSize = m_data.size() * sizeof(Vec4RGBA); + const vk::VkDeviceSize dataSize = m_data.size() * sizeof(PositionColorVertex); m_vertexBuffer = Buffer::createAndAlloc(m_vk, device, BufferCreateInfo(dataSize, vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible); - unsigned char *ptr = reinterpret_cast(m_vertexBuffer->getBoundMemory().getHostPtr()); + deUint8* ptr = reinterpret_cast(m_vertexBuffer->getBoundMemory().getHostPtr()); deMemcpy(ptr, &m_data[0], dataSize); vk::flushMappedMemoryRange(m_vk, device, - m_vertexBuffer->getBoundMemory().getMemory(), - m_vertexBuffer->getBoundMemory().getOffset(), - sizeof(dataSize)); + m_vertexBuffer->getBoundMemory().getMemory(), + m_vertexBuffer->getBoundMemory().getOffset(), + sizeof(dataSize)); const CmdPoolCreateInfo cmdPoolCreateInfo(m_context.getUniversalQueueFamilyIndex()); m_cmdPool = vk::createCommandPool(m_vk, device, &cmdPoolCreateInfo); @@ -262,7 +261,8 @@ protected: virtual tcu::TestStatus iterate (void) { - TCU_FAIL("Implement iterate() method!"); + DE_ASSERT(false); + return tcu::TestStatus::fail("Should reimplement iterate() method"); } void beginRenderPass (void) @@ -281,13 +281,13 @@ protected: const ImageSubresourceRange subresourceRangeImage(vk::VK_IMAGE_ASPECT_COLOR_BIT); m_vk.cmdClearColorImage(*m_cmdBuffer, m_colorTargetImage->object(), - vk::VK_IMAGE_LAYOUT_GENERAL, &clearColor, 1, &subresourceRangeImage); + vk::VK_IMAGE_LAYOUT_GENERAL, &clearColor, 1, &subresourceRangeImage); const vk::VkClearDepthStencilValue depthStencilClearValue = { 0.0f, 0 }; const ImageSubresourceRange subresourceRangeDepthStencil[2] = { vk::VK_IMAGE_ASPECT_DEPTH_BIT, vk::VK_IMAGE_ASPECT_STENCIL_BIT }; m_vk.cmdClearDepthStencilImage(*m_cmdBuffer, m_depthStencilImage->object(), - vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &depthStencilClearValue, 2, subresourceRangeDepthStencil); + vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &depthStencilClearValue, 2, subresourceRangeDepthStencil); const vk::VkRect2D renderArea = { { 0, 0 }, { WIDTH, HEIGHT } }; const RenderPassBeginInfo renderPassBegin(*m_renderPass, *m_framebuffer, renderArea); @@ -355,23 +355,23 @@ protected: class DepthBiasParamTestInstance : public DepthBiasBaseCase { public: - DepthBiasParamTestInstance (Context &context, ShaderMap shaders) + DepthBiasParamTestInstance (Context& context, ShaderMap shaders) : DepthBiasBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 0.5f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 0.5f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 0.5f, 1.0f), vec4Blue())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 0.5f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 0.5f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 0.5f, 1.0f), tcu::RGBA::blue().toVec())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-0.5f, 0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-0.5f, -0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.5f, -0.5f, 1.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, 0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, -0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, -0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f), vec4Red())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 0.5f, 1.0f), vec4Red())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 0.5f, 1.0f), vec4Red())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 0.5f, 1.0f), vec4Red())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f), tcu::RGBA::red().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 0.5f, 1.0f), tcu::RGBA::red().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 0.5f, 1.0f), tcu::RGBA::red().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 0.5f, 1.0f), tcu::RGBA::red().toVec())); // enable depth test m_depthStencilState = PipelineCreateInfo::DepthStencilState( @@ -382,7 +382,7 @@ public: virtual tcu::TestStatus iterate (void) { - tcu::TestLog &log = m_context.getTestContext().getLog(); + tcu::TestLog &log = m_context.getTestContext().getLog(); const vk::VkQueue queue = m_context.getUniversalQueue(); beginRenderPass(); @@ -394,8 +394,8 @@ public: m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline); - const vk::VkDeviceSize vertexBufferOffset = 0; - const vk::VkBuffer vertexBuffer = m_vertexBuffer->object(); + const vk::VkDeviceSize vertexBufferOffset = 0; + const vk::VkBuffer vertexBuffer = m_vertexBuffer->object(); m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset); setDynamicRasterizationState(1.0f, 0.0f); @@ -452,16 +452,14 @@ public: const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; @@ -469,22 +467,21 @@ public: class DepthBiasClampParamTestInstance : public DepthBiasBaseCase { public: - DepthBiasClampParamTestInstance (Context &context, ShaderMap shaders) + DepthBiasClampParamTestInstance (Context& context, ShaderMap shaders) : DepthBiasBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f), vec4Blue())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, 0.0f, 1.0f), vec4Blue())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f), tcu::RGBA::blue().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, 0.0f, 1.0f), tcu::RGBA::blue().toVec())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-0.5f, 0.5f, 0.01f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.5f, 0.5f, 0.01f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-0.5f, -0.5f, 0.01f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.5f, -0.5f, 0.01f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, 0.5f, 0.01f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, 0.5f, 0.01f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, -0.5f, 0.01f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, -0.5f, 0.01f, 1.0f), tcu::RGBA::green().toVec())); // enable depth test - m_depthStencilState = PipelineCreateInfo::DepthStencilState( - vk::VK_TRUE, vk::VK_TRUE, vk::VK_COMPARE_OP_GREATER_OR_EQUAL); + m_depthStencilState = PipelineCreateInfo::DepthStencilState(vk::VK_TRUE, vk::VK_TRUE, vk::VK_COMPARE_OP_GREATER_OR_EQUAL); DepthBiasBaseCase::initialize(); } @@ -536,8 +533,8 @@ public: tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT)); referenceFrame.allocLevel(0); - const deInt32 frameWidth = referenceFrame.getWidth(); - const deInt32 frameHeight = referenceFrame.getHeight(); + const deInt32 frameWidth = referenceFrame.getWidth(); + const deInt32 frameHeight = referenceFrame.getHeight(); tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); @@ -556,20 +553,18 @@ public: } } - const vk::VkOffset3D zeroOffset = { 0, 0, 0 }; + const vk::VkOffset3D zeroOffset = { 0, 0, 0 }; const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; @@ -577,20 +572,20 @@ public: class LineWidthParamTestInstance : public DynamicStateBaseClass { public: - LineWidthParamTestInstance (Context &context, ShaderMap shaders) + LineWidthParamTestInstance (Context& context, ShaderMap shaders) : DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { m_topology = vk::VK_PRIMITIVE_TOPOLOGY_LINE_LIST; - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 0.0f, 0.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 0.0f, 0.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), tcu::RGBA::green().toVec())); DynamicStateBaseClass::initialize(); } virtual tcu::TestStatus iterate (void) { - tcu::TestLog &log = m_context.getTestContext().getLog(); + tcu::TestLog &log = m_context.getTestContext().getLog(); const vk::VkQueue queue = m_context.getUniversalQueue(); beginRenderPass(); @@ -606,8 +601,8 @@ public: m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline); - const vk::VkDeviceSize vertexBufferOffset = 0; - const vk::VkBuffer vertexBuffer = m_vertexBuffer->object(); + const vk::VkDeviceSize vertexBufferOffset = 0; + const vk::VkBuffer vertexBuffer = m_vertexBuffer->object(); m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset); m_vk.cmdDraw(*m_cmdBuffer, static_cast(m_data.size()), 1, 0, 0); @@ -656,42 +651,43 @@ public: const vk::VkOffset3D zeroOffset = { 0, 0, 0 }; const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), - vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - - qpTestResult res = QP_TEST_RESULT_PASS; + vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, + vk::VK_IMAGE_ASPECT_COLOR_BIT); if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; } //anonymous -DynamicStateRSTests::DynamicStateRSTests (tcu::TestContext &testCtx) +DynamicStateRSTests::DynamicStateRSTests (tcu::TestContext& testCtx) : TestCaseGroup (testCtx, "rs_state", "Tests for rasterizer state") { /* Left blank on purpose */ } -DynamicStateRSTests::~DynamicStateRSTests () {} +DynamicStateRSTests::~DynamicStateRSTests () +{ +} void DynamicStateRSTests::init (void) { ShaderMap shaderPaths; - shaderPaths[glu::SHADERTYPE_VERTEX] = "vulkan/dynamic_state/VertexFetch.vert"; - shaderPaths[glu::SHADERTYPE_FRAGMENT] = "vulkan/dynamic_state/VertexFetch.frag"; + shaderPaths[glu::SHADERTYPE_VERTEX] = "vulkan/dynamic_state/VertexFetch.vert"; + shaderPaths[glu::SHADERTYPE_FRAGMENT] = "vulkan/dynamic_state/VertexFetch.frag"; addChild(new InstanceFactory(m_testCtx, "depth_bias", "Test depth bias functionality", shaderPaths)); addChild(new InstanceFactory(m_testCtx, "depth_bias_clamp", "Test depth bias clamp functionality", shaderPaths)); addChild(new InstanceFactory(m_testCtx, "line_width", "Draw a line with width set to max defined by physical device", shaderPaths)); } -} //DynamicState -} //vkt +} // DynamicState +} // vkt diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.hpp index ff8493a..a3c0f20 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateRSTests.hpp @@ -45,17 +45,16 @@ namespace DynamicState class DynamicStateRSTests : public tcu::TestCaseGroup { public: - DynamicStateRSTests (tcu::TestContext &testCtx); + DynamicStateRSTests (tcu::TestContext& testCtx); ~DynamicStateRSTests (void); void init(void); private: - DynamicStateRSTests (const DynamicStateRSTests &other); - DynamicStateRSTests &operator=(const DynamicStateRSTests &other); + DynamicStateRSTests (const DynamicStateRSTests& other); + DynamicStateRSTests& operator= (const DynamicStateRSTests& other); }; -} //DynamicState -} //vkt - +} // DynamicState +} // vkt #endif // _VKTDYNAMICSTATERSTESTS_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTestCaseUtil.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTestCaseUtil.hpp index f2e3c9d..65b9bef 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTestCaseUtil.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTestCaseUtil.hpp @@ -35,7 +35,6 @@ * \brief Dynamic State Tests Test Case Utilities *//*--------------------------------------------------------------------*/ - #include "tcuDefs.hpp" #include "tcuResource.hpp" @@ -51,6 +50,16 @@ namespace vkt namespace DynamicState { +struct PositionColorVertex +{ + PositionColorVertex(tcu::Vec4 position_, tcu::Vec4 color_) + : position(position_) + , color(color_) + {} + tcu::Vec4 position; + tcu::Vec4 color; +}; + class ShaderSourceProvider { public: @@ -97,8 +106,7 @@ private: const ShaderMap m_shaderPaths; }; - -} //DynamicState -} //vkt +} // DynamicState +} // vkt #endif \ No newline at end of file diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTests.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTests.cpp index 62b1ad4..be00ef9 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTests.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTests.cpp @@ -50,7 +50,7 @@ namespace DynamicState tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx) { - de::MovePtr group(new tcu::TestCaseGroup(testCtx, "dynamic-state", "Dynamic State Tests")); + de::MovePtr group(new tcu::TestCaseGroup(testCtx, "dynamic_state", "Dynamic State Tests")); group->addChild(new DynamicStateVPTests(testCtx)); group->addChild(new DynamicStateRSTests(testCtx)); diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTests.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTests.hpp index 2fbcdbf..87d79a5 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTests.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateTests.hpp @@ -45,7 +45,7 @@ namespace DynamicState tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx); -} //DynamicState -} //vkt +} // DynamicState +} // vkt #endif // _VKTDYNAMICSTATETESTS_HPP diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateVPTests.cpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateVPTests.cpp index 9340141..4bbe84b 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateVPTests.cpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateVPTests.cpp @@ -34,10 +34,15 @@ *//*--------------------------------------------------------------------*/ #include "vktDynamicStateVPTests.hpp" -#include "vktDynamicStateBaseClass.hpp" +#include "vktDynamicStateBaseClass.hpp" #include "vktDynamicStateTestCaseUtil.hpp" + +#include "vkImageUtil.hpp" + #include "tcuTextureUtil.hpp" +#include "tcuImageCompare.hpp" +#include "tcuRGBA.hpp" namespace vkt { @@ -49,37 +54,38 @@ namespace class ViewportStateBaseCase : public DynamicStateBaseClass { public: - ViewportStateBaseCase (Context &context, const char* vertexShaderName, const char* fragmentShaderName) - : DynamicStateBaseClass (context, vertexShaderName, fragmentShaderName) + ViewportStateBaseCase (Context& context, const char* vertexShaderName, const char* fragmentShaderName) + : DynamicStateBaseClass (context, vertexShaderName, fragmentShaderName) {} void initialize(void) { m_topology = vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; - m_data.push_back(Vec4RGBA(tcu::Vec4(-0.5f, 0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-0.5f, -0.5f, 1.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(0.5f, -0.5f, 1.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, 0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-0.5f, -0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(0.5f, -0.5f, 1.0f, 1.0f), tcu::RGBA::green().toVec())); DynamicStateBaseClass::initialize(); } virtual tcu::Texture2D buildReferenceFrame (void) { - TCU_FAIL("Implement buildReferenceFrame() method and return valid surface!"); + DE_ASSERT(false); + return tcu::Texture2D(tcu::TextureFormat(), 0, 0); } virtual void setDynamicStates (void) { - TCU_FAIL("Implement setDynamicStates() method!"); + DE_ASSERT(false); } virtual tcu::TestStatus iterate (void) { - tcu::TestLog &log = m_context.getTestContext().getLog(); - const vk::VkDevice device = m_context.getDevice(); - const vk::VkQueue queue = m_context.getUniversalQueue(); + tcu::TestLog &log = m_context.getTestContext().getLog(); + const vk::VkDevice device = m_context.getDevice(); + const vk::VkQueue queue = m_context.getUniversalQueue(); beginRenderPass(); @@ -120,16 +126,14 @@ public: const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; @@ -137,7 +141,7 @@ public: class ViewportParamTestInstane : public ViewportStateBaseCase { public: - ViewportParamTestInstane (Context &context, ShaderMap shaders) + ViewportParamTestInstane (Context& context, ShaderMap shaders) : ViewportStateBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { ViewportStateBaseCase::initialize(); @@ -145,8 +149,8 @@ public: virtual void setDynamicStates(void) { - const vk::VkViewport viewport = { 0.0f, 0.0f, (float)WIDTH * 2, (float)HEIGHT * 2, 0.0f, 0.0f }; - const vk::VkRect2D scissor = { { 0, 0 }, { WIDTH, HEIGHT } }; + const vk::VkViewport viewport = { 0.0f, 0.0f, (float)WIDTH * 2, (float)HEIGHT * 2, 0.0f, 0.0f }; + const vk::VkRect2D scissor = { { 0, 0 }, { WIDTH, HEIGHT } }; setDynamicViewportState(1, &viewport, &scissor); setDynamicRasterizationState(); @@ -159,8 +163,8 @@ public: tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT)); referenceFrame.allocLevel(0); - const deInt32 frameWidth = referenceFrame.getWidth(); - const deInt32 frameHeight = referenceFrame.getHeight(); + const deInt32 frameWidth = referenceFrame.getWidth(); + const deInt32 frameHeight = referenceFrame.getHeight(); tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); @@ -184,7 +188,7 @@ public: class ScissorParamTestInstance : public ViewportStateBaseCase { public: - ScissorParamTestInstance (Context &context, ShaderMap shaders) + ScissorParamTestInstance (Context& context, ShaderMap shaders) : ViewportStateBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) { ViewportStateBaseCase::initialize(); @@ -192,8 +196,8 @@ public: virtual void setDynamicStates (void) { - const vk::VkViewport viewport = { 0.0f, 0.0f, (float)WIDTH, (float)HEIGHT, 0.0f, 0.0f }; - const vk::VkRect2D scissor = { { 0, 0 }, { WIDTH / 2, HEIGHT / 2 } }; + const vk::VkViewport viewport = { 0.0f, 0.0f, (float)WIDTH, (float)HEIGHT, 0.0f, 0.0f }; + const vk::VkRect2D scissor = { { 0, 0 }, { WIDTH / 2, HEIGHT / 2 } }; setDynamicViewportState(1, &viewport, &scissor); setDynamicRasterizationState(); @@ -206,8 +210,8 @@ public: tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT)); referenceFrame.allocLevel(0); - const deInt32 frameWidth = referenceFrame.getWidth(); - const deInt32 frameHeight = referenceFrame.getHeight(); + const deInt32 frameWidth = referenceFrame.getWidth(); + const deInt32 frameHeight = referenceFrame.getHeight(); tcu::clear(referenceFrame.getLevel(0), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); @@ -228,7 +232,6 @@ public: } }; - class ViewportArrayTestInstance : public DynamicStateBaseClass { protected: @@ -236,16 +239,16 @@ protected: public: - ViewportArrayTestInstance (Context &context, ShaderMap shaders) + ViewportArrayTestInstance (Context& context, ShaderMap shaders) : DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT]) , m_geometryShaderName (shaders[glu::SHADERTYPE_GEOMETRY]) { for (int i = 0; i < 4; i++) { - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, 1.0f, (float)i / 3.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, 1.0f, (float)i / 3.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(-1.0f, -1.0f, (float)i / 3.0f, 1.0f), vec4Green())); - m_data.push_back(Vec4RGBA(tcu::Vec4(1.0f, -1.0f, (float)i / 3.0f, 1.0f), vec4Green())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, (float)i / 3.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, 1.0f, (float)i / 3.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, (float)i / 3.0f, 1.0f), tcu::RGBA::green().toVec())); + m_data.push_back(PositionColorVertex(tcu::Vec4(1.0f, -1.0f, (float)i / 3.0f, 1.0f), tcu::RGBA::green().toVec())); } DynamicStateBaseClass::initialize(); @@ -283,9 +286,9 @@ public: beginRenderPass(); // set states here - const float halfWidth = (float)WIDTH / 2; - const float halfHeight = (float)HEIGHT / 2; - const deInt32 quarterWidth = WIDTH / 4; + const float halfWidth = (float)WIDTH / 2; + const float halfHeight = (float)HEIGHT / 2; + const deInt32 quarterWidth = WIDTH / 4; const deInt32 quarterHeight = HEIGHT / 4; const vk::VkViewport viewports[4] = @@ -362,29 +365,29 @@ public: const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT); - qpTestResult res = QP_TEST_RESULT_PASS; - if (!tcu::fuzzyCompare(log, "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, 0.05f, tcu::COMPARE_LOG_RESULT)) { - res = QP_TEST_RESULT_FAIL; + return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Image verification failed"); } - return tcu::TestStatus(res, qpGetTestResultName(res)); + return tcu::TestStatus(QP_TEST_RESULT_PASS, "Image verification passed"); } } }; } //anonymous -DynamicStateVPTests::DynamicStateVPTests (tcu::TestContext &testCtx) +DynamicStateVPTests::DynamicStateVPTests (tcu::TestContext& testCtx) : TestCaseGroup (testCtx, "vp_state", "Tests for viewport state") { /* Left blank on purpose */ } -DynamicStateVPTests::~DynamicStateVPTests () {} +DynamicStateVPTests::~DynamicStateVPTests () +{ +} void DynamicStateVPTests::init (void) { @@ -399,5 +402,5 @@ void DynamicStateVPTests::init (void) addChild(new InstanceFactory(m_testCtx, "viewport_array", "Multiple viewports and scissors", shaderPaths)); } -} //DynamicState -} //vkt +} // DynamicState +} // vkt diff --git a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateVPTests.hpp b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateVPTests.hpp index 2d707d1..23dff10 100644 --- a/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateVPTests.hpp +++ b/external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateVPTests.hpp @@ -45,17 +45,16 @@ namespace DynamicState class DynamicStateVPTests : public tcu::TestCaseGroup { public: - DynamicStateVPTests (tcu::TestContext &testCtx); - ~DynamicStateVPTests (void); - void init (void); + DynamicStateVPTests (tcu::TestContext& testCtx); + ~DynamicStateVPTests (void); + void init (void); private: - DynamicStateVPTests (const DynamicStateVPTests &other); - DynamicStateVPTests &operator=(const DynamicStateVPTests &other); + DynamicStateVPTests (const DynamicStateVPTests& other); + DynamicStateVPTests& operator= (const DynamicStateVPTests& other); }; -} //DynamicState -} //vkt - +} // DynamicState +} // vkt #endif // _VKTDYNAMICSTATEVPTESTS_HPP diff --git a/external/vulkancts/modules/vulkan/vktTestPackage.cpp b/external/vulkancts/modules/vulkan/vktTestPackage.cpp index 463dfb6..134bbdd 100644 --- a/external/vulkancts/modules/vulkan/vktTestPackage.cpp +++ b/external/vulkancts/modules/vulkan/vktTestPackage.cpp @@ -57,7 +57,6 @@ #include "vktShaderRenderDiscardTests.hpp" #include "vktDynamicStateTests.hpp" - #include #include -- 2.7.4