external/vulkancts/modules/vulkan/compute/vktComputeShaderBuiltinVarTests.cpp \
external/vulkancts/modules/vulkan/compute/vktComputeTests.cpp \
external/vulkancts/modules/vulkan/compute/vktComputeTestsUtil.cpp \
+ external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalClearAttachmentTests.cpp \
+ external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalDispatchTests.cpp \
+ external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalDrawTests.cpp \
+ external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalRenderingTestUtil.cpp \
+ external/vulkancts/modules/vulkan/conditional_rendering/vktConditionalTests.cpp \
external/vulkancts/modules/vulkan/device_group/vktDeviceGroupRendering.cpp \
external/vulkancts/modules/vulkan/draw/vktBasicDrawTests.cpp \
external/vulkancts/modules/vulkan/draw/vktDrawBaseClass.cpp \
$(deqp_dir)/external/vulkancts/modules/vulkan/binding_model \
$(deqp_dir)/external/vulkancts/modules/vulkan/clipping \
$(deqp_dir)/external/vulkancts/modules/vulkan/compute \
+ $(deqp_dir)/external/vulkancts/modules/vulkan/conditional_rendering \
$(deqp_dir)/external/vulkancts/modules/vulkan/device_group \
$(deqp_dir)/external/vulkancts/modules/vulkan/draw \
$(deqp_dir)/external/vulkancts/modules/vulkan/dynamic_state \
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.comp
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.vert
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.frag
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_execution.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_noop.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_execution_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_noop_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_execution.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_noop.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_execution_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_noop_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.no_condition_secondary_buffer_expect_execution.clear_attachments
VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
+ VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
enum VkBufferUsageFlagBits
{
- VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
- VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
- VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
- VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
- VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
- VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
- VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
- VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
- VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+ VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
+ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
+ VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
+ VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
+ VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
+ VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
+ VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
+ VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
+ VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
};
typedef deUint32 VkBufferUsageFlags;
VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
+ VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
};
typedef deUint32 VkExternalMemoryFeatureFlagsNV;
+enum VkConditionalRenderingFlagBitsEXT
+{
+ VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
+};
+typedef deUint32 VkConditionalRenderingFlagsEXT;
+
enum VkIndirectCommandsLayoutUsageFlagBitsNVX
{
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
virtual void cmdDrawIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const;
virtual void cmdDrawIndexedIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const;
virtual VkResult getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle) const;
+virtual void cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const;
+virtual void cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer) const;
virtual void cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) const;
virtual void cmdReserveSpaceForCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) const;
virtual VkResult createIndirectCommandsLayoutNVX (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) const;
return m_vk.getMemoryWin32HandleNV(device, memory, handleType, pHandle);
}
+void DeviceDriver::cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const
+{
+ m_vk.cmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
+}
+
+void DeviceDriver::cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer) const
+{
+ m_vk.cmdEndConditionalRenderingEXT(commandBuffer);
+}
+
void DeviceDriver::cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) const
{
m_vk.cmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
CmdDrawIndirectCountKHRFunc cmdDrawIndirectCountKHR;
CmdDrawIndexedIndirectCountKHRFunc cmdDrawIndexedIndirectCountKHR;
GetMemoryWin32HandleNVFunc getMemoryWin32HandleNV;
+CmdBeginConditionalRenderingEXTFunc cmdBeginConditionalRenderingEXT;
+CmdEndConditionalRenderingEXTFunc cmdEndConditionalRenderingEXT;
CmdProcessCommandsNVXFunc cmdProcessCommandsNVX;
CmdReserveSpaceForCommandsNVXFunc cmdReserveSpaceForCommandsNVX;
CreateIndirectCommandsLayoutNVXFunc createIndirectCommandsLayoutNVX;
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceExternalImageFormatPropertiesNVFunc) (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetMemoryWin32HandleNVFunc) (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateViSurfaceNNFunc) (VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdBeginConditionalRenderingEXTFunc) (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdEndConditionalRenderingEXTFunc) (VkCommandBuffer commandBuffer);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdProcessCommandsNVXFunc) (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdReserveSpaceForCommandsNVXFunc) (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateIndirectCommandsLayoutNVXFunc) (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
return VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
}
+template<> VkStructureType getStructureType<VkConditionalRenderingBeginInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDeviceConditionalRenderingFeaturesEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+}
+
+template<> VkStructureType getStructureType<VkCommandBufferInheritanceConditionalRenderingInfoEXT> (void)
+{
+ return VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
+}
+
template<> VkStructureType getStructureType<VkDeviceGeneratedCommandsFeaturesNVX> (void)
{
return VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX;
m_vk.cmdDrawIndirectCountKHR = (CmdDrawIndirectCountKHRFunc) GET_PROC_ADDR("vkCmdDrawIndirectCountKHR");
m_vk.cmdDrawIndexedIndirectCountKHR = (CmdDrawIndexedIndirectCountKHRFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirectCountKHR");
m_vk.getMemoryWin32HandleNV = (GetMemoryWin32HandleNVFunc) GET_PROC_ADDR("vkGetMemoryWin32HandleNV");
+m_vk.cmdBeginConditionalRenderingEXT = (CmdBeginConditionalRenderingEXTFunc) GET_PROC_ADDR("vkCmdBeginConditionalRenderingEXT");
+m_vk.cmdEndConditionalRenderingEXT = (CmdEndConditionalRenderingEXTFunc) GET_PROC_ADDR("vkCmdEndConditionalRenderingEXT");
m_vk.cmdProcessCommandsNVX = (CmdProcessCommandsNVXFunc) GET_PROC_ADDR("vkCmdProcessCommandsNVX");
m_vk.cmdReserveSpaceForCommandsNVX = (CmdReserveSpaceForCommandsNVXFunc) GET_PROC_ADDR("vkCmdReserveSpaceForCommandsNVX");
m_vk.createIndirectCommandsLayoutNVX = (CreateIndirectCommandsLayoutNVXFunc) GET_PROC_ADDR("vkCreateIndirectCommandsLayoutNVX");
return VK_SUCCESS;
}
+VKAPI_ATTR void VKAPI_CALL cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
+{
+ DE_UNREF(commandBuffer);
+ DE_UNREF(pConditionalRenderingBegin);
+}
+
+VKAPI_ATTR void VKAPI_CALL cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer)
+{
+ DE_UNREF(commandBuffer);
+}
+
VKAPI_ATTR void VKAPI_CALL cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
{
DE_UNREF(commandBuffer);
VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountKHR, cmdDrawIndirectCountKHR),
VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountKHR, cmdDrawIndexedIndirectCountKHR),
VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV, getMemoryWin32HandleNV),
+ VK_NULL_FUNC_ENTRY(vkCmdBeginConditionalRenderingEXT, cmdBeginConditionalRenderingEXT),
+ VK_NULL_FUNC_ENTRY(vkCmdEndConditionalRenderingEXT, cmdEndConditionalRenderingEXT),
VK_NULL_FUNC_ENTRY(vkCmdProcessCommandsNVX, cmdProcessCommandsNVX),
VK_NULL_FUNC_ENTRY(vkCmdReserveSpaceForCommandsNVX, cmdReserveSpaceForCommandsNVX),
VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNVX, createIndirectCommandsLayoutNVX),
tcu::Format::Bitfield<32> getDebugReportFlagsEXTStr (VkDebugReportFlagsEXT value);
tcu::Format::Bitfield<32> getExternalMemoryHandleTypeFlagsNVStr (VkExternalMemoryHandleTypeFlagsNV value);
tcu::Format::Bitfield<32> getExternalMemoryFeatureFlagsNVStr (VkExternalMemoryFeatureFlagsNV value);
+tcu::Format::Bitfield<32> getConditionalRenderingFlagsEXTStr (VkConditionalRenderingFlagsEXT value);
tcu::Format::Bitfield<32> getIndirectCommandsLayoutUsageFlagsNVXStr (VkIndirectCommandsLayoutUsageFlagsNVX value);
tcu::Format::Bitfield<32> getObjectEntryUsageFlagsNVXStr (VkObjectEntryUsageFlagsNVX value);
tcu::Format::Bitfield<32> getSurfaceCounterFlagsEXTStr (VkSurfaceCounterFlagsEXT value);
std::ostream& operator<< (std::ostream& s, const VkWin32KeyedMutexAcquireReleaseInfoNV& value);
std::ostream& operator<< (std::ostream& s, const VkValidationFlagsEXT& value);
std::ostream& operator<< (std::ostream& s, const VkViSurfaceCreateInfoNN& value);
+std::ostream& operator<< (std::ostream& s, const VkConditionalRenderingBeginInfoEXT& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceConditionalRenderingFeaturesEXT& value);
+std::ostream& operator<< (std::ostream& s, const VkCommandBufferInheritanceConditionalRenderingInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsFeaturesNVX& value);
std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsLimitsNVX& value);
std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsTokenNVX& value);
case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR";
case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT";
+ case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: return "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT";
case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR";
case VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX: return "VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX";
case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX: return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX";
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_USAGE_TRANSFER_DST_BIT, "VK_BUFFER_USAGE_TRANSFER_DST_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_USAGE_INDEX_BUFFER_BIT, "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"),
- tcu::Format::BitDesc(VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_TRANSFER_DST_BIT, "VK_BUFFER_USAGE_TRANSFER_DST_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_INDEX_BUFFER_BIT, "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
tcu::Format::BitDesc(VK_ACCESS_HOST_WRITE_BIT, "VK_ACCESS_HOST_WRITE_BIT"),
tcu::Format::BitDesc(VK_ACCESS_MEMORY_READ_BIT, "VK_ACCESS_MEMORY_READ_BIT"),
tcu::Format::BitDesc(VK_ACCESS_MEMORY_WRITE_BIT, "VK_ACCESS_MEMORY_WRITE_BIT"),
+ tcu::Format::BitDesc(VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT, "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT"),
tcu::Format::BitDesc(VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX, "VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX"),
tcu::Format::BitDesc(VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, "VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX"),
tcu::Format::BitDesc(VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"),
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
+tcu::Format::Bitfield<32> getConditionalRenderingFlagsEXTStr (VkConditionalRenderingFlagsEXT value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT, "VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
tcu::Format::Bitfield<32> getIndirectCommandsLayoutUsageFlagsNVXStr (VkIndirectCommandsLayoutUsageFlagsNVX value)
{
static const tcu::Format::BitDesc s_desc[] =
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkConditionalRenderingBeginInfoEXT& value)
+{
+ s << "VkConditionalRenderingBeginInfoEXT = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tbuffer = " << value.buffer << '\n';
+ s << "\toffset = " << value.offset << '\n';
+ s << "\tflags = " << getConditionalRenderingFlagsEXTStr(value.flags) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceConditionalRenderingFeaturesEXT& value)
+{
+ s << "VkPhysicalDeviceConditionalRenderingFeaturesEXT = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tconditionalRendering = " << value.conditionalRendering << '\n';
+ s << "\tinheritedConditionalRendering = " << value.inheritedConditionalRendering << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkCommandBufferInheritanceConditionalRenderingInfoEXT& value)
+{
+ s << "VkCommandBufferInheritanceConditionalRenderingInfoEXT = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tconditionalRenderingEnable = " << value.conditionalRenderingEnable << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsFeaturesNVX& value)
{
s << "VkDeviceGeneratedCommandsFeaturesNVX = {\n";
void* window;
};
+struct VkConditionalRenderingBeginInfoEXT
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkConditionalRenderingFlagsEXT flags;
+};
+
+struct VkPhysicalDeviceConditionalRenderingFeaturesEXT
+{
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 conditionalRendering;
+ VkBool32 inheritedConditionalRendering;
+};
+
+struct VkCommandBufferInheritanceConditionalRenderingInfoEXT
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 conditionalRenderingEnable;
+};
+
struct VkDeviceGeneratedCommandsFeaturesNVX
{
VkStructureType sType;
virtual void cmdDrawIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const = 0;
virtual void cmdDrawIndexedIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const = 0;
virtual VkResult getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle) const = 0;
+virtual void cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const = 0;
+virtual void cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer) const = 0;
virtual void cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) const = 0;
virtual void cmdReserveSpaceForCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) const = 0;
virtual VkResult createIndirectCommandsLayoutNVX (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) const = 0;
add_subdirectory(dynamic_state)
add_subdirectory(ssbo)
add_subdirectory(query_pool)
+add_subdirectory(conditional_rendering)
add_subdirectory(draw)
add_subdirectory(device_group)
add_subdirectory(compute)
dynamic_state
ssbo
query_pool
+ conditional_rendering
draw
device_group
compute
deqp-vk-dynamic-state
deqp-vk-ssbo
deqp-vk-query-pool
+ deqp-vk-conditional-rendering
deqp-vk-draw
deqp-vk-device-group
deqp-vk-compute
log << TestLog::Message << extFeatures << TestLog::EndMessage;
vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
- const bool khr_8bit_storage = checkExtension(properties,"VK_KHR_8bit_storage");;
- bool khr_16bit_storage = true;
- bool khr_multiview = true;
- bool deviceProtectedMemory = true;
- bool sampler_ycbcr_conversion = true;
- bool variable_pointers = true;
+ const bool khr_8bit_storage = checkExtension(properties,"VK_KHR_8bit_storage");
+ const bool ext_conditional_rendering = checkExtension(properties,"VK_EXT_conditional_rendering");
+ bool khr_16bit_storage = true;
+ bool khr_multiview = true;
+ bool deviceProtectedMemory = true;
+ bool sampler_ycbcr_conversion = true;
+ bool variable_pointers = true;
if (getPhysicalDeviceProperties(vki, physicalDevice).apiVersion < VK_API_VERSION_1_1)
{
khr_16bit_storage = checkExtension(properties,"VK_KHR_16bit_storage");
const int count = 2u;
VkPhysicalDevice8BitStorageFeaturesKHR device8BitStorageFeatures[count];
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT deviceConditionalRenderingFeatures[count];
VkPhysicalDevice16BitStorageFeatures device16BitStorageFeatures[count];
VkPhysicalDeviceMultiviewFeatures deviceMultiviewFeatures[count];
VkPhysicalDeviceProtectedMemoryFeatures protectedMemoryFeatures[count];
for (int ndx = 0; ndx < count; ++ndx)
{
- deMemset(&device8BitStorageFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDevice8BitStorageFeaturesKHR));
- deMemset(&device16BitStorageFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDevice16BitStorageFeatures));
- deMemset(&deviceMultiviewFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceMultiviewFeatures));
- deMemset(&protectedMemoryFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceProtectedMemoryFeatures));
- deMemset(&samplerYcbcrConversionFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
- deMemset(&variablePointerFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceVariablePointerFeatures));
+ deMemset(&device8BitStorageFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDevice8BitStorageFeaturesKHR));
+ deMemset(&deviceConditionalRenderingFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT));
+ deMemset(&device16BitStorageFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDevice16BitStorageFeatures));
+ deMemset(&deviceMultiviewFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceMultiviewFeatures));
+ deMemset(&protectedMemoryFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceProtectedMemoryFeatures));
+ deMemset(&samplerYcbcrConversionFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
+ deMemset(&variablePointerFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceVariablePointerFeatures));
device8BitStorageFeatures[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR;
- device8BitStorageFeatures[ndx].pNext = &device16BitStorageFeatures[ndx];
+ device8BitStorageFeatures[ndx].pNext = &deviceConditionalRenderingFeatures[ndx];
+
+ deviceConditionalRenderingFeatures[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+ deviceConditionalRenderingFeatures[ndx].pNext = &device16BitStorageFeatures[ndx];
device16BitStorageFeatures[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
device16BitStorageFeatures[ndx].pNext = &deviceMultiviewFeatures[ndx];
TCU_FAIL("Mismatch between VkPhysicalDevice8BitStorageFeatures");
}
+ if ( ext_conditional_rendering &&
+ (deviceConditionalRenderingFeatures[0].conditionalRendering != deviceConditionalRenderingFeatures[1].conditionalRendering ||
+ deviceConditionalRenderingFeatures[0].inheritedConditionalRendering != deviceConditionalRenderingFeatures[1].inheritedConditionalRendering )
+ )
+ {
+ TCU_FAIL("Mismatch between VkPhysicalDeviceConditionalRenderingFeaturesEXT");
+ }
+
if ( khr_16bit_storage &&
(device16BitStorageFeatures[0].storageBuffer16BitAccess != device16BitStorageFeatures[1].storageBuffer16BitAccess ||
device16BitStorageFeatures[0].uniformAndStorageBuffer16BitAccess != device16BitStorageFeatures[1].uniformAndStorageBuffer16BitAccess ||
}
if (khr_8bit_storage)
log << TestLog::Message << device8BitStorageFeatures[0] << TestLog::EndMessage;
+ if (ext_conditional_rendering)
+ log << TestLog::Message << deviceConditionalRenderingFeatures[0] << TestLog::EndMessage;
if (khr_16bit_storage)
log << TestLog::Message << toString(device16BitStorageFeatures[0]) << TestLog::EndMessage;
if (khr_multiview)
--- /dev/null
+include_directories(
+ ..
+ ../draw
+ ../compute
+)
+
+set(DEQP_VK_CONDITIONAL_REDENDERING_SRCS
+ vktConditionalRenderingTestUtil.hpp
+ vktConditionalRenderingTestUtil.cpp
+ vktConditionalDrawTests.hpp
+ vktConditionalDrawTests.cpp
+ vktConditionalDispatchTests.hpp
+ vktConditionalDispatchTests.cpp
+ vktConditionalClearAttachmentTests.hpp
+ vktConditionalClearAttachmentTests.cpp
+ vktConditionalTests.hpp
+ vktConditionalTests.cpp
+)
+
+set(DEQP_VK_CONDITIONAL_REDENDERING_LIBS
+ tcutil
+ vkutil
+ deqp-vk-draw
+ deqp-vk-compute
+)
+
+add_library(deqp-vk-conditional-rendering STATIC ${DEQP_VK_CONDITIONAL_REDENDERING_SRCS})
+target_link_libraries(deqp-vk-conditional-rendering ${DEQP_VK_CONDITIONAL_REDENDERING_LIBS})
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Test for conditional rendering of vkCmdClearAttachments
+ *//*--------------------------------------------------------------------*/
+
+#include "vktConditionalClearAttachmentTests.hpp"
+#include "vktConditionalRenderingTestUtil.hpp"
+
+#include "vktTestCaseUtil.hpp"
+#include "vktDrawTestCaseUtil.hpp"
+
+#include "vktDrawBaseClass.hpp"
+
+#include "tcuTestLog.hpp"
+#include "tcuResource.hpp"
+#include "tcuImageCompare.hpp"
+#include "tcuTextureUtil.hpp"
+#include "tcuRGBA.hpp"
+
+#include "vkDefs.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkTypeUtil.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+namespace
+{
+
+struct ConditionalTestSpec : public Draw::TestSpecBase
+{
+ ConditionalData conditionalData;
+};
+
+class ConditionalClearAttachmentTest : public Draw::DrawTestsBaseClass
+{
+public:
+ typedef ConditionalTestSpec TestSpec;
+
+ ConditionalClearAttachmentTest (Context &context, ConditionalTestSpec testSpec);
+
+ virtual tcu::TestStatus iterate (void);
+protected:
+ const ConditionalData m_conditionalData;
+ de::SharedPtr<Draw::Buffer> m_conditionalBuffer;
+
+ vk::Move<vk::VkCommandBuffer> m_secondaryCmdBuffer;
+};
+
+ConditionalClearAttachmentTest::ConditionalClearAttachmentTest (Context &context, ConditionalTestSpec testSpec)
+ : Draw::DrawTestsBaseClass(context, testSpec.shaders[glu::SHADERTYPE_VERTEX], testSpec.shaders[glu::SHADERTYPE_FRAGMENT], vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
+ , m_conditionalData(testSpec.conditionalData)
+{
+ checkConditionalRenderingCapabilities(context, m_conditionalData);
+
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4(0.0f), tcu::Vec4(0.0f), 0));
+
+ initialize();
+
+ m_secondaryCmdBuffer = vk::allocateCommandBuffer(m_vk, m_context.getDevice(), *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY);
+};
+
+tcu::TestStatus ConditionalClearAttachmentTest::iterate (void)
+{
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
+
+ const tcu::Vec4 clearColor = tcu::RGBA::black().toVec();
+ const tcu::Vec4 drawColor = tcu::RGBA::blue().toVec();
+
+ beginRenderPass(m_conditionalData.useSecondaryBuffer ? vk::VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS : vk::VK_SUBPASS_CONTENTS_INLINE);
+
+ vk::VkCommandBuffer targetCmdBuffer = *m_cmdBuffer;
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ const vk::VkCommandBufferInheritanceConditionalRenderingInfoEXT conditionalRenderingInheritanceInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
+ DE_NULL,
+ VK_TRUE // conditionalRenderingEnable
+ };
+
+ const vk::VkCommandBufferInheritanceInfo inheritanceInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ &conditionalRenderingInheritanceInfo,
+ *m_renderPass, // renderPass
+ 0u, // subpass
+ *m_framebuffer, // framebuffer
+ VK_FALSE, // occlusionQueryEnable
+ (vk::VkQueryControlFlags)0u, // queryFlags
+ (vk::VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ };
+
+ const vk::VkCommandBufferBeginInfo commandBufferBeginInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ DE_NULL,
+ vk::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
+ &inheritanceInfo
+ };
+
+ m_vk.beginCommandBuffer(*m_secondaryCmdBuffer, &commandBufferBeginInfo);
+
+ targetCmdBuffer = *m_secondaryCmdBuffer;
+ }
+
+ m_vk.cmdBindPipeline(targetCmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
+
+ const vk::VkClearAttachment clearAttachment =
+ {
+ vk::VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
+ 0u, // deUint32 colorAttachment;
+ vk::makeClearValueColor(drawColor) // VkClearValue clearValue;
+ };
+
+ const vk::VkClearRect rect =
+ {
+ vk::makeRect2D(WIDTH, HEIGHT), // VkRect2D rect;
+ 0u, // uint32_t baseArrayLayer;
+ 1u, // uint32_t layerCount;
+ };
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ m_vk.cmdClearAttachments(*m_secondaryCmdBuffer, 1, &clearAttachment, 1, &rect);
+ }
+
+ if (m_conditionalData.conditionEnabled)
+ {
+ m_conditionalBuffer = createConditionalRenderingBuffer(m_context, m_conditionalData);
+ beginConditionalRendering(m_vk, *m_cmdBuffer, *m_conditionalBuffer, m_conditionalData);
+ }
+
+ if (!m_conditionalData.useSecondaryBuffer)
+ {
+ m_vk.cmdClearAttachments(*m_cmdBuffer, 1, &clearAttachment, 1, &rect);
+ }
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ m_vk.endCommandBuffer(*m_secondaryCmdBuffer);
+
+ m_vk.cmdExecuteCommands(*m_cmdBuffer, 1, &m_secondaryCmdBuffer.get());
+ }
+
+ if (m_conditionalData.conditionEnabled)
+ {
+ m_vk.cmdEndConditionalRenderingEXT(*m_cmdBuffer);
+ }
+
+ endRenderPass(m_vk, *m_cmdBuffer);
+ endCommandBuffer(m_vk, *m_cmdBuffer);
+
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
+
+ // Validation
+ tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
+ referenceFrame.allocLevel(0);
+
+ const deInt32 frameWidth = referenceFrame.getWidth();
+ const deInt32 frameHeight = referenceFrame.getHeight();
+
+ tcu::clear(referenceFrame.getLevel(0), clearColor);
+
+ const tcu::Vec4 referenceColor = m_conditionalData.expectCommandExecution ?
+ drawColor : clearColor;
+
+ for (int y = 0; y < frameHeight; y++)
+ {
+ for (int x = 0; x < frameWidth; x++)
+ {
+ referenceFrame.getLevel(0).setPixel(referenceColor, x, y);
+ }
+ }
+
+ const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
+ const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
+ vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
+
+ qpTestResult res = QP_TEST_RESULT_PASS;
+
+ if (!tcu::fuzzyCompare(log, "Result", "Image comparison result",
+ referenceFrame.getLevel(0), renderedFrame, 0.05f,
+ tcu::COMPARE_LOG_RESULT))
+ {
+ res = QP_TEST_RESULT_FAIL;
+ }
+
+ return tcu::TestStatus(res, qpGetTestResultName(res));
+};
+
+} // anonymous
+
+ConditionalClearAttachmentTests::ConditionalClearAttachmentTests (tcu::TestContext &testCtx)
+ : TestCaseGroup (testCtx, "clear_attachments", "vkCmdClearAttachments with conditional rendering")
+{
+ /* Left blank on purpose */
+}
+
+ConditionalClearAttachmentTests::~ConditionalClearAttachmentTests (void) {}
+
+void ConditionalClearAttachmentTests::init (void)
+{
+ for (int conditionNdx = 0; conditionNdx < DE_LENGTH_OF_ARRAY(conditional::s_testsData); conditionNdx++)
+ {
+ const ConditionalData& conditionData = conditional::s_testsData[conditionNdx];
+
+ tcu::TestCaseGroup* conditionalDrawRootGroup = new tcu::TestCaseGroup(m_testCtx, de::toString(conditionData).c_str(), "");
+
+ ConditionalTestSpec testSpec;
+ testSpec.conditionalData = conditionData;
+ testSpec.shaders[glu::SHADERTYPE_VERTEX] = "vulkan/dynamic_state/VertexFetch.vert";
+ testSpec.shaders[glu::SHADERTYPE_FRAGMENT] = "vulkan/dynamic_state/VertexFetch.frag";
+
+ conditionalDrawRootGroup->addChild(new Draw::InstanceFactory<ConditionalClearAttachmentTest>(m_testCtx, "clear_attachments", "", testSpec));
+
+ addChild(conditionalDrawRootGroup);
+ }
+}
+
+} // conditional
+} // vkt
--- /dev/null
+#ifndef _VKTCONDITIONALCLEARATTACHMENTTESTS_HPP
+#define _VKTCONDITIONALCLEARATTACHMENTTESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Test for conditional rendering of vkCmdClearAttachments
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+
+class ConditionalClearAttachmentTests : public tcu::TestCaseGroup
+{
+public:
+ ConditionalClearAttachmentTests (tcu::TestContext &testCtx);
+ ~ConditionalClearAttachmentTests(void);
+ void init (void);
+
+private:
+ ConditionalClearAttachmentTests (const ConditionalClearAttachmentTests &other);
+ ConditionalClearAttachmentTests& operator= (const ConditionalClearAttachmentTests &other);
+
+};
+
+} // conditional
+} // vkt
+
+#endif // _VKTCONDITIONALCLEARATTACHMENTTESTS_HPP
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Test for conditional rendering of vkCmdDispatch* functions
+ *//*--------------------------------------------------------------------*/
+
+#include "vktConditionalDispatchTests.hpp"
+#include "vktConditionalRenderingTestUtil.hpp"
+
+#include "vktTestCaseUtil.hpp"
+#include "vktComputeTestsUtil.hpp"
+
+#include "tcuTestLog.hpp"
+#include "tcuResource.hpp"
+
+#include "vkDefs.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkBuilderUtil.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+namespace
+{
+
+enum DispatchCommandType
+{
+ DISPATCH_COMMAND_TYPE_DISPATCH = 0,
+ DISPATCH_COMMAND_TYPE_DISPATCH_INDIRECT,
+ DISPATCH_COMMAND_TYPE_DISPATCH_BASE,
+ DISPATCH_COMMAND_TYPE_DISPATCH_LAST
+};
+
+const char* getDispatchCommandTypeName (DispatchCommandType command)
+{
+ switch (command)
+ {
+ case DISPATCH_COMMAND_TYPE_DISPATCH: return "dispatch";
+ case DISPATCH_COMMAND_TYPE_DISPATCH_INDIRECT: return "dispatch_indirect";
+ case DISPATCH_COMMAND_TYPE_DISPATCH_BASE: return "dispatch_base";
+ default: DE_ASSERT(false);
+ }
+ return "";
+}
+
+struct ConditionalTestSpec
+{
+ DispatchCommandType command;
+ int numCalls;
+ ConditionalData conditionalData;
+};
+
+class ConditionalDispatchTest : public vkt::TestCase
+{
+public:
+ ConditionalDispatchTest (tcu::TestContext& testCtx,
+ const std::string& name,
+ const std::string& description,
+ const ConditionalTestSpec& testSpec);
+
+ void initPrograms (vk::SourceCollections& sourceCollections) const;
+ TestInstance* createInstance (Context& context) const;
+
+private:
+ const ConditionalTestSpec m_testSpec;
+};
+
+class ConditionalDispatchTestInstance : public TestInstance
+{
+public:
+ ConditionalDispatchTestInstance (Context &context, ConditionalTestSpec testSpec);
+
+ virtual tcu::TestStatus iterate (void);
+ void recordDispatch (const vk::DeviceInterface& vk,
+ vk::VkCommandBuffer cmdBuffer,
+ compute::Buffer& indirectBuffer);
+
+protected:
+ const DispatchCommandType m_command;
+ const int m_numCalls;
+ const ConditionalData m_conditionalData;
+};
+
+ConditionalDispatchTest::ConditionalDispatchTest(tcu::TestContext& testCtx,
+ const std::string& name,
+ const std::string& description,
+ const ConditionalTestSpec& testSpec)
+ : TestCase (testCtx, name, description)
+ , m_testSpec (testSpec)
+{
+}
+
+void ConditionalDispatchTest::initPrograms (vk::SourceCollections& sourceCollections) const
+{
+ std::ostringstream src;
+ src << "#version 310 es\n"
+ << "layout(local_size_x = 1u, local_size_y = 1u, local_size_z = 1u) in;\n"
+ << "layout(set = 0, binding = 0, std140) buffer Out\n"
+ << "{\n"
+ << " coherent uint count;\n"
+ << "};\n"
+ << "void main(void)\n"
+ << "{\n"
+ << " atomicAdd(count, 1u);\n"
+ << "}\n";
+
+ sourceCollections.glslSources.add("comp") << glu::ComputeSource(src.str());
+}
+
+TestInstance* ConditionalDispatchTest::createInstance (Context& context) const
+{
+ return new ConditionalDispatchTestInstance(context, m_testSpec);
+}
+
+ConditionalDispatchTestInstance::ConditionalDispatchTestInstance (Context &context, ConditionalTestSpec testSpec)
+ : TestInstance(context)
+ , m_command(testSpec.command)
+ , m_numCalls(testSpec.numCalls)
+ , m_conditionalData(testSpec.conditionalData)
+{
+ checkConditionalRenderingCapabilities(context, m_conditionalData);
+};
+
+void ConditionalDispatchTestInstance::recordDispatch (const vk::DeviceInterface& vk,
+ vk::VkCommandBuffer cmdBuffer,
+ compute::Buffer& indirectBuffer)
+{
+ for (int i = 0; i < m_numCalls; i++)
+ {
+ switch (m_command)
+ {
+ case DISPATCH_COMMAND_TYPE_DISPATCH:
+ {
+ vk.cmdDispatch(cmdBuffer, 1, 1, 1);
+ break;
+ }
+ case DISPATCH_COMMAND_TYPE_DISPATCH_INDIRECT:
+ {
+ vk.cmdDispatchIndirect(cmdBuffer, *indirectBuffer, 0);
+ break;
+ }
+ case DISPATCH_COMMAND_TYPE_DISPATCH_BASE:
+ {
+ vk.cmdDispatchBase(cmdBuffer, 0, 0, 0, 1, 1, 1);
+ break;
+ }
+ default: DE_ASSERT(DE_FALSE);
+ }
+ }
+}
+
+tcu::TestStatus ConditionalDispatchTestInstance::iterate (void)
+{
+ const vk::DeviceInterface& vk = m_context.getDeviceInterface();
+ const vk::VkDevice device = m_context.getDevice();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
+ vk::Allocator& allocator = m_context.getDefaultAllocator();
+
+ // Create a buffer and host-visible memory for it
+
+ const vk::VkDeviceSize bufferSizeBytes = sizeof(deUint32);
+ const compute::Buffer outputBuffer(vk, device, allocator, compute::makeBufferCreateInfo(bufferSizeBytes, vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), vk::MemoryRequirement::HostVisible);
+
+ {
+ const vk::Allocation& alloc = outputBuffer.getAllocation();
+ deUint8* outputBufferPtr = reinterpret_cast<deUint8*>(alloc.getHostPtr());
+ *(deUint32*)(outputBufferPtr) = 0;
+ vk::flushAlloc(vk, device, alloc);
+ }
+
+ // Create descriptor set
+
+ const vk::Unique<vk::VkDescriptorSetLayout> descriptorSetLayout(
+ vk::DescriptorSetLayoutBuilder()
+ .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT)
+ .build(vk, device));
+
+ const vk::Unique<vk::VkDescriptorPool> descriptorPool(
+ vk::DescriptorPoolBuilder()
+ .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
+ .build(vk, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
+
+ const vk::Unique<vk::VkDescriptorSet> descriptorSet(compute::makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
+
+ const vk::VkDescriptorBufferInfo descriptorInfo = vk::makeDescriptorBufferInfo(*outputBuffer, 0ull, bufferSizeBytes);
+ vk::DescriptorSetUpdateBuilder()
+ .writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorInfo)
+ .update(vk, device);
+
+ // Setup pipeline
+
+ const vk::Unique<vk::VkShaderModule> shaderModule(createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0u));
+ const vk::Unique<vk::VkPipelineLayout> pipelineLayout(compute::makePipelineLayout(vk, device, *descriptorSetLayout));
+ const vk::Unique<vk::VkPipeline> pipeline(compute::makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
+
+ const vk::Unique<vk::VkCommandPool> cmdPool(compute::makeCommandPool(vk, device, queueFamilyIndex));
+ const vk::Unique<vk::VkCommandBuffer> cmdBuffer(vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+ const vk::Unique<vk::VkCommandBuffer> secondaryCmdBuffer(vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY));
+
+ // Create indirect buffer
+ const vk::VkDispatchIndirectCommand dispatchCommands[] = { { 1u, 1u, 1u } };
+
+ compute::Buffer indirectBuffer(
+ vk, device, allocator,
+ compute::makeBufferCreateInfo(sizeof(dispatchCommands), vk::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT),
+ vk::MemoryRequirement::HostVisible);
+
+ deUint8* indirectBufferPtr = reinterpret_cast<deUint8*>(indirectBuffer.getAllocation().getHostPtr());
+ deMemcpy(indirectBufferPtr, &dispatchCommands[0], sizeof(dispatchCommands));
+
+ vk::flushAlloc(vk, device, indirectBuffer.getAllocation());
+
+ // Start recording commands
+
+ beginCommandBuffer(vk, *cmdBuffer);
+
+ vk::VkCommandBuffer targetCmdBuffer = *cmdBuffer;
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ const vk::VkCommandBufferInheritanceConditionalRenderingInfoEXT conditionalRenderingInheritanceInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
+ DE_NULL,
+ VK_TRUE // conditionalRenderingEnable
+ };
+
+ const vk::VkCommandBufferInheritanceInfo inheritanceInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ &conditionalRenderingInheritanceInfo,
+ 0u, // renderPass
+ 0u, // subpass
+ 0u, // framebuffer
+ VK_FALSE, // occlusionQueryEnable
+ (vk::VkQueryControlFlags)0u, // queryFlags
+ (vk::VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ };
+
+ const vk::VkCommandBufferBeginInfo commandBufferBeginInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ DE_NULL,
+ vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+ &inheritanceInfo
+ };
+
+ vk.beginCommandBuffer(*secondaryCmdBuffer, &commandBufferBeginInfo);
+
+ targetCmdBuffer = *secondaryCmdBuffer;
+ }
+
+ vk.cmdBindPipeline(targetCmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
+ vk.cmdBindDescriptorSets(targetCmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ recordDispatch(vk, *secondaryCmdBuffer, indirectBuffer);
+ }
+
+ de::SharedPtr<Draw::Buffer> conditionalBuffer;
+ if (m_conditionalData.conditionEnabled)
+ {
+ conditionalBuffer = createConditionalRenderingBuffer(m_context, m_conditionalData);
+ beginConditionalRendering(vk, *cmdBuffer, *conditionalBuffer, m_conditionalData);
+ }
+
+ if (!m_conditionalData.useSecondaryBuffer)
+ {
+ recordDispatch(vk, *cmdBuffer, indirectBuffer);
+ }
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ vk.endCommandBuffer(*secondaryCmdBuffer);
+
+ vk.cmdExecuteCommands(*cmdBuffer, 1, &secondaryCmdBuffer.get());
+ }
+
+ if (m_conditionalData.conditionEnabled)
+ {
+ vk.cmdEndConditionalRenderingEXT(*cmdBuffer);
+ }
+
+ endCommandBuffer(vk, *cmdBuffer);
+
+ submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+
+ // Check result
+
+ qpTestResult res = QP_TEST_RESULT_PASS;
+
+ const vk::Allocation& outputBufferAllocation = outputBuffer.getAllocation();
+ invalidateAlloc(vk, device, outputBufferAllocation);
+
+ const deUint32* bufferPtr = static_cast<deUint32*>(outputBufferAllocation.getHostPtr());
+
+ const deUint32 expectedResult = m_conditionalData.expectCommandExecution ? m_numCalls : 0u;
+ if (bufferPtr[0] != expectedResult)
+ {
+ res = QP_TEST_RESULT_FAIL;
+ }
+
+ return tcu::TestStatus(res, qpGetTestResultName(res));
+};
+
+} // anonymous
+
+ConditionalDispatchTests::ConditionalDispatchTests (tcu::TestContext &testCtx)
+ : TestCaseGroup (testCtx, "dispatch", "Conditional Rendering Of Dispatch Commands")
+{
+ /* Left blank on purpose */
+}
+
+ConditionalDispatchTests::~ConditionalDispatchTests (void) {}
+
+void ConditionalDispatchTests::init (void)
+{
+ for (int conditionNdx = 0; conditionNdx < DE_LENGTH_OF_ARRAY(conditional::s_testsData); conditionNdx++)
+ {
+ const ConditionalData& conditionData = conditional::s_testsData[conditionNdx];
+
+ tcu::TestCaseGroup* conditionalDrawRootGroup = new tcu::TestCaseGroup(m_testCtx, de::toString(conditionData).c_str(), "Conditionaly execute dispatch calls");
+
+ for (deUint32 commandTypeIdx = 0; commandTypeIdx < DISPATCH_COMMAND_TYPE_DISPATCH_LAST; ++commandTypeIdx)
+ {
+ const DispatchCommandType command = DispatchCommandType(commandTypeIdx);
+
+ ConditionalTestSpec testSpec;
+ testSpec.command = command;
+ testSpec.numCalls = 3;
+ testSpec.conditionalData = conditionData;
+
+ conditionalDrawRootGroup->addChild(new ConditionalDispatchTest(m_testCtx, getDispatchCommandTypeName(command), "", testSpec));
+ }
+
+ addChild(conditionalDrawRootGroup);
+ }
+}
+
+} // conditional
+} // vkt
--- /dev/null
+#ifndef _VKTCONDITIONALDISPATCHTESTS_HPP
+#define _VKTCONDITIONALDISPATCHTESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Test for conditional rendering of vkCmdDispatch* functions
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+
+class ConditionalDispatchTests : public tcu::TestCaseGroup
+{
+public:
+ ConditionalDispatchTests (tcu::TestContext &testCtx);
+ ~ConditionalDispatchTests (void);
+ void init (void);
+
+private:
+ ConditionalDispatchTests (const ConditionalDispatchTests &other);
+ ConditionalDispatchTests& operator= (const ConditionalDispatchTests &other);
+
+};
+
+} // conditional
+} // vkt
+
+#endif // _VKTCONDITIONALDISPATCHTESTS_HPP
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Test for conditional rendering of vkCmdDraw* functions
+ *//*--------------------------------------------------------------------*/
+
+#include "vktConditionalDrawTests.hpp"
+#include "vktConditionalRenderingTestUtil.hpp"
+
+#include "vktTestCaseUtil.hpp"
+#include "vktDrawTestCaseUtil.hpp"
+
+#include "vktDrawBaseClass.hpp"
+
+#include "tcuTestLog.hpp"
+#include "tcuResource.hpp"
+#include "tcuImageCompare.hpp"
+#include "tcuTextureUtil.hpp"
+#include "tcuRGBA.hpp"
+
+#include "vkDefs.hpp"
+#include "vkCmdUtil.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+namespace
+{
+
+enum DrawCommandType
+{
+ DRAW_COMMAND_TYPE_DRAW = 0,
+ DRAW_COMMAND_TYPE_DRAW_INDEXED,
+ DRAW_COMMAND_TYPE_DRAW_INDIRECT,
+ DRAW_COMMAND_TYPE_DRAW_INDEXED_INDIRECT,
+ DRAW_COMMAND_TYPE_DRAW_INDIRECT_COUNT,
+ DRAW_COMMAND_TYPE_DRAW_INDEXED_INDIRECT_COUNT,
+
+ DRAW_COMMAND_TYPE_DRAW_LAST
+};
+
+const char* getDrawCommandTypeName (DrawCommandType command)
+{
+ switch (command)
+ {
+ case DRAW_COMMAND_TYPE_DRAW: return "draw";
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED: return "draw_indexed";
+ case DRAW_COMMAND_TYPE_DRAW_INDIRECT: return "draw_indirect";
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED_INDIRECT: return "draw_indexed_indirect";
+ case DRAW_COMMAND_TYPE_DRAW_INDIRECT_COUNT: return "draw_indirect_count";
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED_INDIRECT_COUNT: return "draw_indexed_indirect_count";
+ default: DE_ASSERT(false);
+ }
+ return "";
+}
+
+struct ConditionalTestSpec : public Draw::TestSpecBase
+{
+ DrawCommandType command;
+ deUint32 drawCalls;
+ ConditionalData conditionalData;
+};
+
+class ConditionalDraw : public Draw::DrawTestsBaseClass
+{
+public:
+ typedef ConditionalTestSpec TestSpec;
+
+ ConditionalDraw (Context &context, ConditionalTestSpec testSpec);
+
+ virtual tcu::TestStatus iterate (void);
+ void createAndBindIndexBuffer (vk::VkCommandBuffer cmdBuffer);
+ void createIndirectBuffer (void);
+ void createIndexedIndirectBuffer (void);
+ void createIndirectCountBuffer (void);
+ void recordDraw (vk::VkCommandBuffer cmdBuffer);
+
+protected:
+ const DrawCommandType m_command;
+ const deUint32 m_drawCalls;
+
+ const ConditionalData m_conditionalData;
+ de::SharedPtr<Draw::Buffer> m_conditionalBuffer;
+
+ vk::Move<vk::VkCommandBuffer> m_secondaryCmdBuffer;
+
+ std::vector<deUint32> m_indexes;
+ de::SharedPtr<Draw::Buffer> m_indexBuffer;
+
+ de::SharedPtr<Draw::Buffer> m_indirectBuffer;
+ de::SharedPtr<Draw::Buffer> m_indirectCountBuffer;
+};
+
+ConditionalDraw::ConditionalDraw (Context &context, ConditionalTestSpec testSpec)
+ : Draw::DrawTestsBaseClass(context, testSpec.shaders[glu::SHADERTYPE_VERTEX], testSpec.shaders[glu::SHADERTYPE_FRAGMENT], vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
+ , m_command(testSpec.command)
+ , m_drawCalls(testSpec.drawCalls)
+ , m_conditionalData(testSpec.conditionalData)
+{
+ checkConditionalRenderingCapabilities(context, m_conditionalData);
+
+ const float minX = -0.3f;
+ const float maxX = 0.3f;
+ const float drawStep = 0.6f / static_cast<float>(m_drawCalls);
+
+ for (deUint32 drawIdx = 0; drawIdx < m_drawCalls; drawIdx++)
+ {
+ const float minY = minX + static_cast<float>(drawIdx) * drawStep;
+ const float maxY = minY + drawStep;
+
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( minX, maxY, 0.5f, 1.0f), tcu::RGBA::blue().toVec(), 0));
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( minX, minY, 0.5f, 1.0f), tcu::RGBA::blue().toVec(), 0));
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( maxX, maxY, 0.5f, 1.0f), tcu::RGBA::blue().toVec(), 0));
+
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( minX, minY, 0.5f, 1.0f), tcu::RGBA::blue().toVec(), 0));
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( maxX, maxY, 0.5f, 1.0f), tcu::RGBA::blue().toVec(), 0));
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( maxX, minY, 0.5f, 1.0f), tcu::RGBA::blue().toVec(), 0));
+ }
+
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( -1.0f, 1.0f, 0.0f, 1.0f), tcu::RGBA::red().toVec(), 0));
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), tcu::RGBA::red().toVec(), 0));
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f), tcu::RGBA::red().toVec(), 0));
+
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( -1.0f, -1.0f, 0.0f, 1.0f), tcu::RGBA::red().toVec(), 0));
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f), tcu::RGBA::red().toVec(), 0));
+ m_data.push_back(Draw::VertexElementData(tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f), tcu::RGBA::red().toVec(), 0));
+
+ for (deUint32 index = 0; index < m_data.size(); index++)
+ {
+ m_indexes.push_back(index);
+ }
+
+ initialize();
+
+ m_secondaryCmdBuffer = vk::allocateCommandBuffer(m_vk, m_context.getDevice(), *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY);
+};
+
+void ConditionalDraw::createAndBindIndexBuffer (vk::VkCommandBuffer cmdBuffer)
+{
+ const vk::VkDeviceSize indexDataSize = m_indexes.size() * sizeof(deUint32);
+ m_indexBuffer = Draw::Buffer::createAndAlloc(m_vk, m_context.getDevice(),
+ Draw::BufferCreateInfo(indexDataSize,
+ vk::VK_BUFFER_USAGE_INDEX_BUFFER_BIT),
+ m_context.getDefaultAllocator(),
+ vk::MemoryRequirement::HostVisible);
+
+ deUint8* indexBufferPtr = reinterpret_cast<deUint8*>(m_indexBuffer->getBoundMemory().getHostPtr());
+ deMemcpy(indexBufferPtr, &m_indexes[0], static_cast<size_t>(indexDataSize));
+
+ vk::flushAlloc(m_vk, m_context.getDevice(), m_indexBuffer->getBoundMemory());
+
+ const vk::VkBuffer indexBuffer = m_indexBuffer->object();
+ m_vk.cmdBindIndexBuffer(cmdBuffer, indexBuffer, 0, vk::VK_INDEX_TYPE_UINT32);
+}
+
+void ConditionalDraw::createIndirectBuffer (void)
+{
+ const vk::VkDrawIndirectCommand badDrawCommand =
+ {
+ 6u, // vertexCount
+ 1u, // instanceCount
+ m_drawCalls * 6u, // firstVertex
+ 0u // firstInstance
+ };
+
+ std::vector<vk::VkDrawIndirectCommand> drawCommands;
+ for (deUint32 drawIdx = 0; drawIdx < m_drawCalls; drawIdx++)
+ {
+ const vk::VkDrawIndirectCommand goodDrawCommand =
+ {
+ 6u, // vertexCount
+ 1u, // instanceCount
+ 6u * drawIdx, // firstVertex
+ 0u // firstInstance
+ };
+
+ drawCommands.push_back(goodDrawCommand);
+ // *Bad* commands should not be rendered by vkCmdDrawIndirectCountKHR
+ drawCommands.push_back(badDrawCommand);
+ drawCommands.push_back(badDrawCommand);
+ }
+
+ const vk::VkDeviceSize drawCommandsSize = drawCommands.size() * sizeof(vk::VkDrawIndirectCommand);
+
+ m_indirectBuffer = Draw::Buffer::createAndAlloc(m_vk,
+ m_context.getDevice(),
+ Draw::BufferCreateInfo(drawCommandsSize,
+ vk::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT),
+ m_context.getDefaultAllocator(),
+ vk::MemoryRequirement::HostVisible);
+
+ deUint8* ptr = reinterpret_cast<deUint8*>(m_indirectBuffer->getBoundMemory().getHostPtr());
+ deMemcpy(ptr, &drawCommands[0], static_cast<size_t>(drawCommandsSize));
+
+ vk::flushAlloc(m_vk, m_context.getDevice(), m_indirectBuffer->getBoundMemory());
+}
+
+void ConditionalDraw::createIndexedIndirectBuffer (void)
+{
+ const vk::VkDrawIndexedIndirectCommand badDrawCommand =
+ {
+ 6u, // indexCount
+ 1u, // instanceCount
+ m_drawCalls * 6u, // firstIndex
+ 0u, // vertexOffset
+ 0u, // firstInstance
+ };
+
+ std::vector<vk::VkDrawIndexedIndirectCommand> drawCommands;
+ for (deUint32 drawIdx = 0; drawIdx < m_drawCalls; drawIdx++)
+ {
+ const vk::VkDrawIndexedIndirectCommand goodDrawCommand =
+ {
+ 6u, // indexCount
+ 1u, // instanceCount
+ 6u * drawIdx, // firstIndex
+ 0u, // vertexOffset
+ 0u, // firstInstance
+ };
+
+ drawCommands.push_back(goodDrawCommand);
+ // *Bad* commands should not be rendered by vkCmdDrawIndexedIndirectCountKHR
+ drawCommands.push_back(badDrawCommand);
+ drawCommands.push_back(badDrawCommand);
+ }
+
+ const vk::VkDeviceSize drawCommandsSize = drawCommands.size() * sizeof(vk::VkDrawIndexedIndirectCommand);
+
+ m_indirectBuffer = Draw::Buffer::createAndAlloc(m_vk,
+ m_context.getDevice(),
+ Draw::BufferCreateInfo(drawCommandsSize,
+ vk::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT),
+ m_context.getDefaultAllocator(),
+ vk::MemoryRequirement::HostVisible);
+
+ deUint8* ptr = reinterpret_cast<deUint8*>(m_indirectBuffer->getBoundMemory().getHostPtr());
+ deMemcpy(ptr, &drawCommands[0], static_cast<size_t>(drawCommandsSize));
+
+ vk::flushAlloc(m_vk, m_context.getDevice(), m_indirectBuffer->getBoundMemory());
+}
+
+void ConditionalDraw::createIndirectCountBuffer (void)
+{
+ m_indirectCountBuffer = Draw::Buffer::createAndAlloc(m_vk,
+ m_context.getDevice(),
+ Draw::BufferCreateInfo(sizeof(deUint32),
+ vk::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT),
+ m_context.getDefaultAllocator(),
+ vk::MemoryRequirement::HostVisible);
+
+ deUint8* countBufferPtr = reinterpret_cast<deUint8*>(m_indirectCountBuffer->getBoundMemory().getHostPtr());
+ *(deUint32*)(countBufferPtr) = 1;
+
+ vk::flushAlloc(m_vk, m_context.getDevice(), m_indirectCountBuffer->getBoundMemory());
+}
+
+void ConditionalDraw::recordDraw(vk::VkCommandBuffer cmdBuffer)
+{
+ for (deUint32 drawIdx = 0; drawIdx < m_drawCalls; drawIdx++)
+ {
+ /* Indirect buffer has next layout:
+ * goodCommand badCommand badCommand goodCommand badCommand badCommand ...
+ */
+ const vk::VkDeviceSize indirectOffset = sizeof(vk::VkDrawIndirectCommand) * drawIdx * 3;
+ const vk::VkDeviceSize indexedIndirectOffset = sizeof(vk::VkDrawIndexedIndirectCommand) * drawIdx * 3;
+ switch (m_command)
+ {
+ case DRAW_COMMAND_TYPE_DRAW:
+ {
+ m_vk.cmdDraw(cmdBuffer, 6, 1, 6 * drawIdx, 0);
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED:
+ {
+ m_vk.cmdDrawIndexed(cmdBuffer, 6, 1, 6 * drawIdx, 0, 0);
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDIRECT:
+ {
+ m_vk.cmdDrawIndirect(cmdBuffer, m_indirectBuffer->object(), indirectOffset, 1, 0);
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED_INDIRECT:
+ {
+ m_vk.cmdDrawIndexedIndirect(cmdBuffer, m_indirectBuffer->object(), indexedIndirectOffset, 1, 0);
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDIRECT_COUNT:
+ {
+ m_vk.cmdDrawIndirectCountKHR( cmdBuffer,
+ m_indirectBuffer->object(), indirectOffset,
+ m_indirectCountBuffer->object(), 0, 3,
+ sizeof(vk::VkDrawIndirectCommand));
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED_INDIRECT_COUNT:
+ {
+ m_vk.cmdDrawIndexedIndirectCountKHR(cmdBuffer,
+ m_indirectBuffer->object(), indexedIndirectOffset,
+ m_indirectCountBuffer->object(), 0, 3,
+ sizeof(vk::VkDrawIndexedIndirectCommand));
+ break;
+ }
+ default: DE_ASSERT(false);
+ }
+ }
+}
+
+tcu::TestStatus ConditionalDraw::iterate (void)
+{
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
+
+ beginRenderPass(m_conditionalData.useSecondaryBuffer ? vk::VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS : vk::VK_SUBPASS_CONTENTS_INLINE);
+
+ vk::VkCommandBuffer targetCmdBuffer = *m_cmdBuffer;
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ const vk::VkCommandBufferInheritanceConditionalRenderingInfoEXT conditionalRenderingInheritanceInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
+ DE_NULL,
+ VK_TRUE // conditionalRenderingEnable
+ };
+
+ const vk::VkCommandBufferInheritanceInfo inheritanceInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ &conditionalRenderingInheritanceInfo,
+ *m_renderPass, // renderPass
+ 0u, // subpass
+ *m_framebuffer, // framebuffer
+ VK_FALSE, // occlusionQueryEnable
+ (vk::VkQueryControlFlags)0u, // queryFlags
+ (vk::VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ };
+
+ const vk::VkCommandBufferBeginInfo commandBufferBeginInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ DE_NULL,
+ vk::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
+ &inheritanceInfo
+ };
+
+ m_vk.beginCommandBuffer(*m_secondaryCmdBuffer, &commandBufferBeginInfo);
+
+ targetCmdBuffer = *m_secondaryCmdBuffer;
+ }
+
+ const vk::VkDeviceSize vertexBufferOffset = 0;
+ const vk::VkBuffer vertexBuffer = m_vertexBuffer->object();
+
+ m_vk.cmdBindVertexBuffers(targetCmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
+
+ switch(m_command)
+ {
+ case DRAW_COMMAND_TYPE_DRAW:
+ {
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED:
+ {
+ createAndBindIndexBuffer(targetCmdBuffer);
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDIRECT:
+ {
+ createIndirectBuffer();
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED_INDIRECT:
+ {
+ createAndBindIndexBuffer(targetCmdBuffer);
+ createIndexedIndirectBuffer();
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDIRECT_COUNT:
+ {
+ createIndirectBuffer();
+ createIndirectCountBuffer();
+ break;
+ }
+ case DRAW_COMMAND_TYPE_DRAW_INDEXED_INDIRECT_COUNT:
+ {
+ createAndBindIndexBuffer(targetCmdBuffer);
+ createIndexedIndirectBuffer();
+ createIndirectCountBuffer();
+ break;
+ }
+ default: DE_ASSERT(false);
+ }
+
+ m_vk.cmdBindPipeline(targetCmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ recordDraw(*m_secondaryCmdBuffer);
+ }
+
+ if (m_conditionalData.conditionEnabled)
+ {
+ m_conditionalBuffer = createConditionalRenderingBuffer(m_context, m_conditionalData);
+ beginConditionalRendering(m_vk, *m_cmdBuffer, *m_conditionalBuffer, m_conditionalData);
+ }
+
+ if (!m_conditionalData.useSecondaryBuffer)
+ {
+ recordDraw(*m_cmdBuffer);
+ }
+
+ if (m_conditionalData.useSecondaryBuffer)
+ {
+ m_vk.endCommandBuffer(*m_secondaryCmdBuffer);
+
+ m_vk.cmdExecuteCommands(*m_cmdBuffer, 1, &m_secondaryCmdBuffer.get());
+ }
+
+ if (m_conditionalData.conditionEnabled)
+ {
+ m_vk.cmdEndConditionalRenderingEXT(*m_cmdBuffer);
+ }
+
+ endRenderPass(m_vk, *m_cmdBuffer);
+ endCommandBuffer(m_vk, *m_cmdBuffer);
+
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
+
+ // Validation
+ tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
+ referenceFrame.allocLevel(0);
+
+ const deInt32 frameWidth = referenceFrame.getWidth();
+ const deInt32 frameHeight = referenceFrame.getHeight();
+
+ const tcu::Vec4 clearColor = tcu::RGBA::black().toVec();
+ const tcu::Vec4 drawColor = tcu::RGBA::blue().toVec();
+
+ tcu::clear(referenceFrame.getLevel(0), clearColor);
+
+ const tcu::Vec4 referenceColor = m_conditionalData.expectCommandExecution ?
+ drawColor : clearColor;
+
+ Draw::ReferenceImageCoordinates refCoords;
+
+ for (int y = 0; y < frameHeight; y++)
+ {
+ const float yCoord = (float)(y / (0.5*frameHeight)) - 1.0f;
+
+ for (int x = 0; x < frameWidth; x++)
+ {
+ const float xCoord = (float)(x / (0.5*frameWidth)) - 1.0f;
+
+ if ((yCoord >= refCoords.bottom &&
+ yCoord <= refCoords.top &&
+ xCoord >= refCoords.left &&
+ xCoord <= refCoords.right))
+ referenceFrame.getLevel(0).setPixel(referenceColor, x, y);
+ }
+ }
+
+ const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
+ const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
+ vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
+
+ qpTestResult res = QP_TEST_RESULT_PASS;
+
+ if (!tcu::fuzzyCompare(log, "Result", "Image comparison result",
+ referenceFrame.getLevel(0), renderedFrame, 0.05f,
+ tcu::COMPARE_LOG_RESULT))
+ {
+ res = QP_TEST_RESULT_FAIL;
+ }
+
+ return tcu::TestStatus(res, qpGetTestResultName(res));
+};
+
+} // anonymous
+
+ConditionalDrawTests::ConditionalDrawTests (tcu::TestContext &testCtx)
+ : TestCaseGroup (testCtx, "draw", "Conditional Rendering Of Draw Commands")
+{
+ /* Left blank on purpose */
+}
+
+ConditionalDrawTests::~ConditionalDrawTests (void) {}
+
+void ConditionalDrawTests::init (void)
+{
+ for (int conditionNdx = 0; conditionNdx < DE_LENGTH_OF_ARRAY(conditional::s_testsData); conditionNdx++)
+ {
+ const ConditionalData& conditionData = conditional::s_testsData[conditionNdx];
+
+ tcu::TestCaseGroup* conditionalDrawRootGroup = new tcu::TestCaseGroup(m_testCtx, de::toString(conditionData).c_str(), "Conditionaly execute draw calls");
+
+ for (deUint32 commandTypeIdx = 0; commandTypeIdx < DRAW_COMMAND_TYPE_DRAW_LAST; ++commandTypeIdx)
+ {
+ const DrawCommandType command = DrawCommandType(commandTypeIdx);
+
+ ConditionalTestSpec testSpec;
+ testSpec.command = command;
+ testSpec.drawCalls = 4;
+ testSpec.conditionalData = conditionData;
+ testSpec.shaders[glu::SHADERTYPE_VERTEX] = "vulkan/dynamic_state/VertexFetch.vert";
+ testSpec.shaders[glu::SHADERTYPE_FRAGMENT] = "vulkan/dynamic_state/VertexFetch.frag";
+
+ conditionalDrawRootGroup->addChild(new Draw::InstanceFactory<ConditionalDraw>(m_testCtx, getDrawCommandTypeName(command), "", testSpec));
+ }
+
+ addChild(conditionalDrawRootGroup);
+ }
+}
+
+} // conditional
+} // vkt
--- /dev/null
+#ifndef _VKTCONDITIONALDRAWTESTS_HPP
+#define _VKTCONDITIONALDRAWTESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Test for conditional rendering of vkCmdDraw* functions
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+
+class ConditionalDrawTests : public tcu::TestCaseGroup
+{
+public:
+ ConditionalDrawTests (tcu::TestContext &testCtx);
+ ~ConditionalDrawTests (void);
+ void init (void);
+
+private:
+ ConditionalDrawTests (const ConditionalDrawTests &other);
+ ConditionalDrawTests& operator= (const ConditionalDrawTests &other);
+
+};
+
+} // conditional
+} // vkt
+
+#endif // _VKTCONDITIONALDRAWTESTS_HPP
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Conditional Rendering Test Utils
+ *//*--------------------------------------------------------------------*/
+
+#include "vktConditionalRenderingTestUtil.hpp"
+#include "vktDrawCreateInfoUtil.hpp"
+#include "vkQueryUtil.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+
+void checkConditionalRenderingCapabilities (vkt::Context& context, const ConditionalData& data)
+{
+ if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_conditional_rendering"))
+ TCU_THROW(NotSupportedError, "Missing extension: VK_EXT_conditional_rendering");
+
+ if (data.useSecondaryBuffer)
+ {
+ const vk::VkPhysicalDeviceConditionalRenderingFeaturesEXT& conditionalRenderingFeatures = context.getConditionalRenderingFeatures();
+ if (!conditionalRenderingFeatures.inheritedConditionalRendering)
+ {
+ TCU_THROW(NotSupportedError, "Device does not support inherited conditional rendering");
+ }
+ }
+}
+
+de::SharedPtr<Draw::Buffer> createConditionalRenderingBuffer (vkt::Context& context, const ConditionalData& data)
+{
+ const vk::DeviceInterface& vk = context.getDeviceInterface();
+ de::SharedPtr<Draw::Buffer> buffer = Draw::Buffer::createAndAlloc(vk, context.getDevice(),
+ Draw::BufferCreateInfo(sizeof(deUint32),
+ vk::VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT),
+ context.getDefaultAllocator(),
+ vk::MemoryRequirement::HostVisible);
+
+ deUint8* conditionBufferPtr = reinterpret_cast<deUint8*>(buffer->getBoundMemory().getHostPtr());
+ *(deUint32*)(conditionBufferPtr) = data.conditionValue;
+
+ vk::flushMappedMemoryRange( vk,
+ context.getDevice(),
+ buffer->getBoundMemory().getMemory(),
+ buffer->getBoundMemory().getOffset(),
+ VK_WHOLE_SIZE);
+ return buffer;
+}
+
+void beginConditionalRendering (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, Draw::Buffer& buffer, const ConditionalData& data)
+{
+ vk::VkConditionalRenderingBeginInfoEXT conditionalRenderingBeginInfo;
+ conditionalRenderingBeginInfo.sType = vk::VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT;
+ conditionalRenderingBeginInfo.pNext = DE_NULL;
+ conditionalRenderingBeginInfo.buffer = buffer.object();
+ conditionalRenderingBeginInfo.offset = 0;
+ conditionalRenderingBeginInfo.flags = data.conditionInverted ? vk::VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT : 0;
+
+ vk.cmdBeginConditionalRenderingEXT(cmdBuffer, &conditionalRenderingBeginInfo);
+}
+
+std::ostream& operator<< (std::ostream& str, ConditionalData const& c)
+{
+ str << (c.conditionEnabled ? "condition" : "no_condition");
+
+ if (c.useSecondaryBuffer)
+ {
+ str << "_secondary_buffer";
+ }
+
+ str << "_" << (c.expectCommandExecution ? "expect_execution" : "expect_noop");
+
+ if (c.conditionInverted)
+ {
+ str << "_inverted";
+ }
+
+ return str;
+}
+
+} // conditional
+} // vkt
\ No newline at end of file
--- /dev/null
+#ifndef _VKTCONDITIONALRENDERINGTESTUTIL_HPP
+#define _VKTCONDITIONALRENDERINGTESTUTIL_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Conditional Rendering Test Utils
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "vktDrawBufferObjectUtil.hpp"
+#include "vktTestCase.hpp"
+#include "deSharedPtr.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+
+struct ConditionalData
+{
+ bool conditionEnabled;
+ deUint32 conditionValue;
+ bool conditionInverted;
+ bool useSecondaryBuffer;
+
+ bool expectCommandExecution;
+};
+
+static const ConditionalData s_testsData[] =
+{
+// Enabled Val Inverted Secondary Result
+ { true, 1, false, false, true },
+ { true, 0, false, false, false },
+ { true, 0, true, false, true},
+ { true, 1, true, false, false },
+ { true, 1, false, true, true },
+ { true, 0, false, true, false },
+ { true, 0, true, true, true },
+ { true, 1, true, true, false },
+
+ /* Test that commands are executed correctly when secondary command buffer is constructed
+ * with conditional rendering enabled but conditional rendering is not enabled when
+ * executing it in the primary command buffer.
+ */
+ { false,1, false, true, true },
+};
+
+std::ostream& operator<< (std::ostream& str, ConditionalData const& c);
+
+void checkConditionalRenderingCapabilities (vkt::Context& context, const ConditionalData& data);
+de::SharedPtr<Draw::Buffer> createConditionalRenderingBuffer (vkt::Context& context, const ConditionalData& data);
+void beginConditionalRendering (const vk::DeviceInterface& vk,
+ vk::VkCommandBuffer cmdBuffer,
+ Draw::Buffer& buffer,
+ const ConditionalData& data);
+
+} // conditional
+} // vkt
+
+#endif // _VKTCONDITIONALRENDERINGTESTUTIL_HPP
\ No newline at end of file
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Conditional Rendering Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktConditionalTests.hpp"
+#include "vktTestGroupUtil.hpp"
+#include "vktConditionalDrawTests.hpp"
+#include "vktConditionalDispatchTests.hpp"
+#include "vktConditionalClearAttachmentTests.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+
+namespace
+{
+
+void createChildren (tcu::TestCaseGroup* group)
+{
+ tcu::TestContext& testCtx = group->getTestContext();
+
+ group->addChild(new ConditionalDrawTests(testCtx));
+ group->addChild(new ConditionalDispatchTests(testCtx));
+ group->addChild(new ConditionalClearAttachmentTests(testCtx));
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx)
+{
+ return createTestGroup(testCtx, "conditional_rendering", "Conditional Rendering Tests", createChildren);
+}
+
+} // conditional
+} // vkt
--- /dev/null
+#ifndef _VKTCONDITIONALTESTS_HPP
+#define _VKTCONDITIONALTESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Danylo Piliaiev <danylo.piliaiev@gmail.com>
+ *
+ * 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 Conditional Rendering Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+namespace conditional
+{
+
+tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx);
+
+} // conditional
+} // vkt
+
+#endif // _VKTCONDITIONALTESTS_HPP
m_pipeline = vk::createGraphicsPipeline(m_vk, device, DE_NULL, &pipelineCreateInfo);
}
-void DrawTestsBaseClass::beginRenderPass (void)
+void DrawTestsBaseClass::beginRenderPass (const vk::VkSubpassContents content)
{
const vk::VkClearColorValue clearColor = { { 0.0f, 0.0f, 0.0f, 1.0f } };
0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
const vk::VkRect2D renderArea = vk::makeRect2D(WIDTH, HEIGHT);
- vk::beginRenderPass(m_vk, *m_cmdBuffer, *m_renderPass, *m_framebuffer, renderArea);
+ vk::beginRenderPass(m_vk, *m_cmdBuffer, *m_renderPass, *m_framebuffer, renderArea, content);
}
} // Draw
protected:
void initialize (void);
virtual void initPipeline (const vk::VkDevice device);
- void beginRenderPass (void);
+ void beginRenderPass (const vk::VkSubpassContents content = vk::VK_SUBPASS_CONTENTS_INLINE);
virtual tcu::TestStatus iterate (void) { TCU_FAIL("Implement iterate() method!"); }
enum
VkPhysicalDeviceInlineUniformBlockFeaturesEXT inlineUniformBlockFeatures;
VkPhysicalDeviceVulkanMemoryModelFeaturesKHR vulkanMemoryModelFeatures;
VkPhysicalDeviceShaderAtomicInt64FeaturesKHR shaderAtomicInt64Features;
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT conditionalRenderingFeatures;
DeviceFeatures (const InstanceInterface& vki,
const deUint32 apiVersion,
deMemset(&inlineUniformBlockFeatures, 0, sizeof(inlineUniformBlockFeatures));
deMemset(&vulkanMemoryModelFeatures, 0, sizeof(vulkanMemoryModelFeatures));
deMemset(&shaderAtomicInt64Features, 0, sizeof(shaderAtomicInt64Features));
+ deMemset(&conditionalRenderingFeatures, 0, sizeof(conditionalRenderingFeatures));
coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
samplerYCbCrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
inlineUniformBlockFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT;
vulkanMemoryModelFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR;
shaderAtomicInt64Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR;
+ conditionalRenderingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
if (isPhysicalDeviceFeatures2Supported(apiVersion, instanceExtensions))
*nextPtr = &shaderAtomicInt64Features;
nextPtr = &shaderAtomicInt64Features.pNext;
}
+ if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), "VK_EXT_conditional_rendering"))
+ {
+ *nextPtr = &conditionalRenderingFeatures;
+ nextPtr = &conditionalRenderingFeatures.pNext;
+ }
vki.getPhysicalDeviceFeatures2(physicalDevice, &coreFeatures);
}
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT&getVertexAttributeDivisorFeatures (void) const { return m_deviceFeatures.vertexAttributeDivisorFeatures; }
const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& getVulkanMemoryModelFeatures (void) const { return m_deviceFeatures.vulkanMemoryModelFeatures; }
const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& getShaderAtomicInt64Features (void) const { return m_deviceFeatures.shaderAtomicInt64Features; }
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT& getConditionalRenderingFeatures (void) const { return m_deviceFeatures.conditionalRenderingFeatures; }
VkDevice getDevice (void) const { return *m_device; }
const DeviceInterface& getDeviceInterface (void) const { return m_deviceInterface; }
const VkPhysicalDeviceProperties& getDeviceProperties (void) const { return m_deviceProperties; }
Context::getVulkanMemoryModelFeatures (void) const { return m_device->getVulkanMemoryModelFeatures(); }
const vk::VkPhysicalDeviceShaderAtomicInt64FeaturesKHR&
Context::getShaderAtomicInt64Features (void) const { return m_device->getShaderAtomicInt64Features(); }
+const vk::VkPhysicalDeviceConditionalRenderingFeaturesEXT&
+ Context::getConditionalRenderingFeatures(void) const { return m_device->getConditionalRenderingFeatures(); }
const vk::VkPhysicalDeviceProperties& Context::getDeviceProperties (void) const { return m_device->getDeviceProperties(); }
const vector<string>& Context::getDeviceExtensions (void) const { return m_device->getDeviceExtensions(); }
vk::VkDevice Context::getDevice (void) const { return m_device->getDevice(); }
getVulkanMemoryModelFeatures (void) const;
const vk::VkPhysicalDeviceShaderAtomicInt64FeaturesKHR&
getShaderAtomicInt64Features (void) const;
+ const vk::VkPhysicalDeviceConditionalRenderingFeaturesEXT&
+ getConditionalRenderingFeatures (void) const;
const vk::VkPhysicalDeviceProperties& getDeviceProperties (void) const;
const std::vector<std::string>& getDeviceExtensions (void) const;
vk::VkDevice getDevice (void) const;
#include "vktQueryPoolTests.hpp"
#include "vktDrawTests.hpp"
#include "vktComputeTests.hpp"
+#include "vktConditionalTests.hpp"
#include "vktImageTests.hpp"
#include "vktInfoTests.hpp"
#include "vktWsiTests.hpp"
addChild(ProtectedMem::createTests (m_testCtx));
addChild(DeviceGroup::createTests (m_testCtx));
addChild(MemoryModel::createTests (m_testCtx));
+ addChild(conditional::createTests (m_testCtx));
}
} // vkt
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.comp
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.vert
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.frag
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_execution.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_noop.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_execution_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_noop_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_execution.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_noop.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_execution_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_noop_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.no_condition_secondary_buffer_expect_execution.clear_attachments
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.comp
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.vert
dEQP-VK.memory_model.write_after_read.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.image.guard_local.buffer.frag
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_execution_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_expect_noop_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_execution_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.condition_secondary_buffer_expect_noop_inverted.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indirect
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed_indirect
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indirect_count
+dEQP-VK.conditional_rendering.draw.no_condition_secondary_buffer_expect_execution.draw_indexed_indirect_count
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_execution_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_expect_noop_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_execution_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.condition_secondary_buffer_expect_noop_inverted.dispatch_base
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch_indirect
+dEQP-VK.conditional_rendering.dispatch.no_condition_secondary_buffer_expect_execution.dispatch_base
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_execution.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_noop.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_execution_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_expect_noop_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_execution.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_noop.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_execution_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.condition_secondary_buffer_expect_noop_inverted.clear_attachments
+dEQP-VK.conditional_rendering.clear_attachments.no_condition_secondary_buffer_expect_execution.clear_attachments
VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
+ VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
+ VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferUsageFlagBits;
typedef VkFlags VkBufferUsageFlags;
VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
+ VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
+#define VK_EXT_conditional_rendering 1
+#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1
+#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
+
+
+typedef enum VkConditionalRenderingFlagBitsEXT {
+ VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
+ VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkConditionalRenderingFlagBitsEXT;
+typedef VkFlags VkConditionalRenderingFlagsEXT;
+
+typedef struct VkConditionalRenderingBeginInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkConditionalRenderingFlagsEXT flags;
+} VkConditionalRenderingBeginInfoEXT;
+
+typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 conditionalRendering;
+ VkBool32 inheritedConditionalRendering;
+} VkPhysicalDeviceConditionalRenderingFeaturesEXT;
+
+typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 conditionalRenderingEnable;
+} VkCommandBufferInheritanceConditionalRenderingInfoEXT;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer);
+#endif
#define VK_NVX_device_generated_commands 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
projects / platform / upstream / VK-GL-CTS.git / commitdiff