namespace QueryPool
{
-Buffer::Buffer (const vk::DeviceInterface &vk, vk::VkDevice device, vk::Move<vk::VkBuffer> object)
+Buffer::Buffer (const vk::DeviceInterface& vk, vk::VkDevice device, vk::Move<vk::VkBuffer> object)
: m_object (object)
, m_allocation (DE_NULL)
, m_vk (vk)
m_allocation = allocation;
}
-de::SharedPtr<Buffer> Buffer::createAndAlloc (const vk::DeviceInterface &vk,
+de::SharedPtr<Buffer> Buffer::createAndAlloc (const vk::DeviceInterface& vk,
vk::VkDevice device,
const vk::VkBufferCreateInfo &createInfo,
vk::Allocator &allocator,
return ret;
}
-de::SharedPtr<Buffer> Buffer::create (const vk::DeviceInterface &vk,
+de::SharedPtr<Buffer> Buffer::create (const vk::DeviceInterface& vk,
vk::VkDevice device,
- const vk::VkBufferCreateInfo &createInfo)
+ const vk::VkBufferCreateInfo& createInfo)
{
return de::SharedPtr<Buffer>(new Buffer(vk, device, vk::createBuffer(vk, device, &createInfo)));
}
-} //DynamicState
-} //vkt
+} // QueryPool
+} // vkt
-#ifndef _VKT_DYNAMIC_STATE_BUFFEROBJECTUTIL_HPP
-#define _VKT_DYNAMIC_STATE_BUFFEROBJECTUTIL_HPP
+#ifndef _VKTQUERYPOOLBUFFEROBJECTUTIL_HPP
+#define _VKTQUERYPOOLBUFFEROBJECTUTIL_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
* \brief Buffer Object Util
*//*--------------------------------------------------------------------*/
-#include "vkDefs.hpp"
#include "vkMemUtil.hpp"
#include "vkRefUtil.hpp"
Buffer (const vk::DeviceInterface &vk, vk::VkDevice device, vk::Move<vk::VkBuffer> object);
-
void bindMemory (de::MovePtr<vk::Allocation> allocation);
-
vk::VkBuffer object (void) const { return *m_object; }
vk::Allocation getBoundMemory (void) const { return *m_allocation; }
private:
Buffer (const Buffer& other); // Not allowed!
- Buffer &operator= (const Buffer& other); // Not allowed!
-
+ Buffer& operator= (const Buffer& other); // Not allowed!
de::MovePtr<vk::Allocation> m_allocation;
vk::Unique<vk::VkBuffer> m_object;
- const vk::DeviceInterface & m_vk;
- vk::VkDevice m_device;
+ const vk::DeviceInterface& m_vk;
+ vk::VkDevice m_device;
};
} //DynamicState
} //vkt
-#endif // _VKT_DYNAMIC_STATE_BUFFEROBJECTUTIL_HPP
+#endif // _VKTQUERYPOOLBUFFEROBJECTUTIL_HPP
range = _range;
}
-
BufferCreateInfo::BufferCreateInfo (vk::VkDeviceSize _size,
vk::VkBufferUsageFlags _usage,
vk::VkSharingMode _sharingMode,
deUint32 _queueFamilyIndexCount,
const deUint32* _pQueueFamilyIndices,
vk::VkBufferCreateFlags _flags)
-{
+{
sType = vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
pNext = DE_NULL;
size = _size;
else
{
pQueueFamilyIndices = _pQueueFamilyIndices;
- }
+ }
}
BufferCreateInfo::BufferCreateInfo (const BufferCreateInfo &other)
vk::VkImageUsageFlags _usage,
vk::VkSharingMode _sharingMode,
deUint32 _queueFamilyIndexCount,
- const deUint32* _pQueueFamilyIndices,
+ const deUint32* _pQueueFamilyIndices,
vk::VkImageCreateFlags _flags,
vk::VkImageLayout _initialLayout)
{
}
FramebufferCreateInfo::FramebufferCreateInfo (vk::VkRenderPass _renderPass,
- const std::vector<vk::VkImageView>& atachments,
+ const std::vector<vk::VkImageView>& atachments,
deUint32 _width,
deUint32 _height,
deUint32 _layers)
{
sType = vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
pNext = DE_NULL;
- flags = 0;
+ flags = 0;
attachmentCount = static_cast<deUint32>(m_attachments.size());
pAttachments = &m_attachmentsStructs[0];
attachmentCount = static_cast<deUint32>(m_attachments.size());
- if (attachmentCount) {
+ if (attachmentCount)
+ {
pAttachments = &m_attachmentsStructs[0];
}
else
subpassCount = static_cast<deUint32>(m_subpasses.size());
- if (subpassCount) {
+ if (subpassCount)
+ {
pSubpasses = &m_subpassesStructs[0];
}
else
dependencyCount = static_cast<deUint32>(m_dependiences.size());
- if (dependencyCount) {
+ if (dependencyCount)
+ {
pDependencies = &m_dependiencesStructs[0];
}
else
RenderPassBeginInfo::RenderPassBeginInfo (vk::VkRenderPass _renderPass,
vk::VkFramebuffer _framebuffer,
vk::VkRect2D _renderArea,
- const std::vector<vk::VkClearValue>& _clearValues)
+ const std::vector<vk::VkClearValue>& _clearValues)
{
m_clearValues = _clearValues;
finalLayout = _finalLayout;
}
-AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription &rhs)
+AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription& rhs)
{
flags = rhs.flags;
format = rhs.format;
pPreserveAttachments = DE_NULL;
preserveAttachmentCount = _preserveAttachmentCount;
- if (m_inputAttachments.size()) {
+ if (m_inputAttachments.size())
+ {
pInputAttachments = &m_inputAttachments[0];
}
- if (m_colorAttachments.size()) {
+ if (m_colorAttachments.size())
+ {
pColorAttachments = &m_colorAttachments[0];
}
- if (m_resolveAttachments.size()) {
+ if (m_resolveAttachments.size())
+ {
pResolveAttachments = &m_resolveAttachments[0];
}
- if (m_preserveAttachments.size()) {
+ if (m_preserveAttachments.size())
+ {
pPreserveAttachments = &m_preserveAttachments[0];
}
}
m_colorAttachments = std::vector<vk::VkAttachmentReference>(
rhs.pColorAttachments, rhs.pColorAttachments + rhs.colorAttachmentCount);
- if (rhs.pResolveAttachments) {
+ if (rhs.pResolveAttachments)
+ {
m_resolveAttachments = std::vector<vk::VkAttachmentReference>(
rhs.pResolveAttachments, rhs.pResolveAttachments + rhs.colorAttachmentCount);
}
m_depthStencilAttachment = *rhs.pDepthStencilAttachment;
}
- if (m_inputAttachments.size()) {
+ if (m_inputAttachments.size())
+ {
pInputAttachments = &m_inputAttachments[0];
}
- if (m_colorAttachments.size()) {
+ if (m_colorAttachments.size())
+ {
pColorAttachments = &m_colorAttachments[0];
}
- if (m_resolveAttachments.size()) {
+ if (m_resolveAttachments.size())
+ {
pResolveAttachments = &m_resolveAttachments[0];
}
pDepthStencilAttachment = &m_depthStencilAttachment;
- if (m_preserveAttachments.size()) {
+ if (m_preserveAttachments.size())
+ {
pPreserveAttachments = &m_preserveAttachments[0];
}
}
-SubpassDescription::SubpassDescription (const SubpassDescription& rhs) {
+SubpassDescription::SubpassDescription (const SubpassDescription& rhs)
+{
*this = rhs;
}
m_preserveAttachments = rhs.m_preserveAttachments;
m_depthStencilAttachment = rhs.m_depthStencilAttachment;
- if (m_inputAttachments.size()) {
+ if (m_inputAttachments.size())
+ {
pInputAttachments = &m_inputAttachments[0];
}
- if (m_colorAttachments.size()) {
+ if (m_colorAttachments.size())
+ {
pColorAttachments = &m_colorAttachments[0];
}
- if (m_resolveAttachments.size()) {
+ if (m_resolveAttachments.size())
+ {
pResolveAttachments = &m_resolveAttachments[0];
}
pDepthStencilAttachment = &m_depthStencilAttachment;
- if (m_preserveAttachments.size()) {
+ if (m_preserveAttachments.size())
+ {
pPreserveAttachments = &m_preserveAttachments[0];
}
dependencyFlags = _dependencyFlags;
}
-SubpassDependency::SubpassDependency (const vk::VkSubpassDependency &rhs)
+SubpassDependency::SubpassDependency (const vk::VkSubpassDependency& rhs)
{
srcSubpass = rhs.srcSubpass;
dstSubpass = rhs.dstSubpass;
pBinding = _pBindings;
}
-
PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32 _descriptorSetCount,
const vk::VkDescriptorSetLayout* _pSetLayouts,
deUint32 _pushConstantRangeCount,
pSetLayouts = setLayoutCount > 0 ? &m_setLayouts[0] : DE_NULL;
pushConstantRangeCount = static_cast<deUint32>(m_pushConstantRanges.size());
- if (m_pushConstantRanges.size()) {
+ if (m_pushConstantRanges.size())
+ {
pPushConstantRanges = &m_pushConstantRanges[0];
}
else
}
pushConstantRangeCount = static_cast<deUint32>(m_pushConstantRanges.size());
- if (pushConstantRangeCount) {
+ if (pushConstantRangeCount)
+ {
pPushConstantRanges = &m_pushConstantRanges[0];
}
else
}
}
-
PipelineCreateInfo::PipelineShaderStage::PipelineShaderStage (vk::VkShaderModule _module, const char* _pName, vk::VkShaderStageFlagBits _stage)
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
flags = 0u;
viewportCount = _viewportCount;
scissorCount = _viewportCount;
-
+
if (!_viewports.size())
{
m_viewports.resize(viewportCount);
pScissors = &m_scissors[0];
}
-PipelineCreateInfo::ViewportState::ViewportState (const ViewportState &other)
+PipelineCreateInfo::ViewportState::ViewportState (const ViewportState& other)
{
sType = other.sType;
pNext = other.pNext;
pScissors = &m_scissors[0];
}
-PipelineCreateInfo::ViewportState & PipelineCreateInfo::ViewportState::operator= (const ViewportState &other)
+PipelineCreateInfo::ViewportState& PipelineCreateInfo::ViewportState::operator= (const ViewportState& other)
{
sType = other.sType;
pNext = other.pNext;
vk::VkBool32 _sampleShadingEnable,
float _minSampleShading,
const std::vector<vk::VkSampleMask>& _sampleMask,
- bool _alphaToCoverageEnable,
+ bool _alphaToCoverageEnable,
bool _alphaToOneEnable)
: m_sampleMask(_sampleMask)
{
alphaToOneEnable = _alphaToOneEnable;
}
-PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState &other)
+PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState& other)
{
sType = other.sType;
pNext = other.pNext;
rasterizationSamples = other.rasterizationSamples;
sampleShadingEnable = other.sampleShadingEnable;
minSampleShading = other.minSampleShading;
-
+
const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
m_sampleMask = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
pSampleMask = &m_sampleMask[0];
}
-PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState & other)
+PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState& other)
{
sType = other.sType;
pNext = other.pNext;
: m_attachments(_attachments)
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
- pNext = DE_NULL;
+ pNext = DE_NULL;
flags = 0u;
logicOpEnable = _logicOpEnable;
logicOp = _logicOp;
}
PipelineCreateInfo::ColorBlendState::ColorBlendState (deUint32 _attachmentCount,
- const vk::VkPipelineColorBlendAttachmentState* _attachments,
+ const vk::VkPipelineColorBlendAttachmentState* _attachments,
vk::VkBool32 _logicOpEnable,
vk::VkLogicOp _logicOp)
: m_attachments(_attachments, _attachments + _attachmentCount)
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
- pNext = DE_NULL;
+ pNext = DE_NULL;
logicOpEnable = _logicOpEnable;
logicOp = _logicOp;
attachmentCount = static_cast<deUint32>(m_attachments.size());
pAttachments = &m_attachments[0];
}
-PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo &createInfo)
+PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo)
: m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
{
sType = createInfo.sType;
pAttachments = &m_attachments[0];
}
-PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState &createInfo, std::vector<float> _blendConstants)
+PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState& createInfo, std::vector<float> _blendConstants)
: m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
{
sType = createInfo.sType;
pDynamicStates = &m_dynamicStates[0];
}
-PipelineCreateInfo::DynamicState & PipelineCreateInfo::DynamicState::operator= (const DynamicState &other)
+PipelineCreateInfo::DynamicState& PipelineCreateInfo::DynamicState::operator= (const DynamicState& other)
{
sType = other.sType;
pNext = other.pNext;
pDynamicState = DE_NULL;
}
-PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo &shader)
+PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo& shader)
{
m_shaders.push_back(shader);
}
SamplerCreateInfo::SamplerCreateInfo (vk::VkFilter _magFilter,
- vk::VkFilter _minFilter,
- vk::VkSamplerMipmapMode _mipmapMode,
- vk::VkSamplerAddressMode _addressModeU,
- vk::VkSamplerAddressMode _addressModeV,
- vk::VkSamplerAddressMode _addressModeW,
- float _mipLodBias,
- float _maxAnisotropy,
- vk::VkBool32 _compareEnable,
- vk::VkCompareOp _compareOp,
- float _minLod,
- float _maxLod,
- vk::VkBorderColor _borderColor,
- vk::VkBool32 _unnormalizedCoordinates)
+ vk::VkFilter _minFilter,
+ vk::VkSamplerMipmapMode _mipmapMode,
+ vk::VkSamplerAddressMode _addressModeU,
+ vk::VkSamplerAddressMode _addressModeV,
+ vk::VkSamplerAddressMode _addressModeW,
+ float _mipLodBias,
+ float _maxAnisotropy,
+ vk::VkBool32 _compareEnable,
+ vk::VkCompareOp _compareOp,
+ float _minLod,
+ float _maxLod,
+ vk::VkBorderColor _borderColor,
+ vk::VkBool32 _unnormalizedCoordinates)
{
sType = vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
pNext = DE_NULL;
-#ifndef _VKT_DYNAMIC_STATE_CREATEINFO_UTIL_HPP
-#define _VKT_DYNAMIC_STATE_CREATEINFO_UTIL_HPP
+#ifndef _VKTQUERYPOOLCREATEINFOUTIL_HPP
+#define _VKTQUERYPOOLCREATEINFOUTIL_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
#include "vkDefs.hpp"
#include "tcuVector.hpp"
-
#include "deSharedPtr.hpp"
-
#include <vector>
namespace vkt
class ImageSubresourceRange : public vk::VkImageSubresourceRange
{
public:
- ImageSubresourceRange ( vk::VkImageAspectFlags aspectMask,
- deUint32 baseMipLevel = 0,
- deUint32 levelCount = 1,
- deUint32 baseArrayLayer = 0,
- deUint32 layerCount = 1);
+ ImageSubresourceRange (vk::VkImageAspectFlags aspectMask,
+ deUint32 baseMipLevel = 0,
+ deUint32 levelCount = 1,
+ deUint32 baseArrayLayer = 0,
+ deUint32 layerCount = 1);
};
class ComponentMapping : public vk::VkComponentMapping
{
public:
- ComponentMapping ( vk::VkComponentSwizzle r = vk::VK_COMPONENT_SWIZZLE_R,
- vk::VkComponentSwizzle g = vk::VK_COMPONENT_SWIZZLE_G,
- vk::VkComponentSwizzle b = vk::VK_COMPONENT_SWIZZLE_B,
- vk::VkComponentSwizzle a = vk::VK_COMPONENT_SWIZZLE_A);
+ ComponentMapping (vk::VkComponentSwizzle r = vk::VK_COMPONENT_SWIZZLE_R,
+ vk::VkComponentSwizzle g = vk::VK_COMPONENT_SWIZZLE_G,
+ vk::VkComponentSwizzle b = vk::VK_COMPONENT_SWIZZLE_B,
+ vk::VkComponentSwizzle a = vk::VK_COMPONENT_SWIZZLE_A);
};
class ImageViewCreateInfo : public vk::VkImageViewCreateInfo
{
public:
- ImageViewCreateInfo ( vk::VkImage image,
- vk::VkImageViewType viewType,
- vk::VkFormat format,
- const vk::VkImageSubresourceRange& subresourceRange,
- const vk::VkComponentMapping& components = ComponentMapping(),
- vk::VkImageViewCreateFlags flags = 0);
-
- ImageViewCreateInfo ( vk::VkImage image,
- vk::VkImageViewType viewType,
- vk::VkFormat format,
- const vk::VkComponentMapping& components = ComponentMapping(),
- vk::VkImageViewCreateFlags flags = 0);
+ ImageViewCreateInfo (vk::VkImage image,
+ vk::VkImageViewType viewType,
+ vk::VkFormat format,
+ const vk::VkImageSubresourceRange& subresourceRange,
+ const vk::VkComponentMapping& components = ComponentMapping(),
+ vk::VkImageViewCreateFlags flags = 0);
+
+ ImageViewCreateInfo (vk::VkImage image,
+ vk::VkImageViewType viewType,
+ vk::VkFormat format,
+ const vk::VkComponentMapping& components = ComponentMapping(),
+ vk::VkImageViewCreateFlags flags = 0);
};
class BufferViewCreateInfo : public vk::VkBufferViewCreateInfo
{
public:
- BufferViewCreateInfo ( vk::VkBuffer buffer,
- vk::VkFormat format,
- vk::VkDeviceSize offset,
- vk::VkDeviceSize range);
+ BufferViewCreateInfo (vk::VkBuffer buffer,
+ vk::VkFormat format,
+ vk::VkDeviceSize offset,
+ vk::VkDeviceSize range);
};
class BufferCreateInfo : public vk::VkBufferCreateInfo
{
public:
- BufferCreateInfo ( vk::VkDeviceSize size,
- vk::VkBufferCreateFlags usage,
- vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE,
- deUint32 queueFamilyIndexCount = 0,
- const deUint32* pQueueFamilyIndices = DE_NULL,
- vk::VkBufferCreateFlags flags = 0);
+ BufferCreateInfo (vk::VkDeviceSize size,
+ vk::VkBufferCreateFlags usage,
+ vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE,
+ deUint32 queueFamilyIndexCount = 0,
+ const deUint32* pQueueFamilyIndices = DE_NULL,
+ vk::VkBufferCreateFlags flags = 0);
- BufferCreateInfo (const BufferCreateInfo &other);
- BufferCreateInfo &operator= (const BufferCreateInfo &other);
+ BufferCreateInfo (const BufferCreateInfo& other);
+ BufferCreateInfo& operator= (const BufferCreateInfo& other);
private:
std::vector<deUint32> m_queueFamilyIndices;
};
-
class ImageCreateInfo : public vk::VkImageCreateInfo
{
public:
- ImageCreateInfo ( vk::VkImageType imageType,
- vk::VkFormat format,
- vk::VkExtent3D extent,
- deUint32 mipLevels,
- deUint32 arrayLayers,
- vk::VkSampleCountFlagBits samples,
- vk::VkImageTiling tiling,
- vk::VkImageUsageFlags usage,
- vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE,
- deUint32 queueFamilyIndexCount = 0,
- const deUint32* pQueueFamilyIndices = DE_NULL,
- vk::VkImageCreateFlags flags = 0,
- vk::VkImageLayout initialLayout = vk::VK_IMAGE_LAYOUT_UNDEFINED);
+ ImageCreateInfo (vk::VkImageType imageType,
+ vk::VkFormat format,
+ vk::VkExtent3D extent,
+ deUint32 mipLevels,
+ deUint32 arrayLayers,
+ vk::VkSampleCountFlagBits samples,
+ vk::VkImageTiling tiling,
+ vk::VkImageUsageFlags usage,
+ vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE,
+ deUint32 queueFamilyIndexCount = 0,
+ const deUint32* pQueueFamilyIndices = DE_NULL,
+ vk::VkImageCreateFlags flags = 0,
+ vk::VkImageLayout initialLayout = vk::VK_IMAGE_LAYOUT_UNDEFINED);
private:
- ImageCreateInfo (const ImageCreateInfo &other);
- ImageCreateInfo &operator= (const ImageCreateInfo &other);
+ ImageCreateInfo (const ImageCreateInfo& other);
+ ImageCreateInfo& operator= (const ImageCreateInfo& other);
std::vector<deUint32> m_queueFamilyIndices;
};
class FramebufferCreateInfo : public vk::VkFramebufferCreateInfo
{
public:
- FramebufferCreateInfo ( vk::VkRenderPass renderPass,
- const std::vector<vk::VkImageView>& attachments,
- deUint32 width,
- deUint32 height,
- deUint32 layers);
+ FramebufferCreateInfo (vk::VkRenderPass renderPass,
+ const std::vector<vk::VkImageView>& attachments,
+ deUint32 width,
+ deUint32 height,
+ deUint32 layers);
};
class AttachmentDescription : public vk::VkAttachmentDescription
{
public:
- AttachmentDescription ( vk::VkFormat format,
- vk::VkSampleCountFlagBits samples,
- vk::VkAttachmentLoadOp loadOp,
- vk::VkAttachmentStoreOp storeOp,
- vk::VkAttachmentLoadOp stencilLoadOp,
- vk::VkAttachmentStoreOp stencilStoreOp,
- vk::VkImageLayout initialLayout,
- vk::VkImageLayout finalLayout);
-
- AttachmentDescription (const vk::VkAttachmentDescription &);
+ AttachmentDescription (vk::VkFormat format,
+ vk::VkSampleCountFlagBits samples,
+ vk::VkAttachmentLoadOp loadOp,
+ vk::VkAttachmentStoreOp storeOp,
+ vk::VkAttachmentLoadOp stencilLoadOp,
+ vk::VkAttachmentStoreOp stencilStoreOp,
+ vk::VkImageLayout initialLayout,
+ vk::VkImageLayout finalLayout);
+
+ AttachmentDescription (const vk::VkAttachmentDescription &);
};
class AttachmentReference : public vk::VkAttachmentReference
{
public:
- AttachmentReference (deUint32 attachment, vk::VkImageLayout layout);
- AttachmentReference (void);
+ AttachmentReference (deUint32 attachment, vk::VkImageLayout layout);
+ AttachmentReference (void);
};
class SubpassDescription : public vk::VkSubpassDescription
{
public:
- SubpassDescription ( vk::VkPipelineBindPoint pipelineBindPoint,
- vk::VkSubpassDescriptionFlags flags,
- deUint32 inputAttachmentCount,
- const vk::VkAttachmentReference* inputAttachments,
- deUint32 colorAttachmentCount,
- const vk::VkAttachmentReference* colorAttachments,
- const vk::VkAttachmentReference* resolveAttachments,
- vk::VkAttachmentReference depthStencilAttachment,
- deUint32 preserveAttachmentCount,
- const vk::VkAttachmentReference* preserveAttachments);
-
- SubpassDescription (const vk::VkSubpassDescription& other);
- SubpassDescription (const SubpassDescription& other);
- SubpassDescription& operator= (const SubpassDescription& other);
+ SubpassDescription (vk::VkPipelineBindPoint pipelineBindPoint,
+ vk::VkSubpassDescriptionFlags flags,
+ deUint32 inputAttachmentCount,
+ const vk::VkAttachmentReference* inputAttachments,
+ deUint32 colorAttachmentCount,
+ const vk::VkAttachmentReference* colorAttachments,
+ const vk::VkAttachmentReference* resolveAttachments,
+ vk::VkAttachmentReference depthStencilAttachment,
+ deUint32 preserveAttachmentCount,
+ const vk::VkAttachmentReference* preserveAttachments);
+
+ SubpassDescription (const vk::VkSubpassDescription& other);
+ SubpassDescription (const SubpassDescription& other);
+ SubpassDescription& operator= (const SubpassDescription& other);
private:
- std::vector<vk::VkAttachmentReference> m_inputAttachments;
- std::vector<vk::VkAttachmentReference> m_colorAttachments;
- std::vector<vk::VkAttachmentReference> m_resolveAttachments;
- std::vector<vk::VkAttachmentReference> m_preserveAttachments;
+ std::vector<vk::VkAttachmentReference> m_inputAttachments;
+ std::vector<vk::VkAttachmentReference> m_colorAttachments;
+ std::vector<vk::VkAttachmentReference> m_resolveAttachments;
+ std::vector<vk::VkAttachmentReference> m_preserveAttachments;
vk::VkAttachmentReference m_depthStencilAttachment;
};
class RenderPassCreateInfo : public vk::VkRenderPassCreateInfo
{
public:
- RenderPassCreateInfo ( const std::vector<vk::VkAttachmentDescription>& attachments,
- const std::vector<vk::VkSubpassDescription>& subpasses,
- const std::vector<vk::VkSubpassDependency>& dependiences = std::vector<vk::VkSubpassDependency>());
+ RenderPassCreateInfo (const std::vector<vk::VkAttachmentDescription>& attachments,
+ const std::vector<vk::VkSubpassDescription>& subpasses,
+ const std::vector<vk::VkSubpassDependency>& dependiences = std::vector<vk::VkSubpassDependency>());
- RenderPassCreateInfo ( deUint32 attachmentCount = 0,
- const vk::VkAttachmentDescription* pAttachments = DE_NULL,
- deUint32 subpassCount = 0,
- const vk::VkSubpassDescription* pSubpasses = DE_NULL,
- deUint32 dependencyCount = 0,
- const vk::VkSubpassDependency* pDependiences = DE_NULL);
+ RenderPassCreateInfo (deUint32 attachmentCount = 0,
+ const vk::VkAttachmentDescription* pAttachments = DE_NULL,
+ deUint32 subpassCount = 0,
+ const vk::VkSubpassDescription* pSubpasses = DE_NULL,
+ deUint32 dependencyCount = 0,
+ const vk::VkSubpassDependency* pDependiences = DE_NULL);
- void addAttachment (vk::VkAttachmentDescription attachment);
- void addSubpass (vk::VkSubpassDescription subpass);
- void addDependency (vk::VkSubpassDependency dependency);
+ void addAttachment (vk::VkAttachmentDescription attachment);
+ void addSubpass (vk::VkSubpassDescription subpass);
+ void addDependency (vk::VkSubpassDependency dependency);
private:
std::vector<AttachmentDescription> m_attachments;
std::vector<vk::VkSubpassDependency> m_dependiencesStructs;
RenderPassCreateInfo (const RenderPassCreateInfo &other); //Not allowed!
- RenderPassCreateInfo &operator= (const RenderPassCreateInfo &other); //Not allowed!
+ RenderPassCreateInfo& operator= (const RenderPassCreateInfo &other); //Not allowed!
};
class RenderPassBeginInfo : public vk::VkRenderPassBeginInfo
{
public:
- RenderPassBeginInfo ( vk::VkRenderPass renderPass,
- vk::VkFramebuffer framebuffer,
- vk::VkRect2D renderArea,
- const std::vector<vk::VkClearValue>& clearValues = std::vector<vk::VkClearValue>());
+ RenderPassBeginInfo (vk::VkRenderPass renderPass,
+ vk::VkFramebuffer framebuffer,
+ vk::VkRect2D renderArea,
+ const std::vector<vk::VkClearValue>& clearValues = std::vector<vk::VkClearValue>());
private:
std::vector<vk::VkClearValue> m_clearValues;
- RenderPassBeginInfo (const RenderPassBeginInfo &other); //Not allowed!
- RenderPassBeginInfo &operator= (const RenderPassBeginInfo &other); //Not allowed!
+ RenderPassBeginInfo (const RenderPassBeginInfo& other); //Not allowed!
+ RenderPassBeginInfo& operator= (const RenderPassBeginInfo& other); //Not allowed!
};
class CmdPoolCreateInfo : public vk::VkCommandPoolCreateInfo
{
public:
- CmdPoolCreateInfo (deUint32 queueFamilyIndex,
- vk::VkCommandPoolCreateFlags flags = vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
+ CmdPoolCreateInfo (deUint32 queueFamilyIndex,
+ vk::VkCommandPoolCreateFlags flags = vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
};
class CmdBufferBeginInfo : public vk::VkCommandBufferBeginInfo
{
public:
- CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags flags = 0);
+ CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags flags = 0);
CmdBufferBeginInfo (vk::VkRenderPass renderPass,
deUint32 subpass,
vk::VkFramebuffer framebuffer,
- vk::VkCommandBufferUsageFlags flags = 0,
+ vk::VkCommandBufferUsageFlags flags = 0,
bool occlusionQueryEnable = false,
vk::VkQueryControlFlags queryFlags = 0u,
vk::VkQueryPipelineStatisticFlags pipelineStatistics = 0u);
};
-
class DescriptorPoolSize : public vk::VkDescriptorPoolSize
{
public:
class DescriptorPoolCreateInfo : public vk::VkDescriptorPoolCreateInfo
{
public:
- DescriptorPoolCreateInfo ( const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts,\r
- vk::VkDescriptorPoolCreateFlags flags, \r
- deUint32 maxSets);
+ DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts,
+ vk::VkDescriptorPoolCreateFlags flags,
+ deUint32 maxSets);
DescriptorPoolCreateInfo& addDescriptors (vk::VkDescriptorType type, deUint32 count);
std::vector<vk::VkDescriptorPoolSize> m_poolSizeCounts;
};
-
class DescriptorSetLayoutCreateInfo : public vk::VkDescriptorSetLayoutCreateInfo
{
public:
DescriptorSetLayoutCreateInfo (deUint32 bindingCount, const vk::VkDescriptorSetLayoutBinding* pBindings);
};
-
class PipelineLayoutCreateInfo : public vk::VkPipelineLayoutCreateInfo
{
public:
- PipelineLayoutCreateInfo ( deUint32 descriptorSetCount,
- const vk::VkDescriptorSetLayout* pSetLayouts,
- deUint32 pushConstantRangeCount = 0,
- const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL);
+ PipelineLayoutCreateInfo (deUint32 descriptorSetCount,
+ const vk::VkDescriptorSetLayout* pSetLayouts,
+ deUint32 pushConstantRangeCount = 0,
+ const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL);
- PipelineLayoutCreateInfo ( const std::vector<vk::VkDescriptorSetLayout>& setLayouts = std::vector<vk::VkDescriptorSetLayout>(),
- deUint32 pushConstantRangeCount = 0,
- const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL);
+ PipelineLayoutCreateInfo (const std::vector<vk::VkDescriptorSetLayout>& setLayouts = std::vector<vk::VkDescriptorSetLayout>(),
+ deUint32 pushConstantRangeCount = 0,
+ const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL);
private:
std::vector<vk::VkDescriptorSetLayout> m_setLayouts;
class VertexInputState : public vk::VkPipelineVertexInputStateCreateInfo
{
public:
- VertexInputState ( deUint32 vertexBindingDescriptionCount = 0,
- const vk::VkVertexInputBindingDescription* pVertexBindingDescriptions = NULL,
- deUint32 vertexAttributeDescriptionCount = 0,
- const vk::VkVertexInputAttributeDescription* pVertexAttributeDescriptions = NULL);
+ VertexInputState (deUint32 vertexBindingDescriptionCount = 0,
+ const vk::VkVertexInputBindingDescription* pVertexBindingDescriptions = NULL,
+ deUint32 vertexAttributeDescriptionCount = 0,
+ const vk::VkVertexInputAttributeDescription* pVertexAttributeDescriptions = NULL);
};
class InputAssemblerState : public vk::VkPipelineInputAssemblyStateCreateInfo
class ViewportState : public vk::VkPipelineViewportStateCreateInfo
{
public:
- ViewportState ( deUint32 viewportCount,
- std::vector<vk::VkViewport> viewports = std::vector<vk::VkViewport>(0),
- std::vector<vk::VkRect2D> scissors = std::vector<vk::VkRect2D>(0));
+ ViewportState (deUint32 viewportCount,
+ std::vector<vk::VkViewport> viewports = std::vector<vk::VkViewport>(0),
+ std::vector<vk::VkRect2D> scissors = std::vector<vk::VkRect2D>(0));
- ViewportState (const ViewportState &other);
- ViewportState &operator= (const ViewportState &other);
+ ViewportState (const ViewportState& other);
+ ViewportState& operator= (const ViewportState& other);
std::vector<vk::VkViewport> m_viewports;
std::vector<vk::VkRect2D> m_scissors;
class RasterizerState : public vk::VkPipelineRasterizationStateCreateInfo
{
public:
- RasterizerState ( vk::VkBool32 depthClampEnable = false,
- vk::VkBool32 rasterizerDiscardEnable = false,
- vk::VkPolygonMode polygonMode = vk::VK_POLYGON_MODE_FILL,
- vk::VkCullModeFlags cullMode = vk::VK_CULL_MODE_NONE,
- vk::VkFrontFace frontFace = vk::VK_FRONT_FACE_CLOCKWISE,
- vk::VkBool32 depthBiasEnable = true,\r
- float depthBiasConstantFactor = 0.0f,
- float depthBiasClamp = 0.0f,
- float depthBiasSlopeFactor = 0.0f,
- float lineWidth = 1.0f);
+ RasterizerState (vk::VkBool32 depthClampEnable = false,
+ vk::VkBool32 rasterizerDiscardEnable = false,
+ vk::VkPolygonMode polygonMode = vk::VK_POLYGON_MODE_FILL,
+ vk::VkCullModeFlags cullMode = vk::VK_CULL_MODE_NONE,
+ vk::VkFrontFace frontFace = vk::VK_FRONT_FACE_CLOCKWISE,
+ vk::VkBool32 depthBiasEnable = true,
+ float depthBiasConstantFactor = 0.0f,
+ float depthBiasClamp = 0.0f,
+ float depthBiasSlopeFactor = 0.0f,
+ float lineWidth = 1.0f);
};
class MultiSampleState : public vk::VkPipelineMultisampleStateCreateInfo
{
public:
- MultiSampleState ( vk::VkSampleCountFlagBits rasterizationSamples = vk::VK_SAMPLE_COUNT_1_BIT,
- vk::VkBool32 sampleShadingEnable = false,
- float minSampleShading = 0.0f,
- const std::vector<vk::VkSampleMask>& sampleMask = std::vector<vk::VkSampleMask>(1, 0xffffffff),
- bool alphaToCoverageEnable = false,
- bool alphaToOneEnable = false);
+ MultiSampleState (vk::VkSampleCountFlagBits rasterizationSamples = vk::VK_SAMPLE_COUNT_1_BIT,
+ vk::VkBool32 sampleShadingEnable = false,
+ float minSampleShading = 0.0f,
+ const std::vector<vk::VkSampleMask>& sampleMask = std::vector<vk::VkSampleMask>(1, 0xffffffff),
+ bool alphaToCoverageEnable = false,
+ bool alphaToOneEnable = false);
- MultiSampleState (const MultiSampleState &other);
- MultiSampleState &operator= (const MultiSampleState &other);
+ MultiSampleState (const MultiSampleState& other);
+ MultiSampleState& operator= (const MultiSampleState& other);
private:
std::vector<vk::VkSampleMask> m_sampleMask;
vk::VkBlendFactor srcAlphaBlendFactor = vk::VK_BLEND_FACTOR_SRC_COLOR,
vk::VkBlendFactor dstAlphaBlendFactor = vk::VK_BLEND_FACTOR_DST_COLOR,
vk::VkBlendOp alphaBlendOp = vk::VK_BLEND_OP_ADD,
- deUint8 colorWriteMask = 0xff);
+ deUint8 colorWriteMask = 0xff);
};
- ColorBlendState ( const std::vector<vk::VkPipelineColorBlendAttachmentState>& attachments,
- vk::VkBool32 alphaToCoverageEnable = false,
- vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY);
+ ColorBlendState (const std::vector<vk::VkPipelineColorBlendAttachmentState>& attachments,
+ vk::VkBool32 alphaToCoverageEnable = false,
+ vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY);
- ColorBlendState ( deUint32 attachmentCount,
- const vk::VkPipelineColorBlendAttachmentState* attachments,
- vk::VkBool32 logicOpEnable = false,
- vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY);
+ ColorBlendState (deUint32 attachmentCount,
+ const vk::VkPipelineColorBlendAttachmentState* attachments,
+ vk::VkBool32 logicOpEnable = false,
+ vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY);
- ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo &createInfo);
- ColorBlendState (const ColorBlendState &createInfo, std::vector<float> blendConstants = std::vector<float>(4));
+ ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo);
+ ColorBlendState (const ColorBlendState& createInfo,
+ std::vector<float> blendConstants = std::vector<float>(4));
private:
std::vector<vk::VkPipelineColorBlendAttachmentState> m_attachments;
class StencilOpState : public vk::VkStencilOpState
{
public:
- StencilOpState (vk::VkStencilOp failOp = vk::VK_STENCIL_OP_REPLACE,
- vk::VkStencilOp passOp = vk::VK_STENCIL_OP_REPLACE,
- vk::VkStencilOp depthFailOp = vk::VK_STENCIL_OP_REPLACE,
- vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS,
- deUint32 compareMask = 0xffffffffu,\r
- deUint32 writeMask = 0xffffffffu,\r
- deUint32 reference = 0);
+ StencilOpState (vk::VkStencilOp failOp = vk::VK_STENCIL_OP_REPLACE,
+ vk::VkStencilOp passOp = vk::VK_STENCIL_OP_REPLACE,
+ vk::VkStencilOp depthFailOp = vk::VK_STENCIL_OP_REPLACE,
+ vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS,
+ deUint32 compareMask = 0xffffffffu,
+ deUint32 writeMask = 0xffffffffu,
+ deUint32 reference = 0);
};
- DepthStencilState ( vk::VkBool32 depthTestEnable = false,
- vk::VkBool32 depthWriteEnable = false,
- vk::VkCompareOp depthCompareOp = vk::VK_COMPARE_OP_ALWAYS,
- vk::VkBool32 depthBoundsTestEnable = false,
- vk::VkBool32 stencilTestEnable = false,
- StencilOpState front = StencilOpState(),
- StencilOpState back = StencilOpState(),
- float minDepthBounds = -1.0f,
- float maxDepthBounds = 1.0f);
+ DepthStencilState (vk::VkBool32 depthTestEnable = false,
+ vk::VkBool32 depthWriteEnable = false,
+ vk::VkCompareOp depthCompareOp = vk::VK_COMPARE_OP_ALWAYS,
+ vk::VkBool32 depthBoundsTestEnable = false,
+ vk::VkBool32 stencilTestEnable = false,
+ StencilOpState front = StencilOpState(),
+ StencilOpState back = StencilOpState(),
+ float minDepthBounds = -1.0f,
+ float maxDepthBounds = 1.0f);
};
class PipelineShaderStage : public vk::VkPipelineShaderStageCreateInfo
{
public:
- PipelineShaderStage (vk::VkShaderModule shaderModule, const char* _pName, vk::VkShaderStageFlagBits stage);
+ PipelineShaderStage (vk::VkShaderModule shaderModule, const char* pName, vk::VkShaderStageFlagBits stage);
};
class DynamicState : public vk::VkPipelineDynamicStateCreateInfo
{
public:
- DynamicState (const std::vector<vk::VkDynamicState>& dynamicStates = std::vector<vk::VkDynamicState>(0));
+ DynamicState (const std::vector<vk::VkDynamicState>& dynamicStates = std::vector<vk::VkDynamicState>(0));
- DynamicState (const DynamicState &other);
- DynamicState &operator= (const DynamicState &other);
+ DynamicState (const DynamicState& other);
+ DynamicState& operator= (const DynamicState& other);
std::vector<vk::VkDynamicState> m_dynamicStates;
};
- PipelineCreateInfo(vk::VkPipelineLayout layout, vk::VkRenderPass renderPass, int subpass, vk::VkPipelineCreateFlags flags);
+ PipelineCreateInfo (vk::VkPipelineLayout layout,
+ vk::VkRenderPass renderPass,
+ int subpass,
+ vk::VkPipelineCreateFlags flags);
- PipelineCreateInfo& addShader (const vk::VkPipelineShaderStageCreateInfo& shader);
+ PipelineCreateInfo& addShader (const vk::VkPipelineShaderStageCreateInfo& shader);
- PipelineCreateInfo& addState (const vk::VkPipelineVertexInputStateCreateInfo& state);
- PipelineCreateInfo& addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state);
- PipelineCreateInfo& addState (const vk::VkPipelineColorBlendStateCreateInfo& state);
- PipelineCreateInfo& addState (const vk::VkPipelineViewportStateCreateInfo& state);
- PipelineCreateInfo& addState (const vk::VkPipelineDepthStencilStateCreateInfo& state);
- PipelineCreateInfo& addState (const vk::VkPipelineTessellationStateCreateInfo& state);
- PipelineCreateInfo& addState (const vk::VkPipelineRasterizationStateCreateInfo& state);
- PipelineCreateInfo& addState (const vk::VkPipelineMultisampleStateCreateInfo& state);
- PipelineCreateInfo& addState (const vk::VkPipelineDynamicStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineVertexInputStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineColorBlendStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineViewportStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineDepthStencilStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineTessellationStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineRasterizationStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineMultisampleStateCreateInfo& state);
+ PipelineCreateInfo& addState (const vk::VkPipelineDynamicStateCreateInfo& state);
private:
std::vector<vk::VkPipelineShaderStageCreateInfo> m_shaders;
vk::VkPipelineMultisampleStateCreateInfo m_multisampleState;
vk::VkPipelineDynamicStateCreateInfo m_dynamicState;
- std::vector<vk::VkDynamicState> m_dynamicStates;
+ std::vector<vk::VkDynamicState> m_dynamicStates;
- std::vector<vk::VkViewport> m_viewports;
- std::vector<vk::VkRect2D> m_scissors;
+ std::vector<vk::VkViewport> m_viewports;
+ std::vector<vk::VkRect2D> m_scissors;
- std::vector<vk::VkSampleMask> m_multisampleStateSampleMask;
+ std::vector<vk::VkSampleMask> m_multisampleStateSampleMask;
};
class SamplerCreateInfo : public vk::VkSamplerCreateInfo
{
public:
- SamplerCreateInfo ( vk::VkFilter magFilter = vk::VK_FILTER_NEAREST,
- vk::VkFilter minFilter = vk::VK_FILTER_NEAREST,
- vk::VkSamplerMipmapMode mipmapMode = vk::VK_SAMPLER_MIPMAP_MODE_NEAREST,
- vk::VkSamplerAddressMode addressU = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
- vk::VkSamplerAddressMode addressV = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
- vk::VkSamplerAddressMode addressW = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
- float mipLodBias = 0.0f,
- float maxAnisotropy = 1.0f,
- vk::VkBool32 compareEnable = false,
- vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS,
- float minLod = 0.0f,
- float maxLod = 16.0f,
- vk::VkBorderColor borderColor = vk::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
- vk::VkBool32 unnormalizedCoordinates = false);
+ SamplerCreateInfo (vk::VkFilter magFilter = vk::VK_FILTER_NEAREST,
+ vk::VkFilter minFilter = vk::VK_FILTER_NEAREST,
+ vk::VkSamplerMipmapMode mipmapMode = vk::VK_SAMPLER_MIPMAP_MODE_NEAREST,
+ vk::VkSamplerAddressMode addressU = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
+ vk::VkSamplerAddressMode addressV = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
+ vk::VkSamplerAddressMode addressW = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
+ float mipLodBias = 0.0f,
+ float maxAnisotropy = 1.0f,
+ vk::VkBool32 compareEnable = false,
+ vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS,
+ float minLod = 0.0f,
+ float maxLod = 16.0f,
+ vk::VkBorderColor borderColor = vk::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
+ vk::VkBool32 unnormalizedCoordinates = false);
};
-} // DynamicState
+} // QueryPool
} // vkt
-#endif // _VKT_DYNAMIC_STATE_CREATEINFO_UTIL_HPP
+#endif // _VKTQUERYPOOLCREATEINFOUTIL_HPP
int width,
int height,
int depth,
- vk::VkDeviceSize rowPitch,
- vk::VkDeviceSize depthPitch,
+ vk::VkDeviceSize rowPitchOrZero,
+ vk::VkDeviceSize depthPitchOrZero,
const void * srcBuffer,
void * destBuffer)
{
- if (rowPitch == 0)
+ vk::VkDeviceSize rowPitch = rowPitchOrZero;
+ vk::VkDeviceSize depthPitch = depthPitchOrZero;
+
+ if (rowPitch == 0)
rowPitch = width * pixelSize;
- if (depthPitch == 0)
+ if (depthPitch == 0)
depthPitch = rowPitch * height;
const vk::VkDeviceSize size = depthPitch * depth;
dstStart = dstRow;
if (rowPitch == static_cast<vk::VkDeviceSize>(width * pixelSize) &&
- depthPitch == static_cast<vk::VkDeviceSize>(rowPitch * height))
+ depthPitch == static_cast<vk::VkDeviceSize>(rowPitch * height))
{
// fast path
deMemcpy(dstRow, srcRow, static_cast<size_t>(size));
vk::VkDeviceSize offsetDepthSrc = d * (pixelSize * width * height);
srcRow = srcStart + offsetDepthSrc;
dstRow = dstStart + offsetDepthDst;
- for (int r = 0; r < height; ++r)
+ for (int r = 0; r < height; ++r)
{
deMemcpy(dstRow, srcRow, static_cast<size_t>(rowPitch));
srcRow += pixelSize * width;
int width,
int height,
int depth,
- vk::VkDeviceSize rowPitch,
- vk::VkDeviceSize depthPitch,
+ vk::VkDeviceSize rowPitchOrZero,
+ vk::VkDeviceSize depthPitchOrZero,
const void * srcBuffer,
void * destBuffer)
{
+ vk::VkDeviceSize rowPitch = rowPitchOrZero;
+ vk::VkDeviceSize depthPitch = depthPitchOrZero;
+
if (rowPitch == 0)
rowPitch = width * pixelSize;
- if (depthPitch == 0)
+ if (depthPitch == 0)
depthPitch = rowPitch * height;
const vk::VkDeviceSize size = depthPitch * depth;
dstStart = dstRow;
if (rowPitch == static_cast<vk::VkDeviceSize>(width * pixelSize) &&
- depthPitch == static_cast<vk::VkDeviceSize>(rowPitch * height))
+ depthPitch == static_cast<vk::VkDeviceSize>(rowPitch * height))
{
// fast path
deMemcpy(dstRow, srcRow, static_cast<size_t>(size));
}
- else {
+ else
+ {
// slower, per row path
for (size_t d = 0; d < (size_t)depth; d++)
{
vk::VkDeviceSize offsetDepthSrc = d * depthPitch;
srcRow = srcStart + offsetDepthSrc;
dstRow = dstStart + offsetDepthDst;
- for (int r = 0; r < height; ++r)
+ for (int r = 0; r < height; ++r)
{
deMemcpy(dstRow, srcRow, static_cast<size_t>(pixelSize * width));
srcRow += rowPitch;
}
}
-Image::Image (const vk::DeviceInterface &vk,
+Image::Image (const vk::DeviceInterface& vk,
vk::VkDevice device,
vk::VkFormat format,
- const vk::VkExtent3D &extend,
+ const vk::VkExtent3D& extend,
deUint32 levelCount,
deUint32 layerCount,
vk::Move<vk::VkImage> object)
vk::VkImageType type,
void * data)
{
- if (layout != vk::VK_IMAGE_LAYOUT_GENERAL && layout != vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)
- TCU_FAIL("Image::uploadFromSurface usage error: this function is not going to change Image layout!");
+ DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
de::SharedPtr<Image> stagingResource = copyToLinearImage(queue, allocator, layout, offset, width,
height, depth, mipLevel, arrayElement, aspect, type);
vk::VkImageAspectFlagBits aspect,
void * data)
{
- if (layout != vk::VK_IMAGE_LAYOUT_GENERAL && layout != vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)
- TCU_FAIL("Image::uploadFromSurface usage error: this function is not going to change Image layout!");
+ DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);;
de::SharedPtr<Buffer> stagingResource;
stagingResource = Buffer::createAndAlloc(m_vk, m_device, stagingBufferResourceCreateInfo, allocator, vk::MemoryRequirement::HostVisible);
{
- #pragma message("Get queue family index")
+ //todo [scygan] get proper queueFamilyIndex
CmdPoolCreateInfo copyCmdPoolCreateInfo(0);
vk::Unique<vk::VkCommandPool> copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo));
void* barriers[] = { &barrier };
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
false, DE_LENGTH_OF_ARRAY(barriers), barriers);
}
- vk::VkBufferImageCopy region =
+ const vk::VkBufferImageCopy region =
{
0, 0, 0,
{ aspect, mipLevel, arrayElement, 1 },
m_vk.cmdCopyImageToBuffer(*copyCmdBuffer, object(), layout, stagingResource->object(), 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
- vk::VkSubmitInfo submitInfo =
+ const vk::VkSubmitInfo submitInfo =
{
vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;\r
DE_NULL, // const void* pNext;\r
- 0, // deUint32 waitSemaphoreCount;\r
- DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
- 1, // deUint32 commandBufferCount;\r
+ 0, // deUint32 waitSemaphoreCount;\r
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
+ 1, // deUint32 commandBufferCount;\r
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;\r
- 0, // deUint32 signalSemaphoreCount;\r
+ 0, // deUint32 signalSemaphoreCount;\r
DE_NULL // const VkSemaphore* pSignalSemaphores;\r
};
m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
de::SharedPtr<Image> stagingResource;
{
vk::VkExtent3D stagingExtent = {width, height, depth};
- ImageCreateInfo stagingResourceCreateInfo(
- type, m_format, stagingExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
- vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT);
+ ImageCreateInfo stagingResourceCreateInfo(type, m_format, stagingExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
+ vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT);
stagingResource = Image::createAndAlloc(m_vk, m_device, stagingResourceCreateInfo, allocator,
- vk::MemoryRequirement::HostVisible);
+ vk::MemoryRequirement::HostVisible);
- #pragma message("Get queue family index")
+ //todo [scygan] get proper queueFamilyIndex
CmdPoolCreateInfo copyCmdPoolCreateInfo(0);
vk::Unique<vk::VkCommandPool> copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo));
m_vk.cmdCopyImage(*copyCmdBuffer, object(), layout, stagingResource->object(), vk::VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
- vk::VkSubmitInfo submitInfo =
+ const vk::VkSubmitInfo submitInfo =
{
vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;\r
DE_NULL, // const void* pNext;\r
- 0, // deUint32 waitSemaphoreCount;\r
- DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
- 1, // deUint32 commandBufferCount;\r
+ 0, // deUint32 waitSemaphoreCount;\r
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
+ 1, // deUint32 commandBufferCount;\r
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;\r
- 0, // deUint32 signalSemaphoreCount;\r
+ 0, // deUint32 signalSemaphoreCount;\r
DE_NULL // const VkSemaphore* pSignalSemaphores;\r
};
m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
void Image::uploadVolume(const tcu::ConstPixelBufferAccess& access,
vk::VkQueue queue,
- vk::Allocator& allocator,
+ vk::Allocator& allocator,
vk::VkImageLayout layout,
vk::VkOffset3D offset,
vk::VkImageAspectFlagBits aspect,
void Image::uploadSurface (const tcu::ConstPixelBufferAccess& access,
vk::VkQueue queue,
- vk::Allocator& allocator,
+ vk::Allocator& allocator,
vk::VkImageLayout layout,
vk::VkOffset3D offset,
vk::VkImageAspectFlagBits aspect,
void Image::uploadSurface1D (const tcu::ConstPixelBufferAccess& access,
vk::VkQueue queue,
- vk::Allocator& allocator,
+ vk::Allocator& allocator,
vk::VkImageLayout layout,
vk::VkOffset3D offset,
vk::VkImageAspectFlagBits aspect,
}
void Image::upload (vk::VkQueue queue,
- vk::Allocator& allocator,
+ vk::Allocator& allocator,
vk::VkImageLayout layout,
vk::VkOffset3D offset,
int width,
vk::VkImageType type,
const void * data)
{
-
- if (layout != vk::VK_IMAGE_LAYOUT_UNDEFINED
- && layout != vk::VK_IMAGE_LAYOUT_GENERAL
- && layout != vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)
- {
- TCU_FAIL("Image::uploadFromRaw usage error: this function is not going to change Image layout!");
- }
+ DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_UNDEFINED || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
de::SharedPtr<Image> stagingResource;
vk::VkExtent3D extent = {width, height, depth};
stagingResource = Image::createAndAlloc(m_vk, m_device, stagingResourceCreateInfo, allocator,
vk::MemoryRequirement::HostVisible);
-
+
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
stagingResource->uploadLinear(zeroOffset, width, height, depth, 0, 0, aspect, data);
{
- #pragma message("Get queue family index")
+ //todo [scygan] get proper queueFamilyIndex
CmdPoolCreateInfo copyCmdPoolCreateInfo(0);
vk::Unique<vk::VkCommandPool> copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo));
vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
1u, // deUint32 bufferCount;
};
+
vk::Unique<vk::VkCommandBuffer> copyCmdBuffer(vk::allocateCommandBuffer(m_vk, m_device, &cmdBufferAllocateInfo));
CmdBufferBeginInfo beginInfo;
VK_CHECK(m_vk.beginCommandBuffer(*copyCmdBuffer, &beginInfo));
-
+
if (layout == vk::VK_IMAGE_LAYOUT_UNDEFINED)
{
layout = vk::VK_IMAGE_LAYOUT_GENERAL;
vk::VK_IMAGE_LAYOUT_GENERAL, object(), layout, 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
- vk::VkSubmitInfo submitInfo =
+ const vk::VkSubmitInfo submitInfo =
{
vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;\r
DE_NULL, // const void* pNext;\r
- 0, // deUint32 waitSemaphoreCount;\r
- DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
- 1, // deUint32 commandBufferCount;\r
+ 0, // deUint32 waitSemaphoreCount;\r
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
+ 1, // deUint32 commandBufferCount;\r
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;\r
- 0, // deUint32 signalSemaphoreCount;\r
+ 0, // deUint32 signalSemaphoreCount;\r
DE_NULL // const VkSemaphore* pSignalSemaphores;\r
};
m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
}
void Image::uploadUsingBuffer (vk::VkQueue queue,
- vk::Allocator& allocator,
+ vk::Allocator& allocator,
vk::VkImageLayout layout,
vk::VkOffset3D offset,
int width,
vk::VkImageAspectFlagBits aspect,
const void * data)
{
- if (layout != vk::VK_IMAGE_LAYOUT_UNDEFINED
- && layout != vk::VK_IMAGE_LAYOUT_GENERAL
- && layout != vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)
- {
- TCU_FAIL("Image::uploadFromRaw usage error: this function is not going to change Image layout!");
- }
+ DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_UNDEFINED || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
de::SharedPtr<Buffer> stagingResource;
bool isCombinedType = isCombinedDepthStencilType(vk::mapVkFormat(m_format).type);
deMemcpy(destPtr, data, bufferSize);
vk::flushMappedMemoryRange(m_vk, m_device, stagingResource->getBoundMemory().getMemory(), stagingResource->getBoundMemory().getOffset(), bufferSize);
{
- #pragma message("Get queue family index")
+ //todo [scygan] get proper queueFamilyIndex
CmdPoolCreateInfo copyCmdPoolCreateInfo(0);
vk::Unique<vk::VkCommandPool> copyCmdPool(vk::createCommandPool(m_vk, m_device, ©CmdPoolCreateInfo));
m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
}
- vk::VkBufferImageCopy region = {
+ vk::VkBufferImageCopy region =
+ {
0, 0, 0,
{ aspect, mipLevel, arrayElement, 1 },
offset,
{
vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;\r
DE_NULL, // const void* pNext;\r
- 0, // deUint32 waitSemaphoreCount;\r
- DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
- 1, // deUint32 commandBufferCount;\r
+ 0, // deUint32 waitSemaphoreCount;\r
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;\r
+ 1, // deUint32 commandBufferCount;\r
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;\r
- 0, // deUint32 signalSemaphoreCount;\r
+ 0, // deUint32 signalSemaphoreCount;\r
DE_NULL // const VkSemaphore* pSignalSemaphores;\r
};
m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
}
}
-
void Image::uploadLinear (vk::VkOffset3D offset,
int width,
int height,
destPtr += imageLayout.offset + getPixelOffset(offset, imageLayout.rowPitch, imageLayout.depthPitch, mipLevel, arrayElement);
- MemoryOp::pack(vk::mapVkFormat(m_format).getPixelSize(), width, height, depth,
+ MemoryOp::pack(vk::mapVkFormat(m_format).getPixelSize(), width, height, depth,
imageLayout.rowPitch, imageLayout.depthPitch, data, destPtr);
}
unsigned int level,
unsigned int layer)
{
- if (level >= m_levelCount)
- TCU_FAIL("mip level too large");
-
- if (layer >= m_layerCount)
- TCU_FAIL("array element too large");
+ DE_ASSERT(level < m_levelCount);
+ DE_ASSERT(layer < m_layerCount);
vk::VkDeviceSize mipLevelSizes[32];
vk::VkDeviceSize mipLevelRectSizes[32];
}
vk::VkDeviceSize pixelOffset = layer * arrayElemSize;
- for (size_t i = 0; i < level; ++i) {
+ for (size_t i = 0; i < level; ++i)
+ {
pixelOffset += mipLevelSizes[i];
}
pixelOffset += offset.z * mipLevelRectSizes[level];
de::SharedPtr<Image> Image::createAndAlloc(const vk::DeviceInterface& vk,
vk::VkDevice device,
const vk::VkImageCreateInfo& createInfo,
- vk::Allocator& allocator,
+ vk::Allocator& allocator,
vk::MemoryRequirement memoryRequirement)
{
de::SharedPtr<Image> ret = create(vk, device, createInfo);
vk::createImage(vk, device, &createInfo)));
}
-void transition2DImage (const vk::DeviceInterface& vk,
- vk::VkCommandBuffer cmdBuffer,
- vk::VkImage image,
- vk::VkImageAspectFlags aspectMask,
+void transition2DImage (const vk::DeviceInterface& vk,
+ vk::VkCommandBuffer cmdBuffer,
+ vk::VkImage image,
+ vk::VkImageAspectFlags aspectMask,
vk::VkImageLayout oldLayout,
vk::VkImageLayout newLayout)
{
- vk::VkImageMemoryBarrier barrier;
+ vk::VkImageMemoryBarrier barrier;
barrier.sType = vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
barrier.pNext = DE_NULL;
barrier.srcAccessMask = 0;
vk.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
}
-
void initialTransitionColor2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout)
{
transition2DImage(vk, cmdBuffer, image, vk::VK_IMAGE_ASPECT_COLOR_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, layout);
transition2DImage(vk, cmdBuffer, image, vk::VK_IMAGE_ASPECT_DEPTH_BIT | vk::VK_IMAGE_ASPECT_STENCIL_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, layout);
}
-} //QueryPool
-} //vkt
+} // QueryPool
+} // vkt
-#ifndef _VKT_DYNAMIC_STATE_IMAGEOBJECTUTIL_HPP
-#define _VKT_DYNAMIC_STATE_IMAGEOBJECTUTIL_HPP
+#ifndef _VKTQUERYPOOLIMAGEOBJECTUTIL_HPP
+#define _VKTQUERYPOOLIMAGEOBJECTUTIL_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
* \brief Image Object Util
*//*--------------------------------------------------------------------*/
-#include "vkDefs.hpp"
#include "vkMemUtil.hpp"
#include "vkRefUtil.hpp"
int width,
int height,
int depth,
- vk::VkDeviceSize rowPitch,
- vk::VkDeviceSize depthPitch,
+ vk::VkDeviceSize rowPitchOrZero,
+ vk::VkDeviceSize depthPitchOrZero,
const void * srcBuffer,
void * destBuffer);
int width,
int height,
int depth,
- vk::VkDeviceSize rowPitch,
- vk::VkDeviceSize depthPitch,
+ vk::VkDeviceSize rowPitchOrZero,
+ vk::VkDeviceSize depthPitchOrZero,
const void * srcBuffer,
void * destBuffer);
};
-
class Image
{
public:
- static de::SharedPtr<Image> create (const vk::DeviceInterface &vk, vk::VkDevice device, const vk::VkImageCreateInfo &createInfo);
+ static de::SharedPtr<Image> create (const vk::DeviceInterface& vk, vk::VkDevice device, const vk::VkImageCreateInfo& createInfo);
static de::SharedPtr<Image> createAndAlloc (const vk::DeviceInterface& vk,
vk::VkDevice device,
unsigned int mipLevel = 0,
unsigned int arrayElement = 0);
-
tcu::ConstPixelBufferAccess readSurfaceLinear (vk::VkOffset3D offset,
int width,
int height,
deUint32 layerCount,
vk::Move<vk::VkImage> object);
- Image (const Image &other); // Not allowed!
- Image &operator= (const Image &other); // Not allowed!
+ Image (const Image& other); // Not allowed!
+ Image& operator= (const Image& other); // Not allowed!
- de::MovePtr<vk::Allocation> m_allocation;
+ de::MovePtr<vk::Allocation> m_allocation;
vk::Unique<vk::VkImage> m_object;
vk::VkFormat m_format;
vk::VkDevice m_device;
};
-void transition2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageAspectFlags aspectMask, vk::VkImageLayout oldLayout, vk::VkImageLayout newLayout);
+void transition2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageAspectFlags aspectMask, vk::VkImageLayout oldLayout, vk::VkImageLayout newLayout);
-void initialTransitionColor2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
+void initialTransitionColor2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
-void initialTransitionDepth2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
+void initialTransitionDepth2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
-void initialTransitionStencil2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
+void initialTransitionStencil2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
-void initialTransitionDepthStencil2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
+void initialTransitionDepthStencil2DImage (const vk::DeviceInterface& vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout);
} //QueryPool
} //vkt
-#endif // _VKT_DYNAMIC_STATE_IMAGEOBJECTUTIL_HPP
+#endif // _VKTQUERYPOOLIMAGEOBJECTUTIL_HPP
struct StateObjects {
StateObjects (const vk::DeviceInterface&vk, vkt::Context &context, const int numVertices, vk::VkPrimitiveTopology primitive);
void setVertices (const vk::DeviceInterface&vk, std::vector<tcu::Vec4> vertices);
-
+
enum
{
WIDTH = 128,
vk::VkFormat m_ColorAttachmentFormat;
};
-
StateObjects::StateObjects (const vk::DeviceInterface&vk, vkt::Context &context, const int numVertices, vk::VkPrimitiveTopology primitive)
- : m_context(context)
+ : m_context(context)
, m_ColorAttachmentFormat(vk::VK_FORMAT_R8G8B8A8_UNORM)
{
1 // depth;
};
- ImageCreateInfo colorImageCreateInfo(
- vk::VK_IMAGE_TYPE_2D, m_ColorAttachmentFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
- vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
+ const ImageCreateInfo colorImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_ColorAttachmentFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
+ vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
- m_ColorAttachmentImage = Image::createAndAlloc(vk, device, colorImageCreateInfo, m_context.getDefaultAllocator());
+ m_ColorAttachmentImage = Image::createAndAlloc(vk, device, colorImageCreateInfo, m_context.getDefaultAllocator());
- ImageViewCreateInfo attachmentViewInfo(m_ColorAttachmentImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_ColorAttachmentFormat);
- m_AttachmentView = vk::createImageView(vk, device, &attachmentViewInfo);
+ const ImageViewCreateInfo attachmentViewInfo(m_ColorAttachmentImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_ColorAttachmentFormat);
+ m_AttachmentView = vk::createImageView(vk, device, &attachmentViewInfo);
ImageCreateInfo depthImageCreateInfo(vk::VK_IMAGE_TYPE_2D, depthFormat, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
- m_DepthImage = Image::createAndAlloc(vk, device, depthImageCreateInfo, m_context.getDefaultAllocator());
+ m_DepthImage = Image::createAndAlloc(vk, device, depthImageCreateInfo, m_context.getDefaultAllocator());
// Construct a depth view from depth image
- ImageViewCreateInfo depthViewInfo(m_DepthImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, depthFormat);
- m_DepthView = vk::createImageView(vk, device, &depthViewInfo);
+ const ImageViewCreateInfo depthViewInfo(m_DepthImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, depthFormat);
+ m_DepthView = vk::createImageView(vk, device, &depthViewInfo);
}
{
// Renderpass and Framebuffer
RenderPassCreateInfo renderPassCreateInfo;
- renderPassCreateInfo.addAttachment(AttachmentDescription(
- m_ColorAttachmentFormat, // format
- vk::VK_SAMPLE_COUNT_1_BIT, // samples
- vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
- vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
- vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
- vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
- vk::VK_IMAGE_LAYOUT_GENERAL, // initialLauout
- vk::VK_IMAGE_LAYOUT_GENERAL // finalLayout
- ));
-
- renderPassCreateInfo.addAttachment(AttachmentDescription(
- depthFormat, // format
- vk::VK_SAMPLE_COUNT_1_BIT, // samples
- vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
- vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
- vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
- vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
- vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // initialLauout
- vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // finalLayout
- ));
-
- vk::VkAttachmentReference colorAttachmentReference =
+ renderPassCreateInfo.addAttachment(AttachmentDescription(m_ColorAttachmentFormat, // format
+ vk::VK_SAMPLE_COUNT_1_BIT, // samples
+ vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
+ vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
+ vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
+ vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
+ vk::VK_IMAGE_LAYOUT_GENERAL, // initialLauout
+ vk::VK_IMAGE_LAYOUT_GENERAL)); // finalLayout
+
+ renderPassCreateInfo.addAttachment(AttachmentDescription(depthFormat, // format
+ vk::VK_SAMPLE_COUNT_1_BIT, // samples
+ vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
+ vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
+ vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
+ vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
+ vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // initialLauout
+ vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); // finalLayout
+
+ const vk::VkAttachmentReference colorAttachmentReference =
{
0, // attachment
vk::VK_IMAGE_LAYOUT_GENERAL // layout
};
-
- vk::VkAttachmentReference depthAttachmentReference =
+ const vk::VkAttachmentReference depthAttachmentReference =
{
1, // attachment
vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // layout
};
- renderPassCreateInfo.addSubpass(SubpassDescription(
- vk::VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
- 0, // flags
- 0, // inputCount
- DE_NULL, // pInputAttachments
- 1, // colorCount
- &colorAttachmentReference, // pColorAttachments
- DE_NULL, // pResolveAttachments
- depthAttachmentReference, // depthStencilAttachment
- 0, // preserveCount
- DE_NULL // preserveAttachments
- ));
+ renderPassCreateInfo.addSubpass(SubpassDescription(vk::VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
+ 0, // flags
+ 0, // inputCount
+ DE_NULL, // pInputAttachments
+ 1, // colorCount
+ &colorAttachmentReference, // pColorAttachments
+ DE_NULL, // pResolveAttachments
+ depthAttachmentReference, // depthStencilAttachment
+ 0, // preserveCount
+ DE_NULL)); // preserveAttachments
m_RenderPass = vk::createRenderPass(vk, device, &renderPassCreateInfo);
attachments[0] = *m_AttachmentView;
attachments[1] = *m_DepthView;
- FramebufferCreateInfo framebufferCreateInfo(*m_RenderPass, attachments, WIDTH, HEIGHT, 0);
+ FramebufferCreateInfo framebufferCreateInfo(*m_RenderPass, attachments, WIDTH, HEIGHT, 1);
m_Framebuffer = vk::createFramebuffer(vk, device, &framebufferCreateInfo);
}
vk::Unique<vk::VkShaderModule> vs(vk::createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
vk::Unique<vk::VkShaderModule> fs(vk::createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
- PipelineCreateInfo::ColorBlendState::Attachment attachmentState;
-
+ const PipelineCreateInfo::ColorBlendState::Attachment attachmentState;
- PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
+ const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
m_PipelineLayout = vk::createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
- vk::VkVertexInputBindingDescription vf_binding_desc = {
- 0, // binding;
- 4 * sizeof(float), // stride;
- vk::VK_VERTEX_INPUT_RATE_VERTEX // inputRate
- };
-
- vk::VkVertexInputAttributeDescription vf_attribute_desc = {
- 0, // location;
- 0, // binding;
- vk::VK_FORMAT_R32G32B32A32_SFLOAT, // format;
- 0 // offset;
- };
-
- vk::VkPipelineVertexInputStateCreateInfo vf_info = { // sType;
- vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // pNext;
- NULL, // flags;
- 0u, // vertexBindingDescriptionCount;
- 1, // pVertexBindingDescriptions;
- &vf_binding_desc, // vertexAttributeDescriptionCount;
- 1, // pVertexAttributeDescriptions;
- &vf_attribute_desc
- };
+ const vk::VkVertexInputBindingDescription vf_binding_desc =
+ {
+ 0, // binding;
+ 4 * sizeof(float), // stride;
+ vk::VK_VERTEX_INPUT_RATE_VERTEX // inputRate
+ };
+
+ const vk::VkVertexInputAttributeDescription vf_attribute_desc =
+ {
+ 0, // location;
+ 0, // binding;
+ vk::VK_FORMAT_R32G32B32A32_SFLOAT, // format;
+ 0 // offset;
+ };
+
+ const vk::VkPipelineVertexInputStateCreateInfo vf_info =
+ { // sType;
+ vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // pNext;
+ NULL, // flags;
+ 0u, // vertexBindingDescriptionCount;
+ 1, // pVertexBindingDescriptions;
+ &vf_binding_desc, // vertexAttributeDescriptionCount;
+ 1, // pVertexAttributeDescriptions;
+ &vf_attribute_desc
+ };
PipelineCreateInfo pipelineCreateInfo(*m_PipelineLayout, *m_RenderPass, 0, 0);
pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", vk::VK_SHADER_STAGE_VERTEX_BIT));
pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", vk::VK_SHADER_STAGE_FRAGMENT_BIT));
pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(primitive));
pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &attachmentState));
- vk::VkViewport viewport = {
- 0, // float x;
- 0, // float y;
- WIDTH, // float width;
- HEIGHT, // float height;
- 0.0f, // float minDepth;
- 1.0f // float maxDepth;
- };
-
- vk::VkRect2D scissor = {
- {
- 0, // deInt32 x
- 0, // deInt32 y
- }, // VkOffset2D offset;
- {
- WIDTH, // deInt32 width;
- HEIGHT, // deInt32 height
- }, // VkExtent2D extent;
- };
+ const vk::VkViewport viewport =
+ {
+ 0, // float x;
+ 0, // float y;
+ WIDTH, // float width;
+ HEIGHT, // float height;
+ 0.0f, // float minDepth;
+ 1.0f // float maxDepth;
+ };
+
+ const vk::VkRect2D scissor =
+ {
+ {
+ 0, // deInt32 x
+ 0, // deInt32 y
+ }, // VkOffset2D offset;
+ {
+ WIDTH, // deInt32 width;
+ HEIGHT, // deInt32 height
+ }, // VkExtent2D extent;
+ };
pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, std::vector<vk::VkViewport>(1, viewport), std::vector<vk::VkRect2D>(1, scissor)));
pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState(true, true, vk::VK_COMPARE_OP_GREATER_OR_EQUAL));
pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
WAIT_NONE
};
-enum OcclusionQueryResultsMode
+enum OcclusionQueryResultsMode
{
RESULTS_MODE_GET,
RESULTS_MODE_COPY
vk::VkPrimitiveTopology primitiveRopology;
};
-
class BasicOcclusionQueryTestInstance : public vkt::TestInstance
{
public:
private:
tcu::TestStatus iterate (void);
- static const int kNumQueriesInPool = 2;
- static const int kQueryIndexCaptureEmpty = 0;
- static const int kQueryIndexCaptureDrawcall = 1;
- static const int kNumVerticesInDrawCall = 3;
+ enum
+ {
+ NUM_QUERIES_IN_POOL = 2,\r
+ QUERY_INDEX_CAPTURE_EMPTY = 0,\r
+ QUERY_INDEX_CAPTURE_DRAWCALL = 1,\r
+ NUM_VERTICES_IN_DRAWCALL = 3
+ };
OcclusionQueryTestVector m_testVector;
StateObjects* m_stateObjects;
BasicOcclusionQueryTestInstance::BasicOcclusionQueryTestInstance (vkt::Context &context, const OcclusionQueryTestVector& testVector)
: TestInstance (context)
, m_testVector (testVector)
- , m_stateObjects (new StateObjects(m_context.getDeviceInterface(), m_context, kNumVerticesInDrawCall, m_testVector.primitiveRopology))
+ , m_stateObjects (new StateObjects(m_context.getDeviceInterface(), m_context, NUM_VERTICES_IN_DRAWCALL, m_testVector.primitiveRopology))
{
DE_ASSERT(testVector.queryResultSize == RESULT_SIZE_64_BIT
&& testVector.queryWait == WAIT_QUEUE
const vk::VkDevice device = m_context.getDevice();
const vk::DeviceInterface& vk = m_context.getDeviceInterface();
- vk::VkQueryPoolCreateInfo queryPoolCreateInfo =
+ const vk::VkQueryPoolCreateInfo queryPoolCreateInfo =
{
vk::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
DE_NULL,
0u,
vk::VK_QUERY_TYPE_OCCLUSION,
- kNumQueriesInPool,
+ NUM_QUERIES_IN_POOL,
0
};
VK_CHECK(vk.createQueryPool(device, &queryPoolCreateInfo, /*pAllocator*/ DE_NULL, &m_queryPool));
- std::vector<tcu::Vec4> vertices(kNumVerticesInDrawCall);
+ std::vector<tcu::Vec4> vertices(NUM_VERTICES_IN_DRAWCALL);
vertices[0] = tcu::Vec4(0.5, 0.5, 0.0, 1.0);
vertices[1] = tcu::Vec4(0.5, 0.0, 0.0, 1.0);
vertices[2] = tcu::Vec4(0.0, 0.5, 0.0, 1.0);
std::vector<vk::VkClearValue> renderPassClearValues(2);
deMemset(&renderPassClearValues[0], static_cast<int>(renderPassClearValues.size()) * sizeof(vk::VkClearValue), 0);
- vk::VkRect2D renderArea = {
- { 0, 0 },
- { StateObjects::WIDTH, StateObjects::HEIGHT }
+ const vk::VkRect2D renderArea =
+ {
+ { 0, 0 },
+ { StateObjects::WIDTH, StateObjects::HEIGHT }
};
+
RenderPassBeginInfo renderPassBegin(*m_stateObjects->m_RenderPass, *m_stateObjects->m_Framebuffer, renderArea, renderPassClearValues);
vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBegin, vk::VK_SUBPASS_CONTENTS_INLINE);
const vk::VkDeviceSize vertexBufferOffset = 0;
vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
- vk.cmdResetQueryPool(*cmdBuffer, m_queryPool, 0, kNumQueriesInPool);
+ vk.cmdResetQueryPool(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL);
- vk.cmdBeginQuery(*cmdBuffer, m_queryPool, kQueryIndexCaptureEmpty, m_testVector.queryControlFlags);
- vk.cmdEndQuery(*cmdBuffer, m_queryPool, kQueryIndexCaptureEmpty);
+ vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_EMPTY, m_testVector.queryControlFlags);
+ vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_EMPTY);
- vk.cmdBeginQuery(*cmdBuffer, m_queryPool, kQueryIndexCaptureDrawcall, m_testVector.queryControlFlags);
- vk.cmdDraw(*cmdBuffer, kNumVerticesInDrawCall, 1, 0, 0);
- vk.cmdEndQuery(*cmdBuffer, m_queryPool, kQueryIndexCaptureDrawcall);
+ vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_DRAWCALL, m_testVector.queryControlFlags);
+ vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_DRAWCALL, 1, 0, 0);
+ vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_DRAWCALL);
vk.cmdEndRenderPass(*cmdBuffer);
vk.endCommandBuffer(*cmdBuffer);
// Submit command buffer
- vk::VkSubmitInfo submitInfo =
+ const vk::VkSubmitInfo submitInfo =
{
vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- 1, // deUint32 commandBufferCount;
+ 0, // deUint32 waitSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ 1, // deUint32 commandBufferCount;
&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
+ 0, // deUint32 signalSemaphoreCount;
DE_NULL // const VkSemaphore* pSignalSemaphores;
};
vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
VK_CHECK(vk.queueWaitIdle(queue));
- deUint64 queryResults[kNumQueriesInPool] = { 0 };
- size_t queryResultsSize = sizeof(queryResults);
+ deUint64 queryResults[NUM_QUERIES_IN_POOL] = { 0 };
+ size_t queryResultsSize = sizeof(queryResults);
- vk::VkResult queryResult = vk.getQueryPoolResults(device, m_queryPool, 0, kNumQueriesInPool, queryResultsSize, queryResults, sizeof(queryResults[0]), vk::VK_QUERY_RESULT_64_BIT);
+ vk::VkResult queryResult = vk.getQueryPoolResults(device, m_queryPool, 0, NUM_QUERIES_IN_POOL, queryResultsSize, queryResults, sizeof(queryResults[0]), vk::VK_QUERY_RESULT_64_BIT);
- if (queryResult == vk::VK_NOT_READY) {
+ if (queryResult == vk::VK_NOT_READY)
+ {
TCU_FAIL("Query result not avaliable, but vkWaitIdle() was called.");
}
log << tcu::TestLog::Section("OcclusionQueryResults",
"Occlusion query results");
- for (int i = 0; i < DE_LENGTH_OF_ARRAY(queryResults); ++i) {
- log << tcu::TestLog::Message << "query[ slot == " << i
- << "] result == " << queryResults[i] << tcu::TestLog::EndMessage;
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(queryResults); ++ndx)
+ {
+ log << tcu::TestLog::Message << "query[ slot == " << ndx
+ << "] result == " << queryResults[ndx] << tcu::TestLog::EndMessage;
}
- qpTestResult result = QP_TEST_RESULT_PASS;
+ bool passed = true;
+
+ for (int queryNdx = 0; queryNdx < DE_LENGTH_OF_ARRAY(queryResults); ++queryNdx)
+ {
- for (int i = 0; i < DE_LENGTH_OF_ARRAY(queryResults); ++i) {
-
deUint64 expectedValue;
- switch (i) {
- case kQueryIndexCaptureEmpty:
+ switch (queryNdx)
+ {
+ case QUERY_INDEX_CAPTURE_EMPTY:
expectedValue = 0;
break;
- case kQueryIndexCaptureDrawcall:
- expectedValue = kNumVerticesInDrawCall;
+ case QUERY_INDEX_CAPTURE_DRAWCALL:
+ expectedValue = NUM_VERTICES_IN_DRAWCALL;
break;
}
- if ((m_testVector.queryControlFlags & vk::VK_QUERY_CONTROL_PRECISE_BIT) || expectedValue == 0) {
+ if ((m_testVector.queryControlFlags & vk::VK_QUERY_CONTROL_PRECISE_BIT) || expectedValue == 0)
+ {
// require precise value
- if (queryResults[i] != expectedValue) {
+ if (queryResults[queryNdx] != expectedValue)
+ {
log << tcu::TestLog::Message << "vkGetQueryPoolResults returned "
"wrong value of query for index "
- << i << ", expected " << expectedValue << ", got "
+ << queryNdx << ", expected " << expectedValue << ", got "
<< queryResults[0] << "." << tcu::TestLog::EndMessage;
- result = QP_TEST_RESULT_FAIL;
+ passed = false;
}
}
- else {
+ else
+ {
// require imprecize value > 0
- if (queryResults[i] == 0) {
+ if (queryResults[queryNdx] == 0)
+ {
log << tcu::TestLog::Message << "vkGetQueryPoolResults returned "
"wrong value of query for index "
- << i << ", expected any non-zero value, got "
+ << queryNdx << ", expected any non-zero value, got "
<< queryResults[0] << "." << tcu::TestLog::EndMessage;
- result = QP_TEST_RESULT_FAIL;
+ passed = false;
}
}
}
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
-
tcu::ConstPixelBufferAccess resultImageAccess = m_stateObjects->m_ColorAttachmentImage->readSurface(
queue, m_context.getDefaultAllocator(), vk::VK_IMAGE_LAYOUT_GENERAL,
zeroOffset, StateObjects::HEIGHT, StateObjects::WIDTH, vk::VK_IMAGE_ASPECT_COLOR_BIT);
log << tcu::TestLog::Image("Result", "Result", resultImageAccess);
- return tcu::TestStatus(result, qpGetTestResultName(result));
+ if (passed)
+ {
+ return tcu::TestStatus(QP_TEST_RESULT_PASS, "Query result verification passed");
+ }
+ return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Query result verification failed");
}
-
class OcclusionQueryTestInstance : public vkt::TestInstance
{
public:
void captureResults (deUint64* retResults, deUint64* retAvailability, bool allowNotReady);
void logResults (const deUint64* results, const deUint64* availability);
- qpTestResult validateResults (const deUint64* results, const deUint64* availability, bool allowUnavailable, vk::VkPrimitiveTopology primitiveTopology);
+ bool validateResults (const deUint64* results, const deUint64* availability, bool allowUnavailable, vk::VkPrimitiveTopology primitiveTopology);
void logRenderTarget (void);
- static const int kNumQueriesInPool = 3;
- static const int kQueryIndexCaptureAll = 0;
- static const int kQueryIndexCapturePartiallyOccluded = 1;
- static const int kQueryIndexCaptureOccluded = 2;
-
- static const int kNumVerticesInDrawCall = 3;
- static const int kNumVerticesInPartialOccludeDrawCall = 3;
- static const int kNumVerticesInOccludeDrawCall = 3;
- static const int kNumVertices = kNumVerticesInDrawCall + kNumVerticesInPartialOccludeDrawCall + kNumVerticesInOccludeDrawCall;
- static const int kStartVertex = 0;
- static const int kPartialOccludeCallStartVertex = kStartVertex + kNumVerticesInDrawCall;
- static const int kOccludeStartVertex = kPartialOccludeCallStartVertex + kNumVerticesInPartialOccludeDrawCall;
+ enum
+ {
+ NUM_QUERIES_IN_POOL = 3,\r
+ QUERY_INDEX_CAPTURE_ALL = 0,\r
+ QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED = 1,\r
+ QUERY_INDEX_CAPTURE_OCCLUDED = 2
+ };
+ enum
+ {
+ NUM_VERTICES_IN_DRAWCALL = 3,\r
+ NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL = 3,\r
+ NUM_VERTICES_IN_OCCLUDER_DRAWCALL = 3,\r
+ NUM_VERTICES = NUM_VERTICES_IN_DRAWCALL + NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL + NUM_VERTICES_IN_OCCLUDER_DRAWCALL\r
+ };\r
+ enum\r
+ {\r
+ START_VERTEX = 0,\r
+ START_VERTEX_PARTIALLY_OCCLUDED = START_VERTEX + NUM_VERTICES_IN_DRAWCALL,\r
+ START_VERTEX_OCCLUDER = START_VERTEX_PARTIALLY_OCCLUDED + NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL
+ };
OcclusionQueryTestVector m_testVector;
OcclusionQueryTestInstance::OcclusionQueryTestInstance (vkt::Context &context, const OcclusionQueryTestVector& testVector)
: vkt::TestInstance (context)
, m_testVector (testVector)
- , m_stateObjects (new StateObjects(m_context.getDeviceInterface(), m_context, kNumVerticesInDrawCall + kNumVerticesInPartialOccludeDrawCall + kNumVerticesInOccludeDrawCall, m_testVector.primitiveRopology))
+ , m_stateObjects (new StateObjects(m_context.getDeviceInterface(), m_context, NUM_VERTICES_IN_DRAWCALL + NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL + NUM_VERTICES_IN_OCCLUDER_DRAWCALL, m_testVector.primitiveRopology))
, m_queryResultFlags ((m_testVector.queryWait == WAIT_QUERY ? vk::VK_QUERY_RESULT_WAIT_BIT : 0)
| (m_testVector.queryResultSize == RESULT_SIZE_64_BIT ? vk::VK_QUERY_RESULT_64_BIT : 0)
| (m_testVector.queryResultsAvailability ? vk::VK_QUERY_RESULT_WITH_AVAILABILITY_BIT : 0))
const vk::VkDevice device = m_context.getDevice();
const vk::DeviceInterface& vk = m_context.getDeviceInterface();
- vk::VkQueryPoolCreateInfo queryPoolCreateInfo = {
- vk::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
- DE_NULL,
- 0u,
- vk::VK_QUERY_TYPE_OCCLUSION,
- kNumQueriesInPool,
- 0
- };
+ const vk::VkQueryPoolCreateInfo queryPoolCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
+ DE_NULL,
+ 0u,
+ vk::VK_QUERY_TYPE_OCCLUSION,
+ NUM_QUERIES_IN_POOL,
+ 0
+ };
VK_CHECK(vk.createQueryPool(device, &queryPoolCreateInfo, /*pAllocator*/ DE_NULL, &m_queryPool));
-
+
if (m_testVector.queryResultsMode == RESULTS_MODE_COPY)
{
- const vk::VkDeviceSize resultsBufferSize = m_testVector.queryResultsStride * kNumQueriesInPool;
+ const vk::VkDeviceSize resultsBufferSize = m_testVector.queryResultsStride * NUM_QUERIES_IN_POOL;
m_queryPoolResultsBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(resultsBufferSize, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT), m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible);
}
-
+
const CmdPoolCreateInfo cmdPoolCreateInfo (m_context.getUniversalQueueFamilyIndex());
m_commandPool = vk::createCommandPool(vk, device, &cmdPoolCreateInfo);
m_renderCommandBuffer = recordRender(*m_commandPool);
delete m_stateObjects;
if (m_queryPool != DE_NULL)
- {
+ {
const vk::DeviceInterface& vk = m_context.getDeviceInterface();
vk.destroyQueryPool(device, m_queryPool, /*pAllocator*/ DE_NULL);
}
const vk::VkQueue queue = m_context.getUniversalQueue();
const vk::DeviceInterface& vk = m_context.getDeviceInterface();
tcu::TestLog& log = m_context.getTestContext().getLog();
- std::vector<tcu::Vec4> vertices (kNumVertices);
+ std::vector<tcu::Vec4> vertices (NUM_VERTICES);
// 1st triangle
- vertices[kStartVertex + 0] = tcu::Vec4( 0.5, 0.5, 0.5, 1.0);
- vertices[kStartVertex + 1] = tcu::Vec4( 0.5, -0.5, 0.5, 1.0);
- vertices[kStartVertex + 2] = tcu::Vec4(-0.5, 0.5, 0.5, 1.0);
+ vertices[START_VERTEX + 0] = tcu::Vec4( 0.5, 0.5, 0.5, 1.0);
+ vertices[START_VERTEX + 1] = tcu::Vec4( 0.5, -0.5, 0.5, 1.0);
+ vertices[START_VERTEX + 2] = tcu::Vec4(-0.5, 0.5, 0.5, 1.0);
// 2nd triangle - partially occluding the scene
- vertices[kPartialOccludeCallStartVertex + 0] = tcu::Vec4(-0.5, -0.5, 1.0, 1.0);
- vertices[kPartialOccludeCallStartVertex + 1] = tcu::Vec4( 0.5, -0.5, 1.0, 1.0);
- vertices[kPartialOccludeCallStartVertex + 2] = tcu::Vec4(-0.5, 0.5, 1.0, 1.0);
+ vertices[START_VERTEX_PARTIALLY_OCCLUDED + 0] = tcu::Vec4(-0.5, -0.5, 1.0, 1.0);
+ vertices[START_VERTEX_PARTIALLY_OCCLUDED + 1] = tcu::Vec4( 0.5, -0.5, 1.0, 1.0);
+ vertices[START_VERTEX_PARTIALLY_OCCLUDED + 2] = tcu::Vec4(-0.5, 0.5, 1.0, 1.0);
// 3nd triangle - fully occluding the scene
- vertices[kOccludeStartVertex + 0] = tcu::Vec4( 0.5, 0.5, 1.0, 1.0);
- vertices[kOccludeStartVertex + 1] = tcu::Vec4( 0.5, -0.5, 1.0, 1.0);
- vertices[kOccludeStartVertex + 2] = tcu::Vec4(-0.5, 0.5, 1.0, 1.0);
+ vertices[START_VERTEX_OCCLUDER + 0] = tcu::Vec4( 0.5, 0.5, 1.0, 1.0);
+ vertices[START_VERTEX_OCCLUDER + 1] = tcu::Vec4( 0.5, -0.5, 1.0, 1.0);
+ vertices[START_VERTEX_OCCLUDER + 2] = tcu::Vec4(-0.5, 0.5, 1.0, 1.0);
m_stateObjects->setVertices(vk, vertices);
- vk::VkSubmitInfo submitInfo =
+ const vk::VkSubmitInfo submitInfo =
{
vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- 1, // deUint32 commandBufferCount;
+ 0, // deUint32 waitSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ 1, // deUint32 commandBufferCount;
&m_renderCommandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
+ 0, // deUint32 signalSemaphoreCount;
DE_NULL // const VkSemaphore* pSignalSemaphores;
};
vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
if (m_testVector.queryResultsMode == RESULTS_MODE_COPY)
{
- vk::VkSubmitInfo submitInfo =
+ // In case of WAIT_QUEUE test variant, the previously submitted m_renderCommandBuffer did not
+ // contain vkCmdCopyQueryResults, so additional cmd buffer is needed.
+
+ // In the case of WAIT_NONE or WAIT_QUERY, vkCmdCopyQueryResults is stored in m_renderCommandBuffer.
+
+ const vk::VkSubmitInfo submitInfo =
{
vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- 1, // deUint32 commandBufferCount;
+ 0, // deUint32 waitSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ 1, // deUint32 commandBufferCount;
&m_copyResultsCommandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
+ 0, // deUint32 signalSemaphoreCount;
DE_NULL // const VkSemaphore* pSignalSemaphores;
};
vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
}
}
- deUint64 queryResults [kNumQueriesInPool];
- deUint64 queryAvailability [kNumQueriesInPool];
+ deUint64 queryResults [NUM_QUERIES_IN_POOL];
+ deUint64 queryAvailability [NUM_QUERIES_IN_POOL];
captureResults(queryResults, queryAvailability, m_testVector.queryWait == WAIT_NONE);
log << tcu::TestLog::Section("OcclusionQueryResults", "Occlusion query results");
logResults(queryResults, queryAvailability);
- qpTestResult result = validateResults(queryResults, queryAvailability, m_testVector.queryWait == WAIT_NONE, m_testVector.primitiveRopology);
+ bool passed = validateResults(queryResults, queryAvailability, m_testVector.queryWait == WAIT_NONE, m_testVector.primitiveRopology);
log << tcu::TestLog::EndSection;
logRenderTarget();
- return tcu::TestStatus(result, qpGetTestResultName(result));
+ if (passed)
+ {
+ return tcu::TestStatus(QP_TEST_RESULT_PASS, "Query result verification passed");
+ }
+ return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Query result verification failed");
}
vk::Move<vk::VkCommandBuffer> OcclusionQueryTestInstance::recordRender (vk::VkCommandPool cmdPool)
std::vector<vk::VkClearValue> renderPassClearValues(2);
deMemset(&renderPassClearValues[0], static_cast<int>(renderPassClearValues.size()) * sizeof(vk::VkClearValue), 0);
- vk::VkRect2D renderArea = {
- { 0, 0 },
- { StateObjects::WIDTH, StateObjects::HEIGHT }
- };
+
+ const vk::VkRect2D renderArea =
+ {
+ { 0, 0 },
+ { StateObjects::WIDTH, StateObjects::HEIGHT }
+ };
RenderPassBeginInfo renderPassBegin(*m_stateObjects->m_RenderPass, *m_stateObjects->m_Framebuffer, renderArea, renderPassClearValues);
const vk::VkDeviceSize vertexBufferOffset = 0;
vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
- vk.cmdResetQueryPool(*cmdBuffer, m_queryPool, 0, kNumQueriesInPool);
+ vk.cmdResetQueryPool(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL);
// Draw un-occluded geometry
- vk.cmdBeginQuery(*cmdBuffer, m_queryPool, kQueryIndexCaptureAll, m_testVector.queryControlFlags);
- vk.cmdDraw(*cmdBuffer, kNumVerticesInDrawCall, 1, kStartVertex, 0);
- vk.cmdEndQuery(*cmdBuffer, m_queryPool, kQueryIndexCaptureAll);
+ vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_ALL, m_testVector.queryControlFlags);
+ vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_DRAWCALL, 1, START_VERTEX, 0);
+ vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_ALL);
// Partially occlude geometry
- vk.cmdDraw(*cmdBuffer, kNumVerticesInPartialOccludeDrawCall, 1, kPartialOccludeCallStartVertex, 0);
+ vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_PARTIALLY_OCCLUDED_DRAWCALL, 1, START_VERTEX_PARTIALLY_OCCLUDED, 0);
// Draw partially-occluded geometry
- vk.cmdBeginQuery(*cmdBuffer, m_queryPool, kQueryIndexCapturePartiallyOccluded, m_testVector.queryControlFlags);
- vk.cmdDraw(*cmdBuffer, kNumVerticesInDrawCall, 1, kStartVertex, 0);
- vk.cmdEndQuery(*cmdBuffer, m_queryPool, kQueryIndexCapturePartiallyOccluded);
+ vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED, m_testVector.queryControlFlags);
+ vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_DRAWCALL, 1, START_VERTEX, 0);
+ vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED);
// Occlude geometry
- vk.cmdDraw(*cmdBuffer, kNumVerticesInOccludeDrawCall, 1, kOccludeStartVertex, 0);
+ vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_OCCLUDER_DRAWCALL, 1, START_VERTEX_OCCLUDER, 0);
// Draw occluded geometry
- vk.cmdBeginQuery(*cmdBuffer, m_queryPool, kQueryIndexCaptureOccluded, m_testVector.queryControlFlags);
- vk.cmdDraw(*cmdBuffer, kNumVerticesInDrawCall, 1, kStartVertex, 0);
- vk.cmdEndQuery(*cmdBuffer, m_queryPool, kQueryIndexCaptureOccluded);
+ vk.cmdBeginQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_OCCLUDED, m_testVector.queryControlFlags);
+ vk.cmdDraw(*cmdBuffer, NUM_VERTICES_IN_DRAWCALL, 1, START_VERTEX, 0);
+ vk.cmdEndQuery(*cmdBuffer, m_queryPool, QUERY_INDEX_CAPTURE_OCCLUDED);
if (m_testVector.queryWait != WAIT_QUEUE )
{
//For WAIT_QUEUE another cmdBuffer is issued with cmdCopyQueryPoolResults
if (m_testVector.queryResultsMode == RESULTS_MODE_COPY)
{
- vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, kNumQueriesInPool, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
+ vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
}
}
const CmdBufferBeginInfo beginInfo (DE_NULL, 0, DE_NULL, 0u, true, m_testVector.queryControlFlags);
vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
- vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, kNumQueriesInPool, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
+ vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
vk.endCommandBuffer(*cmdBuffer);
return cmdBuffer;
}
-
void OcclusionQueryTestInstance::captureResults (deUint64* retResults, deUint64* retAvailAbility, bool allowNotReady)
{
const vk::VkDevice device = m_context.getDevice();
const vk::DeviceInterface& vk = m_context.getDeviceInterface();
- std::vector<deUint8> resultsBuffer (m_testVector.queryResultsStride * kNumQueriesInPool);
+ std::vector<deUint8> resultsBuffer (m_testVector.queryResultsStride * NUM_QUERIES_IN_POOL);
if (m_testVector.queryResultsMode == RESULTS_MODE_GET)
{
- const vk::VkResult queryResult = vk.getQueryPoolResults(device, m_queryPool, 0, kNumQueriesInPool, resultsBuffer.size(), &resultsBuffer[0], m_testVector.queryResultsStride, m_queryResultFlags);
+ const vk::VkResult queryResult = vk.getQueryPoolResults(device, m_queryPool, 0, NUM_QUERIES_IN_POOL, resultsBuffer.size(), &resultsBuffer[0], m_testVector.queryResultsStride, m_queryResultFlags);
if (queryResult == vk::VK_NOT_READY && !allowNotReady)
{
TCU_FAIL("getQueryPoolResults returned VK_NOT_READY, but results should be already available.");
deMemcpy(&resultsBuffer[0], allocationData, resultsBuffer.size());
}
-
- for (int i = 0; i < kNumQueriesInPool; i++)
+ for (int queryNdx = 0; queryNdx < NUM_QUERIES_IN_POOL; queryNdx++)
{
- const void* srcPtr = &resultsBuffer[i * m_testVector.queryResultsStride];
+ const void* srcPtr = &resultsBuffer[queryNdx * m_testVector.queryResultsStride];
if (m_testVector.queryResultSize == RESULT_SIZE_32_BIT)
{
const deUint32* srcPtrTyped = static_cast<const deUint32*>(srcPtr);
- retResults[i] = *srcPtrTyped;
+ retResults[queryNdx] = *srcPtrTyped;
if (m_testVector.queryResultsAvailability)
{
- retAvailAbility[i] = *(srcPtrTyped + 1);
+ retAvailAbility[queryNdx] = *(srcPtrTyped + 1);
}
}
else if (m_testVector.queryResultSize == RESULT_SIZE_64_BIT)
{
const deUint64* srcPtrTyped = static_cast<const deUint64*>(srcPtr);
- retResults[i] = *srcPtrTyped;
+ retResults[queryNdx] = *srcPtrTyped;
if (m_testVector.queryResultsAvailability)
{
if (m_testVector.queryResultsAvailability)
{
- retAvailAbility[i] = *(srcPtrTyped + 1);
+ retAvailAbility[queryNdx] = *(srcPtrTyped + 1);
}
}
}
{
tcu::TestLog& log = m_context.getTestContext().getLog();
- for (int i = 0; i < kNumQueriesInPool; ++i)
+ for (int ndx = 0; ndx < NUM_QUERIES_IN_POOL; ++ndx)
{
if (!m_testVector.queryResultsAvailability)
{
- log << tcu::TestLog::Message << "query[ slot == " << i << "] result == " << results[i] << tcu::TestLog::EndMessage;
+ log << tcu::TestLog::Message << "query[ slot == " << ndx << "] result == " << results[ndx] << tcu::TestLog::EndMessage;
}
else
{
- log << tcu::TestLog::Message << "query[ slot == " << i << "] result == " << results[i] << ", availability == " << availability[i] << tcu::TestLog::EndMessage;
+ log << tcu::TestLog::Message << "query[ slot == " << ndx << "] result == " << results[ndx] << ", availability == " << availability[ndx] << tcu::TestLog::EndMessage;
}
}
}
-qpTestResult OcclusionQueryTestInstance::validateResults (const deUint64* results , const deUint64* availability, bool allowUnavailable, vk::VkPrimitiveTopology primitiveTopology)
+bool OcclusionQueryTestInstance::validateResults (const deUint64* results , const deUint64* availability, bool allowUnavailable, vk::VkPrimitiveTopology primitiveTopology)
{
- qpTestResult result = QP_TEST_RESULT_PASS;
+ bool passed = true;
tcu::TestLog& log = m_context.getTestContext().getLog();
- for (int i = 0; i < kNumQueriesInPool; ++i)
+ for (int queryNdx = 0; queryNdx < NUM_QUERIES_IN_POOL; ++queryNdx)
{
deUint64 expectedValueMin = 0;
deUint64 expectedValueMax = 0;
- if (m_testVector.queryResultsAvailability && availability[i] == 0)
+ if (m_testVector.queryResultsAvailability && availability[queryNdx] == 0)
{
// query result was not available
if (!allowUnavailable)
{
log << tcu::TestLog::Message << "query results availability was 0 for index "
- << i << ", expected any value greater than 0." << tcu::TestLog::EndMessage;
- result = QP_TEST_RESULT_FAIL;
+ << queryNdx << ", expected any value greater than 0." << tcu::TestLog::EndMessage;
+ passed = false;
continue;
}
}
// query is available, so expect proper result values
if (primitiveTopology == vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST)
{
- switch (i) {
- case kQueryIndexCaptureOccluded:
+ switch (queryNdx)
+ {
+ case QUERY_INDEX_CAPTURE_OCCLUDED:
expectedValueMin = 0;
expectedValueMax = 0;
break;
- case kQueryIndexCapturePartiallyOccluded:
+ case QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED:
expectedValueMin = 1;
expectedValueMax = 1;
break;
- case kQueryIndexCaptureAll:
- expectedValueMin = kNumVerticesInDrawCall;
- expectedValueMax = kNumVerticesInDrawCall;
+ case QUERY_INDEX_CAPTURE_ALL:
+ expectedValueMin = NUM_VERTICES_IN_DRAWCALL;
+ expectedValueMax = NUM_VERTICES_IN_DRAWCALL;
break;
}
}
else if (primitiveTopology == vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
{
- switch (i) {
- case kQueryIndexCaptureOccluded:
+ switch (queryNdx)
+ {
+ case QUERY_INDEX_CAPTURE_OCCLUDED:
expectedValueMin = 0;
expectedValueMax = 0;
break;
- case kQueryIndexCapturePartiallyOccluded:
- case kQueryIndexCaptureAll:
+ case QUERY_INDEX_CAPTURE_PARTIALLY_OCCLUDED:
+ case QUERY_INDEX_CAPTURE_ALL:
{
const int primWidth = StateObjects::WIDTH / 2;
const int primHeight = StateObjects::HEIGHT / 2;
if ((m_testVector.queryControlFlags & vk::VK_QUERY_CONTROL_PRECISE_BIT) || (expectedValueMin == 0 && expectedValueMax == 0))
{
// require precise value
- if (results[i] < expectedValueMin || results[i] > expectedValueMax) {
+ if (results[queryNdx] < expectedValueMin || results[queryNdx] > expectedValueMax)
+ {
log << tcu::TestLog::Message << "wrong value of query for index "
- << i << ", expected the value minimum of " << expectedValueMin << ", maximum of " << expectedValueMax << " got "
- << results[i] << "." << tcu::TestLog::EndMessage;
- result = QP_TEST_RESULT_FAIL;
+ << queryNdx << ", expected the value minimum of " << expectedValueMin << ", maximum of " << expectedValueMax << " got "
+ << results[queryNdx] << "." << tcu::TestLog::EndMessage;
+ passed = false;
}
}
else
{
// require imprecise value greater than 0
- if (results[i] == 0)
+ if (results[queryNdx] == 0)
{
log << tcu::TestLog::Message << "wrong value of query for index "
- << i << ", expected any non-zero value, got "
- << results[i] << "." << tcu::TestLog::EndMessage;
- result = QP_TEST_RESULT_FAIL;
+ << queryNdx << ", expected any non-zero value, got "
+ << results[queryNdx] << "." << tcu::TestLog::EndMessage;
+ passed = false;
}
}
}
- return result;
+ return passed;
}
void OcclusionQueryTestInstance::logRenderTarget (void)
"void main() {\n"
" gl_Position = in_Postion;\n"
" gl_PointSize = 1.0;\n"
- "}\n");
+ "}\n");
}
-
OcclusionQueryTestVector m_testVector;
};
} //anonymous
-
namespace vkt
{
void QueryPoolOcclusionTests::init (void)
{
- OcclusionQueryTestVector baseTestVector;
- baseTestVector.queryControlFlags = 0;
+ OcclusionQueryTestVector baseTestVector;
+ baseTestVector.queryControlFlags = 0;
baseTestVector.queryResultSize = RESULT_SIZE_64_BIT;
baseTestVector.queryWait = WAIT_QUEUE;
baseTestVector.queryResultsMode = RESULTS_MODE_GET;
{
vk::VkQueryControlFlags controlFlags[] = { 0, vk::VK_QUERY_CONTROL_PRECISE_BIT };
const char* controlFlagsStr[] = { "conservative", "precise" };
-
+
for (int controlFlagIdx = 0; controlFlagIdx < DE_LENGTH_OF_ARRAY(controlFlags); ++controlFlagIdx)
{
for (int resultSizeIdx = 0; resultSizeIdx < DE_LENGTH_OF_ARRAY(resultSize); ++resultSizeIdx)
{
-
+
OcclusionQueryWait wait[] = { WAIT_QUEUE, WAIT_QUERY };
const char* waitStr[] = { "queue", "query" };
testName << resultsModeStr[resultsModeIdx] << "_results"
<< "_" << controlFlagsStr[controlFlagIdx]
- << "_size_" << resultSizeStr[resultSizeIdx]
- << "_wait_" << waitStr[waitIdx]
+ << "_size_" << resultSizeStr[resultSizeIdx]
+ << "_wait_" << waitStr[waitIdx]
<< "_" << testAvailabilityStr[testAvailabilityIdx] << "_availability"
<< "_draw_" << primitiveTopologyStr[primitiveTopologyIdx];
- testDescr << "draw occluded " << primitiveTopologyStr[primitiveTopologyIdx]
+ testDescr << "draw occluded " << primitiveTopologyStr[primitiveTopologyIdx]
<< "with " << controlFlagsStr[controlFlagIdx] << ", "
<< resultsModeStr[resultsModeIdx] << " results "
- << testAvailabilityStr[testAvailabilityIdx] << " availability bit as "
+ << testAvailabilityStr[testAvailabilityIdx] << " availability bit as "
<< resultSizeStr[resultSizeIdx] << "bit variables,"
<< "wait for results on" << waitStr[waitIdx];
for (int resultsModeIdx = 0; resultsModeIdx < DE_LENGTH_OF_ARRAY(resultsMode); ++resultsModeIdx)
{
- OcclusionQueryResultSize resultSize[] = { RESULT_SIZE_32_BIT, RESULT_SIZE_64_BIT };
+ OcclusionQueryResultSize resultSizes[] = { RESULT_SIZE_32_BIT, RESULT_SIZE_64_BIT };
const char* resultSizeStr[] = { "32", "64" };
bool testAvailability[] = { false, true };
for (int testAvailabilityIdx = 0; testAvailabilityIdx < DE_LENGTH_OF_ARRAY(testAvailability); ++testAvailabilityIdx)
{
- for (int resultSizeIdx = 0; resultSizeIdx < DE_LENGTH_OF_ARRAY(resultSize); ++resultSizeIdx)
+ for (int resultSizeIdx = 0; resultSizeIdx < DE_LENGTH_OF_ARRAY(resultSizes); ++resultSizeIdx)
{
- const vk::VkDeviceSize strides[] = { 4, 5, 8, 9, 13, 1024 };
+ const vk::VkDeviceSize resultSize = (resultSizes[resultSizeIdx] == RESULT_SIZE_32_BIT ? sizeof(deUint32) : sizeof(deUint64));
+
+ // \todo [2015-12-18 scygan] Ensure only stride values aligned to resultSize are allowed. Otherwise test should be extended.
+ const vk::VkDeviceSize strides[] =
+ {
+ 1 * resultSize,
+ 2 * resultSize,
+ 3 * resultSize,
+ 4 * resultSize,
+ 5 * resultSize,
+ 13 * resultSize,
+ 1024 * resultSize
+ };
for (int strideIdx = 0; strideIdx < DE_LENGTH_OF_ARRAY(strides); strideIdx++)
{
OcclusionQueryTestVector testVector = baseTestVector;
testVector.queryResultsMode = resultsMode[resultsModeIdx];
- testVector.queryResultSize = resultSize[resultSizeIdx];
+ testVector.queryResultSize = resultSizes[resultSizeIdx];
testVector.queryResultsAvailability = testAvailability[testAvailabilityIdx];
testVector.queryResultsStride = strides[strideIdx];
- vk::VkDeviceSize elementSize = (testVector.queryResultSize == RESULT_SIZE_32_BIT ? sizeof(deUint32) : sizeof(deUint64));
- if (testVector.queryResultsAvailability)
- {
- elementSize *= 2;
- }
+ const vk::VkDeviceSize elementSize = (testVector.queryResultsAvailability ? resultSize * 2 : resultSize);
if (elementSize > testVector.queryResultsStride)
{
std::ostringstream testName;
std::ostringstream testDescr;
- testName << resultsModeStr[resultsModeIdx]
- << "_results_size_" << resultSizeStr[resultSizeIdx]
- << "_stride_" << strides[strideIdx]
+ testName << resultsModeStr[resultsModeIdx]
+ << "_results_size_" << resultSizeStr[resultSizeIdx]
+ << "_stride_" << strides[strideIdx]
<< "_" << testAvailabilityStr[testAvailabilityIdx] << "_availability";
testDescr << resultsModeStr[resultsModeIdx] << " results "
- << testAvailabilityStr[testAvailabilityIdx] << " availability bit as "
+ << testAvailabilityStr[testAvailabilityIdx] << " availability bit as "
<< resultSizeStr[resultSizeIdx] << "bit variables, with stride" << strides[strideIdx];
addChild(new QueryPoolOcclusionTest<OcclusionQueryTestInstance>(m_testCtx, testName.str().c_str(), testDescr.str().c_str(), testVector));
}
}
}
-
+
}
}
} //QueryPool
} //vkt
-
+#ifndef _VKTQUERYPOOLOCCLUSIONTESTS_HPP
+#define _VKTQUERYPOOLOCCLUSIONTESTS_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
* \brief Vulkan Occlusion Query Tests
*//*--------------------------------------------------------------------*/
-
-#ifndef _VKT_OCCLUSION_QUERY_TEST_HPP
-#define _VKT_OCCLUSION_QUERY_TEST_HPP
-
#include "vktTestCase.hpp"
namespace vkt
} // QueryPool
} // vkt
-#endif // _VKT_OCCLUSION_QUERY_TEST_HPP
+#endif // _VKTQUERYPOOLOCCLUSIONTESTS_HPP
* \brief Vulkan Query Pool Tests
*//*--------------------------------------------------------------------*/\r
\r
-#include "vktQueryPoolTests.hpp"\r
#include "vktQueryPoolTests.hpp"
#include "deUniquePtr.hpp"
#ifndef _VKTQUERYPOOLTESTS_HPP
+#define _VKTQUERYPOOLTESTS_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
#include "vktRenderPassTests.hpp"
#include "vktMemoryTests.hpp"
#include "vktShaderRenderDiscardTests.hpp"
+#include "vktQueryPoolTests.hpp"
#include <vector>
#include <sstream>
addChild(createGlslTests (m_testCtx));
addChild(createRenderPassTests (m_testCtx));
addChild(memory::createTests (m_testCtx));
+ addChild(QueryPool::createTests (m_testCtx));
}
} // vkt
projects / platform / upstream / VK-GL-CTS.git / commitdiff