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,
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,
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)
{
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))
{
}
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
}
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
}
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
}
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)
{
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
false,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams)),
DynamicBuffersInstance(context, m_testParams), UniformBufferInstance(context, testCaseParams)
{
VK_DESCRIPTOR_TYPE_UNDEFINED,
BINDING_Undefined,
true,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
}
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;
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
BINDING_SampledImage,
true,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
}
VK_DESCRIPTOR_TYPE_SAMPLER,
BINDING_Sampler,
true,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
{
}
VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
(BINDING_StorageImage + 1),
true,
- performWritesInVertex(testCaseParams.descriptorType),
+ performWritesInVertex(testCaseParams.descriptorType, context),
testCaseParams))
, m_buffer ()
, m_fillColor (10)
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,