CommonDescriptorInstance (Context& context,
const TestParams& testParams);
- void checkIndexingAvailable (const ut::DeviceProperties& devProps) const;
-
deUint32 computeAvailableDescriptorCount (VkDescriptorType descriptorType) const;
Move<VkDescriptorSetLayout> createDescriptorSetLayout (deUint32& descriptorCount) const;
static bool performWritesInVertex (VkDescriptorType descriptorType);
+ static bool performWritesInVertex (VkDescriptorType descriptorType,
+ const Context& context);
static std::string getShaderSource (VkShaderStageFlagBits shaderType,
const TestCaseParams& testCaseParams,
bool allowVertexStoring);
const IterateCommonVariables& variables,
bool fromTest);
+ void iterateCommandSetup (IterateCommonVariables& variables);
- void iterateCommandBegin (IterateCommonVariables& variables);
+ void iterateCommandBegin (IterateCommonVariables& variables,
+ bool firstPass = true);
- bool iterateCommandEnd (IterateCommonVariables& variables,
+ void iterateCommandEnd (IterateCommonVariables& variables,
+ ut::UpdatablePixelBufferAccessPtr& programResult,
+ ut::UpdatablePixelBufferAccessPtr& referenceResult,
bool collectBeforeSubmit = true);
+ bool iterateVerifyResults (IterateCommonVariables& variables,
+ ut::UpdatablePixelBufferAccessPtr programResult,
+ ut::UpdatablePixelBufferAccessPtr referenceResult);
+
Move<VkCommandBuffer> createCmdBuffer (void);
void commandBindPipeline (VkCommandBuffer commandBuffer,
{
}
-void CommonDescriptorInstance::checkIndexingAvailable (const ut::DeviceProperties& devProps) const
-{
- DE_UNREF(devProps);
- m_context.requireDeviceExtension("VK_EXT_descriptor_indexing");
-}
-
deUint32 CommonDescriptorInstance::computeAvailableDescriptorCount (VkDescriptorType descriptorType) const
{
DE_UNREF(descriptorType);
int CommonDescriptorInstance::constructShaderModules (void)
{
int result = 0;
- ut::DeviceProperties dp (m_context);
- const VkPhysicalDeviceFeatures& feats = dp.physicalDeviceFeatures();
tcu::TestLog& log = m_context.getTestContext().getLog();
if (m_testParams.stageFlags & VK_SHADER_STAGE_COMPUTE_BIT)
if (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT)
{
++result;
- const std::string name = ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, (feats.vertexPipelineStoresAndAtomics != DE_FALSE && m_testParams.allowVertexStoring));
+ const std::string name = ut::buildShaderName(VK_SHADER_STAGE_FRAGMENT_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, m_testParams.allowVertexStoring);
m_fragmentModule = vk::createShaderModule(m_vki, m_vkd, m_context.getBinaryCollection().get(name), (VkShaderModuleCreateFlags)0);
log << tcu::TestLog::Message << "Finally used fragment shader: " << name << '\n' << tcu::TestLog::EndMessage;
}
if (m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT)
{
++result;
- const std::string name = ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, (feats.vertexPipelineStoresAndAtomics != DE_FALSE && m_testParams.allowVertexStoring));
+ const std::string name = ut::buildShaderName(VK_SHADER_STAGE_VERTEX_BIT, m_testParams.descriptorType, m_testParams.updateAfterBind, m_testParams.calculateInLoop, m_testParams.allowVertexStoring);
m_vertexModule = vk::createShaderModule(m_vki, m_vkd, m_context.getBinaryCollection().get(name), (VkShaderModuleCreateFlags)0);
log << tcu::TestLog::Message << "Finally used vertex shader: " << name << '\n' << tcu::TestLog::EndMessage;
}
DE_UNREF(variables);
if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
{
- return vk::makeRenderPass(m_vki, m_vkd, m_colorFormat);
+ // Use VK_ATTACHMENT_LOAD_OP_LOAD to make the utility function select initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
+ return vk::makeRenderPass(m_vki, m_vkd, m_colorFormat, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD);
}
return Move<VkRenderPass>();
}
attributeDescriptions // pVertexAttributeDescriptions
};
+ const VkDynamicState dynamicStates[] =
+ {
+ VK_DYNAMIC_STATE_SCISSOR
+ };
+
+ const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // sType
+ DE_NULL, // pNext
+ 0u, // flags
+ DE_LENGTH_OF_ARRAY(dynamicStates), // dynamicStateCount
+ dynamicStates // pDynamicStates
+ };
+
const std::vector<VkViewport> viewports (1, makeViewport(m_testParams.frameResolution.width, m_testParams.frameResolution.height));
- const std::vector<VkRect2D> scissors (1, makeRect2D(m_testParams.frameResolution.width, m_testParams.frameResolution.height));
+ const std::vector<VkRect2D> scissors (1, makeRect2D(0u, 0u));
DE_ASSERT(m_vertexModule && m_fragmentModule);
VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // topology
0U, // subpass
0U, // patchControlPoints
- &vertexInputStateCreateInfo); // vertexInputStateCreateInfo
+ &vertexInputStateCreateInfo, // vertexInputStateCreateInfo
+ nullptr, // rasterizationStateCreateInfo
+ nullptr, // multisampleStateCreateInfo
+ nullptr, // depthStencilStateCreateInfo
+ nullptr, // colorBlendStateCreateInfo
+ &dynamicStateCreateInfo); // dynamicStateCreateInfo
}
VkDeviceSize CommonDescriptorInstance::createBuffers (std::vector<VkDescriptorBufferInfo>& bufferInfos,
*(variables.descriptorsImages[infoIdx]->image), // image
variables.descriptorsImages[infoIdx]->extent, // imageExtent
variables.descriptorsImages[infoIdx]->format, // imageFormat
- variables.descriptorsImages[infoIdx]->layout, // oldImageLayout
+ VK_IMAGE_LAYOUT_UNDEFINED, // oldImageLayout
VK_IMAGE_LAYOUT_GENERAL, // newImageLayout
variables.descriptorsImages[infoIdx]->levels); // mipLevelCount
-
- variables.descriptorsImages[infoIdx]->layout = VK_IMAGE_LAYOUT_GENERAL;
}
}
*(variables.descriptorsImages[infoIdx]->image), // image
variables.descriptorsImages[infoIdx]->extent, // imageExtent
variables.descriptorsImages[infoIdx]->format, // imageFormat
- variables.descriptorsImages[infoIdx]->layout, // oldImageLayout
+ VK_IMAGE_LAYOUT_GENERAL, // oldImageLayout
VK_IMAGE_LAYOUT_GENERAL, // newImageLayout
variables.descriptorsBufferInfos[infoIdx]); // bufferInfo
}
return tcu::PixelBufferAccess(vk::mapVkFormat(imageFormat), (imageExtent.width >> mipLevel), (imageExtent.height >> mipLevel), imageExtent.depth, data);
}
-
void CommonDescriptorInstance::updateDescriptors (IterateCommonVariables& variables)
{
const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
const VkDescriptorImageInfo* pImageInfo = DE_NULL;
const VkBufferView* pTexelBufferView = DE_NULL;
-
VkDescriptorImageInfo imageInfo =
{
static_cast<VkSampler>(0),
}
}
-void CommonDescriptorInstance::iterateCommandBegin (IterateCommonVariables& variables)
+void CommonDescriptorInstance::iterateCommandSetup (IterateCommonVariables& variables)
{
variables.dataAlignment = 0;
updateDescriptors (variables);
}
+}
+
+void CommonDescriptorInstance::iterateCommandBegin (IterateCommonVariables& variables, bool firstPass)
+{
vk::beginCommandBuffer (m_vki, *variables.commandBuffer);
+ // Clear color attachment, and transition it to VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
+ if ((m_testParams.stageFlags & VK_SHADER_STAGE_VERTEX_BIT) || (m_testParams.stageFlags & VK_SHADER_STAGE_FRAGMENT_BIT))
+ {
+ if (firstPass)
+ {
+ const VkImageMemoryBarrier preImageBarrier =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ 0u, // VkAccessFlags srcAccessMask
+ VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout
+ VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
+ VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
+ *variables.frameBuffer->image->image, // VkImage image
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
+ 0u, // uint32_t baseMipLevel
+ VK_REMAINING_MIP_LEVELS, // uint32_t mipLevels,
+ 0u, // uint32_t baseArray
+ VK_REMAINING_ARRAY_LAYERS, // uint32_t arraySize
+ }
+ };
+
+ m_vki.cmdPipelineBarrier(*variables.commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+ (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ 1, &preImageBarrier);
+
+ const VkClearColorValue clearColorValue = makeClearValueColor(m_clearColor).color;
+
+ m_vki.cmdClearColorImage(*variables.commandBuffer, *variables.frameBuffer->image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColorValue, 1, &preImageBarrier.subresourceRange);
+
+ const VkImageMemoryBarrier postImageBarrier =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout
+ VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
+ VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
+ *variables.frameBuffer->image->image, // VkImage image
+ {
+ VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
+ 0u, // uint32_t baseMipLevel
+ VK_REMAINING_MIP_LEVELS, // uint32_t mipLevels,
+ 0u, // uint32_t baseArray
+ VK_REMAINING_ARRAY_LAYERS, // uint32_t arraySize
+ }
+ };
+
+ m_vki.cmdPipelineBarrier(*variables.commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+ (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ 1, &postImageBarrier);
+
+ }
+ }
+
if (m_testParams.calculateInLoop)
{
deRandom rnd;
tcu::TestStatus CommonDescriptorInstance::iterate (void)
{
IterateCommonVariables v;
- iterateCommandBegin (v);
+ ut::UpdatablePixelBufferAccessPtr programResult;
+ ut::UpdatablePixelBufferAccessPtr referenceResult;
- if (true == m_testParams.copyBuffersToImages)
- {
- copyBuffersToImages (v);
- }
+ bool firstPass = true;
- if (true == m_testParams.updateAfterBind)
- {
- updateDescriptors (v);
- }
+ iterateCommandSetup (v);
+
+ v.renderArea.extent.width = m_testParams.frameResolution.width/4;
+ v.renderArea.extent.height = m_testParams.frameResolution.height/4;
+
+ for (int x = 0; x < 4; x++)
+ for (int y= 0; y < 4; y++)
+ {
+ iterateCommandBegin (v, firstPass);
+
+ if (true == firstPass && true == m_testParams.copyBuffersToImages)
+ {
+ copyBuffersToImages (v);
+ }
+
+ firstPass = false;
+
+ if (true == m_testParams.updateAfterBind)
+ {
+ updateDescriptors (v);
+ }
+
+ v.renderArea.offset.x = x * m_testParams.frameResolution.width/4;
+ v.renderArea.offset.y = y * m_testParams.frameResolution.height/4;
- vk::beginRenderPass (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
- m_vki.cmdDraw (*v.commandBuffer, v.vertexCount, 1u, 0u, 0u);
- vk::endRenderPass (m_vki, *v.commandBuffer);
+ vk::VkRect2D scissor = makeRect2D(v.renderArea.offset.x, v.renderArea.offset.y, v.renderArea.extent.width, v.renderArea.extent.height);
+ m_vki.cmdSetScissor(*v.commandBuffer, 0u, 1u, &scissor);
- return (iterateCommandEnd(v) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
+ vk::beginRenderPass (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
+ m_vki.cmdDraw (*v.commandBuffer, v.vertexCount, 1u, 0u, 0u);
+ vk::endRenderPass (m_vki, *v.commandBuffer);
+
+ iterateCommandEnd(v, programResult, referenceResult);
+ }
+
+ return ( iterateVerifyResults(v, programResult, referenceResult) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
}
std::vector<float> CommonDescriptorInstance::createColorScheme (void)
return cs;
}
-bool CommonDescriptorInstance::iterateCommandEnd (IterateCommonVariables& variables,
+void CommonDescriptorInstance::iterateCommandEnd (IterateCommonVariables& variables,
+ ut::UpdatablePixelBufferAccessPtr& programResult,
+ ut::UpdatablePixelBufferAccessPtr& referenceResult,
bool collectBeforeSubmit)
{
- ut::UpdatablePixelBufferAccessPtr programResult;
- ut::UpdatablePixelBufferAccessPtr referenceResult;
-
if (collectBeforeSubmit)
{
iterateCollectResults(programResult, variables, true);
iterateCollectResults(programResult, variables, true);
iterateCollectResults(referenceResult, variables, false);
}
+}
+bool CommonDescriptorInstance::iterateVerifyResults (IterateCommonVariables& variables,
+ ut::UpdatablePixelBufferAccessPtr programResult,
+ ut::UpdatablePixelBufferAccessPtr referenceResult)
+{
bool result = false;
if (m_testParams.fuzzyComparison)
{
0u, // baseMipLevel
1u, // levelCount
0u, // baseArrayLayer
- 1u, // layerCount
+ 1u // layerCount
};
- const VkImageMemoryBarrier imageBarrier =
+ const VkImageMemoryBarrier barrierBefore =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType;
DE_NULL, // pNext;
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // srcAccessMask;
VK_ACCESS_TRANSFER_READ_BIT, // dstAccessMask;
- VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // oldLayout
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // newLayout;
VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex;
image, // image;
- subresourceRange, // subresourceRange;
+ subresourceRange // subresourceRange;
};
const VkBufferImageCopy copyRegion =
bufferSize // size;
};
+ const VkImageMemoryBarrier barrierAfter =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType;
+ DE_NULL, // pNext;
+ VK_ACCESS_TRANSFER_READ_BIT, // srcAccessMask;
+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // dstAccessMask;
+ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // oldLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout;
+ VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex;
+ image, // image
+ subresourceRange // subresourceRange
+ };
+
+
m_vki.cmdPipelineBarrier(commandBuffer, // commandBuffer
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, // srcStageMask, dstStageMask
(VkDependencyFlags)0, // dependencyFlags
- 0u, (const VkMemoryBarrier*)DE_NULL, // memoryBarrierCount, pMemoryBarriers
- 0u, (const VkBufferMemoryBarrier*)DE_NULL, // bufferBarrierCount, pBufferBarriers
- 1u, &imageBarrier); // imageBarrierCount, pImageBarriers
+ 0u, DE_NULL, // memoryBarrierCount, pMemoryBarriers
+ 0u, DE_NULL, // bufferBarrierCount, pBufferBarriers
+ 1u, &barrierBefore); // imageBarrierCount, pImageBarriers
m_vki.cmdCopyImageToBuffer(commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1u, ©Region);
m_vki.cmdPipelineBarrier(commandBuffer,
- VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
+ VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT | VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
(VkDependencyFlags)0,
- 0, DE_NULL,
- 1, &bufferBarrier,
- 0u, DE_NULL);
+ 0u, DE_NULL,
+ 1u, &bufferBarrier,
+ 1u, &barrierAfter);
content = ut::BufferHandleAllocSp(new ut::BufferHandleAlloc(buffer, allocation));
}
return result;
}
+bool CommonDescriptorInstance::performWritesInVertex (VkDescriptorType descriptorType,
+ const Context& context)
+{
+ bool result = false;
+
+ ut::DeviceProperties dp (context);
+ const VkPhysicalDeviceFeatures& feats = dp.physicalDeviceFeatures();
+
+ if (feats.vertexPipelineStoresAndAtomics != DE_FALSE)
+ {
+ result = CommonDescriptorInstance::performWritesInVertex(descriptorType);
+ }
+
+ return result;
+}
+
std::string CommonDescriptorInstance::getShaderSource (VkShaderStageFlagBits shaderType,
const TestCaseParams& testCaseParams,
bool allowVertexStoring)
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const vk::VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
-
- if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer descriptor arrays is not supported.");
-
- if (m_testParams.updateAfterBind)
- {
- if (!(feats.descriptorBindingStorageBufferUpdateAfterBind))
- TCU_THROW(NotSupportedError, "Update after bind for storage buffer descriptors is not supported.");
- }
}
void StorageBufferInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
-
- if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform buffer descriptor arrays is not supported.");
-
- if (m_testParams.updateAfterBind)
- {
- if (!(feats.descriptorBindingUniformBufferUpdateAfterBind))
- TCU_THROW(NotSupportedError, "Update after bind for uniform buffer descriptors is not supported.");
- }
}
void UniformBufferInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
-
- if (!(feats.shaderStorageTexelBufferArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing for storage texel buffer descriptor arrays is not supported.");
-
- if (m_testParams.updateAfterBind)
- {
- if (!(feats.descriptorBindingStorageTexelBufferUpdateAfterBind))
- TCU_THROW(NotSupportedError, "Update after bind for storage texel buffer descriptors is not supported.");
- }
}
void StorageTexelInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
-
- if (!(feats.shaderUniformTexelBufferArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform texel buffer descriptor arrays is not supported.");
-
- if (m_testParams.updateAfterBind)
- {
- if (!(feats.descriptorBindingUniformTexelBufferUpdateAfterBind))
- TCU_THROW(NotSupportedError, "Update after bind for uniform texel buffer descriptors is not supported.");
- }
}
void UniformTexelInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
tcu::TestStatus DynamicBuffersInstance::iterate (void)
{
IterateCommonVariables v;
- iterateCommandBegin (v);
+ iterateCommandSetup (v);
+
+ ut::UpdatablePixelBufferAccessPtr programResult;
+ ut::UpdatablePixelBufferAccessPtr referenceResult;
+ bool firstPass = true;
DE_ASSERT(v.dataAlignment);
const VkDescriptorSet descriptorSets[] = { *v.descriptorSet };
+ v.renderArea.extent.width = m_testParams.frameResolution.width/4;
+ v.renderArea.extent.height = m_testParams.frameResolution.height/4;
+
+ for (int x = 0; x < 4; x++)
+ for (int y= 0; y < 4; y++)
+ {
+
+ v.renderArea.offset.x = x * m_testParams.frameResolution.width/4;
+ v.renderArea.offset.y = y * m_testParams.frameResolution.height/4;
+
+ iterateCommandBegin (v, firstPass);
+ firstPass = false;
+
m_vki.cmdBindDescriptorSets(
*v.commandBuffer, // commandBuffer
VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
v.availableDescriptorCount, // dynamicOffsetCount
dynamicOffsets.data()); // pDynamicOffsets
+ vk::VkRect2D scissor = makeRect2D(v.renderArea.offset.x, v.renderArea.offset.y, v.renderArea.extent.width, v.renderArea.extent.height);
+ m_vki.cmdSetScissor(*v.commandBuffer, 0u, 1u, &scissor);
+
vk::beginRenderPass (m_vki, *v.commandBuffer, *v.renderPass, *v.frameBuffer->buffer, v.renderArea, m_clearColor);
- m_vki.cmdDraw (*v.commandBuffer, v.vertexCount, 1, 0, 0);
+ m_vki.cmdDraw (*v.commandBuffer, v.vertexCount, 1u, 0u, 0u);
vk::endRenderPass (m_vki, *v.commandBuffer);
- return (iterateCommandEnd(v) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
+ iterateCommandEnd(v, programResult, referenceResult);
+ }
+
+ return (iterateVerifyResults(v, programResult, referenceResult) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
}
class DynamicStorageBufferInstance : public DynamicBuffersInstance, public StorageBufferInstance
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams)),
DynamicBuffersInstance(context, m_testParams), StorageBufferInstance(context, testCaseParams)
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
-
- if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer dynamic descriptor arrays is not supported.");
-
- if (testCaseParams.updateAfterBind)
- {
- TCU_THROW(NotSupportedError, "Update after bind for storage buffer dynamic descriptors is not supported.");
- }
}
tcu::TestStatus DynamicStorageBufferInstance::iterate(void)
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams)),
DynamicBuffersInstance(context, m_testParams), UniformBufferInstance(context, testCaseParams)
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
-
- if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing over uniform buffer dynamic descriptor arrays is not supported.");
-
- if (testCaseParams.updateAfterBind)
- {
- TCU_THROW(NotSupportedError, "Update after bind for uniform buffer dynamic descriptors is not supported.");
- }
}
tcu::TestStatus DynamicUniformBufferInstance::iterate(void)
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
true,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
-
- if (!(feats.shaderInputAttachmentArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing over input attachment descriptor arrays is not supported.");
-
- if (testCaseParams.updateAfterBind)
- {
- TCU_THROW(NotSupportedError, "Update after bind for input attachment descriptors is not supported.");
- }
}
void InputAttachmentInstance::createAndPopulateDescriptors (IterateCommonVariables& variables)
{
createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
- (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT), m_testParams.frameResolution, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount);
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT, m_testParams.frameResolution, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount);
createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
for (deUint32 descriptorIdx = 0; descriptorIdx < variables.validDescriptorCount; ++descriptorIdx)
const tcu::PixelBufferAccess pa = getPixelAccess(descriptorIdx, m_testParams.frameResolution, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer);
tcu::clear(pa, tcu::Vec4(component, component, component, 1.0f));
}
+ vk::flushAlloc(m_vki, m_vkd, *variables.descriptorsBuffer->alloc);
}
Move<VkRenderPass> InputAttachmentInstance::createRenderPass (const IterateCommonVariables& variables)
VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
- VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout;
};
const VkAttachmentReference colorAttachmentRef =
// build input atachments
{
+ const std::vector<deUint32> primes = ut::generatePrimes(variables.availableDescriptorCount);
const deUint32 inputCount = static_cast<deUint32>(variables.descriptorImageViews.size());
for (deUint32 inputIdx = 0; inputIdx < inputCount; ++inputIdx)
{
+ // primes holds the indices of input attachments for shader binding 10 which has input_attachment_index=1
+ deUint32 nextInputAttachmentIndex = primes[inputIdx] + 1;
+
+ // Fill up the subpass description's input attachments with unused attachments forming gaps to the next referenced attachment
+ for (deUint32 unusedIdx = static_cast<deUint32>(inputAttachmentRefs.size()); unusedIdx < nextInputAttachmentIndex; ++unusedIdx)
+ {
+ const VkAttachmentReference inputAttachmentRef =
+ {
+ VK_ATTACHMENT_UNUSED, // deUint32 attachment;
+ VK_IMAGE_LAYOUT_GENERAL // VkImageLayout layout;
+ };
+
+ inputAttachmentRefs.push_back(inputAttachmentRef);
+ }
+
const VkAttachmentDescription inputAttachmentDescription =
{
VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, // VkAttachmentDescriptionFlags flags;
variables.descriptorsImages[inputIdx]->format, // VkFormat format;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
- VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
+ VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
- variables.descriptorsImages[inputIdx]->layout, // VkImageLayout initialLayout;
- VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
+ VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout initialLayout;
+ VK_IMAGE_LAYOUT_GENERAL // VkImageLayout finalLayout;
};
const VkAttachmentReference inputAttachmentRef =
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
BINDING_SampledImage,
true,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
- // Note: common flags for SAMPLER, SAMPLED_IMAGE, COMBINED_IMAGE_SAMPLER
-
- if (!(feats.shaderSampledImageArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing over sampler descriptor arrays is not supported.");
-
- if (testCaseParams.updateAfterBind)
- {
- if (!(feats.descriptorBindingSampledImageUpdateAfterBind))
- TCU_THROW(NotSupportedError, "Update after bind for sampler descriptors is not supported.");
- }
}
void SamplerInstance::updateDescriptors (IterateCommonVariables& variables)
};
createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
- (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT), imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1, m_testParams.usesMipMaps);
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, 1, m_testParams.usesMipMaps);
createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
PixelBufferAccess pa = getPixelAccess(0, imageExtent, m_colorFormat, variables.descriptorsBufferInfos, variables.descriptorsBuffer, m_testParams.usesMipMaps ? 1 : 0);
VK_DESCRIPTOR_TYPE_SAMPLER,
BINDING_Sampler,
true,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
- // Note: common flags for SAMPLER, SAMPLED_IMAGE, COMBINED_IMAGE_SAMPLER
-
- if (!(feats.shaderSampledImageArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing over sampled image descriptor arrays is not supported.");
-
- if (testCaseParams.updateAfterBind)
- {
- if (!(feats.descriptorBindingSampledImageUpdateAfterBind))
- TCU_THROW(NotSupportedError, "Update after bind for sampled image descriptors is not supported.");
- }
}
void SampledImageInstance::updateDescriptors (IterateCommonVariables& variables)
const VkExtent3D& imageExtent = m_testParams.usesMipMaps ? bigImageExtent : smallImageExtent;
createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer,
- (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT), imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT, imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
PixelBufferAccess pixelAccess;
performWritesInVertex(testCaseParams.descriptorType),
testCaseParams))
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = dp.descriptorIndexingFeatures();
- // Note: common flags for SAMPLER, SAMPLED_IMAGE, COMBINED_IMAGE_SAMPLER
-
- if (!(feats.shaderSampledImageArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing over combined image sampler descriptor arrays is not supported.");
-
- if (testCaseParams.updateAfterBind)
- {
- if (!(feats.descriptorBindingSampledImageUpdateAfterBind))
- TCU_THROW(NotSupportedError, "Update after bind for combined image sampler descriptors is not supported.");
- }
}
void CombinedImageInstance::updateDescriptors (IterateCommonVariables& variables)
variables.descriptorSamplers.push_back(ut::SamplerSp(new Move<VkSampler>(vk::createSampler(m_vki, m_vkd, &createInfo))));
const VkExtent3D& imageExtent = m_testParams.usesMipMaps ? bigImageExtent : smallImageExtent;
- createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer, (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT),
+ createImages(variables.descriptorsImages, variables.descriptorsBufferInfos, variables.descriptorsBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
imageExtent, m_colorFormat, VK_IMAGE_LAYOUT_UNDEFINED, variables.validDescriptorCount, m_testParams.usesMipMaps);
createImagesViews(variables.descriptorImageViews, variables.descriptorsImages, m_colorFormat);
VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
(BINDING_StorageImage + 1),
true,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
, m_buffer ()
, m_fillColor (10)
{
- ut::DeviceProperties dp(context);
-
- checkIndexingAvailable(dp);
-
- const VkPhysicalDeviceDescriptorIndexingFeaturesEXT& features = dp.descriptorIndexingFeatures();
-
- if (!(features.shaderStorageImageArrayNonUniformIndexing))
- TCU_THROW(NotSupportedError, "Non-uniform indexing over storage image descriptor arrays is not supported.");
-
- if (testCaseParams.updateAfterBind)
- {
- if (!(features.descriptorBindingStorageImageUpdateAfterBind))
- TCU_THROW(NotSupportedError, "Update after bind for storage image descriptors is not supported.");
- }
}
void StorageImageInstance::updateDescriptors (IterateCommonVariables& variables)
tcu::TestStatus StorageImageInstance::iterate (void)
{
IterateCommonVariables v;
+ iterateCommandSetup (v);
iterateCommandBegin (v);
+ ut::UpdatablePixelBufferAccessPtr programResult;
+ ut::UpdatablePixelBufferAccessPtr referenceResult;
+
if (m_testParams.updateAfterBind)
{
updateDescriptors (v);
copyImagesToBuffers (v);
- return (iterateCommandEnd(v, false) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
+ iterateCommandEnd(v, programResult, referenceResult, false);
+
+ return ( iterateVerifyResults(v, programResult, referenceResult) ? tcu::TestStatus::pass : tcu::TestStatus::fail)("");
}
void StorageImageInstance::iterateCollectResults (ut::UpdatablePixelBufferAccessPtr& result,
{
const TestCaseParams m_testCaseParams;
public:
- DescriptorIndexingTestCase(tcu::TestContext &context, const char *name, const char *description, const TestCaseParams& testCaseParams)
+ DescriptorIndexingTestCase (tcu::TestContext &context, const char *name, const char *description, const TestCaseParams& testCaseParams)
: TestCase(context, name, description)
, m_testCaseParams(testCaseParams)
{
}
- vkt::TestInstance* createInstance(vkt::Context& context) const // override
+ vkt::TestInstance* createInstance (vkt::Context& context) const // override
{
switch (m_testCaseParams.descriptorType)
{
return DE_NULL;
}
- virtual void initPrograms(SourceCollections& programCollection) const
+ virtual void checkSupport (vkt::Context& context) const
+ {
+ context.requireDeviceExtension("VK_EXT_descriptor_indexing");
+
+ const vk::VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = context.getDescriptorIndexingFeatures();
+
+ switch (m_testCaseParams.descriptorType)
+ {
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+ if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageBufferUpdateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for storage buffer descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform buffer descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingUniformBufferUpdateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for uniform buffer descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+ if (!(feats.shaderStorageTexelBufferArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing for storage texel buffer descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageTexelBufferUpdateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for storage texel buffer descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ if (!(feats.shaderUniformTexelBufferArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing for uniform texel buffer descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingUniformTexelBufferUpdateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for uniform texel buffer descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+ if (!(feats.shaderStorageBufferArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing over storage buffer dynamic descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for storage buffer dynamic descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ if (!(feats.shaderUniformBufferArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing over uniform buffer dynamic descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for uniform buffer dynamic descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+ if (!(feats.shaderInputAttachmentArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing over input attachment descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for input attachment descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_SAMPLER:
+ if (!(feats.shaderSampledImageArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing over sampler descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for sampler descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+ if (!(feats.shaderSampledImageArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing over sampled image descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for sampled image descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+ if (!(feats.shaderSampledImageArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing over combined image sampler descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingSampledImageUpdateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for combined image sampler descriptors is not supported.");
+ break;
+ case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+ if (!(feats.shaderStorageImageArrayNonUniformIndexing))
+ TCU_THROW(NotSupportedError, "Non-uniform indexing over storage image descriptor arrays is not supported.");
+
+ if (m_testCaseParams.updateAfterBind && !feats.descriptorBindingStorageImageUpdateAfterBind)
+ TCU_THROW(NotSupportedError, "Update after bind for storage image descriptors is not supported.");
+ break;
+ default:
+ DE_FATAL("Unknown Descriptor Type");
+ break;
+ }
+ }
+
+ virtual void initPrograms (SourceCollections& programCollection) const
{
std::string(*genShaderSource)(VkShaderStageFlagBits, const TestCaseParams&, bool) = &CommonDescriptorInstance::getShaderSource;
projects / platform / upstream / VK-GL-CTS.git / blobdiff