--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2021 The Khronos Group 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 Acceleration Structure binding tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktBindingDescriptorUpdateASTests.hpp"
+
+#include "vkDefs.hpp"
+
+#include "vktTestCase.hpp"
+#include "vktTestGroupUtil.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkObjUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkBarrierUtil.hpp"
+#include "vkBufferWithMemory.hpp"
+#include "vkImageWithMemory.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkImageUtil.hpp"
+#include "deRandom.hpp"
+#include "tcuTexture.hpp"
+#include "tcuTextureUtil.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuImageCompare.hpp"
+#include "tcuCommandLine.hpp"
+
+#include "vkRayTracingUtil.hpp"
+
+namespace vkt
+{
+namespace BindingModel
+{
+namespace
+{
+using namespace vk;
+using namespace vkt;
+
+static const VkFlags ALL_RAY_TRACING_STAGES = VK_SHADER_STAGE_RAYGEN_BIT_KHR
+ | VK_SHADER_STAGE_ANY_HIT_BIT_KHR
+ | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR
+ | VK_SHADER_STAGE_MISS_BIT_KHR
+ | VK_SHADER_STAGE_INTERSECTION_BIT_KHR
+ | VK_SHADER_STAGE_CALLABLE_BIT_KHR;
+
+enum TestType
+{
+ TEST_TYPE_USING_RAY_QUERY = 0,
+ TEST_TYPE_USING_RAY_TRACING,
+};
+
+enum UpdateMethod
+{
+ UPDATE_METHOD_NORMAL = 0, //!< use vkUpdateDescriptorSets vkUpdateDescriptorSets
+ UPDATE_METHOD_WITH_TEMPLATE, //!< use descriptor update templates vkUpdateDescriptorSetWithTemplate
+ UPDATE_METHOD_WITH_PUSH, //!< use push descriptor updates vkCmdPushDescriptorSetKHR
+ UPDATE_METHOD_WITH_PUSH_TEMPLATE, //!< use push descriptor update templates vkCmdPushDescriptorSetWithTemplateKHR
+
+ UPDATE_METHOD_LAST
+};
+
+const deUint32 TEST_WIDTH = 16u;
+const deUint32 TEST_HEIGHT = 16u;
+const deUint32 FIXED_POINT_DIVISOR = 1024 * 1024;
+const float PLAIN_Z0 = 2.0f;
+const float PLAIN_Z1 = 4.0f;
+
+struct TestParams;
+
+typedef void (*CheckSupportFunc)(Context& context, const TestParams& testParams);
+typedef void (*InitProgramsFunc)(SourceCollections& programCollection, const TestParams& testParams);
+typedef const std::string (*ShaderBodyTextFunc)(const TestParams& testParams);
+
+struct TestParams
+{
+ deUint32 width;
+ deUint32 height;
+ deUint32 depth;
+ TestType testType;
+ UpdateMethod updateMethod;
+ VkShaderStageFlagBits stage;
+ VkFormat format;
+ CheckSupportFunc pipelineCheckSupport;
+ InitProgramsFunc pipelineInitPrograms;
+ ShaderBodyTextFunc testConfigShaderBodyText;
+};
+
+
+static deUint32 getShaderGroupHandleSize (const InstanceInterface& vki,
+ const VkPhysicalDevice physicalDevice)
+{
+ de::MovePtr<RayTracingProperties> rayTracingPropertiesKHR;
+
+ rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice);
+
+ return rayTracingPropertiesKHR->getShaderGroupHandleSize();
+}
+
+static deUint32 getShaderGroupBaseAlignment (const InstanceInterface& vki,
+ const VkPhysicalDevice physicalDevice)
+{
+ de::MovePtr<RayTracingProperties> rayTracingPropertiesKHR;
+
+ rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice);
+
+ return rayTracingPropertiesKHR->getShaderGroupBaseAlignment();
+}
+
+static VkBuffer getVkBuffer (const de::MovePtr<BufferWithMemory>& buffer)
+{
+ VkBuffer result = (buffer.get() == DE_NULL) ? DE_NULL : buffer->get();
+
+ return result;
+}
+
+static VkStridedDeviceAddressRegionKHR makeStridedDeviceAddressRegion (const DeviceInterface& vkd, const VkDevice device, VkBuffer buffer, deUint32 stride, deUint32 count)
+{
+ if (buffer == DE_NULL)
+ {
+ return makeStridedDeviceAddressRegionKHR(0, 0, 0);
+ }
+ else
+ {
+ return makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, buffer, 0), stride, stride * count);
+ }
+}
+
+static Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface& vk,
+ const VkDevice device,
+ const VkDescriptorSetLayout descriptorSetLayout0,
+ const VkDescriptorSetLayout descriptorSetLayout1,
+ const VkDescriptorSetLayout descriptorSetLayoutOpt = DE_NULL)
+{
+ std::vector<VkDescriptorSetLayout> descriptorSetLayouts;
+
+ descriptorSetLayouts.push_back(descriptorSetLayout0);
+ descriptorSetLayouts.push_back(descriptorSetLayout1);
+
+ if (descriptorSetLayoutOpt != DE_NULL)
+ descriptorSetLayouts.push_back(descriptorSetLayoutOpt);
+
+ return makePipelineLayout(vk, device, (deUint32)descriptorSetLayouts.size(), descriptorSetLayouts.data());
+}
+
+static VkWriteDescriptorSetAccelerationStructureKHR makeWriteDescriptorSetAccelerationStructureKHR (const VkAccelerationStructureKHR* accelerationStructureKHR)
+{
+ const VkWriteDescriptorSetAccelerationStructureKHR result =
+ {
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 1u, // deUint32 accelerationStructureCount;
+ accelerationStructureKHR // const VkAccelerationStructureKHR* pAccelerationStructures;
+ };
+
+ return result;
+}
+
+static bool isPushUpdateMethod (const UpdateMethod updateMethod)
+{
+ switch (updateMethod)
+ {
+ case UPDATE_METHOD_NORMAL: return false;
+ case UPDATE_METHOD_WITH_TEMPLATE: return false;
+ case UPDATE_METHOD_WITH_PUSH: return true;
+ case UPDATE_METHOD_WITH_PUSH_TEMPLATE: return true;
+ default: TCU_THROW(InternalError, "Unknown update method");
+ }
+}
+
+static bool isTemplateUpdateMethod (const UpdateMethod updateMethod)
+{
+ switch (updateMethod)
+ {
+ case UPDATE_METHOD_NORMAL: return false;
+ case UPDATE_METHOD_WITH_TEMPLATE: return true;
+ case UPDATE_METHOD_WITH_PUSH: return false;
+ case UPDATE_METHOD_WITH_PUSH_TEMPLATE: return true;
+ default: TCU_THROW(InternalError, "Unknown update method");
+ }
+}
+
+static Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface& vki,
+ const VkDevice device,
+ const VkDescriptorPool descriptorPool,
+ const VkDescriptorSetLayout setLayout,
+ UpdateMethod updateMethod)
+{
+ const bool pushUpdateMethod = isPushUpdateMethod(updateMethod);
+ Move<VkDescriptorSet> descriptorSet = pushUpdateMethod
+ ? vk::Move<vk::VkDescriptorSet>()
+ : vk::makeDescriptorSet(vki, device, descriptorPool, setLayout, DE_NULL);
+
+ return descriptorSet;
+}
+
+static VkImageCreateInfo makeImageCreateInfo (VkFormat format,
+ deUint32 width,
+ deUint32 height,
+ deUint32 depth,
+ VkImageType imageType = VK_IMAGE_TYPE_3D,
+ VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT)
+{
+ const VkImageCreateInfo imageCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
+ imageType, // VkImageType imageType;
+ format, // VkFormat format;
+ makeExtent3D(width, height, depth), // VkExtent3D extent;
+ 1u, // deUint32 mipLevels;
+ 1u, // deUint32 arrayLayers;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
+ usageFlags, // VkImageUsageFlags usage;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 0u, // deUint32 queueFamilyIndexCount;
+ DE_NULL, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
+ };
+
+ return imageCreateInfo;
+}
+
+static Move<VkPipeline> makeComputePipeline (const DeviceInterface& vk,
+ const VkDevice device,
+ const VkPipelineLayout pipelineLayout,
+ const VkShaderModule shaderModule)
+{
+ const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineShaderStageCreateFlags flags;
+ VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
+ shaderModule, // VkShaderModule module;
+ "main", // const char* pName;
+ DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
+ };
+ const VkComputePipelineCreateInfo pipelineCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineCreateFlags flags;
+ pipelineShaderStageParams, // VkPipelineShaderStageCreateInfo stage;
+ pipelineLayout, // VkPipelineLayout layout;
+ DE_NULL, // VkPipeline basePipelineHandle;
+ 0, // deInt32 basePipelineIndex;
+ };
+
+ return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo);
+}
+
+static const std::string getMissPassthrough (void)
+{
+ std::ostringstream src;
+
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "\n"
+ << "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << "}\n";
+
+ return src.str();
+}
+
+static const std::string getHitPassthrough (void)
+{
+ std::ostringstream src;
+
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "hitAttributeEXT vec3 attribs;\n"
+ << "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << "}\n";
+
+ return src.str();
+}
+
+static const std::string getGraphicsPassthrough (void)
+{
+ std::ostringstream src;
+
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << "}\n";
+
+ return src.str();
+}
+
+static const std::string getVertexPassthrough (void)
+{
+ std::ostringstream src;
+
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "\n"
+ << "layout(location = 0) in vec4 in_position;\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " gl_Position = in_position;\n"
+ << "}\n";
+
+ return src.str();
+}
+
+static VkDescriptorSetLayoutCreateFlags getDescriptorSetLayoutCreateFlags(const UpdateMethod updateMethod)
+{
+ vk::VkDescriptorSetLayoutCreateFlags extraFlags = 0;
+
+ if (updateMethod == UPDATE_METHOD_WITH_PUSH_TEMPLATE || updateMethod == UPDATE_METHOD_WITH_PUSH)
+ {
+ extraFlags |= vk::VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR;
+ }
+
+ return extraFlags;
+}
+
+class BindingAcceleratioStructureTestInstance : public TestInstance
+{
+public:
+ BindingAcceleratioStructureTestInstance (Context& context,
+ const TestParams& testParams);
+ virtual ~BindingAcceleratioStructureTestInstance () {};
+ virtual tcu::TestStatus iterate (void);
+
+protected:
+ virtual void initPipeline (void) = 0;
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) = 0;
+ virtual VkShaderStageFlags getShaderStageFlags (void) = 0;
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) = 0;
+
+ virtual void fillCommandBuffer (VkCommandBuffer commandBuffer) = 0;
+
+ virtual const VkAccelerationStructureKHR* createAccelerationStructures (Context& context,
+ TestParams& testParams);
+ virtual void buildAccelerationStructures (Context& context,
+ TestParams& testParams,
+ VkCommandBuffer commandBuffer);
+ virtual bool verify (BufferWithMemory* resultBuffer,
+ Context& context,
+ TestParams& testParams);
+
+ TestParams m_testParams;
+
+ std::vector<de::SharedPtr<BottomLevelAccelerationStructure>> m_bottomAccelerationStructures;
+ de::SharedPtr<TopLevelAccelerationStructure> m_topAccelerationStructure;
+
+ Move<VkDescriptorPool> m_descriptorPool;
+
+ Move<VkDescriptorSetLayout> m_descriptorSetLayoutImg;
+ Move<VkDescriptorSet> m_descriptorSetImg;
+
+ Move<VkDescriptorSetLayout> m_descriptorSetLayoutAS;
+ Move<VkDescriptorSet> m_descriptorSetAS;
+
+ Move<VkPipelineLayout> m_pipelineLayout;
+ Move<VkPipeline> m_pipeline;
+
+ Move<VkDescriptorUpdateTemplate> m_updateTemplate;
+};
+
+BindingAcceleratioStructureTestInstance::BindingAcceleratioStructureTestInstance (Context& context, const TestParams& testParams)
+ : TestInstance (context)
+ , m_testParams (testParams)
+ , m_bottomAccelerationStructures ()
+ , m_topAccelerationStructure ()
+ , m_descriptorPool ()
+ , m_descriptorSetLayoutImg ()
+ , m_descriptorSetImg ()
+ , m_descriptorSetLayoutAS ()
+ , m_descriptorSetAS ()
+ , m_pipelineLayout ()
+ , m_pipeline ()
+ , m_updateTemplate ()
+{
+}
+
+tcu::TestStatus BindingAcceleratioStructureTestInstance::iterate (void)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkQueue queue = m_context.getUniversalQueue();
+ Allocator& allocator = m_context.getDefaultAllocator();
+ const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
+ const bool templateUpdateMethod = isTemplateUpdateMethod(m_testParams.updateMethod);
+ const bool pushUpdateMethod = isPushUpdateMethod(m_testParams.updateMethod);
+
+ const deUint32 width = m_testParams.width;
+ const deUint32 height = m_testParams.height;
+ const deUint32 depth = m_testParams.depth;
+ const VkImageCreateInfo imageCreateInfo = makeImageCreateInfo(m_testParams.format, width, height, depth);
+ const VkImageSubresourceRange imageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
+ const de::MovePtr<ImageWithMemory> image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
+ const Move<VkImageView> imageView = makeImageView(vkd, device, **image, VK_IMAGE_VIEW_TYPE_3D, m_testParams.format, imageSubresourceRange);
+
+ const deUint32 pixelSize = mapVkFormat(m_testParams.format).getPixelSize();
+ const VkBufferCreateInfo resultBufferCreateInfo = makeBufferCreateInfo(width * height * depth * pixelSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
+ const VkImageSubresourceLayers resultBufferImageSubresourceLayers = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u);
+ const VkBufferImageCopy resultBufferImageRegion = makeBufferImageCopy(makeExtent3D(width, height, depth), resultBufferImageSubresourceLayers);
+ de::MovePtr<BufferWithMemory> resultBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(vkd, device, allocator, resultBufferCreateInfo, MemoryRequirement::HostVisible));
+ const VkDescriptorImageInfo resultImageInfo = makeDescriptorImageInfo(DE_NULL, *imageView, VK_IMAGE_LAYOUT_GENERAL);
+
+ const Move<VkCommandPool> commandPool = createCommandPool(vkd, device, 0, queueFamilyIndex);
+ const Move<VkCommandBuffer> commandBuffer = allocateCommandBuffer(vkd, device, *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+ const VkAccelerationStructureKHR* topAccelerationStructurePtr = createAccelerationStructures(m_context, m_testParams);
+ const VkWriteDescriptorSetAccelerationStructureKHR writeDescriptorSetAccelerationStructure = makeWriteDescriptorSetAccelerationStructureKHR(topAccelerationStructurePtr);
+ const deUint32 accelerationStructureDescriptorCount = 1 + getExtraAccelerationDescriptorCount();
+ deUint32 updateCount = 0;
+
+ m_descriptorPool = DescriptorPoolBuilder()
+ .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
+ .addType(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, accelerationStructureDescriptorCount)
+ .build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u + accelerationStructureDescriptorCount);
+
+ m_descriptorSetLayoutImg = DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, getShaderStageFlags())
+ .build(vkd, device);
+ m_descriptorSetImg = makeDescriptorSet(vkd, device, *m_descriptorPool, *m_descriptorSetLayoutImg);
+
+ DescriptorSetUpdateBuilder()
+ .writeSingle(*m_descriptorSetImg, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &resultImageInfo)
+ .update(vkd, device);
+
+ m_descriptorSetLayoutAS = DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, getShaderStageFlags())
+ .build(vkd, device, getDescriptorSetLayoutCreateFlags(m_testParams.updateMethod));
+ m_descriptorSetAS = makeDescriptorSet(vkd, device, *m_descriptorPool, *m_descriptorSetLayoutAS, m_testParams.updateMethod);
+
+ initPipeline();
+
+ if (m_testParams.updateMethod == UPDATE_METHOD_NORMAL)
+ {
+ DescriptorSetUpdateBuilder()
+ .writeSingle(*m_descriptorSetAS, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &writeDescriptorSetAccelerationStructure)
+ .update(vkd, device);
+
+ updateCount++;
+ }
+
+ if (templateUpdateMethod)
+ {
+ const VkDescriptorUpdateTemplateType updateTemplateType = isPushUpdateMethod(m_testParams.updateMethod)
+ ? VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
+ : VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET;
+ const VkDescriptorUpdateTemplateEntry updateTemplateEntry =
+ {
+ 0, // deUint32 dstBinding;
+ 0, // deUint32 dstArrayElement;
+ 1, // deUint32 descriptorCount;
+ VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, // VkDescriptorType descriptorType;
+ 0, // deUintptr offset;
+ 0, // deUintptr stride;
+ };
+ const VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkDescriptorUpdateTemplateCreateFlags flags;
+ 1, // deUint32 descriptorUpdateEntryCount;
+ &updateTemplateEntry, // const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;
+ updateTemplateType, // VkDescriptorUpdateTemplateType templateType;
+ *m_descriptorSetLayoutAS, // VkDescriptorSetLayout descriptorSetLayout;
+ getPipelineBindPoint(), // VkPipelineBindPoint pipelineBindPoint;
+ *m_pipelineLayout, // VkPipelineLayout pipelineLayout;
+ 0, // deUint32 set;
+ };
+
+ m_updateTemplate = vk::createDescriptorUpdateTemplate(vkd, device, &templateCreateInfo);
+
+ if (!pushUpdateMethod)
+ {
+ vkd.updateDescriptorSetWithTemplate(device, *m_descriptorSetAS, *m_updateTemplate, topAccelerationStructurePtr);
+
+ updateCount++;
+ }
+ }
+
+ beginCommandBuffer(vkd, *commandBuffer, 0u);
+ {
+ {
+ const VkClearValue clearValue = makeClearValueColorU32(0u, 0u, 0u, 0u);
+ const VkImageMemoryBarrier preImageBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, **image, imageSubresourceRange);
+ const VkImageMemoryBarrier postImageBarrier = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR | VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, **image, imageSubresourceRange);
+
+ cmdPipelineImageMemoryBarrier(vkd, *commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &preImageBarrier);
+ vkd.cmdClearColorImage(*commandBuffer, **image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue.color, 1, &imageSubresourceRange);
+ cmdPipelineImageMemoryBarrier(vkd, *commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, &postImageBarrier);
+
+ vkd.cmdBindDescriptorSets(*commandBuffer, getPipelineBindPoint(), *m_pipelineLayout, 1, 1, &m_descriptorSetImg.get(), 0, DE_NULL);
+ }
+
+ switch (m_testParams.updateMethod)
+ {
+ case UPDATE_METHOD_NORMAL: // fallthrough
+ case UPDATE_METHOD_WITH_TEMPLATE:
+ {
+ vkd.cmdBindDescriptorSets(*commandBuffer, getPipelineBindPoint(), *m_pipelineLayout, 0, 1, &m_descriptorSetAS.get(), 0, DE_NULL);
+
+ break;
+ }
+
+ case UPDATE_METHOD_WITH_PUSH:
+ {
+ DescriptorSetUpdateBuilder()
+ .writeSingle(*m_descriptorSetAS, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &writeDescriptorSetAccelerationStructure)
+ .updateWithPush(vkd, *commandBuffer, getPipelineBindPoint(), *m_pipelineLayout, 0, 0, 1);
+
+ updateCount++;
+
+ break;
+ }
+
+ case UPDATE_METHOD_WITH_PUSH_TEMPLATE:
+ {
+ vkd.cmdPushDescriptorSetWithTemplateKHR(*commandBuffer, *m_updateTemplate, *m_pipelineLayout, 0, topAccelerationStructurePtr);
+
+ updateCount++;
+
+ break;
+ }
+
+ default: TCU_THROW(InternalError, "Unknown update method");
+ }
+
+ {
+ const VkMemoryBarrier preTraceMemoryBarrier = makeMemoryBarrier(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR);
+ const VkPipelineStageFlags dstStageFlags = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
+
+ buildAccelerationStructures(m_context, m_testParams, *commandBuffer);
+
+ cmdPipelineMemoryBarrier(vkd, *commandBuffer, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, dstStageFlags, &preTraceMemoryBarrier);
+ }
+
+ fillCommandBuffer(*commandBuffer);
+
+ {
+ const VkMemoryBarrier postTestMemoryBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);
+
+ cmdPipelineMemoryBarrier(vkd, *commandBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &postTestMemoryBarrier);
+ }
+
+ vkd.cmdCopyImageToBuffer(*commandBuffer, **image, VK_IMAGE_LAYOUT_GENERAL, **resultBuffer, 1u, &resultBufferImageRegion);
+ }
+ endCommandBuffer(vkd, *commandBuffer);
+
+ if (updateCount != 1)
+ TCU_THROW(InternalError, "Invalid descriptor update");
+
+ submitCommandsAndWait(vkd, device, queue, commandBuffer.get());
+
+ invalidateMappedMemoryRange(vkd, device, resultBuffer->getAllocation().getMemory(), resultBuffer->getAllocation().getOffset(), VK_WHOLE_SIZE);
+
+ if (verify(resultBuffer.get(), m_context, m_testParams))
+ return tcu::TestStatus::pass("Pass");
+ else
+ return tcu::TestStatus::fail("Fail");
+}
+
+const VkAccelerationStructureKHR* BindingAcceleratioStructureTestInstance::createAccelerationStructures (Context& context,
+ TestParams& testParams)
+{
+ DE_UNREF(testParams);
+
+ const DeviceInterface& vkd = context.getDeviceInterface();
+ const VkDevice device = context.getDevice();
+ Allocator& allocator = context.getDefaultAllocator();
+ de::MovePtr<BottomLevelAccelerationStructure> rayQueryBottomLevelAccelerationStructure = makeBottomLevelAccelerationStructure();
+ de::MovePtr<TopLevelAccelerationStructure> rayQueryTopLevelAccelerationStructure = makeTopLevelAccelerationStructure();
+ std::vector<tcu::Vec3> geometryData;
+
+ // Generate in-plain square starting at (0,0,PLAIN_Z0) and ending at (1,1,PLAIN_Z1).
+ // Vertices 1,0 and 0,1 by Z axis are in the middle between PLAIN_Z0 and PLAIN_Z1
+ geometryData.push_back(tcu::Vec3(0.0f, 0.0f, PLAIN_Z0));
+ geometryData.push_back(tcu::Vec3(1.0f, 0.0f, (PLAIN_Z0 + PLAIN_Z1) / 2.0f));
+ geometryData.push_back(tcu::Vec3(0.0f, 1.0f, (PLAIN_Z0 + PLAIN_Z1) / 2.0f));
+ geometryData.push_back(tcu::Vec3(1.0f, 1.0f, PLAIN_Z1));
+ geometryData.push_back(tcu::Vec3(0.0f, 1.0f, (PLAIN_Z0 + PLAIN_Z1) / 2.0f));
+ geometryData.push_back(tcu::Vec3(1.0f, 0.0f, (PLAIN_Z0 + PLAIN_Z1) / 2.0f));
+
+ rayQueryBottomLevelAccelerationStructure->setGeometryCount(1u);
+ rayQueryBottomLevelAccelerationStructure->addGeometry(geometryData, true);
+ rayQueryBottomLevelAccelerationStructure->create(vkd, device, allocator, 0);
+ m_bottomAccelerationStructures.push_back(de::SharedPtr<BottomLevelAccelerationStructure>(rayQueryBottomLevelAccelerationStructure.release()));
+
+ m_topAccelerationStructure = de::SharedPtr<TopLevelAccelerationStructure>(rayQueryTopLevelAccelerationStructure.release());
+ m_topAccelerationStructure->addInstance(m_bottomAccelerationStructures.back());
+ m_topAccelerationStructure->create(vkd, device, allocator);
+
+ return m_topAccelerationStructure.get()->getPtr();
+}
+
+void BindingAcceleratioStructureTestInstance::buildAccelerationStructures (Context& context,
+ TestParams& testParams,
+ VkCommandBuffer commandBuffer)
+{
+ DE_UNREF(testParams);
+
+ const DeviceInterface& vkd = context.getDeviceInterface();
+ const VkDevice device = context.getDevice();
+
+ for (size_t blStructNdx = 0; blStructNdx < m_bottomAccelerationStructures.size(); ++blStructNdx)
+ m_bottomAccelerationStructures[blStructNdx]->build(vkd, device, commandBuffer);
+
+ m_topAccelerationStructure->build(vkd, device, commandBuffer);
+}
+
+bool BindingAcceleratioStructureTestInstance::verify (BufferWithMemory* resultBuffer,
+ Context& context,
+ TestParams& testParams)
+{
+ tcu::TestLog& log = context.getTestContext().getLog();
+ const deUint32 width = testParams.width;
+ const deUint32 height = testParams.height;
+ const deInt32* retrieved = (deInt32*)resultBuffer->getAllocation().getHostPtr();
+ deUint32 failures = 0;
+ deUint32 pos = 0;
+ std::vector<deInt32> expected;
+
+ expected.reserve(width * height);
+
+ for (deUint32 y = 0; y < height; ++y)
+ {
+ const float expectedY = deFloatMix(PLAIN_Z0, PLAIN_Z1, (0.5f + float(y)) / float(height));
+
+ for (deUint32 x = 0; x < width; ++x)
+ {
+ const float expectedX = deFloatMix(PLAIN_Z0, PLAIN_Z1, (0.5f + float(x)) / float(width));
+ const deInt32 expectedV = deInt32(float(FIXED_POINT_DIVISOR / 2) * (expectedX + expectedY));
+
+ expected.push_back(expectedV);
+ }
+ }
+
+ for (deUint32 y = 0; y < height; ++y)
+ for (deUint32 x = 0; x < width; ++x)
+ {
+ if (retrieved[pos] != expected[pos])
+ {
+ failures++;
+
+ if (failures < 10)
+ {
+ const deInt32 expectedValue = expected[pos];
+ const deInt32 retrievedValue = retrieved[pos];
+
+ log << tcu::TestLog::Message
+ << "At (" << x <<"," << y << ") "
+ << "expected " << std::fixed << std::setprecision(6) << std::setw(8) << float(expectedValue) / float(FIXED_POINT_DIVISOR) << " (" << expectedValue << ") "
+ << "retrieved " << std::fixed << std::setprecision(6) << std::setw(8) << float(retrievedValue) / float(FIXED_POINT_DIVISOR) << " (" << retrievedValue << ") "
+ << tcu::TestLog::EndMessage;
+ }
+ }
+
+ pos++;
+ }
+
+ if (failures != 0)
+ {
+ for (deUint32 dumpNdx = 0; dumpNdx < 2; ++dumpNdx)
+ {
+ const deInt32* data = (dumpNdx == 0) ? expected.data() : retrieved;
+ const char* dataName = (dumpNdx == 0) ? "Expected" : "Retrieved";
+ std::ostringstream css;
+
+ pos = 0;
+
+ for (deUint32 y = 0; y < height; ++y)
+ {
+ for (deUint32 x = 0; x < width; ++x)
+ {
+ if (expected[pos] != retrieved[pos])
+ css << std::fixed << std::setprecision(6) << std::setw(8) << float(data[pos]) / float(FIXED_POINT_DIVISOR) << ",";
+ else
+ css << "________,";
+
+ pos++;
+ }
+
+ css << std::endl;
+ }
+
+ log << tcu::TestLog::Message << dataName << ":" << tcu::TestLog::EndMessage;
+ log << tcu::TestLog::Message << css.str() << tcu::TestLog::EndMessage;
+ }
+ }
+
+ return (failures == 0);
+}
+
+
+class BindingAcceleratioStructureGraphicsTestInstance : public BindingAcceleratioStructureTestInstance
+{
+public:
+ static void checkSupport (Context& context,
+ const TestParams& testParams);
+ static void initPrograms (SourceCollections& programCollection,
+ const TestParams& testParams);
+
+ BindingAcceleratioStructureGraphicsTestInstance (Context& context,
+ const TestParams& testParams);
+ virtual ~BindingAcceleratioStructureGraphicsTestInstance () {};
+
+protected:
+ virtual void initPipeline (void) override;
+ virtual void fillCommandBuffer (VkCommandBuffer commandBuffer) override;
+
+ void initVertexBuffer (void);
+ Move<VkPipeline> makeGraphicsPipeline (void);
+
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 0; };
+ virtual VkShaderStageFlags getShaderStageFlags (void) override { return VK_SHADER_STAGE_ALL_GRAPHICS; }
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_GRAPHICS; };
+
+ VkFormat m_framebufferFormat;
+ Move<VkImage> m_framebufferImage;
+ de::MovePtr<Allocation> m_framebufferImageAlloc;
+ Move<VkImageView> m_framebufferAttachment;
+
+ Move<VkShaderModule> m_vertShaderModule;
+ Move<VkShaderModule> m_geomShaderModule;
+ Move<VkShaderModule> m_tescShaderModule;
+ Move<VkShaderModule> m_teseShaderModule;
+ Move<VkShaderModule> m_fragShaderModule;
+
+ Move<VkRenderPass> m_renderPass;
+ Move<VkFramebuffer> m_framebuffer;
+
+ deUint32 m_vertexCount;
+ Move<VkBuffer> m_vertexBuffer;
+ de::MovePtr<Allocation> m_vertexBufferAlloc;
+};
+
+BindingAcceleratioStructureGraphicsTestInstance::BindingAcceleratioStructureGraphicsTestInstance (Context& context,
+ const TestParams& testParams)
+ : BindingAcceleratioStructureTestInstance (context, testParams)
+ , m_framebufferFormat (VK_FORMAT_R8G8B8A8_UNORM)
+ , m_framebufferImage ()
+ , m_framebufferImageAlloc ()
+ , m_framebufferAttachment ()
+ , m_vertShaderModule ()
+ , m_geomShaderModule ()
+ , m_tescShaderModule ()
+ , m_teseShaderModule ()
+ , m_fragShaderModule ()
+ , m_renderPass ()
+ , m_framebuffer ()
+ , m_vertexCount (0)
+ , m_vertexBuffer ()
+ , m_vertexBufferAlloc ()
+{
+}
+
+void BindingAcceleratioStructureGraphicsTestInstance::checkSupport (Context& context,
+ const TestParams& testParams)
+{
+ switch (testParams.stage)
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ break;
+
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ {
+ context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_TESSELLATION_SHADER);
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ {
+ context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER);
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ break;
+
+ default:
+ TCU_THROW(InternalError, "Unknown stage");
+ }
+}
+
+void BindingAcceleratioStructureGraphicsTestInstance::initPrograms (SourceCollections& programCollection,
+ const TestParams& testParams)
+{
+ const vk::ShaderBuildOptions buildOptions (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
+ const std::string testShaderBody = testParams.testConfigShaderBodyText(testParams);
+
+ switch (testParams.stage)
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ {
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void testFunc(ivec3 pos, ivec3 size)\n"
+ << "{\n"
+ << testShaderBody
+ << "}\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " const int posId = int(gl_VertexIndex / 3);\n"
+ << " const int vertId = int(gl_VertexIndex % 3);\n"
+ << " const ivec3 size = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
+ << " const ivec3 pos = ivec3(posId % size.x, posId / size.x, 0);\n"
+ << "\n"
+ << " if (vertId == 0)\n"
+ << " {\n"
+ << " testFunc(pos, size);\n"
+ << " }\n"
+ << "}\n";
+
+ programCollection.glslSources.add("vert") << glu::VertexSource(src.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("frag") << glu::FragmentSource(getGraphicsPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ {
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "\n"
+ << "layout(location = 0) in vec4 in_position;\n"
+ << "out gl_PerVertex\n"
+ << "{\n"
+ << " vec4 gl_Position;\n"
+ << "};\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " gl_Position = in_position;\n"
+ << "}\n";
+
+ programCollection.glslSources.add("vert") << glu::VertexSource(src.str()) << buildOptions;
+ }
+
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_tessellation_shader : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "in gl_PerVertex\n"
+ << "{\n"
+ << " vec4 gl_Position;\n"
+ << "} gl_in[];\n"
+ << "layout(vertices = 3) out;\n"
+ << "out gl_PerVertex\n"
+ << "{\n"
+ << " vec4 gl_Position;\n"
+ << "} gl_out[];\n"
+ << "\n"
+ << "void testFunc(ivec3 pos, ivec3 size)\n"
+ << "{\n"
+ << testShaderBody
+ << "}\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << "\n"
+ << " if (gl_InvocationID == 0)\n"
+ << " {\n"
+ << " const ivec3 size = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
+ << " int index = int(gl_in[gl_InvocationID].gl_Position.z);\n"
+ << " int x = index % size.x;\n"
+ << " int y = index / size.y;\n"
+ << " const ivec3 pos = ivec3(x, y, 0);\n"
+ << " testFunc(pos, size);\n"
+ << " }\n"
+ << "\n"
+ << " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
+ << " gl_TessLevelInner[0] = 1;\n"
+ << " gl_TessLevelInner[1] = 1;\n"
+ << " gl_TessLevelOuter[gl_InvocationID] = 1;\n"
+ << "}\n";
+
+ programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()) << buildOptions;
+ }
+
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_tessellation_shader : require\n"
+ << "layout(triangles, equal_spacing, ccw) in;\n"
+ << "\n"
+ << "in gl_PerVertex\n"
+ << "{\n"
+ << " vec4 gl_Position;\n"
+ << "} gl_in[];\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " gl_Position = gl_in[0].gl_Position;\n"
+ << "}\n";
+
+ programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()) << buildOptions;
+ }
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ {
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "\n"
+ << "layout(location = 0) in vec4 in_position;\n"
+ << "out gl_PerVertex"
+ << "{\n"
+ << " vec4 gl_Position;\n"
+ << "};\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " gl_Position = in_position;\n"
+ << "}\n";
+
+ programCollection.glslSources.add("vert") << glu::VertexSource(src.str()) << buildOptions;
+ }
+
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_tessellation_shader : require\n"
+ << "\n"
+ << "in gl_PerVertex\n"
+ << "{\n"
+ << " vec4 gl_Position;\n"
+ << "} gl_in[];\n"
+ << "layout(vertices = 3) out;\n"
+ << "out gl_PerVertex\n"
+ << "{\n"
+ << " vec4 gl_Position;\n"
+ << "} gl_out[];\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
+ << " gl_TessLevelInner[0] = 1;\n"
+ << " gl_TessLevelInner[1] = 1;\n"
+ << " gl_TessLevelOuter[gl_InvocationID] = 1;\n"
+ << "}\n";
+
+ programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()) << buildOptions;
+ }
+
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_tessellation_shader : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "layout(triangles, equal_spacing, ccw) in;\n"
+ << "in gl_PerVertex\n"
+ << "{\n"
+ << " vec4 gl_Position;\n"
+ << "} gl_in[];\n"
+ << "\n"
+ << "void testFunc(ivec3 pos, ivec3 size)\n"
+ << "{\n"
+ << testShaderBody
+ << "}\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " const ivec3 size = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
+ << " int index = int(gl_in[0].gl_Position.z);\n"
+ << " int x = index % size.x;\n"
+ << " int y = index / size.y;\n"
+ << " const ivec3 pos = ivec3(x, y, 0);\n"
+ << " testFunc(pos, size);\n"
+ << " gl_Position = gl_in[0].gl_Position;\n"
+ << "}\n";
+
+ programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()) << buildOptions;
+ }
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ {
+ programCollection.glslSources.add("vert") << glu::VertexSource(getVertexPassthrough()) << buildOptions;
+
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "layout(triangles) in;\n"
+ << "layout(points, max_vertices = 1) out;\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void testFunc(ivec3 pos, ivec3 size)\n"
+ << "{\n"
+ << testShaderBody
+ << "}\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " const int posId = int(gl_PrimitiveIDIn);\n"
+ << " const ivec3 size = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
+ << " const ivec3 pos = ivec3(posId % size.x, posId / size.x, 0);\n"
+ << "\n"
+ << " testFunc(pos, size);\n"
+ << " gl_PointSize = 1.0;\n"
+ << "}\n";
+
+ programCollection.glslSources.add("geom") << glu::GeometrySource(src.str()) << buildOptions;
+ }
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ {
+ programCollection.glslSources.add("vert") << glu::VertexSource(getVertexPassthrough()) << buildOptions;
+
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void testFunc(ivec3 pos, ivec3 size)\n"
+ << "{\n"
+ << testShaderBody
+ << "}\n"
+ << "\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " const ivec3 size = ivec3(" << testParams.width << ", " << testParams.height << ", 1);\n"
+ << " const ivec3 pos = ivec3(int(gl_FragCoord.x - 0.5f), int(gl_FragCoord.y - 0.5f), 0);\n"
+ << "\n"
+ << " testFunc(pos, size);\n"
+ << "}\n";
+
+ programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()) << buildOptions;
+ }
+
+ break;
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown stage");
+ }
+}
+
+void BindingAcceleratioStructureGraphicsTestInstance::initVertexBuffer (void)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const deUint32 width = m_testParams.width;
+ const deUint32 height = m_testParams.height;
+ Allocator& allocator = m_context.getDefaultAllocator();
+ std::vector<tcu::Vec4> vertices;
+
+ switch (m_testParams.stage)
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ {
+ float z = 0.0f;
+
+ vertices.reserve(3 * height * width);
+
+ for (deUint32 y = 0; y < height; ++y)
+ for (deUint32 x = 0; x < width; ++x)
+ {
+ const float x0 = float(x + 0) / float(width);
+ const float y0 = float(y + 0) / float(height);
+ const float x1 = float(x + 1) / float(width);
+ const float y1 = float(y + 1) / float(height);
+ const float xm = (x0 + x1) / 2.0f;
+ const float ym = (y0 + y1) / 2.0f;
+
+ vertices.push_back(tcu::Vec4(x0, y0, z, 1.0f));
+ vertices.push_back(tcu::Vec4(xm, y1, z, 1.0f));
+ vertices.push_back(tcu::Vec4(x1, ym, z, 1.0f));
+
+ z += 1.f;
+ }
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ {
+ const float z = 1.0f;
+ const tcu::Vec4 a = tcu::Vec4(-1.0f, -1.0f, z, 1.0f);
+ const tcu::Vec4 b = tcu::Vec4(+1.0f, -1.0f, z, 1.0f);
+ const tcu::Vec4 c = tcu::Vec4(-1.0f, +1.0f, z, 1.0f);
+ const tcu::Vec4 d = tcu::Vec4(+1.0f, +1.0f, z, 1.0f);
+
+ vertices.push_back(a);
+ vertices.push_back(b);
+ vertices.push_back(c);
+
+ vertices.push_back(b);
+ vertices.push_back(c);
+ vertices.push_back(d);
+
+ break;
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown stage");
+
+ }
+
+ // Initialize vertex buffer
+ {
+ const VkDeviceSize vertexBufferSize = sizeof(vertices[0][0]) * vertices[0].SIZE * vertices.size();
+ const VkBufferCreateInfo vertexBufferCreateInfo = makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
+
+ m_vertexCount = static_cast<deUint32>(vertices.size());
+ m_vertexBuffer = createBuffer(vkd, device, &vertexBufferCreateInfo);
+ m_vertexBufferAlloc = bindBuffer(vkd, device, allocator, *m_vertexBuffer, vk::MemoryRequirement::HostVisible);
+
+ deMemcpy(m_vertexBufferAlloc->getHostPtr(), vertices.data(), (size_t)vertexBufferSize);
+ flushAlloc(vkd, device, *m_vertexBufferAlloc);
+ }
+}
+
+Move<VkPipeline> BindingAcceleratioStructureGraphicsTestInstance::makeGraphicsPipeline (void)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const bool tessStageTest = (m_testParams.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || m_testParams.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
+ const VkPrimitiveTopology topology = tessStageTest ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+ const deUint32 patchControlPoints = tessStageTest ? 3 : 0;
+ const std::vector<VkViewport> viewports (1, makeViewport(m_testParams.width, m_testParams.height));
+ const std::vector<VkRect2D> scissors (1, makeRect2D(m_testParams.width, m_testParams.height));
+
+ return vk::makeGraphicsPipeline (vkd,
+ device,
+ *m_pipelineLayout,
+ *m_vertShaderModule,
+ *m_tescShaderModule,
+ *m_teseShaderModule,
+ *m_geomShaderModule,
+ *m_fragShaderModule,
+ *m_renderPass,
+ viewports,
+ scissors,
+ topology,
+ 0,
+ patchControlPoints);
+}
+
+void BindingAcceleratioStructureGraphicsTestInstance::initPipeline (void)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ Allocator& allocator = m_context.getDefaultAllocator();
+ vk::BinaryCollection& collection = m_context.getBinaryCollection();
+ VkShaderStageFlags shaders = static_cast<VkShaderStageFlags>(0);
+ deUint32 shaderCount = 0;
+
+ if (collection.contains("vert")) shaders |= VK_SHADER_STAGE_VERTEX_BIT;
+ if (collection.contains("geom")) shaders |= VK_SHADER_STAGE_GEOMETRY_BIT;
+ if (collection.contains("tesc")) shaders |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
+ if (collection.contains("tese")) shaders |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
+ if (collection.contains("frag")) shaders |= VK_SHADER_STAGE_FRAGMENT_BIT;
+
+ for (BinaryCollection::Iterator it = collection.begin(); it != collection.end(); ++it)
+ shaderCount++;
+
+ if (shaderCount != (deUint32)dePop32(shaders))
+ TCU_THROW(InternalError, "Unused shaders detected in the collection");
+
+ if (0 != (shaders & VK_SHADER_STAGE_VERTEX_BIT)) m_vertShaderModule = createShaderModule(vkd, device, collection.get("vert"), 0);
+ if (0 != (shaders & VK_SHADER_STAGE_GEOMETRY_BIT)) m_geomShaderModule = createShaderModule(vkd, device, collection.get("geom"), 0);
+ if (0 != (shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT)) m_tescShaderModule = createShaderModule(vkd, device, collection.get("tesc"), 0);
+ if (0 != (shaders & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)) m_teseShaderModule = createShaderModule(vkd, device, collection.get("tese"), 0);
+ if (0 != (shaders & VK_SHADER_STAGE_FRAGMENT_BIT)) m_fragShaderModule = createShaderModule(vkd, device, collection.get("frag"), 0);
+
+ m_framebufferImage = makeImage (vkd, device, makeImageCreateInfo(m_framebufferFormat, m_testParams.width, m_testParams.height, 1u, VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT));
+ m_framebufferImageAlloc = bindImage (vkd, device, allocator, *m_framebufferImage, MemoryRequirement::Any);
+ m_framebufferAttachment = makeImageView (vkd, device, *m_framebufferImage, VK_IMAGE_VIEW_TYPE_2D, m_framebufferFormat, makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
+ m_renderPass = makeRenderPass (vkd, device, m_framebufferFormat);
+ m_framebuffer = makeFramebuffer (vkd, device, *m_renderPass, *m_framebufferAttachment, m_testParams.width, m_testParams.height);
+ m_pipelineLayout = makePipelineLayout (vkd, device, m_descriptorSetLayoutAS.get(), m_descriptorSetLayoutImg.get());
+ m_pipeline = makeGraphicsPipeline ();
+
+ initVertexBuffer();
+}
+
+void BindingAcceleratioStructureGraphicsTestInstance::fillCommandBuffer (VkCommandBuffer commandBuffer)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDeviceSize vertexBufferOffset = 0;
+
+ vkd.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
+ vkd.cmdBindVertexBuffers(commandBuffer, 0u, 1u, &m_vertexBuffer.get(), &vertexBufferOffset);
+
+ beginRenderPass(vkd, commandBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, m_testParams.width, m_testParams.height), tcu::UVec4());
+
+ vkd.cmdDraw(commandBuffer, m_vertexCount, 1u, 0u, 0u);
+
+ endRenderPass(vkd, commandBuffer);
+}
+
+class BindingAcceleratioStructureComputeTestInstance : public BindingAcceleratioStructureTestInstance
+{
+public:
+ BindingAcceleratioStructureComputeTestInstance (Context& context,
+ const TestParams& testParams);
+
+ virtual ~BindingAcceleratioStructureComputeTestInstance () {};
+
+ static void checkSupport (Context& context,
+ const TestParams& testParams);
+ static void initPrograms (SourceCollections& programCollection,
+ const TestParams& testParams);
+
+protected:
+ virtual void initPipeline (void) override;
+ virtual void fillCommandBuffer (VkCommandBuffer commandBuffer) override;
+
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 0; };
+ virtual VkShaderStageFlags getShaderStageFlags (void) override { return VK_SHADER_STAGE_COMPUTE_BIT; }
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_COMPUTE; };
+
+ Move<VkShaderModule> m_shaderModule;
+};
+
+BindingAcceleratioStructureComputeTestInstance::BindingAcceleratioStructureComputeTestInstance (Context& context,
+ const TestParams& testParams)
+ : BindingAcceleratioStructureTestInstance (context, testParams)
+ , m_shaderModule ()
+{
+}
+
+void BindingAcceleratioStructureComputeTestInstance::checkSupport (Context& context,
+ const TestParams& testParams)
+{
+ DE_UNREF(context);
+ DE_UNREF(testParams);
+}
+
+void BindingAcceleratioStructureComputeTestInstance::initPrograms (SourceCollections& programCollection,
+ const TestParams& testParams)
+{
+ const vk::ShaderBuildOptions buildOptions (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
+ const std::string testShaderBody = testParams.testConfigShaderBodyText(testParams);
+ const std::string testBody =
+ " ivec3 pos = ivec3(gl_WorkGroupID);\n"
+ " ivec3 size = ivec3(gl_NumWorkGroups);\n"
+ + testShaderBody;
+
+ switch (testParams.stage)
+ {
+ case VK_SHADER_STAGE_COMPUTE_BIT:
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testBody
+ << "}\n";
+
+ programCollection.glslSources.add("comp") << glu::ComputeSource(css.str()) << buildOptions;
+
+ break;
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown stage");
+ }
+}
+
+void BindingAcceleratioStructureComputeTestInstance::initPipeline (void)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ vk::BinaryCollection& collection = m_context.getBinaryCollection();
+
+ m_shaderModule = createShaderModule(vkd, device, collection.get("comp"), 0);
+ m_pipelineLayout = makePipelineLayout(vkd, device, m_descriptorSetLayoutAS.get(), m_descriptorSetLayoutImg.get());
+ m_pipeline = makeComputePipeline(vkd, device, *m_pipelineLayout, *m_shaderModule);
+}
+
+void BindingAcceleratioStructureComputeTestInstance::fillCommandBuffer (VkCommandBuffer commandBuffer)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+
+ vkd.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, m_pipeline.get());
+
+ vkd.cmdDispatch(commandBuffer, m_testParams.width, m_testParams.height, 1);
+}
+
+class BindingAcceleratioStructureRayTracingTestInstance : public BindingAcceleratioStructureTestInstance
+{
+public:
+ BindingAcceleratioStructureRayTracingTestInstance (Context& context,
+ const TestParams& testParams);
+ virtual ~BindingAcceleratioStructureRayTracingTestInstance () {};
+
+ static void checkSupport (Context& context,
+ const TestParams& testParams);
+ static void initPrograms (SourceCollections& programCollection,
+ const TestParams& testParams);
+
+protected:
+ virtual void initPipeline (void) override;
+ virtual void fillCommandBuffer (VkCommandBuffer commandBuffer) override;
+
+ de::MovePtr<BufferWithMemory> createShaderBindingTable (const InstanceInterface& vki,
+ const DeviceInterface& vkd,
+ const VkDevice device,
+ const VkPhysicalDevice physicalDevice,
+ const VkPipeline pipeline,
+ Allocator& allocator,
+ de::MovePtr<RayTracingPipeline>& rayTracingPipeline,
+ const deUint32 group);
+
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 1; };
+ virtual VkShaderStageFlags getShaderStageFlags (void) override { return ALL_RAY_TRACING_STAGES; }
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR; };
+
+ deUint32 m_shaders;
+ deUint32 m_raygenShaderGroup;
+ deUint32 m_missShaderGroup;
+ deUint32 m_hitShaderGroup;
+ deUint32 m_callableShaderGroup;
+ deUint32 m_shaderGroupCount;
+
+ Move<VkDescriptorSetLayout> m_descriptorSetLayoutSvc;
+ Move<VkDescriptorSet> m_descriptorSetSvc;
+
+ de::MovePtr<RayTracingPipeline> m_rayTracingPipeline;
+
+ de::MovePtr<BufferWithMemory> m_raygenShaderBindingTable;
+ de::MovePtr<BufferWithMemory> m_hitShaderBindingTable;
+ de::MovePtr<BufferWithMemory> m_missShaderBindingTable;
+ de::MovePtr<BufferWithMemory> m_callableShaderBindingTable;
+
+ VkStridedDeviceAddressRegionKHR m_raygenShaderBindingTableRegion;
+ VkStridedDeviceAddressRegionKHR m_missShaderBindingTableRegion;
+ VkStridedDeviceAddressRegionKHR m_hitShaderBindingTableRegion;
+ VkStridedDeviceAddressRegionKHR m_callableShaderBindingTableRegion;
+
+ de::SharedPtr<BottomLevelAccelerationStructure> m_bottomLevelAccelerationStructure;
+ de::SharedPtr<TopLevelAccelerationStructure> m_topLevelAccelerationStructure;
+};
+
+BindingAcceleratioStructureRayTracingTestInstance::BindingAcceleratioStructureRayTracingTestInstance (Context& context,
+ const TestParams& testParams)
+ : BindingAcceleratioStructureTestInstance (context, testParams)
+ , m_shaders (0)
+ , m_raygenShaderGroup (~0u)
+ , m_missShaderGroup (~0u)
+ , m_hitShaderGroup (~0u)
+ , m_callableShaderGroup (~0u)
+ , m_shaderGroupCount (0)
+
+ , m_descriptorSetLayoutSvc ()
+ , m_descriptorSetSvc ()
+
+ , m_rayTracingPipeline ()
+
+ , m_raygenShaderBindingTable ()
+ , m_hitShaderBindingTable ()
+ , m_missShaderBindingTable ()
+ , m_callableShaderBindingTable ()
+
+ , m_raygenShaderBindingTableRegion ()
+ , m_missShaderBindingTableRegion ()
+ , m_hitShaderBindingTableRegion ()
+ , m_callableShaderBindingTableRegion ()
+
+ , m_bottomLevelAccelerationStructure ()
+ , m_topLevelAccelerationStructure ()
+{
+}
+
+void BindingAcceleratioStructureRayTracingTestInstance::checkSupport (Context& context,
+ const TestParams& testParams)
+{
+ DE_UNREF(testParams);
+
+ context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline");
+
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& rayTracingPipelineFeaturesKHR = context.getRayTracingPipelineFeatures();
+
+ if (rayTracingPipelineFeaturesKHR.rayTracingPipeline == DE_FALSE)
+ TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline");
+}
+
+void BindingAcceleratioStructureRayTracingTestInstance::initPrograms (SourceCollections& programCollection,
+ const TestParams& testParams)
+{
+ const vk::ShaderBuildOptions buildOptions (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
+ const std::string testShaderBody = testParams.testConfigShaderBodyText(testParams);
+ const std::string testBody =
+ " ivec3 pos = ivec3(gl_LaunchIDEXT);\n"
+ " ivec3 size = ivec3(gl_LaunchSizeEXT);\n"
+ + testShaderBody;
+ const std::string commonRayGenerationShader =
+ std::string(glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460)) + "\n"
+ "#extension GL_EXT_ray_tracing : require\n"
+ "\n"
+ "layout(location = 0) rayPayloadEXT vec3 hitValue;\n"
+ "layout(set = 2, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " uint rayFlags = 0;\n"
+ " uint cullMask = 0xFF;\n"
+ " float tmin = 0.0;\n"
+ " float tmax = 9.0;\n"
+ " vec3 origin = vec3((float(gl_LaunchIDEXT.x) + 0.5f) / float(gl_LaunchSizeEXT.x), (float(gl_LaunchIDEXT.y) + 0.5f) / float(gl_LaunchSizeEXT.y), 0.0);\n"
+ " vec3 direct = vec3(0.0, 0.0, -1.0);\n"
+ " traceRayEXT(topLevelAS, rayFlags, cullMask, 0, 0, 0, origin, tmin, direct, tmax, 0);\n"
+ "}\n";
+
+ switch (testParams.stage)
+ {
+ case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testBody
+ << "}\n";
+
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(css.str()) << buildOptions;
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
+ {
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;
+
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "hitAttributeEXT vec3 attribs;\n"
+ << "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testBody
+ << "}\n";
+
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(css.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
+ {
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;
+
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ << "hitAttributeEXT vec3 attribs;\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testBody
+ << "}\n";
+
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(css.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
+ {
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;
+
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "hitAttributeEXT vec3 hitAttribute;\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testBody
+ << " hitAttribute = vec3(0.0f, 0.0f, 0.0f);\n"
+ << " reportIntersectionEXT(1.0f, 0);\n"
+ << "}\n";
+
+ programCollection.glslSources.add("sect") << glu::IntersectionSource(css.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_MISS_BIT_KHR:
+ {
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;
+
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testBody
+ << "}\n";
+
+ programCollection.glslSources.add("miss") << glu::MissSource(css.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
+ {
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "\n"
+ << "layout(location = 0) callableDataEXT float dummy;"
+ << "layout(set = 2, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << " executeCallableEXT(0, 0);\n"
+ << "}\n";
+
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(css.str()) << buildOptions;
+ }
+
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "#extension GL_EXT_ray_query : require\n"
+ << "layout(location = 0) callableDataInEXT float dummy;"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT tlas;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testBody
+ << "}\n";
+
+ programCollection.glslSources.add("call") << glu::CallableSource(css.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown stage");
+ }
+}
+
+void BindingAcceleratioStructureRayTracingTestInstance::initPipeline (void)
+{
+ const InstanceInterface& vki = m_context.getInstanceInterface();
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
+ vk::BinaryCollection& collection = m_context.getBinaryCollection();
+ Allocator& allocator = m_context.getDefaultAllocator();
+ const deUint32 shaderGroupHandleSize = getShaderGroupHandleSize(vki, physicalDevice);
+ const VkShaderStageFlags hitStages = VK_SHADER_STAGE_ANY_HIT_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
+ deUint32 shaderCount = 0;
+
+ m_shaderGroupCount = 0;
+
+ if (collection.contains("rgen")) m_shaders |= VK_SHADER_STAGE_RAYGEN_BIT_KHR;
+ if (collection.contains("ahit")) m_shaders |= VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
+ if (collection.contains("chit")) m_shaders |= VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
+ if (collection.contains("miss")) m_shaders |= VK_SHADER_STAGE_MISS_BIT_KHR;
+ if (collection.contains("sect")) m_shaders |= VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
+ if (collection.contains("call")) m_shaders |= VK_SHADER_STAGE_CALLABLE_BIT_KHR;
+
+ for (BinaryCollection::Iterator it = collection.begin(); it != collection.end(); ++it)
+ shaderCount++;
+
+ if (shaderCount != (deUint32)dePop32(m_shaders))
+ TCU_THROW(InternalError, "Unused shaders detected in the collection");
+
+ if (0 != (m_shaders & VK_SHADER_STAGE_RAYGEN_BIT_KHR))
+ m_raygenShaderGroup = m_shaderGroupCount++;
+
+ if (0 != (m_shaders & VK_SHADER_STAGE_MISS_BIT_KHR))
+ m_missShaderGroup = m_shaderGroupCount++;
+
+ if (0 != (m_shaders & hitStages))
+ m_hitShaderGroup = m_shaderGroupCount++;
+
+ if (0 != (m_shaders & VK_SHADER_STAGE_CALLABLE_BIT_KHR))
+ m_callableShaderGroup = m_shaderGroupCount++;
+
+ m_rayTracingPipeline = de::newMovePtr<RayTracingPipeline>();
+
+ m_descriptorSetLayoutSvc = DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, ALL_RAY_TRACING_STAGES)
+ .build(vkd, device);
+ m_descriptorSetSvc = makeDescriptorSet(vkd, device, *m_descriptorPool, *m_descriptorSetLayoutSvc);
+
+ if (0 != (m_shaders & VK_SHADER_STAGE_RAYGEN_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR , createShaderModule(vkd, device, collection.get("rgen"), 0), m_raygenShaderGroup);
+ if (0 != (m_shaders & VK_SHADER_STAGE_ANY_HIT_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR , createShaderModule(vkd, device, collection.get("ahit"), 0), m_hitShaderGroup);
+ if (0 != (m_shaders & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR , createShaderModule(vkd, device, collection.get("chit"), 0), m_hitShaderGroup);
+ if (0 != (m_shaders & VK_SHADER_STAGE_MISS_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR , createShaderModule(vkd, device, collection.get("miss"), 0), m_missShaderGroup);
+ if (0 != (m_shaders & VK_SHADER_STAGE_INTERSECTION_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_INTERSECTION_BIT_KHR , createShaderModule(vkd, device, collection.get("sect"), 0), m_hitShaderGroup);
+ if (0 != (m_shaders & VK_SHADER_STAGE_CALLABLE_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_CALLABLE_BIT_KHR , createShaderModule(vkd, device, collection.get("call"), 0), m_callableShaderGroup);
+
+ m_pipelineLayout = makePipelineLayout(vkd, device, m_descriptorSetLayoutAS.get(), m_descriptorSetLayoutImg.get(), m_descriptorSetLayoutSvc.get());
+ m_pipeline = m_rayTracingPipeline->createPipeline(vkd, device, *m_pipelineLayout);
+
+ m_raygenShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_raygenShaderGroup);
+ m_missShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_missShaderGroup);
+ m_hitShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_hitShaderGroup);
+ m_callableShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_callableShaderGroup);
+
+ m_raygenShaderBindingTableRegion = makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_raygenShaderBindingTable), shaderGroupHandleSize, 1);
+ m_missShaderBindingTableRegion = makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_missShaderBindingTable), shaderGroupHandleSize, 1);
+ m_hitShaderBindingTableRegion = makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_hitShaderBindingTable), shaderGroupHandleSize, 1);
+ m_callableShaderBindingTableRegion = makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_callableShaderBindingTable), shaderGroupHandleSize, 1);
+}
+
+void BindingAcceleratioStructureRayTracingTestInstance::fillCommandBuffer (VkCommandBuffer commandBuffer)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ Allocator& allocator = m_context.getDefaultAllocator();
+ de::MovePtr<BottomLevelAccelerationStructure> bottomLevelAccelerationStructure = makeBottomLevelAccelerationStructure();
+ de::MovePtr<TopLevelAccelerationStructure> topLevelAccelerationStructure = makeTopLevelAccelerationStructure();
+
+ m_bottomLevelAccelerationStructure = de::SharedPtr<BottomLevelAccelerationStructure>(bottomLevelAccelerationStructure.release());
+ m_bottomLevelAccelerationStructure->setDefaultGeometryData(m_testParams.stage);
+ m_bottomLevelAccelerationStructure->createAndBuild(vkd, device, commandBuffer, allocator);
+
+ m_topLevelAccelerationStructure = de::SharedPtr<TopLevelAccelerationStructure>(topLevelAccelerationStructure.release());
+ m_topLevelAccelerationStructure->setInstanceCount(1);
+ m_topLevelAccelerationStructure->addInstance(m_bottomLevelAccelerationStructure);
+ m_topLevelAccelerationStructure->createAndBuild(vkd, device, commandBuffer, allocator);
+
+ const TopLevelAccelerationStructure* topLevelAccelerationStructurePtr = m_topLevelAccelerationStructure.get();
+ const VkWriteDescriptorSetAccelerationStructureKHR accelerationStructureWriteDescriptorSet = makeWriteDescriptorSetAccelerationStructureKHR(topLevelAccelerationStructurePtr->getPtr());
+
+ DescriptorSetUpdateBuilder()
+ .writeSingle(*m_descriptorSetSvc, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &accelerationStructureWriteDescriptorSet)
+ .update(vkd, device);
+
+ vkd.cmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *m_pipelineLayout, 2, 1, &m_descriptorSetSvc.get(), 0, DE_NULL);
+
+ vkd.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, m_pipeline.get());
+
+ cmdTraceRays(vkd,
+ commandBuffer,
+ &m_raygenShaderBindingTableRegion,
+ &m_missShaderBindingTableRegion,
+ &m_hitShaderBindingTableRegion,
+ &m_callableShaderBindingTableRegion,
+ m_testParams.width, m_testParams.height, 1);
+}
+
+de::MovePtr<BufferWithMemory> BindingAcceleratioStructureRayTracingTestInstance::createShaderBindingTable (const InstanceInterface& vki,
+ const DeviceInterface& vkd,
+ const VkDevice device,
+ const VkPhysicalDevice physicalDevice,
+ const VkPipeline pipeline,
+ Allocator& allocator,
+ de::MovePtr<RayTracingPipeline>& rayTracingPipeline,
+ const deUint32 group)
+{
+ de::MovePtr<BufferWithMemory> shaderBindingTable;
+
+ if (group < m_shaderGroupCount)
+ {
+ const deUint32 shaderGroupHandleSize = getShaderGroupHandleSize(vki, physicalDevice);
+ const deUint32 shaderGroupBaseAlignment = getShaderGroupBaseAlignment(vki, physicalDevice);
+
+ shaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, group, 1u);
+ }
+
+ return shaderBindingTable;
+}
+
+
+class BindingAcceleratioStructureRayTracingRayTracingTestInstance : public BindingAcceleratioStructureTestInstance
+{
+public:
+ BindingAcceleratioStructureRayTracingRayTracingTestInstance (Context& context,
+ const TestParams& testParams);
+ virtual ~BindingAcceleratioStructureRayTracingRayTracingTestInstance () {};
+
+ static void checkSupport (Context& context,
+ const TestParams& testParams);
+ static void initPrograms (SourceCollections& programCollection,
+ const TestParams& testParams);
+
+protected:
+ virtual void initPipeline (void) override;
+ virtual void fillCommandBuffer (VkCommandBuffer commandBuffer) override;
+
+ void calcShaderGroup (deUint32& shaderGroupCounter,
+ const VkShaderStageFlags shaders1,
+ const VkShaderStageFlags shaders2,
+ const VkShaderStageFlags shaderStageFlags,
+ deUint32& shaderGroup,
+ deUint32& shaderGroupCount) const;
+
+
+ de::MovePtr<BufferWithMemory> createShaderBindingTable (const InstanceInterface& vki,
+ const DeviceInterface& vkd,
+ const VkDevice device,
+ const VkPhysicalDevice physicalDevice,
+ const VkPipeline pipeline,
+ Allocator& allocator,
+ de::MovePtr<RayTracingPipeline>& rayTracingPipeline,
+ const deUint32 group,
+ const deUint32 groupCount = 1);
+
+ virtual deUint32 getExtraAccelerationDescriptorCount (void) override { return 1; };
+ virtual VkShaderStageFlags getShaderStageFlags (void) override { return ALL_RAY_TRACING_STAGES; }
+ virtual VkPipelineBindPoint getPipelineBindPoint (void) override { return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR; };
+
+ deUint32 m_shaders;
+ deUint32 m_raygenShaderGroup;
+ deUint32 m_missShaderGroup;
+ deUint32 m_hitShaderGroup;
+ deUint32 m_callableShaderGroup;
+ deUint32 m_shaderGroupCount;
+
+ Move<VkDescriptorSetLayout> m_descriptorSetLayoutSvc;
+ Move<VkDescriptorSet> m_descriptorSetSvc;
+
+ de::MovePtr<RayTracingPipeline> m_rayTracingPipeline;
+
+ de::MovePtr<BufferWithMemory> m_raygenShaderBindingTable;
+ de::MovePtr<BufferWithMemory> m_hitShaderBindingTable;
+ de::MovePtr<BufferWithMemory> m_missShaderBindingTable;
+ de::MovePtr<BufferWithMemory> m_callableShaderBindingTable;
+
+ VkStridedDeviceAddressRegionKHR m_raygenShaderBindingTableRegion;
+ VkStridedDeviceAddressRegionKHR m_missShaderBindingTableRegion;
+ VkStridedDeviceAddressRegionKHR m_hitShaderBindingTableRegion;
+ VkStridedDeviceAddressRegionKHR m_callableShaderBindingTableRegion;
+
+ de::SharedPtr<BottomLevelAccelerationStructure> m_bottomLevelAccelerationStructure;
+ de::SharedPtr<TopLevelAccelerationStructure> m_topLevelAccelerationStructure;
+};
+
+BindingAcceleratioStructureRayTracingRayTracingTestInstance::BindingAcceleratioStructureRayTracingRayTracingTestInstance (Context& context,
+ const TestParams& testParams)
+ : BindingAcceleratioStructureTestInstance (context, testParams)
+ , m_shaders (0)
+ , m_raygenShaderGroup (~0u)
+ , m_missShaderGroup (~0u)
+ , m_hitShaderGroup (~0u)
+ , m_callableShaderGroup (~0u)
+ , m_shaderGroupCount (0)
+
+ , m_descriptorSetLayoutSvc ()
+ , m_descriptorSetSvc ()
+
+ , m_rayTracingPipeline ()
+
+ , m_raygenShaderBindingTable ()
+ , m_hitShaderBindingTable ()
+ , m_missShaderBindingTable ()
+ , m_callableShaderBindingTable ()
+
+ , m_raygenShaderBindingTableRegion ()
+ , m_missShaderBindingTableRegion ()
+ , m_hitShaderBindingTableRegion ()
+ , m_callableShaderBindingTableRegion ()
+
+ , m_bottomLevelAccelerationStructure ()
+ , m_topLevelAccelerationStructure ()
+{
+}
+
+void BindingAcceleratioStructureRayTracingRayTracingTestInstance::checkSupport (Context& context,
+ const TestParams& testParams)
+{
+ DE_UNREF(testParams);
+
+ context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline");
+
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& rayTracingPipelineFeaturesKHR = context.getRayTracingPipelineFeatures();
+
+ if (rayTracingPipelineFeaturesKHR.rayTracingPipeline == DE_FALSE)
+ TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline");
+}
+
+void BindingAcceleratioStructureRayTracingRayTracingTestInstance::initPrograms (SourceCollections& programCollection,
+ const TestParams& testParams)
+{
+ const vk::ShaderBuildOptions buildOptions (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
+ const std::string testShaderBody = testParams.testConfigShaderBodyText(testParams);
+ const std::string testBody =
+ " ivec3 pos = ivec3(gl_LaunchIDEXT);\n"
+ " ivec3 size = ivec3(gl_LaunchSizeEXT);\n"
+ + testShaderBody;
+ const std::string testOutClosestHitShader =
+ std::string(glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460)) + "\n"
+ "#extension GL_EXT_ray_tracing : require\n"
+ "\n"
+ "hitAttributeEXT vec3 attribs;\n"
+ "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ + testBody +
+ "}\n";
+ const std::string testInShaderFragment =
+ " uint rayFlags = 0;\n"
+ " uint cullMask = 0xFF;\n"
+ " float tmin = 0.0;\n"
+ " float tmax = 9.0;\n"
+ " vec3 origin = vec3((float(gl_LaunchIDEXT.x) + 0.5f) / float(gl_LaunchSizeEXT.x), (float(gl_LaunchIDEXT.y) + 0.5f) / float(gl_LaunchSizeEXT.y), 0.0);\n"
+ " vec3 direct = vec3(0.0, 0.0, 1.0);\n"
+ "\n"
+ " traceRayEXT(topLevelAS, rayFlags, cullMask, 1, 0, 1, origin, tmin, direct, tmax, 0);\n";
+ const std::string commonRayGenerationShader =
+ std::string(glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460)) + "\n"
+ "#extension GL_EXT_ray_tracing : require\n"
+ "\n"
+ "layout(location = 0) rayPayloadEXT vec3 hitValue;\n"
+ "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ "layout(set = 2, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " uint rayFlags = 0;\n"
+ " uint cullMask = 0xFF;\n"
+ " float tmin = 0.0;\n"
+ " float tmax = 9.0;\n"
+ " vec3 origin = vec3((float(gl_LaunchIDEXT.x) + 0.5f) / float(gl_LaunchSizeEXT.x), (float(gl_LaunchIDEXT.y) + 0.5f) / float(gl_LaunchSizeEXT.y), 0.0);\n"
+ " vec3 direct = vec3(0.0, 0.0, -1.0);\n"
+ "\n"
+ " traceRayEXT(topLevelAS, rayFlags, cullMask, 0, 0, 0, origin, tmin, direct, tmax, 0);\n"
+ "}\n";
+
+ programCollection.glslSources.add("chit0") << glu::ClosestHitSource(testOutClosestHitShader) << buildOptions;
+ programCollection.glslSources.add("ahit0") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("miss0") << glu::MissSource(getMissPassthrough()) << buildOptions;
+
+ switch (testParams.stage)
+ {
+ case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
+ {
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "\n"
+ << "layout(location = 0) rayPayloadEXT vec3 hitValue;\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testInShaderFragment
+ << "}\n";
+
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(css.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
+ {
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;
+
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "\n"
+ << "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ << "hitAttributeEXT vec3 attribs;\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testInShaderFragment
+ << "}\n";
+
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(css.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("miss") << glu::MissSource(getMissPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ case VK_SHADER_STAGE_MISS_BIT_KHR:
+ {
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(commonRayGenerationShader) << buildOptions;
+
+ {
+ std::stringstream css;
+ css << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_460) << "\n"
+ << "#extension GL_EXT_ray_tracing : require\n"
+ << "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ << "\n"
+ << "layout(set = 0, binding = 0) uniform accelerationStructureEXT topLevelAS;\n"
+ << "layout(set = 1, binding = 0, r32i) uniform iimage3D result;\n"
+ << "\n"
+ << "void main()\n"
+ << "{\n"
+ << testInShaderFragment
+ << "}\n";
+
+ programCollection.glslSources.add("miss") << glu::MissSource(css.str()) << buildOptions;
+ }
+
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(getHitPassthrough()) << buildOptions;
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(getHitPassthrough()) << buildOptions;
+
+ break;
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown stage");
+ }
+}
+
+void BindingAcceleratioStructureRayTracingRayTracingTestInstance::calcShaderGroup (deUint32& shaderGroupCounter,
+ const VkShaderStageFlags shaders1,
+ const VkShaderStageFlags shaders2,
+ const VkShaderStageFlags shaderStageFlags,
+ deUint32& shaderGroup,
+ deUint32& shaderGroupCount) const
+{
+ const deUint32 shader1Count = ((shaders1 & shaderStageFlags) != 0) ? 1 : 0;
+ const deUint32 shader2Count = ((shaders2 & shaderStageFlags) != 0) ? 1 : 0;
+
+ shaderGroupCount = shader1Count + shader2Count;
+
+ if (shaderGroupCount != 0)
+ {
+ shaderGroup = shaderGroupCounter;
+ shaderGroupCounter += shaderGroupCount;
+ }
+}
+
+void BindingAcceleratioStructureRayTracingRayTracingTestInstance::initPipeline (void)
+{
+ const InstanceInterface& vki = m_context.getInstanceInterface();
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
+ vk::BinaryCollection& collection = m_context.getBinaryCollection();
+ Allocator& allocator = m_context.getDefaultAllocator();
+ const deUint32 shaderGroupHandleSize = getShaderGroupHandleSize(vki, physicalDevice);
+ const VkShaderStageFlags hitStages = VK_SHADER_STAGE_ANY_HIT_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
+ deUint32 shaderCount = 0;
+ VkShaderStageFlags shaders0 = static_cast<VkShaderStageFlags>(0);
+ deUint32 raygenShaderGroupCount = 0;
+ deUint32 hitShaderGroupCount = 0;
+ deUint32 missShaderGroupCount = 0;
+
+ if (collection.contains("rgen")) m_shaders |= VK_SHADER_STAGE_RAYGEN_BIT_KHR;
+ if (collection.contains("ahit")) m_shaders |= VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
+ if (collection.contains("chit")) m_shaders |= VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
+ if (collection.contains("miss")) m_shaders |= VK_SHADER_STAGE_MISS_BIT_KHR;
+
+ if (collection.contains("ahit0")) shaders0 |= VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
+ if (collection.contains("chit0")) shaders0 |= VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
+ if (collection.contains("miss0")) shaders0 |= VK_SHADER_STAGE_MISS_BIT_KHR;
+
+ for (BinaryCollection::Iterator it = collection.begin(); it != collection.end(); ++it)
+ shaderCount++;
+
+ if (shaderCount != (deUint32)(dePop32(m_shaders) + dePop32(shaders0)))
+ TCU_THROW(InternalError, "Unused shaders detected in the collection");
+
+ calcShaderGroup(m_shaderGroupCount, m_shaders, shaders0, VK_SHADER_STAGE_RAYGEN_BIT_KHR, m_raygenShaderGroup, raygenShaderGroupCount);
+ calcShaderGroup(m_shaderGroupCount, m_shaders, shaders0, VK_SHADER_STAGE_MISS_BIT_KHR, m_missShaderGroup, missShaderGroupCount);
+ calcShaderGroup(m_shaderGroupCount, m_shaders, shaders0, hitStages, m_hitShaderGroup, hitShaderGroupCount);
+
+ m_rayTracingPipeline = de::newMovePtr<RayTracingPipeline>();
+
+ m_descriptorSetLayoutSvc = DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, ALL_RAY_TRACING_STAGES)
+ .build(vkd, device);
+ m_descriptorSetSvc = makeDescriptorSet(vkd, device, *m_descriptorPool, *m_descriptorSetLayoutSvc);
+
+ if (0 != (m_shaders & VK_SHADER_STAGE_RAYGEN_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR , createShaderModule(vkd, device, collection.get("rgen"), 0), m_raygenShaderGroup);
+ if (0 != (m_shaders & VK_SHADER_STAGE_ANY_HIT_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR , createShaderModule(vkd, device, collection.get("ahit"), 0), m_hitShaderGroup);
+ if (0 != (m_shaders & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR , createShaderModule(vkd, device, collection.get("chit"), 0), m_hitShaderGroup);
+ if (0 != (m_shaders & VK_SHADER_STAGE_MISS_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR , createShaderModule(vkd, device, collection.get("miss"), 0), m_missShaderGroup);
+
+ if (0 != (shaders0 & VK_SHADER_STAGE_ANY_HIT_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR , createShaderModule(vkd, device, collection.get("ahit0"), 0), m_hitShaderGroup + 1);
+ if (0 != (shaders0 & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR , createShaderModule(vkd, device, collection.get("chit0"), 0), m_hitShaderGroup + 1);
+ if (0 != (shaders0 & VK_SHADER_STAGE_MISS_BIT_KHR)) m_rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR , createShaderModule(vkd, device, collection.get("miss0"), 0), m_missShaderGroup + 1);
+
+ m_pipelineLayout = makePipelineLayout(vkd, device, m_descriptorSetLayoutAS.get(), m_descriptorSetLayoutImg.get(), m_descriptorSetLayoutSvc.get());
+ m_pipeline = m_rayTracingPipeline->createPipeline(vkd, device, *m_pipelineLayout);
+
+ m_raygenShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_raygenShaderGroup, raygenShaderGroupCount);
+ m_missShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_missShaderGroup, missShaderGroupCount);
+ m_hitShaderBindingTable = createShaderBindingTable(vki, vkd, device, physicalDevice, *m_pipeline, allocator, m_rayTracingPipeline, m_hitShaderGroup, hitShaderGroupCount);
+
+ m_raygenShaderBindingTableRegion = makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_raygenShaderBindingTable), shaderGroupHandleSize, raygenShaderGroupCount);
+ m_missShaderBindingTableRegion = makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_missShaderBindingTable), shaderGroupHandleSize, missShaderGroupCount);
+ m_hitShaderBindingTableRegion = makeStridedDeviceAddressRegion(vkd, device, getVkBuffer(m_hitShaderBindingTable), shaderGroupHandleSize, hitShaderGroupCount);
+ m_callableShaderBindingTableRegion = makeStridedDeviceAddressRegion(vkd, device, DE_NULL, 0, 0);
+}
+
+void BindingAcceleratioStructureRayTracingRayTracingTestInstance::fillCommandBuffer (VkCommandBuffer commandBuffer)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ Allocator& allocator = m_context.getDefaultAllocator();
+ de::MovePtr<BottomLevelAccelerationStructure> bottomLevelAccelerationStructure = makeBottomLevelAccelerationStructure();
+ de::MovePtr<TopLevelAccelerationStructure> topLevelAccelerationStructure = makeTopLevelAccelerationStructure();
+
+ m_bottomLevelAccelerationStructure = de::SharedPtr<BottomLevelAccelerationStructure>(bottomLevelAccelerationStructure.release());
+ m_bottomLevelAccelerationStructure->setDefaultGeometryData(m_testParams.stage);
+ m_bottomLevelAccelerationStructure->createAndBuild(vkd, device, commandBuffer, allocator);
+
+ m_topLevelAccelerationStructure = de::SharedPtr<TopLevelAccelerationStructure>(topLevelAccelerationStructure.release());
+ m_topLevelAccelerationStructure->setInstanceCount(1);
+ m_topLevelAccelerationStructure->addInstance(m_bottomLevelAccelerationStructure);
+ m_topLevelAccelerationStructure->createAndBuild(vkd, device, commandBuffer, allocator);
+
+ const TopLevelAccelerationStructure* topLevelAccelerationStructurePtr = m_topLevelAccelerationStructure.get();
+ const VkWriteDescriptorSetAccelerationStructureKHR accelerationStructureWriteDescriptorSet = makeWriteDescriptorSetAccelerationStructureKHR(topLevelAccelerationStructurePtr->getPtr());
+
+ DescriptorSetUpdateBuilder()
+ .writeSingle(*m_descriptorSetSvc, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &accelerationStructureWriteDescriptorSet)
+ .update(vkd, device);
+
+ vkd.cmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *m_pipelineLayout, 2, 1, &m_descriptorSetSvc.get(), 0, DE_NULL);
+
+ vkd.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, m_pipeline.get());
+
+ cmdTraceRays(vkd,
+ commandBuffer,
+ &m_raygenShaderBindingTableRegion,
+ &m_missShaderBindingTableRegion,
+ &m_hitShaderBindingTableRegion,
+ &m_callableShaderBindingTableRegion,
+ m_testParams.width, m_testParams.height, 1);
+}
+
+de::MovePtr<BufferWithMemory> BindingAcceleratioStructureRayTracingRayTracingTestInstance::createShaderBindingTable (const InstanceInterface& vki,
+ const DeviceInterface& vkd,
+ const VkDevice device,
+ const VkPhysicalDevice physicalDevice,
+ const VkPipeline pipeline,
+ Allocator& allocator,
+ de::MovePtr<RayTracingPipeline>& rayTracingPipeline,
+ const deUint32 group,
+ const deUint32 groupCount)
+{
+ de::MovePtr<BufferWithMemory> shaderBindingTable;
+
+ if (group < m_shaderGroupCount)
+ {
+ const deUint32 shaderGroupHandleSize = getShaderGroupHandleSize(vki, physicalDevice);
+ const deUint32 shaderGroupBaseAlignment = getShaderGroupBaseAlignment(vki, physicalDevice);
+
+ shaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, group, groupCount);
+ }
+
+ return shaderBindingTable;
+}
+
+
+const std::string getRayQueryShaderBodyText (const TestParams& testParams)
+{
+ DE_UNREF(testParams);
+
+ const std::string result =
+ " const float mult = " + de::toString(FIXED_POINT_DIVISOR) + ".0f;\n"
+ " uint rayFlags = 0;\n"
+ " uint cullMask = 0xFF;\n"
+ " float tmin = 0.0;\n"
+ " float tmax = 9.0;\n"
+ " vec3 origin = vec3((float(pos.x) + 0.5f) / float(size.x), (float(pos.y) + 0.5f) / float(size.y), 0.0);\n"
+ " vec3 direct = vec3(0.0, 0.0, 1.0);\n"
+ " int value = 0;\n"
+ " rayQueryEXT rayQuery;\n"
+ "\n"
+ " rayQueryInitializeEXT(rayQuery, tlas, rayFlags, cullMask, origin, tmin, direct, tmax);\n"
+ "\n"
+ " while(rayQueryProceedEXT(rayQuery))\n"
+ " {\n"
+ " if (rayQueryGetIntersectionTypeEXT(rayQuery, false) == gl_RayQueryCandidateIntersectionTriangleEXT)\n"
+ " {\n"
+ " const float t = rayQueryGetIntersectionTEXT(rayQuery, false);"
+ "\n"
+ " value = int(round(mult * t));\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " imageStore(result, pos, ivec4(value, 0, 0, 0));\n";
+
+ return result;
+}
+
+const std::string getRayTracingShaderBodyText (const TestParams& testParams)
+{
+ DE_UNREF(testParams);
+
+ const std::string result =
+ " const float mult = " + de::toString(FIXED_POINT_DIVISOR) + ".0f;\n"
+ " int value = int(round(mult * gl_HitTEXT));\n"
+ "\n"
+ " imageStore(result, pos, ivec4(value, 0, 0, 0));\n";
+
+ return result;
+}
+
+class BindingAccelerationStructureTestCase : public TestCase
+{
+ public:
+ BindingAccelerationStructureTestCase (tcu::TestContext& context, const char* name, const char* desc, const TestParams testParams);
+ ~BindingAccelerationStructureTestCase (void);
+
+ virtual void checkSupport (Context& context) const;
+ virtual void initPrograms (SourceCollections& programCollection) const;
+ virtual TestInstance* createInstance (Context& context) const;
+
+private:
+ TestParams m_testParams;
+};
+
+BindingAccelerationStructureTestCase::BindingAccelerationStructureTestCase (tcu::TestContext& context, const char* name, const char* desc, const TestParams testParams)
+ : vkt::TestCase (context, name, desc)
+ , m_testParams (testParams)
+{
+}
+
+BindingAccelerationStructureTestCase::~BindingAccelerationStructureTestCase (void)
+{
+}
+
+void BindingAccelerationStructureTestCase::checkSupport (Context& context) const
+{
+ context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
+
+ const VkPhysicalDeviceAccelerationStructureFeaturesKHR& accelerationStructureFeaturesKHR = context.getAccelerationStructureFeatures();
+ if (accelerationStructureFeaturesKHR.accelerationStructure == DE_FALSE)
+ TCU_THROW(TestError, "Requires VkPhysicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure");
+
+ switch (m_testParams.testType)
+ {
+ case TEST_TYPE_USING_RAY_QUERY:
+ {
+ context.requireDeviceFunctionality("VK_KHR_ray_query");
+
+ const VkPhysicalDeviceRayQueryFeaturesKHR& rayQueryFeaturesKHR = context.getRayQueryFeatures();
+
+ if (rayQueryFeaturesKHR.rayQuery == DE_FALSE)
+ TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayQueryFeaturesKHR.rayQuery");
+
+ break;
+ }
+
+ case TEST_TYPE_USING_RAY_TRACING:
+ {
+ context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline");
+
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& rayTracingPipelineFeaturesKHR = context.getRayTracingPipelineFeatures();
+
+ if (rayTracingPipelineFeaturesKHR.rayTracingPipeline == DE_FALSE)
+ TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline");
+
+ break;
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown test type");
+ }
+
+ switch (m_testParams.updateMethod)
+ {
+ case UPDATE_METHOD_NORMAL:
+ {
+ break;
+ }
+
+ case UPDATE_METHOD_WITH_TEMPLATE:
+ {
+ context.requireDeviceFunctionality("VK_KHR_descriptor_update_template");
+
+ break;
+ }
+
+ case UPDATE_METHOD_WITH_PUSH:
+ {
+ context.requireDeviceFunctionality("VK_KHR_push_descriptor");
+
+ break;
+ }
+
+ case UPDATE_METHOD_WITH_PUSH_TEMPLATE:
+ {
+ context.requireDeviceFunctionality("VK_KHR_push_descriptor");
+ context.requireDeviceFunctionality("VK_KHR_descriptor_update_template");
+
+ break;
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown update method");
+ }
+
+ m_testParams.pipelineCheckSupport(context, m_testParams);
+}
+
+TestInstance* BindingAccelerationStructureTestCase::createInstance (Context& context) const
+{
+ switch (m_testParams.testType)
+ {
+ case TEST_TYPE_USING_RAY_QUERY:
+ {
+ switch (m_testParams.stage)
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ {
+ return new BindingAcceleratioStructureGraphicsTestInstance(context, m_testParams);
+ }
+
+ case VK_SHADER_STAGE_COMPUTE_BIT:
+ {
+ return new BindingAcceleratioStructureComputeTestInstance(context, m_testParams);
+ }
+
+ case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
+ case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
+ case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
+ case VK_SHADER_STAGE_MISS_BIT_KHR:
+ case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
+ case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
+ {
+ return new BindingAcceleratioStructureRayTracingTestInstance(context, m_testParams);
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown shader stage");
+ }
+ }
+
+ case TEST_TYPE_USING_RAY_TRACING:
+ {
+ return new BindingAcceleratioStructureRayTracingRayTracingTestInstance(context, m_testParams);
+ }
+
+ default:
+ TCU_THROW(InternalError, "Unknown shader stage");
+ }
+}
+
+void BindingAccelerationStructureTestCase::initPrograms (SourceCollections& programCollection) const
+{
+ m_testParams.pipelineInitPrograms(programCollection, m_testParams);
+}
+
+static inline CheckSupportFunc getPipelineRayQueryCheckSupport (const VkShaderStageFlagBits stage)
+{
+ switch (stage)
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ return BindingAcceleratioStructureGraphicsTestInstance::checkSupport;
+
+ case VK_SHADER_STAGE_COMPUTE_BIT:
+ return BindingAcceleratioStructureComputeTestInstance::checkSupport;
+
+ case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
+ case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
+ case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
+ case VK_SHADER_STAGE_MISS_BIT_KHR:
+ case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
+ case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
+ return BindingAcceleratioStructureRayTracingTestInstance::checkSupport;
+
+ default:
+ TCU_THROW(InternalError, "Unknown shader stage");
+ }
+}
+
+static inline CheckSupportFunc getPipelineRayTracingCheckSupport (const VkShaderStageFlagBits stage)
+{
+ DE_UNREF(stage);
+
+ return BindingAcceleratioStructureRayTracingRayTracingTestInstance::checkSupport;
+}
+
+static inline InitProgramsFunc getPipelineRayQueryInitPrograms (const VkShaderStageFlagBits stage)
+{
+ switch (stage)
+ {
+ case VK_SHADER_STAGE_VERTEX_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
+ case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
+ case VK_SHADER_STAGE_GEOMETRY_BIT:
+ case VK_SHADER_STAGE_FRAGMENT_BIT:
+ return BindingAcceleratioStructureGraphicsTestInstance::initPrograms;
+
+ case VK_SHADER_STAGE_COMPUTE_BIT:
+ return BindingAcceleratioStructureComputeTestInstance::initPrograms;
+
+ case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
+ case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
+ case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
+ case VK_SHADER_STAGE_MISS_BIT_KHR:
+ case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
+ case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
+ return BindingAcceleratioStructureRayTracingTestInstance::initPrograms;
+
+ default:
+ TCU_THROW(InternalError, "Unknown shader stage");
+ }
+}
+
+static inline InitProgramsFunc getPipelineRayTracingInitPrograms (const VkShaderStageFlagBits stage)
+{
+ DE_UNREF(stage);
+
+ return BindingAcceleratioStructureRayTracingRayTracingTestInstance::initPrograms;
+}
+
+static inline ShaderBodyTextFunc getShaderBodyTextFunc (const TestType testType)
+{
+ switch (testType)
+ {
+ case TEST_TYPE_USING_RAY_QUERY: return getRayQueryShaderBodyText; break;
+ case TEST_TYPE_USING_RAY_TRACING: return getRayTracingShaderBodyText; break;
+ default: TCU_THROW(InternalError, "Unknown test type");
+ }
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createDescriptorUpdateASTests (tcu::TestContext& testCtx)
+{
+ de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "acceleration_structure", "Tests acceleration structure descriptor updates"));
+
+ const struct TestTypes
+ {
+ TestType testType;
+ const char* name;
+ }
+ testTypes[] =
+ {
+ { TEST_TYPE_USING_RAY_QUERY, "ray_query" },
+ { TEST_TYPE_USING_RAY_TRACING, "ray_tracing" },
+ };
+ const struct UpdateMethods
+ {
+ const UpdateMethod method;
+ const char* name;
+ const char* description;
+ }
+ updateMethods[] =
+ {
+ { UPDATE_METHOD_NORMAL, "regular", "Use regular descriptor updates" },
+ { UPDATE_METHOD_WITH_TEMPLATE, "with_template", "Use descriptor update templates" },
+ { UPDATE_METHOD_WITH_PUSH, "with_push", "Use push descriptor updates" },
+ { UPDATE_METHOD_WITH_PUSH_TEMPLATE, "with_push_template", "Use push descriptor update templates" },
+ };
+ const struct PipelineStages
+ {
+ VkShaderStageFlagBits stage;
+ const char* name;
+ const bool rayTracing;
+ }
+ pipelineStages[] =
+ {
+ { VK_SHADER_STAGE_VERTEX_BIT, "vert", false },
+ { VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, "tesc", false },
+ { VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, "tese", false },
+ { VK_SHADER_STAGE_GEOMETRY_BIT, "geom", false },
+ { VK_SHADER_STAGE_FRAGMENT_BIT, "frag", false },
+ { VK_SHADER_STAGE_COMPUTE_BIT, "comp", false },
+ { VK_SHADER_STAGE_RAYGEN_BIT_KHR, "rgen", true },
+ { VK_SHADER_STAGE_ANY_HIT_BIT_KHR, "ahit", false },
+ { VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, "chit", true },
+ { VK_SHADER_STAGE_MISS_BIT_KHR, "miss", true },
+ { VK_SHADER_STAGE_INTERSECTION_BIT_KHR, "sect", false },
+ { VK_SHADER_STAGE_CALLABLE_BIT_KHR, "call", false },
+ };
+
+ for (size_t testTypeNdx = 0; testTypeNdx < DE_LENGTH_OF_ARRAY(testTypes); ++testTypeNdx)
+ {
+ de::MovePtr<tcu::TestCaseGroup> testTypeGroup (new tcu::TestCaseGroup(group->getTestContext(), testTypes[testTypeNdx].name, ""));
+ const TestType testType = testTypes[testTypeNdx].testType;
+ const ShaderBodyTextFunc shaderBodyTextFunc = getShaderBodyTextFunc(testType);
+ const deUint32 imageDepth = 1;
+
+ for (size_t updateMethodsNdx = 0; updateMethodsNdx < DE_LENGTH_OF_ARRAY(updateMethods); ++updateMethodsNdx)
+ {
+ de::MovePtr<tcu::TestCaseGroup> updateMethodsGroup (new tcu::TestCaseGroup(group->getTestContext(), updateMethods[updateMethodsNdx].name, updateMethods[updateMethodsNdx].description));
+ const UpdateMethod updateMethod = updateMethods[updateMethodsNdx].method;
+
+ for (size_t pipelineStageNdx = 0; pipelineStageNdx < DE_LENGTH_OF_ARRAY(pipelineStages); ++pipelineStageNdx)
+ {
+ const VkShaderStageFlagBits stage = pipelineStages[pipelineStageNdx].stage;
+ const CheckSupportFunc pipelineCheckSupport = (testType == TEST_TYPE_USING_RAY_QUERY)
+ ? getPipelineRayQueryCheckSupport(stage)
+ : getPipelineRayTracingCheckSupport(stage);
+ const InitProgramsFunc pipelineInitPrograms = (testType == TEST_TYPE_USING_RAY_QUERY)
+ ? getPipelineRayQueryInitPrograms(stage)
+ : getPipelineRayTracingInitPrograms(stage);
+
+ if (testType == TEST_TYPE_USING_RAY_TRACING && !pipelineStages[pipelineStageNdx].rayTracing)
+ continue;
+
+ const TestParams testParams =
+ {
+ TEST_WIDTH, // deUint32 width;
+ TEST_HEIGHT, // deUint32 height;
+ imageDepth, // deUint32 depth;
+ testType, // TestType testType;
+ updateMethod, // UpdateMethod updateMethod;
+ stage, // VkShaderStageFlagBits stage;
+ VK_FORMAT_R32_SINT, // VkFormat format;
+ pipelineCheckSupport, // CheckSupportFunc pipelineCheckSupport;
+ pipelineInitPrograms, // InitProgramsFunc pipelineInitPrograms;
+ shaderBodyTextFunc, // ShaderTestTextFunc testConfigShaderBodyText;
+ };
+
+ updateMethodsGroup->addChild(new BindingAccelerationStructureTestCase(group->getTestContext(), pipelineStages[pipelineStageNdx].name, "", testParams));
+ }
+
+ testTypeGroup->addChild(updateMethodsGroup.release());
+ }
+
+ group->addChild(testTypeGroup.release());
+ }
+
+ return group.release();
+}
+
+} // RayQuery
+} // vkt
projects / platform / upstream / VK-GL-CTS.git / commitdiff