set(DEQP_VK_DYNAMIC_STATE_SRCS
vktDynamicStateTestCaseUtil.hpp
vktDynamicStateBaseClass.hpp
+ vktDynamicStateBaseClass.cpp
vktDynamicStateCBTests.cpp
vktDynamicStateCBTests.hpp
vktDynamicStateDSTests.cpp
--- /dev/null
+/*------------------------------------------------------------------------
+ * 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<vk::VkImageView> 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<unsigned char *>(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<vk::VkShaderModule> vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0));
+ const vk::Unique<vk::VkShaderModule> 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<float>(width);
+ viewport.height = static_cast<float>(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
#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,
const std::string m_vertexShaderName;
const std::string m_fragmentShaderName;
-
- std::vector<Vec4RGBA> 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<vk::VkImageView> 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<unsigned char *>(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<vk::VkShaderModule> vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0));
- const vk::Unique<vk::VkShaderModule> 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<float>(width);
- viewport.height = static_cast<float>(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<PositionColorVertex> m_data;
};
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
#endif // _VKTDYNAMICSTATEBASECLASS_HPP
#include "vktDynamicStateBufferObjectUtil.hpp"
-
#include "vkQueryUtil.hpp"
-
namespace vkt
{
namespace DynamicState
{
-Buffer::Buffer (const vk::DeviceInterface &vk, vk::VkDevice device, vk::Move<vk::VkBuffer> object)
+Buffer::Buffer (const vk::DeviceInterface& vk, vk::VkDevice device, vk::Move<vk::VkBuffer> object)
: m_object (object)
, m_allocation (DE_NULL)
, m_vk (vk)
m_allocation = allocation;
}
-de::SharedPtr<Buffer> Buffer::createAndAlloc (const vk::DeviceInterface &vk,
- vk::VkDevice device,
- const vk::VkBufferCreateInfo &createInfo,
- vk::Allocator &allocator,
- vk::MemoryRequirement memoryRequirement)
+de::SharedPtr<Buffer> Buffer::createAndAlloc (const vk::DeviceInterface& vk,
+ vk::VkDevice device,
+ const vk::VkBufferCreateInfo &createInfo,
+ vk::Allocator &allocator,
+ vk::MemoryRequirement memoryRequirement)
{
de::SharedPtr<Buffer> ret = create(vk, device, createInfo);
return ret;
}
-de::SharedPtr<Buffer> Buffer::create (const vk::DeviceInterface &vk,
+de::SharedPtr<Buffer> Buffer::create (const vk::DeviceInterface& vk,
vk::VkDevice device,
- const vk::VkBufferCreateInfo &createInfo)
+ const vk::VkBufferCreateInfo& createInfo)
{
return de::SharedPtr<Buffer>(new Buffer(vk, device, vk::createBuffer(vk, device, &createInfo)));
}
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
-#ifndef _VKT_DYNAMIC_STATE_BUFFEROBJECTUTIL_HPP
-#define _VKT_DYNAMIC_STATE_BUFFEROBJECTUTIL_HPP
+#ifndef _VKTDYNAMICSTATEBUFFEROBJECTUTIL_HPP
+#define _VKTDYNAMICSTATEBUFFEROBJECTUTIL_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
Buffer (const vk::DeviceInterface &vk, vk::VkDevice device, vk::Move<vk::VkBuffer> object);
-
void bindMemory (de::MovePtr<vk::Allocation> 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<vk::Allocation> m_allocation;
vk::Unique<vk::VkBuffer> 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
*//*--------------------------------------------------------------------*/
#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
{
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();
}
const vk::Unique<vk::VkShaderModule> 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));
vk::VkSubmitInfo submitInfo =
{
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;\r
- DE_NULL, // const void* pNext;\r
- 0, // deUint32 waitSemaphoreCount;\r
- DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
- 1, // deUint32 commandBufferCount;\r
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;\r
- 0, // deUint32 signalSemaphoreCount;\r
- DE_NULL // const VkSemaphore* pSignalSemaphores;\r
+ 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));
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 */
addChild(new InstanceFactory<BlendConstantsTestInstance>(m_testCtx, "blend_constants", "Check if blend constants are working properly", shaderPaths));
}
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
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
range = _range;
}
-
BufferCreateInfo::BufferCreateInfo (vk::VkDeviceSize _size,
vk::VkBufferUsageFlags _usage,
vk::VkSharingMode _sharingMode,
vk::VkImageUsageFlags _usage,
vk::VkSharingMode _sharingMode,
deUint32 _queueFamilyIndexCount,
- const deUint32* _pQueueFamilyIndices,
+ const deUint32* _pQueueFamilyIndices,
vk::VkImageCreateFlags _flags,
vk::VkImageLayout _initialLayout)
{
}
FramebufferCreateInfo::FramebufferCreateInfo (vk::VkRenderPass _renderPass,
- const std::vector<vk::VkImageView>& atachments,
+ const std::vector<vk::VkImageView>& atachments,
deUint32 _width,
deUint32 _height,
deUint32 _layers)
RenderPassBeginInfo::RenderPassBeginInfo (vk::VkRenderPass _renderPass,
vk::VkFramebuffer _framebuffer,
vk::VkRect2D _renderArea,
- const std::vector<vk::VkClearValue>& _clearValues)
+ const std::vector<vk::VkClearValue>& _clearValues)
{
m_clearValues = _clearValues;
finalLayout = _finalLayout;
}
-AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription &rhs)
+AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription& rhs)
{
flags = rhs.flags;
format = rhs.format;
dependencyFlags = _dependencyFlags;
}
-SubpassDependency::SubpassDependency (const vk::VkSubpassDependency &rhs)
+SubpassDependency::SubpassDependency (const vk::VkSubpassDependency& rhs)
{
srcSubpass = rhs.srcSubpass;
dstSubpass = rhs.dstSubpass;
pBinding = _pBindings;
}
-
PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32 _descriptorSetCount,
const vk::VkDescriptorSetLayout* _pSetLayouts,
deUint32 _pushConstantRangeCount,
}
}
-
PipelineCreateInfo::PipelineShaderStage::PipelineShaderStage (vk::VkShaderModule _module, const char* _pName, vk::VkShaderStageFlagBits _stage)
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
pScissors = &m_scissors[0];
}
-PipelineCreateInfo::ViewportState::ViewportState (const ViewportState &other)
+PipelineCreateInfo::ViewportState::ViewportState (const ViewportState& other)
{
sType = other.sType;
pNext = other.pNext;
pScissors = &m_scissors[0];
}
-PipelineCreateInfo::ViewportState & PipelineCreateInfo::ViewportState::operator= (const ViewportState &other)
+PipelineCreateInfo::ViewportState& PipelineCreateInfo::ViewportState::operator= (const ViewportState& other)
{
sType = other.sType;
pNext = other.pNext;
alphaToOneEnable = _alphaToOneEnable;
}
-PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState &other)
+PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState& other)
{
sType = other.sType;
pNext = other.pNext;
pSampleMask = &m_sampleMask[0];
}
-PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState & other)
+PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState& other)
{
sType = other.sType;
pNext = other.pNext;
}
PipelineCreateInfo::ColorBlendState::ColorBlendState (deUint32 _attachmentCount,
- const vk::VkPipelineColorBlendAttachmentState* _attachments,
+ const vk::VkPipelineColorBlendAttachmentState* _attachments,
vk::VkBool32 _logicOpEnable,
vk::VkLogicOp _logicOp)
: m_attachments(_attachments, _attachments + _attachmentCount)
pAttachments = &m_attachments[0];
}
-PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo &createInfo)
+PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo)
: m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
{
sType = createInfo.sType;
pAttachments = &m_attachments[0];
}
-PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState &createInfo, std::vector<float> _blendConstants)
+PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState& createInfo, std::vector<float> _blendConstants)
: m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
{
sType = createInfo.sType;
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;
pDynamicState = DE_NULL;
}
-PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo &shader)
+PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo& shader)
{
m_shaders.push_back(shader);
}
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;
-#ifndef _VKT_DYNAMIC_STATE_CREATEINFO_UTIL_HPP
-#define _VKT_DYNAMIC_STATE_CREATEINFO_UTIL_HPP
+#ifndef _VKTDYNAMICSTATECREATEINFOUTIL_HPP
+#define _VKTDYNAMICSTATECREATEINFOUTIL_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
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<deUint32> 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<deUint32> m_queueFamilyIndices;
};
class FramebufferCreateInfo : public vk::VkFramebufferCreateInfo
{
public:
- FramebufferCreateInfo ( vk::VkRenderPass renderPass,
- const std::vector<vk::VkImageView>& attachments,
- deUint32 width,
- deUint32 height,
- deUint32 layers);
+ FramebufferCreateInfo (vk::VkRenderPass renderPass,
+ const std::vector<vk::VkImageView>& 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<vk::VkAttachmentReference> m_inputAttachments;
class RenderPassCreateInfo : public vk::VkRenderPassCreateInfo
{
public:
- RenderPassCreateInfo ( const std::vector<vk::VkAttachmentDescription>& attachments,
- const std::vector<vk::VkSubpassDescription>& subpasses,
- const std::vector<vk::VkSubpassDependency>& dependiences = std::vector<vk::VkSubpassDependency>());
+ RenderPassCreateInfo (const std::vector<vk::VkAttachmentDescription>& attachments,
+ const std::vector<vk::VkSubpassDescription>& subpasses,
+ const std::vector<vk::VkSubpassDependency>& dependiences = std::vector<vk::VkSubpassDependency>());
- 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<AttachmentDescription> m_attachments;
std::vector<vk::VkSubpassDependency> 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<vk::VkClearValue>& clearValues = std::vector<vk::VkClearValue>());
+ RenderPassBeginInfo (vk::VkRenderPass renderPass,
+ vk::VkFramebuffer framebuffer,
+ vk::VkRect2D renderArea,
+ const std::vector<vk::VkClearValue>& clearValues = std::vector<vk::VkClearValue>());
private:
std::vector<vk::VkClearValue> 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,
vk::VkQueryPipelineStatisticFlags pipelineStatistics = 0u);
};
-
class DescriptorPoolSize : public vk::VkDescriptorPoolSize
{
public:
class DescriptorPoolCreateInfo : public vk::VkDescriptorPoolCreateInfo
{
public:
- DescriptorPoolCreateInfo ( const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts,\r
- vk::VkDescriptorPoolCreateFlags flags, \r
- deUint32 maxSets);
+ DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts,
+ vk::VkDescriptorPoolCreateFlags flags,
+ deUint32 maxSets);
DescriptorPoolCreateInfo& addDescriptors (vk::VkDescriptorType type, deUint32 count);
std::vector<vk::VkDescriptorPoolSize> 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<vk::VkDescriptorSetLayout>& setLayouts = std::vector<vk::VkDescriptorSetLayout>(),
- deUint32 pushConstantRangeCount = 0,
- const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL);
+ PipelineLayoutCreateInfo (const std::vector<vk::VkDescriptorSetLayout>& setLayouts = std::vector<vk::VkDescriptorSetLayout>(),
+ deUint32 pushConstantRangeCount = 0,
+ const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL);
private:
std::vector<vk::VkDescriptorSetLayout> m_setLayouts;
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
class ViewportState : public vk::VkPipelineViewportStateCreateInfo
{
public:
- ViewportState ( deUint32 viewportCount,
- std::vector<vk::VkViewport> viewports = std::vector<vk::VkViewport>(0),
- std::vector<vk::VkRect2D> scissors = std::vector<vk::VkRect2D>(0));
+ ViewportState (deUint32 viewportCount,
+ std::vector<vk::VkViewport> viewports = std::vector<vk::VkViewport>(0),
+ std::vector<vk::VkRect2D> scissors = std::vector<vk::VkRect2D>(0));
- ViewportState (const ViewportState &other);
- ViewportState &operator= (const ViewportState &other);
+ ViewportState (const ViewportState& other);
+ ViewportState& operator= (const ViewportState& other);
std::vector<vk::VkViewport> m_viewports;
std::vector<vk::VkRect2D> m_scissors;
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,\r
- 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<vk::VkSampleMask>& sampleMask = std::vector<vk::VkSampleMask>(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<vk::VkSampleMask>& sampleMask = std::vector<vk::VkSampleMask>(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<vk::VkSampleMask> m_sampleMask;
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<vk::VkPipelineColorBlendAttachmentState>& attachments,
- vk::VkBool32 alphaToCoverageEnable = false,
- vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY);
+ ColorBlendState (const std::vector<vk::VkPipelineColorBlendAttachmentState>& 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<float> blendConstants = std::vector<float>(4));
+ ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo);
+ ColorBlendState (const ColorBlendState& createInfo,
+ std::vector<float> blendConstants = std::vector<float>(4));
private:
std::vector<vk::VkPipelineColorBlendAttachmentState> m_attachments;
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,\r
- deUint32 writeMask = 0xffffffffu,\r
- 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<vk::VkDynamicState>& dynamicStates = std::vector<vk::VkDynamicState>(0));
+ DynamicState (const std::vector<vk::VkDynamicState>& dynamicStates = std::vector<vk::VkDynamicState>(0));
- DynamicState (const DynamicState &other);
- DynamicState &operator= (const DynamicState &other);
+ DynamicState (const DynamicState& other);
+ DynamicState& operator= (const DynamicState& other);
std::vector<vk::VkDynamicState> 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<vk::VkPipelineShaderStageCreateInfo> m_shaders;
vk::VkPipelineMultisampleStateCreateInfo m_multisampleState;
vk::VkPipelineDynamicStateCreateInfo m_dynamicState;
- std::vector<vk::VkDynamicState> m_dynamicStates;
+ std::vector<vk::VkDynamicState> m_dynamicStates;
- std::vector<vk::VkViewport> m_viewports;
- std::vector<vk::VkRect2D> m_scissors;
+ std::vector<vk::VkViewport> m_viewports;
+ std::vector<vk::VkRect2D> m_scissors;
- std::vector<vk::VkSampleMask> m_multisampleStateSampleMask;
+ std::vector<vk::VkSampleMask> 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
#include "tcuImageCompare.hpp"
#include "tcuCommandLine.hpp"
#include "tcuTextureUtil.hpp"
+#include "tcuRGBA.hpp"
#include "vkRefUtil.hpp"
#include "vkImageUtil.hpp"
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)
const std::string m_vertexShaderName;
const std::string m_fragmentShaderName;
- std::vector<Vec4RGBA> m_data;
+ std::vector<PositionColorVertex> m_data;
PipelineCreateInfo::DepthStencilState m_depthStencilState_1;
PipelineCreateInfo::DepthStencilState m_depthStencilState_2;
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());
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 =
{
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<unsigned char *>(m_vertexBuffer->getBoundMemory().getHostPtr());
+ deUint8* ptr = reinterpret_cast<unsigned char *>(m_vertexBuffer->getBoundMemory().getHostPtr());
deMemcpy(ptr, &m_data[0], dataSize);
vk::flushMappedMemoryRange(m_vk, device,
virtual tcu::TestStatus iterate (void)
{
- TCU_FAIL("Implement iterate() method!");
+ DE_ASSERT(false);
+ return tcu::TestStatus::fail("Implement iterate() method!");
}
void beginRenderPass (void)
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);
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");
}
}
};
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)
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(
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");
}
}
};
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)
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(
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)
{
addChild(new InstanceFactory<StencilParamsAdvancedTestInstance>(m_testCtx, "stencil_params_advanced", "Perform advanced stencil test", shaderPaths));
}
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
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
#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"
{
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();
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
vk::VkSubmitInfo submitInfo =
{
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;\r
- DE_NULL, // const void* pNext;\r
- 0, // deUint32 waitSemaphoreCount;\r
- DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
- 1, // deUint32 commandBufferCount;\r
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;\r
- 0, // deUint32 signalSemaphoreCount;\r
- DE_NULL // const VkSemaphore* pSignalSemaphores;\r
+ 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);
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));
}
}
- 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();
vk::VkSubmitInfo submitInfo =
{
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;\r
- DE_NULL, // const void* pNext;\r
- 0, // deUint32 waitSemaphoreCount;\r
- DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
- 1, // deUint32 commandBufferCount;\r
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;\r
- 0, // deUint32 signalSemaphoreCount;\r
- DE_NULL // const VkSemaphore* pSignalSemaphores;\r
+ 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);
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");
}
};
vk::Move<vk::VkPipeline> 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();
}
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();
vk::VkSubmitInfo submitInfo =
{
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;\r
- DE_NULL, // const void* pNext;\r
- 0, // deUint32 waitSemaphoreCount;\r
- DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
- 1, // deUint32 commandBufferCount;\r
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;\r
- 0, // deUint32 signalSemaphoreCount;\r
- DE_NULL // const VkSemaphore* pSignalSemaphores;\r
+ 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);
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));
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 */
addChild(new InstanceFactory<StatePersistenceTestInstance>(m_testCtx, "state_persistence", "Check if bound states are persistent across pipelines", shaderPaths));
}
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
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
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;
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;
}
}
-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<vk::VkImage> object)
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<Image> stagingResource = copyToLinearImage(queue, allocator, layout, offset, width,
height, depth, mipLevel, arrayElement, aspect, type);
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<Buffer> stagingResource;
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<vk::VkCommandPool> copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo));
de::SharedPtr<Image> 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<vk::VkCommandPool> copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo));
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<Image> stagingResource;
vk::VkExtent3D extent = {width, height, depth};
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<vk::VkCommandPool> copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo));
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<Buffer> stagingResource;
bool isCombinedType = isCombinedDepthStencilType(vk::mapVkFormat(m_format).type);
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<vk::VkCommandPool> copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo));
}
}
-
void Image::uploadLinear (vk::VkOffset3D offset,
int width,
int height,
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];
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);
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
-#ifndef _VKT_DYNAMIC_STATE_IMAGEOBJECTUTIL_HPP
-#define _VKT_DYNAMIC_STATE_IMAGEOBJECTUTIL_HPP
+#ifndef _VKTDYNAMICSTATEIMAGEOBJECTUTIL_HPP
+#define _VKTDYNAMICSTATEIMAGEOBJECTUTIL_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
int width,
int height,
int depth,
- vk::VkDeviceSize rowPitch,
- vk::VkDeviceSize depthPitch,
+ vk::VkDeviceSize rowPitchOrZero,
+ vk::VkDeviceSize depthPitchOrZero,
const void * srcBuffer,
void * destBuffer);
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<Image> create (const vk::DeviceInterface &vk, vk::VkDevice device, const vk::VkImageCreateInfo &createInfo);
+ static de::SharedPtr<Image> create (const vk::DeviceInterface& vk, vk::VkDevice device, const vk::VkImageCreateInfo& createInfo);
static de::SharedPtr<Image> createAndAlloc (const vk::DeviceInterface& vk,
vk::VkDevice device,
unsigned int mipLevel = 0,
unsigned int arrayElement = 0);
-
tcu::ConstPixelBufferAccess readSurfaceLinear (vk::VkOffset3D offset,
int width,
int height,
deUint32 layerCount,
vk::Move<vk::VkImage> 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<vk::Allocation> m_allocation;
vk::Unique<vk::VkImage> m_object;
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
*//*--------------------------------------------------------------------*/
#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"
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)
std::string m_vertexShaderName;
std::string m_fragmentShaderName;
- std::vector<Vec4RGBA> m_data;
+ std::vector<PositionColorVertex> 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<vk::VkShaderModule> vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0));
const vk::Unique<vk::VkShaderModule> 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());
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 =
{
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);
}
};
- m_vertexInputState = PipelineCreateInfo::VertexInputState(
- 1,
- &vertexInputBindingDescription,
- 2,
- vertexInputAttributeDescriptions);
+ m_vertexInputState = PipelineCreateInfo::VertexInputState(1,
+ &vertexInputBindingDescription,
+ 2,
+ vertexInputAttributeDescriptions);
const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState;
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<unsigned char *>(m_vertexBuffer->getBoundMemory().getHostPtr());
+ deUint8* ptr = reinterpret_cast<unsigned char *>(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);
virtual tcu::TestStatus iterate (void)
{
- TCU_FAIL("Implement iterate() method!");
+ DE_ASSERT(false);
+ return tcu::TestStatus::fail("Should reimplement iterate() method");
}
void beginRenderPass (void)
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);
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(
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();
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);
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");
}
}
};
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();
}
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));
}
}
- 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");
}
}
};
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();
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<deUint32>(m_data.size()), 1, 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;
+ 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<DepthBiasParamTestInstance>(m_testCtx, "depth_bias", "Test depth bias functionality", shaderPaths));
addChild(new InstanceFactory<DepthBiasClampParamTestInstance>(m_testCtx, "depth_bias_clamp", "Test depth bias clamp functionality", shaderPaths));
addChild(new InstanceFactory<LineWidthParamTestInstance>(m_testCtx, "line_width", "Draw a line with width set to max defined by physical device", shaderPaths));
}
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
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
* \brief Dynamic State Tests Test Case Utilities
*//*--------------------------------------------------------------------*/
-
#include "tcuDefs.hpp"
#include "tcuResource.hpp"
namespace DynamicState
{
+struct PositionColorVertex
+{
+ PositionColorVertex(tcu::Vec4 position_, tcu::Vec4 color_)
+ : position(position_)
+ , color(color_)
+ {}
+ tcu::Vec4 position;
+ tcu::Vec4 color;
+};
+
class ShaderSourceProvider
{
public:
const ShaderMap m_shaderPaths;
};
-
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
#endif
\ No newline at end of file
tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx)
{
- de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "dynamic-state", "Dynamic State Tests"));
+ de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "dynamic_state", "Dynamic State Tests"));
group->addChild(new DynamicStateVPTests(testCtx));
group->addChild(new DynamicStateRSTests(testCtx));
tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx);
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
#endif // _VKTDYNAMICSTATETESTS_HPP
*//*--------------------------------------------------------------------*/
#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
{
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();
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");
}
}
};
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();
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();
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));
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();
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();
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));
}
};
-
class ViewportArrayTestInstance : public DynamicStateBaseClass
{
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();
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] =
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)
{
addChild(new InstanceFactory<ViewportArrayTestInstance>(m_testCtx, "viewport_array", "Multiple viewports and scissors", shaderPaths));
}
-} //DynamicState
-} //vkt
+} // DynamicState
+} // vkt
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
#include "vktShaderRenderDiscardTests.hpp"
#include "vktDynamicStateTests.hpp"
-
#include <vector>
#include <sstream>
projects / platform / upstream / VK-GL-CTS.git / commitdiff