*
* Copyright (c) 2015 The Khronos Group Inc.
* Copyright (c) 2015 Imagination Technologies Ltd.
+ * Copyright (c) 2017 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "vktPipelineMultisampleTests.hpp"
#include "vktPipelineMultisampleImageTests.hpp"
+#include "vktPipelineMultisampleSampleLocationsExtTests.hpp"
#include "vktPipelineClearUtil.hpp"
#include "vktPipelineImageUtil.hpp"
#include "vktPipelineVertexUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkPrograms.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "tcuImageCompare.hpp"
RENDER_TYPE_COPY_SAMPLES
};
-void initMultisamplePrograms (SourceCollections& sources, GeometryType geometryType);
+enum ImageBackingMode
+{
+ IMAGE_BACKING_MODE_REGULAR = 0u,
+ IMAGE_BACKING_MODE_SPARSE
+};
+
+struct MultisampleTestParams
+{
+ GeometryType geometryType;
+ ImageBackingMode backingMode;
+};
+
+void initMultisamplePrograms (SourceCollections& sources, MultisampleTestParams params);
bool isSupportedSampleCount (const InstanceInterface& instanceInterface, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits rasterizationSamples);
bool isSupportedDepthStencilFormat (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkFormat format);
VkPipelineColorBlendAttachmentState getDefaultColorBlendAttachmentState (void);
const std::string& description,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- GeometryType geometryType);
+ GeometryType geometryType,
+ ImageBackingMode backingMode);
virtual ~MultisampleTest (void) {}
virtual void initPrograms (SourceCollections& programCollection) const;
VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
const VkPipelineColorBlendAttachmentState m_colorBlendState;
const GeometryType m_geometryType;
+ const ImageBackingMode m_backingMode;
std::vector<VkSampleMask> m_sampleMask;
};
const std::string& description,
VkSampleCountFlagBits rasterizationSamples,
GeometryType geometryType,
+ ImageBackingMode backingMode,
TestModeFlags modeFlags = 0u);
virtual ~RasterizationSamplesTest (void) {}
static VkPipelineMultisampleStateCreateInfo getRasterizationSamplesStateParams (VkSampleCountFlagBits rasterizationSamples);
+ const ImageBackingMode m_backingMode;
const TestModeFlags m_modeFlags;
};
const std::string& description,
VkSampleCountFlagBits rasterizationSamples,
float minSampleShading,
- GeometryType geometryType);
+ GeometryType geometryType,
+ ImageBackingMode backingMode);
virtual ~MinSampleShadingTest (void) {}
protected:
const VkPipelineColorBlendAttachmentState& colorBlendState) const;
static VkPipelineMultisampleStateCreateInfo getMinSampleShadingStateParams (VkSampleCountFlagBits rasterizationSamples, float minSampleShading);
+
+ const ImageBackingMode m_backingMode;
};
class SampleMaskTest : public MultisampleTest
const std::string& description,
VkSampleCountFlagBits rasterizationSamples,
const std::vector<VkSampleMask>& sampleMask,
- GeometryType geometryType);
+ GeometryType geometryType,
+ ImageBackingMode backingMode);
virtual ~SampleMaskTest (void) {}
const VkPipelineColorBlendAttachmentState& colorBlendState) const;
static VkPipelineMultisampleStateCreateInfo getSampleMaskStateParams (VkSampleCountFlagBits rasterizationSamples, const std::vector<VkSampleMask>& sampleMask);
+
+ const ImageBackingMode m_backingMode;
};
class AlphaToOneTest : public MultisampleTest
AlphaToOneTest (tcu::TestContext& testContext,
const std::string& name,
const std::string& description,
- VkSampleCountFlagBits rasterizationSamples);
+ VkSampleCountFlagBits rasterizationSamples,
+ ImageBackingMode backingMode);
virtual ~AlphaToOneTest (void) {}
static VkPipelineMultisampleStateCreateInfo getAlphaToOneStateParams (VkSampleCountFlagBits rasterizationSamples);
static VkPipelineColorBlendAttachmentState getAlphaToOneBlendState (void);
+
+ const ImageBackingMode m_backingMode;
};
class AlphaToCoverageTest : public MultisampleTest
const std::string& name,
const std::string& description,
VkSampleCountFlagBits rasterizationSamples,
- GeometryType geometryType);
+ GeometryType geometryType,
+ ImageBackingMode backingMode);
virtual ~AlphaToCoverageTest (void) {}
static VkPipelineMultisampleStateCreateInfo getAlphaToCoverageStateParams (VkSampleCountFlagBits rasterizationSamples);
GeometryType m_geometryType;
+ const ImageBackingMode m_backingMode;
};
typedef de::SharedPtr<Unique<VkPipeline> > VkPipelineSp;
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- const RenderType renderType);
+ const RenderType renderType,
+ const ImageBackingMode backingMode);
MultisampleRenderer (Context& context,
const VkFormat colorFormat,
const std::vector<Vertex4RGBA>* pVertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- const RenderType renderType);
+ const RenderType renderType,
+ const ImageBackingMode backingMode);
virtual ~MultisampleRenderer (void);
Context& m_context;
+ const Unique<VkSemaphore> m_bindSemaphore;
+
const VkFormat m_colorFormat;
const VkFormat m_depthStencilFormat;
tcu::IVec2 m_renderSize;
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
- Move<VkFence> m_fence;
+ std::vector<de::SharedPtr<Allocation> > m_allocations;
+
+ ImageBackingMode m_backingMode;
};
class RasterizationSamplesInstance : public vkt::TestInstance
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- const TestModeFlags modeFlags);
+ const TestModeFlags modeFlags,
+ ImageBackingMode backingMode);
virtual ~RasterizationSamplesInstance (void) {}
virtual tcu::TestStatus iterate (void);
VkPrimitiveTopology topology,
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
- const VkPipelineColorBlendAttachmentState& blendState);
+ const VkPipelineColorBlendAttachmentState& blendState,
+ ImageBackingMode backingMode);
virtual ~MinSampleShadingInstance (void) {}
virtual tcu::TestStatus iterate (void);
const std::vector<Vertex4RGBA> m_vertices;
const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
const VkPipelineColorBlendAttachmentState m_colorBlendState;
+ const ImageBackingMode m_backingMode;
};
class SampleMaskInstance : public vkt::TestInstance
VkPrimitiveTopology topology,
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
- const VkPipelineColorBlendAttachmentState& blendState);
+ const VkPipelineColorBlendAttachmentState& blendState,
+ ImageBackingMode backingMode);
virtual ~SampleMaskInstance (void) {}
virtual tcu::TestStatus iterate (void);
const std::vector<Vertex4RGBA> m_vertices;
const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
const VkPipelineColorBlendAttachmentState m_colorBlendState;
+ const ImageBackingMode m_backingMode;
};
class AlphaToOneInstance : public vkt::TestInstance
VkPrimitiveTopology topology,
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
- const VkPipelineColorBlendAttachmentState& blendState);
+ const VkPipelineColorBlendAttachmentState& blendState,
+ ImageBackingMode backingMode);
virtual ~AlphaToOneInstance (void) {}
virtual tcu::TestStatus iterate (void);
const std::vector<Vertex4RGBA> m_vertices;
const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
const VkPipelineColorBlendAttachmentState m_colorBlendState;
+ const ImageBackingMode m_backingMode;
};
class AlphaToCoverageInstance : public vkt::TestInstance
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- GeometryType geometryType);
+ GeometryType geometryType,
+ ImageBackingMode backingMode);
virtual ~AlphaToCoverageInstance (void) {}
virtual tcu::TestStatus iterate (void);
const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
const VkPipelineColorBlendAttachmentState m_colorBlendState;
const GeometryType m_geometryType;
+ const ImageBackingMode m_backingMode;
};
// Helper functions
-void initMultisamplePrograms (SourceCollections& sources, GeometryType geometryType)
+void initMultisamplePrograms (SourceCollections& sources, MultisampleTestParams params)
{
std::ostringstream vertexSource;
"{\n"
" gl_Position = position;\n"
" vtxColor = color;\n"
- << (geometryType == GEOMETRY_TYPE_OPAQUE_POINT ? " gl_PointSize = 3.0f;\n"
+ << (params.geometryType == GEOMETRY_TYPE_OPAQUE_POINT ? " gl_PointSize = 3.0f;\n"
: "")
<< "}\n";
const std::string& description,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- GeometryType geometryType)
+ GeometryType geometryType,
+ ImageBackingMode backingMode)
: vkt::TestCase (testContext, name, description)
, m_multisampleStateParams (multisampleStateParams)
, m_colorBlendState (blendState)
, m_geometryType (geometryType)
+ , m_backingMode (backingMode)
{
if (m_multisampleStateParams.pSampleMask)
{
void MultisampleTest::initPrograms (SourceCollections& programCollection) const
{
- initMultisamplePrograms(programCollection, m_geometryType);
+ MultisampleTestParams params = {m_geometryType, m_backingMode};
+ initMultisamplePrograms(programCollection, params);
}
TestInstance* MultisampleTest::createInstance (Context& context) const
const std::string& description,
VkSampleCountFlagBits rasterizationSamples,
GeometryType geometryType,
+ ImageBackingMode backingMode,
TestModeFlags modeFlags)
- : MultisampleTest (testContext, name, description, getRasterizationSamplesStateParams(rasterizationSamples), getDefaultColorBlendAttachmentState(), geometryType)
+ : MultisampleTest (testContext, name, description, getRasterizationSamplesStateParams(rasterizationSamples), getDefaultColorBlendAttachmentState(), geometryType, backingMode)
+ , m_backingMode (backingMode)
, m_modeFlags (modeFlags)
{
}
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& colorBlendState) const
{
- return new RasterizationSamplesInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_modeFlags);
+ return new RasterizationSamplesInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_modeFlags, m_backingMode);
}
const std::string& description,
VkSampleCountFlagBits rasterizationSamples,
float minSampleShading,
- GeometryType geometryType)
- : MultisampleTest (testContext, name, description, getMinSampleShadingStateParams(rasterizationSamples, minSampleShading), getDefaultColorBlendAttachmentState(), geometryType)
+ GeometryType geometryType,
+ ImageBackingMode backingMode)
+ : MultisampleTest (testContext, name, description, getMinSampleShadingStateParams(rasterizationSamples, minSampleShading), getDefaultColorBlendAttachmentState(), geometryType, backingMode)
+ , m_backingMode (backingMode)
{
}
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& colorBlendState) const
{
- return new MinSampleShadingInstance(context, topology, vertices, multisampleStateParams, colorBlendState);
+ return new MinSampleShadingInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_backingMode);
}
VkPipelineMultisampleStateCreateInfo MinSampleShadingTest::getMinSampleShadingStateParams (VkSampleCountFlagBits rasterizationSamples, float minSampleShading)
const std::string& description,
VkSampleCountFlagBits rasterizationSamples,
const std::vector<VkSampleMask>& sampleMask,
- GeometryType geometryType)
- : MultisampleTest (testContext, name, description, getSampleMaskStateParams(rasterizationSamples, sampleMask), getDefaultColorBlendAttachmentState(), geometryType)
+ GeometryType geometryType,
+ ImageBackingMode backingMode)
+ : MultisampleTest (testContext, name, description, getSampleMaskStateParams(rasterizationSamples, sampleMask), getDefaultColorBlendAttachmentState(), geometryType, backingMode)
+ , m_backingMode (backingMode)
{
}
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& colorBlendState) const
{
- return new SampleMaskInstance(context, topology,vertices, multisampleStateParams, colorBlendState);
+ return new SampleMaskInstance(context, topology,vertices, multisampleStateParams, colorBlendState, m_backingMode);
}
VkPipelineMultisampleStateCreateInfo SampleMaskTest::getSampleMaskStateParams (VkSampleCountFlagBits rasterizationSamples, const std::vector<VkSampleMask>& sampleMask)
AlphaToOneTest::AlphaToOneTest (tcu::TestContext& testContext,
const std::string& name,
const std::string& description,
- VkSampleCountFlagBits rasterizationSamples)
- : MultisampleTest (testContext, name, description, getAlphaToOneStateParams(rasterizationSamples), getAlphaToOneBlendState(), GEOMETRY_TYPE_GRADIENT_QUAD)
+ VkSampleCountFlagBits rasterizationSamples,
+ ImageBackingMode backingMode)
+ : MultisampleTest (testContext, name, description, getAlphaToOneStateParams(rasterizationSamples), getAlphaToOneBlendState(), GEOMETRY_TYPE_GRADIENT_QUAD, backingMode)
+ , m_backingMode(backingMode)
{
}
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& colorBlendState) const
{
- return new AlphaToOneInstance(context, topology, vertices, multisampleStateParams, colorBlendState);
+ return new AlphaToOneInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_backingMode);
}
VkPipelineMultisampleStateCreateInfo AlphaToOneTest::getAlphaToOneStateParams (VkSampleCountFlagBits rasterizationSamples)
const std::string& name,
const std::string& description,
VkSampleCountFlagBits rasterizationSamples,
- GeometryType geometryType)
- : MultisampleTest (testContext, name, description, getAlphaToCoverageStateParams(rasterizationSamples), getDefaultColorBlendAttachmentState(), geometryType)
+ GeometryType geometryType,
+ ImageBackingMode backingMode)
+ : MultisampleTest (testContext, name, description, getAlphaToCoverageStateParams(rasterizationSamples), getDefaultColorBlendAttachmentState(), geometryType, backingMode)
, m_geometryType (geometryType)
+ , m_backingMode (backingMode)
{
}
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& colorBlendState) const
{
- return new AlphaToCoverageInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_geometryType);
+ return new AlphaToCoverageInstance(context, topology, vertices, multisampleStateParams, colorBlendState, m_geometryType, m_backingMode);
}
VkPipelineMultisampleStateCreateInfo AlphaToCoverageTest::getAlphaToCoverageStateParams (VkSampleCountFlagBits rasterizationSamples)
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- const TestModeFlags modeFlags)
+ const TestModeFlags modeFlags,
+ ImageBackingMode backingMode)
: vkt::TestInstance (context)
, m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
, m_renderSize (32, 32)
m_multisampleRenderer = de::MovePtr<MultisampleRenderer>(
new MultisampleRenderer(
- context, m_colorFormat, depthStencilFormat, m_renderSize, useDepth, useStencil, 2u, pTopology, pVertices, multisampleStateParams, blendState, RENDER_TYPE_RESOLVE));
+ context, m_colorFormat, depthStencilFormat, m_renderSize, useDepth, useStencil, 2u, pTopology, pVertices, multisampleStateParams, blendState, RENDER_TYPE_RESOLVE, backingMode));
}
else
{
m_multisampleRenderer = de::MovePtr<MultisampleRenderer>(
- new MultisampleRenderer(context, m_colorFormat, m_renderSize, topology, vertices, multisampleStateParams, blendState, RENDER_TYPE_RESOLVE));
+ new MultisampleRenderer(context, m_colorFormat, m_renderSize, topology, vertices, multisampleStateParams, blendState, RENDER_TYPE_RESOLVE, backingMode));
}
}
VkPrimitiveTopology topology,
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
- const VkPipelineColorBlendAttachmentState& colorBlendState)
+ const VkPipelineColorBlendAttachmentState& colorBlendState,
+ ImageBackingMode backingMode)
: vkt::TestInstance (context)
, m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
, m_renderSize (32, 32)
, m_vertices (vertices)
, m_multisampleStateParams (multisampleStateParams)
, m_colorBlendState (colorBlendState)
+ , m_backingMode (backingMode)
{
VkPhysicalDeviceFeatures deviceFeatures;
multisampleStateParms.sampleShadingEnable = VK_FALSE;
multisampleStateParms.minSampleShading = 0.0;
- MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleStateParms, m_colorBlendState, RENDER_TYPE_RESOLVE);
+ MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleStateParms, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
noSampleshadingImage = renderer.render();
}
// Render with test minSampleShading and collect per-sample images
{
- MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_COPY_SAMPLES);
+ MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_COPY_SAMPLES, m_backingMode);
renderer.render();
sampleShadedImages.resize(m_multisampleStateParams.rasterizationSamples);
VkPrimitiveTopology topology,
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
- const VkPipelineColorBlendAttachmentState& blendState)
+ const VkPipelineColorBlendAttachmentState& blendState,
+ ImageBackingMode backingMode)
: vkt::TestInstance (context)
, m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
, m_renderSize (32, 32)
, m_vertices (vertices)
, m_multisampleStateParams (multisampleStateParams)
, m_colorBlendState (blendState)
+ , m_backingMode (backingMode)
{
}
// Render with test flags
{
- MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE);
+ MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
testSampleMaskImage = renderer.render();
}
multisampleParams.pSampleMask = sampleMask.data();
- MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE);
+ MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
minSampleMaskImage = renderer.render();
}
multisampleParams.pSampleMask = sampleMask.data();
- MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE);
+ MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
maxSampleMaskImage = renderer.render();
}
return tcu::TestStatus::pass("Unique colors within expected bounds");
}
-tcu::TestStatus testRasterSamplesConsistency (Context& context, GeometryType geometryType)
+tcu::TestStatus testRasterSamplesConsistency (Context& context, MultisampleTestParams params)
{
- // Use triangle only.
- DE_UNREF(geometryType);
-
const VkSampleCountFlagBits samples[] =
{
VK_SAMPLE_COUNT_1_BIT,
false // VkBool32 alphaToOneEnable;
};
- MultisampleRenderer renderer (context, VK_FORMAT_R8G8B8A8_UNORM, tcu::IVec2(32, 32), VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, vertices, multisampleStateParams, getDefaultColorBlendAttachmentState(), RENDER_TYPE_RESOLVE);
+ MultisampleRenderer renderer (context, VK_FORMAT_R8G8B8A8_UNORM, tcu::IVec2(32, 32), VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, vertices, multisampleStateParams, getDefaultColorBlendAttachmentState(), RENDER_TYPE_RESOLVE, params.backingMode);
de::MovePtr<tcu::TextureLevel> result = renderer.render();
const deUint32 uniqueColors = getUniqueColorsCount(result->getAccess());
VkPrimitiveTopology topology,
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
- const VkPipelineColorBlendAttachmentState& blendState)
+ const VkPipelineColorBlendAttachmentState& blendState,
+ ImageBackingMode backingMode)
: vkt::TestInstance (context)
, m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
, m_renderSize (32, 32)
, m_vertices (vertices)
, m_multisampleStateParams (multisampleStateParams)
, m_colorBlendState (blendState)
+ , m_backingMode (backingMode)
{
VkPhysicalDeviceFeatures deviceFeatures;
// Render with blend enabled and alpha to one on
{
- MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE);
+ MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
alphaOneImage = renderer.render();
}
VkPipelineMultisampleStateCreateInfo multisampleParams = m_multisampleStateParams;
multisampleParams.alphaToOneEnable = false;
- MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE);
+ MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, multisampleParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
noAlphaOneImage = renderer.render();
}
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- GeometryType geometryType)
+ GeometryType geometryType,
+ ImageBackingMode backingMode)
: vkt::TestInstance (context)
, m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
, m_renderSize (32, 32)
, m_multisampleStateParams (multisampleStateParams)
, m_colorBlendState (blendState)
, m_geometryType (geometryType)
+ , m_backingMode (backingMode)
{
}
DE_ASSERT(m_multisampleStateParams.alphaToCoverageEnable);
de::MovePtr<tcu::TextureLevel> result;
- MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE);
+ MultisampleRenderer renderer (m_context, m_colorFormat, m_renderSize, m_primitiveTopology, m_vertices, m_multisampleStateParams, m_colorBlendState, RENDER_TYPE_RESOLVE, m_backingMode);
result = renderer.render();
const std::vector<Vertex4RGBA>& vertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- const RenderType renderType)
+ const RenderType renderType,
+ const ImageBackingMode backingMode)
: m_context (context)
+ , m_bindSemaphore (createSemaphore(context.getDeviceInterface(), context.getDevice()))
, m_colorFormat (colorFormat)
, m_depthStencilFormat (VK_FORMAT_UNDEFINED)
, m_renderSize (renderSize)
, m_multisampleStateParams (multisampleStateParams)
, m_colorBlendState (blendState)
, m_renderType (renderType)
+ , m_backingMode (backingMode)
{
initialize(context, 1u, &topology, &vertices);
}
const std::vector<Vertex4RGBA>* pVertices,
const VkPipelineMultisampleStateCreateInfo& multisampleStateParams,
const VkPipelineColorBlendAttachmentState& blendState,
- const RenderType renderType)
+ const RenderType renderType,
+ const ImageBackingMode backingMode)
: m_context (context)
+ , m_bindSemaphore (createSemaphore(context.getDeviceInterface(), context.getDevice()))
, m_colorFormat (colorFormat)
, m_depthStencilFormat (depthStencilFormat)
, m_renderSize (renderSize)
, m_multisampleStateParams (multisampleStateParams)
, m_colorBlendState (blendState)
, m_renderType (renderType)
+ , m_backingMode (backingMode)
{
initialize(context, numTopologies, pTopology, pVertices);
}
const DeviceInterface& vk = context.getDeviceInterface();
const VkDevice vkDevice = context.getDevice();
- const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
- SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
+ const deUint32 queueFamilyIndices[] = { context.getUniversalQueueFamilyIndex(), context.getSparseQueueFamilyIndex() };
+ const bool sparse = m_backingMode == IMAGE_BACKING_MODE_SPARSE;
const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
+ const VkImageCreateFlags imageCreateFlags = sparse ? (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) : 0u;
+ const VkSharingMode sharingMode = (sparse && context.getUniversalQueueFamilyIndex() != context.getSparseQueueFamilyIndex()) ? VK_SHARING_MODE_CONCURRENT : VK_SHARING_MODE_EXCLUSIVE;
+ Allocator& memAlloc = m_context.getDefaultAllocator();
// Create color image
{
-
- const VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+ const VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
(m_renderType == RENDER_TYPE_COPY_SAMPLES ? VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT : (VkImageUsageFlagBits)0u);
- const VkImageCreateInfo colorImageParams =
+ const VkImageCreateInfo colorImageParams =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 0u, // VkImageCreateFlags flags;
+ imageCreateFlags, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
m_colorFormat, // VkFormat format;
{ (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
imageUsageFlags, // VkImageUsageFlags usage;
- VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
- 1u, // deUint32 queueFamilyIndexCount;
- &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ sharingMode, // VkSharingMode sharingMode;
+ sharingMode == VK_SHARING_MODE_CONCURRENT ? 2u : 1u, // deUint32 queueFamilyIndexCount;
+ queueFamilyIndices, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
};
- m_colorImage = createImage(vk, vkDevice, &colorImageParams);
+ if (sparse && !checkSparseImageFormatSupport(context.getPhysicalDevice(), context.getInstanceInterface(), colorImageParams))
+ TCU_THROW(NotSupportedError, "The image format does not support sparse operations.");
+
+ m_colorImage = createImage(vk, vkDevice, &colorImageParams);
// Allocate and bind color image memory
- m_colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImage), MemoryRequirement::Any);
- VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImage, m_colorImageAlloc->getMemory(), m_colorImageAlloc->getOffset()));
+ if (sparse)
+ {
+ allocateAndBindSparseImage(vk, vkDevice, context.getPhysicalDevice(), context.getInstanceInterface(), colorImageParams, *m_bindSemaphore, context.getSparseQueue(), memAlloc, m_allocations, mapVkFormat(m_colorFormat), *m_colorImage);
+ }
+ else
+ {
+ m_colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImage), MemoryRequirement::Any);
+ VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImage, m_colorImageAlloc->getMemory(), m_colorImageAlloc->getOffset()));
+ }
}
// Create resolve image
VK_IMAGE_USAGE_TRANSFER_DST_BIT,
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
- &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ queueFamilyIndices, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
VK_IMAGE_USAGE_TRANSFER_DST_BIT,
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
- &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ queueFamilyIndices, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
- &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ queueFamilyIndices, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
- &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
+ &queueFamilyIndices[0] // const deUint32* pQueueFamilyIndices;
};
m_vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
}
// Create command pool
- m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
+ m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndices[0]);
// Create command buffer
{
&clearValues[0] // const VkClearValue* pClearValues;
};
+ vk::VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
std::vector<VkImageMemoryBarrier> imageLayoutBarriers;
{
{ depthStencilAttachmentAspect, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange;
};
imageLayoutBarriers.push_back(depthStencilImageBarrier);
+ dstStageMask |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
};
m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0,
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, dstStageMask, (VkDependencyFlags)0,
0u, DE_NULL, 0u, DE_NULL, (deUint32)imageLayoutBarriers.size(), &imageLayoutBarriers[0]);
vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
MultisampleRenderer::~MultisampleRenderer (void)
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
- SimpleAllocator allocator (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
if (m_renderType == RENDER_TYPE_RESOLVE)
{
- return readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_resolveImage, m_colorFormat, m_renderSize.cast<deUint32>());
+ return readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, m_context.getDefaultAllocator(), *m_resolveImage, m_colorFormat, m_renderSize.cast<deUint32>());
}
else
{
de::MovePtr<tcu::TextureLevel> MultisampleRenderer::getSingleSampledImage (deUint32 sampleId)
{
- const DeviceInterface& vk = m_context.getDeviceInterface();
- const VkDevice vkDevice = m_context.getDevice();
- const VkQueue queue = m_context.getUniversalQueue();
- const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
- SimpleAllocator allocator (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
-
- return readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_perSampleImages[sampleId]->m_image, m_colorFormat, m_renderSize.cast<deUint32>());
+ return readColorAttachment(m_context.getDeviceInterface(), m_context.getDevice(), m_context.getUniversalQueue(), m_context.getUniversalQueueFamilyIndex(), m_context.getDefaultAllocator(), *m_perSampleImages[sampleId]->m_image, m_colorFormat, m_renderSize.cast<deUint32>());
}
} // anonymous
de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
- samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_triangle", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_TRIANGLE));
- samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_line", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_LINE));
- samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_point", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_POINT));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_triangle", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_line", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_REGULAR));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_point", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_REGULAR));
+
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR, TEST_MODE_DEPTH_BIT));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "stencil", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR, TEST_MODE_STENCIL_BIT));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth_stencil", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR, TEST_MODE_DEPTH_BIT | TEST_MODE_STENCIL_BIT));
- samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, TEST_MODE_DEPTH_BIT));
- samplesTests->addChild(new RasterizationSamplesTest(testCtx, "stencil", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, TEST_MODE_STENCIL_BIT));
- samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth_stencil", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, TEST_MODE_DEPTH_BIT | TEST_MODE_STENCIL_BIT));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_triangle_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_line_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_SPARSE));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "primitive_point_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_SPARSE));
+
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE, TEST_MODE_DEPTH_BIT));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "stencil_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE, TEST_MODE_STENCIL_BIT));
+ samplesTests->addChild(new RasterizationSamplesTest(testCtx, "depth_stencil_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE, TEST_MODE_DEPTH_BIT | TEST_MODE_STENCIL_BIT));
rasterizationSamplesTests->addChild(samplesTests.release());
}
// Raster samples consistency check
{
- de::MovePtr<tcu::TestCaseGroup> rasterSamplesConsistencyTests(new tcu::TestCaseGroup(testCtx, "raster_samples_consistency", ""));
+ de::MovePtr<tcu::TestCaseGroup> rasterSamplesConsistencyTests (new tcu::TestCaseGroup(testCtx, "raster_samples_consistency", ""));
+ MultisampleTestParams paramsRegular = {GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR};
+ MultisampleTestParams paramsSparse = {GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE};
addFunctionCaseWithPrograms(rasterSamplesConsistencyTests.get(),
"unique_colors_check",
"",
initMultisamplePrograms,
testRasterSamplesConsistency,
- GEOMETRY_TYPE_OPAQUE_TRIANGLE);
+ paramsRegular);
+
+ addFunctionCaseWithPrograms(rasterSamplesConsistencyTests.get(),
+ "unique_colors_check_sparse",
+ "",
+ initMultisamplePrograms,
+ testRasterSamplesConsistency,
+ paramsSparse);
multisampleTests->addChild(rasterSamplesConsistencyTests.release());
}
de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
- samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_triangle", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_TRIANGLE));
- samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_line", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_LINE));
- samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_point", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_POINT));
+ samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_triangle", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR));
+ samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_line", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_REGULAR));
+ samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_point", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_REGULAR));
+
+ samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_triangle_sparse", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE));
+ samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_line_sparse", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_SPARSE));
+ samplesTests->addChild(new MinSampleShadingTest(testCtx, "primitive_point_sparse", "", samples[samplesNdx], testConfig.minSampleShading, GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_SPARSE));
minShadingValueTests->addChild(samplesTests.release());
}
for (deUint32 maskNdx = 0; maskNdx < sampleMaskCount; maskNdx++)
mask.push_back(testConfig.sampleMask);
- samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_triangle", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_TRIANGLE));
- samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_line", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_LINE));
- samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_point", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_POINT));
+ samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_triangle", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_REGULAR));
+ samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_line", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_REGULAR));
+ samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_point", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_REGULAR));
+
+ samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_triangle_sparse", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_TRIANGLE, IMAGE_BACKING_MODE_SPARSE));
+ samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_line_sparse", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_LINE, IMAGE_BACKING_MODE_SPARSE));
+ samplesTests->addChild(new SampleMaskTest(testCtx, "primitive_point_sparse", "", samples[samplesNdx], mask, GEOMETRY_TYPE_OPAQUE_POINT, IMAGE_BACKING_MODE_SPARSE));
sampleMaskValueTests->addChild(samplesTests.release());
}
std::ostringstream caseName;
caseName << "samples_" << samples[samplesNdx];
- alphaToOneTests->addChild(new AlphaToOneTest(testCtx, caseName.str(), "", samples[samplesNdx]));
+ alphaToOneTests->addChild(new AlphaToOneTest(testCtx, caseName.str(), "", samples[samplesNdx], IMAGE_BACKING_MODE_REGULAR));
+
+ caseName << "_sparse";
+ alphaToOneTests->addChild(new AlphaToOneTest(testCtx, caseName.str(), "", samples[samplesNdx], IMAGE_BACKING_MODE_SPARSE));
}
multisampleTests->addChild(alphaToOneTests.release());
de::MovePtr<tcu::TestCaseGroup> samplesTests (new tcu::TestCaseGroup(testCtx, caseName.str().c_str(), ""));
- samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_opaque", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_QUAD));
- samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_translucent", "", samples[samplesNdx], GEOMETRY_TYPE_TRANSLUCENT_QUAD));
- samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_invisible", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_QUAD));
+ samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_opaque", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_QUAD, IMAGE_BACKING_MODE_REGULAR));
+ samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_translucent", "", samples[samplesNdx], GEOMETRY_TYPE_TRANSLUCENT_QUAD, IMAGE_BACKING_MODE_REGULAR));
+ samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_invisible", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_QUAD, IMAGE_BACKING_MODE_REGULAR));
+
+ samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_opaque_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_OPAQUE_QUAD, IMAGE_BACKING_MODE_SPARSE));
+ samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_translucent_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_TRANSLUCENT_QUAD, IMAGE_BACKING_MODE_SPARSE));
+ samplesTests->addChild(new AlphaToCoverageTest(testCtx, "alpha_invisible_sparse", "", samples[samplesNdx], GEOMETRY_TYPE_INVISIBLE_QUAD, IMAGE_BACKING_MODE_SPARSE));
alphaToCoverageTests->addChild(samplesTests.release());
}
multisampleTests->addChild(createMultisampleStorageImageTests(testCtx));
}
+ // VK_EXT_sample_locations
+ {
+ multisampleTests->addChild(createMultisampleSampleLocationsExtTests(testCtx));
+ }
+
return multisampleTests.release();
}
projects / platform / upstream / VK-GL-CTS.git / blobdiff