| #ifndef _GLUTEXTURETESTUTIL_HPP |
| #define _GLUTEXTURETESTUTIL_HPP |
| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Utility functions and structures for texture tests. |
| * |
| * This code is originated from the modules/glshared/glsTextureTestUtil.hpp |
| * and it is tightly coupled with the GLES and Vulkan texture tests! |
| * |
| * About coordinates: |
| * + Quads consist of 2 triangles, rendered using explicit indices. |
| * + All TextureTestUtil functions and classes expect texture coordinates |
| * for quads to be specified in order (-1, -1), (-1, 1), (1, -1), (1, 1). |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "tcuDefs.hpp" |
| #include "tcuSurfaceAccess.hpp" |
| #include "tcuTestContext.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuTexture.hpp" |
| #include "tcuTexCompareVerifier.hpp" |
| #include "qpWatchDog.h" |
| |
| namespace glu |
| { |
| namespace TextureTestUtil |
| { |
| enum TextureType |
| { |
| TEXTURETYPE_2D = 0, |
| TEXTURETYPE_CUBE, |
| TEXTURETYPE_2D_ARRAY, |
| TEXTURETYPE_3D, |
| TEXTURETYPE_CUBE_ARRAY, |
| TEXTURETYPE_1D, |
| TEXTURETYPE_1D_ARRAY, |
| TEXTURETYPE_BUFFER, |
| |
| TEXTURETYPE_LAST |
| }; |
| |
| enum SamplerType |
| { |
| SAMPLERTYPE_FLOAT, |
| SAMPLERTYPE_INT, |
| SAMPLERTYPE_UINT, |
| SAMPLERTYPE_SHADOW, |
| |
| SAMPLERTYPE_FETCH_FLOAT, |
| SAMPLERTYPE_FETCH_INT, |
| SAMPLERTYPE_FETCH_UINT, |
| |
| SAMPLERTYPE_LAST |
| }; |
| |
| struct RenderParams |
| { |
| enum Flags |
| { |
| PROJECTED = (1<<0), |
| USE_BIAS = (1<<1), |
| LOG_PROGRAMS = (1<<2), |
| LOG_UNIFORMS = (1<<3), |
| |
| LOG_ALL = LOG_PROGRAMS|LOG_UNIFORMS |
| }; |
| |
| RenderParams (TextureType texType_) |
| : texType (texType_) |
| , samplerType (SAMPLERTYPE_FLOAT) |
| , flags (0) |
| , w (1.0f) |
| , bias (0.0f) |
| , ref (0.0f) |
| , colorScale (1.0f) |
| , colorBias (0.0f) |
| { |
| } |
| |
| TextureType texType; //!< Texture type. |
| SamplerType samplerType; //!< Sampler type. |
| deUint32 flags; //!< Feature flags. |
| tcu::Vec4 w; //!< w coordinates for quad vertices. |
| float bias; //!< User-supplied bias. |
| float ref; //!< Reference value for shadow lookups. |
| |
| // color = lookup() * scale + bias |
| tcu::Vec4 colorScale; //!< Scale for texture color values. |
| tcu::Vec4 colorBias; //!< Bias for texture color values. |
| }; |
| |
| enum LodMode |
| { |
| LODMODE_EXACT = 0, //!< Ideal lod computation. |
| LODMODE_MIN_BOUND, //!< Use estimation range minimum bound. |
| LODMODE_MAX_BOUND, //!< Use estimation range maximum bound. |
| |
| LODMODE_LAST |
| }; |
| |
| struct ReferenceParams : public RenderParams |
| { |
| ReferenceParams (TextureType texType_) |
| : RenderParams (texType_) |
| , sampler () |
| , lodMode (LODMODE_EXACT) |
| , minLod (-1000.0f) |
| , maxLod (1000.0f) |
| , baseLevel (0) |
| , maxLevel (1000) |
| , unnormal (false) |
| { |
| } |
| |
| ReferenceParams (TextureType texType_, const tcu::Sampler& sampler_, LodMode lodMode_ = LODMODE_EXACT) |
| : RenderParams (texType_) |
| , sampler (sampler_) |
| , lodMode (lodMode_) |
| , minLod (-1000.0f) |
| , maxLod (1000.0f) |
| , baseLevel (0) |
| , maxLevel (1000) |
| , unnormal (false) |
| { |
| } |
| |
| tcu::Sampler sampler; |
| LodMode lodMode; |
| float minLod; |
| float maxLod; |
| int baseLevel; |
| int maxLevel; |
| bool unnormal; |
| }; |
| |
| |
| SamplerType getSamplerType (tcu::TextureFormat format); |
| SamplerType getFetchSamplerType (tcu::TextureFormat format); |
| |
| // Similar to sampleTexture() except uses texelFetch. |
| void fetchTexture (const tcu::SurfaceAccess& dst, const tcu::ConstPixelBufferAccess& src, const float* texCoord, const tcu::Vec4& colorScale, const tcu::Vec4& colorBias); |
| |
| void sampleTexture (const tcu::SurfaceAccess& dst, const tcu::Texture2DView& src, const float* texCoord, const ReferenceParams& params); |
| void sampleTexture (const tcu::SurfaceAccess& dst, const tcu::TextureCubeView& src, const float* texCoord, const ReferenceParams& params); |
| void sampleTexture (const tcu::SurfaceAccess& dst, const tcu::Texture2DArrayView& src, const float* texCoord, const ReferenceParams& params); |
| void sampleTexture (const tcu::SurfaceAccess& dst, const tcu::Texture3DView& src, const float* texCoord, const ReferenceParams& params); |
| void sampleTexture (const tcu::SurfaceAccess& dst, const tcu::TextureCubeArrayView& src, const float* texCoord, const ReferenceParams& params); |
| void sampleTexture (const tcu::SurfaceAccess& dst, const tcu::Texture1DView& src, const float* texCoord, const ReferenceParams& params); |
| void sampleTexture (const tcu::SurfaceAccess& dst, const tcu::Texture1DArrayView& src, const float* texCoord, const ReferenceParams& params); |
| |
| float computeLodFromDerivates (LodMode mode, float dudx, float dudy); |
| float computeLodFromDerivates (LodMode mode, float dudx, float dvdx, float dudy, float dvdy); |
| float computeLodFromDerivates (LodMode mode, float dudx, float dvdx, float dwdx, float dudy, float dvdy, float dwdy); |
| |
| void computeQuadTexCoord1D (std::vector<float>& dst, float left, float right); |
| void computeQuadTexCoord1DArray (std::vector<float>& dst, int layerNdx, float left, float right); |
| void computeQuadTexCoord2D (std::vector<float>& dst, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight); |
| void computeQuadTexCoord2DArray (std::vector<float>& dst, int layerNdx, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight); |
| void computeQuadTexCoord3D (std::vector<float>& dst, const tcu::Vec3& p0, const tcu::Vec3& p1, const tcu::IVec3& dirSwz); |
| void computeQuadTexCoordCube (std::vector<float>& dst, tcu::CubeFace face); |
| void computeQuadTexCoordCube (std::vector<float>& dst, tcu::CubeFace face, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight); |
| void computeQuadTexCoordCubeArray (std::vector<float>& dst, tcu::CubeFace face, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight, const tcu::Vec2& layerRange); |
| |
| bool compareImages (tcu::TestLog& log, const char* name, const char* desc, const tcu::Surface& reference, const tcu::Surface& rendered, tcu::RGBA threshold); |
| bool compareImages (tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& rendered, tcu::RGBA threshold); |
| int measureAccuracy (tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& rendered, int bestScoreDiff, int worstScoreDiff); |
| |
| int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::Texture1DView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| qpWatchDog* watchDog); |
| |
| int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::Texture2DView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| qpWatchDog* watchDog); |
| |
| int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::TextureCubeView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| qpWatchDog* watchDog); |
| |
| int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::Texture1DArrayView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| qpWatchDog* watchDog); |
| |
| int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::Texture2DArrayView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| qpWatchDog* watchDog); |
| |
| int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::Texture3DView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| qpWatchDog* watchDog); |
| |
| int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::TextureCubeArrayView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::IVec4& coordBits, |
| const tcu::LodPrecision& lodPrec, |
| qpWatchDog* watchDog); |
| |
| bool verifyTextureResult (tcu::TestContext& testCtx, |
| const tcu::ConstPixelBufferAccess& result, |
| const tcu::Texture1DView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::PixelFormat& pixelFormat); |
| |
| bool verifyTextureResult (tcu::TestContext& testCtx, |
| const tcu::ConstPixelBufferAccess& result, |
| const tcu::Texture2DView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::PixelFormat& pixelFormat); |
| |
| bool verifyTextureResult (tcu::TestContext& testCtx, |
| const tcu::ConstPixelBufferAccess& result, |
| const tcu::TextureCubeView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::PixelFormat& pixelFormat); |
| |
| bool verifyTextureResult (tcu::TestContext& testCtx, |
| const tcu::ConstPixelBufferAccess& result, |
| const tcu::Texture1DArrayView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::PixelFormat& pixelFormat); |
| |
| bool verifyTextureResult (tcu::TestContext& testCtx, |
| const tcu::ConstPixelBufferAccess& result, |
| const tcu::Texture2DArrayView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::PixelFormat& pixelFormat); |
| |
| bool verifyTextureResult (tcu::TestContext& testCtx, |
| const tcu::ConstPixelBufferAccess& result, |
| const tcu::Texture3DView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::PixelFormat& pixelFormat); |
| |
| bool verifyTextureResult (tcu::TestContext& testCtx, |
| const tcu::ConstPixelBufferAccess& result, |
| const tcu::TextureCubeArrayView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::LookupPrecision& lookupPrec, |
| const tcu::IVec4& coordBits, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::PixelFormat& pixelFormat); |
| |
| int computeTextureCompareDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::Texture2DView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::TexComparePrecision& comparePrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::Vec3& nonShadowThreshold); |
| |
| int computeTextureCompareDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::TextureCubeView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::TexComparePrecision& comparePrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::Vec3& nonShadowThreshold); |
| |
| int computeTextureCompareDiff (const tcu::ConstPixelBufferAccess& result, |
| const tcu::ConstPixelBufferAccess& reference, |
| const tcu::PixelBufferAccess& errorMask, |
| const tcu::Texture2DArrayView& src, |
| const float* texCoord, |
| const ReferenceParams& sampleParams, |
| const tcu::TexComparePrecision& comparePrec, |
| const tcu::LodPrecision& lodPrec, |
| const tcu::Vec3& nonShadowThreshold); |
| |
| |
| inline tcu::IVec4 getBitsVec (const tcu::PixelFormat& format) |
| { |
| return tcu::IVec4(format.redBits, format.greenBits, format.blueBits, format.alphaBits); |
| } |
| |
| inline tcu::BVec4 getCompareMask (const tcu::PixelFormat& format) |
| { |
| return tcu::BVec4(format.redBits > 0, |
| format.greenBits > 0, |
| format.blueBits > 0, |
| format.alphaBits > 0); |
| } |
| |
| |
| // Mipmap generation comparison. |
| |
| struct GenMipmapPrecision |
| { |
| tcu::IVec3 filterBits; //!< Bits in filtering parameters (fixed-point). |
| tcu::Vec4 colorThreshold; //!< Threshold for color value comparison. |
| tcu::BVec4 colorMask; //!< Color channel comparison mask. |
| }; |
| |
| qpTestResult compareGenMipmapResult (tcu::TestLog& log, const tcu::Texture2D& resultTexture, const tcu::Texture2D& level0Reference, const GenMipmapPrecision& precision); |
| qpTestResult compareGenMipmapResult (tcu::TestLog& log, const tcu::TextureCube& resultTexture, const tcu::TextureCube& level0Reference, const GenMipmapPrecision& precision); |
| |
| // Utility for logging texture gradient ranges. |
| struct LogGradientFmt |
| { |
| LogGradientFmt (const tcu::Vec4* min_, const tcu::Vec4* max_) : valueMin(min_), valueMax(max_) {} |
| const tcu::Vec4* valueMin; |
| const tcu::Vec4* valueMax; |
| }; |
| |
| std::ostream& operator<< (std::ostream& str, const LogGradientFmt& fmt); |
| inline LogGradientFmt formatGradient (const tcu::Vec4* minVal, const tcu::Vec4* maxVal) { return LogGradientFmt(minVal, maxVal); } |
| |
| } // TextureTestUtil |
| } // glu |
| |
| #endif // _GLUTEXTURETESTUTIL_HPP |
