| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2022 The Khronos Group Inc. |
| * Copyright (c) 2022 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. |
| * |
| *//*! |
| * \brief Robustness1 vertex access out of range tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktRobustness1VertexAccessTests.hpp" |
| #include "deDefs.h" |
| #include "deMemory.h" |
| #include "gluShaderProgram.hpp" |
| #include "gluShaderUtil.hpp" |
| #include "image/vktImageLoadStoreUtil.hpp" |
| #include "pipeline/vktPipelineSpecConstantUtil.hpp" |
| #include "qpTestLog.h" |
| #include "tcuTestCase.hpp" |
| #include "tcuTestContext.hpp" |
| #include "tcuTexture.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuVectorType.hpp" |
| #include "tcuVectorUtil.hpp" |
| #include "vkBarrierUtil.hpp" |
| #include "vkCmdUtil.hpp" |
| #include "vkDefs.hpp" |
| #include "vkObjUtil.hpp" |
| #include "vkShaderProgram.hpp" |
| #include "vktRobustnessUtil.hpp" |
| #include "vktTestCase.hpp" |
| #include "vktTestCaseUtil.hpp" |
| #include "vkBuilderUtil.hpp" |
| #include "vkImageUtil.hpp" |
| #include "vkMemUtil.hpp" |
| #include "vkPrograms.hpp" |
| #include "vkQueryUtil.hpp" |
| #include "vkRef.hpp" |
| #include "vkRefUtil.hpp" |
| #include "vkTypeUtil.hpp" |
| #include "tcuTestLog.hpp" |
| #include "deMath.h" |
| #include "deUniquePtr.hpp" |
| #include "vkRefUtil.hpp" |
| #include <algorithm> |
| #include <cstdint> |
| #include <cstdio> |
| #include <iterator> |
| #include <sstream> |
| #include <tuple> |
| #include <vector> |
| #include <array> |
| #include <functional> |
| #include <cmath> |
| #include <limits> |
| #include "pipeline/vktPipelineImageUtil.hpp" |
| |
| namespace vkt |
| { |
| namespace robustness |
| { |
| namespace |
| { |
| |
| using namespace vk; |
| using namespace de; |
| using namespace tcu; |
| |
| using std::function; |
| using std::ostringstream; |
| using std::string; |
| using std::vector; |
| using std::numeric_limits; |
| using std::setprecision; |
| using std::fixed; |
| |
| typedef function<deUint32(Vec4, Vec4)> AllocateVertexFn; |
| typedef function<void(deUint32)> WriteIndexFn; |
| struct ValidityInfo |
| { |
| bool color0; |
| bool color1; |
| }; |
| |
| deUint32 GetVerticesCountForTriangles(deUint32 tilesX, deUint32 tilesY); |
| void GenerateTriangles(deUint32 tilesX, deUint32 tilesY, vector<Vec4> colors, const vector<deUint32>& invalidIndices, AllocateVertexFn allocateVertex, WriteIndexFn writeIndex = [](deUint32) { }); |
| |
| typedef vector<VkVertexInputBindingDescription> VertexBindings; |
| typedef vector<VkVertexInputAttributeDescription> VertexAttributes; |
| struct AttributeData |
| { |
| const void* data; |
| deUint32 size; |
| }; |
| |
| struct InputInfo |
| { |
| VertexBindings vertexBindings; |
| VertexAttributes vertexAttributes; |
| vector<AttributeData> data; |
| deUint32 vertexCount; |
| vector<deUint32> indices; |
| }; |
| typedef function<TestStatus(const ConstPixelBufferAccess &)> ValidationFn; |
| |
| |
| static const auto expectedColor = Vec4(0.25f, 0.0f, 0.75f, 1.0f); // Expected color input |
| static const auto unusedColor = Vec4(0.75f, 0.0f, 0.25f, 1.0f); // Unused color attributes |
| static const auto outOfRangeColor = Vec4(0.2f , 0.2f, 0.2f , 1.0f); // Padding, out of range accesses - never accepted as output |
| static const auto validColors = vector<Vec4> // Colors accepted as valid in verification shader |
| { |
| expectedColor, unusedColor |
| }; |
| static const auto invalidColors = vector<Vec4> // Colors accepted as oob access in verification shader |
| { |
| expectedColor, unusedColor, Vec4(0.0f), Vec4(0.0f, 0.0f, 0.0f, 1.0f) |
| }; |
| |
| static TestStatus robustness1TestFn(TestContext& testCtx, Context& context, const VkDevice device, const vector<InputInfo>& inputs, const IVec2& renderSize); |
| |
| template<typename T> |
| class PaddedAlloc |
| { |
| deUint32 m_count, m_paddingCount; |
| vector<T> m_data; |
| public: |
| PaddedAlloc (deUint32 count, deUint32 paddingCount, const T& paddingValue); |
| PaddedAlloc (const PaddedAlloc<T>&) = delete; |
| |
| deUint32 paddedSize() const { return static_cast<deUint32>(m_data.size()); } |
| deUint32 paddedStart() const { return m_paddingCount; } |
| const T* paddedData() const { return m_data.data(); } |
| |
| deUint32 size() const { return m_count; } |
| const T* data() const { return m_data.data() + m_paddingCount; } |
| |
| T& operator[](const deUint32 index) { return m_data[m_paddingCount + index]; } |
| const T& operator[](const deUint32 index) const { return m_data[m_paddingCount + index]; } |
| |
| PaddedAlloc& operator= (PaddedAlloc&) = delete; |
| }; |
| |
| template <typename T> |
| PaddedAlloc<T>::PaddedAlloc (deUint32 count, deUint32 paddingCount, const T& paddingValue) |
| : m_count (count) |
| , m_paddingCount (paddingCount) |
| { |
| DE_ASSERT((count + 2 * paddingCount) * sizeof(T) <= numeric_limits<deUint32>::max()); |
| m_data.resize(count + 2 * paddingCount); |
| const auto end = m_data.size() - 1; |
| for(deUint32 i = 0; i < paddingCount; ++i) |
| { |
| m_data[i] = paddingValue; |
| m_data[end - i] = paddingValue; |
| } |
| } |
| |
| typedef function<TestStatus (TestContext&, Context&, const VkDevice)> TestFn; |
| struct Robustness1TestInfo |
| { |
| string name; |
| string description; |
| TestFn testFn; |
| }; |
| static const auto renderTargetSize = IVec2(12, 12); |
| static const auto robustness1Tests = vector<Robustness1TestInfo> |
| { |
| /* Layout of generated vertices vs location invalid vertices always at middle, |
| (3x3 tiles = 4x4 vertices): |
| 0 1 2 3 -> 0 1 2 3 |
| 4 * 5 * 6 7 -> 4 7 8 11 |
| 8 * 9 *10 11 -> 12 13 14 15 |
| 12 13 14 15 -> * 5 * 6 * 9 *10 |
| */ |
| { |
| "out_of_bounds_stride_0", // string name |
| "Last elements 4 out of bounds, color with stride 0", // string description |
| [](TestContext& testContext, Context& context, const VkDevice device) // TestFn testFn |
| { |
| struct Color |
| { |
| Vec4 unused; |
| Vec4 color; |
| }; |
| const deUint32 totalCount = GetVerticesCountForTriangles(3, 3); |
| PaddedAlloc<Vec4> positions (totalCount, 8, outOfRangeColor); |
| PaddedAlloc<Color> colors (totalCount, 8, { outOfRangeColor, outOfRangeColor }); |
| PaddedAlloc<Vec4> color0 (1, 4, outOfRangeColor); |
| color0[0] = expectedColor; |
| vector<deUint32> indices; |
| deUint32 writeIndex = 0; |
| GenerateTriangles( |
| 3u, |
| 3u, |
| { unusedColor }, |
| { 5, 6, 9, 10 }, |
| [&positions, &colors, &writeIndex](Vec4 position, Vec4 color) |
| { |
| positions[writeIndex] = position; |
| colors[writeIndex] = { color, color }; |
| return writeIndex++; |
| }, |
| [&indices](deUint32 index) { indices.push_back(index); }); |
| auto bindings = |
| { |
| makeVertexInputBindingDescription(0u, sizeof(positions[0]), VK_VERTEX_INPUT_RATE_VERTEX), |
| makeVertexInputBindingDescription(1u, 0u, VK_VERTEX_INPUT_RATE_VERTEX), |
| makeVertexInputBindingDescription(2u, sizeof(colors[0]), VK_VERTEX_INPUT_RATE_VERTEX) |
| }; |
| auto attributes = |
| { |
| makeVertexInputAttributeDescription(0u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, 0u), |
| makeVertexInputAttributeDescription(1u, 1u, VK_FORMAT_R32G32B32A32_SFLOAT, 0u), |
| makeVertexInputAttributeDescription(2u, 2u, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(Color, color)) |
| }; |
| return robustness1TestFn( |
| testContext, context, device, |
| { |
| { |
| bindings, |
| attributes, |
| { |
| { positions.data() , positions.size() * static_cast<deUint32>(sizeof(positions[0])) }, |
| { color0.data() , color0.size() * static_cast<deUint32>(sizeof(color0[0])) }, |
| { colors.data() , (colors.size() - 3) * static_cast<deUint32>(sizeof(colors[0])) - static_cast<deUint32>(sizeof(Color::color) / 2) } |
| }, |
| static_cast<deUint32>(positions.size()), |
| indices |
| } |
| }, |
| renderTargetSize); |
| } |
| }, |
| { |
| "out_of_bounds_stride_16_single_buffer", // string name |
| "Last 4 elements out of bounds, color with stride 16", // string description |
| [](TestContext& testContext, Context& context, const VkDevice device) // TestFn testFn |
| { |
| struct Vertex |
| { |
| Vec4 position; |
| Vec4 unused1; |
| Vec4 color1; |
| Vec4 color2; |
| }; |
| const deUint32 totalCount = GetVerticesCountForTriangles(3, 3); |
| PaddedAlloc<Vertex> vertices (totalCount, 8, { outOfRangeColor, outOfRangeColor, outOfRangeColor, outOfRangeColor }); |
| deUint32 writeIndex = 0; |
| vector<deUint32> indices; |
| GenerateTriangles( |
| 3u, |
| 3u, |
| { expectedColor }, |
| { 5, 6, 9, 10 }, |
| [&vertices, &writeIndex](Vec4 position, Vec4 color) |
| { |
| vertices[writeIndex] = { position, unusedColor, color, color }; |
| return writeIndex++; |
| }, |
| [&indices](deUint32 index) { indices.push_back(index); }); |
| auto bindings = |
| { |
| makeVertexInputBindingDescription(0u, sizeof(Vertex), VK_VERTEX_INPUT_RATE_VERTEX), |
| makeVertexInputBindingDescription(1u, sizeof(Vertex), VK_VERTEX_INPUT_RATE_VERTEX) |
| }; |
| auto attributes = |
| { |
| makeVertexInputAttributeDescription(0u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(Vertex, position)), |
| makeVertexInputAttributeDescription(1u, 1u, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(Vertex, color1)), |
| makeVertexInputAttributeDescription(2u, 1u, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(Vertex, color2)) |
| }; |
| return robustness1TestFn( |
| testContext, context, device, |
| { |
| { |
| bindings, |
| attributes, |
| { |
| { vertices.data(), static_cast<deUint32>(vertices.size() * sizeof(vertices[0])) }, |
| { vertices.data(), static_cast<deUint32>((vertices.size() - 3) * sizeof(vertices[0]) - sizeof(Vertex::color2)) } |
| }, |
| static_cast<deUint32>(vertices.size()), |
| indices, |
| } |
| }, |
| renderTargetSize); |
| } |
| }, |
| { |
| "out_of_bounds_stride_30_middle_of_buffer", // string name |
| "Last elements 4 out of bounds, color with stride 30, data middle of buffer", // string description |
| [](TestContext& testContext, Context& context, const VkDevice device) // TestFn testFn |
| { |
| const vector<deUint32> invalidIndices = { 5, 6, 9, 10 }; |
| const deUint32 invalidCount = static_cast<deUint32>(invalidIndices.size()); |
| const deUint32 totalCount = GetVerticesCountForTriangles(3, 3); |
| struct Vertex |
| { |
| Vec4 position; |
| Vec4 color1; |
| Vec4 unused1; |
| Vec4 color2; |
| Vec4 unused2; |
| }; |
| PaddedAlloc<Vertex> vertices (totalCount, 8, { outOfRangeColor, outOfRangeColor, outOfRangeColor, outOfRangeColor, outOfRangeColor }); |
| deUint32 writeIndex = 0; |
| vector<deUint32> indices; |
| GenerateTriangles( |
| 3u, |
| 3u, |
| { expectedColor }, |
| invalidIndices, |
| [&vertices, &writeIndex](Vec4 position, Vec4 color) |
| { |
| vertices[writeIndex] = { position, color, unusedColor, unusedColor, unusedColor }; |
| return writeIndex++; |
| }, |
| [&indices](deUint32 index) { indices.push_back(index); }); |
| const auto elementSize = static_cast<deUint32>(sizeof(Vertex)); |
| auto bindings = |
| { |
| makeVertexInputBindingDescription(0u, elementSize, VK_VERTEX_INPUT_RATE_VERTEX), |
| makeVertexInputBindingDescription(1u, elementSize, VK_VERTEX_INPUT_RATE_VERTEX), |
| }; |
| auto attributes = |
| { |
| makeVertexInputAttributeDescription(0u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, vertices.paddedStart() * elementSize + static_cast<deUint32>(offsetof(Vertex, position))), |
| makeVertexInputAttributeDescription(1u, 1u, VK_FORMAT_R32G32B32A32_SFLOAT, vertices.paddedStart() * elementSize + static_cast<deUint32>(offsetof(Vertex, color1))), |
| makeVertexInputAttributeDescription(2u, 1u, VK_FORMAT_R32G32B32A32_SFLOAT, vertices.paddedStart() * elementSize + static_cast<deUint32>(offsetof(Vertex, color2))), |
| }; |
| return robustness1TestFn( |
| testContext, context, device, |
| { |
| { |
| bindings, |
| attributes, |
| { |
| { vertices.paddedData() , vertices.paddedSize() * elementSize }, |
| { vertices.paddedData() , (vertices.paddedSize() - invalidCount) * elementSize }, |
| }, |
| static_cast<deUint32>(vertices.size()), |
| indices |
| } |
| }, |
| renderTargetSize); |
| } |
| }, |
| { |
| "out_of_bounds_stride_8_middle_of_buffer_separate", // string name |
| "Last elements 4 out of bounds, color with stride 8, data middle of buffer", // string description |
| [](TestContext& testContext, Context& context, const VkDevice device) // TestFn testFn |
| { |
| /* NOTE: Out of range entries ('padding') need to be initialized with unusedColor as the spec |
| allows out of range to return any value from within the bound memory range. */ |
| const vector<deUint32> invalidIndices = { 5, 6, 9, 10 }; |
| const deUint32 invalidCount = static_cast<deUint32>(invalidIndices.size()); |
| const deUint32 totalCount = GetVerticesCountForTriangles(3, 3); |
| PaddedAlloc<Vec4> vertices (totalCount, 8, unusedColor); |
| PaddedAlloc<Vec4> colors (2 * totalCount - invalidCount, 8, unusedColor); |
| deUint32 writeIndex = 0; |
| vector<deUint32> indices; |
| GenerateTriangles( |
| 3u, |
| 3u, |
| { expectedColor }, |
| invalidIndices, |
| [&vertices, &colors, &writeIndex, totalCount](Vec4 position, Vec4 color) |
| { |
| vertices[writeIndex] = position; |
| colors[writeIndex] = color; |
| if (totalCount + writeIndex < colors.size()) |
| { |
| colors[totalCount + writeIndex] = color; |
| } |
| return writeIndex++; |
| }, |
| [&indices](deUint32 index) { indices.push_back(index); }); |
| const auto elementSize = static_cast<deUint32>(sizeof(Vec4)); |
| auto bindings = |
| { |
| makeVertexInputBindingDescription(0u, elementSize, VK_VERTEX_INPUT_RATE_VERTEX), |
| makeVertexInputBindingDescription(1u, elementSize, VK_VERTEX_INPUT_RATE_VERTEX) |
| }; |
| auto attributes = |
| { |
| makeVertexInputAttributeDescription(0u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, vertices.paddedStart() * elementSize), |
| makeVertexInputAttributeDescription(1u, 1u, VK_FORMAT_R32G32B32A32_SFLOAT, colors.paddedStart() * elementSize), |
| makeVertexInputAttributeDescription(2u, 1u, VK_FORMAT_R32G32B32A32_SFLOAT, (colors.paddedStart() + totalCount) * elementSize) |
| }; |
| return robustness1TestFn( |
| testContext, context, device, |
| { |
| { |
| bindings, |
| attributes, |
| { |
| { vertices.paddedData() , vertices.paddedSize() * elementSize }, |
| { colors.paddedData() , colors.paddedSize() * elementSize } |
| }, |
| static_cast<deUint32>(vertices.size()), |
| indices |
| } |
| }, |
| renderTargetSize); |
| } |
| } |
| }; |
| |
| deUint32 GetVerticesCountForTriangles(deUint32 tilesX, deUint32 tilesY) |
| { |
| return (tilesX + 1) * (tilesY + 1); |
| } |
| |
| // Generate triangles with invalid vertices placed at end of buffer. NOTE: Assumes invalidIndices to be in ascending order! |
| void GenerateTriangles (deUint32 tilesX, deUint32 tilesY, vector<Vec4> colors, const vector<deUint32>& invalidIndices, AllocateVertexFn allocateVertex, WriteIndexFn writeIndex) |
| { |
| const auto tilesStride = (tilesX + 1); |
| const auto total = tilesStride * (tilesY + 1); |
| const auto lastValidIndex = total - 1 - static_cast<deUint32>(invalidIndices.size()); |
| const Vec2 step (1.0f / static_cast<float>(tilesX), 1.0f / static_cast<float>(tilesY)); |
| |
| vector<deUint32> indexMappings (total); |
| deUint32 nextInvalid = 0; |
| deUint32 writeOffset = 0; |
| deUint32 nextInvalidValue = nextInvalid < invalidIndices.size() ? invalidIndices[nextInvalid] : total; |
| for(deUint32 i = 0; i < total; ++i) |
| { |
| if (i < nextInvalidValue) |
| { |
| indexMappings[writeOffset++] = i; |
| } |
| else |
| { |
| ++nextInvalid; |
| nextInvalidValue = nextInvalid < invalidIndices.size() ? invalidIndices[nextInvalid] : total; |
| } |
| } |
| for(deUint32 i = 0; i < static_cast<deUint32>(invalidIndices.size()); ++i) |
| { |
| indexMappings[writeOffset++] = invalidIndices[i]; |
| } |
| deUint32 count = 0; |
| const auto vertexFn = [lastValidIndex, &step, allocateVertex, &count](deUint32 x, deUint32 y, Vec4 color) |
| { |
| const auto result = allocateVertex( |
| Vec4( |
| 2.0f * static_cast<float>(x) * step.x() - 1.0f, |
| 2.0f * static_cast<float>(y) * step.y() - 1.0f, |
| (count <= lastValidIndex) ? 1.0f : 0.0f, |
| 1.0f |
| ), color); |
| ++count; |
| return result; |
| }; |
| vector<deUint32> indices(total); |
| for(deUint32 index = 0; index < total; ++index) |
| { |
| const auto mapped = indexMappings[index]; |
| const auto x = mapped % tilesStride; |
| const auto y = mapped / tilesStride; |
| const auto color = colors[(x + y) % colors.size()]; |
| indices[y * tilesStride + x] = vertexFn(x, y, color); |
| } |
| for(deUint32 y = 0; y < tilesY; ++y) |
| { |
| for(deUint32 x = 0; x < tilesX; ++x) |
| { |
| writeIndex(indices[(y ) * tilesStride + x ]); |
| writeIndex(indices[(y + 1) * tilesStride + x ]); |
| writeIndex(indices[(y ) * tilesStride + x + 1]); |
| writeIndex(indices[(y ) * tilesStride + x + 1]); |
| writeIndex(indices[(y + 1) * tilesStride + x + 1]); |
| writeIndex(indices[(y + 1) * tilesStride + x ]); |
| } |
| } |
| } |
| |
| static TestStatus robustness1TestFn (TestContext& testCtx, Context& context, const VkDevice device, const vector<InputInfo>& inputs, const IVec2& renderSize) |
| { |
| const auto colorFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| const auto& vk = context.getDeviceInterface(); |
| auto allocator = SimpleAllocator(vk, device, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice())); |
| |
| const auto queueFamilyIndex = context.getUniversalQueueFamilyIndex(); |
| VkQueue queue; |
| vk.getDeviceQueue(device, queueFamilyIndex, 0, &queue); |
| |
| vector<Move<VkImage>> colorImages; |
| vector<MovePtr<Allocation>> colorImageAllocs; |
| vector<Move<VkImageView>> colorViews; |
| vector<VkImageView> attachmentViews; |
| VkImageCreateInfo imageCreateInfos[] = |
| { |
| pipeline::makeImageCreateInfo(renderSize, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT), |
| }; |
| for(const auto& params : imageCreateInfos) |
| { |
| auto image = createImage(vk, device, ¶ms); |
| auto imageAlloc = allocator.allocate(getImageMemoryRequirements(vk, device, *image), MemoryRequirement::Any); |
| VK_CHECK(vk.bindImageMemory(device, *image, imageAlloc->getMemory(), imageAlloc->getOffset())); |
| const auto createInfo = VkImageViewCreateInfo |
| { |
| VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkImageViewCreateFlags flags; |
| *image, // VkImage image; |
| VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType; |
| colorFormat, // VkFormat format; |
| { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, |
| VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY }, // VkComponentMapping components; |
| { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange; |
| }; |
| auto imageView = createImageView(vk, device, &createInfo); |
| attachmentViews.push_back(*imageView); |
| colorImageAllocs.emplace_back(imageAlloc); |
| colorViews.emplace_back(imageView); |
| colorImages.emplace_back(image); |
| } |
| |
| const auto colorAttachmentDescs = vector<VkAttachmentDescription> |
| { |
| { |
| (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags |
| colorFormat, // VkFormat format |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples |
| VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp |
| VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp |
| VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp |
| VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp |
| VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout |
| }, |
| }; |
| const auto attachmentRefs = vector<vector<VkAttachmentReference>> |
| { |
| { { 0u, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL } }, // pass 0 color |
| }; |
| const auto subpassDescs = vector<VkSubpassDescription> |
| { |
| { |
| static_cast<VkSubpassDescriptionFlags>(0), // VkSubpassDescriptionFlags flags; |
| VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; |
| 0u, // uint32_t inputAttachmentCount; |
| DE_NULL, // const VkAttachmentReference* pInputAttachments; |
| static_cast<deUint32>(attachmentRefs[0].size()), // uint32_t colorAttachmentCount; |
| attachmentRefs[0].data(), // const VkAttachmentReference* pColorAttachments; |
| DE_NULL, // const VkAttachmentReference* pResolveAttachments; |
| DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; |
| 0u, // uint32_t preserveAttachmentCount; |
| DE_NULL // const uint32_t* pPreserveAttachments; |
| } |
| }; |
| const auto subpassDeps = vector<VkSubpassDependency> |
| { |
| { |
| VK_SUBPASS_EXTERNAL, // uint32_t srcSubpass; |
| 0u, // uint32_t dstSubpass; |
| VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask; |
| VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags dstStageMask; |
| 0u, // VkAccessFlags srcAccessMask; |
| VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask; |
| VK_DEPENDENCY_BY_REGION_BIT // VkDependencyFlags dependencyFlags; |
| }, |
| { |
| 0u, // uint32_t srcSubpass; |
| VK_SUBPASS_EXTERNAL, // uint32_t dstSubpass; |
| VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags srcStageMask; |
| VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask; |
| VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, // VkAccessFlags srcAccessMask; |
| VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask; |
| VK_DEPENDENCY_BY_REGION_BIT // VkDependencyFlags dependencyFlags; |
| } |
| }; |
| const auto renderPassInfo = VkRenderPassCreateInfo |
| { |
| VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType |
| DE_NULL, // const void* pNext |
| static_cast<VkRenderPassCreateFlags>(0), // VkRenderPassCreateFlags flags |
| static_cast<deUint32>(colorAttachmentDescs.size()), // deUint32 attachmentCount |
| colorAttachmentDescs.data(), // const VkAttachmentDescription* pAttachments |
| static_cast<deUint32>(subpassDescs.size()), // deUint32 subpassCount |
| subpassDescs.data(), // const VkSubpassDescription* pSubpasses |
| static_cast<deUint32>(subpassDeps.size()), // deUint32 dependencyCount |
| subpassDeps.data() // const VkSubpassDependency* pDependencies |
| }; |
| const Unique<VkRenderPass> pass (createRenderPass(vk, device, &renderPassInfo, DE_NULL)); |
| |
| vector<Move<VkBuffer>> vertexBuffers; |
| vector<MovePtr<Allocation>> vertexBufferAllocs; |
| vector<vector<VkBuffer>> vertexBufferPtrs; |
| vector<vector<VkDeviceSize>> vertexBufferOffsets; |
| vector<Move<VkBuffer>> indexBuffers; |
| vector<MovePtr<Allocation>> indexBufferAllocs; |
| vector<Move<VkPipelineLayout>> pipelineLayouts; |
| vector<Move<VkPipeline>> pipelines; |
| |
| const auto descriptorPool = DescriptorPoolBuilder() |
| .addType(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, static_cast<deUint32>(inputs.size() * 4u)) |
| .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u); |
| vector<Move<VkDescriptorSetLayout>> descriptorSetLayouts; |
| vector<Move<VkDescriptorSet>> descriptorSets; |
| vector<vector<VkDescriptorSet>> descriptorSetPtrs; |
| vector<Move<VkShaderModule>> shaderModules; |
| const vector<VkViewport> viewports = { makeViewport(renderSize) }; |
| const vector<VkRect2D> scissors = { makeRect2D(renderSize) }; |
| const vector<string> vertexNames = { "vertex-test" }; |
| const vector<string> fragmentNames = { "fragment-test" }; |
| for(vector<InputInfo>::size_type i = 0; i < inputs.size(); ++i) |
| { |
| const auto& input = inputs[i]; |
| vector<VkDescriptorSet> inputDescriptorSets; |
| vector<VkDescriptorSetLayout> setLayouts; |
| DescriptorSetLayoutBuilder builder; |
| for(size_t j = 0; j < input.vertexBindings.size(); ++j) |
| { |
| builder.addSingleBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_ALL); |
| } |
| auto descriptorSetLayout = builder.build(vk, device); |
| setLayouts.push_back(*descriptorSetLayout); |
| VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = |
| { |
| VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| *descriptorPool, // VkDescriptorPool descriptorPool; |
| 1u, // deUint32 setLayoutCount; |
| &*descriptorSetLayout // const VkDescriptorSetLayout* pSetLayouts; |
| }; |
| auto descriptorSet = allocateDescriptorSet(vk, device, &descriptorSetAllocateInfo); |
| inputDescriptorSets.push_back(*descriptorSet); |
| |
| VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkPipelineLayoutCreateFlags flags; |
| static_cast<deUint32>(setLayouts.size()), // deUint32 setLayoutCount; |
| setLayouts.data(), // const VkDescriptorSetLayout* pSetLayouts; |
| 0u, // deUint32 pushConstantRangeCount; |
| DE_NULL // const VkPushConstantRange* pPushConstantRanges; |
| }; |
| auto pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo); |
| |
| descriptorSetPtrs.push_back(inputDescriptorSets); |
| descriptorSetLayouts.emplace_back(descriptorSetLayout); |
| descriptorSets.emplace_back(descriptorSet); |
| |
| vector<VkBuffer> inputVertexBufferPtrs; |
| for(const auto& data : input.data) |
| { |
| const auto createInfo = makeBufferCreateInfo(data.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); |
| auto buffer = createBuffer(vk, device, &createInfo); |
| auto bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible); |
| VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset())); |
| deMemcpy(bufferAlloc->getHostPtr(), data.data, data.size); |
| flushMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), VK_WHOLE_SIZE); |
| inputVertexBufferPtrs.push_back(*buffer); |
| vertexBufferAllocs.emplace_back(bufferAlloc); |
| vertexBuffers.emplace_back(buffer); |
| } |
| vertexBufferOffsets.push_back(vector<VkDeviceSize>(inputVertexBufferPtrs.size(), 0ull)); |
| vertexBufferPtrs.push_back(inputVertexBufferPtrs); |
| |
| if (input.indices.size() > 0u) |
| { |
| const auto indexDataSize = input.indices.size() * sizeof(input.indices[0]); |
| const auto createInfo = makeBufferCreateInfo(indexDataSize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT); |
| auto indexBuffer = createBuffer(vk, device, &createInfo); |
| auto indexBufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *indexBuffer), MemoryRequirement::HostVisible); |
| VK_CHECK(vk.bindBufferMemory(device, *indexBuffer, indexBufferAlloc->getMemory(), indexBufferAlloc->getOffset())); |
| deMemcpy(indexBufferAlloc->getHostPtr(), input.indices.data(), indexDataSize); |
| flushMappedMemoryRange(vk, device, indexBufferAlloc->getMemory(), indexBufferAlloc->getOffset(), VK_WHOLE_SIZE); |
| indexBufferAllocs.emplace_back(indexBufferAlloc); |
| indexBuffers.emplace_back(indexBuffer); |
| } |
| const auto& bindings = input.vertexBindings; |
| const auto& attributes = input.vertexAttributes; |
| const auto vertexInputCreateInfo = VkPipelineVertexInputStateCreateInfo |
| { |
| VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkPipelineVertexInputStateCreateFlags flags; |
| static_cast<deUint32>(bindings.size()), // deUint32 vertexBindingDescriptionCount; |
| bindings.data(), // const VkVertexInputBindingDescription* pVertexBindingDescriptions; |
| static_cast<deUint32>(attributes.size()), // deUint32 vertexAttributeDescriptionCount; |
| attributes.data() // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; |
| }; |
| auto vertexShaderModule = createShaderModule(vk, device, context.getBinaryCollection().get(vertexNames[i % vertexNames.size()]), 0u); |
| auto fragmentShaderModule = createShaderModule(vk, device, context.getBinaryCollection().get(fragmentNames[i % fragmentNames.size()]), 0u); |
| auto graphicsPipeline = makeGraphicsPipeline( |
| vk, // const DeviceInterface& vk, |
| device, // const VkDevice device, |
| *pipelineLayout, // const VkPipelineLayout pipelineLayout, |
| *vertexShaderModule, // const VkShaderModule vertexShaderModule, |
| DE_NULL, // const VkShaderModule tessellationControlShaderModule, |
| DE_NULL, // const VkShaderModule tessellationEvalShaderModule, |
| DE_NULL, // const VkShaderModule geometryShaderModule, |
| *fragmentShaderModule, // const VkShaderModule fragmentShaderModule, |
| *pass, // const VkRenderPass renderPass, |
| viewports, // const std::vector<VkViewport>& viewports, |
| scissors, // const std::vector<VkRect2D>& scissors, |
| VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // const VkPrimitiveTopology topology, |
| static_cast<deUint32>(i), // const deUint32 subpass, |
| 0u, // const deUint32 patchControlPoints, |
| &vertexInputCreateInfo); // const VkPipelineVertexInputStateCreateInfo* vertexInputStateCreateInfo, |
| |
| pipelineLayouts.emplace_back(pipelineLayout); |
| pipelines.emplace_back(graphicsPipeline); |
| shaderModules.emplace_back(vertexShaderModule); |
| shaderModules.emplace_back(fragmentShaderModule); |
| } |
| |
| const auto framebufferCreateInfo = VkFramebufferCreateInfo |
| { |
| VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkFramebufferCreateFlags flags; |
| *pass, // VkRenderPass renderPass; |
| static_cast<deUint32>(attachmentViews.size()), // deUint32 attachmentCount; |
| attachmentViews.data(), // const VkImageView* pAttachments; |
| (deUint32)renderSize.x(), // deUint32 width; |
| (deUint32)renderSize.y(), // deUint32 height; |
| 1u // deUint32 layers; |
| }; |
| const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, device, &framebufferCreateInfo)); |
| |
| const Unique<VkCommandPool> commandPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex)); |
| const Unique<VkCommandBuffer> commandBuffer (allocateCommandBuffer(vk, device, *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); |
| beginCommandBuffer(vk, *commandBuffer, 0u); |
| beginRenderPass(vk, *commandBuffer, *pass, *framebuffer, makeRect2D(renderSize), Vec4(0.0f)); |
| deUint32 nextIndex = 0; |
| for(vector<InputInfo>::size_type i = 0; i < inputs.size(); ++i) |
| { |
| const auto& input = inputs[i]; |
| vk.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelines[i]); |
| vk.cmdBindDescriptorSets(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayouts[i], 0, static_cast<deUint32>(descriptorSetPtrs[i].size()), descriptorSetPtrs[i].data(), 0, DE_NULL); |
| vk.cmdBindVertexBuffers(*commandBuffer, 0, (deUint32)vertexBufferPtrs[i].size(), vertexBufferPtrs[i].data(), vertexBufferOffsets[i].data()); |
| if (!input.indices.empty()) |
| { |
| vk.cmdBindIndexBuffer(*commandBuffer, *indexBuffers[nextIndex], 0u, VK_INDEX_TYPE_UINT32); |
| vk.cmdDrawIndexed(*commandBuffer, static_cast<deUint32>(input.indices.size()), 1u, 0, 0, 0u); |
| ++nextIndex; |
| } |
| else |
| { |
| vk.cmdDraw(*commandBuffer, input.vertexCount, 1u, 0, 0); |
| } |
| if (i + 1 < inputs.size()) |
| { |
| vk.cmdNextSubpass(*commandBuffer, VK_SUBPASS_CONTENTS_INLINE); |
| } |
| } |
| endRenderPass(vk, *commandBuffer); |
| |
| endCommandBuffer(vk, *commandBuffer); |
| submitCommandsAndWait(vk, device, queue, *commandBuffer); |
| |
| const auto texture0 = pipeline::readColorAttachment(vk, device, queue, queueFamilyIndex, allocator, *colorImages[0], colorFormat, UVec2(renderSize.x(), renderSize.y())); |
| |
| const auto tex1Access = texture0->getAccess(); |
| for(deInt32 y = 0; y < tex1Access.getHeight(); ++y) |
| { |
| for(deInt32 x = 0; x < tex1Access.getWidth(); ++x) |
| { |
| if (tex1Access.getPixel(x, y) != Vec4(0.0f, 1.0f, 0.0f, 1.0f)) |
| { |
| testCtx.getLog() |
| << TestLog::ImageSet("Result Images", "") |
| << TestLog::Image("Texture 0 (source)", "", texture0->getAccess()) |
| << TestLog::EndImageSet; |
| |
| return TestStatus::fail("Image comparison failed."); |
| } |
| } |
| } |
| return TestStatus::pass("OK"); |
| } |
| } // namespace |
| |
| // Robustness1AccessInstance |
| |
| template<typename T> |
| class Robustness1AccessInstance : public vkt::TestInstance |
| { |
| public: |
| Robustness1AccessInstance (TestContext& testCtx, Context& context, T device, const Robustness1TestInfo& testInfo); |
| virtual ~Robustness1AccessInstance () {} |
| virtual TestStatus iterate() override; |
| |
| private: |
| TestContext& m_testCtx; |
| T m_device; |
| const Robustness1TestInfo& m_testInfo; |
| }; |
| |
| template<typename T> |
| Robustness1AccessInstance<T>::Robustness1AccessInstance (TestContext& testCtx, Context& context, T device, const Robustness1TestInfo& testInfo) |
| : vkt::TestInstance(context), m_testCtx(testCtx), m_device(device), m_testInfo(testInfo) |
| { |
| } |
| |
| template<typename T> |
| TestStatus Robustness1AccessInstance<T>::iterate () |
| { |
| return m_testInfo.testFn(m_testCtx, m_context, m_device); |
| } |
| |
| // Robustness1AccessTest |
| |
| class Robustness1AccessTest : public vkt::TestCase |
| { |
| public: |
| Robustness1AccessTest (TestContext& testContext, const Robustness1TestInfo &testInfo); |
| virtual ~Robustness1AccessTest () {} |
| |
| virtual TestInstance* createInstance (Context& context) const override; |
| |
| protected: |
| virtual void initPrograms (SourceCollections& programCollection) const override; |
| |
| private: |
| Robustness1TestInfo m_testInfo; |
| }; |
| |
| Robustness1AccessTest::Robustness1AccessTest (TestContext &testContext, const Robustness1TestInfo& testInfo) |
| : vkt::TestCase(testContext, testInfo.name, testInfo.description), |
| m_testInfo(testInfo) |
| { |
| } |
| |
| TestInstance *Robustness1AccessTest::createInstance (Context &context) const |
| { |
| return new Robustness1AccessInstance<VkDevice>(m_testCtx, context, context.getDevice(), m_testInfo); |
| } |
| |
| void Robustness1AccessTest::initPrograms (SourceCollections& programCollection) const |
| { |
| ostringstream vertexTestSource; |
| vertexTestSource |
| << "#version 310 es\n" |
| << "precision highp float;\n" |
| << "layout(location = 0) in vec4 in_position;\n" |
| << "layout(location = 1) in vec4 in_color0;\n" |
| << "layout(location = 2) in vec4 in_color1;\n" |
| << "layout(location = 0) out vec4 out_color;\n" |
| << "bool is_valid(vec4 color)\n" |
| << "{\n" |
| << " return\n"; |
| const auto compare_color = [](ostringstream& out, const string& variable, const Vec4& color) |
| { |
| out << setprecision(5) << fixed |
| << " (" |
| << variable << ".r - " << color.x() << " < 0.00001 && " |
| << variable << ".g - " << color.y() << " < 0.00001 && " |
| << variable << ".b - " << color.z() << " < 0.00001 && " |
| << variable << ".a - " << color.w() << " < 0.00001" |
| << ")"; |
| }; |
| for(vector<Vec4>::size_type i = 0; i < validColors.size(); ++i) |
| { |
| compare_color(vertexTestSource, "color", validColors[i]); |
| vertexTestSource << ((i < validColors.size() - 1) ? " ||\n" : ";\n"); |
| } |
| vertexTestSource |
| << "}\n" |
| << "bool is_invalid(vec4 color)\n" |
| << "{\n" |
| << " return\n"; |
| for(vector<Vec4>::size_type i = 0; i < invalidColors.size(); ++i) |
| { |
| compare_color(vertexTestSource, "color", invalidColors[i]); |
| vertexTestSource << ((i < invalidColors.size() - 1) ? " ||\n" : ";\n"); |
| } |
| vertexTestSource |
| << "}\n" |
| << "bool validate(bool should_be_valid, vec4 color0, vec4 color1)\n" |
| << "{\n" |
| << " return (should_be_valid && is_valid(color0) && is_valid(color1)) || (is_invalid(color0) && is_invalid(color1));\n" |
| << "}\n" |
| << "void main()\n" |
| << "{\n" |
| << " out_color = validate(in_position.z >= 1.0, in_color0, in_color1) ? vec4(0,1,0,1) : in_color0;" |
| << " gl_Position = vec4(in_position.xy, 0.0, 1.0);\n" |
| << "}\n"; |
| programCollection.glslSources.add("vertex-test") << glu::VertexSource(vertexTestSource.str()); |
| programCollection.glslSources.add("fragment-test") << glu::FragmentSource( |
| "#version 310 es\n" |
| "precision highp float;\n" |
| "layout(location = 0) in vec4 in_color;\n" |
| "layout(location = 0) out vec4 out_color;\n" |
| "void main() {\n" |
| " out_color = in_color;\n" |
| "}\n"); |
| } |
| |
| TestCaseGroup* createRobustness1VertexAccessTests (TestContext& testCtx) |
| { |
| MovePtr<TestCaseGroup> robustness1AccessTests (new TestCaseGroup(testCtx, "robustness1_vertex_access", "")); |
| for(const auto& info : robustness1Tests) |
| { |
| robustness1AccessTests->addChild(new Robustness1AccessTest(testCtx, info)); |
| } |
| |
| return robustness1AccessTests.release(); |
| } |
| |
| } // robustness |
| } // vkt |
