#include "deClock.h"
#include "deMath.h"
+#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include <sstream>
case IMG_DIM_1D:
result += "1D";
break;
+
case IMG_DIM_2D:
result += "2D";
break;
+
case IMG_DIM_3D:
result += "3D";
break;
+
case IMG_DIM_CUBE:
result += "Cube";
break;
+
default:
break;
}
const SamplerParameters& samplerParams,
const SampleLookupSettings& lookupSettings)
{
- int dim;
+ int dim = -1;
switch (imParams.dim)
{
case IMG_DIM_1D:
dim = 1;
break;
+
case IMG_DIM_2D:
dim = 2;
break;
+
case IMG_DIM_3D:
dim = 3;
break;
+
case IMG_DIM_CUBE:
dim = 3;
break;
+
default:
dim = 0;
break;
if (lookupSettings.lookupLodMode == LOOKUP_LOD_MODE_DERIVATIVES)
{
- code += ", dPdx, dPdy";
+ code += ", vec";
+ code += (char) (numCoordComp + '0');
+ code += "(dPdx), ";
+ code += "vec";
+ code += (char) (numCoordComp + '0');
+ code += "(dPdy)";
}
else if (lookupSettings.lookupLodMode == LOOKUP_LOD_MODE_LOD)
{
const VkImageSubresourceLayers curSubresource =
{
VK_IMAGE_ASPECT_COLOR_BIT,
- (deUint32) level,
+ (deUint32)level,
0,
- (deUint32) imParams.arrayLayers
+ (deUint32)imParams.arrayLayers
};
const VkBufferImageCopy curRegion =
0,
curSubresource,
{0U, 0U, 0U},
- {(deUint32) curLevelSize[0], (deUint32) curLevelSize[1], (deUint32) curLevelSize[2]}
+ {(deUint32)curLevelSize[0], (deUint32)curLevelSize[1], (deUint32)curLevelSize[2]}
};
copyRegions.push_back(curRegion);
{
VK_IMAGE_ASPECT_COLOR_BIT,
0,
- imParams.levels,
+ (deUint32)imParams.levels,
0,
- imParams.arrayLayers
+ (deUint32)imParams.arrayLayers
};
VkImageMemoryBarrier imMemBar =
buf.get(),
im,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
- (deUint32) copyRegions.size(),
+ (deUint32)copyRegions.size(),
©Regions[0]);
imMemBar.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
ImageViewParameters imParams;
SamplerParameters samplerParams;
SampleLookupSettings sampleLookupSettings;
- const SampleArguments* sampleArguments;
- deUint32 numSamples;
glu::ShaderType shaderType;
};
case IMG_DIM_1D:
imType = VK_IMAGE_TYPE_1D;
break;
+
case IMG_DIM_2D:
case IMG_DIM_CUBE:
imType = VK_IMAGE_TYPE_2D;
break;
+
case IMG_DIM_3D:
imType = VK_IMAGE_TYPE_3D;
break;
+
default:
imType = VK_IMAGE_TYPE_LAST;
break;
case IMG_DIM_1D:
imViewType = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
break;
+
case IMG_DIM_2D:
imViewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
break;
+
case IMG_DIM_CUBE:
imViewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
break;
+
default:
imViewType = VK_IMAGE_VIEW_TYPE_LAST;
break;
case IMG_DIM_1D:
imViewType = VK_IMAGE_VIEW_TYPE_1D;
break;
+
case IMG_DIM_2D:
imViewType = VK_IMAGE_VIEW_TYPE_2D;
break;
+
case IMG_DIM_3D:
imViewType = VK_IMAGE_VIEW_TYPE_3D;
break;
+
case IMG_DIM_CUBE:
imViewType = VK_IMAGE_VIEW_TYPE_CUBE;
break;
+
default:
imViewType = VK_IMAGE_VIEW_TYPE_LAST;
break;
m_pba = m_gen->getPba();
m_sampleArguments = m_gen->getSampleArgs();
- m_numSamples = (deUint32) m_sampleArguments.size();
+ m_numSamples = (deUint32)m_sampleArguments.size();
createResources();
initializeImage(m_ctx, m_im.get(), &m_pba[0], m_imParams);
m_mipmapBits,
m_pba);
+ const int maxPrintedFailures = 5;
+ int failCount = 0;
+
for (deUint32 sampleNdx = 0; sampleNdx < m_numSamples; ++sampleNdx)
{
if (!verifier.verifySample(m_sampleArguments[sampleNdx], m_resultSamples[sampleNdx]))
{
- // Re-run with report logging
- std::string report;
- verifier.verifySampleReport(m_sampleArguments[sampleNdx], m_resultSamples[sampleNdx], report);
-
- m_ctx.getTestContext().getLog()
- << TestLog::Message
- << "Failed verification at sample " << sampleNdx << ".\n"
- << "\tCoordinate: " << m_sampleArguments[sampleNdx].coord << "\n"
- << "\tLOD: " << m_sampleArguments[sampleNdx].lod << "\n"
- << "\tGPU Result: " << m_resultSamples[sampleNdx] << "\n"
- << TestLog::EndMessage;
-
- for (int levelNdx = 0; levelNdx < m_imParams.levels; ++levelNdx)
+ if (failCount++ < maxPrintedFailures)
{
- LogImage("", "", m_pba[levelNdx]).write(m_ctx.getTestContext().getLog());
+ // Re-run with report logging
+ std::string report;
+ verifier.verifySampleReport(m_sampleArguments[sampleNdx], m_resultSamples[sampleNdx], report);
+
+ m_ctx.getTestContext().getLog()
+ << TestLog::Section("Failed sample", "Failed sample")
+ << TestLog::Message
+ << "Sample " << sampleNdx << ".\n"
+ << "\tCoordinate: " << m_sampleArguments[sampleNdx].coord << "\n"
+ << "\tLOD: " << m_sampleArguments[sampleNdx].lod << "\n"
+ << "\tGPU Result: " << m_resultSamples[sampleNdx] << "\n\n"
+ << "Failure report:\n" << report << "\n"
+ << TestLog::EndMessage
+ << TestLog::EndSection;
}
-
- m_ctx.getTestContext().getLog()
- << TestLog::Message
- << "Failure report:\n" << report << "\n"
- << TestLog::EndMessage;
-
- return false;
}
}
- return true;
+ m_ctx.getTestContext().getLog()
+ << TestLog::Message
+ << "Passed " << m_numSamples - failCount << " out of " << m_numSamples << "."
+ << TestLog::EndMessage;
+
+ return failCount == 0;
}
void TextureFilteringTestInstance::execute (void)
mapImageType(m_imParams.dim), // imageType
m_imParams.format, // format
m_imExtent, // extent
- m_imParams.levels, // mipLevels
- m_imParams.arrayLayers, // arrayLayers
+ (deUint32)m_imParams.levels, // mipLevels
+ (deUint32)m_imParams.arrayLayers, // arrayLayers
VK_SAMPLE_COUNT_1_BIT, // samples
VK_IMAGE_TILING_OPTIMAL, // tiling
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, // usage
// \todo [2016-06-23 collinbaker] Pick aspectMask based on image type (i.e. support depth and/or stencil images)
VkImageSubresourceRange imViewSubresourceRange =
{
- VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
- 0, // baseMipLevel
- m_imParams.levels, // levelCount
- 0, // baseArrayLayer
- m_imParams.arrayLayers // layerCount
+ VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
+ 0, // baseMipLevel
+ (deUint32)m_imParams.levels, // levelCount
+ 0, // baseArrayLayer
+ (deUint32)m_imParams.arrayLayers // layerCount
};
if (m_imParams.dim == IMG_DIM_CUBE)
VkFilter magFilter,
VkFilter minFilter,
VkSamplerMipmapMode mipmapFilter,
- VkSamplerAddressMode wrappingMode)
+ VkSamplerAddressMode wrappingMode,
+ bool useDerivatives)
: TextureFilteringTestCase (testCtx, name, desc)
- , m_testCtx (testCtx)
, m_format (format)
, m_dimensions (dimensions)
, m_magFilter (magFilter)
, m_minFilter (minFilter)
, m_mipmapFilter (mipmapFilter)
, m_wrappingMode (wrappingMode)
+ , m_useDerivatives (useDerivatives)
{
m_testCaseData = genTestCaseData();
init();
{
// Generate grid
- SampleLookupSettings sampleLookupSettings =
+ const SampleLookupSettings sampleLookupSettings =
{
- LOOKUP_LOD_MODE_LOD, // lookupLodMode
+ m_useDerivatives ? LOOKUP_LOD_MODE_DERIVATIVES : LOOKUP_LOD_MODE_LOD, // lookupLodMode
false, // hasLodBias
false, // isProjective
};
- SamplerParameters samplerParameters =
+ const SamplerParameters samplerParameters =
{
m_magFilter, // magFilter
m_minFilter, // minFilter
false // isCompare
};
- deUint8 numLevels = (deUint8) (1 + deLog2Floor32(de::max(m_dimensions[0],
- m_dimensions[1])));
+ const deUint8 numLevels = (deUint8) (1 + deLog2Floor32(de::max(m_dimensions[0],
+ m_dimensions[1])));
- ImageViewParameters imParameters =
+ const ImageViewParameters imParameters =
{
IMG_DIM_2D, // dim
mapTextureFormat(m_format), // format
1, // arrayLayers
};
- TestCaseData data =
+ const TestCaseData data =
{
std::vector<ConstPixelBufferAccess>(),
imParameters,
samplerParameters,
sampleLookupSettings,
- &m_args[0],
- (deUint32) m_args.size(),
glu::SHADERTYPE_FRAGMENT
};
}
private:
- TestContext& m_testCtx;
- TextureFormat m_format;
- IVec3 m_dimensions;
- VkFilter m_magFilter;
- VkFilter m_minFilter;
- VkSamplerMipmapMode m_mipmapFilter;
- VkSamplerAddressMode m_wrappingMode;
-
- std::vector<SampleArguments> m_args;
+ const TextureFormat m_format;
+ const IVec3 m_dimensions;
+ const VkFilter m_magFilter;
+ const VkFilter m_minFilter;
+ const VkSamplerMipmapMode m_mipmapFilter;
+ const VkSamplerAddressMode m_wrappingMode;
+ const bool m_useDerivatives;
};
class Texture2DGradientTestCase::Generator : public DataGenerator
m_testCase->m_dimensions[0],
m_testCase->m_dimensions[1]));
- deUint8 numLevels = (deUint8) (1 + deLog2Floor32(de::max(m_testCase->m_dimensions[0],
- m_testCase->m_dimensions[1])));
+ const deUint8 numLevels = (deUint8) (1 + deLog2Floor32(de::max(m_testCase->m_dimensions[0],
+ m_testCase->m_dimensions[1])));
- TextureFormatInfo fmtInfo = getTextureFormatInfo(m_testCase->m_format);
+ const TextureFormatInfo fmtInfo = getTextureFormatInfo(m_testCase->m_format);
- Vec4 cBias = fmtInfo.valueMin;
- Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin;
+ const Vec4 cBias = fmtInfo.valueMin;
+ const Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin;
for (deUint8 levelNdx = 0; levelNdx < numLevels; ++levelNdx)
{
- Vec4 gMin = Vec4(0.0f, 0.0f, 0.0f, 1.0f) * cScale + cBias;
- Vec4 gMax = Vec4(1.0f, 1.0f, 1.0f, 0.0f) * cScale + cBias;
+ const Vec4 gMin = Vec4(0.0f, 0.0f, 0.0f, 1.0f) * cScale + cBias;
+ const Vec4 gMax = Vec4(1.0f, 1.0f, 1.0f, 0.0f) * cScale + cBias;
m_tex->allocLevel(levelNdx);
fillWithComponentGradients(m_tex->getLevel(levelNdx), gMin, gMax);
{
std::vector<SampleArguments> args;
- const float lodList[] = {-1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0};
-
- for (deInt32 i = 0; i < 2 * m_testCase->m_dimensions[0] + 1; ++i)
+ if (m_testCase->m_useDerivatives)
+ {
+ struct
+ {
+ Vec4 dPdx;
+ Vec4 dPdy;
+ }
+ derivativePairs[] =
+ {
+ {Vec4(0.0f, 0.0f, 0.0f, 0.0f), Vec4(0.0f, 0.0f, 0.0f, 0.0f)},
+ {Vec4(1.0f, 1.0f, 1.0f, 0.0f), Vec4(1.0f, 1.0f, 1.0f, 0.0f)},
+ {Vec4(0.0f, 0.0f, 0.0f, 0.0f), Vec4(1.0f, 1.0f, 1.0f, 0.0f)},
+ {Vec4(1.0f, 1.0f, 1.0f, 0.0f), Vec4(0.0f, 0.0f, 0.0f, 0.0f)},
+ {Vec4(2.0f, 2.0f, 2.0f, 0.0f), Vec4(2.0f, 2.0f, 2.0f, 0.0f)}
+ };
+
+ for (deInt32 i = 0; i < 2 * m_testCase->m_dimensions[0] + 1; ++i)
+ {
+ for (deInt32 j = 0; j < 2 * m_testCase->m_dimensions[1] + 1; ++j)
+ {
+ for (deUint32 derivNdx = 0; derivNdx < DE_LENGTH_OF_ARRAY(derivativePairs); ++derivNdx)
+ {
+ SampleArguments cur;
+ cur.coord = Vec4((float)i / (float)(2 * m_testCase->m_dimensions[0]),
+ (float)j / (float)(2 * m_testCase->m_dimensions[1]),
+ 0.0f, 0.0f);
+ cur.dPdx = derivativePairs[derivNdx].dPdx;
+ cur.dPdy = derivativePairs[derivNdx].dPdy;
+
+ args.push_back(cur);
+ }
+ }
+ }
+ }
+ else
{
- for (deInt32 j = 0; j < 2 * m_testCase->m_dimensions[1] + 1; ++j)
+ const float lodList[] = {-1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0};
+
+ for (deInt32 i = 0; i < 2 * m_testCase->m_dimensions[0] + 1; ++i)
{
- for (deUint32 lodNdx = 0; lodNdx < DE_LENGTH_OF_ARRAY(lodList); ++lodNdx)
+ for (deInt32 j = 0; j < 2 * m_testCase->m_dimensions[1] + 1; ++j)
{
- SampleArguments cur;
- cur.coord = Vec4((float) i / (float) (2 * m_testCase->m_dimensions[0]),
- (float) j / (float) (2 * m_testCase->m_dimensions[1]),
- 0.0f, 0.0f);
- cur.lod = lodList[lodNdx];
+ for (deUint32 lodNdx = 0; lodNdx < DE_LENGTH_OF_ARRAY(lodList); ++lodNdx)
+ {
+ SampleArguments cur;
+ cur.coord = Vec4((float)i / (float)(2 * m_testCase->m_dimensions[0]),
+ (float)j / (float)(2 * m_testCase->m_dimensions[1]),
+ 0.0f, 0.0f);
+ cur.lod = lodList[lodNdx];
- args.push_back(cur);
+ args.push_back(cur);
+ }
}
}
}
VK_FORMAT_R8G8_SNORM,
VK_FORMAT_R8G8B8A8_UNORM,
VK_FORMAT_R8G8B8A8_SNORM,
- VK_FORMAT_R8G8B8A8_SRGB,
+// VK_FORMAT_R8G8B8A8_SRGB,
VK_FORMAT_B8G8R8A8_UNORM,
- VK_FORMAT_B8G8R8A8_SRGB,
+// VK_FORMAT_B8G8R8A8_SRGB,
VK_FORMAT_A8B8G8R8_UNORM_PACK32,
VK_FORMAT_A8B8G8R8_SNORM_PACK32,
- VK_FORMAT_A8B8G8R8_SRGB_PACK32,
+// VK_FORMAT_A8B8G8R8_SRGB_PACK32,
VK_FORMAT_A2B10G10R10_UNORM_PACK32,
VK_FORMAT_R16_SFLOAT,
VK_FORMAT_R16G16_SFLOAT,
VK_FORMAT_R16G16B16A16_SFLOAT,
- VK_FORMAT_B10G11R11_UFLOAT_PACK32,
- VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
+ VK_FORMAT_R32_SFLOAT,
+ VK_FORMAT_R32G32_SFLOAT,
+ VK_FORMAT_R32G32B32A32_SFLOAT,
+// VK_FORMAT_B10G11R11_UFLOAT_PACK32,
+// VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
};
const IVec3 size(32, 32, 1);
for (deUint32 formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
{
- std::string prefix = getFormatName(formats[formatNdx]);
+ const std::string prefix = de::toLower(std::string(getFormatName(formats[formatNdx])).substr(10));
Texture2DGradientTestCase* testCaseNearest =
new Texture2DGradientTestCase(
VK_FILTER_NEAREST,
VK_FILTER_NEAREST,
VK_SAMPLER_MIPMAP_MODE_NEAREST,
- VK_SAMPLER_ADDRESS_MODE_REPEAT);
+ VK_SAMPLER_ADDRESS_MODE_REPEAT,
+ false);
tests->addChild(testCaseNearest);
VK_FILTER_LINEAR,
VK_FILTER_LINEAR,
VK_SAMPLER_MIPMAP_MODE_LINEAR,
- VK_SAMPLER_ADDRESS_MODE_REPEAT);
+ VK_SAMPLER_ADDRESS_MODE_REPEAT,
+ false);
tests->addChild(testCaseLinear);
}
return tests.release();
}
+TestCaseGroup* create2DDerivTests (TestContext& testCtx)
+{
+ de::MovePtr<TestCaseGroup> tests(
+ new TestCaseGroup(testCtx, "derivatives", "Explicit derivative tests"));
+
+ const VkFormat format = VK_FORMAT_R8G8B8A8_UNORM;
+ const VkSamplerAddressMode wrappingMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+ const IVec3 size = IVec3(16, 16, 1);
+
+ const VkFilter filters[2] =
+ {
+ VK_FILTER_NEAREST,
+ VK_FILTER_LINEAR
+ };
+
+ const VkSamplerMipmapMode mipmapFilters[2] =
+ {
+ VK_SAMPLER_MIPMAP_MODE_NEAREST,
+ VK_SAMPLER_MIPMAP_MODE_LINEAR,
+ };
+
+ for (int magFilterNdx = 0; magFilterNdx < DE_LENGTH_OF_ARRAY(filters); ++magFilterNdx)
+ {
+ for (int minFilterNdx = 0; minFilterNdx < DE_LENGTH_OF_ARRAY(filters); ++minFilterNdx)
+ {
+ for (int mipmapFilterNdx = 0; mipmapFilterNdx < DE_LENGTH_OF_ARRAY(mipmapFilters); ++mipmapFilterNdx)
+ {
+ std::ostringstream caseName;
+
+ switch (filters[magFilterNdx])
+ {
+ case VK_FILTER_NEAREST:
+ caseName << "nearest";
+ break;
+
+ case VK_FILTER_LINEAR:
+ caseName << "linear";
+ break;
+
+ default:
+ break;
+ }
+
+ switch (filters[minFilterNdx])
+ {
+ case VK_FILTER_NEAREST:
+ caseName << "_nearest";
+ break;
+
+ case VK_FILTER_LINEAR:
+ caseName << "_linear";
+ break;
+
+ default:
+ break;
+ }
+
+ caseName << "_mipmap";
+
+ switch (mipmapFilters[mipmapFilterNdx])
+ {
+ case VK_SAMPLER_MIPMAP_MODE_NEAREST:
+ caseName << "_nearest";
+ break;
+
+ case VK_SAMPLER_MIPMAP_MODE_LINEAR:
+ caseName << "_linear";
+ break;
+
+ default:
+ break;
+ }
+
+ Texture2DGradientTestCase* testCase =
+ new Texture2DGradientTestCase(
+ testCtx,
+ caseName.str().c_str(),
+ "...",
+ mapVkFormat(format),
+ size,
+ filters[magFilterNdx],
+ filters[minFilterNdx],
+ mipmapFilters[mipmapFilterNdx],
+ wrappingMode,
+ true);
+
+ tests->addChild(testCase);
+ }
+ }
+ }
+
+ return tests.release();
+}
+
TestCaseGroup* create2DSizeTests (TestContext& testCtx)
{
de::MovePtr<TestCaseGroup> tests(
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE
};
- IVec3 sizes[] =
+ const IVec3 sizes[] =
{
IVec3(2, 2, 1),
IVec3(2, 3, 1),
case VK_FILTER_NEAREST:
caseName << "_nearest";
break;
+
case VK_FILTER_LINEAR:
caseName << "_linear";
break;
+
default:
break;
}
case VK_FILTER_NEAREST:
caseName << "_nearest";
break;
+
case VK_FILTER_LINEAR:
caseName << "_linear";
break;
+
default:
break;
}
case VK_SAMPLER_MIPMAP_MODE_NEAREST:
caseName << "_mipmap_nearest";
break;
+
case VK_SAMPLER_MIPMAP_MODE_LINEAR:
caseName << "_mipmap_linear";
break;
+
default:
break;
}
case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
caseName << "_clamp";
break;
+
case VK_SAMPLER_ADDRESS_MODE_REPEAT:
caseName << "_repeat";
break;
+
default:
break;
}
filters[magFilterNdx],
filters[minFilterNdx],
mipmapFilters[mipmapFilterNdx],
- wrappingModes[wrappingModeNdx]);
+ wrappingModes[wrappingModeNdx],
+ false);
tests->addChild(testCase);
}
tests->addChild(create2DSizeTests(testCtx));
tests->addChild(create2DFormatTests(testCtx));
+ tests->addChild(create2DDerivTests(testCtx));
return tests.release();
}
projects / platform / upstream / VK-GL-CTS.git / blobdiff