Lines Matching defs:const
105 static const char* getDerivateFuncName (DerivateFunc func)
126 static const char* getDerivateFuncCaseName (DerivateFunc func)
181 static inline bool isSkippedPixel (const tcu::ConstPixelBufferAccess& surface, int x, int y)
183 const tcu::Vec4 skipValue(0.7843f, 0.2039f, 0.4706f, 0.0f);
184 const tcu::Vec4 value = surface.getPixel(x, y);
188 static inline tcu::Vec4 readDerivate (const tcu::ConstPixelBufferAccess& surface, const tcu::Vec4& derivScale, const tcu::Vec4& derivBias, int x, int y)
193 static inline tcu::UVec4 getCompExpBits (const tcu::Vec4& v)
201 float computeFloatingPointError (const float value, const int numAccurateBits)
203 const int numGarbageBits = 23-numAccurateBits;
204 const deUint32 mask = (1u<<numGarbageBits)-1u;
205 const int exp = tcu::Float32(value).exponent();
210 static int getNumMantissaBits (const glu::Precision precision)
223 static int getMinExponent (const glu::Precision precision)
242 const int ulpBitNdx = 23-numMantissaBits;
254 const int exp = tcu::Float32(value).exponent();
266 const tcu::Float32 inputFloat = tcu::Float32(value);
267 const int numTruncatedBits = 23-numAccurateBits;
268 const deUint32 truncMask = (1u<<numTruncatedBits)-1u;
314 static inline tcu::Vec4 getDerivateThreshold (const glu::Precision precision, const tcu::Vec4& valueMin, const tcu::Vec4& valueMax, const tcu::Vec4& expectedDerivate)
316 const int baseBits = getNumMantissaBits(precision);
317 const tcu::UVec4 derivExp = getCompExpBits(expectedDerivate);
318 const tcu::UVec4 maxValueExp = max(getCompExpBits(valueMin), getCompExpBits(valueMax));
319 const tcu::UVec4 numBitsLost = maxValueExp - min(maxValueExp, derivExp);
320 const tcu::IVec4 numAccurateBits = max(baseBits - numBitsLost.asInt() - (int)INTERPOLATION_LOST_BITS, tcu::IVec4(0));
330 const tcu::Vec4& v;
333 LogVecComps (const tcu::Vec4& v_, int numComps_)
340 std::ostream& operator<< (std::ostream& str, const LogVecComps& v)
356 const tcu::ConstPixelBufferAccess& result,
357 const tcu::PixelBufferAccess& errorMask,
359 const tcu::Vec4& reference,
360 const tcu::Vec4& threshold,
361 const tcu::Vec4& scale,
362 const tcu::Vec4& bias,
365 const int numComps = glu::getDataTypeFloatScalars(dataType);
366 const tcu::BVec4 mask = tcu::logicalNot(getDerivateMask(dataType));
379 const tcu::Vec4 resDerivate = readDerivate(result, scale, bias, x, y);
380 const bool isOk = tcu::allEqual(tcu::logicalOr(tcu::lessThanEqual(tcu::abs(reference - resDerivate), threshold), mask), tcu::BVec4(true));
413 tcu::Vec4 evaluateAt (float screenX, float screenY) const;
416 tcu::Vec4 Linear2DFunctionEvaluator::evaluateAt (float screenX, float screenY) const
418 const tcu::Vec3 position(screenX, screenY, 1.0f);
423 const tcu::ConstPixelBufferAccess& result,
424 const tcu::PixelBufferAccess& errorMask,
427 const tcu::Vec4& derivScale,
428 const tcu::Vec4& derivBias,
429 const tcu::Vec4& surfaceThreshold,
431 const Linear2DFunctionEvaluator& function)
437 const tcu::IVec4 red (255, 0, 0, 255);
438 const tcu::IVec4 green (0, 255, 0, 255);
439 const float divisionErrorUlps = 2.5f;
441 const int numComponents = glu::getDataTypeFloatScalars(dataType);
442 const int numBits = getNumMantissaBits(precision);
443 const int minExponent = getMinExponent(precision);
445 const int numVaryingSampleBits = numBits - INTERPOLATION_LOST_BITS;
461 const tcu::Vec4 resultDerivative = readDerivate(result, derivScale, derivBias, x, y);
469 const tcu::Vec4 functionValueForward = (isDfdxFunc(derivateFunc))
472 const tcu::Vec4 functionValueBackward = (isDfdyFunc(derivateFunc))
482 const tcu::Interval forwardComponent (convertFloatFlushToZeroRtn(addErrorUlp((float)functionValueForward[c], -0.5f, numVaryingSampleBits), minExponent, numBits),
484 const tcu::Interval backwardComponent (convertFloatFlushToZeroRtn(addErrorUlp((float)functionValueBackward[c], -0.5f, numVaryingSampleBits), minExponent, numBits),
486 const int maxValueExp = de::max(de::max(tcu::Float32(forwardComponent.lo()).exponent(), tcu::Float32(forwardComponent.hi()).exponent()),
492 const tcu::Interval numerator (forwardComponent - backwardComponent);
493 const int numeratorLoExp = tcu::Float32(numerator.lo()).exponent();
494 const int numeratorHiExp = tcu::Float32(numerator.hi()).exponent();
495 const int numeratorLoBitsLost = de::max(0, maxValueExp - numeratorLoExp); //!< must clamp to zero since if forward and backward components have different
496 const int numeratorHiBitsLost = de::max(0, maxValueExp - numeratorHiExp); //!< sign, numerator might have larger exponent than its operands.
497 const int numeratorLoBits = de::max(0, numBits - numeratorLoBitsLost);
498 const int numeratorHiBits = de::max(0, numBits - numeratorHiBitsLost);
500 const tcu::Interval numeratorRange (convertFloatFlushToZeroRtn((float)numerator.lo(), minExponent, numeratorLoBits),
503 const tcu::Interval divisionRange = numeratorRange / 3.0f; // legal sample area is anywhere within this and neighboring pixels (i.e. size = 3)
504 const tcu::Interval divisionResultRange (convertFloatFlushToZeroRtn(addErrorUlp((float)divisionRange.lo(), -divisionErrorUlps, numBits), minExponent, numBits),
506 const tcu::Interval finalResultRange (divisionResultRange.lo() - surfaceThreshold[c], divisionResultRange.hi() + surfaceThreshold[c]);
594 virtual void setup (ShaderRenderCaseInstance& instance, const tcu::Vec4&) const;
597 const bool m_useSampler;
615 const UniformSetup& uniformSetup,
616 const DerivateCaseDefinition& definitions,
617 const DerivateCaseValues& values);
624 virtual bool verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask) = 0;
625 tcu::Vec4 getSurfaceThreshold (void) const;
628 const DerivateCaseDefinition& m_definitions;
629 const DerivateCaseValues& m_values;
646 const UniformSetup& uniformSetup,
647 const DerivateCaseDefinition& definitions,
648 const DerivateCaseValues& values)
663 tcu::Vec4 TriangleDerivateCaseInstance::getSurfaceThreshold (void) const
677 const int numVertices = 4;
678 const float positions[] =
685 const float coords[] =
701 const deUint32 numVertices = 4;
702 const deUint32 numTriangles = 2;
703 const deUint16 indices[] = { 0, 2, 1, 2, 3, 1 };
711 const tcu::TextureLevel& renderedImage = getResultImage();
715 const tcu::TextureFormat dataFormat (tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT);
731 const bool isOk = verify(resultImage.getAccess(), errorMask.getAccess());
748 void DerivateUniformSetup::setup (ShaderRenderCaseInstance& instance, const tcu::Vec4&) const
768 const std::string& name,
769 const UniformSetup* uniformSetup);
772 void checkSupport (Context& context) const override;
780 const std::string& name,
781 const UniformSetup* uniformSetup)
791 void TriangleDerivateCase::checkSupport (Context& context) const
795 const bool subgroupFunc = isSubgroupFunc(m_definitions.func);
799 const std::string errorPrefix = m_definitions.inNonUniformControlFlow
806 const auto& subgroupProperties = context.getSubgroupProperties();
826 const std::string vertexTmpl =
857 const UniformSetup& uniformSetup,
858 const DerivateCaseDefinition& definitions,
859 const DerivateCaseValues& values);
862 virtual bool verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask);
866 const UniformSetup& uniformSetup,
867 const DerivateCaseDefinition& definitions,
868 const DerivateCaseValues& values)
877 bool ConstantDerivateCaseInstance::verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask)
879 const tcu::Vec4 reference (0.0f); // Derivate of constant argument should always be 0
880 const tcu::Vec4 threshold = getSurfaceThreshold() / abs(m_values.derivScale);
892 const std::string& name,
897 virtual void initPrograms (vk::SourceCollections& programCollection) const;
898 virtual TestInstance* createInstance (Context& context) const;
902 const std::string& name,
919 TestInstance* ConstantDerivateCase::createInstance (Context& context) const
925 void ConstantDerivateCase::initPrograms (vk::SourceCollections& programCollection) const
927 const char* fragmentTmpl =
964 virtual void setup (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords) const;
967 const BaseUniformType m_usedDefaultUniform;
980 void LinearDerivateUniformSetup::setup (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords) const
1002 const UniformSetup& uniformSetup,
1003 const DerivateCaseDefinition& definitions,
1004 const DerivateCaseValues& values);
1007 virtual bool verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask);
1011 const UniformSetup& uniformSetup,
1012 const DerivateCaseDefinition& definitions,
1013 const DerivateCaseValues& values)
1022 bool LinearDerivateCaseInstance::verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask)
1024 const tcu::Vec4 xScale = tcu::Vec4(1.0f, 0.0f, 0.5f, -0.5f);
1025 const tcu::Vec4 yScale = tcu::Vec4(0.0f, 1.0f, 0.5f, -0.5f);
1026 const tcu::Vec4 surfaceThreshold = getSurfaceThreshold() / abs(m_values.derivScale);
1030 const bool isX = isDfdxFunc(m_definitions.func);
1031 const float div = isX ? float(result.getWidth()) : float(result.getHeight());
1032 const tcu::Vec4 scale = isX ? xScale : yScale;
1034 const tcu::Vec4 opThreshold = getDerivateThreshold(m_definitions.precision, m_values.coordMin, m_values.coordMax, reference);
1035 const tcu::Vec4 threshold = max(surfaceThreshold, opThreshold);
1036 const int numComps = glu::getDataTypeFloatScalars(m_definitions.dataType);
1071 const tcu::UVec2 viewportSize (VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1072 const float w = float(viewportSize.x());
1073 const float h = float(viewportSize.y());
1074 const tcu::Vec4 valueRamp = (m_values.coordMax - m_values.coordMin);
1091 const float w = float(result.getWidth());
1092 const float h = float(result.getHeight());
1094 const tcu::Vec4 dx = ((m_values.coordMax - m_values.coordMin) / w) * xScale;
1095 const tcu::Vec4 dy = ((m_values.coordMax - m_values.coordMin) / h) * yScale;
1096 const tcu::Vec4 reference = tcu::abs(dx) + tcu::abs(dy);
1097 const tcu::Vec4 dxThreshold = getDerivateThreshold(m_definitions.precision, m_values.coordMin*xScale, m_values.coordMax*xScale, dx);
1098 const tcu::Vec4 dyThreshold = getDerivateThreshold(m_definitions.precision, m_values.coordMin*yScale, m_values.coordMax*yScale, dy);
1099 const tcu::Vec4 threshold = max(surfaceThreshold, max(dxThreshold, dyThreshold));
1112 const std::string& name,
1119 const std::string& fragmentSrcTmpl,
1123 virtual void initPrograms (vk::SourceCollections& programCollection) const;
1124 virtual TestInstance* createInstance (Context& context) const;
1127 const std::string m_fragmentTmpl;
1131 const std::string& name,
1138 const std::string& fragmentSrcTmpl,
1152 const tcu::UVec2 viewportSize (VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1153 const float w = float(viewportSize.x());
1154 const float h = float(viewportSize.y());
1186 const tcu::Vec4 dx = (m_values.coordMax - m_values.coordMin) / tcu::Vec4(w, w, w*0.5f, -w*0.5f);
1187 const tcu::Vec4 dy = (m_values.coordMax - m_values.coordMin) / tcu::Vec4(h, h, h*0.5f, -h*0.5f);
1206 TestInstance* LinearDerivateCase::createInstance (Context& context) const
1212 void LinearDerivateCase::initPrograms (vk::SourceCollections& programCollection) const
1214 const SpirvVersion spirvVersion = (m_definitions.inNonUniformControlFlow || isSubgroupFunc(m_definitions.func)) ? vk::SPIRV_VERSION_1_3 : vk::SPIRV_VERSION_1_0;
1215 const vk::ShaderBuildOptions buildOptions(programCollection.usedVulkanVersion, spirvVersion, 0u);
1217 const bool packToInt = m_definitions.surfaceType == SURFACETYPE_FLOAT_FBO;
1252 const UniformSetup& uniformSetup,
1253 const DerivateCaseDefinition& definitions,
1254 const DerivateCaseValues& values,
1255 const TextureCaseValues& textureValues);
1258 virtual bool verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask);
1261 const TextureCaseValues& m_textureValues;
1265 const UniformSetup& uniformSetup,
1266 const DerivateCaseDefinition& definitions,
1267 const DerivateCaseValues& values,
1268 const TextureCaseValues& textureValues)
1276 const tcu::UVec2 viewportSize (VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1277 const tcu::TextureFormat format = glu::mapGLInternalFormat(m_definitions.precision == glu::PRECISION_HIGHP ? GL_RGBA32F : GL_RGBA16F);
1285 const tcu::PixelBufferAccess level0 = texture->getLevel(0);
1290 const float xf = (float(x)+0.5f) / float(level0.getWidth());
1291 const float yf = (float(y)+0.5f) / float(level0.getHeight());
1292 const tcu::Vec4 s = tcu::Vec4(xf, yf, (xf+yf)/2.0f, 1.0f - (xf+yf)/2.0f);
1318 bool TextureDerivateCaseInstance::verify (const tcu::ConstPixelBufferAccess& result, const tcu::PixelBufferAccess& errorMask)
1326 const tcu::Vec4 xScale = tcu::Vec4(1.0f, 0.0f, 0.5f, -0.5f);
1327 const tcu::Vec4 yScale = tcu::Vec4(0.0f, 1.0f, 0.5f, -0.5f);
1328 const float w = float(result.getWidth());
1329 const float h = float(result.getHeight());
1331 const tcu::Vec4 surfaceThreshold = getSurfaceThreshold() / abs(m_values.derivScale);
1335 const bool isX = isDfdxFunc(m_definitions.func);
1336 const float div = isX ? w : h;
1337 const tcu::Vec4 scale = isX ? xScale : yScale;
1339 const tcu::Vec4 opThreshold = getDerivateThreshold(m_definitions.precision, m_textureValues.texValueMin, m_textureValues.texValueMax, reference);
1340 const tcu::Vec4 threshold = max(surfaceThreshold, opThreshold);
1341 const int numComps = glu::getDataTypeFloatScalars(m_definitions.dataType);
1376 const tcu::Vec4 valueRamp = (m_textureValues.texValueMax - m_textureValues.texValueMin);
1393 const tcu::Vec4 dx = ((m_textureValues.texValueMax - m_textureValues.texValueMin) / w) * xScale;
1394 const tcu::Vec4 dy = ((m_textureValues.texValueMax - m_textureValues.texValueMin) / h) * yScale;
1395 const tcu::Vec4 reference = tcu::abs(dx) + tcu::abs(dy);
1396 const tcu::Vec4 dxThreshold = getDerivateThreshold(m_definitions.precision, m_textureValues.texValueMin*xScale, m_textureValues.texValueMax*xScale, dx);
1397 const tcu::Vec4 dyThreshold = getDerivateThreshold(m_definitions.precision, m_textureValues.texValueMin*yScale, m_textureValues.texValueMax*yScale, dy);
1398 const tcu::Vec4 threshold = max(surfaceThreshold, max(dxThreshold, dyThreshold));
1411 const std::string& name,
1419 virtual void initPrograms (vk::SourceCollections& programCollection) const;
1420 virtual TestInstance* createInstance (Context& context) const;
1427 const std::string& name,
1482 const tcu::UVec2 viewportSize (VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
1483 const float w = float(viewportSize.x());
1484 const float h = float(viewportSize.y());
1485 const tcu::Vec4 dx = (m_textureValues.texValueMax - m_textureValues.texValueMin) / tcu::Vec4(w, w, w*0.5f, -w*0.5f);
1486 const tcu::Vec4 dy = (m_textureValues.texValueMax - m_textureValues.texValueMin) / tcu::Vec4(h, h, h*0.5f, -h*0.5f);
1505 TestInstance* TextureDerivateCase::createInstance (Context& context) const
1511 void TextureDerivateCase::initPrograms (vk::SourceCollections& programCollection) const
1515 const char* fragmentTmpl =
1529 const bool packToInt = m_definitions.surfaceType == SURFACETYPE_FLOAT_FBO;
1574 ShaderDerivateTests (const ShaderDerivateTests&); // not allowed!
1575 ShaderDerivateTests& operator= (const ShaderDerivateTests&); // not allowed!
1594 FunctionSpec (const std::string& name_, DerivateFunc function_, glu::DataType dataType_, glu::Precision precision_)
1605 static const struct
1607 const char* name;
1608 const char* description;
1609 const char* source;
1877 const char* dFdxSubgroupSource =
1905 const char* dFdySubgroupSource =
1934 static const struct
1936 const char* name;
1947 static const struct
1949 const char* name;
1962 const DerivateFunc function = DerivateFunc(funcNdx);
1973 const glu::DataType dataType = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
1986 const char* source = s_linearDerivateCases[caseNdx].source;
1992 const glu::DataType dataType = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
1993 const glu::Precision precision = glu::Precision(precNdx);
1994 const SurfaceType surfaceType = SURFACETYPE_UNORM_FBO;
1995 const int numSamples = 0;
2016 const char* source = function == DERIVATE_DFDXSUBGROUP ? dFdxSubgroupSource :
2019 const SurfaceType surfaceType = s_fboConfigs[caseNdx].surfaceType;
2020 const int numSamples = s_fboConfigs[caseNdx].numSamples;
2026 const glu::DataType dataType = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
2027 const glu::Precision precision = glu::Precision(precNdx);
2050 const SurfaceType surfaceType = s_textureConfigs[texCaseNdx].surfaceType;
2051 const int numSamples = s_textureConfigs[texCaseNdx].numSamples;
2057 const glu::DataType dataType = vecSize > 1 ? glu::getDataTypeFloatVec(vecSize) : glu::TYPE_FLOAT;
2058 const glu::Precision precision = glu::Precision(precNdx);