From ae491da77bce565e08dc99599da280fdc44d8d61 Mon Sep 17 00:00:00 2001 From: Arkadiusz Sarwa Date: Fri, 3 Nov 2017 10:34:27 +0100 Subject: [PATCH] Cross-stage interface tests New tests: dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.* Components: Vulkan VK-GL-CTS issue: 225 Change-Id: Ie8b67c6b2d6ece86052fdca45618b394b977019e --- AndroidGen.mk | 1 + android/cts/master/vk-master.txt | 6 + .../modules/vulkan/spirv_assembly/CMakeLists.txt | 2 + .../vktSpvAsmCrossStageInterfaceTests.cpp | 3004 ++++++++++++++++++++ .../vktSpvAsmCrossStageInterfaceTests.hpp | 40 + .../spirv_assembly/vktSpvAsmInstructionTests.cpp | 4 +- .../mustpass/1.1.2/vk-default-no-waivers.txt | 6 + external/vulkancts/mustpass/1.1.2/vk-default.txt | 6 + 8 files changed, 3067 insertions(+), 2 deletions(-) create mode 100644 external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.cpp create mode 100644 external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.hpp diff --git a/AndroidGen.mk b/AndroidGen.mk index accfae7..1e5a4c9 100644 --- a/AndroidGen.mk +++ b/AndroidGen.mk @@ -244,6 +244,7 @@ LOCAL_SRC_FILES := \ external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmComputeShaderCase.cpp \ external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmComputeShaderTestUtil.cpp \ external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmConditionalBranchTests.cpp \ + external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.cpp \ external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmGraphicsShaderTestUtil.cpp \ external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmImageSamplerTests.cpp \ external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmIndexingTests.cpp \ diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt index 5c460b7..ecc386b 100755 --- a/android/cts/master/vk-master.txt +++ b/android/cts/master/vk-master.txt @@ -196083,6 +196083,12 @@ dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_ima dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_image.pass_sampler_to_function dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_image.pass_image_and_sampler_to_function dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.combined_image_sampler.all_local_variables +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.flat +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.no_perspective +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.relaxedprecision +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.flat +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.no_perspective +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.relaxedprecision dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_vertex dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_tesselation_evaluation dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_tesselation_control diff --git a/external/vulkancts/modules/vulkan/spirv_assembly/CMakeLists.txt b/external/vulkancts/modules/vulkan/spirv_assembly/CMakeLists.txt index 7d53ef5..745a005 100644 --- a/external/vulkancts/modules/vulkan/spirv_assembly/CMakeLists.txt +++ b/external/vulkancts/modules/vulkan/spirv_assembly/CMakeLists.txt @@ -3,6 +3,8 @@ include_directories(..) set(DEQP_VK_SPIRV_ASSEMBLY_SRCS + vktSpvAsmCrossStageInterfaceTests.cpp + vktSpvAsmCrossStageInterfaceTests.hpp vktSpvAsm16bitStorageTests.cpp vktSpvAsm16bitStorageTests.hpp vktSpvAsmUboMatrixPaddingTests.cpp diff --git a/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.cpp b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.cpp new file mode 100644 index 0000000..5b3155e --- /dev/null +++ b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.cpp @@ -0,0 +1,3004 @@ +/*------------------------------------------------------------------------- + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2017 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 Shader cross-stage interface tests + *//*--------------------------------------------------------------------*/ + +#include "vktSpvAsmCrossStageInterfaceTests.hpp" + +#include "tcuTestLog.hpp" +#include "tcuTextureUtil.hpp" +#include "tcuImageCompare.hpp" + +#include "vkDefs.hpp" +#include "vkMemUtil.hpp" +#include "deSharedPtr.hpp" +#include "vkQueryUtil.hpp" +#include "vkRefUtil.hpp" +#include "vkStrUtil.hpp" +#include "vkTypeUtil.hpp" +#include "vkImageUtil.hpp" + +#include "deUniquePtr.hpp" + +#include "vktSpvAsmGraphicsShaderTestUtil.hpp" +#include "vktTestCaseUtil.hpp" +#include "vktTestGroupUtil.hpp" + +#include +#include + +namespace vkt +{ +namespace SpirVAssembly +{ +using namespace vk; + +namespace +{ +using std::string; +using std::map; +using std::vector; + +typedef de::SharedPtr > ShaderModuleSP; +using de::MovePtr; + +using tcu::Vec4; + +enum TestType +{ + TEST_TYPE_FLAT = 0, + TEST_TYPE_NOPERSPECTIVE, + TEST_TYPE_RELAXEDPRECISION, + TEST_TYPE_LAST +}; + +struct TestParameters +{ + TestParameters (TestType q, size_t s) + :testOptions (s) + ,qualifier (q) + {} + vector testOptions; + TestType qualifier; +}; + +VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize bufferSize, const VkBufferUsageFlags usage) +{ + const VkBufferCreateInfo bufferCreateInfo = + { + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkBufferCreateFlags)0, // VkBufferCreateFlags flags; + bufferSize, // VkDeviceSize size; + usage, // VkBufferUsageFlags usage; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 0u, // deUint32 queueFamilyIndexCount; + DE_NULL, // const deUint32* pQueueFamilyIndices; + }; + return bufferCreateInfo; +} + +VkImageCreateInfo makeImageCreateInfo (const VkImageType imageType, const VkExtent3D& extent, const VkFormat format, const VkImageUsageFlags usage, deUint32 queueFamilyIndex) +{ + const VkImageCreateInfo imageInfo = + { + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkImageCreateFlags)0, // VkImageCreateFlags flags; + imageType, // VkImageType imageType; + format, // VkFormat format; + {extent.width, extent.height, 1u}, // VkExtent3D extent; + 1u, // uint32_t mipLevels; + extent.depth, // uint32_t arrayLayers; + VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; + VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; + usage, // VkImageUsageFlags usage; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 1u, // uint32_t queueFamilyIndexCount; + &queueFamilyIndex, // const uint32_t* pQueueFamilyIndices; + VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; + }; + return imageInfo; +} + +Move makeRenderPass (const DeviceInterface& vk, + const VkDevice device, + const VkFormat colorFormat) +{ + const VkAttachmentDescription colorAttachmentDescription = + { + (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags; + colorFormat, // VkFormat format; + VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; + VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; + VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; + VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; + VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout; + }; + + const VkAttachmentReference colorAttachmentReference = + { + 0u, // deUint32 attachment; + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; + }; + + const VkSubpassDescription subpassDescription = + { + (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags; + VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; + 0u, // deUint32 inputAttachmentCount; + DE_NULL, // const VkAttachmentReference* pInputAttachments; + 1u, // deUint32 colorAttachmentCount; + &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments; + DE_NULL, // const VkAttachmentReference* pResolveAttachments; + DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; + 0u, // deUint32 preserveAttachmentCount; + DE_NULL // const deUint32* pPreserveAttachments; + }; + + const VkRenderPassCreateInfo renderPassInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags; + 1u, // deUint32 attachmentCount; + &colorAttachmentDescription, // const VkAttachmentDescription* pAttachments; + 1u, // deUint32 subpassCount; + &subpassDescription, // const VkSubpassDescription* pSubpasses; + 0u, // deUint32 dependencyCount; + DE_NULL // const VkSubpassDependency* pDependencies; + }; + + return createRenderPass(vk, device, &renderPassInfo); +} + +Move makeImageView (const DeviceInterface& vk, + const VkDevice device, + const VkImage image, + const VkImageViewType viewType, + const VkFormat format, + const VkImageSubresourceRange subresourceRange) +{ + const VkImageViewCreateInfo imageViewParams = + { + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkImageViewCreateFlags)0, // VkImageViewCreateFlags flags; + image, // VkImage image; + viewType, // VkImageViewType viewType; + format, // VkFormat format; + makeComponentMappingRGBA(), // VkComponentMapping components; + subresourceRange, // VkImageSubresourceRange subresourceRange; + }; + return createImageView(vk, device, &imageViewParams); +} + +Move makeFramebuffer (const DeviceInterface& vk, + const VkDevice device, + const VkRenderPass renderPass, + const VkImageView attachments, + const deUint32 width, + const deUint32 height) +{ + const VkFramebufferCreateInfo framebufferInfo = + { + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags; + renderPass, // VkRenderPass renderPass; + 1u, // uint32_t attachmentCount; + &attachments, // const VkImageView* pAttachments; + width, // uint32_t width; + height, // uint32_t height; + 1u, // uint32_t layers; + }; + return createFramebuffer(vk, device, &framebufferInfo); +} + +Move makePipelineLayout (const DeviceInterface& vk, + const VkDevice device) +{ + VkPipelineLayoutCreateInfo pipelineLayoutParams = + { + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineLayoutCreateFlags)0, + 0u, // deUint32 descriptorSetCount; + DE_NULL, // const VkDescriptorSetLayout* pSetLayouts; + 0u, // deUint32 pushConstantRangeCount; + DE_NULL, // const VkPushConstantRange* pPushConstantRanges; + }; + return createPipelineLayout(vk, device, &pipelineLayoutParams); +} + +void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer) +{ + const VkCommandBufferBeginInfo info = + { + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags; + DE_NULL, // const VkCommandBufferInheritanceInfo* pInheritanceInfo; + }; + VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info)); +} + +void submitCommandsAndWait (const DeviceInterface& vk, + const VkDevice device, + const VkQueue queue, + const VkCommandBuffer commandBuffer) +{ + const VkFenceCreateInfo fenceInfo = + { + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkFenceCreateFlags)0, // VkFenceCreateFlags flags; + }; + const Unique fence (createFence(vk, device, &fenceInfo)); + + const VkSubmitInfo submitInfo = + { + VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // uint32_t waitSemaphoreCount; + DE_NULL, // const VkSemaphore* pWaitSemaphores; + DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask; + 1u, // uint32_t commandBufferCount; + &commandBuffer, // const VkCommandBuffer* pCommandBuffers; + 0u, // uint32_t signalSemaphoreCount; + DE_NULL, // const VkSemaphore* pSignalSemaphores; + }; + VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence)); + VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull)); +} + +void imageBarrier (const DeviceInterface& vk, + const VkCommandBuffer cmdBuffer, + const VkImage image, + const VkImageSubresourceRange subresourceRange, + const VkImageLayout oldLayout, + const VkImageLayout newLayout, + const VkAccessFlags srcAccessMask, + const VkAccessFlags dstAccessMask, + const VkPipelineStageFlags srcStageMask, + const VkPipelineStageFlags dstStageMask) +{ + const VkImageMemoryBarrier barrier = + { + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; + DE_NULL, // const void* pNext; + srcAccessMask, // VkAccessFlags srcAccessMask; + dstAccessMask, // VkAccessFlags dstAccessMask; + oldLayout, // VkImageLayout oldLayout; + newLayout, // VkImageLayout newLayout; + VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; + VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex; + image, // VkImage image; + subresourceRange, // VkImageSubresourceRange subresourceRange; + }; + + vk.cmdPipelineBarrier(cmdBuffer, srcStageMask, dstStageMask, (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, + 0u, (const VkBufferMemoryBarrier*)DE_NULL, + 1u, &barrier); +} + +class CrossStageTestInstance : public TestInstance +{ +public: + CrossStageTestInstance (Context& context, const TestParameters& parameters) + : TestInstance (context) + , m_parameters (parameters) + , m_verticesCount (4u) + , m_data (2u * m_verticesCount) + , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM) + , m_colorRed (1.0f, 0.0f, 0.0f, 1.0f) + , m_colorGreen (0.0f, 1.0f, 0.0f, 1.0f) + { + createVertexData(); + m_extent.width = 51u; + m_extent.height = 51u; + m_extent.depth = 1u; + } +enum +{ + DECORATION_IN_VERTEX = 0, + DECORATION_IN_FRAGMENT, + DECORATION_IN_ALL_SHADERS, + DECORATION_LAST +}; +protected: + tcu::TestStatus iterate (void); +private: + void createVertexData (void); + void madeShaderModule (map& shaderModule, + vector& shaderStageParams, + const VkShaderStageFlagBits stageFlag, + const int optionNdx); + + Move makeGraphicsPipeline (const VkRenderPass renderPass, + const VkPipelineLayout pipelineLayout, + const deUint32 pipelineShaderStageCount, + const VkPipelineShaderStageCreateInfo* pipelineShaderStageCreate, + const VkVertexInputRate vertexInputRate, + const VkPrimitiveTopology primitiveTopology); + + bool checkImage (VkImage image, + VkCommandBuffer cmdBuffer, + const string& description, + const tcu::Texture2DArray& referenceFrame); + void interpolationFill (tcu::Texture2DArray& referenceFrame); + void perspectiveFill (tcu::Texture2DArray& referenceFrame); + void redFill (tcu::Texture2DArray& referenceFrame); + + const TestParameters m_parameters; + const deUint32 m_verticesCount; + vector m_data; + VkExtent3D m_extent; + const VkFormat m_colorFormat; + const Vec4 m_colorRed; + const Vec4 m_colorGreen; +}; + +tcu::TestStatus CrossStageTestInstance::iterate (void) +{ + const DeviceInterface& vk = m_context.getDeviceInterface(); + const VkDevice vkDevice = m_context.getDevice(); + const VkPhysicalDeviceFeatures& features = m_context.getDeviceFeatures(); + const bool supportsGeometry = features.geometryShader == VK_TRUE; + const bool supportsTessellation = features.tessellationShader == VK_TRUE; + const VkDeviceSize vertexDataSize = static_cast(deAlignSize(static_cast( m_data.size() * sizeof(Vec4)), + static_cast(m_context.getDeviceProperties().limits.nonCoherentAtomSize))); + const VkBufferCreateInfo bufferInfo = makeBufferCreateInfo(vertexDataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); + Move vertexBuffer = createBuffer(vk, vkDevice, &bufferInfo); + MovePtr allocationVertex = m_context.getDefaultAllocator().allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible); + + const VkImageSubresourceRange imageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u); + const VkImageCreateInfo colorAttachmentInfo = makeImageCreateInfo(VK_IMAGE_TYPE_2D, m_extent, m_colorFormat, + VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, m_context.getUniversalQueueFamilyIndex()); + + Move colorAttachmentImage = createImage(vk, vkDevice, &colorAttachmentInfo); + MovePtr allocationAttachment = m_context.getDefaultAllocator().allocate(getImageMemoryRequirements(vk, vkDevice, *colorAttachmentImage), MemoryRequirement::Any); + VK_CHECK(vk.bindImageMemory(vkDevice, *colorAttachmentImage, allocationAttachment->getMemory(), allocationAttachment->getOffset())); + Move colorAttachmentView = makeImageView(vk, vkDevice, *colorAttachmentImage, VK_IMAGE_VIEW_TYPE_2D, m_colorFormat, imageSubresourceRange); + + MovePtr referenceImage1 = MovePtr(new tcu::Texture2DArray(mapVkFormat(m_colorFormat), m_extent.width, m_extent.height, m_extent.depth)); + MovePtr referenceImage2 = MovePtr(new tcu::Texture2DArray(mapVkFormat(m_colorFormat), m_extent.width, m_extent.height, m_extent.depth)); + + // Init host buffer data + VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, allocationVertex->getMemory(), allocationVertex->getOffset())); + deMemcpy(allocationVertex->getHostPtr(), m_data.data(), static_cast(vertexDataSize)); + flushMappedMemoryRange(vk, vkDevice, allocationVertex->getMemory(), allocationVertex->getOffset(), static_cast(vertexDataSize)); + + Move renderPass = makeRenderPass (vk, vkDevice, m_colorFormat); + Move frameBuffer = makeFramebuffer (vk, vkDevice, *renderPass, *colorAttachmentView, m_extent.width, m_extent.height); + Move pipelineLayout = makePipelineLayout (vk, vkDevice); + Move cmdPool; + Move cmdBuffer; + const VkClearValue renderPassClearValue = makeClearValueColor(tcu::Vec4(0.0f)); + const VkRect2D renderArea = { { 0, 0 }, { m_extent.width, m_extent.height } }; + const VkRenderPassBeginInfo renderPassBeginInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *renderPass, // VkRenderPass renderPass; + *frameBuffer, // VkFramebuffer framebuffer; + renderArea, // VkRect2D renderArea; + 1u, // uint32_t clearValueCount; + &renderPassClearValue, // const VkClearValue* pClearValues; + }; + + // cmdPool + { + const VkCommandPoolCreateInfo cmdPoolParams = + { + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // VkCmdPoolCreateFlags flags; + m_context.getUniversalQueueFamilyIndex(), // deUint32 queueFamilyIndex; + }; + cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams); + } + + // cmdBuffer + { + const VkCommandBufferAllocateInfo cmdBufferAllocateInfo = + { + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *cmdPool, // VkCommandPool commandPool; + VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level; + 1u, // deUint32 bufferCount; + }; + cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo); + } + + if (!supportsTessellation) + m_context.getTestContext().getLog() << tcu::TestLog::Message << "Tessellation not supported" << tcu::TestLog::EndMessage; + + if (!supportsGeometry) + m_context.getTestContext().getLog() << tcu::TestLog::Message << "Geometry not supported" << tcu::TestLog::EndMessage; + + vector shadersStagesFlagsBits; + shadersStagesFlagsBits.push_back(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); + + if (supportsTessellation) + shadersStagesFlagsBits.push_back(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); + + if (supportsGeometry) + shadersStagesFlagsBits.push_back(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); + + if (supportsTessellation && supportsGeometry) + shadersStagesFlagsBits.push_back(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); + + referenceImage1->allocLevel(0); + referenceImage2->allocLevel(0); + switch(m_parameters.qualifier) + { + case TEST_TYPE_FLAT: + interpolationFill(*referenceImage1); + redFill(*referenceImage2); + break; + case TEST_TYPE_NOPERSPECTIVE: + perspectiveFill(*referenceImage1); + interpolationFill(*referenceImage2); + break; + case TEST_TYPE_RELAXEDPRECISION: + interpolationFill(*referenceImage1); + interpolationFill(*referenceImage2); + break; + default: + DE_ASSERT(0); + } + + for (deUint32 optionNdx = 0; optionNdx < m_parameters.testOptions.size(); optionNdx++) + for (size_t stagesNdx = 0ull; stagesNdx < shadersStagesFlagsBits.size(); stagesNdx++) + { + vector shaderStageParams; + map shaderModule; + string imageDescription; + madeShaderModule(shaderModule, shaderStageParams, (VkShaderStageFlagBits)shadersStagesFlagsBits[stagesNdx], optionNdx); + + Move graphicsPipeline = makeGraphicsPipeline (*renderPass, *pipelineLayout, static_cast(shaderModule.size()), &shaderStageParams[0], VK_VERTEX_INPUT_RATE_VERTEX, + ((VkShaderStageFlagBits)shadersStagesFlagsBits[stagesNdx] & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP); + const VkDeviceSize vertexBufferOffset = 0u; + + beginCommandBuffer(vk, *cmdBuffer); + + imageBarrier(vk, *cmdBuffer, *colorAttachmentImage, imageSubresourceRange, + VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 0u, 0u, + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT); + + vk.cmdClearColorImage(*cmdBuffer, *colorAttachmentImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &renderPassClearValue.color, 1, &imageSubresourceRange); + + imageBarrier(vk, *cmdBuffer, *colorAttachmentImage, imageSubresourceRange, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT); + + vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); + + vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &(*vertexBuffer), &vertexBufferOffset); + + vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline); + + vk.cmdDraw(*cmdBuffer, m_verticesCount, 1u, 0u, 0u); + + vk.cmdEndRenderPass(*cmdBuffer); + + VK_CHECK(vk.endCommandBuffer(*cmdBuffer)); + + submitCommandsAndWait(vk, vkDevice, m_context.getUniversalQueue(), *cmdBuffer); + + { + const string geometry = (VK_SHADER_STAGE_GEOMETRY_BIT & (VkShaderStageFlagBits)shadersStagesFlagsBits[stagesNdx]) ? "Geometry->" : ""; + const string tessellation = ( VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT & (VkShaderStageFlagBits)shadersStagesFlagsBits[stagesNdx]) ? "Tessellation->" : ""; + imageDescription = "Pipeline: Vertex->" + tessellation + geometry + "Fragment | "; + } + + if (DECORATION_IN_VERTEX == m_parameters.testOptions[optionNdx]) + imageDescription+= "decoration in vertex | "; + if (DECORATION_IN_FRAGMENT == m_parameters.testOptions[optionNdx]) + imageDescription+= "decoration in fragment | "; + if (DECORATION_IN_ALL_SHADERS == m_parameters.testOptions[optionNdx]) + imageDescription+= "decoration in all shaders | "; + + { + bool resultComparison = false; + if (TEST_TYPE_RELAXEDPRECISION == m_parameters.qualifier) + { + resultComparison = checkImage(*colorAttachmentImage, *cmdBuffer, imageDescription+" Expected Pass", *referenceImage1); + } + else + { + if (DECORATION_IN_VERTEX == m_parameters.testOptions[optionNdx]) + resultComparison = checkImage(*colorAttachmentImage, *cmdBuffer, imageDescription+" Expected Pass", *referenceImage1); + else if ((VkShaderStageFlagBits)(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT) == (VkShaderStageFlagBits)shadersStagesFlagsBits[stagesNdx]) + resultComparison = checkImage(*colorAttachmentImage, *cmdBuffer, imageDescription+" Expected Pass", *referenceImage2); + else + resultComparison = !checkImage(*colorAttachmentImage, *cmdBuffer, imageDescription+" Expected Fail", *referenceImage1); + } + + if(!resultComparison) + return tcu::TestStatus::fail("Fail"); + } + } + return tcu::TestStatus::pass("Pass"); +} + +void CrossStageTestInstance::createVertexData (void) +{ + int ndx = -1; + if (TEST_TYPE_NOPERSPECTIVE == m_parameters.qualifier) + m_data[++ndx] = Vec4(-2.0f,-2.0f, 1.0f, 2.0f); //position + else + m_data[++ndx] = Vec4(-1.0f,-1.0f, 1.0f, 1.0f); //position + m_data[++ndx] = m_colorRed; + + if (TEST_TYPE_NOPERSPECTIVE == m_parameters.qualifier) + m_data[++ndx] = Vec4(-2.0f, 2.0f, 1.0f, 2.0f); //position + else + m_data[++ndx] = Vec4(-1.0f, 1.0f, 1.0f, 1.0f); //position + m_data[++ndx] = m_colorRed; + + m_data[++ndx] = Vec4( 1.0f,-1.0f, 1.0f, 1.0f); //position + m_data[++ndx] = m_colorGreen; + + m_data[++ndx] = Vec4( 1.0f, 1.0f, 1.0f, 1.0f); //position + m_data[++ndx] = m_colorGreen; +} + +void CrossStageTestInstance::madeShaderModule (map& shaderModule, + vector& shaderStageParams, + const VkShaderStageFlagBits stageFlag, + const int optionNdx) +{ + const DeviceInterface& vk = m_context.getDeviceInterface(); + const VkDevice vkDevice = m_context.getDevice(); + + std::ostringstream vertex; + vertex<<"vertex"<(createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get(vertex.str()), 0)))); + + if (stageFlag & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) + shaderModule[VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT] = (ShaderModuleSP(new Unique(createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("tessellation_control"), 0)))); + + if (stageFlag & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) + shaderModule[VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT] = (ShaderModuleSP(new Unique(createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("tessellation_evaluation"), 0)))); + + if (stageFlag & VK_SHADER_STAGE_GEOMETRY_BIT) + shaderModule[VK_SHADER_STAGE_GEOMETRY_BIT] = (ShaderModuleSP(new Unique(createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("geometry"), 0)))); + + if (stageFlag & VK_SHADER_STAGE_FRAGMENT_BIT) + shaderModule[VK_SHADER_STAGE_FRAGMENT_BIT] = (ShaderModuleSP(new Unique(createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get(fragment.str()), 0)))); + + VkPipelineShaderStageCreateInfo pipelineShaderStage = + { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; + (VkShaderStageFlagBits)0, // VkShaderStageFlagBits stage; + (VkShaderModule)0, // VkShaderModule module; + "main", // const char* pName; + (const VkSpecializationInfo*)DE_NULL, // const VkSpecializationInfo* pSpecializationInfo; + }; + + for (map::iterator it=shaderModule.begin(); it!=shaderModule.end(); ++it) + { + pipelineShaderStage.stage = it->first; + pipelineShaderStage.module = **it->second; + shaderStageParams.push_back(pipelineShaderStage); + } +} + +Move CrossStageTestInstance::makeGraphicsPipeline (const VkRenderPass renderPass, + const VkPipelineLayout pipelineLayout, + const deUint32 pipelineShaderStageCount, + const VkPipelineShaderStageCreateInfo* pipelineShaderStageCreate, + const VkVertexInputRate vertexInputRate, + const VkPrimitiveTopology primitiveTopology) +{ + const DeviceInterface& vk = m_context.getDeviceInterface(); + const VkDevice vkDevice = m_context.getDevice(); + + const VkVertexInputBindingDescription vertexInputBindingDescription = + { + 0u, // binding; + static_cast(2u*sizeof(Vec4)), // stride; + vertexInputRate // inputRate + }; + + const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] = + { + { + 0u, + 0u, + VK_FORMAT_R32G32B32A32_SFLOAT, + 0u + }, // VertexElementData::position + { + 1u, + 0u, + VK_FORMAT_R32G32B32A32_SFLOAT, + static_cast(sizeof(tcu::Vec4)) + }, // VertexElementData::color + }; + + const VkPipelineVertexInputStateCreateInfo vertexInputStateParams = + { // sType; + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // pNext; + NULL, // flags; + 0u, // vertexBindingDescriptionCount; + 1u, // pVertexBindingDescriptions; + &vertexInputBindingDescription, // vertexAttributeDescriptionCount; + 2u, // pVertexAttributeDescriptions; + vertexInputAttributeDescriptions + }; + + const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkPipelineInputAssemblyStateCreateFlags flags; + primitiveTopology, // VkPrimitiveTopology topology; + VK_FALSE, // VkBool32 primitiveRestartEnable; + }; + + const VkViewport viewport = + { + 0.0f, // float originX; + 0.0f, // float originY; + (float)m_extent.width, // float width; + (float)m_extent.height, // float height; + 0.0f, // float minDepth; + 1.0f // float maxDepth; + }; + + const VkRect2D scissor = + { + { 0, 0 }, // VkOffset2D offset; + { m_extent.width, m_extent.height } // VkExtent2D extent; + }; + + const VkPipelineViewportStateCreateInfo viewportStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkPipelineViewportStateCreateFlags flags; + 1u, // deUint32 viewportCount; + &viewport, // const VkViewport* pViewports; + 1u, // deUint32 scissorCount; + &scissor // const VkRect2D* pScissors; + }; + + const VkPipelineRasterizationStateCreateInfo rasterStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkPipelineRasterizationStateCreateFlags flags; + VK_FALSE, // VkBool32 depthClampEnable; + VK_FALSE, // VkBool32 rasterizerDiscardEnable; + VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode; + VK_CULL_MODE_NONE, // VkCullModeFlags cullMode; + VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace; + VK_FALSE, // VkBool32 depthBiasEnable; + 0.0f, // float depthBiasConstantFactor; + 0.0f, // float depthBiasClamp; + 0.0f, // float depthBiasSlopeFactor; + 1.0f, // float lineWidth; + }; + + const VkPipelineMultisampleStateCreateInfo multisampleStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkPipelineMultisampleStateCreateFlags flags; + VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples; + VK_FALSE, // VkBool32 sampleShadingEnable; + 0.0f, // float minSampleShading; + DE_NULL, // const VkSampleMask* pSampleMask; + VK_FALSE, // VkBool32 alphaToCoverageEnable; + VK_FALSE, // VkBool32 alphaToOneEnable; + }; + + VkPipelineDepthStencilStateCreateInfo depthStencilStateParams = + { + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkPipelineDepthStencilStateCreateFlags flags; + VK_TRUE, // VkBool32 depthTestEnable; + VK_TRUE, // VkBool32 depthWriteEnable; + VK_COMPARE_OP_LESS_OR_EQUAL, // VkCompareOp depthCompareOp; + VK_FALSE, // VkBool32 depthBoundsTestEnable; + VK_FALSE, // VkBool32 stencilTestEnable; + // VkStencilOpState front; + { + VK_STENCIL_OP_KEEP, // VkStencilOp failOp; + VK_STENCIL_OP_KEEP, // VkStencilOp passOp; + VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp; + VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; + 0u, // deUint32 compareMask; + 0u, // deUint32 writeMask; + 0u, // deUint32 reference; + }, + // VkStencilOpState back; + { + VK_STENCIL_OP_KEEP, // VkStencilOp failOp; + VK_STENCIL_OP_KEEP, // VkStencilOp passOp; + VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp; + VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; + 0u, // deUint32 compareMask; + 0u, // deUint32 writeMask; + 0u, // deUint32 reference; + }, + 0.0f, // float minDepthBounds; + 1.0f, // float maxDepthBounds; + }; + + const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = + { + VK_FALSE, // 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_ONE, // VkBlendFactor dstAlphaBlendFactor; + VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp; + VK_COLOR_COMPONENT_R_BIT | // VkColorComponentFlags colorWriteMask; + VK_COLOR_COMPONENT_G_BIT | + VK_COLOR_COMPONENT_B_BIT | + VK_COLOR_COMPONENT_A_BIT + }; + + 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_COPY, // VkLogicOp logicOp; + 1u, // deUint32 attachmentCount; + &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments; + { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConst[4]; + }; + + VkPipelineTessellationStateCreateInfo TessellationState = + { + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineTessellationStateCreateFlags)0, // VkPipelineTessellationStateCreateFlags flags; + 4u // deUint32 patchControlPoints; + }; + + const VkGraphicsPipelineCreateInfo graphicsPipelineParams = + { + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineCreateFlags)0u, // VkPipelineCreateFlags flags; + pipelineShaderStageCount, // deUint32 stageCount; + pipelineShaderStageCreate, // const VkPipelineShaderStageCreateInfo* pStages; + &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST == primitiveTopology)? &TessellationState : DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState; + &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState; + &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterState; + &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState; + pipelineLayout, // VkPipelineLayout layout; + renderPass, // VkRenderPass renderPass; + 0u, // deUint32 subpass; + 0u, // VkPipeline basePipelineHandle; + 0, // deInt32 basePipelineIndex; + }; + + return createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams); +} + +bool CrossStageTestInstance::checkImage (VkImage image, VkCommandBuffer cmdBuffer, const string& description, const tcu::Texture2DArray& referenceFrame) +{ + const DeviceInterface& vk = m_context.getDeviceInterface(); + const VkDevice vkDevice = m_context.getDevice(); + const int pixelSize = referenceFrame.getFormat().getPixelSize(); + Move buffer; + MovePtr bufferAlloc; + vector pixelAccessData (m_extent.width * m_extent.height * m_extent.depth * pixelSize); + tcu::PixelBufferAccess dst (referenceFrame.getFormat(), m_extent.width, m_extent.height, m_extent.depth, pixelAccessData.data()); + const VkDeviceSize pixelDataSize = dst.getWidth() * dst.getHeight() * dst.getDepth() * pixelSize; + + // Create destination buffer + { + const VkBufferCreateInfo bufferParams = + { + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkBufferCreateFlags flags; + pixelDataSize, // VkDeviceSize size; + VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage; + VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; + 0u, // deUint32 queueFamilyIndexCount; + DE_NULL, // const deUint32* pQueueFamilyIndices; + }; + + buffer = createBuffer(vk, vkDevice, &bufferParams); + bufferAlloc = m_context.getDefaultAllocator().allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible); + VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset())); + + deMemset(bufferAlloc->getHostPtr(), 0, static_cast(pixelDataSize)); + flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize); + } + + const VkBufferMemoryBarrier bufferBarrier = + { + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType; + DE_NULL, // const void* pNext; + VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask; + VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask; + VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; + VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex; + *buffer, // VkBuffer buffer; + 0u, // VkDeviceSize offset; + pixelDataSize // VkDeviceSize size; + }; + + // Copy image to buffer + const VkBufferImageCopy copyRegion = + { + 0u, // VkDeviceSize bufferOffset; + (deUint32)dst.getWidth(), // deUint32 bufferRowLength; + (deUint32)dst.getHeight(), // deUint32 bufferImageHeight; + { + VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspect; + 0u, // deUint32 mipLevel; + 0u, // deUint32 baseArrayLayer; + m_extent.depth, // deUint32 layerCount; + }, // VkImageSubresourceLayers imageSubresource; + { 0, 0, 0 }, // VkOffset3D imageOffset; + { m_extent.width, m_extent.height, 1u } // VkExtent3D imageExtent; + }; + + beginCommandBuffer (vk, cmdBuffer); + { + VkImageSubresourceRange subresourceRange = + { + VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask; + 0u, // deUint32 baseMipLevel; + 1u, // deUint32 mipLevels; + 0u, // deUint32 baseArraySlice; + m_extent.depth, // deUint32 arraySize; + }; + + imageBarrier (vk, cmdBuffer, image, subresourceRange, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + 0u, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); + + vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1u, ©Region); + vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0u, DE_NULL); + } + VK_CHECK(vk.endCommandBuffer(cmdBuffer)); + submitCommandsAndWait(vk, vkDevice, m_context.getUniversalQueue(), cmdBuffer); + + // Read buffer data + invalidateMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize); + tcu::copy(dst, tcu::ConstPixelBufferAccess(dst.getFormat(), dst.getSize(), bufferAlloc->getHostPtr())); + + if (tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Result", description.c_str(), referenceFrame.getLevel(0), dst, tcu::Vec4(0.05f), tcu::COMPARE_LOG_EVERYTHING)) + return true; + return false; +} + +void CrossStageTestInstance::interpolationFill (tcu::Texture2DArray& referenceFrame) +{ + for (deUint32 x = 0u; x < m_extent.width; ++x) + { + float u = static_cast(x)/static_cast(m_extent.width - 1); + const Vec4 resultColor (m_colorRed.x() * (1.0f - u) + m_colorGreen.x() * u, + m_colorRed.y() * (1.0f - u) + m_colorGreen.y() * u, + m_colorRed.z() * (1.0f - u) + m_colorGreen.z() * u, + m_colorRed.w() * (1.0f - u) + m_colorGreen.w() * u); + + referenceFrame.getLevel(0).setPixel(resultColor,x,0); + } + + for (deUint32 y = 0u; y < m_extent.height; ++y) + { + deMemcpy (referenceFrame.getLevel(0).getPixelPtr(0,y), referenceFrame.getLevel(0).getPixelPtr(0,0), m_extent.width * m_extent.depth* referenceFrame.getFormat().getPixelSize()); + } +} + +void CrossStageTestInstance::perspectiveFill (tcu::Texture2DArray& referenceFrame) +{ + float dynamics = 1.732f; + float dynamicChange = 0.732f / static_cast(m_extent.width); + for (deUint32 x = 0u; x < m_extent.width; ++x) + { + float u = static_cast(x)/static_cast(m_extent.width - 1); + const Vec4 resultColor (m_colorRed.x() * (1.0f - dynamics * u) + m_colorGreen.x() * u* dynamics, + m_colorRed.y() * (1.0f - dynamics * u) + m_colorGreen.y() * u* dynamics, + m_colorRed.z() * (1.0f - dynamics * u) + m_colorGreen.z() * u* dynamics, + m_colorRed.w() * (1.0f - dynamics * u) + m_colorGreen.w() * u* dynamics); + dynamics -= dynamicChange; + if (dynamics < 1.0f) + dynamics = 1.0f; + + referenceFrame.getLevel(0).setPixel(resultColor,x,0); + } + + for (deUint32 y = 0u; y < m_extent.height; ++y) + { + deMemcpy (referenceFrame.getLevel(0).getPixelPtr(0,y), referenceFrame.getLevel(0).getPixelPtr(0,0), m_extent.width * m_extent.depth* referenceFrame.getFormat().getPixelSize()); + } +} + +void CrossStageTestInstance::redFill (tcu::Texture2DArray& referenceFrame) +{ + for (deUint32 x = 0u; x < m_extent.width; ++x) + referenceFrame.getLevel(0).setPixel(m_colorRed,x,0); + + for (deUint32 y = 0u; y < m_extent.height; ++y) + deMemcpy (referenceFrame.getLevel(0).getPixelPtr(0,y), referenceFrame.getLevel(0).getPixelPtr(0,0), m_extent.width * m_extent.depth* referenceFrame.getFormat().getPixelSize()); +} + +struct Decorations +{ + Decorations() + {}; + Decorations(const string& f, const string& v, const string& o) + : fragment (f) + , vertex (v) + , others (o) + {}; + string fragment; + string vertex; + string others; +}; + +class CrossStageBasicTestsCase : public vkt::TestCase +{ +public: + CrossStageBasicTestsCase (tcu::TestContext &context, const char *name, const char *description, const TestParameters& parameters) + : TestCase (context, name, description) + , m_parameters (parameters) + { + } +private: + vkt::TestInstance* createInstance (vkt::Context& context) const; + void initPrograms (SourceCollections& programCollection) const; + + const TestParameters m_parameters; + +}; + +vkt::TestInstance* CrossStageBasicTestsCase::createInstance (vkt::Context& context) const +{ + return new CrossStageTestInstance(context, m_parameters); +} + +void CrossStageBasicTestsCase::initPrograms (SourceCollections& programCollection) const +{ + vector decorations; + switch(m_parameters.qualifier) + { + case TEST_TYPE_FLAT: + decorations.push_back(Decorations("", + //Vertex + "OpDecorate %color_out Flat\n" + "OpDecorate %color_in Flat\n" + "OpDecorate %r_float_out Flat\n" + "OpDecorate %rg_float_out Flat\n" + "OpDecorate %rgb_float_out Flat\n" + "OpDecorate %rgba_float_out Flat\n", + "")); + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in Flat\n" + "OpDecorate %r_float_in Flat\n" + "OpDecorate %rg_float_in Flat\n" + "OpDecorate %rgb_float_in Flat\n" + "OpDecorate %rgba_float_in Flat\n", + "", + "")); + + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in Flat\n" + "OpDecorate %r_float_in Flat\n" + "OpDecorate %rg_float_in Flat\n" + "OpDecorate %rgb_float_in Flat\n" + "OpDecorate %rgba_float_in Flat\n", + //Vertex + "OpDecorate %color_out Flat\n" + "OpDecorate %color_in Flat\n" + "OpDecorate %r_float_out Flat\n" + "OpDecorate %rg_float_out Flat\n" + "OpDecorate %rgb_float_out Flat\n" + "OpDecorate %rgba_float_out Flat\n", + "")); + break; + case TEST_TYPE_NOPERSPECTIVE: + decorations.push_back(Decorations("", + //Vertex + "OpDecorate %color_out NoPerspective\n" + "OpDecorate %color_in NoPerspective\n" + "OpDecorate %r_float_out NoPerspective\n" + "OpDecorate %rg_float_out NoPerspective\n" + "OpDecorate %rgb_float_out NoPerspective\n" + "OpDecorate %rgba_float_out NoPerspective\n", + "")); + + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in NoPerspective\n" + "OpDecorate %r_float_in NoPerspective\n" + "OpDecorate %rg_float_in NoPerspective\n" + "OpDecorate %rgb_float_in NoPerspective\n" + "OpDecorate %rgba_float_in NoPerspective\n", + "", + "")); + + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in NoPerspective\n" + "OpDecorate %r_float_in NoPerspective\n" + "OpDecorate %rg_float_in NoPerspective\n" + "OpDecorate %rgb_float_in NoPerspective\n" + "OpDecorate %rgba_float_in NoPerspective\n", + //Vertex + "OpDecorate %color_out NoPerspective\n" + "OpDecorate %color_in NoPerspective\n" + "OpDecorate %r_float_out NoPerspective\n" + "OpDecorate %rg_float_out NoPerspective\n" + "OpDecorate %rgb_float_out NoPerspective\n" + "OpDecorate %rgba_float_out NoPerspective\n", + //Others + "")); + break; + case TEST_TYPE_RELAXEDPRECISION: + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_out RelaxedPrecision\n" + "OpDecorate %color_in RelaxedPrecision\n" + "OpDecorate %r_float_in RelaxedPrecision\n" + "OpDecorate %rg_float_in RelaxedPrecision\n" + "OpDecorate %rgb_float_in RelaxedPrecision\n" + "OpDecorate %rgba_float_in RelaxedPrecision\n", + //Vertex + "OpDecorate %color_out RelaxedPrecision\n" + "OpDecorate %color_in RelaxedPrecision\n" + "OpDecorate %r_float_out RelaxedPrecision\n" + "OpDecorate %rg_float_out RelaxedPrecision\n" + "OpDecorate %rgb_float_out RelaxedPrecision\n" + "OpDecorate %rgba_float_out RelaxedPrecision\n", + //Others + "OpDecorate %color_out RelaxedPrecision\n" + "OpDecorate %color_in RelaxedPrecision\n" + "OpDecorate %r_float_out RelaxedPrecision\n" + "OpDecorate %rg_float_out RelaxedPrecision\n" + "OpDecorate %rgb_float_out RelaxedPrecision\n" + "OpDecorate %rgba_float_out RelaxedPrecision\n" + "OpDecorate %r_float_in RelaxedPrecision\n" + "OpDecorate %rg_float_in RelaxedPrecision\n" + "OpDecorate %rgb_float_in RelaxedPrecision\n" + "OpDecorate %rgba_float_in RelaxedPrecision\n")); + break; + default: + DE_ASSERT(0); + } + + //Spir-v spec: decoration flat can be used only in Shader (fragment or vertex) + for (deUint32 ndx = 0; ndx < decorations.size(); ++ndx) + { + + /*#version 450 + layout(location = 0) in highp vec4 in_position; + layout(location = 1) in vec4 in_color; + layout(location = 0) out vec4 out_color; + layout(location = 1) out float r_float_out; + layout(location = 2) out vec2 rg_float_out; + layout(location = 3) out vec3 rgb_float_out; + layout(location = 4) out vec4 rgba_float_out; + void main (void) + { + gl_Position = in_position; + out_color = in_color; + r_float_out = in_color.r; + rg_float_out = vec2(in_color.r, in_color.g); + rgb_float_out = vec3(in_color.r, in_color.g,in_color.b); + rgba_float_out = vec4(in_color.r, in_color.g, in_color.b, in_color.a); + } + */ + const string vertexShaderSource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 60\n" + "; Schema: 0\n" + "OpCapability Shader\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Vertex %4 \"main\" %13 %17 %color_out %color_in %r_float_out %rg_float_out %rgb_float_out %rgba_float_out\n" + "OpMemberDecorate %11 0 BuiltIn Position\n" + "OpMemberDecorate %11 1 BuiltIn PointSize\n" + "OpMemberDecorate %11 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %11 3 BuiltIn CullDistance\n" + "OpDecorate %11 Block\n" + "OpDecorate %17 Location 0\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 1\n" + "OpDecorate %r_float_out Location 1\n" + "OpDecorate %rg_float_out Location 2\n" + "OpDecorate %rgb_float_out Location 3\n" + "OpDecorate %rgba_float_out Location 4\n" + +decorations[ndx].vertex+ + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeFloat 32\n" + "%7 = OpTypeVector %6 4\n" + "%8 = OpTypeInt 32 0\n" + "%9 = OpConstant %8 1\n" + "%10 = OpTypeArray %6 %9\n" + "%11 = OpTypeStruct %7 %6 %10 %10\n" + "%12 = OpTypePointer Output %11\n" + "%13 = OpVariable %12 Output\n" + "%14 = OpTypeInt 32 1\n" + "%15 = OpConstant %14 0\n" + "%16 = OpTypePointer Input %7\n" + "%17 = OpVariable %16 Input\n" + "%19 = OpTypePointer Output %7\n" + "%color_out = OpVariable %19 Output\n" + "%color_in = OpVariable %16 Input\n" + "%24 = OpTypePointer Output %6\n" + "%r_float_out = OpVariable %24 Output\n" + "%26 = OpConstant %8 0\n" + "%27 = OpTypePointer Input %6\n" + "%30 = OpTypeVector %6 2\n" + "%31 = OpTypePointer Output %30\n" + "%rg_float_out = OpVariable %31 Output\n" + "%38 = OpTypeVector %6 3\n" + "%39 = OpTypePointer Output %38\n" + "%rgb_float_out = OpVariable %39 Output\n" + "%45 = OpConstant %8 2\n" + "%rgba_float_out = OpVariable %19 Output\n" + "%56 = OpConstant %8 3\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%18 = OpLoad %7 %17\n" + "%20 = OpAccessChain %19 %13 %15\n" + "OpStore %20 %18\n" + "%23 = OpLoad %7 %color_in\n" + "OpStore %color_out %23\n" + "%28 = OpAccessChain %27 %color_in %26\n" + "%29 = OpLoad %6 %28\n" + "OpStore %r_float_out %29\n" + "%33 = OpAccessChain %27 %color_in %26\n" + "%34 = OpLoad %6 %33\n" + "%35 = OpAccessChain %27 %color_in %9\n" + "%36 = OpLoad %6 %35\n" + "%37 = OpCompositeConstruct %30 %34 %36\n" + "OpStore %rg_float_out %37\n" + "%41 = OpAccessChain %27 %color_in %26\n" + "%42 = OpLoad %6 %41\n" + "%43 = OpAccessChain %27 %color_in %9\n" + "%44 = OpLoad %6 %43\n" + "%46 = OpAccessChain %27 %color_in %45\n" + "%47 = OpLoad %6 %46\n" + "%48 = OpCompositeConstruct %38 %42 %44 %47\n" + "OpStore %rgb_float_out %48\n" + "%50 = OpAccessChain %27 %color_in %26\n" + "%51 = OpLoad %6 %50\n" + "%52 = OpAccessChain %27 %color_in %9\n" + "%53 = OpLoad %6 %52\n" + "%54 = OpAccessChain %27 %color_in %45\n" + "%55 = OpLoad %6 %54\n" + "%57 = OpAccessChain %27 %color_in %56\n" + "%58 = OpLoad %6 %57\n" + "%59 = OpCompositeConstruct %7 %51 %53 %55 %58\n" + "OpStore %rgba_float_out %59\n" + "OpReturn\n" + "OpFunctionEnd\n"; + + /* #version 450 + layout(location = 0) out vec4 out_color; + layout(location = 0) in vec4 in_color; + layout(location = 1) in float r_float_in; + layout(location = 2) in vec2 rg_float_in; + layout(location = 3) in vec3 rgb_float_in; + layout(location = 4) in vec4 rgba_float_in; + void main() + { + out_color = in_color; + if(r_float_in != in_color.r) + out_color.r = 1.0f; + if(rg_float_in != in_color.rg) + out_color.rg = vec2(1.0f); + if(rgb_float_in != in_color.rgb) + out_color.rgb = vec3(1.0f); + if(rgba_float_in != in_color.rgba) + out_color.rgba = vec4(1.0f); + } + */ + + const string fragmentShaderSource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 64\n" + "; Schema: 0\n" + "OpCapability Shader\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Fragment %4 \"main\" %color_out %color_in %r_float_in %rg_float_in %rgb_float_in %rgba_float_in\n" + "OpExecutionMode %4 OriginUpperLeft\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 0\n" + "OpDecorate %r_float_in Location 1\n" + "OpDecorate %rg_float_in Location 2\n" + "OpDecorate %rgb_float_in Location 3\n" + "OpDecorate %rgba_float_in Location 4\n" + +decorations[ndx].fragment+ + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeFloat 32\n" + "%7 = OpTypeVector %6 4\n" + "%8 = OpTypePointer Output %7\n" + "%color_out = OpVariable %8 Output\n" + "%10 = OpTypePointer Input %7\n" + "%color_in = OpVariable %10 Input\n" + "%13 = OpTypePointer Input %6\n" + "%r_float_in = OpVariable %13 Input\n" + "%16 = OpTypeInt 32 0\n" + "%17 = OpConstant %16 0\n" + "%20 = OpTypeBool\n" + "%24 = OpConstant %6 1\n" + "%25 = OpTypePointer Output %6\n" + "%27 = OpTypeVector %6 2\n" + "%28 = OpTypePointer Input %27\n" + "%rg_float_in = OpVariable %28 Input\n" + "%33 = OpTypeVector %20 2\n" + "%38 = OpConstantComposite %27 %24 %24\n" + "%41 = OpTypeVector %6 3\n" + "%42 = OpTypePointer Input %41\n" + "%rgb_float_in = OpVariable %42 Input\n" + "%47 = OpTypeVector %20 3\n" + "%52 = OpConstantComposite %41 %24 %24 %24\n" + "%rgba_float_in = OpVariable %10 Input\n" + "%58 = OpTypeVector %20 4\n" + "%63 = OpConstantComposite %7 %24 %24 %24 %24\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%12 = OpLoad %7 %color_in\n" + "OpStore %color_out %12\n" + "%15 = OpLoad %6 %r_float_in\n" + "%18 = OpAccessChain %13 %color_in %17\n" + "%19 = OpLoad %6 %18\n" + "%21 = OpFOrdNotEqual %20 %15 %19\n" + "OpSelectionMerge %23 None\n" + "OpBranchConditional %21 %22 %23\n" + "%22 = OpLabel\n" + "%26 = OpAccessChain %25 %color_out %17\n" + "OpStore %26 %24\n" + "OpBranch %23\n" + "%23 = OpLabel\n" + "%30 = OpLoad %27 %rg_float_in\n" + "%31 = OpLoad %7 %color_in\n" + "%32 = OpVectorShuffle %27 %31 %31 0 1\n" + "%34 = OpFOrdNotEqual %33 %30 %32\n" + "%35 = OpAny %20 %34\n" + "OpSelectionMerge %37 None\n" + "OpBranchConditional %35 %36 %37\n" + "%36 = OpLabel\n" + "%39 = OpLoad %7 %color_out\n" + "%40 = OpVectorShuffle %7 %39 %38 4 5 2 3\n" + "OpStore %color_out %40\n" + "OpBranch %37\n" + "%37 = OpLabel\n" + "%44 = OpLoad %41 %rgb_float_in\n" + "%45 = OpLoad %7 %color_in\n" + "%46 = OpVectorShuffle %41 %45 %45 0 1 2\n" + "%48 = OpFOrdNotEqual %47 %44 %46\n" + "%49 = OpAny %20 %48\n" + "OpSelectionMerge %51 None\n" + "OpBranchConditional %49 %50 %51\n" + "%50 = OpLabel\n" + "%53 = OpLoad %7 %color_out\n" + "%54 = OpVectorShuffle %7 %53 %52 4 5 6 3\n" + "OpStore %color_out %54\n" + "OpBranch %51\n" + "%51 = OpLabel\n" + "%56 = OpLoad %7 %rgba_float_in\n" + "%57 = OpLoad %7 %color_in\n" + "%59 = OpFOrdNotEqual %58 %56 %57\n" + "%60 = OpAny %20 %59\n" + "OpSelectionMerge %62 None\n" + "OpBranchConditional %60 %61 %62\n" + "%61 = OpLabel\n" + "OpStore %color_out %63\n" + "OpBranch %62\n" + "%62 = OpLabel\n" + "OpReturn\n" + "OpFunctionEnd\n"; + + std::ostringstream vertex; + vertex << "vertex" << ndx; + std::ostringstream fragment; + fragment << "fragment" << ndx; + + programCollection.spirvAsmSources.add(vertex.str()) << vertexShaderSource; + programCollection.spirvAsmSources.add(fragment.str()) << fragmentShaderSource; + } + { + /*#version 450 + #extension GL_EXT_tessellation_shader : require + layout(vertices = 4) out; + layout(location = 0) in vec4 in_color[]; + layout(location = 1) in float r_float_in[]; + layout(location = 2) in vec2 rg_float_in[]; + layout(location = 3) in vec3 rgb_float_in[]; + layout(location = 4) in vec4 rgba_float_in[]; + layout(location = 0) out vec4 out_color[]; + layout(location = 1) out float r_float_out[]; + layout(location = 2) out vec2 rg_float_out[]; + layout(location = 3) out vec3 rgb_float_out[]; + layout(location = 4) out vec4 rgba_float_out[]; + void main (void) + { + if ( gl_InvocationID == 0 ) + { + gl_TessLevelInner[0] = 4.0f; + gl_TessLevelInner[1] = 4.0f; + gl_TessLevelOuter[0] = 4.0f; + gl_TessLevelOuter[1] = 4.0f; + gl_TessLevelOuter[2] = 4.0f; + gl_TessLevelOuter[3] = 4.0f; + } + out_color[gl_InvocationID] = in_color[gl_InvocationID]; + r_float_out[gl_InvocationID] = r_float_in[gl_InvocationID]; + rg_float_out[gl_InvocationID] = rg_float_in[gl_InvocationID]; + rgb_float_out[gl_InvocationID] = rgb_float_in[gl_InvocationID]; + rgba_float_out[gl_InvocationID] = rgba_float_in[gl_InvocationID]; + gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; + }*/ + + const string tessellationControlSource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 111\n" + "; Schema: 0\n" + "OpCapability Tessellation\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint TessellationControl %4 \"main\" %8 %20 %29 %color_out %color_in %r_float_out %r_float_in %rg_float_out %rg_float_in %rgb_float_out %rgb_float_in %rgba_float_out %rgba_float_in %101 %106\n" + "OpExecutionMode %4 OutputVertices 4\n" + "OpDecorate %8 BuiltIn InvocationId\n" + "OpDecorate %20 Patch\n" + "OpDecorate %20 BuiltIn TessLevelInner\n" + "OpDecorate %29 Patch\n" + "OpDecorate %29 BuiltIn TessLevelOuter\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 0\n" + "OpDecorate %r_float_out Location 1\n" + "OpDecorate %r_float_in Location 1\n" + "OpDecorate %rg_float_out Location 2\n" + "OpDecorate %rg_float_in Location 2\n" + "OpDecorate %rgb_float_out Location 3\n" + "OpDecorate %rgb_float_in Location 3\n" + "OpDecorate %rgba_float_out Location 4\n" + "OpDecorate %rgba_float_in Location 4\n" + +decorations[0].others+ + "OpMemberDecorate %98 0 BuiltIn Position\n" + "OpMemberDecorate %98 1 BuiltIn PointSize\n" + "OpMemberDecorate %98 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %98 3 BuiltIn CullDistance\n" + "OpDecorate %98 Block\n" + "OpMemberDecorate %103 0 BuiltIn Position\n" + "OpMemberDecorate %103 1 BuiltIn PointSize\n" + "OpMemberDecorate %103 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %103 3 BuiltIn CullDistance\n" + "OpDecorate %103 Block\n" + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeInt 32 1\n" + "%7 = OpTypePointer Input %6\n" + "%8 = OpVariable %7 Input\n" + "%10 = OpConstant %6 0\n" + "%11 = OpTypeBool\n" + "%15 = OpTypeFloat 32\n" + "%16 = OpTypeInt 32 0\n" + "%17 = OpConstant %16 2\n" + "%18 = OpTypeArray %15 %17\n" + "%19 = OpTypePointer Output %18\n" + "%20 = OpVariable %19 Output\n" + "%21 = OpConstant %15 4\n" + "%22 = OpTypePointer Output %15\n" + "%24 = OpConstant %6 1\n" + "%26 = OpConstant %16 4\n" + "%27 = OpTypeArray %15 %26\n" + "%28 = OpTypePointer Output %27\n" + "%29 = OpVariable %28 Output\n" + "%32 = OpConstant %6 2\n" + "%34 = OpConstant %6 3\n" + "%36 = OpTypeVector %15 4\n" + "%37 = OpTypeArray %36 %26\n" + "%38 = OpTypePointer Output %37\n" + "%color_out = OpVariable %38 Output\n" + "%41 = OpConstant %16 32\n" + "%42 = OpTypeArray %36 %41\n" + "%43 = OpTypePointer Input %42\n" + "%color_in = OpVariable %43 Input\n" + "%46 = OpTypePointer Input %36\n" + "%49 = OpTypePointer Output %36\n" + "%r_float_out = OpVariable %28 Output\n" + "%53 = OpTypeArray %15 %41\n" + "%54 = OpTypePointer Input %53\n" + "%r_float_in = OpVariable %54 Input\n" + "%57 = OpTypePointer Input %15\n" + "%61 = OpTypeVector %15 2\n" + "%62 = OpTypeArray %61 %26\n" + "%63 = OpTypePointer Output %62\n" + "%rg_float_out = OpVariable %63 Output\n" + "%66 = OpTypeArray %61 %41\n" + "%67 = OpTypePointer Input %66\n" + "%rg_float_in = OpVariable %67 Input\n" + "%70 = OpTypePointer Input %61\n" + "%73 = OpTypePointer Output %61\n" + "%75 = OpTypeVector %15 3\n" + "%76 = OpTypeArray %75 %26\n" + "%77 = OpTypePointer Output %76\n" + "%rgb_float_out = OpVariable %77 Output\n" + "%80 = OpTypeArray %75 %41\n" + "%81 = OpTypePointer Input %80\n" + "%rgb_float_in = OpVariable %81 Input\n" + "%84 = OpTypePointer Input %75\n" + "%87 = OpTypePointer Output %75\n" + "%rgba_float_out = OpVariable %38 Output\n" + "%rgba_float_in = OpVariable %43 Input\n" + "%96 = OpConstant %16 1\n" + "%97 = OpTypeArray %15 %96\n" + "%98 = OpTypeStruct %36 %15 %97 %97\n" + "%99 = OpTypeArray %98 %26\n" + "%100 = OpTypePointer Output %99\n" + "%101 = OpVariable %100 Output\n" + "%103 = OpTypeStruct %36 %15 %97 %97\n" + "%104 = OpTypeArray %103 %41\n" + "%105 = OpTypePointer Input %104\n" + "%106 = OpVariable %105 Input\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%9 = OpLoad %6 %8\n" + "%12 = OpIEqual %11 %9 %10\n" + "OpSelectionMerge %14 None\n" + "OpBranchConditional %12 %13 %14\n" + "%13 = OpLabel\n" + "%23 = OpAccessChain %22 %20 %10\n" + "OpStore %23 %21\n" + "%25 = OpAccessChain %22 %20 %24\n" + "OpStore %25 %21\n" + "%30 = OpAccessChain %22 %29 %10\n" + "OpStore %30 %21\n" + "%31 = OpAccessChain %22 %29 %24\n" + "OpStore %31 %21\n" + "%33 = OpAccessChain %22 %29 %32\n" + "OpStore %33 %21\n" + "%35 = OpAccessChain %22 %29 %34\n" + "OpStore %35 %21\n" + "OpBranch %14\n" + "%14 = OpLabel\n" + "%40 = OpLoad %6 %8\n" + "%45 = OpLoad %6 %8\n" + "%47 = OpAccessChain %46 %color_in %45\n" + "%48 = OpLoad %36 %47\n" + "%50 = OpAccessChain %49 %color_out %40\n" + "OpStore %50 %48\n" + "%52 = OpLoad %6 %8\n" + "%56 = OpLoad %6 %8\n" + "%58 = OpAccessChain %57 %r_float_in %56\n" + "%59 = OpLoad %15 %58\n" + "%60 = OpAccessChain %22 %r_float_out %52\n" + "OpStore %60 %59\n" + "%65 = OpLoad %6 %8\n" + "%69 = OpLoad %6 %8\n" + "%71 = OpAccessChain %70 %rg_float_in %69\n" + "%72 = OpLoad %61 %71\n" + "%74 = OpAccessChain %73 %rg_float_out %65\n" + "OpStore %74 %72\n" + "%79 = OpLoad %6 %8\n" + "%83 = OpLoad %6 %8\n" + "%85 = OpAccessChain %84 %rgb_float_in %83\n" + "%86 = OpLoad %75 %85\n" + "%88 = OpAccessChain %87 %rgb_float_out %79\n" + "OpStore %88 %86\n" + "%90 = OpLoad %6 %8\n" + "%92 = OpLoad %6 %8\n" + "%93 = OpAccessChain %46 %rgba_float_in %92\n" + "%94 = OpLoad %36 %93\n" + "%95 = OpAccessChain %49 %rgba_float_out %90\n" + "OpStore %95 %94\n" + "%102 = OpLoad %6 %8\n" + "%107 = OpLoad %6 %8\n" + "%108 = OpAccessChain %46 %106 %107 %10\n" + "%109 = OpLoad %36 %108\n" + "%110 = OpAccessChain %49 %101 %102 %10\n" + "OpStore %110 %109\n" + "OpReturn\n" + "OpFunctionEnd\n"; + + /*#version 450 + #extension GL_EXT_tessellation_shader : require + layout( quads, equal_spacing, ccw ) in; + layout(location = 0) in vec4 in_color[]; + layout(location = 1) in float r_float_in[]; + layout(location = 2) in vec2 rg_float_in[]; + layout(location = 3) in vec3 rgb_float_in[]; + layout(location = 4) in vec4 rgba_float_in[]; + layout(location = 0) out vec4 out_color; + layout(location = 1) out float r_float_out; + layout(location = 2) out vec2 rg_float_out; + layout(location = 3) out vec3 rgb_float_out; + layout(location = 4) out vec4 rgba_float_out; + void main (void) + { + const float u = gl_TessCoord.x; + const float v = gl_TessCoord.y; + const float w = gl_TessCoord.z; + out_color = (1 - u) * (1 - v) * in_color[0] +(1 - u) * v * in_color[1] + u * (1 - v) * in_color[2] + u * v * in_color[3]; + r_float_out = (1 - u) * (1 - v) * r_float_in[0] +(1 - u) * v * r_float_in[1] + u * (1 - v) * r_float_in[2] + u * v * r_float_in[3]; + rg_float_out = (1 - u) * (1 - v) * rg_float_in[0] +(1 - u) * v * rg_float_in[1] + u * (1 - v) * rg_float_in[2] + u * v * rg_float_in[3]; + rgb_float_out = (1 - u) * (1 - v) * rgb_float_in[0] +(1 - u) * v * rgb_float_in[1] + u * (1 - v) * rgb_float_in[2] + u * v * rgb_float_in[3]; + rgba_float_out = (1 - u) * (1 - v) * rgba_float_in[0] +(1 - u) * v * rgba_float_in[1] + u * (1 - v) * rgba_float_in[2] + u * v * rgba_float_in[3]; + gl_Position = (1 - u) * (1 - v) * gl_in[0].gl_Position +(1 - u) * v * gl_in[1].gl_Position + u * (1 - v) * gl_in[2].gl_Position + u * v * gl_in[3].gl_Position; + }*/ + + const string tessellationEvaluationSource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 253\n" + "; Schema: 0\n" + "OpCapability Tessellation\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint TessellationEvaluation %4 \"main\" %11 %color_out %color_in %r_float_out %r_float_in %rg_float_out %rg_float_in %rgb_float_out %rgb_float_in %rgba_float_out %rgba_float_in %216 %225\n" + "OpExecutionMode %4 Quads\n" + "OpExecutionMode %4 SpacingEqual\n" + "OpExecutionMode %4 VertexOrderCcw\n" + "OpDecorate %11 BuiltIn TessCoord\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 0\n" + "OpDecorate %r_float_out Location 1\n" + "OpDecorate %r_float_in Location 1\n" + "OpDecorate %rg_float_out Location 2\n" + "OpDecorate %rg_float_in Location 2\n" + "OpDecorate %rgb_float_out Location 3\n" + "OpDecorate %rgb_float_in Location 3\n" + "OpDecorate %rgba_float_out Location 4\n" + "OpDecorate %rgba_float_in Location 4\n" + +decorations[0].others+ + "OpMemberDecorate %214 0 BuiltIn Position\n" + "OpMemberDecorate %214 1 BuiltIn PointSize\n" + "OpMemberDecorate %214 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %214 3 BuiltIn CullDistance\n" + "OpDecorate %214 Block\n" + "OpMemberDecorate %222 0 BuiltIn Position\n" + "OpMemberDecorate %222 1 BuiltIn PointSize\n" + "OpMemberDecorate %222 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %222 3 BuiltIn CullDistance\n" + "OpDecorate %222 Block\n" + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeFloat 32\n" + "%7 = OpTypePointer Function %6\n" + "%9 = OpTypeVector %6 3\n" + "%10 = OpTypePointer Input %9\n" + "%11 = OpVariable %10 Input\n" + "%12 = OpTypeInt 32 0\n" + "%13 = OpConstant %12 0\n" + "%14 = OpTypePointer Input %6\n" + "%18 = OpConstant %12 1\n" + "%22 = OpConstant %12 2\n" + "%25 = OpTypeVector %6 4\n" + "%26 = OpTypePointer Output %25\n" + "%color_out = OpVariable %26 Output\n" + "%28 = OpConstant %6 1\n" + "%34 = OpConstant %12 32\n" + "%35 = OpTypeArray %25 %34\n" + "%36 = OpTypePointer Input %35\n" + "%color_in = OpVariable %36 Input\n" + "%38 = OpTypeInt 32 1\n" + "%39 = OpConstant %38 0\n" + "%40 = OpTypePointer Input %25\n" + "%48 = OpConstant %38 1\n" + "%57 = OpConstant %38 2\n" + "%65 = OpConstant %38 3\n" + "%70 = OpTypePointer Output %6\n" + "%r_float_out = OpVariable %70 Output\n" + "%77 = OpTypeArray %6 %34\n" + "%78 = OpTypePointer Input %77\n" + "%r_float_in = OpVariable %78 Input\n" + "%106 = OpTypeVector %6 2\n" + "%107 = OpTypePointer Output %106\n" + "%rg_float_out = OpVariable %107 Output\n" + "%114 = OpTypeArray %106 %34\n" + "%115 = OpTypePointer Input %114\n" + "%rg_float_in = OpVariable %115 Input\n" + "%117 = OpTypePointer Input %106\n" + "%144 = OpTypePointer Output %9\n" + "%rgb_float_out = OpVariable %144 Output\n" + "%151 = OpTypeArray %9 %34\n" + "%152 = OpTypePointer Input %151\n" + "%rgb_float_in = OpVariable %152 Input\n" + "%rgba_float_out = OpVariable %26 Output\n" + "%rgba_float_in = OpVariable %36 Input\n" + "%213 = OpTypeArray %6 %18\n" + "%214 = OpTypeStruct %25 %6 %213 %213\n" + "%215 = OpTypePointer Output %214\n" + "%216 = OpVariable %215 Output\n" + "%222 = OpTypeStruct %25 %6 %213 %213\n" + "%223 = OpTypeArray %222 %34\n" + "%224 = OpTypePointer Input %223\n" + "%225 = OpVariable %224 Input\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%8 = OpVariable %7 Function\n" + "%17 = OpVariable %7 Function\n" + "%21 = OpVariable %7 Function\n" + "%15 = OpAccessChain %14 %11 %13\n" + "%16 = OpLoad %6 %15\n" + "OpStore %8 %16\n" + "%19 = OpAccessChain %14 %11 %18\n" + "%20 = OpLoad %6 %19\n" + "OpStore %17 %20\n" + "%23 = OpAccessChain %14 %11 %22\n" + "%24 = OpLoad %6 %23\n" + "OpStore %21 %24\n" + "%29 = OpLoad %6 %8\n" + "%30 = OpFSub %6 %28 %29\n" + "%31 = OpLoad %6 %17\n" + "%32 = OpFSub %6 %28 %31\n" + "%33 = OpFMul %6 %30 %32\n" + "%41 = OpAccessChain %40 %color_in %39\n" + "%42 = OpLoad %25 %41\n" + "%43 = OpVectorTimesScalar %25 %42 %33\n" + "%44 = OpLoad %6 %8\n" + "%45 = OpFSub %6 %28 %44\n" + "%46 = OpLoad %6 %17\n" + "%47 = OpFMul %6 %45 %46\n" + "%49 = OpAccessChain %40 %color_in %48\n" + "%50 = OpLoad %25 %49\n" + "%51 = OpVectorTimesScalar %25 %50 %47\n" + "%52 = OpFAdd %25 %43 %51\n" + "%53 = OpLoad %6 %8\n" + "%54 = OpLoad %6 %17\n" + "%55 = OpFSub %6 %28 %54\n" + "%56 = OpFMul %6 %53 %55\n" + "%58 = OpAccessChain %40 %color_in %57\n" + "%59 = OpLoad %25 %58\n" + "%60 = OpVectorTimesScalar %25 %59 %56\n" + "%61 = OpFAdd %25 %52 %60\n" + "%62 = OpLoad %6 %8\n" + "%63 = OpLoad %6 %17\n" + "%64 = OpFMul %6 %62 %63\n" + "%66 = OpAccessChain %40 %color_in %65\n" + "%67 = OpLoad %25 %66\n" + "%68 = OpVectorTimesScalar %25 %67 %64\n" + "%69 = OpFAdd %25 %61 %68\n" + "OpStore %color_out %69\n" + "%72 = OpLoad %6 %8\n" + "%73 = OpFSub %6 %28 %72\n" + "%74 = OpLoad %6 %17\n" + "%75 = OpFSub %6 %28 %74\n" + "%76 = OpFMul %6 %73 %75\n" + "%80 = OpAccessChain %14 %r_float_in %39\n" + "%81 = OpLoad %6 %80\n" + "%82 = OpFMul %6 %76 %81\n" + "%83 = OpLoad %6 %8\n" + "%84 = OpFSub %6 %28 %83\n" + "%85 = OpLoad %6 %17\n" + "%86 = OpFMul %6 %84 %85\n" + "%87 = OpAccessChain %14 %r_float_in %48\n" + "%88 = OpLoad %6 %87\n" + "%89 = OpFMul %6 %86 %88\n" + "%90 = OpFAdd %6 %82 %89\n" + "%91 = OpLoad %6 %8\n" + "%92 = OpLoad %6 %17\n" + "%93 = OpFSub %6 %28 %92\n" + "%94 = OpFMul %6 %91 %93\n" + "%95 = OpAccessChain %14 %r_float_in %57\n" + "%96 = OpLoad %6 %95\n" + "%97 = OpFMul %6 %94 %96\n" + "%98 = OpFAdd %6 %90 %97\n" + "%99 = OpLoad %6 %8\n" + "%100 = OpLoad %6 %17\n" + "%101 = OpFMul %6 %99 %100\n" + "%102 = OpAccessChain %14 %r_float_in %65\n" + "%103 = OpLoad %6 %102\n" + "%104 = OpFMul %6 %101 %103\n" + "%105 = OpFAdd %6 %98 %104\n" + "OpStore %r_float_out %105\n" + "%109 = OpLoad %6 %8\n" + "%110 = OpFSub %6 %28 %109\n" + "%111 = OpLoad %6 %17\n" + "%112 = OpFSub %6 %28 %111\n" + "%113 = OpFMul %6 %110 %112\n" + "%118 = OpAccessChain %117 %rg_float_in %39\n" + "%119 = OpLoad %106 %118\n" + "%120 = OpVectorTimesScalar %106 %119 %113\n" + "%121 = OpLoad %6 %8\n" + "%122 = OpFSub %6 %28 %121\n" + "%123 = OpLoad %6 %17\n" + "%124 = OpFMul %6 %122 %123\n" + "%125 = OpAccessChain %117 %rg_float_in %48\n" + "%126 = OpLoad %106 %125\n" + "%127 = OpVectorTimesScalar %106 %126 %124\n" + "%128 = OpFAdd %106 %120 %127\n" + "%129 = OpLoad %6 %8\n" + "%130 = OpLoad %6 %17\n" + "%131 = OpFSub %6 %28 %130\n" + "%132 = OpFMul %6 %129 %131\n" + "%133 = OpAccessChain %117 %rg_float_in %57\n" + "%134 = OpLoad %106 %133\n" + "%135 = OpVectorTimesScalar %106 %134 %132\n" + "%136 = OpFAdd %106 %128 %135\n" + "%137 = OpLoad %6 %8\n" + "%138 = OpLoad %6 %17\n" + "%139 = OpFMul %6 %137 %138\n" + "%140 = OpAccessChain %117 %rg_float_in %65\n" + "%141 = OpLoad %106 %140\n" + "%142 = OpVectorTimesScalar %106 %141 %139\n" + "%143 = OpFAdd %106 %136 %142\n" + "OpStore %rg_float_out %143\n" + "%146 = OpLoad %6 %8\n" + "%147 = OpFSub %6 %28 %146\n" + "%148 = OpLoad %6 %17\n" + "%149 = OpFSub %6 %28 %148\n" + "%150 = OpFMul %6 %147 %149\n" + "%154 = OpAccessChain %10 %rgb_float_in %39\n" + "%155 = OpLoad %9 %154\n" + "%156 = OpVectorTimesScalar %9 %155 %150\n" + "%157 = OpLoad %6 %8\n" + "%158 = OpFSub %6 %28 %157\n" + "%159 = OpLoad %6 %17\n" + "%160 = OpFMul %6 %158 %159\n" + "%161 = OpAccessChain %10 %rgb_float_in %48\n" + "%162 = OpLoad %9 %161\n" + "%163 = OpVectorTimesScalar %9 %162 %160\n" + "%164 = OpFAdd %9 %156 %163\n" + "%165 = OpLoad %6 %8\n" + "%166 = OpLoad %6 %17\n" + "%167 = OpFSub %6 %28 %166\n" + "%168 = OpFMul %6 %165 %167\n" + "%169 = OpAccessChain %10 %rgb_float_in %57\n" + "%170 = OpLoad %9 %169\n" + "%171 = OpVectorTimesScalar %9 %170 %168\n" + "%172 = OpFAdd %9 %164 %171\n" + "%173 = OpLoad %6 %8\n" + "%174 = OpLoad %6 %17\n" + "%175 = OpFMul %6 %173 %174\n" + "%176 = OpAccessChain %10 %rgb_float_in %65\n" + "%177 = OpLoad %9 %176\n" + "%178 = OpVectorTimesScalar %9 %177 %175\n" + "%179 = OpFAdd %9 %172 %178\n" + "OpStore %rgb_float_out %179\n" + "%181 = OpLoad %6 %8\n" + "%182 = OpFSub %6 %28 %181\n" + "%183 = OpLoad %6 %17\n" + "%184 = OpFSub %6 %28 %183\n" + "%185 = OpFMul %6 %182 %184\n" + "%187 = OpAccessChain %40 %rgba_float_in %39\n" + "%188 = OpLoad %25 %187\n" + "%189 = OpVectorTimesScalar %25 %188 %185\n" + "%190 = OpLoad %6 %8\n" + "%191 = OpFSub %6 %28 %190\n" + "%192 = OpLoad %6 %17\n" + "%193 = OpFMul %6 %191 %192\n" + "%194 = OpAccessChain %40 %rgba_float_in %48\n" + "%195 = OpLoad %25 %194\n" + "%196 = OpVectorTimesScalar %25 %195 %193\n" + "%197 = OpFAdd %25 %189 %196\n" + "%198 = OpLoad %6 %8\n" + "%199 = OpLoad %6 %17\n" + "%200 = OpFSub %6 %28 %199\n" + "%201 = OpFMul %6 %198 %200\n" + "%202 = OpAccessChain %40 %rgba_float_in %57\n" + "%203 = OpLoad %25 %202\n" + "%204 = OpVectorTimesScalar %25 %203 %201\n" + "%205 = OpFAdd %25 %197 %204\n" + "%206 = OpLoad %6 %8\n" + "%207 = OpLoad %6 %17\n" + "%208 = OpFMul %6 %206 %207\n" + "%209 = OpAccessChain %40 %rgba_float_in %65\n" + "%210 = OpLoad %25 %209\n" + "%211 = OpVectorTimesScalar %25 %210 %208\n" + "%212 = OpFAdd %25 %205 %211\n" + "OpStore %rgba_float_out %212\n" + "%217 = OpLoad %6 %8\n" + "%218 = OpFSub %6 %28 %217\n" + "%219 = OpLoad %6 %17\n" + "%220 = OpFSub %6 %28 %219\n" + "%221 = OpFMul %6 %218 %220\n" + "%226 = OpAccessChain %40 %225 %39 %39\n" + "%227 = OpLoad %25 %226\n" + "%228 = OpVectorTimesScalar %25 %227 %221\n" + "%229 = OpLoad %6 %8\n" + "%230 = OpFSub %6 %28 %229\n" + "%231 = OpLoad %6 %17\n" + "%232 = OpFMul %6 %230 %231\n" + "%233 = OpAccessChain %40 %225 %48 %39\n" + "%234 = OpLoad %25 %233\n" + "%235 = OpVectorTimesScalar %25 %234 %232\n" + "%236 = OpFAdd %25 %228 %235\n" + "%237 = OpLoad %6 %8\n" + "%238 = OpLoad %6 %17\n" + "%239 = OpFSub %6 %28 %238\n" + "%240 = OpFMul %6 %237 %239\n" + "%241 = OpAccessChain %40 %225 %57 %39\n" + "%242 = OpLoad %25 %241\n" + "%243 = OpVectorTimesScalar %25 %242 %240\n" + "%244 = OpFAdd %25 %236 %243\n" + "%245 = OpLoad %6 %8\n" + "%246 = OpLoad %6 %17\n" + "%247 = OpFMul %6 %245 %246\n" + "%248 = OpAccessChain %40 %225 %65 %39\n" + "%249 = OpLoad %25 %248\n" + "%250 = OpVectorTimesScalar %25 %249 %247\n" + "%251 = OpFAdd %25 %244 %250\n" + "%252 = OpAccessChain %26 %216 %39\n" + "OpStore %252 %251\n" + "OpReturn\n" + "OpFunctionEnd\n"; + programCollection.spirvAsmSources.add("tessellation_control") << tessellationControlSource; + programCollection.spirvAsmSources.add("tessellation_evaluation") << tessellationEvaluationSource; + } + { + + /*#version 450 + layout(triangles) in; + layout(triangle_strip, max_vertices = 3) out; + layout(location = 0) in vec4 in_color[]; + layout(location = 1) in float r_float_in[]; + layout(location = 2) in vec2 rg_float_in[]; + layout(location = 3) in vec3 rgb_float_in[]; + layout(location = 4) in vec4 rgba_float_in[]; + layout(location = 0) out vec4 out_color; + layout(location = 1) out float r_float_out; + layout(location = 2) out vec2 rg_float_out; + layout(location = 3) out vec3 rgb_float_out; + layout(location = 4) out vec4 rgba_float_out; + void main (void) + { + out_color = in_color[0]; + r_float_out = r_float_in[0]; + rg_float_out = rg_float_in[0]; + rgb_float_out = rgb_float_in[0]; + rgba_float_out = rgba_float_in[0]; + gl_Position = gl_in[0].gl_Position; + EmitVertex(); + out_color = in_color[1]; + r_float_out = r_float_in[1]; + rg_float_out = rg_float_in[1]; + rgb_float_out = rgb_float_in[1]; + rgba_float_out = rgba_float_in[1]; + gl_Position = gl_in[1].gl_Position; + EmitVertex(); + out_color = in_color[2]; + r_float_out = r_float_in[2]; + rg_float_out = rg_float_in[2]; + rgb_float_out = rgb_float_in[2]; + rgba_float_out = rgba_float_in[2]; + gl_Position = gl_in[2].gl_Position; + EmitVertex(); + EndPrimitive(); + } + */ + const string geometrySource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 90\n" + "; Schema: 0\n" + "OpCapability Geometry\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Geometry %4 \"main\" %color_out %color_in %r_float_out %r_float_in %rg_float_out %rg_float_in %rgb_float_out %rgb_float_in %rgba_float_out %rgba_float_in %54 %58\n" + "OpExecutionMode %4 Triangles\n" + "OpExecutionMode %4 Invocations 1\n" + "OpExecutionMode %4 OutputTriangleStrip\n" + "OpExecutionMode %4 OutputVertices 3\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 0\n" + "OpDecorate %r_float_out Location 1\n" + "OpDecorate %r_float_in Location 1\n" + "OpDecorate %rg_float_out Location 2\n" + "OpDecorate %rg_float_in Location 2\n" + "OpDecorate %rgb_float_out Location 3\n" + "OpDecorate %rgb_float_in Location 3\n" + "OpDecorate %rgba_float_out Location 4\n" + "OpDecorate %rgba_float_in Location 4\n" + +decorations[0].others+ + "OpMemberDecorate %52 0 BuiltIn Position\n" + "OpMemberDecorate %52 1 BuiltIn PointSize\n" + "OpMemberDecorate %52 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %52 3 BuiltIn CullDistance\n" + "OpDecorate %52 Block\n" + "OpMemberDecorate %55 0 BuiltIn Position\n" + "OpMemberDecorate %55 1 BuiltIn PointSize\n" + "OpMemberDecorate %55 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %55 3 BuiltIn CullDistance\n" + "OpDecorate %55 Block\n" + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeFloat 32\n" + "%7 = OpTypeVector %6 4\n" + "%8 = OpTypePointer Output %7\n" + "%color_out = OpVariable %8 Output\n" + "%10 = OpTypeInt 32 0\n" + "%11 = OpConstant %10 3\n" + "%12 = OpTypeArray %7 %11\n" + "%13 = OpTypePointer Input %12\n" + "%color_in = OpVariable %13 Input\n" + "%15 = OpTypeInt 32 1\n" + "%16 = OpConstant %15 0\n" + "%17 = OpTypePointer Input %7\n" + "%20 = OpTypePointer Output %6\n" + "%r_float_out = OpVariable %20 Output\n" + "%22 = OpTypeArray %6 %11\n" + "%23 = OpTypePointer Input %22\n" + "%r_float_in = OpVariable %23 Input\n" + "%25 = OpTypePointer Input %6\n" + "%28 = OpTypeVector %6 2\n" + "%29 = OpTypePointer Output %28\n" + "%rg_float_out = OpVariable %29 Output\n" + "%31 = OpTypeArray %28 %11\n" + "%32 = OpTypePointer Input %31\n" + "%rg_float_in = OpVariable %32 Input\n" + "%34 = OpTypePointer Input %28\n" + "%37 = OpTypeVector %6 3\n" + "%38 = OpTypePointer Output %37\n" + "%rgb_float_out = OpVariable %38 Output\n" + "%40 = OpTypeArray %37 %11\n" + "%41 = OpTypePointer Input %40\n" + "%rgb_float_in = OpVariable %41 Input\n" + "%43 = OpTypePointer Input %37\n" + "%rgba_float_out = OpVariable %8 Output\n" + "%rgba_float_in = OpVariable %13 Input\n" + "%50 = OpConstant %10 1\n" + "%51 = OpTypeArray %6 %50\n" + "%52 = OpTypeStruct %7 %6 %51 %51\n" + "%53 = OpTypePointer Output %52\n" + "%54 = OpVariable %53 Output\n" + "%55 = OpTypeStruct %7 %6 %51 %51\n" + "%56 = OpTypeArray %55 %11\n" + "%57 = OpTypePointer Input %56\n" + "%58 = OpVariable %57 Input\n" + "%62 = OpConstant %15 1\n" + "%76 = OpConstant %15 2\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%18 = OpAccessChain %17 %color_in %16\n" + "%19 = OpLoad %7 %18\n" + "OpStore %color_out %19\n" + "%26 = OpAccessChain %25 %r_float_in %16\n" + "%27 = OpLoad %6 %26\n" + "OpStore %r_float_out %27\n" + "%35 = OpAccessChain %34 %rg_float_in %16\n" + "%36 = OpLoad %28 %35\n" + "OpStore %rg_float_out %36\n" + "%44 = OpAccessChain %43 %rgb_float_in %16\n" + "%45 = OpLoad %37 %44\n" + "OpStore %rgb_float_out %45\n" + "%48 = OpAccessChain %17 %rgba_float_in %16\n" + "%49 = OpLoad %7 %48\n" + "OpStore %rgba_float_out %49\n" + "%59 = OpAccessChain %17 %58 %16 %16\n" + "%60 = OpLoad %7 %59\n" + "%61 = OpAccessChain %8 %54 %16\n" + "OpStore %61 %60\n" + "OpEmitVertex\n" + "%63 = OpAccessChain %17 %color_in %62\n" + "%64 = OpLoad %7 %63\n" + "OpStore %color_out %64\n" + "%65 = OpAccessChain %25 %r_float_in %62\n" + "%66 = OpLoad %6 %65\n" + "OpStore %r_float_out %66\n" + "%67 = OpAccessChain %34 %rg_float_in %62\n" + "%68 = OpLoad %28 %67\n" + "OpStore %rg_float_out %68\n" + "%69 = OpAccessChain %43 %rgb_float_in %62\n" + "%70 = OpLoad %37 %69\n" + "OpStore %rgb_float_out %70\n" + "%71 = OpAccessChain %17 %rgba_float_in %62\n" + "%72 = OpLoad %7 %71\n" + "OpStore %rgba_float_out %72\n" + "%73 = OpAccessChain %17 %58 %62 %16\n" + "%74 = OpLoad %7 %73\n" + "%75 = OpAccessChain %8 %54 %16\n" + "OpStore %75 %74\n" + "OpEmitVertex\n" + "%77 = OpAccessChain %17 %color_in %76\n" + "%78 = OpLoad %7 %77\n" + "OpStore %color_out %78\n" + "%79 = OpAccessChain %25 %r_float_in %76\n" + "%80 = OpLoad %6 %79\n" + "OpStore %r_float_out %80\n" + "%81 = OpAccessChain %34 %rg_float_in %76\n" + "%82 = OpLoad %28 %81\n" + "OpStore %rg_float_out %82\n" + "%83 = OpAccessChain %43 %rgb_float_in %76\n" + "%84 = OpLoad %37 %83\n" + "OpStore %rgb_float_out %84\n" + "%85 = OpAccessChain %17 %rgba_float_in %76\n" + "%86 = OpLoad %7 %85\n" + "OpStore %rgba_float_out %86\n" + "%87 = OpAccessChain %17 %58 %76 %16\n" + "%88 = OpLoad %7 %87\n" + "%89 = OpAccessChain %8 %54 %16\n" + "OpStore %89 %88\n" + "OpEmitVertex\n" + "OpEndPrimitive\n" + "OpReturn\n" + "OpFunctionEnd\n"; + programCollection.spirvAsmSources.add("geometry") << geometrySource; + } +} + +class CrossStageInterfaceTestsCase : public vkt::TestCase +{ +public: + CrossStageInterfaceTestsCase (tcu::TestContext &context, const char *name, const char *description, const TestParameters& parameters) + : TestCase (context, name, description) + , m_parameters (parameters) + { + } +private: + vkt::TestInstance* createInstance (vkt::Context& context) const; + void initPrograms (SourceCollections& programCollection) const; + + const TestParameters m_parameters; + +}; + +vkt::TestInstance* CrossStageInterfaceTestsCase::createInstance (vkt::Context& context) const +{ + return new CrossStageTestInstance(context, m_parameters); +} + +void CrossStageInterfaceTestsCase::initPrograms (SourceCollections& programCollection) const +{ + vector decorations; + switch(m_parameters.qualifier) + { + case TEST_TYPE_FLAT: + decorations.push_back(Decorations("", + //Vertex + "OpDecorate %color_out Flat\n" + "OpDecorate %color_in Flat\n" + "OpMemberDecorate %block_out 0 Flat\n" + "OpMemberDecorate %block_out 1 Flat\n", + "")); + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in Flat\n" + "OpMemberDecorate %block_in 0 Flat\n" + "OpMemberDecorate %block_in 1 Flat\n", + "", + "")); + + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in Flat\n" + "OpMemberDecorate %block_in 0 Flat\n" + "OpMemberDecorate %block_in 1 Flat\n", + //Vertex + "OpDecorate %color_out Flat\n" + "OpDecorate %color_in Flat\n" + "OpMemberDecorate %block_out 0 Flat\n" + "OpMemberDecorate %block_out 1 Flat\n", + "")); + break; + case TEST_TYPE_NOPERSPECTIVE: + decorations.push_back(Decorations("", + //Vertex + "OpDecorate %color_out NoPerspective\n" + "OpDecorate %color_in NoPerspective\n" + "OpMemberDecorate %block_out 0 NoPerspective\n" + "OpMemberDecorate %block_out 1 NoPerspective\n", + "")); + + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in NoPerspective\n" + "OpMemberDecorate %block_in 0 NoPerspective\n" + "OpMemberDecorate %block_in 1 NoPerspective\n", + "", + "")); + + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in NoPerspective\n" + "OpMemberDecorate %block_in 0 NoPerspective\n" + "OpMemberDecorate %block_in 1 NoPerspective\n", + //Vertex + "OpDecorate %color_out NoPerspective\n" + "OpDecorate %color_in NoPerspective\n" + "OpMemberDecorate %block_out 0 NoPerspective\n" + "OpMemberDecorate %block_out 1 NoPerspective\n", + "")); + break; + case TEST_TYPE_RELAXEDPRECISION: + decorations.push_back(Decorations(//Fragment + "OpDecorate %color_in RelaxedPrecision\n" + "OpDecorate %color_out RelaxedPrecision\n" + "OpMemberDecorate %block_in 0 RelaxedPrecision\n" + "OpMemberDecorate %block_in 1 RelaxedPrecision\n", + //Vertex + "OpDecorate %color_out RelaxedPrecision\n" + "OpDecorate %color_in RelaxedPrecision\n" + "OpMemberDecorate %block_out 0 RelaxedPrecision\n" + "OpMemberDecorate %block_out 1 RelaxedPrecision\n", + //Others + "OpDecorate %color_out RelaxedPrecision\n" + "OpDecorate %color_in RelaxedPrecision\n" + "OpMemberDecorate %block_out 0 RelaxedPrecision\n" + "OpMemberDecorate %block_out 1 RelaxedPrecision\n" + "OpMemberDecorate %block_in 0 RelaxedPrecision\n" + "OpMemberDecorate %block_in 1 RelaxedPrecision\n")); + break; + default: + DE_ASSERT(0); + } + + //Spir-v spec: decoration flat can be used only in Shader (fragment or vertex) + for (deUint32 ndx = 0; ndx < decorations.size(); ++ndx) + { + + /*#version 450 + #version 450 + layout(location = 0) in highp vec4 in_position; + layout(location = 1) in vec4 in_color; + layout(location = 0) out vec4 out_color; + layout(location = 1) out ColorData + { + vec4 colorVec; + mat2 colorMat; + } outData; + void main (void) + { + gl_Position = in_position; + out_color = in_color; + outData.colorVec = in_color; + outData.colorMat = mat2(in_color.r, in_color.g, in_color.b, in_color.a); + } + */ + const string vertexShaderSource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 51\n" + "; Schema: 0\n" + "OpCapability Shader\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Vertex %4 \"main\" %13 %17 %color_out %color_in %28\n" + "OpMemberDecorate %11 0 BuiltIn Position\n" + "OpMemberDecorate %11 1 BuiltIn PointSize\n" + "OpMemberDecorate %11 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %11 3 BuiltIn CullDistance\n" + "OpDecorate %11 Block\n" + "OpDecorate %17 Location 0\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 1\n" + "OpDecorate %block_out Block\n" + "OpDecorate %28 Location 1\n" + +decorations[ndx].vertex+ + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeFloat 32\n" + "%7 = OpTypeVector %6 4\n" + "%8 = OpTypeInt 32 0\n" + "%9 = OpConstant %8 1\n" + "%10 = OpTypeArray %6 %9\n" + "%11 = OpTypeStruct %7 %6 %10 %10\n" + "%12 = OpTypePointer Output %11\n" + "%13 = OpVariable %12 Output\n" + "%14 = OpTypeInt 32 1\n" + "%15 = OpConstant %14 0\n" + "%16 = OpTypePointer Input %7\n" + "%17 = OpVariable %16 Input\n" + "%19 = OpTypePointer Output %7\n" + "%color_out = OpVariable %19 Output\n" + "%color_in = OpVariable %16 Input\n" + "%24 = OpTypeVector %6 2\n" + "%25 = OpTypeMatrix %24 2\n" + "%block_out = OpTypeStruct %7 %25\n" + "%27 = OpTypePointer Output %block_out\n" + "%28 = OpVariable %27 Output\n" + "%31 = OpConstant %14 1\n" + "%32 = OpConstant %8 0\n" + "%33 = OpTypePointer Input %6\n" + "%38 = OpConstant %8 2\n" + "%41 = OpConstant %8 3\n" + "%44 = OpConstant %6 1\n" + "%45 = OpConstant %6 0\n" + "%49 = OpTypePointer Output %25\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%18 = OpLoad %7 %17\n" + "%20 = OpAccessChain %19 %13 %15\n" + "OpStore %20 %18\n" + "%23 = OpLoad %7 %color_in\n" + "OpStore %color_out %23\n" + "%29 = OpLoad %7 %color_in\n" + "%30 = OpAccessChain %19 %28 %15\n" + "OpStore %30 %29\n" + "%34 = OpAccessChain %33 %color_in %32\n" + "%35 = OpLoad %6 %34\n" + "%36 = OpAccessChain %33 %color_in %9\n" + "%37 = OpLoad %6 %36\n" + "%39 = OpAccessChain %33 %color_in %38\n" + "%40 = OpLoad %6 %39\n" + "%42 = OpAccessChain %33 %color_in %41\n" + "%43 = OpLoad %6 %42\n" + "%46 = OpCompositeConstruct %24 %35 %37\n" + "%47 = OpCompositeConstruct %24 %40 %43\n" + "%48 = OpCompositeConstruct %25 %46 %47\n" + "%50 = OpAccessChain %49 %28 %31\n" + "OpStore %50 %48\n" + "OpReturn\n" + "OpFunctionEnd\n"; + + /* #version 450 + layout(location = 0) in vec4 in_color; + layout(location = 0) out vec4 out_color; + layout(location = 1) in ColorData + { + vec4 colorVec; + mat2 colorMat; + } inData; + void main() + { + out_color = in_color; + if(inData.colorVec != in_color) + out_color.rgba = vec4(1.0f); + if(inData.colorMat[0][0] != in_color.r) + out_color.rgba = vec4(1.0f); + if(inData.colorMat[1][1] != in_color.a) + out_color.rgba = vec4(1.0f); + } + */ + const string fragmentShaderSource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 51\n" + "; Schema: 0\n" + "OpCapability Shader\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Fragment %4 \"main\" %color_out %color_in %17\n" + "OpExecutionMode %4 OriginUpperLeft\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 0\n" + "OpDecorate %block_in Block\n" + "OpDecorate %17 Location 1\n" + +decorations[ndx].fragment+ + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeFloat 32\n" + "%7 = OpTypeVector %6 4\n" + "%8 = OpTypePointer Output %7\n" + "%color_out = OpVariable %8 Output\n" + "%10 = OpTypePointer Input %7\n" + "%color_in = OpVariable %10 Input\n" + "%13 = OpTypeVector %6 2\n" + "%14 = OpTypeMatrix %13 2\n" + "%block_in = OpTypeStruct %7 %14\n" + "%16 = OpTypePointer Input %block_in\n" + "%17 = OpVariable %16 Input\n" + "%18 = OpTypeInt 32 1\n" + "%19 = OpConstant %18 0\n" + "%23 = OpTypeBool\n" + "%24 = OpTypeVector %23 4\n" + "%29 = OpConstant %6 1\n" + "%30 = OpConstantComposite %7 %29 %29 %29 %29\n" + "%31 = OpConstant %18 1\n" + "%32 = OpTypeInt 32 0\n" + "%33 = OpConstant %32 0\n" + "%34 = OpTypePointer Input %6\n" + "%42 = OpConstant %32 1\n" + "%45 = OpConstant %32 3\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%12 = OpLoad %7 %color_in\n" + "OpStore %color_out %12\n" + "%20 = OpAccessChain %10 %17 %19\n" + "%21 = OpLoad %7 %20\n" + "%22 = OpLoad %7 %color_in\n" + "%25 = OpFOrdNotEqual %24 %21 %22\n" + "%26 = OpAny %23 %25\n" + "OpSelectionMerge %28 None\n" + "OpBranchConditional %26 %27 %28\n" + "%27 = OpLabel\n" + "OpStore %color_out %30\n" + "OpBranch %28\n" + "%28 = OpLabel\n" + "%35 = OpAccessChain %34 %17 %31 %19 %33\n" + "%36 = OpLoad %6 %35\n" + "%37 = OpAccessChain %34 %color_in %33\n" + "%38 = OpLoad %6 %37\n" + "%39 = OpFOrdNotEqual %23 %36 %38\n" + "OpSelectionMerge %41 None\n" + "OpBranchConditional %39 %40 %41\n" + "%40 = OpLabel\n" + "OpStore %color_out %30\n" + "OpBranch %41\n" + "%41 = OpLabel\n" + "%43 = OpAccessChain %34 %17 %31 %31 %42\n" + "%44 = OpLoad %6 %43\n" + "%46 = OpAccessChain %34 %color_in %45\n" + "%47 = OpLoad %6 %46\n" + "%48 = OpFOrdNotEqual %23 %44 %47\n" + "OpSelectionMerge %50 None\n" + "OpBranchConditional %48 %49 %50\n" + "%49 = OpLabel\n" + "OpStore %color_out %30\n" + "OpBranch %50\n" + "%50 = OpLabel\n" + "OpReturn\n" + "OpFunctionEnd\n"; + + std::ostringstream vertex; + vertex << "vertex" << ndx; + std::ostringstream fragment; + fragment << "fragment" << ndx; + + programCollection.spirvAsmSources.add(vertex.str()) << vertexShaderSource; + programCollection.spirvAsmSources.add(fragment.str()) << fragmentShaderSource; + } + { + /*#version 450 + #extension GL_EXT_tessellation_shader : require + layout(vertices = 4) out; + layout(location = 0) in vec4 in_color[]; + layout(location = 1) in ColorData + { + vec4 colorVec; + mat2 colorMat; + } inData[]; + layout(location = 0) out vec4 out_color[]; + layout(location = 1) out ColorData + { + vec4 colorVec; + mat2 colorMat; + } outData[]; + void main (void) + { + if ( gl_InvocationID == 0 ) + { + gl_TessLevelInner[0] = 4.0f; + gl_TessLevelInner[1] = 4.0f; + gl_TessLevelOuter[0] = 4.0f; + gl_TessLevelOuter[1] = 4.0f; + gl_TessLevelOuter[2] = 4.0f; + gl_TessLevelOuter[3] = 4.0f; + } + out_color[gl_InvocationID] = in_color[gl_InvocationID]; + outData[gl_InvocationID].colorVec = inData[gl_InvocationID].colorVec; + outData[gl_InvocationID].colorMat = inData[gl_InvocationID].colorMat; + gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; + }*/ + + const string tessellationControlSource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 88\n" + "; Schema: 0\n" + "OpCapability Tessellation\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint TessellationControl %4 \"main\" %8 %20 %29 %color_out %color_in %56 %61 %78 %83\n" + "OpExecutionMode %4 OutputVertices 4\n" + "OpDecorate %8 BuiltIn InvocationId\n" + "OpDecorate %20 Patch\n" + "OpDecorate %20 BuiltIn TessLevelInner\n" + "OpDecorate %29 Patch\n" + "OpDecorate %29 BuiltIn TessLevelOuter\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 0\n" + "OpDecorate %block_out Block\n" + "OpDecorate %56 Location 1\n" + "OpDecorate %block_in Block\n" + "OpDecorate %61 Location 1\n" + +decorations[0].others+ + "OpMemberDecorate %75 0 BuiltIn Position\n" + "OpMemberDecorate %75 1 BuiltIn PointSize\n" + "OpMemberDecorate %75 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %75 3 BuiltIn CullDistance\n" + "OpDecorate %75 Block\n" + "OpMemberDecorate %80 0 BuiltIn Position\n" + "OpMemberDecorate %80 1 BuiltIn PointSize\n" + "OpMemberDecorate %80 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %80 3 BuiltIn CullDistance\n" + "OpDecorate %80 Block\n" + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeInt 32 1\n" + "%7 = OpTypePointer Input %6\n" + "%8 = OpVariable %7 Input\n" + "%10 = OpConstant %6 0\n" + "%11 = OpTypeBool\n" + "%15 = OpTypeFloat 32\n" + "%16 = OpTypeInt 32 0\n" + "%17 = OpConstant %16 2\n" + "%18 = OpTypeArray %15 %17\n" + "%19 = OpTypePointer Output %18\n" + "%20 = OpVariable %19 Output\n" + "%21 = OpConstant %15 4\n" + "%22 = OpTypePointer Output %15\n" + "%24 = OpConstant %6 1\n" + "%26 = OpConstant %16 4\n" + "%27 = OpTypeArray %15 %26\n" + "%28 = OpTypePointer Output %27\n" + "%29 = OpVariable %28 Output\n" + "%32 = OpConstant %6 2\n" + "%34 = OpConstant %6 3\n" + "%36 = OpTypeVector %15 4\n" + "%37 = OpTypeArray %36 %26\n" + "%38 = OpTypePointer Output %37\n" + "%color_out = OpVariable %38 Output\n" + "%41 = OpConstant %16 32\n" + "%42 = OpTypeArray %36 %41\n" + "%43 = OpTypePointer Input %42\n" + "%color_in = OpVariable %43 Input\n" + "%46 = OpTypePointer Input %36\n" + "%49 = OpTypePointer Output %36\n" + "%51 = OpTypeVector %15 2\n" + "%52 = OpTypeMatrix %51 2\n" + "%block_out = OpTypeStruct %36 %52\n" + "%54 = OpTypeArray %block_out %26\n" + "%55 = OpTypePointer Output %54\n" + "%56 = OpVariable %55 Output\n" + "%block_in = OpTypeStruct %36 %52\n" + "%59 = OpTypeArray %block_in %41\n" + "%60 = OpTypePointer Input %59\n" + "%61 = OpVariable %60 Input\n" + "%68 = OpTypePointer Input %52\n" + "%71 = OpTypePointer Output %52\n" + "%73 = OpConstant %16 1\n" + "%74 = OpTypeArray %15 %73\n" + "%75 = OpTypeStruct %36 %15 %74 %74\n" + "%76 = OpTypeArray %75 %26\n" + "%77 = OpTypePointer Output %76\n" + "%78 = OpVariable %77 Output\n" + "%80 = OpTypeStruct %36 %15 %74 %74\n" + "%81 = OpTypeArray %80 %41\n" + "%82 = OpTypePointer Input %81\n" + "%83 = OpVariable %82 Input\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%9 = OpLoad %6 %8\n" + "%12 = OpIEqual %11 %9 %10\n" + "OpSelectionMerge %14 None\n" + "OpBranchConditional %12 %13 %14\n" + "%13 = OpLabel\n" + "%23 = OpAccessChain %22 %20 %10\n" + "OpStore %23 %21\n" + "%25 = OpAccessChain %22 %20 %24\n" + "OpStore %25 %21\n" + "%30 = OpAccessChain %22 %29 %10\n" + "OpStore %30 %21\n" + "%31 = OpAccessChain %22 %29 %24\n" + "OpStore %31 %21\n" + "%33 = OpAccessChain %22 %29 %32\n" + "OpStore %33 %21\n" + "%35 = OpAccessChain %22 %29 %34\n" + "OpStore %35 %21\n" + "OpBranch %14\n" + "%14 = OpLabel\n" + "%40 = OpLoad %6 %8\n" + "%45 = OpLoad %6 %8\n" + "%47 = OpAccessChain %46 %color_in %45\n" + "%48 = OpLoad %36 %47\n" + "%50 = OpAccessChain %49 %color_out %40\n" + "OpStore %50 %48\n" + "%57 = OpLoad %6 %8\n" + "%62 = OpLoad %6 %8\n" + "%63 = OpAccessChain %46 %61 %62 %10\n" + "%64 = OpLoad %36 %63\n" + "%65 = OpAccessChain %49 %56 %57 %10\n" + "OpStore %65 %64\n" + "%66 = OpLoad %6 %8\n" + "%67 = OpLoad %6 %8\n" + "%69 = OpAccessChain %68 %61 %67 %24\n" + "%70 = OpLoad %52 %69\n" + "%72 = OpAccessChain %71 %56 %66 %24\n" + "OpStore %72 %70\n" + "%79 = OpLoad %6 %8\n" + "%84 = OpLoad %6 %8\n" + "%85 = OpAccessChain %46 %83 %84 %10\n" + "%86 = OpLoad %36 %85\n" + "%87 = OpAccessChain %49 %78 %79 %10\n" + "OpStore %87 %86\n" + "OpReturn\n" + "OpFunctionEnd\n"; + + /*#version 450 + #extension GL_EXT_tessellation_shader : require + layout( quads, equal_spacing, ccw ) in; + layout(location = 0) in vec4 in_color[]; + layout(location = 1) in ColorData + { + vec4 colorVec; + mat2 colorMat; + } inData[]; + layout(location = 0) out vec4 out_color; + layout(location = 1) out ColorData + { + vec4 colorVec; + mat2 colorMat; + } outData; + void main (void) + { + const float u = gl_TessCoord.x; + const float v = gl_TessCoord.y; + const float w = gl_TessCoord.z; + out_color = (1 - u) * (1 - v) * in_color[0] +(1 - u) * v * in_color[1] + u * (1 - v) * in_color[2] + u * v * in_color[3]; + outData.colorVec = (1 - u) * (1 - v) * inData[0].colorVec +(1 - u) * v * inData[1].colorVec + u * (1 - v) * inData[2].colorVec + u * v * inData[3].colorVec; + outData.colorMat = (1 - u) * (1 - v) * inData[0].colorMat +(1 - u) * v * inData[1].colorMat + u * (1 - v) * inData[2].colorMat + u * v * inData[3].colorMat; + gl_Position = (1 - u) * (1 - v) * gl_in[0].gl_Position +(1 - u) * v * gl_in[1].gl_Position + u * (1 - v) * gl_in[2].gl_Position + u * v * gl_in[3].gl_Position; + }*/ + + const string tessellationEvaluationSource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 203\n" + "; Schema: 0\n" + "OpCapability Tessellation\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint TessellationEvaluation %4 \"main\" %11 %color_out %color_in %74 %83 %166 %175\n" + "OpExecutionMode %4 Quads\n" + "OpExecutionMode %4 SpacingEqual\n" + "OpExecutionMode %4 VertexOrderCcw\n" + "OpDecorate %11 BuiltIn TessCoord\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 0\n" + "OpDecorate %block_out Block\n" + "OpDecorate %74 Location 1\n" + "OpDecorate %block_in Block\n" + "OpDecorate %83 Location 1\n" + +decorations[0].others+ + "OpMemberDecorate %164 0 BuiltIn Position\n" + "OpMemberDecorate %164 1 BuiltIn PointSize\n" + "OpMemberDecorate %164 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %164 3 BuiltIn CullDistance\n" + "OpDecorate %164 Block\n" + "OpMemberDecorate %172 0 BuiltIn Position\n" + "OpMemberDecorate %172 1 BuiltIn PointSize\n" + "OpMemberDecorate %172 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %172 3 BuiltIn CullDistance\n" + "OpDecorate %172 Block\n" + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeFloat 32\n" + "%7 = OpTypePointer Function %6\n" + "%9 = OpTypeVector %6 3\n" + "%10 = OpTypePointer Input %9\n" + "%11 = OpVariable %10 Input\n" + "%12 = OpTypeInt 32 0\n" + "%13 = OpConstant %12 0\n" + "%14 = OpTypePointer Input %6\n" + "%18 = OpConstant %12 1\n" + "%22 = OpConstant %12 2\n" + "%25 = OpTypeVector %6 4\n" + "%26 = OpTypePointer Output %25\n" + "%color_out = OpVariable %26 Output\n" + "%28 = OpConstant %6 1\n" + "%34 = OpConstant %12 32\n" + "%35 = OpTypeArray %25 %34\n" + "%36 = OpTypePointer Input %35\n" + "%color_in = OpVariable %36 Input\n" + "%38 = OpTypeInt 32 1\n" + "%39 = OpConstant %38 0\n" + "%40 = OpTypePointer Input %25\n" + "%48 = OpConstant %38 1\n" + "%57 = OpConstant %38 2\n" + "%65 = OpConstant %38 3\n" + "%70 = OpTypeVector %6 2\n" + "%71 = OpTypeMatrix %70 2\n" + "%block_out = OpTypeStruct %25 %71\n" + "%73 = OpTypePointer Output %block_out\n" + "%74 = OpVariable %73 Output\n" + "%block_in = OpTypeStruct %25 %71\n" + "%81 = OpTypeArray %block_in %34\n" + "%82 = OpTypePointer Input %81\n" + "%83 = OpVariable %82 Input\n" + "%116 = OpTypePointer Input %71\n" + "%161 = OpTypePointer Output %71\n" + "%163 = OpTypeArray %6 %18\n" + "%164 = OpTypeStruct %25 %6 %163 %163\n" + "%165 = OpTypePointer Output %164\n" + "%166 = OpVariable %165 Output\n" + "%172 = OpTypeStruct %25 %6 %163 %163\n" + "%173 = OpTypeArray %172 %34\n" + "%174 = OpTypePointer Input %173\n" + "%175 = OpVariable %174 Input\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%8 = OpVariable %7 Function\n" + "%17 = OpVariable %7 Function\n" + "%21 = OpVariable %7 Function\n" + "%15 = OpAccessChain %14 %11 %13\n" + "%16 = OpLoad %6 %15\n" + "OpStore %8 %16\n" + "%19 = OpAccessChain %14 %11 %18\n" + "%20 = OpLoad %6 %19\n" + "OpStore %17 %20\n" + "%23 = OpAccessChain %14 %11 %22\n" + "%24 = OpLoad %6 %23\n" + "OpStore %21 %24\n" + "%29 = OpLoad %6 %8\n" + "%30 = OpFSub %6 %28 %29\n" + "%31 = OpLoad %6 %17\n" + "%32 = OpFSub %6 %28 %31\n" + "%33 = OpFMul %6 %30 %32\n" + "%41 = OpAccessChain %40 %color_in %39\n" + "%42 = OpLoad %25 %41\n" + "%43 = OpVectorTimesScalar %25 %42 %33\n" + "%44 = OpLoad %6 %8\n" + "%45 = OpFSub %6 %28 %44\n" + "%46 = OpLoad %6 %17\n" + "%47 = OpFMul %6 %45 %46\n" + "%49 = OpAccessChain %40 %color_in %48\n" + "%50 = OpLoad %25 %49\n" + "%51 = OpVectorTimesScalar %25 %50 %47\n" + "%52 = OpFAdd %25 %43 %51\n" + "%53 = OpLoad %6 %8\n" + "%54 = OpLoad %6 %17\n" + "%55 = OpFSub %6 %28 %54\n" + "%56 = OpFMul %6 %53 %55\n" + "%58 = OpAccessChain %40 %color_in %57\n" + "%59 = OpLoad %25 %58\n" + "%60 = OpVectorTimesScalar %25 %59 %56\n" + "%61 = OpFAdd %25 %52 %60\n" + "%62 = OpLoad %6 %8\n" + "%63 = OpLoad %6 %17\n" + "%64 = OpFMul %6 %62 %63\n" + "%66 = OpAccessChain %40 %color_in %65\n" + "%67 = OpLoad %25 %66\n" + "%68 = OpVectorTimesScalar %25 %67 %64\n" + "%69 = OpFAdd %25 %61 %68\n" + "OpStore %color_out %69\n" + "%75 = OpLoad %6 %8\n" + "%76 = OpFSub %6 %28 %75\n" + "%77 = OpLoad %6 %17\n" + "%78 = OpFSub %6 %28 %77\n" + "%79 = OpFMul %6 %76 %78\n" + "%84 = OpAccessChain %40 %83 %39 %39\n" + "%85 = OpLoad %25 %84\n" + "%86 = OpVectorTimesScalar %25 %85 %79\n" + "%87 = OpLoad %6 %8\n" + "%88 = OpFSub %6 %28 %87\n" + "%89 = OpLoad %6 %17\n" + "%90 = OpFMul %6 %88 %89\n" + "%91 = OpAccessChain %40 %83 %48 %39\n" + "%92 = OpLoad %25 %91\n" + "%93 = OpVectorTimesScalar %25 %92 %90\n" + "%94 = OpFAdd %25 %86 %93\n" + "%95 = OpLoad %6 %8\n" + "%96 = OpLoad %6 %17\n" + "%97 = OpFSub %6 %28 %96\n" + "%98 = OpFMul %6 %95 %97\n" + "%99 = OpAccessChain %40 %83 %57 %39\n" + "%100 = OpLoad %25 %99\n" + "%101 = OpVectorTimesScalar %25 %100 %98\n" + "%102 = OpFAdd %25 %94 %101\n" + "%103 = OpLoad %6 %8\n" + "%104 = OpLoad %6 %17\n" + "%105 = OpFMul %6 %103 %104\n" + "%106 = OpAccessChain %40 %83 %65 %39\n" + "%107 = OpLoad %25 %106\n" + "%108 = OpVectorTimesScalar %25 %107 %105\n" + "%109 = OpFAdd %25 %102 %108\n" + "%110 = OpAccessChain %26 %74 %39\n" + "OpStore %110 %109\n" + "%111 = OpLoad %6 %8\n" + "%112 = OpFSub %6 %28 %111\n" + "%113 = OpLoad %6 %17\n" + "%114 = OpFSub %6 %28 %113\n" + "%115 = OpFMul %6 %112 %114\n" + "%117 = OpAccessChain %116 %83 %39 %48\n" + "%118 = OpLoad %71 %117\n" + "%119 = OpMatrixTimesScalar %71 %118 %115\n" + "%120 = OpLoad %6 %8\n" + "%121 = OpFSub %6 %28 %120\n" + "%122 = OpLoad %6 %17\n" + "%123 = OpFMul %6 %121 %122\n" + "%124 = OpAccessChain %116 %83 %48 %48\n" + "%125 = OpLoad %71 %124\n" + "%126 = OpMatrixTimesScalar %71 %125 %123\n" + "%127 = OpCompositeExtract %70 %119 0\n" + "%128 = OpCompositeExtract %70 %126 0\n" + "%129 = OpFAdd %70 %127 %128\n" + "%130 = OpCompositeExtract %70 %119 1\n" + "%131 = OpCompositeExtract %70 %126 1\n" + "%132 = OpFAdd %70 %130 %131\n" + "%133 = OpCompositeConstruct %71 %129 %132\n" + "%134 = OpLoad %6 %8\n" + "%135 = OpLoad %6 %17\n" + "%136 = OpFSub %6 %28 %135\n" + "%137 = OpFMul %6 %134 %136\n" + "%138 = OpAccessChain %116 %83 %57 %48\n" + "%139 = OpLoad %71 %138\n" + "%140 = OpMatrixTimesScalar %71 %139 %137\n" + "%141 = OpCompositeExtract %70 %133 0\n" + "%142 = OpCompositeExtract %70 %140 0\n" + "%143 = OpFAdd %70 %141 %142\n" + "%144 = OpCompositeExtract %70 %133 1\n" + "%145 = OpCompositeExtract %70 %140 1\n" + "%146 = OpFAdd %70 %144 %145\n" + "%147 = OpCompositeConstruct %71 %143 %146\n" + "%148 = OpLoad %6 %8\n" + "%149 = OpLoad %6 %17\n" + "%150 = OpFMul %6 %148 %149\n" + "%151 = OpAccessChain %116 %83 %65 %48\n" + "%152 = OpLoad %71 %151\n" + "%153 = OpMatrixTimesScalar %71 %152 %150\n" + "%154 = OpCompositeExtract %70 %147 0\n" + "%155 = OpCompositeExtract %70 %153 0\n" + "%156 = OpFAdd %70 %154 %155\n" + "%157 = OpCompositeExtract %70 %147 1\n" + "%158 = OpCompositeExtract %70 %153 1\n" + "%159 = OpFAdd %70 %157 %158\n" + "%160 = OpCompositeConstruct %71 %156 %159\n" + "%162 = OpAccessChain %161 %74 %48\n" + "OpStore %162 %160\n" + "%167 = OpLoad %6 %8\n" + "%168 = OpFSub %6 %28 %167\n" + "%169 = OpLoad %6 %17\n" + "%170 = OpFSub %6 %28 %169\n" + "%171 = OpFMul %6 %168 %170\n" + "%176 = OpAccessChain %40 %175 %39 %39\n" + "%177 = OpLoad %25 %176\n" + "%178 = OpVectorTimesScalar %25 %177 %171\n" + "%179 = OpLoad %6 %8\n" + "%180 = OpFSub %6 %28 %179\n" + "%181 = OpLoad %6 %17\n" + "%182 = OpFMul %6 %180 %181\n" + "%183 = OpAccessChain %40 %175 %48 %39\n" + "%184 = OpLoad %25 %183\n" + "%185 = OpVectorTimesScalar %25 %184 %182\n" + "%186 = OpFAdd %25 %178 %185\n" + "%187 = OpLoad %6 %8\n" + "%188 = OpLoad %6 %17\n" + "%189 = OpFSub %6 %28 %188\n" + "%190 = OpFMul %6 %187 %189\n" + "%191 = OpAccessChain %40 %175 %57 %39\n" + "%192 = OpLoad %25 %191\n" + "%193 = OpVectorTimesScalar %25 %192 %190\n" + "%194 = OpFAdd %25 %186 %193\n" + "%195 = OpLoad %6 %8\n" + "%196 = OpLoad %6 %17\n" + "%197 = OpFMul %6 %195 %196\n" + "%198 = OpAccessChain %40 %175 %65 %39\n" + "%199 = OpLoad %25 %198\n" + "%200 = OpVectorTimesScalar %25 %199 %197\n" + "%201 = OpFAdd %25 %194 %200\n" + "%202 = OpAccessChain %26 %166 %39\n" + "OpStore %202 %201\n" + "OpReturn\n" + "OpFunctionEnd\n"; + programCollection.spirvAsmSources.add("tessellation_control") << tessellationControlSource; + programCollection.spirvAsmSources.add("tessellation_evaluation") << tessellationEvaluationSource; + } + { + + /*#version 450 + layout(triangles) in; + layout(triangle_strip, max_vertices = 3) out; + layout(location = 0) in vec4 in_color[]; + layout(location = 1) in ColorData + { + vec4 colorVec; + mat2 colorMat; + } inData[]; + layout(location = 0) out vec4 out_color; + layout(location = 1) out ColorData + { + vec4 colorVec; + mat2 colorMat; + } outData; + void main (void) + { + out_color = in_color[0]; + outData.colorVec = inData[0].colorVec; + outData.colorMat = inData[0].colorMat; + gl_Position = gl_in[0].gl_Position; + EmitVertex(); + out_color = in_color[1]; + outData.colorVec = inData[1].colorVec; + outData.colorMat = inData[1].colorMat; + gl_Position = gl_in[1].gl_Position; + EmitVertex(); + out_color = in_color[2]; + outData.colorVec = inData[2].colorVec; + outData.colorMat = inData[2].colorMat; + gl_Position = gl_in[2].gl_Position; + EmitVertex(); + EndPrimitive(); + }*/ + const string geometrySource = + "; SPIR-V\n" + "; Version: 1.3\n" + "; Generator: Khronos Glslang Reference Front End; 2\n" + "; Bound: 73\n" + "; Schema: 0\n" + "OpCapability Geometry\n" + "%1 = OpExtInstImport \"GLSL.std.450\"\n" + "OpMemoryModel Logical GLSL450\n" + "OpEntryPoint Geometry %4 \"main\" %color_out %color_in %24 %28 %42 %46\n" + "OpExecutionMode %4 Triangles\n" + "OpExecutionMode %4 Invocations 1\n" + "OpExecutionMode %4 OutputTriangleStrip\n" + "OpExecutionMode %4 OutputVertices 3\n" + "OpDecorate %color_out Location 0\n" + "OpDecorate %color_in Location 0\n" + "OpDecorate %block_out Block\n" + "OpDecorate %24 Location 1\n" + "OpDecorate %block_in Block\n" + "OpDecorate %28 Location 1\n" + +decorations[0].others+ + "OpMemberDecorate %40 0 BuiltIn Position\n" + "OpMemberDecorate %40 1 BuiltIn PointSize\n" + "OpMemberDecorate %40 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %40 3 BuiltIn CullDistance\n" + "OpDecorate %40 Block\n" + "OpMemberDecorate %43 0 BuiltIn Position\n" + "OpMemberDecorate %43 1 BuiltIn PointSize\n" + "OpMemberDecorate %43 2 BuiltIn ClipDistance\n" + "OpMemberDecorate %43 3 BuiltIn CullDistance\n" + "OpDecorate %43 Block\n" + "%2 = OpTypeVoid\n" + "%3 = OpTypeFunction %2\n" + "%6 = OpTypeFloat 32\n" + "%7 = OpTypeVector %6 4\n" + "%8 = OpTypePointer Output %7\n" + "%color_out = OpVariable %8 Output\n" + "%10 = OpTypeInt 32 0\n" + "%11 = OpConstant %10 3\n" + "%12 = OpTypeArray %7 %11\n" + "%13 = OpTypePointer Input %12\n" + "%color_in = OpVariable %13 Input\n" + "%15 = OpTypeInt 32 1\n" + "%16 = OpConstant %15 0\n" + "%17 = OpTypePointer Input %7\n" + "%20 = OpTypeVector %6 2\n" + "%21 = OpTypeMatrix %20 2\n" + "%block_out = OpTypeStruct %7 %21\n" + "%23 = OpTypePointer Output %block_out\n" + "%24 = OpVariable %23 Output\n" + "%block_in = OpTypeStruct %7 %21\n" + "%26 = OpTypeArray %block_in %11\n" + "%27 = OpTypePointer Input %26\n" + "%28 = OpVariable %27 Input\n" + "%32 = OpConstant %15 1\n" + "%33 = OpTypePointer Input %21\n" + "%36 = OpTypePointer Output %21\n" + "%38 = OpConstant %10 1\n" + "%39 = OpTypeArray %6 %38\n" + "%40 = OpTypeStruct %7 %6 %39 %39\n" + "%41 = OpTypePointer Output %40\n" + "%42 = OpVariable %41 Output\n" + "%43 = OpTypeStruct %7 %6 %39 %39\n" + "%44 = OpTypeArray %43 %11\n" + "%45 = OpTypePointer Input %44\n" + "%46 = OpVariable %45 Input\n" + "%61 = OpConstant %15 2\n" + "%4 = OpFunction %2 None %3\n" + "%5 = OpLabel\n" + "%18 = OpAccessChain %17 %color_in %16\n" + "%19 = OpLoad %7 %18\n" + "OpStore %color_out %19\n" + "%29 = OpAccessChain %17 %28 %16 %16\n" + "%30 = OpLoad %7 %29\n" + "%31 = OpAccessChain %8 %24 %16\n" + "OpStore %31 %30\n" + "%34 = OpAccessChain %33 %28 %16 %32\n" + "%35 = OpLoad %21 %34\n" + "%37 = OpAccessChain %36 %24 %32\n" + "OpStore %37 %35\n" + "%47 = OpAccessChain %17 %46 %16 %16\n" + "%48 = OpLoad %7 %47\n" + "%49 = OpAccessChain %8 %42 %16\n" + "OpStore %49 %48\n" + "OpEmitVertex\n" + "%50 = OpAccessChain %17 %color_in %32\n" + "%51 = OpLoad %7 %50\n" + "OpStore %color_out %51\n" + "%52 = OpAccessChain %17 %28 %32 %16\n" + "%53 = OpLoad %7 %52\n" + "%54 = OpAccessChain %8 %24 %16\n" + "OpStore %54 %53\n" + "%55 = OpAccessChain %33 %28 %32 %32\n" + "%56 = OpLoad %21 %55\n" + "%57 = OpAccessChain %36 %24 %32\n" + "OpStore %57 %56\n" + "%58 = OpAccessChain %17 %46 %32 %16\n" + "%59 = OpLoad %7 %58\n" + "%60 = OpAccessChain %8 %42 %16\n" + "OpStore %60 %59\n" + "OpEmitVertex\n" + "%62 = OpAccessChain %17 %color_in %61\n" + "%63 = OpLoad %7 %62\n" + "OpStore %color_out %63\n" + "%64 = OpAccessChain %17 %28 %61 %16\n" + "%65 = OpLoad %7 %64\n" + "%66 = OpAccessChain %8 %24 %16\n" + "OpStore %66 %65\n" + "%67 = OpAccessChain %33 %28 %61 %32\n" + "%68 = OpLoad %21 %67\n" + "%69 = OpAccessChain %36 %24 %32\n" + "OpStore %69 %68\n" + "%70 = OpAccessChain %17 %46 %61 %16\n" + "%71 = OpLoad %7 %70\n" + "%72 = OpAccessChain %8 %42 %16\n" + "OpStore %72 %71\n" + "OpEmitVertex\n" + "OpEndPrimitive\n" + "OpReturn\n" + "OpFunctionEnd\n"; + programCollection.spirvAsmSources.add("geometry") << geometrySource; + } +} +} // anonymous + +tcu::TestCaseGroup* createCrossStageInterfaceTests (tcu::TestContext& testCtx) +{ + de::MovePtr testGroup(new tcu::TestCaseGroup(testCtx, "cross_stage", "")); + { + de::MovePtr basicGroup(new tcu::TestCaseGroup(testCtx, "basic_type", "")); + de::MovePtr interfaceGroup(new tcu::TestCaseGroup(testCtx, "interface_blocks", "")); + { + TestParameters parm(TEST_TYPE_FLAT,3); + for (int ndx = 0; ndx < CrossStageTestInstance::DECORATION_LAST; ++ndx) + parm.testOptions[ndx] = ndx; + + basicGroup->addChild(new CrossStageBasicTestsCase(testCtx, "flat", "", parm)); + interfaceGroup->addChild(new CrossStageInterfaceTestsCase(testCtx, "flat", "", parm)); + + parm.qualifier = TEST_TYPE_NOPERSPECTIVE; + basicGroup->addChild(new CrossStageBasicTestsCase(testCtx, "no_perspective", "", parm)); + interfaceGroup->addChild(new CrossStageInterfaceTestsCase(testCtx, "no_perspective", "", parm)); + } + + { + TestParameters parm(TEST_TYPE_RELAXEDPRECISION,1); + parm.testOptions[0] = CrossStageTestInstance::DECORATION_IN_ALL_SHADERS; + basicGroup->addChild(new CrossStageBasicTestsCase(testCtx, "relaxedprecision", "", parm)); + interfaceGroup->addChild(new CrossStageInterfaceTestsCase(testCtx, "relaxedprecision", "", parm)); + } + testGroup->addChild(basicGroup.release()); + testGroup->addChild(interfaceGroup.release()); + } + + return testGroup.release(); +} + +} // SpirVAssembly +} // vkt diff --git a/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.hpp b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.hpp new file mode 100644 index 0000000..e00697c --- /dev/null +++ b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmCrossStageInterfaceTests.hpp @@ -0,0 +1,40 @@ +#ifndef _VKTSPVASMCROSSSTAGEINTERFACETESTS_HPP +#define _VKTSPVASMCROSSSTAGEINTERFACETESTS_HPP + +/*------------------------------------------------------------------------- + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2017 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 Shader cross-stage interface tests + *//*--------------------------------------------------------------------*/ + +#include "tcuDefs.hpp" +#include "tcuTestCase.hpp" + +namespace vkt +{ +namespace SpirVAssembly +{ + +tcu::TestCaseGroup* createCrossStageInterfaceTests (tcu::TestContext& testCtx); + +} // SpirVAssembly +} // vkt + +#endif // _VKTSPVASMCROSSSTAGEINTERFACETESTS_HPP diff --git a/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp index b7d7d14..ef6b7c4 100644 --- a/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp +++ b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp @@ -49,6 +49,7 @@ #include "deMath.h" #include "tcuStringTemplate.hpp" +#include "vktSpvAsmCrossStageInterfaceTests.hpp" #include "vktSpvAsm16bitStorageTests.hpp" #include "vktSpvAsmUboMatrixPaddingTests.hpp" #include "vktSpvAsmConditionalBranchTests.hpp" @@ -7838,7 +7839,6 @@ tcu::TestCaseGroup* createOpSModGraphicsTests(tcu::TestContext& testCtx, qpTestR return testGroup.release(); } - enum IntegerType { INTEGER_TYPE_SIGNED_16, @@ -8999,13 +8999,13 @@ tcu::TestCaseGroup* createInstructionTests (tcu::TestContext& testCtx) computeTests->addChild(computeAndroidTests.release()); } - computeTests->addChild(create16BitStorageComputeGroup(testCtx)); computeTests->addChild(createUboMatrixPaddingComputeGroup(testCtx)); computeTests->addChild(createConditionalBranchComputeGroup(testCtx)); computeTests->addChild(createIndexingComputeGroup(testCtx)); computeTests->addChild(createVariablePointersComputeGroup(testCtx)); computeTests->addChild(createImageSamplerComputeGroup(testCtx)); + graphicsTests->addChild(createCrossStageInterfaceTests(testCtx)); graphicsTests->addChild(createSpivVersionCheckTests(testCtx, !testComputePipeline)); graphicsTests->addChild(createOpNopTests(testCtx)); graphicsTests->addChild(createOpSourceTests(testCtx)); diff --git a/external/vulkancts/mustpass/1.1.2/vk-default-no-waivers.txt b/external/vulkancts/mustpass/1.1.2/vk-default-no-waivers.txt index 1c110fb..912f97d 100644 --- a/external/vulkancts/mustpass/1.1.2/vk-default-no-waivers.txt +++ b/external/vulkancts/mustpass/1.1.2/vk-default-no-waivers.txt @@ -196084,6 +196084,12 @@ dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_ima dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_image.pass_sampler_to_function dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_image.pass_image_and_sampler_to_function dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.combined_image_sampler.all_local_variables +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.flat +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.no_perspective +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.relaxedprecision +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.flat +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.no_perspective +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.relaxedprecision dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_vertex dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_tesselation_evaluation dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_tesselation_control diff --git a/external/vulkancts/mustpass/1.1.2/vk-default.txt b/external/vulkancts/mustpass/1.1.2/vk-default.txt index 14f3349..0b31c0d 100644 --- a/external/vulkancts/mustpass/1.1.2/vk-default.txt +++ b/external/vulkancts/mustpass/1.1.2/vk-default.txt @@ -196084,6 +196084,12 @@ dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_ima dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_image.pass_sampler_to_function dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.sampled_image.pass_image_and_sampler_to_function dEQP-VK.spirv_assembly.instruction.compute.image_sampler.imagesample.combined_image_sampler.all_local_variables +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.flat +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.no_perspective +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.basic_type.relaxedprecision +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.flat +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.no_perspective +dEQP-VK.spirv_assembly.instruction.graphics.cross_stage.interface_blocks.relaxedprecision dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_vertex dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_tesselation_evaluation dEQP-VK.spirv_assembly.instruction.graphics.spirv_version.1_0_tesselation_control -- 2.7.4