blob: 7e250196db689b56cf0f783d33bf1a17801edc35 [file] [log] [blame]
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
*
* Copyright (c) 2021 The Khronos Group Inc.
* Copyright (c) 2021 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Tests load and store op "none"
*//*--------------------------------------------------------------------*/
#include "vktRenderPassLoadStoreOpNoneTests.hpp"
#include "pipeline/vktPipelineImageUtil.hpp"
#include "vktTestCase.hpp"
#include "vkImageUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkPrograms.hpp"
#include "vkQueryUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkObjUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuPlatform.hpp"
#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include "deRandom.hpp"
#include <cstring>
#include <cmath>
#include <vector>
namespace vkt
{
namespace renderpass
{
using namespace vk;
namespace
{
enum AttachmentInit
{
ATTACHMENT_INIT_PRE = 1,
ATTACHMENT_INIT_CMD_CLEAR = 2
};
enum AttachmentUsage
{
ATTACHMENT_USAGE_UNDEFINED = 0,
ATTACHMENT_USAGE_COLOR = 1,
ATTACHMENT_USAGE_DEPTH = 2,
ATTACHMENT_USAGE_STENCIL = 4,
ATTACHMENT_USAGE_INPUT = 8,
ATTACHMENT_USAGE_WRITE_OFF = 16,
ATTACHMENT_USAGE_DEPTH_STENCIL = ATTACHMENT_USAGE_DEPTH | ATTACHMENT_USAGE_STENCIL,
ATTACHMENT_USAGE_MULTISAMPLE = 32,
ATTACHMENT_USAGE_RESOLVE_TARGET = 64,
ATTACHMENT_USAGE_INTEGER = 128
};
struct AttachmentParams
{
deUint32 usage;
VkAttachmentLoadOp loadOp;
VkAttachmentStoreOp storeOp;
deUint32 init;
bool verifyInner;
tcu::Vec4 innerRef;
bool verifyOuter;
tcu::Vec4 outerRef;
};
struct AttachmentRef
{
deUint32 idx;
deUint32 usage;
};
struct SubpassParams
{
std::vector<AttachmentRef> attachmentRefs;
deUint32 numDraws;
};
struct TestParams
{
std::vector<AttachmentParams> attachments;
std::vector<SubpassParams> subpasses;
RenderingType renderingType;
VkFormat depthStencilFormat;
bool alphaBlend;
};
struct Vertex4RGBA
{
tcu::Vec4 position;
tcu::Vec4 color;
};
template<typename T>
inline de::SharedPtr<vk::Move<T> > makeSharedPtr(vk::Move<T> move)
{
return de::SharedPtr<vk::Move<T> >(new vk::Move<T>(move));
}
std::vector<Vertex4RGBA> createQuad (void)
{
std::vector<Vertex4RGBA> vertices;
const float size = 1.0f;
const tcu::Vec4 red (1.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 blue (0.0f, 0.0f, 1.0f, 1.0f);
const Vertex4RGBA lowerLeftVertexRed = {tcu::Vec4(-size, -size, 0.0f, 1.0f), red};
const Vertex4RGBA lowerRightVertexRed = {tcu::Vec4(size, -size, 0.0f, 1.0f), red};
const Vertex4RGBA upperLeftVertexRed = {tcu::Vec4(-size, size, 0.0f, 1.0f), red};
const Vertex4RGBA upperRightVertexRed = {tcu::Vec4(size, size, 0.0f, 1.0f), red};
const Vertex4RGBA lowerLeftVertexBlue = {tcu::Vec4(-size, -size, 0.0f, 1.0f), blue};
const Vertex4RGBA lowerRightVertexBlue = {tcu::Vec4(size, -size, 0.0f, 1.0f), blue};
const Vertex4RGBA upperLeftVertexBlue = {tcu::Vec4(-size, size, 0.0f, 1.0f), blue};
const Vertex4RGBA upperRightVertexBlue = {tcu::Vec4(size, size, 0.0f, 1.0f), blue};
vertices.push_back(lowerLeftVertexRed);
vertices.push_back(lowerRightVertexRed);
vertices.push_back(upperLeftVertexRed);
vertices.push_back(upperLeftVertexRed);
vertices.push_back(lowerRightVertexRed);
vertices.push_back(upperRightVertexRed);
vertices.push_back(lowerLeftVertexBlue);
vertices.push_back(lowerRightVertexBlue);
vertices.push_back(upperLeftVertexBlue);
vertices.push_back(upperLeftVertexBlue);
vertices.push_back(lowerRightVertexBlue);
vertices.push_back(upperRightVertexBlue);
return vertices;
}
deUint32 getFirstUsage (deUint32 attachmentIdx, const std::vector<SubpassParams>& subpasses)
{
for (const auto& subpass : subpasses)
for (const auto& ref : subpass.attachmentRefs)
if (ref.idx == attachmentIdx)
return ref.usage;
return ATTACHMENT_USAGE_UNDEFINED;
}
std::string getFormatCaseName(VkFormat format)
{
return de::toLower(de::toString(getFormatStr(format)).substr(10));
}
// Selects an image format based on the usage flags.
VkFormat getFormat (deUint32 usage, VkFormat depthStencilFormat)
{
if (usage & ATTACHMENT_USAGE_DEPTH_STENCIL)
{
return depthStencilFormat;
}
if (usage & ATTACHMENT_USAGE_INTEGER)
{
// Color attachment using integer format.
return VK_FORMAT_R8G8B8A8_UINT;
}
return VK_FORMAT_R8G8B8A8_UNORM;
}
template<typename AttachmentDesc, typename AttachmentRef, typename SubpassDesc, typename SubpassDep, typename RenderPassCreateInfo>
Move<VkRenderPass> createRenderPass (const DeviceInterface& vk,
VkDevice vkDevice,
const TestParams testParams)
{
const VkImageAspectFlags aspectMask = testParams.renderingType == RENDERING_TYPE_RENDERPASS_LEGACY ? 0 : VK_IMAGE_ASPECT_COLOR_BIT;
std::vector<AttachmentDesc> attachmentDescriptions;
std::vector<SubpassDesc> subpassDescriptions;
struct Refs
{
std::vector<AttachmentRef> colorAttachmentRefs;
std::vector<AttachmentRef> resolveAttachmentRefs;
std::vector<AttachmentRef> depthStencilAttachmentRefs;
std::vector<AttachmentRef> inputAttachmentRefs;
};
std::vector<Refs> subpassRefs;
bool hasInputAttachment = false;
for (size_t i = 0; i < testParams.attachments.size(); i++)
{
VkImageLayout initialLayout;
VkImageLayout finalLayout;
VkFormat format = getFormat(testParams.attachments[i].usage, testParams.depthStencilFormat);
// Search for the first reference to determine the initial layout.
deUint32 firstUsage = getFirstUsage((deUint32)i, testParams.subpasses);
// No subpasses using this attachment. Use the usage flags of the attachment.
if (firstUsage == ATTACHMENT_USAGE_UNDEFINED)
firstUsage = testParams.attachments[i].usage;
if (firstUsage & ATTACHMENT_USAGE_COLOR)
initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
else if (firstUsage & ATTACHMENT_USAGE_DEPTH_STENCIL)
initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
else
{
DE_ASSERT(firstUsage & ATTACHMENT_USAGE_INPUT);
initialLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
}
// Set final layout to transfer src if it's being verified. Otherwise
// just use the initial layout as it's known to be supported by
// the usage flags.
if (testParams.attachments[i].verifyInner || testParams.attachments[i].verifyOuter)
finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
else
finalLayout = initialLayout;
const VkSampleCountFlagBits sampleCount = testParams.attachments[i].usage & ATTACHMENT_USAGE_MULTISAMPLE ? VK_SAMPLE_COUNT_4_BIT : VK_SAMPLE_COUNT_1_BIT;
const AttachmentDesc attachmentDesc =
{
DE_NULL, // const void* pNext
(VkAttachmentDescriptionFlags) 0, // VkAttachmentDescriptionFlags flags
format, // VkFormat format
sampleCount, // VkSampleCountFlagBits samples
testParams.attachments[i].loadOp, // VkAttachmentLoadOp loadOp
testParams.attachments[i].storeOp, // VkAttachmentStoreOp storeOp
testParams.attachments[i].loadOp, // VkAttachmentLoadOp stencilLoadOp
testParams.attachments[i].storeOp, // VkAttachmentStoreOp stencilStoreOp
initialLayout, // VkImageLayout initialLayout
finalLayout // VkImageLayout finalLayout
};
attachmentDescriptions.push_back(attachmentDesc);
}
for (const auto& subpass : testParams.subpasses)
{
subpassRefs.push_back({});
auto& refs = subpassRefs.back();
for (const auto& ref : subpass.attachmentRefs)
{
VkImageLayout layout;
if (ref.usage & ATTACHMENT_USAGE_RESOLVE_TARGET)
{
layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
refs.resolveAttachmentRefs.push_back({DE_NULL, ref.idx, layout, aspectMask});
}
else if (ref.usage & ATTACHMENT_USAGE_COLOR)
{
layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
refs.colorAttachmentRefs.push_back({DE_NULL, ref.idx, layout, aspectMask});
}
else if (ref.usage & ATTACHMENT_USAGE_DEPTH_STENCIL)
{
layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
const auto depthStencilAspectMask = testParams.renderingType == RENDERING_TYPE_RENDERPASS_LEGACY ? 0 : getImageAspectFlags(mapVkFormat(testParams.depthStencilFormat));
refs.depthStencilAttachmentRefs.push_back({DE_NULL, ref.idx, layout, depthStencilAspectMask});
}
else
{
DE_ASSERT(ref.usage & ATTACHMENT_USAGE_INPUT);
layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
refs.inputAttachmentRefs.push_back({DE_NULL, ref.idx, layout, aspectMask});
hasInputAttachment = true;
}
}
const SubpassDesc subpassDescription =
{
DE_NULL,
(VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags
VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
0u, // deUint32 viewMask
(deUint32)refs.inputAttachmentRefs.size(), // deUint32 inputAttachmentCount
refs.inputAttachmentRefs.empty() ? DE_NULL : refs.inputAttachmentRefs.data(), // const VkAttachmentReference* pInputAttachments
(deUint32)refs.colorAttachmentRefs.size(), // deUint32 colorAttachmentCount
refs.colorAttachmentRefs.empty() ? DE_NULL : refs.colorAttachmentRefs.data(), // const VkAttachmentReference* pColorAttachments
refs.resolveAttachmentRefs.empty() ? DE_NULL : refs.resolveAttachmentRefs.data(), // const VkAttachmentReference* pResolveAttachments
refs.depthStencilAttachmentRefs.empty() ? DE_NULL : refs.depthStencilAttachmentRefs.data(), // const VkAttachmentReference* pDepthStencilAttachment
0u, // deUint32 preserveAttachmentCount
DE_NULL // const deUint32* pPreserveAttachments
};
subpassDescriptions.push_back(subpassDescription);
}
// Dependency of color attachment of subpass 0 to input attachment of subpass 1.
// Determined later if it's being used.
const SubpassDep subpassDependency =
{
DE_NULL, // const void* pNext
0u, // uint32_t srcSubpass
1u, // uint32_t dstSubpass
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags srcStageMask
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, // VkPipelineStageFlags dstStageMask
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, // VkAccessFlags dstAccessMask
VK_DEPENDENCY_BY_REGION_BIT, // VkDependencyFlags dependencyFlags
0u // deInt32 viewOffset
};
const RenderPassCreateInfo renderPassInfo =
{
DE_NULL, // const void* pNext
(VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags
(deUint32)attachmentDescriptions.size(), // deUint32 attachmentCount
attachmentDescriptions.data(), // const VkAttachmentDescription* pAttachments
(deUint32)subpassDescriptions.size(), // deUint32 subpassCount
subpassDescriptions.data(), // const VkSubpassDescription* pSubpasses
hasInputAttachment ? 1u : 0u, // deUint32 dependencyCount
hasInputAttachment ? &subpassDependency : DE_NULL, // const VkSubpassDependency* pDependencies
0u, // deUint32 correlatedViewMaskCount
DE_NULL // const deUint32* pCorrelatedViewMasks
};
return renderPassInfo.createRenderPass(vk, vkDevice);
}
class LoadStoreOpNoneTest : public vkt::TestCase
{
public:
LoadStoreOpNoneTest (tcu::TestContext& testContext,
const std::string& name,
const std::string& description,
const TestParams& testParams);
virtual ~LoadStoreOpNoneTest (void);
virtual void initPrograms (SourceCollections& sourceCollections) const;
virtual void checkSupport (Context& context) const;
virtual TestInstance* createInstance (Context& context) const;
private:
const TestParams m_testParams;
};
class LoadStoreOpNoneTestInstance : public vkt::TestInstance
{
public:
LoadStoreOpNoneTestInstance (Context& context,
const TestParams& testParams);
virtual ~LoadStoreOpNoneTestInstance (void);
virtual tcu::TestStatus iterate (void);
template<typename RenderpassSubpass>
void createCommandBuffer (const DeviceInterface& vk,
VkDevice vkDevice,
std::vector<Move<VkImageView>>& imageViews,
std::vector<Move<VkDescriptorSet>>& descriptorSets,
std::vector<Move<VkPipelineLayout>>& pipelineLayouts,
std::vector<Move<VkPipeline>>& pipelines);
private:
TestParams m_testParams;
const tcu::UVec2 m_imageSize;
const tcu::UVec2 m_renderSize;
Move<VkDescriptorPool> m_descriptorPool;
Move<VkRenderPass> m_renderPass;
Move<VkFramebuffer> m_framebuffer;
Move<VkBuffer> m_vertexBuffer;
std::vector<Vertex4RGBA> m_vertices;
de::MovePtr<Allocation> m_vertexBufferAlloc;
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
};
LoadStoreOpNoneTest::LoadStoreOpNoneTest (tcu::TestContext& testContext,
const std::string& name,
const std::string& description,
const TestParams& testParams)
: vkt::TestCase (testContext, name, description)
, m_testParams(testParams)
{
}
LoadStoreOpNoneTest::~LoadStoreOpNoneTest (void)
{
}
TestInstance* LoadStoreOpNoneTest::createInstance (Context& context) const
{
return new LoadStoreOpNoneTestInstance(context, m_testParams);
}
void LoadStoreOpNoneTest::checkSupport (Context& ctx) const
{
// Check for renderpass2 extension if used.
if (m_testParams.renderingType == RENDERING_TYPE_RENDERPASS2)
ctx.requireDeviceFunctionality("VK_KHR_create_renderpass2");
// Check for dynamic_rendering extension if used
if (m_testParams.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING)
ctx.requireDeviceFunctionality("VK_KHR_dynamic_rendering");
ctx.requireDeviceFunctionality("VK_EXT_load_store_op_none");
// Check depth/stencil format support.
for (const auto& att : m_testParams.attachments)
{
if (att.usage & ATTACHMENT_USAGE_DEPTH_STENCIL)
{
const VkFormat format = getFormat(att.usage, m_testParams.depthStencilFormat);
VkImageUsageFlags usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
const auto aspectFlags = getImageAspectFlags(mapVkFormat(format));
if (att.usage & ATTACHMENT_USAGE_DEPTH)
DE_ASSERT((aspectFlags & VK_IMAGE_ASPECT_DEPTH_BIT) != 0u);
if (att.usage & ATTACHMENT_USAGE_STENCIL)
DE_ASSERT((aspectFlags & VK_IMAGE_ASPECT_STENCIL_BIT) != 0u);
DE_UNREF(aspectFlags); // For release builds.
if (att.verifyInner || att.verifyOuter)
usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if (att.init & ATTACHMENT_INIT_PRE)
usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
const auto& vki = ctx.getInstanceInterface();
const auto physDev = ctx.getPhysicalDevice();
const auto imgType = VK_IMAGE_TYPE_2D;
const auto tiling = VK_IMAGE_TILING_OPTIMAL;
VkImageFormatProperties properties;
const auto result = vki.getPhysicalDeviceImageFormatProperties(physDev, format, imgType, tiling, usage, 0u, &properties);
if (result != VK_SUCCESS)
TCU_THROW(NotSupportedError, "Depth-stencil format not supported");
}
}
}
void LoadStoreOpNoneTest::initPrograms (SourceCollections& sourceCollections) const
{
std::ostringstream fragmentSource;
sourceCollections.glslSources.add("color_vert") << glu::VertexSource(
"#version 450\n"
"layout(location = 0) in highp vec4 position;\n"
"layout(location = 1) in highp vec4 color;\n"
"layout(location = 0) out highp vec4 vtxColor;\n"
"void main (void)\n"
"{\n"
" gl_Position = position;\n"
" vtxColor = color;\n"
"}\n");
sourceCollections.glslSources.add("color_frag") << glu::FragmentSource(
"#version 450\n"
"layout(location = 0) in highp vec4 vtxColor;\n"
"layout(location = 0) out highp vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vtxColor;\n"
" gl_FragDepth = 1.0;\n"
"}\n");
sourceCollections.glslSources.add("color_frag_uint") << glu::FragmentSource(
"#version 450\n"
"layout(location = 0) in highp vec4 vtxColor;\n"
"layout(location = 0) out highp uvec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = uvec4(vtxColor * vec4(255));\n"
" gl_FragDepth = 1.0;\n"
"}\n");
sourceCollections.glslSources.add("color_frag_blend") << glu::FragmentSource(
"#version 450\n"
"layout(location = 0) in highp vec4 vtxColor;\n"
"layout(location = 0) out highp vec4 fragColor;\n"
"void main (void)\n"
"{\n"
" fragColor = vec4(vtxColor.rgb, 0.5);\n"
" gl_FragDepth = 1.0;\n"
"}\n");
sourceCollections.glslSources.add("color_frag_input") << glu::FragmentSource(
"#version 450\n"
"layout(location = 0) in highp vec4 vtxColor;\n"
"layout(location = 0) out highp vec4 fragColor;\n"
"layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInput inputColor;\n"
"void main (void)\n"
"{\n"
" fragColor = subpassLoad(inputColor) + vtxColor;\n"
" gl_FragDepth = 1.0;\n"
"}\n");
}
LoadStoreOpNoneTestInstance::LoadStoreOpNoneTestInstance (Context& context,
const TestParams& testParams)
: vkt::TestInstance (context)
, m_testParams (testParams)
, m_imageSize (32u, 32u)
, m_renderSize (27u, 19u)
, m_vertices (createQuad())
{
}
LoadStoreOpNoneTestInstance::~LoadStoreOpNoneTestInstance (void)
{
}
template<typename RenderpassSubpass>
void LoadStoreOpNoneTestInstance::createCommandBuffer (const DeviceInterface& vk,
VkDevice vkDevice,
std::vector<Move<VkImageView>>& imageViews,
std::vector<Move<VkDescriptorSet>>& descriptorSets,
std::vector<Move<VkPipelineLayout>>& pipelineLayouts,
std::vector<Move<VkPipeline>>& pipelines)
{
const typename RenderpassSubpass::SubpassBeginInfo subpassBeginInfo (DE_NULL, VK_SUBPASS_CONTENTS_INLINE);
const typename RenderpassSubpass::SubpassEndInfo subpassEndInfo (DE_NULL);
const VkDeviceSize vertexBufferOffset = 0;
m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
beginCommandBuffer(vk, *m_cmdBuffer, 0u);
if (m_testParams.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING)
{
std::vector<VkRenderingAttachmentInfoKHR> colorAttachments;
VkRenderingAttachmentInfoKHR dsAttachment
{
VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
DE_NULL, // VkImageView imageView;
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout imageLayout;
VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
DE_NULL, // VkImageView resolveImageView;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
makeClearValueDepthStencil(0.0f, 0u) // VkClearValue clearValue;
};
bool useDepth = false;
bool useStencil = false;
for (size_t i = 0; i < imageViews.size(); i++)
{
if (m_testParams.attachments[i].usage & ATTACHMENT_USAGE_MULTISAMPLE)
{
DE_ASSERT(m_testParams.attachments[i+1].usage & ATTACHMENT_USAGE_RESOLVE_TARGET);
const auto resolveMode = ((m_testParams.attachments[i].usage & ATTACHMENT_USAGE_INTEGER) ? VK_RESOLVE_MODE_SAMPLE_ZERO_BIT : VK_RESOLVE_MODE_AVERAGE_BIT);
colorAttachments.push_back({
VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
*imageViews[i], // VkImageView imageView;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout imageLayout;
resolveMode, // VkResolveModeFlagBits resolveMode;
*imageViews[i+1], // VkImageView resolveImageView;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout resolveImageLayout;
m_testParams.attachments[i].loadOp, // VkAttachmentLoadOp loadOp;
m_testParams.attachments[i].storeOp, // VkAttachmentStoreOp storeOp;
makeClearValueColor(tcu::Vec4(0.0f)) // VkClearValue clearValue;
});
i += 1;
}
else if (m_testParams.attachments[i].usage & ATTACHMENT_USAGE_COLOR)
{
colorAttachments.push_back({
VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
*imageViews[i], // VkImageView imageView;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout imageLayout;
VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
DE_NULL, // VkImageView resolveImageView;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
m_testParams.attachments[i].loadOp, // VkAttachmentLoadOp loadOp;
m_testParams.attachments[i].storeOp, // VkAttachmentStoreOp storeOp;
makeClearValueColor(tcu::Vec4(0.0f)) // VkClearValue clearValue;
});
}
else
{
deUint32 usage = m_testParams.attachments[i].usage;
useDepth = usage & ATTACHMENT_USAGE_DEPTH;
useStencil = usage & ATTACHMENT_USAGE_STENCIL;
dsAttachment.imageView = *imageViews[i];
dsAttachment.loadOp = m_testParams.attachments[i].loadOp;
dsAttachment.storeOp = m_testParams.attachments[i].storeOp;
}
}
VkRenderingInfoKHR renderingInfo
{
VK_STRUCTURE_TYPE_RENDERING_INFO_KHR,
DE_NULL,
0u, // VkRenderingFlagsKHR flags;
makeRect2D(m_renderSize), // VkRect2D renderArea;
1u, // deUint32 layerCount;
0u, // deUint32 viewMask;
(deUint32)colorAttachments.size(), // deUint32 colorAttachmentCount;
de::dataOrNull(colorAttachments), // const VkRenderingAttachmentInfoKHR* pColorAttachments;
useDepth ? &dsAttachment : DE_NULL, // const VkRenderingAttachmentInfoKHR* pDepthAttachment;
useStencil ? &dsAttachment : DE_NULL // const VkRenderingAttachmentInfoKHR* pStencilAttachment;
};
vk.cmdBeginRendering(*m_cmdBuffer, &renderingInfo);
}
else
{
const VkRenderPassBeginInfo renderPassBeginInfo =
{
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
*m_renderPass, // VkRenderPass renderPass
*m_framebuffer, // VkFramebuffer framebuffer
makeRect2D(m_renderSize), // VkRect2D renderArea
0u, // uint32_t clearValueCount
DE_NULL // const VkClearValue* pClearValues
};
RenderpassSubpass::cmdBeginRenderPass(vk, *m_cmdBuffer, &renderPassBeginInfo, &subpassBeginInfo);
}
// Add clear commands for selected attachments
std::vector<VkClearAttachment> clearAttachments;
deUint32 colorAttIdx = 0u;
for (const auto& att : m_testParams.attachments)
{
if (att.init & ATTACHMENT_INIT_CMD_CLEAR)
{
if (att.usage & ATTACHMENT_USAGE_DEPTH_STENCIL)
{
clearAttachments.push_back({getImageAspectFlags(mapVkFormat(m_testParams.depthStencilFormat)), 0u,
makeClearValueDepthStencil(0.25, 64)});
}
else
{
clearAttachments.push_back({VK_IMAGE_ASPECT_COLOR_BIT, colorAttIdx++,
makeClearValueColorF32(0.0f, 0.0f, 0.5f, 1.0f)});
}
}
}
if (!clearAttachments.empty())
{
VkClearRect rect = { makeRect2D(m_renderSize), 0u, 1u };
vk.cmdClearAttachments(*m_cmdBuffer, (deUint32) clearAttachments.size(), clearAttachments.data(), 1u, &rect);
}
vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &m_vertexBuffer.get(), &vertexBufferOffset);
deUint32 descriptorSetIdx = 0u;
deUint32 vertexOffset = 0u;
for (size_t i = 0; i < m_testParams.subpasses.size(); i++)
{
if (i != 0)
{
vk.cmdNextSubpass(*m_cmdBuffer, VK_SUBPASS_CONTENTS_INLINE);
DE_ASSERT(m_testParams.renderingType != RENDERING_TYPE_DYNAMIC_RENDERING); // multi subpass tests should not be executed for dynamic rendering
}
vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelines[i]);
bool hasInput = false;
for (const auto &ref : m_testParams.subpasses[i].attachmentRefs)
if (ref.usage & ATTACHMENT_USAGE_INPUT)
hasInput = true;
if (hasInput)
vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayouts[i], 0, 1,
&descriptorSets[descriptorSetIdx++].get(), 0, DE_NULL);
for (deUint32 d = 0; d < m_testParams.subpasses[i].numDraws; d++)
{
vk.cmdDraw(*m_cmdBuffer, 6u, 1, vertexOffset, 0);
vertexOffset += 6u;
}
}
if (m_testParams.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING)
vk.cmdEndRendering(*m_cmdBuffer);
else
RenderpassSubpass::cmdEndRenderPass(vk, *m_cmdBuffer, &subpassEndInfo);
endCommandBuffer(vk, *m_cmdBuffer);
}
tcu::TestStatus LoadStoreOpNoneTestInstance::iterate (void)
{
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
std::vector<Move<VkImage>> attachmentImages;
std::vector<de::MovePtr<Allocation>> attachmentImageAllocs;
std::vector<Move<VkImageView>> imageViews;
std::vector<Move<VkPipeline>> pipelines;
for (const auto& att : m_testParams.attachments)
{
VkFormat format = getFormat(att.usage, m_testParams.depthStencilFormat);
VkImageUsageFlags usage = 0;
VkImageAspectFlags aspectFlags;
if (att.verifyInner || att.verifyOuter) usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
if (att.init & ATTACHMENT_INIT_PRE) usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
if (att.usage & ATTACHMENT_USAGE_DEPTH_STENCIL)
{
aspectFlags = getImageAspectFlags(mapVkFormat(format));
usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
else
{
// Color and input attachments.
aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
if (att.usage & ATTACHMENT_USAGE_COLOR)
usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
if (att.usage & ATTACHMENT_USAGE_INPUT)
usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
}
const VkSampleCountFlagBits sampleCount = att.usage & ATTACHMENT_USAGE_MULTISAMPLE ? VK_SAMPLE_COUNT_4_BIT : VK_SAMPLE_COUNT_1_BIT;
const VkImageCreateInfo imageParams =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkImageCreateFlags flags
VK_IMAGE_TYPE_2D, // VkImageType imageType
format, // VkFormat format
{ m_imageSize.x(), m_imageSize.y(), 1u }, // VkExtent3D extent
1u, // deUint32 mipLevels
1u, // deUint32 arrayLayers
sampleCount, // VkSampleCountFlagBits samples
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling
usage, // VkImageUsageFlags usage
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
1u, // deUint32 queueFamilyIndexCount
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout
};
attachmentImages.push_back(createImage(vk, vkDevice, &imageParams));
// Allocate and bind image memory.
attachmentImageAllocs.push_back(memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *attachmentImages.back()), MemoryRequirement::Any));
VK_CHECK(vk.bindImageMemory(vkDevice, *attachmentImages.back(), attachmentImageAllocs.back()->getMemory(), attachmentImageAllocs.back()->getOffset()));
// Create image view.
const VkImageViewCreateInfo imageViewParams =
{
VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkImageViewCreateFlags flags
*attachmentImages.back(), // VkImage image
VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType
format, // VkFormat format
componentMappingRGBA, // VkChannelMapping channels
{ aspectFlags, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange
};
imageViews.push_back(createImageView(vk, vkDevice, &imageViewParams));
if (att.init & ATTACHMENT_INIT_PRE)
{
// Preinitialize image
deUint32 firstUsage = getFirstUsage((deUint32)attachmentImages.size() - 1, m_testParams.subpasses);
if (firstUsage == ATTACHMENT_USAGE_UNDEFINED)
firstUsage = att.usage;
if (firstUsage & ATTACHMENT_USAGE_DEPTH_STENCIL)
{
const auto dstAccess = (VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
const auto dstStage = (VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
clearDepthStencilImage(vk, vkDevice, queue, queueFamilyIndex, *attachmentImages.back(), format, 0.5f, 128u,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
dstAccess, dstStage);
}
else
{
const auto dstAccess = (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
const auto dstStage = (VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
const auto clearColor = ((att.usage & ATTACHMENT_USAGE_INTEGER) ? makeClearValueColorU32(0u, 255u, 0u, 255u).color : makeClearValueColorF32(0.0f, 1.0f, 0.0f, 1.0f).color);
const auto layout = ((firstUsage & ATTACHMENT_USAGE_COLOR) ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
clearColorImage(vk, vkDevice, queue, queueFamilyIndex, *attachmentImages.back(), clearColor, VK_IMAGE_LAYOUT_UNDEFINED,
layout, dstAccess, dstStage);
}
}
}
if (m_testParams.renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
{
// Create render pass.
if (m_testParams.renderingType == RENDERING_TYPE_RENDERPASS_LEGACY)
m_renderPass = createRenderPass<AttachmentDescription1, AttachmentReference1, SubpassDescription1, SubpassDependency1, RenderPassCreateInfo1>(vk, vkDevice, m_testParams);
else
m_renderPass = createRenderPass<AttachmentDescription2, AttachmentReference2, SubpassDescription2, SubpassDependency2, RenderPassCreateInfo2>(vk, vkDevice, m_testParams);
std::vector<VkImageView> views;
for (const auto& view : imageViews)
views.push_back(*view);
// Create framebuffer.
const VkFramebufferCreateInfo framebufferParams =
{
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkFramebufferCreateFlags flags
*m_renderPass, // VkRenderPass renderPass
(deUint32)views.size(), // deUint32 attachmentCount
views.data(), // const VkImageView* pAttachments
(deUint32)m_imageSize.x(), // deUint32 width
(deUint32)m_imageSize.y(), // deUint32 height
1u // deUint32 layers
};
m_framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
}
// Create shader modules
Unique<VkShaderModule> vertexShaderModule (createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_vert"), 0));
Unique<VkShaderModule> fragmentShaderModule (createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_frag"), 0));
Unique<VkShaderModule> fragmentShaderModuleUint (createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_frag_uint"), 0));
Unique<VkShaderModule> fragmentShaderModuleBlend (createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_frag_blend"), 0));
Unique<VkShaderModule> fragmentShaderModuleInput (createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("color_frag_input"), 0));
// Create descriptor pool. Prepare for using one input attachment at most.
{
const VkDescriptorPoolSize descriptorPoolSize =
{
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, // VkDescriptorType type
1u // deUint32 descriptorCount
};
const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, // VkDescriptorPoolCreateFlags flags
1u, // deUint32 maxSets
1u, // deUint32 poolSizeCount
&descriptorPoolSize // const VkDescriptorPoolSize* pPoolSizes
};
m_descriptorPool = createDescriptorPool(vk, vkDevice, &descriptorPoolCreateInfo);
}
std::vector<Move<VkDescriptorSetLayout>> descriptorSetLayouts;
std::vector<Move<VkDescriptorSet>> descriptorSets;
std::vector<Move<VkPipelineLayout>> pipelineLayouts;
for (const auto& subpass : m_testParams.subpasses)
{
deUint32 numInputAttachments = 0u;
bool noColorWrite = false;
bool depthTest = false;
bool stencilTest = false;
bool multisample = false;
bool uintColorBuffer = false;
// Create pipeline layout.
{
std::vector<VkDescriptorSetLayoutBinding> layoutBindings;
for (const auto ref : subpass.attachmentRefs)
{
if (ref.usage & ATTACHMENT_USAGE_INPUT)
{
const VkDescriptorSetLayoutBinding layoutBinding =
{
0u, // deUint32 binding
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, // VkDescriptorType descriptorType
1u, // deUint32 descriptorCount
VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlags stageFlags
DE_NULL // const VkSampler* pImmutableSamplers
};
layoutBindings.push_back(layoutBinding);
numInputAttachments++;
}
if (ref.usage & ATTACHMENT_USAGE_COLOR)
{
if (ref.usage & ATTACHMENT_USAGE_WRITE_OFF)
noColorWrite = true;
}
if (ref.usage & ATTACHMENT_USAGE_DEPTH)
{
if (!(ref.usage & ATTACHMENT_USAGE_WRITE_OFF))
depthTest = true;
}
if (ref.usage & ATTACHMENT_USAGE_STENCIL)
{
if (!(ref.usage & ATTACHMENT_USAGE_WRITE_OFF))
stencilTest = true;
}
if (ref.usage & ATTACHMENT_USAGE_MULTISAMPLE)
{
multisample = true;
}
if (ref.usage & ATTACHMENT_USAGE_INTEGER)
{
uintColorBuffer = true;
}
}
const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutParams =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkDescriptorSetLayoutCreateFlags flags
(deUint32) layoutBindings.size(), // deUint32 bindingCount
layoutBindings.empty() ? DE_NULL : layoutBindings.data() // const VkDescriptorSetLayoutBinding* pBindings
};
descriptorSetLayouts.push_back(createDescriptorSetLayout(vk, vkDevice, &descriptorSetLayoutParams));
const VkPipelineLayoutCreateInfo pipelineLayoutParams =
{
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkPipelineLayoutCreateFlags flags
1u, // deUint32 setLayoutCount
&descriptorSetLayouts.back().get(), // const VkDescriptorSetLayout* pSetLayouts
0u, // deUint32 pushConstantRangeCount
DE_NULL // const VkPushConstantRange* pPushConstantRanges
};
pipelineLayouts.push_back(createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
}
// Update descriptor set if needed.
if (numInputAttachments > 0u)
{
// Assuming there's only one input attachment at most.
DE_ASSERT(numInputAttachments == 1u);
const VkDescriptorSetAllocateInfo descriptorSetAllocateInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
*m_descriptorPool, // VkDescriptorPool descriptorPool
1u, // deUint32 descriptorSetCount
&descriptorSetLayouts.back().get(), // const VkDescriptorSetLayout* pSetLayouts
};
descriptorSets.push_back(allocateDescriptorSet(vk, vkDevice, &descriptorSetAllocateInfo));
for (size_t i = 0; i < imageViews.size(); i++)
{
if (m_testParams.attachments[i].usage & ATTACHMENT_USAGE_INPUT)
{
const VkDescriptorImageInfo inputImageInfo =
{
DE_NULL, // VkSampler sampler
*imageViews[i], // VkImageView imageView
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL // VkImageLayout imageLayout
};
const VkWriteDescriptorSet descriptorWrite =
{
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // VkStructureType sType
DE_NULL, // const void* pNext
*descriptorSets.back(), // VkDescriptorSet dstSet
0u, // deUint32 dstBinding
0u, // deUint32 dstArrayElement
1u, // deUint32 descriptorCount
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, // VkDescriptorType descriptorType
&inputImageInfo, // const VkDescriptorImageInfo* pImageInfo
DE_NULL, // const VkDescriptorBufferInfo* pBufferInfo
DE_NULL // const VkBufferView* pTexelBufferView
};
vk.updateDescriptorSets(vkDevice, 1u, &descriptorWrite, 0u, DE_NULL);
}
}
}
// Create pipeline.
{
const VkVertexInputBindingDescription vertexInputBindingDescription =
{
0u, // deUint32 binding
(deUint32)sizeof(Vertex4RGBA), // deUint32 strideInBytes
VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputStepRate inputRate
};
const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
{
{
0u, // deUint32 location
0u, // deUint32 binding
VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format
0u // deUint32 offset
},
{
1u, // deUint32 location
0u, // deUint32 binding
VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format
(deUint32)(sizeof(float) * 4), // deUint32 offset
}
};
const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
{
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkPipelineVertexInputStateCreateFlags flags
1u, // deUint32 vertexBindingDescriptionCount
&vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions
2u, // deUint32 vertexAttributeDescriptionCount
vertexInputAttributeDescriptions // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions
};
const VkColorComponentFlags writeMask = noColorWrite ? 0 : VK_COLOR_COMPONENT_R_BIT // VkColorComponentFlags colorWriteMask
| VK_COLOR_COMPONENT_G_BIT
| VK_COLOR_COMPONENT_B_BIT
| VK_COLOR_COMPONENT_A_BIT;
const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
{
m_testParams.alphaBlend, // VkBool32 blendEnable
VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcColorBlendFactor
VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, // VkBlendFactor dstColorBlendFactor
VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp
VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor
VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor
VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp
writeMask // VkColorComponentFlags colorWriteMask
};
const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
{
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkPipelineColorBlendStateCreateFlags flags
VK_FALSE, // VkBool32 logicOpEnable
VK_LOGIC_OP_CLEAR, // VkLogicOp logicOp
1u, // deUint32 attachmentCount
&colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments
{ 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4]
};
const VkStencilOpState stencilOpState =
{
VK_STENCIL_OP_KEEP, // VkStencilOp failOp
VK_STENCIL_OP_REPLACE, // VkStencilOp passOp
VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp
VK_COMPARE_OP_GREATER, // VkCompareOp compareOp
0xff, // deUint32 compareMask
0xff, // deUint32 writeMask
0xff // deUint32 reference
};
const VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
{
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkPipelineDepthStencilStateCreateFlags flags
depthTest, // VkBool32 depthTestEnable
VK_TRUE, // VkBool32 depthWriteEnable
VK_COMPARE_OP_GREATER, // VkCompareOp depthCompareOp
VK_FALSE, // VkBool32 depthBoundsTestEnable
stencilTest, // VkBool32 stencilTestEnable
stencilOpState, // VkStencilOpState front
stencilOpState, // VkStencilOpState back
0.0f, // float minDepthBounds
1.0f, // float maxDepthBounds
};
const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
{
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkPipelineMultisampleStateCreateFlags flags
multisample ? VK_SAMPLE_COUNT_4_BIT : VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples
VK_FALSE, // VkBool32 sampleShadingEnable
1.0f, // float minSampleShading
DE_NULL, // const VkSampleMask* pSampleMask
VK_FALSE, // VkBool32 alphaToCoverageEnable
VK_FALSE // VkBool32 alphaToOneEnable
};
const std::vector<VkViewport> viewports (1, makeViewport(m_imageSize));
const std::vector<VkRect2D> scissors (1, makeRect2D(m_renderSize));
VkShaderModule fragShader = *fragmentShaderModule;
if (numInputAttachments > 0u)
fragShader = *fragmentShaderModuleInput;
else if (uintColorBuffer)
fragShader = *fragmentShaderModuleUint;
else if (m_testParams.alphaBlend)
fragShader = *fragmentShaderModuleBlend;
VkPipelineRenderingCreateInfoKHR renderingCreateInfo
{
VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
DE_NULL,
0u,
0u,
DE_NULL,
VK_FORMAT_UNDEFINED,
VK_FORMAT_UNDEFINED
};
std::vector<VkFormat> colorVector;
for (const auto& att : m_testParams.attachments)
{
VkFormat format = getFormat(att.usage, m_testParams.depthStencilFormat);
if (att.usage & ATTACHMENT_USAGE_DEPTH_STENCIL)
{
const auto tcuFormat = mapVkFormat(format);
const auto hasDepth = tcu::hasDepthComponent(tcuFormat.order);
const auto hasStencil = tcu::hasStencilComponent(tcuFormat.order);
renderingCreateInfo.depthAttachmentFormat = (hasDepth ? format : VK_FORMAT_UNDEFINED);
renderingCreateInfo.stencilAttachmentFormat = (hasStencil ? format : VK_FORMAT_UNDEFINED);
}
else if (!(att.usage & ATTACHMENT_USAGE_RESOLVE_TARGET))
{
colorVector.push_back(format);
}
}
vk::VkPipelineRenderingCreateInfoKHR* nextPtr = DE_NULL;
if (m_testParams.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING)
{
renderingCreateInfo.colorAttachmentCount = static_cast<deUint32>(colorVector.size());
renderingCreateInfo.pColorAttachmentFormats = colorVector.data();
nextPtr = &renderingCreateInfo;
}
pipelines.push_back(makeGraphicsPipeline(
vk, // const DeviceInterface& vk
vkDevice, // const VkDevice device
*pipelineLayouts.back(), // const VkPipelineLayout pipelineLayout
*vertexShaderModule, // const VkShaderModule vertexShaderModule
DE_NULL, // const VkShaderModule tessellationControlModule
DE_NULL, // const VkShaderModule tessellationEvalModule
DE_NULL, // const VkShaderModule geometryShaderModule
fragShader, // const VkShaderModule fragmentShaderModule
*m_renderPass, // const VkRenderPass renderPass
viewports, // const std::vector<VkViewport>& viewports
scissors, // const std::vector<VkRect2D>& scissors
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // const VkPrimitiveTopology topology
(deUint32)pipelines.size(), // const deUint32 subpass
0u, // const deUint32 patchControlPoints
&vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo
DE_NULL, // const VkPipelineRasterizationStateCreateInfo* rasterizationStateCreateInfo
&multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* multisampleStateCreateInfo
&depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* depthStencilStateCreateInfo
&colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* colorBlendStateCreateInfo
DE_NULL, // const VkPipelineDynamicStateCreateInfo* dynamicStateCreateInfo
nextPtr)); // const void* pNext
}
}
// Create vertex buffer.
{
const VkBufferCreateInfo vertexBufferParams =
{
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkBufferCreateFlags flags
(VkDeviceSize)(sizeof(Vertex4RGBA) * m_vertices.size()), // VkDeviceSize size
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
1u, // deUint32 queueFamilyIndexCount
&queueFamilyIndex // const deUint32* pQueueFamilyIndices
};
m_vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
m_vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_vertexBuffer), MemoryRequirement::HostVisible);
VK_CHECK(vk.bindBufferMemory(vkDevice, *m_vertexBuffer, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset()));
// Upload vertex data.
deMemcpy(m_vertexBufferAlloc->getHostPtr(), m_vertices.data(), m_vertices.size() * sizeof(Vertex4RGBA));
flushAlloc(vk, vkDevice, *m_vertexBufferAlloc);
}
// Create command pool.
m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
// Create command buffer.
if (m_testParams.renderingType == RENDERING_TYPE_RENDERPASS_LEGACY)
createCommandBuffer<RenderpassSubpass1>(vk, vkDevice, imageViews, descriptorSets, pipelineLayouts, pipelines);
else
createCommandBuffer<RenderpassSubpass2>(vk, vkDevice, imageViews, descriptorSets, pipelineLayouts, pipelines);
// Submit commands.
submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
bool pass = true;
// Verify selected attachments.
for (size_t i = 0; i < m_testParams.attachments.size(); i++)
{
if (m_testParams.attachments[i].verifyInner || m_testParams.attachments[i].verifyOuter)
{
de::MovePtr<tcu::TextureLevel> textureLevelResult;
SimpleAllocator allocator (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
VkFormat format = getFormat(m_testParams.attachments[i].usage, m_testParams.depthStencilFormat);
if (m_testParams.attachments[i].usage & ATTACHMENT_USAGE_DEPTH)
{
VkImageLayout layout = (m_testParams.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING) ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
textureLevelResult = pipeline::readDepthAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *attachmentImages[i], m_testParams.depthStencilFormat, m_imageSize, layout);
}
else if (m_testParams.attachments[i].usage & ATTACHMENT_USAGE_STENCIL)
{
VkImageLayout layout = (m_testParams.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING) ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
textureLevelResult = pipeline::readStencilAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *attachmentImages[i], m_testParams.depthStencilFormat, m_imageSize, layout);
}
else
{
VkImageLayout layout = ((m_testParams.renderingType == RENDERING_TYPE_DYNAMIC_RENDERING) ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
textureLevelResult = pipeline::readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *attachmentImages[i], format, m_imageSize, layout);
}
const tcu::ConstPixelBufferAccess& access = textureLevelResult->getAccess();
// Log attachment contents
m_context.getTestContext().getLog() << tcu::TestLog::ImageSet("Attachment " + de::toString(i), "")
<< tcu::TestLog::Image("Attachment " + de::toString(i), "", access)
<< tcu::TestLog::EndImageSet;
for (int y = 0; y < access.getHeight(); y++)
for (int x = 0; x < access.getWidth(); x++)
{
const bool inner = x < (int)m_renderSize.x() && y < (int)m_renderSize.y();
if (inner && !m_testParams.attachments[i].verifyInner)
continue;
if (!inner && !m_testParams.attachments[i].verifyOuter)
continue;
const tcu::Vec4 ref = inner ? m_testParams.attachments[i].innerRef : m_testParams.attachments[i].outerRef;
const tcu::Vec4 p = access.getPixel(x, y);
for (int c = 0; c < 4; c++)
if (fabs(p[c] - ref[c]) > 0.01f)
pass = false;
}
}
}
if (pass)
return tcu::TestStatus::pass("Pass");
else
return tcu::TestStatus::fail("Fail");
}
} // anonymous
tcu::TestCaseGroup* createRenderPassLoadStoreOpNoneTests (tcu::TestContext& testCtx, const RenderingType renderingType)
{
de::MovePtr<tcu::TestCaseGroup> opNoneTests (new tcu::TestCaseGroup(testCtx, "load_store_op_none", ""));
const tcu::Vec4 red (1.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 green (0.0f, 1.0f, 0.0f, 1.0f);
const tcu::Vec4 magenta (1.0f, 0.0f, 1.0f, 1.0f);
const tcu::Vec4 darkBlue (0.0f, 0.0f, 0.5f, 1.0f);
const tcu::Vec4 blend (0.5f, 0.0f, 0.25f, 0.5f);
const tcu::Vec4 depthInit (0.5f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 depthFull (1.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 stencilInit (128.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 stencilFull (255.0f, 0.0f, 0.0f, 1.0f);
const tcu::Vec4 redUint (255.0f, 0.0f, 0.0f, 255.0f);
const tcu::Vec4 greenUint (0.0f, 255.0f, 0.0f, 255.0f);
// Preinitialize attachments 0 and 1 to green.
// Subpass 0: draw a red rectangle inside attachment 0.
// Subpass 1: use the attachment 0 as input and add blue channel to it resulting in magenta. Write the results to
// attachment 1.
// After the render pass attachment 0 has undefined values inside the render area because of the shader writes with
// store op 'none', but outside should still have the preinitialized value of green. Attachment 1 should have the
// preinitialized green outside the render area and magenta inside.
if (renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
{
TestParams params;
params.alphaBlend = false;
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR | ATTACHMENT_USAGE_INPUT,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_NONE_EXT,
ATTACHMENT_INIT_PRE,
false, green,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_DONT_CARE,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, magenta,
true, green});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}}, 1u});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_INPUT}, {1u, ATTACHMENT_USAGE_COLOR}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "color_load_op_load_store_op_none", "", params));
}
// Preinitialize color attachment to green. Use a render pass with load and store ops none, but
// disable color writes using an empty color mask. The color attachment image should have the original
// preinitialized value after the render pass.
{
TestParams params;
params.alphaBlend = false;
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_NONE_EXT,
ATTACHMENT_INIT_PRE,
true, green,
true, green});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR | ATTACHMENT_USAGE_WRITE_OFF}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "color_load_op_none_store_op_none_write_off", "", params));
}
// Preinitialize color attachment to green. Use a render pass with load and store ops none, and
// write a rectange to the color buffer. The render area is undefined, but the outside area should
// still have the preinitialized color.
{
TestParams params;
params.alphaBlend = false;
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_NONE_EXT,
ATTACHMENT_INIT_PRE,
false, green,
true, green});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "color_load_op_none_store_op_none", "", params));
}
// Preinitialize color attachment to green. Use a subpass with no draw calls but instead
// do an attachment clear command using dark blue color. Using load op none preserves the preinitialized
// data and store op store causes the cleared blue render area to be present after the render pass.
{
TestParams params;
params.alphaBlend = false;
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE | ATTACHMENT_INIT_CMD_CLEAR,
true, darkBlue,
true, green});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}}, 0u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "color_load_op_none_store_op_store", "", params));
}
// Preinitialize color attachment to green. Use a subpass with a dark blue attachment clear followed
// by an alpha blender draw. Load op is none preserves the preinitialized data and store op store
// keeps the blended color inside the render area after the render pass.
{
TestParams params;
params.alphaBlend = true;
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE | ATTACHMENT_INIT_CMD_CLEAR,
true, blend,
true, green});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "color_load_op_none_store_op_store_alphablend", "", params));
}
// Preinitialize attachments 0 and 1 to green. Attachment 0 contents inside render area is undefined because load op 'none'.
// Subpass 0: draw a red rectangle inside attachment 0 overwriting all undefined values.
// Subpass 1: use the attachment 0 as input and add blue to it resulting in magenta. Write the results to attachment 1.
// After the render pass attachment 0 contents inside the render area are undefined because of store op 'don't care',
// but the outside area should still have the preinitialized content.
// Attachment 1 should have the preinitialized green outside render area and magenta inside.
if (renderingType != RENDERING_TYPE_DYNAMIC_RENDERING)
{
TestParams params;
params.alphaBlend = false;
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR | ATTACHMENT_USAGE_INPUT,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_DONT_CARE,
ATTACHMENT_INIT_PRE,
false, green,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, magenta,
true, green});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}}, 1u});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_INPUT}, {1u, ATTACHMENT_USAGE_COLOR}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "color_load_op_none_store_op_dontcare", "", params));
}
// Preinitialize color attachment to green. Use a render pass with load and store ops none for a multisample color
// target. Write a red rectangle and check it ends up in the resolved buffer even though the multisample attachment
// doesn't store the results.
{
TestParams params;
params.alphaBlend = false;
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR | ATTACHMENT_USAGE_MULTISAMPLE | ATTACHMENT_USAGE_INTEGER,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_NONE_EXT,
ATTACHMENT_INIT_PRE,
false, green,
false, green});
params.attachments.push_back({ATTACHMENT_USAGE_COLOR | ATTACHMENT_USAGE_RESOLVE_TARGET | ATTACHMENT_USAGE_INTEGER,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, redUint,
true, greenUint});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR | ATTACHMENT_USAGE_MULTISAMPLE | ATTACHMENT_USAGE_INTEGER}, {1u, ATTACHMENT_USAGE_COLOR | ATTACHMENT_USAGE_RESOLVE_TARGET}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "color_load_op_none_store_op_none_resolve", "", params));
}
std::vector<VkFormat> formats = { VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT };
for (deUint32 f = 0; f < formats.size(); ++f)
{
const std::string formatName = getFormatCaseName(formats[f]);
// Preinitialize attachment 0 (color) to green and attachment 1 (depth) to 0.5.
// Draw a red rectangle using depth 1.0 and depth op 'greater'. Depth test will pass and update
// depth buffer to 1.0.
// This is followed by another draw with a blue rectangle using the same depth of 1.0. This time
// the depth test fails and nothing is written.
// After the renderpass the red color should remain inside the render area of the color buffer.
// Store op 'store' for depth buffer makes the written values undefined, but the pixels outside
// render area should still contain the original value of 0.5.
{
TestParams params;
params.alphaBlend = false;
params.depthStencilFormat = formats[f];
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, red,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_DEPTH,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_NONE_EXT,
ATTACHMENT_INIT_PRE,
false, depthInit,
true, depthInit});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}, {1u, ATTACHMENT_USAGE_DEPTH}}, 2u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "depth_"+formatName+"_load_op_load_store_op_none", "", params));
}
// Preinitialize depth attachment to 0.5. Use a render pass with load and store ops none for the depth, but
// disable depth test which also disables depth writes. The depth attachment should have the original
// preinitialized value after the render pass.
{
TestParams params;
params.alphaBlend = false;
params.depthStencilFormat = formats[f];
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, red,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_DEPTH,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_NONE_EXT,
ATTACHMENT_INIT_PRE,
true, depthInit,
true, depthInit});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}, {1u, ATTACHMENT_USAGE_DEPTH | ATTACHMENT_USAGE_WRITE_OFF}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "depth_" + formatName + "_load_op_none_store_op_none_write_off", "", params));
}
// Preinitialize attachment 0 (color) to green and depth buffer to 0.5. During the render pass initialize attachment 1 (depth) to 0.25
// using cmdClearAttachments. Draw a red rectangle using depth 1.0 and depth op 'greater'. Depth test will pass and update
// depth buffer to 1.0. After the renderpass the color buffer should have red inside the render area and depth should have the
// shader updated value of 1.0.
{
TestParams params;
params.alphaBlend = false;
params.depthStencilFormat = formats[f];
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, red,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_DEPTH,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE | ATTACHMENT_INIT_CMD_CLEAR,
true, depthFull,
true, depthInit});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}, {1u, ATTACHMENT_USAGE_DEPTH}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "depth_" + formatName + "_load_op_none_store_op_store", "", params));
}
// Preinitialize attachment 0 (color) to green and depth buffer to 0.5. During the render pass initialize attachment 1 (depth) to 0.25
// using cmdClearAttachments. Draw a red rectangle using depth 1.0 and depth op 'greater' which will pass.
// After the renderpass the color buffer should have red inside the render area. Depth buffer contents inside render
// are is undefined because of store op 'don't care', but the outside should have the original value of 0.5.
{
TestParams params;
params.alphaBlend = false;
params.depthStencilFormat = formats[f];
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, red,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_DEPTH,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_DONT_CARE,
ATTACHMENT_INIT_PRE | ATTACHMENT_INIT_CMD_CLEAR,
false, depthFull,
true, depthInit});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}, {1u, ATTACHMENT_USAGE_DEPTH}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "depth_" + formatName + "_load_op_none_store_op_dontcare", "", params));
}
// Preinitialize attachment 0 (color) to green and attachment 1 (stencil) to 128.
// Draw a red rectangle using stencil testing with compare op 'greater' and reference of 255. The stencil test
// will pass. This is followed by another draw with a blue rectangle using the same stencil settings. This time
// the stencil test fails and nothing is written.
// After the renderpass the red color should remain inside the render area of the color buffer.
// Store op 'store' for stencil buffer makes the written values undefined, but the pixels outside
// render area should still contain the original value of 128.
{
TestParams params;
params.alphaBlend = false;
params.depthStencilFormat = formats[f];
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, red,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_STENCIL,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_NONE_EXT,
ATTACHMENT_INIT_PRE,
false, stencilInit,
true, stencilInit});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}, {1u, ATTACHMENT_USAGE_STENCIL}}, 2u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "stencil_" + formatName + "_load_op_load_store_op_none", "", params));
}
// Preinitialize stencil attachment to 128. Use a render pass with load and store ops none for the stencil, but
// disable stencil test which also disables stencil writes. The stencil attachment should have the original
// preinitialized value after the render pass.
{
TestParams params;
params.alphaBlend = false;
params.depthStencilFormat = formats[f];
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, red,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_STENCIL,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_NONE_EXT,
ATTACHMENT_INIT_PRE,
true, stencilInit,
true, stencilInit});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}, {1u, ATTACHMENT_USAGE_STENCIL | ATTACHMENT_USAGE_WRITE_OFF}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "stencil_" + formatName + "_load_op_none_store_op_none_write_off", "", params));
}
// Preinitialize attachment 0 (color) to green and stencil buffer to 128. During the render pass initialize attachment 1 (stencil) to 64
// using cmdClearAttachments. Draw a red rectangle using stencil reference of 255 and stencil op 'greater'. Stencil test will pass and update
// stencil buffer to 255. After the renderpass the color buffer should have red inside the render area and stencil should have the
// shader updated value of 255.
{
TestParams params;
params.alphaBlend = false;
params.depthStencilFormat = formats[f];
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, red,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_STENCIL,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE | ATTACHMENT_INIT_CMD_CLEAR,
true, stencilFull,
true, stencilInit});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}, {1u, ATTACHMENT_USAGE_STENCIL}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "stencil_" + formatName + "_load_op_none_store_op_store", "", params));
}
// Preinitialize attachment 0 (color) to green and stencil buffer to 128. During the render pass initialize attachment 1 (stencil) to 64
// using cmdClearAttachments. Draw a red rectangle using stencil reference 255 and stencil op 'greater' which will pass.
// After the renderpass the color buffer should have red inside the render area. Stencil buffer contents inside render
// are is undefined because of store op 'don't care', but the outside should have the original value of 128.
{
TestParams params;
params.alphaBlend = false;
params.depthStencilFormat = formats[f];
params.renderingType = renderingType;
params.attachments.push_back({ATTACHMENT_USAGE_COLOR,
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_STORE,
ATTACHMENT_INIT_PRE,
true, red,
true, green});
params.attachments.push_back({ATTACHMENT_USAGE_STENCIL,
VK_ATTACHMENT_LOAD_OP_NONE_EXT,
VK_ATTACHMENT_STORE_OP_DONT_CARE,
ATTACHMENT_INIT_PRE | ATTACHMENT_INIT_CMD_CLEAR,
false, stencilFull,
true, stencilInit});
params.subpasses.push_back({{{0u, ATTACHMENT_USAGE_COLOR}, {1u, ATTACHMENT_USAGE_STENCIL}}, 1u});
opNoneTests->addChild(new LoadStoreOpNoneTest(testCtx, "stencil_" + formatName + "_load_op_none_store_op_dontcare", "", params));
}
}
return opNoneTests.release();
}
} // renderpass
} // vkt