}
info.buffer = *buffer;
- vk.getBufferMemoryRequirements2(vkDevice, &info, &memReqs); // get the proper size requirement
+ vk.getBufferMemoryRequirements2(vkDevice, &info, &memReqs); // get the proper size requirement
if (size > memReqs.memoryRequirements.size)
{
#include "tcuTestLog.hpp"
#include "vkPrograms.hpp"
#include "vkRefUtil.hpp"
-#include "vkQueryUtil.hpp"
#include "vktTestCase.hpp"
+#include "vkQueryUtil.hpp"
namespace vkt
{
const DeviceInterface& vk = context.getDeviceInterface();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
VkPhysicalDeviceMemoryProperties memoryProperties;
- VkMemoryDedicatedRequirements dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType;
DE_NULL, // const void* pNext;
false, // VkBool32 prefersDedicatedAllocation
false // VkBool32 requiresDedicatedAllocation
};
- VkMemoryRequirements2 memReqs =
+ VkMemoryRequirements2 memReqs =
{
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
&dedicatedRequirements, // void* pNext
return tcu::TestStatus::fail("Buffer creation failed! (Error code: " + de::toString(error.getMessage()) + ")");
}
- VkBufferMemoryRequirementsInfo2 info =
+ VkBufferMemoryRequirementsInfo2 info =
{
VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
DE_NULL, // const void* pNext
vkInstance.getPhysicalDeviceMemoryProperties(vkPhysicalDevice, &memoryProperties);
const deUint32 heapTypeIndex = static_cast<deUint32>(deCtz32(memReqs.memoryRequirements.memoryTypeBits));
- //const VkMemoryType memoryType = memoryProperties.memoryTypes[heapTypeIndex];
- //const VkMemoryHeap memoryHeap = memoryProperties.memoryHeaps[memoryType.heapIndex];
- vk.getBufferMemoryRequirements2(vkDevice, &info, &memReqs); // get the proper size requirement
+ vk.getBufferMemoryRequirements2(vkDevice, &info, &memReqs); // get the proper size requirement
if (size > memReqs.memoryRequirements.size)
{
for (deUint32 format = vk::VK_FORMAT_UNDEFINED + 1; format < VK_CORE_FORMAT_LAST; format++)
{
- const std::string formatName = de::toLower(getFormatName((VkFormat)format)).substr(10);
+ const std::string formatName = de::toLower(getFormatName((VkFormat)format)).substr(10);
de::MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, "suballocation", "BufferView Construction Tests for Suballocated Buffer"));
- const std::string testName = de::toLower(getFormatName((VkFormat)format)).substr(10);
- const std::string testDescription = "vkBufferView test " + testName;
+ const std::string testName = de::toLower(getFormatName((VkFormat)format)).substr(10);
+ const std::string testDescription = "vkBufferView test " + testName;
{
- const BufferViewCaseParameters testParams =
+ const BufferViewCaseParameters
+ testParams =
{
- static_cast<vk::VkFormat>(format), // VkFormat format;
- 0, // VkDeviceSize offset;
- range, // VkDeviceSize range;
- usage[usageNdx], // VkBufferUsageFlags usage;
- feature[usageNdx], // VkFormatFeatureFlags flags;
- static_cast<AllocationKind>(allocationKind) // AllocationKind bufferAllocationKind;
+ static_cast<vk::VkFormat>(format), // VkFormat format;
+ 0, // VkDeviceSize offset;
+ range, // VkDeviceSize range;
+ usage[usageNdx], // VkBufferUsageFlags usage;
+ feature[usageNdx], // VkFormatFeatureFlags flags;
+ static_cast<AllocationKind>(allocationKind) // AllocationKind bufferAllocationKind;
};
usageGroup->addChild(new BufferViewTestCase(testCtx, testName.c_str(), testDescription.c_str(), testParams));
{
vk::VkMemoryDedicatedRequirements getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkBuffer buffer)
+ vk::VkDevice device,
+ vk::VkBuffer buffer)
{
const vk::VkBufferMemoryRequirementsInfo2 requirementInfo =
{
}
vk::VkMemoryDedicatedRequirements getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkImage image)
+ vk::VkDevice device,
+ vk::VkImage image)
{
const vk::VkImageMemoryRequirementsInfo2 requirementInfo =
{
return instanceExtensions;
}
-vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp,
+vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp,
const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
const vk::VkExternalFenceHandleTypeFlags externalFenceTypes)
}
}
-vk::Move<vk::VkDevice> createDevice (const deUint32 apiVersion,
- const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice physicalDevice,
+vk::Move<vk::VkDevice> createDevice (const deUint32 apiVersion,
+ const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice physicalDevice,
const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
const vk::VkExternalFenceHandleTypeFlags externalFenceTypes,
- deUint32 queueFamilyIndex,
- bool useDedicatedAllocs = false)
+ deUint32 queueFamilyIndex,
+ bool useDedicatedAllocs = false)
{
std::vector<const char*> deviceExtensions;
return queue;
}
-void checkSemaphoreSupport (const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice device,
+void checkSemaphoreSupport (const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice device,
vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
const vk::VkPhysicalDeviceExternalSemaphoreInfo info =
TCU_THROW(NotSupportedError, "Semaphore doesn't support importing in external type");
}
-void checkFenceSupport (const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice device,
+void checkFenceSupport (const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice device,
vk::VkExternalFenceHandleTypeFlagBits externalType)
{
const vk::VkPhysicalDeviceExternalFenceInfo info =
void checkBufferSupport (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice device,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkBufferViewCreateFlags createFlag,
vk::VkBufferUsageFlags usageFlag,
bool dedicated)
TCU_THROW(NotSupportedError, "External handle type requires dedicated allocation");
}
-void checkImageSupport (const vk::InstanceInterface& vki,
- vk::VkPhysicalDevice device,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
- vk::VkImageViewCreateFlags createFlag,
- vk::VkImageUsageFlags usageFlag,
- vk::VkFormat format,
- vk::VkImageTiling tiling,
- bool dedicated)
+void checkImageSupport (const vk::InstanceInterface& vki,
+ vk::VkPhysicalDevice device,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkImageViewCreateFlags createFlag,
+ vk::VkImageUsageFlags usageFlag,
+ vk::VkFormat format,
+ vk::VkImageTiling tiling,
+ bool dedicated)
{
- const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
+ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
{
vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
externalType
};
- const vk::VkPhysicalDeviceImageFormatInfo2 info =
+ const vk::VkPhysicalDeviceImageFormatInfo2 info =
{
vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
&externalInfo,
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
DE_NULL
};
- const vk::VkExportSemaphoreCreateInfo exportCreateInfo=
+ const vk::VkExportSemaphoreCreateInfo exportCreateInfo=
{
vk::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
&win32ExportInfo,
(vk::VkExternalMemoryHandleTypeFlags)config.externalType
};
- const vk::VkSemaphoreCreateInfo createInfo =
+ const vk::VkSemaphoreCreateInfo createInfo =
{
vk::VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
&exportCreateInfo,
if (transference == TRANSFERENCE_COPY)
submitDummySignal(vkd, queue, *semaphore);
- NativeHandle handleA;
+ NativeHandle handleA;
getSemaphoreNative(vkd, *device, *semaphore, config.externalType, handleA);
{
- const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
- const vk::Unique<vk::VkSemaphore> semaphoreA (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
+ const vk::Unique<vk::VkSemaphore> semaphoreA (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
if (transference == TRANSFERENCE_COPY)
submitDummyWait(vkd, queue, *semaphoreA);
tcu::TestStatus testFenceQueries (Context& context, vk::VkExternalFenceHandleTypeFlagBits externalType)
{
- const vk::PlatformInterface& vkp (context.getPlatformInterface());
- const vk::Unique<vk::VkInstance> instance (createInstance(vkp, 0u, 0u, externalType));
- const vk::InstanceDriver vki (vkp, *instance);
- const vk::VkPhysicalDevice device (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
+ const vk::PlatformInterface& vkp (context.getPlatformInterface());
+ const vk::Unique<vk::VkInstance> instance (createInstance(vkp, 0u, 0u, externalType));
+ const vk::InstanceDriver vki (vkp, *instance);
+ const vk::VkPhysicalDevice device (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
- TestLog& log = context.getTestContext().getLog();
+ TestLog& log = context.getTestContext().getLog();
- const vk::VkPhysicalDeviceExternalFenceInfo info =
+ const vk::VkPhysicalDeviceExternalFenceInfo info =
{
vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalFenceProperties properties =
+ vk::VkExternalFenceProperties properties =
{
vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
DE_NULL,
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
DE_NULL
};
- const vk::VkExportFenceCreateInfo exportCreateInfo=
+ const vk::VkExportFenceCreateInfo exportCreateInfo=
{
vk::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
&win32ExportInfo,
&exportCreateInfo,
0u
};
- const vk::Unique<vk::VkFence> fence (vk::createFence(vkd, *device, &createInfo));
+ const vk::Unique<vk::VkFence> fence (vk::createFence(vkd, *device, &createInfo));
if (transference == TRANSFERENCE_COPY)
submitDummySignal(vkd, queue, *fence);
- NativeHandle handleA;
+ NativeHandle handleA;
getFenceNative(vkd, *device, *fence, config.externalType, handleA);
{
- const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
- const vk::Unique<vk::VkFence> fenceA (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::Unique<vk::VkFence> fenceA (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
if (transference == TRANSFERENCE_COPY)
VK_CHECK(vkd.waitForFences(*device, 1u, &*fenceA, VK_TRUE, ~0ull));
}
else
{
- const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const cmsghdr* const cmsg = CMSG_FIRSTHDR(&msg);
int newFd_;
deMemcpy(&newFd_, CMSG_DATA(cmsg), sizeof(int));
usageFlag,
externalType
};
- vk::VkExternalBufferProperties properties =
+ vk::VkExternalBufferProperties properties =
{
vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
DE_NULL,
if (deviceHasDedicated)
{
const vk::Unique<vk::VkBuffer> buffer (createExternalBuffer(*vkd, *device, queueFamilyIndex, externalType, 1024u, createFlag, usageFlag));
- const vk::VkMemoryDedicatedRequirements reqs (getMemoryDedicatedRequirements(*vkd, *device, *buffer));
+ const vk::VkMemoryDedicatedRequirements reqs (getMemoryDedicatedRequirements(*vkd, *device, *buffer));
const bool propertiesRequiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
const bool objectRequiresDedicated = (reqs.requiresDedicatedAllocation != VK_FALSE);
struct BufferTestConfig
{
- BufferTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
- bool dedicated_)
+ BufferTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
+ bool dedicated_)
: externalType (externalType_)
, dedicated (dedicated_)
{
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
const vk::VkImageType type = vk::VK_IMAGE_TYPE_2D;
const vk::VkImageTiling tiling = vk::VK_IMAGE_TILING_OPTIMAL;
- const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
+ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
{
vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
externalType
};
- const vk::VkPhysicalDeviceImageFormatInfo2 info =
+ const vk::VkPhysicalDeviceImageFormatInfo2 info =
{
vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
&externalInfo,
usageFlag,
createFlag,
};
- vk::VkExternalImageFormatProperties externalProperties =
+ vk::VkExternalImageFormatProperties externalProperties =
{
vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
- vk::VkImageFormatProperties2 properties =
+ vk::VkImageFormatProperties2 properties =
{
vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
&externalProperties,
if (deviceHasDedicated)
{
const vk::Unique<vk::VkImage> image (createExternalImage(*vkd, *device, queueFamilyIndex, externalType, format, 16u, 16u, tiling, createFlag, usageFlag));
- const vk::VkMemoryDedicatedRequirements reqs (getMemoryDedicatedRequirements(*vkd, *device, *image));
+ const vk::VkMemoryDedicatedRequirements reqs (getMemoryDedicatedRequirements(*vkd, *device, *image));
const bool propertiesRequiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
const bool objectRequiresDedicated = (reqs.requiresDedicatedAllocation != VK_FALSE);
struct ImageTestConfig
{
- ImageTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
- bool dedicated_)
+ ImageTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
+ bool dedicated_)
: externalType (externalType_)
, dedicated (dedicated_)
{
}
vk::VkExternalMemoryHandleTypeFlagBits externalType;
- bool dedicated;
+ bool dedicated;
};
tcu::TestStatus testImageBindExportImportBind (Context& context,
for (size_t deviceNdx = 0; deviceNdx < devices.size(); ++deviceNdx)
{
VkPhysicalDeviceFeatures coreFeatures;
- VkPhysicalDeviceFeatures2 extFeatures;
+ VkPhysicalDeviceFeatures2 extFeatures;
deMemset(&coreFeatures, 0xcd, sizeof(coreFeatures));
deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features));
for (size_t deviceNdx = 0; deviceNdx < devices.size(); ++deviceNdx)
{
- VkPhysicalDeviceProperties coreProperties;
+ VkPhysicalDeviceProperties coreProperties;
VkPhysicalDeviceProperties2 extProperties;
extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
{
const VkFormat format = (VkFormat)formatNdx;
VkFormatProperties coreProperties;
- VkFormatProperties2 extProperties;
+ VkFormatProperties2 extProperties;
deMemset(&coreProperties, 0xcd, sizeof(VkFormatProperties));
deMemset(&extProperties, 0xcd, sizeof(VkFormatProperties2));
{
case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: pointClippingOutside = true; break;
case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY: pointClippingOutside = false; break;
- case invalidClippingBehavior: TCU_FAIL("Clipping behavior read failure"); break;
+ case invalidClippingBehavior: TCU_FAIL("Clipping behavior read failure"); break;
default:
{
TCU_FAIL("Unexpected clipping behavior reported");
deviceExtensions.push_back("VK_KHR_device_group");
deviceExtensions.push_back("VK_KHR_swapchain");
- VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
+ VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
DE_NULL, //pNext
devGroupProperties[devGroupIdx].physicalDevices //physicalDevices
};
InstanceDriver instance (m_context.getPlatformInterface(), m_deviceGroupInstance.get());
- const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(instance, deviceGroupInfo.pPhysicalDevices[physDeviceIdx]);
- const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instance, devGroupProperties[devGroupIdx].physicalDevices[physDeviceIdx]);
+ const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(instance, deviceGroupInfo.pPhysicalDevices[physDeviceIdx]);
+ const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instance, devGroupProperties[devGroupIdx].physicalDevices[physDeviceIdx]);
m_physicalDevices.resize(m_numPhysDevices);
for (deUint32 physDevIdx = 0; physDevIdx < m_numPhysDevices; physDevIdx++)
m_queueFamilyIndex = (deUint32)queueNdx;
}
- VkDeviceQueueCreateInfo queueInfo =
+ VkDeviceQueueCreateInfo queueInfo =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
&queuePriority // const float* pQueuePriorities;
};
- const VkDeviceCreateInfo deviceInfo =
+ const VkDeviceCreateInfo deviceInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
&deviceGroupInfo, // const void* pNext;
void UploadDownloadExecutor::uploadStore(Context& context)
{
- const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo = {
+ const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo =
+ {
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VK_IMAGE_USAGE_STORAGE_BIT, // VkImageUsageFlags usage;
for (deUint32 subpassNdx = 0; subpassNdx < m_caseDef.numLayers; ++subpassNdx)
{
- const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo = {
+ const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo =
+ {
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // VkImageUsageFlags usage;
m_dTex.outImageAlloc = bindImage(m_vk, m_device, m_allocator, *m_dTex.outImage, MemoryRequirement::Any);
m_dTex.outImageView = makeImageView(m_vk, m_device, *m_dTex.outImage, getImageViewType(m_caseDef.imageType), m_caseDef.viewFormat, makeColorSubresourceRange(0, m_caseDef.numLayers));
- const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo = {
+ const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo =
+ {
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
m_dLoad.outImageAlloc = bindImage(m_vk, m_device, m_allocator, *m_dLoad.outImage, MemoryRequirement::Any);
m_dLoad.outImageView = makeImageView(m_vk, m_device, *m_dLoad.outImage, getImageViewType(m_caseDef.imageType), m_caseDef.viewFormat, makeColorSubresourceRange(0, m_caseDef.numLayers));
- const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo = {
+ const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo =
+ {
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VK_IMAGE_USAGE_STORAGE_BIT, // VkImageUsageFlags usage;
const vk::VkImageViewType imageViewType,
const vk::VkFormat format,
const vk::VkImageSubresourceRange subresourceRange,
- const vk::VkImageViewUsageCreateInfo* ImageUsageCreateInfoKHR = DE_NULL);
+ const vk::VkImageViewUsageCreateInfo* ImageUsageCreateInfoKHR = DE_NULL);
vk::Move<vk::VkDescriptorSet> makeDescriptorSet (const vk::DeviceInterface& vk,
const vk::VkDevice device,
VkDeviceQueueCreateInfo queueInfo =
{
- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (VkDeviceQueueCreateFlags)0u, // VkDeviceQueueCreateFlags flags;
- queueFamilyIndex, // deUint32 queueFamilyIndex;
- 1u, // deUint32 queueCount;
- &queuePriority // const float* pQueuePriorities;
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (VkDeviceQueueCreateFlags)0u, // VkDeviceQueueCreateFlags flags;
+ queueFamilyIndex, // deUint32 queueFamilyIndex;
+ 1u, // deUint32 queueCount;
+ &queuePriority // const float* pQueuePriorities;
};
const VkDeviceCreateInfo deviceInfo =
0u, // uint32_t enabledLayerCount;
DE_NULL, // const char* const* ppEnabledLayerNames;
deUint32(deviceExtensions.size()), // uint32_t enabledExtensionCount;
- deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0], // const char* const* ppEnabledExtensionNames;
+ deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0], // const char* const* ppEnabledExtensionNames;
&deviceFeatures, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
m_logicalDevice = createDevice(instance, deviceGroupInfo.pPhysicalDevices[physDeviceIdx], &deviceInfo);
VkMemoryRequirements getImageMemoryRequirements(const DeviceInterface& vk, VkDevice device, Move<VkImage>& image)
{
- VkImageMemoryRequirementsInfo2 info =
+ VkImageMemoryRequirementsInfo2 info =
{
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
- DE_NULL, // const void* pNext
- *image // VkImage image
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ *image // VkImage image
};
- VkMemoryDedicatedRequirements dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
- VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType
- DE_NULL, // const void* pNext
- VK_FALSE, // VkBool32 prefersDedicatedAllocation
- VK_FALSE // VkBool32 requiresDedicatedAllocation
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ VK_FALSE, // VkBool32 prefersDedicatedAllocation
+ VK_FALSE // VkBool32 requiresDedicatedAllocation
};
- VkMemoryRequirements2 req2 =
+ VkMemoryRequirements2 req2 =
{
- VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
- &dedicatedRequirements, // void* pNext
- {0, 0, 0} // VkMemoryRequirements memoryRequirements
+ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
+ &dedicatedRequirements, // void* pNext
+ {0, 0, 0} // VkMemoryRequirements memoryRequirements
};
vk.getImageMemoryRequirements2(device, &info, &req2);
VkMemoryRequirements getBufferMemoryRequirements(const DeviceInterface& vk, VkDevice device, Move<VkBuffer>& buffer)
{
- VkBufferMemoryRequirementsInfo2 info =
+ VkBufferMemoryRequirementsInfo2 info =
{
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
- DE_NULL, // const void* pNext
- *buffer // VkImage image
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ *buffer // VkImage image
};
- VkMemoryDedicatedRequirements dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
- VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType
- DE_NULL, // const void* pNext
- VK_FALSE, // VkBool32 prefersDedicatedAllocation
- VK_FALSE // VkBool32 requiresDedicatedAllocation
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ VK_FALSE, // VkBool32 prefersDedicatedAllocation
+ VK_FALSE // VkBool32 requiresDedicatedAllocation
};
- VkMemoryRequirements2 req2 =
+ VkMemoryRequirements2 req2 =
{
- VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
- &dedicatedRequirements, // void* pNext
- {0, 0, 0} // VkMemoryRequirements memoryRequirements
+ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
+ &dedicatedRequirements, // void* pNext
+ {0, 0, 0} // VkMemoryRequirements memoryRequirements
};
vk.getBufferMemoryRequirements2(device, &info, &req2);
if (!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_KHR_multiview"))
throw tcu::NotSupportedError("VK_KHR_multiview is not supported");
- const InstanceInterface& instance = m_context.getInstanceInterface();
- const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
+ const InstanceInterface& instance = m_context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
VkPhysicalDeviceMultiviewProperties multiviewProperties =
{
void MultiViewRenderTestInstance::createVertexBuffer (void)
{
- const VkDeviceSize vertexDataSize = static_cast<VkDeviceSize>(deAlignSize(static_cast<size_t>( m_data.size() * sizeof(VertexData)),
- static_cast<size_t>(m_context.getDeviceProperties().limits.nonCoherentAtomSize)));
- const VkBufferCreateInfo bufferInfo = makeBufferCreateInfo(vertexDataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
+ const VkDeviceSize vertexDataSize = static_cast<VkDeviceSize>(deAlignSize(static_cast<size_t>( m_data.size() * sizeof(VertexData)),
+ static_cast<size_t>(m_context.getDeviceProperties().limits.nonCoherentAtomSize)));
+ const VkBufferCreateInfo bufferInfo = makeBufferCreateInfo(vertexDataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
m_vertexBuffer = createBuffer(*m_device, *m_logicalDevice, &bufferInfo);
m_allocationBuffer = m_allocator->allocate(getBufferMemoryRequirements(*m_device, *m_logicalDevice, *m_vertexBuffer), MemoryRequirement::HostVisible);
const float queuePriorities = 1.0f;
const VkDeviceQueueCreateInfo queueInfo =
{
- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, //VkStructureType sType;
- DE_NULL, //const void* pNext;
- (VkDeviceQueueCreateFlags)0u, //VkDeviceQueueCreateFlags flags;
- m_queueFamilyIndex, //deUint32 queueFamilyIndex;
- 1u, //deUint32 queueCount;
- &queuePriorities //const float* pQueuePriorities;
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, //VkStructureType sType;
+ DE_NULL, //const void* pNext;
+ (VkDeviceQueueCreateFlags)0u, //VkDeviceQueueCreateFlags flags;
+ m_queueFamilyIndex, //deUint32 queueFamilyIndex;
+ 1u, //deUint32 queueCount;
+ &queuePriorities //const float* pQueuePriorities;
};
- VkPhysicalDeviceMultiviewFeatures multiviewFeatures =
+ VkPhysicalDeviceMultiviewFeatures multiviewFeatures =
{
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, // VkStructureType sType;
- DE_NULL, // void* pNext;
- DE_FALSE, // VkBool32 multiview;
- DE_FALSE, // VkBool32 multiviewGeometryShader;
- DE_FALSE, // VkBool32 multiviewTessellationShader;
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, // VkStructureType sType;
+ DE_NULL, // void* pNext;
+ DE_FALSE, // VkBool32 multiview;
+ DE_FALSE, // VkBool32 multiviewGeometryShader;
+ DE_FALSE, // VkBool32 multiviewTessellationShader;
};
- VkPhysicalDeviceFeatures2 enabledFeatures;
- enabledFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
- enabledFeatures.pNext = &multiviewFeatures;
+ VkPhysicalDeviceFeatures2 enabledFeatures;
+ enabledFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+ enabledFeatures.pNext = &multiviewFeatures;
instance.getPhysicalDeviceFeatures2(physicalDevice, &enabledFeatures);
if (TEST_TYPE_VIEW_INDEX_IN_TESELLATION == m_parameters.viewIndex && !multiviewFeatures.multiviewTessellationShader)
TCU_THROW(NotSupportedError, "Tessellation shader is not supported");
- VkPhysicalDeviceMultiviewProperties multiviewProperties =
+ VkPhysicalDeviceMultiviewProperties multiviewProperties =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, //VkStructureType sType;
DE_NULL, //void* pNext;
{
const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
{
- VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- *m_cmdPool, // VkCommandPool commandPool;
- VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
- 1u, // deUint32 bufferCount;
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *m_cmdPool, // VkCommandPool commandPool;
+ VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
+ 1u, // deUint32 bufferCount;
};
m_cmdBuffer = allocateCommandBuffer(*m_device, *m_logicalDevice, &cmdBufferAllocateInfo);
}
VK_FALSE, // VkBool32 primitiveRestartEnable;
};
- const VkViewport viewport =
+ const VkViewport viewport =
{
0.0f, // float originX;
0.0f, // float originY;
1.0f // float maxDepth;
};
- const VkRect2D scissor =
+ const VkRect2D scissor =
{
{ 0, 0 }, // VkOffset2D offset;
{ m_parameters.extent.width, m_parameters.extent.height } // VkExtent2D extent;
return vk::createDescriptorSetLayout(vk, device, &createInfo);
}
-Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk,
- const VkDevice device,
- const VkFormat colorFormat,
- const vector<deUint32>& viewMasks)
+Move<VkRenderPass> makeRenderPass (const DeviceInterface& vk,
+ const VkDevice device,
+ const VkFormat colorFormat,
+ const vector<deUint32>& viewMasks)
{
const deUint32 subpassCount = static_cast<deUint32>(viewMasks.size());
const VkAttachmentDescription colorAttachmentDescription =
{
- (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
- colorFormat, // VkFormat format;
- VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
- VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
- VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
- VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
+ (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
+ colorFormat, // VkFormat format;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
};
const VkAttachmentReference colorAttachmentReference =
{
- 0u, // deUint32 attachment;
- VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
+ 0u, // deUint32 attachment;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
};
const VkAttachmentReference depthAttachmentReference =
{
- VK_ATTACHMENT_UNUSED, // deUint32 attachment;
- VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout layout;
+ VK_ATTACHMENT_UNUSED, // deUint32 attachment;
+ VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout layout;
};
const VkSubpassDescription subpassDescription =
{
- (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
- VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
- 0u, // deUint32 inputAttachmentCount;
- DE_NULL, // const VkAttachmentReference* pInputAttachments;
- 1u, // deUint32 colorAttachmentCount;
- &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
- DE_NULL, // const VkAttachmentReference* pResolveAttachments;
- &depthAttachmentReference, // const VkAttachmentReference* pDepthStencilAttachment;
- 0u, // deUint32 preserveAttachmentCount;
- DE_NULL // const deUint32* pPreserveAttachments;
+ (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
+ VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
+ 0u, // deUint32 inputAttachmentCount;
+ DE_NULL, // const VkAttachmentReference* pInputAttachments;
+ 1u, // deUint32 colorAttachmentCount;
+ &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
+ DE_NULL, // const VkAttachmentReference* pResolveAttachments;
+ &depthAttachmentReference, // const VkAttachmentReference* pDepthStencilAttachment;
+ 0u, // deUint32 preserveAttachmentCount;
+ DE_NULL // const deUint32* pPreserveAttachments;
};
vector <VkSubpassDescription> subpassDescriptions (subpassCount, subpassDescription);
- const VkRenderPassMultiviewCreateInfo renderPassMultiviewInfo =
+ const VkRenderPassMultiviewCreateInfo renderPassMultiviewInfo =
{
- VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, //VkStructureType sType;
- DE_NULL, //const void* pNext;
- subpassCount, //uint32_t subpassCount;
- &viewMasks[0], //const uint32_t* pViewMasks;
- 0u, //uint32_t dependencyCount;
- DE_NULL, //const int32_t* pViewOffsets;
- 0u, //uint32_t correlationMaskCount;
- DE_NULL, //const uint32_t* pCorrelationMasks;
+ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, //VkStructureType sType;
+ DE_NULL, //const void* pNext;
+ subpassCount, //uint32_t subpassCount;
+ &viewMasks[0], //const uint32_t* pViewMasks;
+ 0u, //uint32_t dependencyCount;
+ DE_NULL, //const int32_t* pViewOffsets;
+ 0u, //uint32_t correlationMaskCount;
+ DE_NULL, //const uint32_t* pCorrelationMasks;
};
vector <VkSubpassDependency> subpassDependencies;
for(deUint32 subpassNdx = 0u; subpassNdx < subpassCount; ++subpassNdx)
{
- const VkSubpassDependency subpassDependency =
+ const VkSubpassDependency subpassDependency =
{
subpassNdx, // deUint32 srcSubpass;
(subpassNdx ==subpassCount - 1u) ? subpassNdx : subpassNdx+1u, // deUint32 dstSubpass;
subpassDependencies.push_back(subpassDependency);
}
- const VkRenderPassCreateInfo renderPassInfo =
+ const VkRenderPassCreateInfo renderPassInfo =
{
- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
- &renderPassMultiviewInfo, // const void* pNext;
- (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
- 1u, // deUint32 attachmentCount;
- &colorAttachmentDescription, // const VkAttachmentDescription* pAttachments;
- subpassCount, // deUint32 subpassCount;
- &subpassDescriptions[0], // const VkSubpassDescription* pSubpasses;
- subpassCount, // deUint32 dependencyCount;
- &subpassDependencies[0] // const VkSubpassDependency* pDependencies;
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
+ &renderPassMultiviewInfo, // const void* pNext;
+ (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
+ 1u, // deUint32 attachmentCount;
+ &colorAttachmentDescription, // const VkAttachmentDescription* pAttachments;
+ subpassCount, // deUint32 subpassCount;
+ &subpassDescriptions[0], // const VkSubpassDescription* pSubpasses;
+ subpassCount, // deUint32 dependencyCount;
+ &subpassDependencies[0] // const VkSubpassDependency* pDependencies;
};
return createRenderPass(vk, device, &renderPassInfo);
const bool useDeviceGroups,
const deUint32 physicalDeviceID)
{
- const VkFenceCreateInfo fenceParams =
+ const VkFenceCreateInfo fenceParams =
{
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // VkFenceCreateFlags flags;
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkFenceCreateFlags flags;
};
- const Unique<VkFence> fence(createFence(vk, device, &fenceParams));
+ const Unique<VkFence> fence(createFence (vk, device, &fenceParams));
- const deUint32 deviceMask = 1 << physicalDeviceID;
- std::vector<deUint32> deviceIndices (waitSemaphoreCount, physicalDeviceID);
+ const deUint32 deviceMask = 1 << physicalDeviceID;
+ std::vector<deUint32> deviceIndices (waitSemaphoreCount, physicalDeviceID);
VkDeviceGroupSubmitInfo deviceGroupSubmitInfo =
{
- VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, //VkStructureType sType
- DE_NULL, // const void* pNext
- waitSemaphoreCount, // uint32_t waitSemaphoreCount
- deviceIndices.size() ? &deviceIndices[0] : DE_NULL, // const uint32_t* pWaitSemaphoreDeviceIndices
- 1u, // uint32_t commandBufferCount
- &deviceMask, // const uint32_t* pCommandBufferDeviceMasks
- 0u, // uint32_t signalSemaphoreCount
- DE_NULL, // const uint32_t* pSignalSemaphoreDeviceIndices
+ VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, //VkStructureType sType
+ DE_NULL, // const void* pNext
+ waitSemaphoreCount, // uint32_t waitSemaphoreCount
+ deviceIndices.size() ? &deviceIndices[0] : DE_NULL, // const uint32_t* pWaitSemaphoreDeviceIndices
+ 1u, // uint32_t commandBufferCount
+ &deviceMask, // const uint32_t* pCommandBufferDeviceMasks
+ 0u, // uint32_t signalSemaphoreCount
+ DE_NULL, // const uint32_t* pSignalSemaphoreDeviceIndices
};
- const VkSubmitInfo submitInfo =
+ const VkSubmitInfo submitInfo =
{
VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
useDeviceGroups ? &deviceGroupSubmitInfo : DE_NULL, // const void* pNext;
TestConfig (const ResourceDescription& resource_,
OperationName writeOp_,
OperationName readOp_,
- vk::VkExternalMemoryHandleTypeFlagBits memoryHandleType_,
- vk::VkExternalSemaphoreHandleTypeFlagBits semaphoreHandleType_,
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleType_,
+ vk::VkExternalSemaphoreHandleTypeFlagBits semaphoreHandleType_,
bool dedicated_)
: resource (resource_)
, writeOp (writeOp_)
{
vk::VkExternalMemoryHandleTypeFlagBits memoryType;
vk::VkExternalSemaphoreHandleTypeFlagBits semaphoreType;
- const char* nameSuffix;
+ const char* nameSuffix;
} cases[] =
{
{
struct TestConfig
{
- TestConfig (const ResourceDescription& resource_,
- OperationName writeOp_,
- OperationName readOp_,
+ TestConfig (const ResourceDescription& resource_,
+ OperationName writeOp_,
+ OperationName readOp_,
vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeBuffer_,
vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeImage_)
: resource (resource_)
return -1;
}
-vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- const vk::VkMemoryRequirements& requirements,
+vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ const vk::VkMemoryRequirements& requirements,
vk::VkExternalMemoryHandleTypeFlagBits externalType,
- NativeHandle& handle,
- bool requiresDedicated,
- vk::VkBuffer buffer,
- vk::VkImage image)
+ NativeHandle& handle,
+ bool requiresDedicated,
+ vk::VkBuffer buffer,
+ vk::VkImage image)
{
const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
vk::VkDevice device,
vk::VkBuffer buffer,
NativeHandle& nativeHandle,
- vk::VkExternalMemoryHandleTypeFlagBits externalType)
+ vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
const vk::VkBufferMemoryRequirementsInfo2 requirementsInfo =
{
}
de::MovePtr<vk::Allocation> importAndBindMemory (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkImage image,
- NativeHandle& nativeHandle,
- vk::VkExternalMemoryHandleTypeFlagBits externalType)
+ vk::VkDevice device,
+ vk::VkImage image,
+ NativeHandle& nativeHandle,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
- const vk::VkImageMemoryRequirementsInfo2 requirementsInfo =
+ const vk::VkImageMemoryRequirementsInfo2 requirementsInfo =
{
vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
0u,
1u
};
- const vk::VkExternalMemoryImageCreateInfo externalInfo =
+ const vk::VkExternalMemoryImageCreateInfo externalInfo =
{
vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
DE_NULL,
(vk::VkExternalMemoryHandleTypeFlags)externalType
};
- const vk::VkImageCreateInfo createInfo =
+ const vk::VkImageCreateInfo createInfo =
{
vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
&externalInfo,
vk::VK_IMAGE_LAYOUT_UNDEFINED
};
- vk::Move<vk::VkImage> image = vk::createImage(vkd, device, &createInfo);
- de::MovePtr<vk::Allocation> allocation = importAndBindMemory(vkd, device, *image, nativeHandle, externalType);
+ vk::Move<vk::VkImage> image = vk::createImage(vkd, device, &createInfo);
+ de::MovePtr<vk::Allocation> allocation = importAndBindMemory(vkd, device, *image, nativeHandle, externalType);
return de::MovePtr<Resource>(new Resource(image, allocation, extent, resourceDesc.imageType, resourceDesc.imageFormat, subresourceRange, subresourceLayers));
}
else
{
- const vk::VkDeviceSize offset = 0u;
- const vk::VkDeviceSize size = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
- const vk::VkBufferUsageFlags usage = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
- const vk::VkExternalMemoryBufferCreateInfo externalInfo =
+ const vk::VkDeviceSize offset = 0u;
+ const vk::VkDeviceSize size = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
+ const vk::VkBufferUsageFlags usage = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
+ const vk::VkExternalMemoryBufferCreateInfo externalInfo =
{
vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
DE_NULL,
(vk::VkExternalMemoryHandleTypeFlags)externalType
};
- const vk::VkBufferCreateInfo createInfo =
+ const vk::VkBufferCreateInfo createInfo =
{
vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
&externalInfo,
(deUint32)queueFamilyIndices.size(),
&queueFamilyIndices[0]
};
- vk::Move<vk::VkBuffer> buffer = vk::createBuffer(vkd, device, &createInfo);
- de::MovePtr<vk::Allocation> allocation = importAndBindMemory(vkd, device, *buffer, nativeHandle, externalType);
+ vk::Move<vk::VkBuffer> buffer = vk::createBuffer(vkd, device, &createInfo);
+ de::MovePtr<vk::Allocation> allocation = importAndBindMemory(vkd, device, *buffer, nativeHandle, externalType);
return de::MovePtr<Resource>(new Resource(resourceDesc.type, buffer, allocation, offset, size));
}
deUint32 writeQueueFamilyIndex,
const SyncInfo& readSync)
{
- const vk::VkPipelineStageFlags srcStageMask = writeSync.stageMask;
- const vk::VkAccessFlags srcAccessMask = writeSync.accessMask;
+ const vk::VkPipelineStageFlags srcStageMask = writeSync.stageMask;
+ const vk::VkAccessFlags srcAccessMask = writeSync.accessMask;
- const vk::VkPipelineStageFlags dstStageMask = readSync.stageMask;
- const vk::VkAccessFlags dstAccessMask = readSync.accessMask;
+ const vk::VkPipelineStageFlags dstStageMask = readSync.stageMask;
+ const vk::VkAccessFlags dstAccessMask = readSync.accessMask;
- const vk::VkDependencyFlags dependencyFlags = 0;
+ const vk::VkDependencyFlags dependencyFlags = 0;
if (resource.getType() == RESOURCE_TYPE_IMAGE)
{
const SyncInfo& readSync,
deUint32 readQueueFamilyIndex)
{
- const vk::VkPipelineStageFlags srcStageMask = readSync.stageMask;
- const vk::VkAccessFlags srcAccessMask = readSync.accessMask;
+ const vk::VkPipelineStageFlags srcStageMask = readSync.stageMask;
+ const vk::VkAccessFlags srcAccessMask = readSync.accessMask;
- const vk::VkPipelineStageFlags dstStageMask = readSync.stageMask;
- const vk::VkAccessFlags dstAccessMask = readSync.accessMask;
+ const vk::VkPipelineStageFlags dstStageMask = readSync.stageMask;
+ const vk::VkAccessFlags dstAccessMask = readSync.accessMask;
- const vk::VkDependencyFlags dependencyFlags = 0;
+ const vk::VkDependencyFlags dependencyFlags = 0;
if (resource.getType() == RESOURCE_TYPE_IMAGE)
{
{
const struct
{
- vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeBuffer;
- vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeImage;
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeBuffer;
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeImage;
const char* nameSuffix;
} cases[] =
{
int getMemoryFd (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
- vk::VkExternalMemoryHandleTypeFlagBits externalType)
+ vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
const vk::VkMemoryGetFdInfoKHR info =
{
void getMemoryNative (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
NativeHandle& nativeHandle)
{
if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
vk::Move<vk::VkFence> createExportableFence (const vk::DeviceInterface& vkd,
vk::VkDevice device,
- vk::VkExternalFenceHandleTypeFlagBits externalType)
+ vk::VkExternalFenceHandleTypeFlagBits externalType)
{
const vk::VkExportFenceCreateInfo exportCreateInfo =
{
int getFenceFd (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBits externalType)
+ vk::VkExternalFenceHandleTypeFlagBits externalType)
{
const vk::VkFenceGetFdInfoKHR info =
{
void getFenceNative (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBits externalType,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
NativeHandle& nativeHandle)
{
if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
void importFence (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
const vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBits externalType,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
NativeHandle& handle,
vk::VkFenceImportFlags flags)
{
void importSemaphore (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
const vk::VkSemaphore semaphore,
- vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
NativeHandle& handle,
vk::VkSemaphoreImportFlags flags)
{
vk::Move<vk::VkSemaphore> createAndImportSemaphore (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
- vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
NativeHandle& handle,
- vk::VkSemaphoreImportFlags flags)
+ vk::VkSemaphoreImportFlags flags)
{
vk::Move<vk::VkSemaphore> semaphore (createSemaphore(vkd, device));
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkBuffer buffer,
- deUint32& exportedMemoryTypeIndex)
+ deUint32& exportedMemoryTypeIndex)
{
exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits);
const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkImage image,
- deUint32& exportedMemoryTypeIndex)
+ deUint32& exportedMemoryTypeIndex)
{
exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits);
const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
bool hostVisible,
vk::VkBuffer buffer,
deUint32& exportedMemoryTypeIndex)
externalType,
handle.getFd()
};
- const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
+ const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
&importInfo,
else if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
|| externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
- const vk::VkImportMemoryWin32HandleInfoKHR importInfo =
+ const vk::VkImportMemoryWin32HandleInfoKHR importInfo =
{
vk::VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
DE_NULL,
handle.getWin32Handle(),
DE_NULL
};
- const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
+ const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
&importInfo,
vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle)
{
vk::VkDevice device,
vk::VkBuffer buffer,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle)
{
vk::VkDevice device,
vk::VkImage image,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle)
{
vk::Move<vk::VkBuffer> createExternalBuffer (const vk::DeviceInterface& vkd,
vk::VkDevice device,
deUint32 queueFamilyIndex,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkDeviceSize size,
vk::VkBufferCreateFlags createFlags,
vk::VkBufferUsageFlags usageFlags)
{
- const vk::VkExternalMemoryBufferCreateInfo externalCreateInfo =
+ const vk::VkExternalMemoryBufferCreateInfo externalCreateInfo =
{
vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
DE_NULL,
vk::Move<vk::VkImage> createExternalImage (const vk::DeviceInterface& vkd,
vk::VkDevice device,
deUint32 queueFamilyIndex,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkFormat format,
deUint32 width,
deUint32 height,
NativeHandle& operator= (const NativeHandle&);
};
-const char* externalSemaphoreTypeToName (vk::VkExternalSemaphoreHandleTypeFlagBits type);
-const char* externalFenceTypeToName (vk::VkExternalFenceHandleTypeFlagBits type);
-const char* externalMemoryTypeToName (vk::VkExternalMemoryHandleTypeFlagBits type);
+const char* externalSemaphoreTypeToName (vk::VkExternalSemaphoreHandleTypeFlagBits type);
+const char* externalFenceTypeToName (vk::VkExternalFenceHandleTypeFlagBits type);
+const char* externalMemoryTypeToName (vk::VkExternalMemoryHandleTypeFlagBits type);
enum Permanence
{
};
bool isSupportedPermanence (vk::VkExternalSemaphoreHandleTypeFlagBits type,
- Permanence permanence);
+ Permanence permanence);
Transference getHandelTypeTransferences (vk::VkExternalSemaphoreHandleTypeFlagBits type);
bool isSupportedPermanence (vk::VkExternalFenceHandleTypeFlagBits type,
- Permanence permanence);
+ Permanence permanence);
Transference getHandelTypeTransferences (vk::VkExternalFenceHandleTypeFlagBits type);
int getMemoryFd (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
- vk::VkExternalMemoryHandleTypeFlagBits externalType);
+ vk::VkExternalMemoryHandleTypeFlagBits externalType);
void getMemoryNative (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
NativeHandle& nativeHandle);
-vk::Move<vk::VkSemaphore> createExportableSemaphore (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
+vk::Move<vk::VkSemaphore> createExportableSemaphore (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
vk::VkExternalSemaphoreHandleTypeFlagBits externalType);
-int getSemaphoreFd (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkSemaphore semaphore,
+int getSemaphoreFd (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkSemaphore semaphore,
vk::VkExternalSemaphoreHandleTypeFlagBits externalType);
-void getSemaphoreNative (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkSemaphore semaphore,
+void getSemaphoreNative (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkSemaphore semaphore,
vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
- NativeHandle& nativeHandle);
+ NativeHandle& nativeHandle);
-void importSemaphore (const vk::DeviceInterface& vkd,
- const vk::VkDevice device,
- const vk::VkSemaphore semaphore,
+void importSemaphore (const vk::DeviceInterface& vkd,
+ const vk::VkDevice device,
+ const vk::VkSemaphore semaphore,
vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
- NativeHandle& handle,
+ NativeHandle& handle,
vk::VkSemaphoreImportFlags flags);
-vk::Move<vk::VkSemaphore> createAndImportSemaphore (const vk::DeviceInterface& vkd,
- const vk::VkDevice device,
+vk::Move<vk::VkSemaphore> createAndImportSemaphore (const vk::DeviceInterface& vkd,
+ const vk::VkDevice device,
vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
- NativeHandle& handle,
+ NativeHandle& handle,
vk::VkSemaphoreImportFlags flags);
-vk::Move<vk::VkFence> createExportableFence (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
+vk::Move<vk::VkFence> createExportableFence (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
vk::VkExternalFenceHandleTypeFlagBits externalType);
-int getFenceFd (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkFence fence,
+int getFenceFd (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkFence fence,
vk::VkExternalFenceHandleTypeFlagBits externalType);
-void getFenceNative (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkFence fence,
+void getFenceNative (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkFence fence,
vk::VkExternalFenceHandleTypeFlagBits externalType,
- NativeHandle& nativeHandle);
+ NativeHandle& nativeHandle);
-void importFence (const vk::DeviceInterface& vkd,
- const vk::VkDevice device,
- const vk::VkFence fence,
+void importFence (const vk::DeviceInterface& vkd,
+ const vk::VkDevice device,
+ const vk::VkFence fence,
vk::VkExternalFenceHandleTypeFlagBits externalType,
- NativeHandle& handle,
+ NativeHandle& handle,
vk::VkFenceImportFlags flags);
-vk::Move<vk::VkFence> createAndImportFence (const vk::DeviceInterface& vkd,
- const vk::VkDevice device,
+vk::Move<vk::VkFence> createAndImportFence (const vk::DeviceInterface& vkd,
+ const vk::VkDevice device,
vk::VkExternalFenceHandleTypeFlagBits externalType,
- NativeHandle& handle,
+ NativeHandle& handle,
vk::VkFenceImportFlags flags);
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32& exportedMemoryTypeIndex);
// If buffer is not null use dedicated allocation
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkBuffer buffer,
deUint32& exportedMemoryTypeIndex);
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkImage image,
deUint32& exportedMemoryTypeIndex);
const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
bool hostVisible,
vk::VkBuffer buffer,
deUint32& exportedMemoryTypeIndex);
vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle);
vk::VkDevice device,
vk::VkBuffer buffer,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle);
vk::VkDevice device,
vk::VkImage image,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle);
vk::Move<vk::VkBuffer> createExternalBuffer (const vk::DeviceInterface& vkd,
vk::VkDevice device,
deUint32 queueFamilyIndex,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkDeviceSize size,
vk::VkBufferCreateFlags createFlags,
vk::VkBufferUsageFlags usageFlags);
vk::Move<vk::VkImage> createExternalImage (const vk::DeviceInterface& vkd,
vk::VkDevice device,
deUint32 queueFamilyIndex,
- vk::VkExternalMemoryHandleTypeFlagBits externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkFormat format,
deUint32 width,
deUint32 height,
tcu::TestStatus queryDevGroupSurfacePresentCapabilitiesTest (Context& context, Type wsiType)
{
- tcu::TestLog& log = context.getTestContext().getLog();
- const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
- const float queuePriority = 1.0f;
- const tcu::CommandLine& cmdLine = context.getTestContext().getCommandLine();
- const deUint32 devGroupIdx = cmdLine.getVKDeviceGroupId() - 1;
- const deUint32 deviceIdx = context.getTestContext().getCommandLine().getVKDeviceId() - 1u;
- const VkDeviceGroupPresentModeFlagsKHR requiredFlag = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
- const VkDeviceGroupPresentModeFlagsKHR maxValidFlag = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR |
- VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR;
- deUint8 buffer [sizeof(VkDeviceGroupPresentCapabilitiesKHR) + GUARD_SIZE];
- deUint32 queueFamilyIndex = 0;
- VkDeviceGroupPresentCapabilitiesKHR* presentCapabilities;
- std::vector<const char*> deviceExtensions;
+ tcu::TestLog& log = context.getTestContext().getLog();
+ const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_device_group_creation")));
+ const float queuePriority = 1.0f;
+ const tcu::CommandLine& cmdLine = context.getTestContext().getCommandLine();
+ const deUint32 devGroupIdx = cmdLine.getVKDeviceGroupId() - 1;
+ const deUint32 deviceIdx = context.getTestContext().getCommandLine().getVKDeviceId() - 1u;
+ const VkDeviceGroupPresentModeFlagsKHR requiredFlag = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
+ const VkDeviceGroupPresentModeFlagsKHR maxValidFlag = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR |
+ VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR|VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR;
+ deUint8 buffer [sizeof(VkDeviceGroupPresentCapabilitiesKHR) + GUARD_SIZE];
+ deUint32 queueFamilyIndex = 0;
+ VkDeviceGroupPresentCapabilitiesKHR* presentCapabilities;
+ std::vector<const char*> deviceExtensions;
if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
deviceExtensions.push_back("VK_KHR_device_group");
deviceExtensions.push_back("VK_KHR_swapchain");
- const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
- const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
+ const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
{
if (queueProps[queueNdx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
queueFamilyIndex = (deUint32)queueNdx;
}
- const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
+ const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, //type
DE_NULL, //pNext
1u, //queueCount;
&queuePriority, //pQueuePriorities;
};
- const VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
+ const VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
DE_NULL, //pNext
deviceGroupProps[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
deviceGroupProps[devGroupIdx].physicalDevices //physicalDevices
};
- const VkDeviceCreateInfo deviceCreateInfo =
+ const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, //sType;
&deviceGroupInfo, //pNext;
}
}
-Interval rangeExpandChroma (vk::VkSamplerYcbcrRange range,
+Interval rangeExpandChroma (vk::VkSamplerYcbcrRange range,
const FloatFormat& conversionFormat,
const deUint32 bits,
const Interval& sample)
}
}
-Interval rangeExpandLuma (vk::VkSamplerYcbcrRange range,
+Interval rangeExpandLuma (vk::VkSamplerYcbcrRange range,
const FloatFormat& conversionFormat,
const deUint32 bits,
const Interval& sample)
Interval reconstructLinearXChromaSample (const FloatFormat& filteringFormat,
const FloatFormat& conversionFormat,
- vk::VkChromaLocation offset,
+ vk::VkChromaLocation offset,
vk::VkSamplerAddressMode addressModeU,
vk::VkSamplerAddressMode addressModeV,
const ChannelAccess& access,
struct RangeNamePair
{
const char* name;
- vk::VkSamplerYcbcrRange value;
+ vk::VkSamplerYcbcrRange value;
};
struct ChromaLocationNamePair
{
- const char* name;
- vk::VkChromaLocation value;
+ const char* name;
+ vk::VkChromaLocation value;
};
void initTests (tcu::TestCaseGroup* testGroup)
{ "nearest", vk::VK_FILTER_NEAREST }
};
// Used by the chroma reconstruction tests
- const vk::VkSamplerYcbcrModelConversion defaultColorModel (vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY);
- const vk::VkSamplerYcbcrRange defaultColorRange (vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL);
+ const vk::VkSamplerYcbcrModelConversion defaultColorModel (vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY);
+ const vk::VkSamplerYcbcrRange defaultColorRange (vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL);
const vk::VkComponentMapping identitySwizzle =
{
vk::VK_COMPONENT_SWIZZLE_IDENTITY,
// Test formats without chroma reconstruction
for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(noChromaSubsampledFormats); formatNdx++)
{
- const vk::VkFormat format (noChromaSubsampledFormats[formatNdx]);
- const std::string formatName (de::toLower(std::string(getFormatName(format)).substr(10)));
- de::MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, formatName.c_str(), ("Tests for color conversion using format " + formatName).c_str()));
+ const vk::VkFormat format (noChromaSubsampledFormats[formatNdx]);
+ const std::string formatName (de::toLower(std::string(getFormatName(format)).substr(10)));
+ de::MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, formatName.c_str(), ("Tests for color conversion using format " + formatName).c_str()));
for (size_t modelNdx = 0; modelNdx < DE_LENGTH_OF_ARRAY(colorModels); modelNdx++)
{
- const char* const colorModelName (colorModels[modelNdx].name);
- const vk::VkSamplerYcbcrModelConversion colorModel (colorModels[modelNdx].value);
+ const char* const colorModelName (colorModels[modelNdx].name);
+ const vk::VkSamplerYcbcrModelConversion colorModel (colorModels[modelNdx].value);
if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY && getFormatChannelCount(format) < 3)
continue;
- de::MovePtr<tcu::TestCaseGroup> colorModelGroup (new tcu::TestCaseGroup(testCtx, colorModelName, ("Tests for color model " + string(colorModelName)).c_str()));
+ de::MovePtr<tcu::TestCaseGroup> colorModelGroup (new tcu::TestCaseGroup(testCtx, colorModelName, ("Tests for color model " + string(colorModelName)).c_str()));
if (colorModel == vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY)
{
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
{
- const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
- const char* const tilingName (imageTilings[tilingNdx].name);
- const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
+ const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
+ const char* const tilingName (imageTilings[tilingNdx].name);
+ const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
const vk::VkSamplerYcbcrRange colorRange (rng.choose<RangeNamePair, const RangeNamePair*>(DE_ARRAY_BEGIN(colorRanges), DE_ARRAY_END(colorRanges)).value);
const vk::VkChromaLocation chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
- const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
- textureFilter, chromaLocation, chromaLocation, false, false,
- colorRange, colorModel, identitySwizzle);
+ const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+ textureFilter, chromaLocation, chromaLocation, false, false,
+ colorRange, colorModel, identitySwizzle);
addFunctionCaseWithPrograms(colorModelGroup.get(), std::string(textureFilterName) + "_" + tilingName, "", createTestShaders, textureConversionTest, config);
}
{
for (size_t rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(colorRanges); rangeNdx++)
{
- const char* const colorRangeName (colorRanges[rangeNdx].name);
+ const char* const colorRangeName (colorRanges[rangeNdx].name);
const vk::VkSamplerYcbcrRange colorRange (colorRanges[rangeNdx].value);
// Narrow range doesn't really work with formats that have less than 8 bits
if (colorRange == vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW)
{
- const UVec4 bitDepth (getBitDepth(format));
+ const UVec4 bitDepth (getBitDepth(format));
if (bitDepth[0] < 8 || bitDepth[1] < 8 || bitDepth[2] < 8)
continue;
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
{
- const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
- const char* const tilingName (imageTilings[tilingNdx].name);
- const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
+ const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
+ const char* const tilingName (imageTilings[tilingNdx].name);
+ const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
const vk::VkChromaLocation chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
- const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
- textureFilter, chromaLocation, chromaLocation, false, false,
- colorRange, colorModel, identitySwizzle);
+ const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+ textureFilter, chromaLocation, chromaLocation, false, false,
+ colorRange, colorModel, identitySwizzle);
addFunctionCaseWithPrograms(colorRangeGroup.get(), std::string(textureFilterName) + "_" + tilingName, "", createTestShaders, textureConversionTest, config);
}
for (size_t xChromaOffsetNdx = 0; xChromaOffsetNdx < DE_LENGTH_OF_ARRAY(chromaLocations); xChromaOffsetNdx++)
{
- const char* const xChromaOffsetName (chromaLocations[xChromaOffsetNdx].name);
+ const char* const xChromaOffsetName (chromaLocations[xChromaOffsetNdx].name);
const vk::VkChromaLocation xChromaOffset (chromaLocations[xChromaOffsetNdx].value);
for (size_t modelNdx = 0; modelNdx < DE_LENGTH_OF_ARRAY(colorModels); modelNdx++)
{
- const char* const colorModelName (colorModels[modelNdx].name);
+ const char* const colorModelName (colorModels[modelNdx].name);
const vk::VkSamplerYcbcrModelConversion colorModel (colorModels[modelNdx].value);
if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY && getFormatChannelCount(format) < 3)
{
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
{
- const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
- const char* const tilingName (imageTilings[tilingNdx].name);
+ const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
+ const char* const tilingName (imageTilings[tilingNdx].name);
const vk::VkSamplerYcbcrRange colorRange (rng.choose<RangeNamePair, const RangeNamePair*>(DE_ARRAY_BEGIN(colorRanges), DE_ARRAY_END(colorRanges)).value);
- const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
+ const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
const vk::VkChromaLocation yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
- const TestConfig config (shaderType, format, tiling, vk::VK_FILTER_NEAREST, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
- vk::VK_FILTER_NEAREST, xChromaOffset, yChromaOffset, false, false,
- colorRange, colorModel, identitySwizzle);
+ const TestConfig config (shaderType, format, tiling, vk::VK_FILTER_NEAREST, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+ vk::VK_FILTER_NEAREST, xChromaOffset, yChromaOffset, false, false,
+ colorRange, colorModel, identitySwizzle);
addFunctionCaseWithPrograms(conversionGroup.get(), std::string(colorModelName) + "_" + tilingName + "_" + xChromaOffsetName, "", createTestShaders, textureConversionTest, config);
}
{
for (size_t rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(colorRanges); rangeNdx++)
{
- const char* const colorRangeName (colorRanges[rangeNdx].name);
+ const char* const colorRangeName (colorRanges[rangeNdx].name);
const vk::VkSamplerYcbcrRange colorRange (colorRanges[rangeNdx].value);
// Narrow range doesn't really work with formats that have less than 8 bits
if (colorRange == vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW)
{
- const UVec4 bitDepth (getBitDepth(format));
+ const UVec4 bitDepth (getBitDepth(format));
if (bitDepth[0] < 8 || bitDepth[1] < 8 || bitDepth[2] < 8)
continue;
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
{
- const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
- const char* const tilingName (imageTilings[tilingNdx].name);
- const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
+ const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
+ const char* const tilingName (imageTilings[tilingNdx].name);
+ const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
const vk::VkChromaLocation yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
- const TestConfig config (shaderType, format, tiling, vk::VK_FILTER_NEAREST, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
- vk::VK_FILTER_NEAREST, xChromaOffset, yChromaOffset, false, false,
- colorRange, colorModel, identitySwizzle);
+ const TestConfig config (shaderType, format, tiling, vk::VK_FILTER_NEAREST, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+ vk::VK_FILTER_NEAREST, xChromaOffset, yChromaOffset, false, false,
+ colorRange, colorModel, identitySwizzle);
addFunctionCaseWithPrograms(conversionGroup.get(), (string(colorModelName) + "_" + colorRangeName + "_" + tilingName + "_" + xChromaOffsetName).c_str(), "", createTestShaders, textureConversionTest, config);
}
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
{
- const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
- const char* const tilingName (imageTilings[tilingNdx].name);
+ const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
+ const char* const tilingName (imageTilings[tilingNdx].name);
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
for (size_t chromaOffsetNdx = 0; chromaOffsetNdx < DE_LENGTH_OF_ARRAY(chromaLocations); chromaOffsetNdx++)
{
- const char* const chromaOffsetName (chromaLocations[chromaOffsetNdx].name);
+ const char* const chromaOffsetName (chromaLocations[chromaOffsetNdx].name);
const vk::VkChromaLocation chromaOffset (chromaLocations[chromaOffsetNdx].value);
for (size_t modelNdx = 0; modelNdx < DE_LENGTH_OF_ARRAY(colorModels); modelNdx++)
VkDevice device,
VkImage image,
VkFormat format,
- VkSamplerYcbcrConversion conversion)
+ VkSamplerYcbcrConversion conversion)
{
- const VkSamplerYcbcrConversionInfo conversionInfo =
+ const VkSamplerYcbcrConversionInfo conversionInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vkd, VkDevice device, VkSampler sampler)
{
- const VkDescriptorSetLayoutBinding binding =
+ const VkDescriptorSetLayoutBinding binding =
{
- 0u, // binding
+ 0u, // binding
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
- 1u, // descriptorCount
+ 1u, // descriptorCount
VK_SHADER_STAGE_ALL,
&sampler
};
VkImageView imageView,
VkSampler sampler)
{
- Move<VkDescriptorSet> descSet;
+ Move<VkDescriptorSet> descSet;
{
- const VkDescriptorSetAllocateInfo allocInfo =
+ const VkDescriptorSetAllocateInfo allocInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
DE_NULL,
}
{
- const VkDescriptorImageInfo imageInfo =
+ const VkDescriptorImageInfo imageInfo =
{
sampler,
imageView,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
};
- const VkWriteDescriptorSet descriptorWrite =
+ const VkWriteDescriptorSet descriptorWrite =
{
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
DE_NULL,
{
checkSupport(context, params);
- const DeviceInterface& vkd = context.getDeviceInterface();
- const VkDevice device = context.getDevice();
+ const DeviceInterface& vkd = context.getDeviceInterface();
+ const VkDevice device = context.getDevice();
- const VkFormat format = params.format;
- const PlanarFormatDescription formatInfo = getPlanarFormatDescription(format);
- const UVec2 size = params.size;
- const VkImageCreateFlags createFlags = params.flags;
- const VkImageTiling tiling = params.tiling;
- const bool mappedMemory = params.useMappedMemory;
+ const VkFormat format = params.format;
+ const PlanarFormatDescription formatInfo = getPlanarFormatDescription(format);
+ const UVec2 size = params.size;
+ const VkImageCreateFlags createFlags = params.flags;
+ const VkImageTiling tiling = params.tiling;
+ const bool mappedMemory = params.useMappedMemory;
- const Unique<VkImage> image (createTestImage(vkd, device, format, size, createFlags, tiling, mappedMemory ? VK_IMAGE_LAYOUT_PREINITIALIZED : VK_IMAGE_LAYOUT_UNDEFINED));
- const vector<AllocationSp> allocations (allocateAndBindImageMemory(vkd, device, context.getDefaultAllocator(), *image, format, createFlags, mappedMemory ? MemoryRequirement::HostVisible : MemoryRequirement::Any));
+ const Unique<VkImage> image (createTestImage(vkd, device, format, size, createFlags, tiling, mappedMemory ? VK_IMAGE_LAYOUT_PREINITIALIZED : VK_IMAGE_LAYOUT_UNDEFINED));
+ const vector<AllocationSp> allocations (allocateAndBindImageMemory(vkd, device, context.getDefaultAllocator(), *image, format, createFlags, mappedMemory ? MemoryRequirement::HostVisible : MemoryRequirement::Any));
- const VkSamplerYcbcrConversionCreateInfo conversionInfo =
+ const VkSamplerYcbcrConversionCreateInfo
+ conversionInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
DE_NULL,
VK_FILTER_NEAREST,
VK_FALSE, // forceExplicitReconstruction
};
- const Unique<VkSamplerYcbcrConversion> conversion (createSamplerYcbcrConversion(vkd, device, &conversionInfo));
- const Unique<VkImageView> imageView (createImageView(vkd, device, *image, format, *conversion));
+ const Unique<VkSamplerYcbcrConversion> conversion (createSamplerYcbcrConversion(vkd, device, &conversionInfo));
+ const Unique<VkImageView> imageView (createImageView(vkd, device, *image, format, *conversion));
- const VkSamplerYcbcrConversionInfo samplerConversionInfo =
+ const VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
VK_FALSE, // unnormalizedCoords
};
- const Unique<VkSampler> sampler (createSampler(vkd, device, &samplerInfo));
+ const Unique<VkSampler> sampler (createSampler(vkd, device, &samplerInfo));
- const Unique<VkDescriptorSetLayout> descLayout (createDescriptorSetLayout(vkd, device, *sampler));
- const Unique<VkDescriptorPool> descPool (createDescriptorPool(vkd, device));
- const Unique<VkDescriptorSet> descSet (createDescriptorSet(vkd, device, *descPool, *descLayout, *imageView, *sampler));
+ const Unique<VkDescriptorSetLayout> descLayout (createDescriptorSetLayout(vkd, device, *sampler));
+ const Unique<VkDescriptorPool> descPool (createDescriptorPool(vkd, device));
+ const Unique<VkDescriptorSet> descSet (createDescriptorSet(vkd, device, *descPool, *descLayout, *imageView, *sampler));
- MultiPlaneImageData imageData (format, size);
+ MultiPlaneImageData imageData (format, size);
// Prepare texture data
fillGradient(&imageData, Vec4(0.0f), Vec4(1.0f));
const DeviceInterface& vkd = context.getDeviceInterface();
const VkDevice device = context.getDevice();
- const VkSamplerYcbcrConversionCreateInfo conversionInfo =
+ const VkSamplerYcbcrConversionCreateInfo conversionInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
DE_NULL,
VK_FALSE, // forceExplicitReconstruction
};
const Unique<VkSamplerYcbcrConversion> conversion (isYCbCrImage
- ? createSamplerYcbcrConversion(vkd, device, &conversionInfo)
- : Move<VkSamplerYcbcrConversion>());
+ ? createSamplerYcbcrConversion(vkd, device, &conversionInfo)
+ : Move<VkSamplerYcbcrConversion>());
const VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
*conversion,
};
- const VkSamplerCreateInfo samplerInfo =
+ const VkSamplerCreateInfo samplerInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
isYCbCrImage ? &samplerConversionInfo : DE_NULL,
if (params.query == QUERY_TYPE_IMAGE_SIZE_LOD)
{
- const PlanarFormatDescription& formatDesc = getPlanarFormatDescription(params.format);
- const UVec2 maxDivisor = getMaxPlaneDivisor(formatDesc);
- vector<UVec2> testSizes;
+ const PlanarFormatDescription& formatDesc = getPlanarFormatDescription(params.format);
+ const UVec2 maxDivisor = getMaxPlaneDivisor(formatDesc);
+ vector<UVec2> testSizes;
testSizes.push_back(maxDivisor);
testSizes.push_back(maxDivisor * UVec2(2u, 1u));
*conversion,
};
- const VkSamplerCreateInfo samplerInfo =
+ const VkSamplerCreateInfo samplerInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
isYCbCrImage ? &samplerConversionInfo : DE_NULL,
VkImage image,
VkFormat format,
VkImageAspectFlagBits imageAspect,
- VkSamplerYcbcrConversion conversion)
+ VkSamplerYcbcrConversion conversion)
{
const VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
projects / platform / upstream / VK-GL-CTS.git / commitdiff