--- /dev/null
+/*-------------------------------------------------------------------------
+ * OpenGL Conformance Test Suite
+ * -----------------------------
+ *
+ * Copyright (c) 2014-2019 The Khronos Group Inc.
+ *
+ * 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
+ */ /*-------------------------------------------------------------------*/
+
+/*!
+ * \file esextcTextureShadowLodFunctionsTest.cpp
+ * \brief EXT_texture_shadow_lod extension testing
+ */ /*-------------------------------------------------------------------*/
+
+#include "esextcTextureShadowLodFunctionsTest.hpp"
+#include "deMath.h"
+#include "glcShaderLibrary.hpp"
+#include "glcShaderRenderCase.hpp"
+#include "glsTextureTestUtil.hpp"
+#include "gluPixelTransfer.hpp"
+#include "gluStrUtil.hpp"
+#include "gluTexture.hpp"
+#include "gluTextureUtil.hpp"
+#include "glwFunctions.hpp"
+#include "tcuMatrix.hpp"
+#include "tcuMatrixUtil.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuTextureUtil.hpp"
+
+#include <sstream>
+
+#include "glwEnums.hpp"
+#include "glwFunctions.hpp"
+
+namespace deqp
+{
+namespace Functional
+{
+namespace
+{
+
+using glu::TextureTestUtil::computeLodFromDerivates;
+
+enum Function
+{
+ FUNCTION_TEXTURE = 0, //!< texture(), textureOffset()
+ FUNCTION_TEXTURELOD, // ...
+ FUNCTION_LAST
+};
+
+// For texture(..., [bias]) functions.
+inline bool functionHasAutoLod(glu::ShaderType shaderType, Function function)
+{
+ return (shaderType == glu::SHADERTYPE_FRAGMENT) && (function == FUNCTION_TEXTURE);
+}
+
+// For textureLod* functions.
+inline bool functionHasLod(Function function)
+{
+ return function == FUNCTION_TEXTURELOD;
+}
+
+struct TextureLookupSpec
+{
+ // The texture function to use.
+ Function function;
+
+ // Min/max texture coordinates.
+ tcu::Vec4 minCoord;
+ tcu::Vec4 maxCoord;
+
+ // Bias
+ bool useBias;
+
+ // Bias or Lod for *Lod* functions
+ float minLodBias;
+ float maxLodBias;
+
+ // For *Offset variants
+ bool useOffset;
+ tcu::IVec3 offset;
+
+ // Do we require an additional shadow ref "compare"
+ // parameter in the texture function's parameter list? (used for
+ // shadow cube array textures).
+ bool useSepRef;
+ float minSepRef;
+ float maxSepRef;
+
+ TextureLookupSpec(void)
+ : function(FUNCTION_LAST)
+ , minCoord(0.0f)
+ , maxCoord(1.0f)
+ , useBias(false)
+ , minLodBias(0.0f)
+ , maxLodBias(0.0f)
+ , useOffset(false)
+ , offset(0)
+ , useSepRef(false)
+ , minSepRef(0.0f)
+ , maxSepRef(0.0f)
+ {
+ }
+
+ TextureLookupSpec(Function function_, const tcu::Vec4& minCoord_, const tcu::Vec4& maxCoord_, bool useBias_,
+ float minLodBias_, float maxLodBias_, bool useOffset_, const tcu::IVec3& offset_, bool useSepRef_,
+ float minSepRef_, float maxSepRef_)
+ : function(function_)
+ , minCoord(minCoord_)
+ , maxCoord(maxCoord_)
+ , useBias(useBias_)
+ , minLodBias(minLodBias_)
+ , maxLodBias(maxLodBias_)
+ , useOffset(useOffset_)
+ , offset(offset_)
+ , useSepRef(useSepRef_)
+ , minSepRef(minSepRef_)
+ , maxSepRef(maxSepRef_)
+ {
+ }
+};
+
+// Only shadow texture types contained in EXT_texture_shadow_lod will be tested.
+enum TextureType
+{
+ TEXTURETYPE_2D,
+ TEXTURETYPE_CUBE_MAP,
+ TEXTURETYPE_CUBE_MAP_ARRAY,
+ TEXTURETYPE_2D_ARRAY,
+
+ TEXTURETYPE_LAST
+};
+
+struct TextureSpec
+{
+ TextureType type; //!< Texture type (2D, cubemap, ...)
+ deUint32 format; //!< Internal format.
+ int width;
+ int height;
+ int depth;
+ int numLevels;
+ tcu::Sampler sampler;
+
+ TextureSpec(void) : type(TEXTURETYPE_LAST), format(GL_NONE), width(0), height(0), depth(0), numLevels(0)
+ {
+ }
+
+ TextureSpec(TextureType type_, deUint32 format_, int width_, int height_, int depth_, int numLevels_,
+ const tcu::Sampler& sampler_)
+ : type(type_)
+ , format(format_)
+ , width(width_)
+ , height(height_)
+ , depth(depth_)
+ , numLevels(numLevels_)
+ , sampler(sampler_)
+ {
+ }
+};
+
+struct TexLookupParams
+{
+ float lod;
+ tcu::IVec3 offset;
+ tcu::Vec4 scale;
+ tcu::Vec4 bias;
+
+ TexLookupParams(void) : lod(0.0f), offset(0), scale(1.0f), bias(0.0f)
+ {
+ }
+};
+
+} // namespace
+
+using tcu::IVec2;
+using tcu::IVec3;
+using tcu::IVec4;
+using tcu::Vec2;
+using tcu::Vec3;
+using tcu::Vec4;
+
+static const glu::TextureTestUtil::LodMode DEFAULT_LOD_MODE = glu::TextureTestUtil::LODMODE_EXACT;
+
+typedef void (*TexEvalFunc)(ShaderEvalContext& c, const TexLookupParams& lookupParams);
+
+inline float texture2DShadow(const ShaderEvalContext& c, float ref, float s, float t, float lod)
+{
+ return c.textures[0].tex2D->sampleCompare(c.textures[0].sampler, ref, s, t, lod);
+}
+inline float texture2DArrayShadow(const ShaderEvalContext& c, float ref, float s, float t, float r, float lod)
+{
+ return c.textures[0].tex2DArray->sampleCompare(c.textures[0].sampler, ref, s, t, r, lod);
+}
+inline float textureCubeShadow(const ShaderEvalContext& c, float ref, float s, float t, float r, float lod)
+{
+ return c.textures[0].texCube->sampleCompare(c.textures[0].sampler, ref, s, t, r, lod);
+}
+inline float textureCubeArrayShadow(const ShaderEvalContext& c, float ref, float s, float t, float r, float q,
+ float lod)
+{
+ return c.textures[0].texCubeArray->sampleCompare(c.textures[0].sampler, ref, s, t, r, q, lod);
+}
+inline float texture2DShadowOffset(const ShaderEvalContext& c, float ref, float s, float t, float lod, IVec2 offset)
+{
+ return c.textures[0].tex2D->sampleCompareOffset(c.textures[0].sampler, ref, s, t, lod, offset);
+}
+inline float texture2DArrayShadowOffset(const ShaderEvalContext& c, float ref, float s, float t, float r, float lod,
+ IVec2 offset)
+{
+ return c.textures[0].tex2DArray->sampleCompareOffset(c.textures[0].sampler, ref, s, t, r, lod, offset);
+}
+
+// Shadow evaluation functions
+static void evalTexture2DArrayShadow(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() = texture2DArrayShadow(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), p.lod);
+}
+static void evalTexture2DArrayShadowBias(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() = texture2DArrayShadow(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), p.lod + c.in[1].x());
+}
+static void evalTexture2DArrayShadowOffset(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() = texture2DArrayShadowOffset(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), p.lod,
+ p.offset.swizzle(0, 1));
+}
+static void evalTexture2DArrayShadowOffsetBias(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() = texture2DArrayShadowOffset(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), p.lod + c.in[1].x(),
+ p.offset.swizzle(0, 1));
+}
+
+static void evalTexture2DArrayShadowLod(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ (void)p;
+ c.color.x() = texture2DArrayShadow(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), c.in[1].x());
+}
+static void evalTexture2DArrayShadowLodOffset(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() = texture2DArrayShadowOffset(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), c.in[1].x(),
+ p.offset.swizzle(0, 1));
+}
+
+static void evalTextureCubeShadow(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() = textureCubeShadow(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), p.lod);
+}
+static void evalTextureCubeShadowBias(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() = textureCubeShadow(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), p.lod + c.in[1].x());
+}
+static void evalTextureCubeShadowLod(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ (void)p;
+ c.color.x() = textureCubeShadow(c, c.in[0].w(), c.in[0].x(), c.in[0].y(), c.in[0].z(), c.in[1].x());
+}
+
+static void evalTextureCubeArrayShadow(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() = textureCubeArrayShadow(c, c.in[1].y(), c.in[0].x(), c.in[0].y(), c.in[0].z(), c.in[0].w(), p.lod);
+}
+static void evalTextureCubeArrayShadowBias(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ c.color.x() =
+ textureCubeArrayShadow(c, c.in[1].y(), c.in[0].x(), c.in[0].y(), c.in[0].z(), c.in[0].w(), p.lod + c.in[1].x());
+}
+static void evalTextureCubeArrayShadowLod(ShaderEvalContext& c, const TexLookupParams& p)
+{
+ (void)p;
+ c.color.x() =
+ textureCubeArrayShadow(c, c.in[1].y(), c.in[0].x(), c.in[0].y(), c.in[0].z(), c.in[0].w(), c.in[1].x());
+}
+
+class TexLookupEvaluator : public ShaderEvaluator
+{
+public:
+ TexLookupEvaluator(TexEvalFunc evalFunc, const TexLookupParams& lookupParams)
+ : m_evalFunc(evalFunc), m_lookupParams(lookupParams)
+ {
+ }
+
+ virtual void evaluate(ShaderEvalContext& ctx)
+ {
+ m_evalFunc(ctx, m_lookupParams);
+ }
+
+private:
+ TexEvalFunc m_evalFunc;
+ const TexLookupParams& m_lookupParams;
+};
+
+class TextureShadowLodTestCase : public ShaderRenderCase
+{
+public:
+ TextureShadowLodTestCase(Context& context, const char* name, const char* desc, const TextureLookupSpec& lookup,
+ const TextureSpec& texture, TexEvalFunc evalFunc, bool isVertexCase);
+ ~TextureShadowLodTestCase(void);
+
+ void init(void);
+ void deinit(void);
+
+protected:
+ void setupUniforms(deUint32 programID, const tcu::Vec4& constCoords);
+
+private:
+ void initTexture(void);
+ void initShaderSources(void);
+
+ TextureLookupSpec m_lookupSpec;
+ TextureSpec m_textureSpec;
+
+ TexLookupParams m_lookupParams;
+ TexLookupEvaluator m_evaluator;
+
+ glu::Texture2D* m_texture2D;
+ glu::TextureCube* m_textureCube;
+ glu::TextureCubeArray* m_textureCubeArray;
+ glu::Texture2DArray* m_texture2DArray;
+};
+
+TextureShadowLodTestCase::TextureShadowLodTestCase(Context& context, const char* name, const char* desc,
+ const TextureLookupSpec& lookup, const TextureSpec& texture,
+ TexEvalFunc evalFunc, bool isVertexCase)
+ : ShaderRenderCase(context.getTestContext(), context.getRenderContext(), context.getContextInfo(), name, desc,
+ isVertexCase, m_evaluator)
+ , m_lookupSpec(lookup)
+ , m_textureSpec(texture)
+ , m_evaluator(evalFunc, m_lookupParams)
+ , m_texture2D(DE_NULL)
+ , m_textureCube(DE_NULL)
+ , m_textureCubeArray(DE_NULL)
+ , m_texture2DArray(DE_NULL)
+{
+}
+
+TextureShadowLodTestCase::~TextureShadowLodTestCase(void)
+{
+ delete m_texture2D;
+ delete m_textureCube;
+ delete m_textureCubeArray;
+ delete m_texture2DArray;
+}
+
+void TextureShadowLodTestCase::init(void)
+{
+ // Check extension and other features are supported with this context/platform.
+ {
+ glu::ContextInfo* info = glu::ContextInfo::create(m_renderCtx);
+
+ // First check if extension is available.
+ if (!info->isExtensionSupported("GL_EXT_texture_shadow_lod"))
+ {
+ throw tcu::NotSupportedError("EXT_texture_shadow_lod is not supported on the platform");
+ }
+
+ // Check that API support and that the various texture_cube_map_array extension is supported based on GL / ES versions.
+
+ if (glu::isContextTypeES(m_renderCtx.getType()))
+ {
+ // ES
+ if (!glu::contextSupports(m_renderCtx.getType(), glu::ApiType::es(3, 0)))
+ {
+ throw tcu::NotSupportedError(
+ "EXT_texture_shadow_lod is not supported due to minimum ES version requirements");
+ }
+
+ // Check if cube map array is supported. For ES, it is supported
+ // as of ES 3.2, or with OES_texture_cube_map_array for
+ // 3.1.
+ if (m_textureSpec.type == TEXTURETYPE_CUBE_MAP_ARRAY)
+ {
+ if (!glu::contextSupports(m_renderCtx.getType(), glu::ApiType::es(3, 2)) &&
+ !(glu::contextSupports(m_renderCtx.getType(), glu::ApiType::es(3, 1)) &&
+ (info->isExtensionSupported("GL_OES_texture_cube_map_array") ||
+ info->isExtensionSupported("GL_EXT_texture_cube_map_array"))))
+ {
+ throw tcu::NotSupportedError("GL_OES_texture_cube_map_array or GL_EXT_texture_cube_map_array is "
+ "required for this configuration and is not available.");
+ }
+ }
+ }
+ else
+ {
+ // GL
+ if (!glu::contextSupports(m_renderCtx.getType(), glu::ApiType::core(2, 0)))
+ {
+ throw tcu::NotSupportedError(
+ "EXT_texture_shadow_lod is not supported due to minimum GL version requirements");
+ }
+
+ // Check if cube map array is supported. For GL, it is supported
+ // as of GL 4.0 core, or with ARB_texture_cube_map_array prior.
+ if (m_textureSpec.type == TEXTURETYPE_CUBE_MAP_ARRAY)
+ {
+ if (!glu::contextSupports(m_renderCtx.getType(), glu::ApiType::core(4, 0)) &&
+ !info->isExtensionSupported("GL_ARB_texture_cube_map_array"))
+ {
+ throw tcu::NotSupportedError(
+ "ARB_texture_cube_map_array is required for this configuration and is not available.");
+ }
+ }
+ }
+ }
+
+ // Set up the user attributes.
+ // The user attributes are set up as matrices where each row represents a component
+ // in the attribute transformed against the vertex's interpolated position across the grid.
+ {
+ // Base coord scale & bias
+ Vec4 s = m_lookupSpec.maxCoord - m_lookupSpec.minCoord;
+ Vec4 b = m_lookupSpec.minCoord;
+
+ float baseCoordTrans[] = { s.x(), 0.0f, 0.f, b.x(),
+ 0.f, s.y(), 0.f, b.y(),
+ s.z() / 2.f, -s.z() / 2.f, 0.f, s.z() / 2.f + b.z(),
+ -s.w() / 2.f, s.w() / 2.f, 0.f, s.w() / 2.f + b.w() };
+
+ //a_in0
+ m_userAttribTransforms.push_back(tcu::Mat4(baseCoordTrans));
+ }
+
+ bool hasLodBias = functionHasLod(m_lookupSpec.function) || m_lookupSpec.useBias;
+
+ if (hasLodBias || m_lookupSpec.useSepRef)
+ {
+ float s = 0.0f;
+ float b = 0.0f;
+ float sepRefS = 0.0f;
+ float sepRefB = 0.0f;
+
+ if (hasLodBias)
+ {
+ s = m_lookupSpec.maxLodBias - m_lookupSpec.minLodBias;
+ b = m_lookupSpec.minLodBias;
+ }
+
+ if (m_lookupSpec.useSepRef)
+ {
+ sepRefS = m_lookupSpec.maxSepRef - m_lookupSpec.minSepRef;
+ sepRefB = m_lookupSpec.minSepRef;
+ }
+ float lodCoordTrans[] = { s / 2.0f, s / 2.0f, 0.f, b, sepRefS / 2.0f, sepRefS / 2.0f, 0.0f, sepRefB,
+ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+
+ //a_in1
+ m_userAttribTransforms.push_back(tcu::Mat4(lodCoordTrans));
+ }
+
+ initShaderSources();
+ initTexture();
+
+ ShaderRenderCase::init();
+}
+
+void TextureShadowLodTestCase::initTexture(void)
+{
+ static const IVec4 texCubeSwz[] = { IVec4(0, 0, 1, 1), IVec4(1, 1, 0, 0), IVec4(0, 1, 0, 1),
+ IVec4(1, 0, 1, 0), IVec4(0, 1, 1, 0), IVec4(1, 0, 0, 1) };
+ DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(texCubeSwz) == tcu::CUBEFACE_LAST);
+
+ tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_textureSpec.format);
+ tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt);
+ tcu::IVec2 viewportSize = getViewportSize();
+ bool isAutoLod = functionHasAutoLod(m_isVertexCase ? glu::SHADERTYPE_VERTEX : glu::SHADERTYPE_FRAGMENT,
+ m_lookupSpec.function); // LOD can vary significantly
+
+ switch (m_textureSpec.type)
+ {
+ case TEXTURETYPE_2D:
+ {
+ float levelStep = isAutoLod ? 0.0f : 1.0f / (float)de::max(1, m_textureSpec.numLevels - 1);
+ Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin;
+ Vec4 cBias = fmtInfo.valueMin;
+ int baseCellSize = de::min(m_textureSpec.width / 4, m_textureSpec.height / 4);
+
+ m_texture2D = new glu::Texture2D(m_renderCtx, m_textureSpec.format, m_textureSpec.width, m_textureSpec.height);
+ for (int level = 0; level < m_textureSpec.numLevels; level++)
+ {
+ float fA = float(level) * levelStep;
+ float fB = 1.0f - fA;
+ Vec4 colorA = cBias + cScale * Vec4(fA, fB, fA, fB);
+ Vec4 colorB = cBias + cScale * Vec4(fB, fA, fB, fA);
+
+ m_texture2D->getRefTexture().allocLevel(level);
+ tcu::fillWithGrid(m_texture2D->getRefTexture().getLevel(level), de::max(1, baseCellSize >> level), colorA,
+ colorB);
+ }
+ m_texture2D->upload();
+
+ // Compute LOD.
+ float dudx =
+ (m_lookupSpec.maxCoord[0] - m_lookupSpec.minCoord[0]) * (float)m_textureSpec.width / (float)viewportSize[0];
+ float dvdy = (m_lookupSpec.maxCoord[1] - m_lookupSpec.minCoord[1]) * (float)m_textureSpec.height /
+ (float)viewportSize[1];
+ m_lookupParams.lod = computeLodFromDerivates(DEFAULT_LOD_MODE, dudx, 0.0f, 0.0f, dvdy);
+
+ // Append to texture list.
+ m_textures.push_back(TextureBinding(m_texture2D, m_textureSpec.sampler));
+ break;
+ }
+
+ case TEXTURETYPE_2D_ARRAY:
+ {
+ float layerStep = 1.0f / (float)m_textureSpec.depth;
+ float levelStep =
+ isAutoLod ? 0.0f : 1.0f / (float)(de::max(1, m_textureSpec.numLevels - 1) * m_textureSpec.depth);
+ Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin;
+ Vec4 cBias = fmtInfo.valueMin;
+ int baseCellSize = de::min(m_textureSpec.width / 4, m_textureSpec.height / 4);
+
+ m_texture2DArray = new glu::Texture2DArray(m_renderCtx, m_textureSpec.format, m_textureSpec.width,
+ m_textureSpec.height, m_textureSpec.depth);
+ for (int level = 0; level < m_textureSpec.numLevels; level++)
+ {
+ m_texture2DArray->getRefTexture().allocLevel(level);
+ tcu::PixelBufferAccess levelAccess = m_texture2DArray->getRefTexture().getLevel(level);
+
+ for (int layer = 0; layer < levelAccess.getDepth(); layer++)
+ {
+ float fA = (float)layer * layerStep + (float)level * levelStep;
+ float fB = 1.0f - fA;
+ Vec4 colorA = cBias + cScale * Vec4(fA, fB, fA, fB);
+ Vec4 colorB = cBias + cScale * Vec4(fB, fA, fB, fA);
+
+ tcu::fillWithGrid(
+ tcu::getSubregion(levelAccess, 0, 0, layer, levelAccess.getWidth(), levelAccess.getHeight(), 1),
+ de::max(1, baseCellSize >> level), colorA, colorB);
+ }
+ }
+ m_texture2DArray->upload();
+
+ // Compute LOD.
+ float dudx =
+ (m_lookupSpec.maxCoord[0] - m_lookupSpec.minCoord[0]) * (float)m_textureSpec.width / (float)viewportSize[0];
+ float dvdy = (m_lookupSpec.maxCoord[1] - m_lookupSpec.minCoord[1]) * (float)m_textureSpec.height /
+ (float)viewportSize[1];
+ m_lookupParams.lod = computeLodFromDerivates(DEFAULT_LOD_MODE, dudx, 0.0f, 0.0f, dvdy);
+
+ // Append to texture list.
+ m_textures.push_back(TextureBinding(m_texture2DArray, m_textureSpec.sampler));
+ break;
+ }
+
+ case TEXTURETYPE_CUBE_MAP:
+ {
+ float levelStep = isAutoLod ? 0.0f : 1.0f / (float)de::max(1, m_textureSpec.numLevels - 1);
+ Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin;
+ Vec4 cBias = fmtInfo.valueMin;
+ Vec4 cCorner = cBias + cScale * 0.5f;
+ int baseCellSize = de::min(m_textureSpec.width / 4, m_textureSpec.height / 4);
+
+ DE_ASSERT(m_textureSpec.width == m_textureSpec.height);
+ m_textureCube = new glu::TextureCube(m_renderCtx, m_textureSpec.format, m_textureSpec.width);
+ for (int level = 0; level < m_textureSpec.numLevels; level++)
+ {
+ float fA = float(level) * levelStep;
+ float fB = 1.0f - fA;
+ Vec2 f(fA, fB);
+
+ for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
+ {
+ const IVec4& swzA = texCubeSwz[face];
+ IVec4 swzB = 1 - swzA;
+ Vec4 colorA = cBias + cScale * f.swizzle(swzA[0], swzA[1], swzA[2], swzA[3]);
+ Vec4 colorB = cBias + cScale * f.swizzle(swzB[0], swzB[1], swzB[2], swzB[3]);
+
+ m_textureCube->getRefTexture().allocLevel((tcu::CubeFace)face, level);
+ {
+ const tcu::PixelBufferAccess access =
+ m_textureCube->getRefTexture().getLevelFace(level, (tcu::CubeFace)face);
+ const int lastPix = access.getWidth() - 1;
+
+ tcu::fillWithGrid(access, de::max(1, baseCellSize >> level), colorA, colorB);
+
+ // Ensure all corners have identical colors in order to avoid dealing with ambiguous corner texel filtering
+ access.setPixel(cCorner, 0, 0);
+ access.setPixel(cCorner, 0, lastPix);
+ access.setPixel(cCorner, lastPix, 0);
+ access.setPixel(cCorner, lastPix, lastPix);
+ }
+ }
+ }
+ m_textureCube->upload();
+
+ // Compute LOD \note Assumes that only single side is accessed and R is constant major axis.
+ DE_ASSERT(de::abs(m_lookupSpec.minCoord[2] - m_lookupSpec.maxCoord[2]) < 0.005);
+ DE_ASSERT(de::abs(m_lookupSpec.minCoord[0]) < de::abs(m_lookupSpec.minCoord[2]) &&
+ de::abs(m_lookupSpec.maxCoord[0]) < de::abs(m_lookupSpec.minCoord[2]));
+ DE_ASSERT(de::abs(m_lookupSpec.minCoord[1]) < de::abs(m_lookupSpec.minCoord[2]) &&
+ de::abs(m_lookupSpec.maxCoord[1]) < de::abs(m_lookupSpec.minCoord[2]));
+
+ tcu::CubeFaceFloatCoords c00 =
+ tcu::getCubeFaceCoords(Vec3(m_lookupSpec.minCoord[0], m_lookupSpec.minCoord[1], m_lookupSpec.minCoord[2]));
+ tcu::CubeFaceFloatCoords c10 =
+ tcu::getCubeFaceCoords(Vec3(m_lookupSpec.maxCoord[0], m_lookupSpec.minCoord[1], m_lookupSpec.minCoord[2]));
+ tcu::CubeFaceFloatCoords c01 =
+ tcu::getCubeFaceCoords(Vec3(m_lookupSpec.minCoord[0], m_lookupSpec.maxCoord[1], m_lookupSpec.minCoord[2]));
+ float dudx = (c10.s - c00.s) * (float)m_textureSpec.width / (float)viewportSize[0];
+ float dvdy = (c01.t - c00.t) * (float)m_textureSpec.height / (float)viewportSize[1];
+
+ m_lookupParams.lod = computeLodFromDerivates(DEFAULT_LOD_MODE, dudx, 0.0f, 0.0f, dvdy);
+
+ m_textures.push_back(TextureBinding(m_textureCube, m_textureSpec.sampler));
+ break;
+ }
+
+ case TEXTURETYPE_CUBE_MAP_ARRAY:
+ {
+ float layerStep = 1.0f / (float)m_textureSpec.depth;
+ float levelStep =
+ isAutoLod ? 0.0f : 1.0f / (float)(de::max(1, m_textureSpec.numLevels - 1) * m_textureSpec.depth);
+ Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin;
+ Vec4 cBias = fmtInfo.valueMin;
+ Vec4 cCorner = cBias + cScale * 0.5f;
+ int baseCellSize = de::min(m_textureSpec.width / 4, m_textureSpec.height / 4);
+
+ DE_ASSERT(m_textureSpec.width == m_textureSpec.height);
+ // I think size here means width/height of cube tex
+ m_textureCubeArray =
+ new glu::TextureCubeArray(m_renderCtx, m_textureSpec.format, m_textureSpec.width, m_textureSpec.depth * 6);
+ // mipmap level
+ for (int level = 0; level < m_textureSpec.numLevels; level++)
+ {
+ m_textureCubeArray->getRefTexture().allocLevel(level);
+ tcu::PixelBufferAccess levelAccess = m_textureCubeArray->getRefTexture().getLevel(level);
+
+ //array layer
+ DE_ASSERT((levelAccess.getDepth() % 6) == 0);
+
+ for (int layer = 0; layer < levelAccess.getDepth() / 6; ++layer)
+ {
+ for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
+ {
+ float fA = (float)layer * layerStep + float(level) * levelStep;
+ float fB = 1.0f - fA;
+ Vec2 f(fA, fB);
+
+ const IVec4& swzA = texCubeSwz[face];
+ IVec4 swzB = 1 - swzA;
+ Vec4 colorA = cBias + cScale * f.swizzle(swzA[0], swzA[1], swzA[2], swzA[3]);
+ Vec4 colorB = cBias + cScale * f.swizzle(swzB[0], swzB[1], swzB[2], swzB[3]);
+
+ {
+ const tcu::PixelBufferAccess access = m_textureCubeArray->getRefTexture().getLevel(level);
+ const int lastPix = access.getWidth() - 1;
+
+ int layerFaceNdx = face + layer * 6;
+
+ DE_ASSERT(levelAccess.getWidth() == levelAccess.getHeight());
+ tcu::fillWithGrid(tcu::getSubregion(access, 0, 0, layerFaceNdx, levelAccess.getWidth(),
+ levelAccess.getHeight(), 1),
+ de::max(1, baseCellSize >> level), colorA, colorB);
+
+ // Ensure all corners have identical colors in order to avoid dealing with ambiguous corner texel filtering
+ access.setPixel(cCorner, 0, 0, layer);
+ access.setPixel(cCorner, 0, lastPix, layer);
+ access.setPixel(cCorner, lastPix, 0, layer);
+ access.setPixel(cCorner, lastPix, lastPix, layer);
+ }
+ }
+ }
+ }
+ m_textureCubeArray->upload();
+
+ // Compute LOD \note Assumes that only single side is accessed and R is constant major axis.
+ DE_ASSERT(de::abs(m_lookupSpec.minCoord[2] - m_lookupSpec.maxCoord[2]) < 0.005);
+ DE_ASSERT(de::abs(m_lookupSpec.minCoord[0]) < de::abs(m_lookupSpec.minCoord[2]) &&
+ de::abs(m_lookupSpec.maxCoord[0]) < de::abs(m_lookupSpec.minCoord[2]));
+ DE_ASSERT(de::abs(m_lookupSpec.minCoord[1]) < de::abs(m_lookupSpec.minCoord[2]) &&
+ de::abs(m_lookupSpec.maxCoord[1]) < de::abs(m_lookupSpec.minCoord[2]));
+
+ tcu::CubeFaceFloatCoords c00 =
+ tcu::getCubeFaceCoords(Vec3(m_lookupSpec.minCoord[0], m_lookupSpec.minCoord[1], m_lookupSpec.minCoord[2]));
+ tcu::CubeFaceFloatCoords c10 =
+ tcu::getCubeFaceCoords(Vec3(m_lookupSpec.maxCoord[0], m_lookupSpec.minCoord[1], m_lookupSpec.minCoord[2]));
+ tcu::CubeFaceFloatCoords c01 =
+ tcu::getCubeFaceCoords(Vec3(m_lookupSpec.minCoord[0], m_lookupSpec.maxCoord[1], m_lookupSpec.minCoord[2]));
+ float dudx = (c10.s - c00.s) * (float)m_textureSpec.width / (float)viewportSize[0];
+ float dvdy = (c01.t - c00.t) * (float)m_textureSpec.height / (float)viewportSize[1];
+
+ m_lookupParams.lod = computeLodFromDerivates(DEFAULT_LOD_MODE, dudx, 0.0f, 0.0f, dvdy);
+
+ m_textures.push_back(TextureBinding(m_textureCubeArray, m_textureSpec.sampler));
+ break;
+ }
+
+ default:
+ DE_ASSERT(DE_FALSE);
+ }
+
+ // Set lookup scale & bias
+ m_lookupParams.scale = fmtInfo.lookupScale;
+ m_lookupParams.bias = fmtInfo.lookupBias;
+ m_lookupParams.offset = m_lookupSpec.offset;
+}
+
+void TextureShadowLodTestCase::initShaderSources(void)
+{
+ Function function = m_lookupSpec.function;
+ bool isVtxCase = m_isVertexCase;
+ bool hasLodBias = functionHasLod(m_lookupSpec.function) || m_lookupSpec.useBias;
+ int texCoordComps = m_textureSpec.type == TEXTURETYPE_2D ? 2 : 3;
+ int extraCoordComps = 1; // For shadow ref
+ bool hasSepShadowRef = m_lookupSpec.useSepRef;
+ glu::DataType coordType = glu::getDataTypeFloatVec(texCoordComps + extraCoordComps);
+ glu::Precision coordPrec = glu::PRECISION_HIGHP;
+ const char* coordTypeName = glu::getDataTypeName(coordType);
+ const char* coordPrecName = glu::getPrecisionName(coordPrec);
+ glu::DataType samplerType = glu::TYPE_LAST;
+ const char* baseFuncName = DE_NULL;
+
+ switch (m_textureSpec.type)
+ {
+ case TEXTURETYPE_2D:
+ samplerType = glu::TYPE_SAMPLER_2D_SHADOW;
+ break;
+ case TEXTURETYPE_CUBE_MAP:
+ samplerType = glu::TYPE_SAMPLER_CUBE_SHADOW;
+ break;
+ case TEXTURETYPE_CUBE_MAP_ARRAY:
+ samplerType = glu::TYPE_SAMPLER_CUBE_ARRAY_SHADOW;
+ break;
+ case TEXTURETYPE_2D_ARRAY:
+ samplerType = glu::TYPE_SAMPLER_2D_ARRAY_SHADOW;
+ break;
+ default:
+ DE_ASSERT(DE_FALSE);
+ }
+
+ switch (m_lookupSpec.function)
+ {
+ case FUNCTION_TEXTURE:
+ baseFuncName = "texture";
+ break;
+ case FUNCTION_TEXTURELOD:
+ baseFuncName = "textureLod";
+ break;
+ default:
+ DE_ASSERT(DE_FALSE);
+ }
+
+ bool isGL = glu::isContextTypeGLCore(m_renderCtx.getType());
+ glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_renderCtx.getType());
+
+ std::string shaderVersion = glu::getGLSLVersionDeclaration(glslVersion);
+
+ std::ostringstream vert;
+ std::ostringstream frag;
+ std::ostringstream& op = isVtxCase ? vert : frag;
+
+ std::string cubeMapArrayEXT = "";
+
+ // Check if we need to add the texture_cube_map_array extension.
+ if (m_textureSpec.type == TEXTURETYPE_CUBE_MAP_ARRAY)
+ {
+ if (!glu::contextSupports(m_renderCtx.getType(), glu::ApiType::es(3, 2)) &&
+ !glu::contextSupports(m_renderCtx.getType(), glu::ApiType::core(4, 0)))
+ {
+ if (isGL)
+ {
+ cubeMapArrayEXT = "#extension GL_ARB_texture_cube_map_array : require\n";
+ }
+ else
+ {
+ glu::ContextInfo* info = glu::ContextInfo::create(m_renderCtx);
+ if (info->isExtensionSupported("GL_EXT_texture_cube_map_array"))
+ {
+ cubeMapArrayEXT = "#extension GL_EXT_texture_cube_map_array : require\n";
+ }
+ else
+ {
+ cubeMapArrayEXT = "#extension GL_OES_texture_cube_map_array : require\n";
+ }
+ }
+ }
+ }
+
+ vert << shaderVersion << "\n"
+ << "#extension GL_EXT_texture_shadow_lod : require\n\n";
+
+ vert << cubeMapArrayEXT;
+
+ vert << "in highp vec4 a_position;\n"
+ << "in " << coordPrecName << " " << coordTypeName << " a_in0;\n";
+
+ if (hasLodBias || hasSepShadowRef)
+ {
+ vert << "in " << coordPrecName << " vec4 a_in1;\n";
+ }
+
+ frag << shaderVersion << "\n"
+ << "#extension GL_EXT_texture_shadow_lod : require\n\n";
+
+ frag << cubeMapArrayEXT;
+
+ frag << "out mediump vec4 o_color;\n";
+
+ if (isVtxCase)
+ {
+ vert << "out mediump vec4 v_color;\n";
+ frag << "in mediump vec4 v_color;\n";
+ }
+ else
+ {
+ vert << "out " << coordPrecName << " " << coordTypeName << " v_texCoord;\n";
+ frag << "in " << coordPrecName << " " << coordTypeName << " v_texCoord;\n";
+
+ if (hasLodBias || hasSepShadowRef)
+ {
+ vert << "out " << coordPrecName << " vec4 v_lodShadowRef;\n";
+ frag << "in " << coordPrecName << " vec4 v_lodShadowRef;\n";
+ }
+ }
+
+ // Uniforms
+ op << "uniform highp " << glu::getDataTypeName(samplerType) << " u_sampler;\n"
+ << "uniform highp vec4 u_scale;\n"
+ << "uniform highp vec4 u_bias;\n";
+
+ vert << "\nvoid main()\n{\n"
+ << "\tgl_Position = a_position;\n";
+ frag << "\nvoid main()\n{\n";
+
+ if (isVtxCase)
+ vert << "\tv_color = ";
+ else
+ frag << "\to_color = ";
+
+ // Op.
+ {
+ const char* texCoord = isVtxCase ? "a_in0" : "v_texCoord";
+ const char* lodBias = isVtxCase ? "a_in1" : "v_lodShadowRef";
+
+ op << "vec4(" << baseFuncName;
+ if (m_lookupSpec.useOffset)
+ op << "Offset";
+ op << "(u_sampler, ";
+
+ op << texCoord;
+
+ if (m_lookupSpec.useSepRef)
+ {
+ op << ", " << lodBias << ".y";
+ }
+
+ if (functionHasLod(function))
+ {
+ op << ", " << lodBias << ".x";
+ }
+
+ if (m_lookupSpec.useOffset)
+ {
+ int offsetComps = 2;
+
+ op << ", ivec" << offsetComps << "(";
+ for (int ndx = 0; ndx < offsetComps; ndx++)
+ {
+ if (ndx != 0)
+ op << ", ";
+ op << m_lookupSpec.offset[ndx];
+ }
+ op << ")";
+ }
+
+ if (m_lookupSpec.useBias)
+ op << ", " << lodBias << ".x";
+
+ op << ")";
+
+ op << ", 0.0, 0.0, 1.0)";
+
+ op << ";\n";
+ }
+
+ if (isVtxCase)
+ frag << "\to_color = v_color;\n";
+ else
+ {
+ vert << "\tv_texCoord = a_in0;\n";
+
+ if (hasLodBias || hasSepShadowRef)
+ {
+ vert << "\tv_lodShadowRef = a_in1;\n";
+ }
+ }
+
+ vert << "}\n";
+ frag << "}\n";
+
+ m_vertShaderSource = vert.str();
+ m_fragShaderSource = frag.str();
+}
+
+void TextureShadowLodTestCase::deinit(void)
+{
+ ShaderRenderCase::deinit();
+
+ delete m_texture2D;
+ delete m_textureCube;
+ delete m_texture2DArray;
+
+ m_texture2D = DE_NULL;
+ m_textureCube = DE_NULL;
+ m_texture2DArray = DE_NULL;
+}
+
+void TextureShadowLodTestCase::setupUniforms(deUint32 programID, const tcu::Vec4&)
+{
+ const glw::Functions& gl = m_renderCtx.getFunctions();
+ gl.uniform1i(gl.getUniformLocation(programID, "u_sampler"), 0);
+ gl.uniform4fv(gl.getUniformLocation(programID, "u_scale"), 1, m_lookupParams.scale.getPtr());
+ gl.uniform4fv(gl.getUniformLocation(programID, "u_bias"), 1, m_lookupParams.bias.getPtr());
+}
+
+TextureShadowLodTest::TextureShadowLodTest(Context& context)
+ : TestCaseGroup(context, "ext_texture_shadow_lod", "Texture Access Function Tests")
+{
+}
+
+TextureShadowLodTest::~TextureShadowLodTest(void)
+{
+}
+
+enum CaseFlags
+{
+ VERTEX = (1 << 0),
+ FRAGMENT = (1 << 1),
+ BOTH = VERTEX | FRAGMENT
+};
+
+struct TexFuncCaseSpec
+{
+ const char* name;
+ TextureLookupSpec lookupSpec;
+ TextureSpec texSpec;
+ TexEvalFunc evalFunc;
+ deUint32 flags;
+};
+
+#define CASE_SPEC(NAME, FUNC, MINCOORD, MAXCOORD, USEBIAS, MINLOD, MAXLOD, USEOFFSET, OFFSET, USESEPREF, MINSEPREF, \
+ MAXSEPREF, TEXSPEC, EVALFUNC, FLAGS) \
+ { \
+ #NAME, TextureLookupSpec(FUNC, MINCOORD, MAXCOORD, USEBIAS, MINLOD, MAXLOD, USEOFFSET, OFFSET, USESEPREF, \
+ MINSEPREF, MAXSEPREF), \
+ TEXSPEC, EVALFUNC, FLAGS \
+ }
+
+static void createCaseGroup(TestCaseGroup* parent, const char* groupName, const char* groupDesc,
+ const TexFuncCaseSpec* cases, int numCases)
+{
+ tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), groupName, groupDesc);
+ parent->addChild(group);
+
+ for (int ndx = 0; ndx < numCases; ndx++)
+ {
+ std::string name = cases[ndx].name;
+ if (cases[ndx].flags & VERTEX)
+ group->addChild(new TextureShadowLodTestCase(parent->getContext(), (name + "_vertex").c_str(), "",
+ cases[ndx].lookupSpec, cases[ndx].texSpec, cases[ndx].evalFunc,
+ true));
+ if (cases[ndx].flags & FRAGMENT)
+ group->addChild(new TextureShadowLodTestCase(parent->getContext(), (name + "_fragment").c_str(), "",
+ cases[ndx].lookupSpec, cases[ndx].texSpec, cases[ndx].evalFunc,
+ false));
+ }
+}
+
+void TextureShadowLodTest::init(void)
+{
+ // Samplers
+ static const tcu::Sampler samplerShadowNoMipmap(
+ tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::NEAREST,
+ tcu::Sampler::NEAREST, 0.0f /* LOD threshold */, true /* normalized coords */, tcu::Sampler::COMPAREMODE_LESS,
+ 0 /* cmp channel */, tcu::Vec4(0.0f) /* border color */, true /* seamless cube map */);
+ static const tcu::Sampler samplerShadowMipmap(
+ tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::NEAREST_MIPMAP_NEAREST,
+ tcu::Sampler::NEAREST, 0.0f /* LOD threshold */, true /* normalized coords */, tcu::Sampler::COMPAREMODE_LESS,
+ 0 /* cmp channel */, tcu::Vec4(0.0f) /* border color */, true /* seamless cube map */);
+
+ // Default textures.
+ // Type Format W H D L Sampler
+
+ static const TextureSpec tex2DArrayShadow(TEXTURETYPE_2D_ARRAY, GL_DEPTH_COMPONENT16, 128, 128, 4, 1,
+ samplerShadowNoMipmap);
+ static const TextureSpec texCubeShadow(TEXTURETYPE_CUBE_MAP, GL_DEPTH_COMPONENT16, 256, 256, 1, 1,
+ samplerShadowNoMipmap);
+ static const TextureSpec texCubeMipmapShadow(TEXTURETYPE_CUBE_MAP, GL_DEPTH_COMPONENT16, 256, 256, 1, 9,
+ samplerShadowMipmap);
+ static const TextureSpec texCubeArrayShadow(TEXTURETYPE_CUBE_MAP_ARRAY, GL_DEPTH_COMPONENT16, 128, 128, 4, 1,
+ samplerShadowNoMipmap);
+ static const TextureSpec texCubeArrayMipmapShadow(TEXTURETYPE_CUBE_MAP_ARRAY, GL_DEPTH_COMPONENT16, 128, 128, 4, 8,
+ samplerShadowMipmap);
+ static const TextureSpec tex2DArrayMipmapShadow(TEXTURETYPE_2D_ARRAY, GL_DEPTH_COMPONENT16, 128, 128, 4, 8,
+ samplerShadowMipmap);
+
+ // texture() cases
+ static const TexFuncCaseSpec textureCases[] = {
+ // Name Function MinCoord MaxCoord Bias? MinLod MaxLod Offset? Offset Format EvalFunc Flags
+ CASE_SPEC(sampler2darrayshadow, FUNCTION_TEXTURE, Vec4(-1.2f, -0.4f, -0.5f, 0.0f), Vec4(1.5f, 2.3f, 3.5f, 1.0f),
+ false, 0.0f, 0.0f, false, IVec3(0), false, 0.0f, 0.0f, tex2DArrayShadow, evalTexture2DArrayShadow,
+ VERTEX),
+ CASE_SPEC(sampler2darrayshadow, FUNCTION_TEXTURE, Vec4(-1.2f, -0.4f, -0.5f, 0.0f), Vec4(1.5f, 2.3f, 3.5f, 1.0f),
+ false, 0.0f, 0.0f, false, IVec3(0), false, 0.0f, 0.0f, tex2DArrayMipmapShadow,
+ evalTexture2DArrayShadow, FRAGMENT),
+ CASE_SPEC(sampler2darrayshadow_bias, FUNCTION_TEXTURE, Vec4(-1.2f, -0.4f, -0.5f, 0.0f),
+ Vec4(1.5f, 2.3f, 3.5f, 1.0f), true, -2.0f, 2.0f, false, IVec3(0), false, 0.0f, 0.0f,
+ tex2DArrayMipmapShadow, evalTexture2DArrayShadowBias, FRAGMENT),
+
+ CASE_SPEC(samplercubearrayshadow, FUNCTION_TEXTURE, Vec4(-1.0f, -1.0f, 1.01f, -0.5f),
+ Vec4(1.0f, 1.0f, 1.01f, 3.5f), false, 0.0f, 0.0f, false, IVec3(0), true, 0.0f, 1.0f,
+ texCubeArrayShadow, evalTextureCubeArrayShadow, VERTEX),
+ CASE_SPEC(samplercubearrayshadow, FUNCTION_TEXTURE, Vec4(-1.0f, -1.0f, 1.01f, -0.5f),
+ Vec4(1.0f, 1.0f, 1.01f, 3.5f), false, 0.0f, 0.0f, false, IVec3(0), true, 0.0f, 1.0f,
+ texCubeArrayMipmapShadow, evalTextureCubeArrayShadow, FRAGMENT),
+ CASE_SPEC(samplercubearrayshadow_bias, FUNCTION_TEXTURE, Vec4(-1.0f, -1.0f, 1.01f, -0.5f),
+ Vec4(1.0f, 1.0f, 1.01f, 3.5f), true, -2.0, 2.0f, false, IVec3(0), true, 0.0f, 1.0f,
+ texCubeArrayMipmapShadow, evalTextureCubeArrayShadowBias, FRAGMENT),
+ };
+ createCaseGroup(this, "texture", "texture() Tests", textureCases, DE_LENGTH_OF_ARRAY(textureCases));
+
+ // textureOffset() cases
+ // \note _bias variants are not using mipmap thanks to wide allowed range for LOD computation
+ static const TexFuncCaseSpec textureOffsetCases[] = {
+ // Name Function MinCoord MaxCoord Bias? MinLod MaxLod Offset? Offset Format EvalFunc Flags
+ CASE_SPEC(sampler2darrayshadow, FUNCTION_TEXTURE, Vec4(-1.2f, -0.4f, -0.5f, 0.0f), Vec4(1.5f, 2.3f, 3.5f, 1.0f),
+ false, 0.0f, 0.0f, true, IVec3(-8, 7, 0), false, 0.0f, 0.0f, tex2DArrayShadow,
+ evalTexture2DArrayShadowOffset, VERTEX),
+ CASE_SPEC(sampler2darrayshadow, FUNCTION_TEXTURE, Vec4(-1.2f, -0.4f, -0.5f, 0.0f), Vec4(1.5f, 2.3f, 3.5f, 1.0f),
+ false, 0.0f, 0.0f, true, IVec3(7, -8, 0), false, 0.0f, 0.0f, tex2DArrayMipmapShadow,
+ evalTexture2DArrayShadowOffset, FRAGMENT),
+ CASE_SPEC(sampler2darrayshadow_bias, FUNCTION_TEXTURE, Vec4(-1.2f, -0.4f, -0.5f, 0.0f),
+ Vec4(1.5f, 2.3f, 3.5f, 1.0f), true, -2.0f, 2.0f, true, IVec3(7, -8, 0), false, 0.0f, 0.0f,
+ tex2DArrayMipmapShadow, evalTexture2DArrayShadowOffsetBias, FRAGMENT),
+ };
+ createCaseGroup(this, "textureoffset", "textureOffset() Tests", textureOffsetCases,
+ DE_LENGTH_OF_ARRAY(textureOffsetCases));
+
+ // textureLod() cases
+ static const TexFuncCaseSpec textureLodCases[] = {
+ // Name Function MinCoord MaxCoord Bias? MinLod MaxLod Offset? Offset Format EvalFunc Flags
+ CASE_SPEC(sampler2darrayshadow, FUNCTION_TEXTURELOD, Vec4(-1.2f, -0.4f, -0.5f, 0.0f),
+ Vec4(1.5f, 2.3f, 3.5f, 1.0f), false, -1.0f, 8.0f, false, IVec3(0), false, 0.0f, 0.0f,
+ tex2DArrayMipmapShadow, evalTexture2DArrayShadowLod, BOTH),
+ CASE_SPEC(samplercubeshadow, FUNCTION_TEXTURELOD, Vec4(-1.0f, -1.0f, 1.01f, 0.0f),
+ Vec4(1.0f, 1.0f, 1.01f, 1.0f), false, -1.0f, 8.0f, false, IVec3(0), false, 0.0f, 0.0f,
+ texCubeMipmapShadow, evalTextureCubeShadowLod, BOTH),
+ CASE_SPEC(samplercubearrayshadow, FUNCTION_TEXTURELOD, Vec4(-1.0f, -1.0f, 1.01f, -0.5f),
+ Vec4(1.0f, 1.0f, 1.01f, 3.5f), false, -1.0f, 8.0f, false, IVec3(0), true, 0.0f, 1.0f,
+ texCubeArrayMipmapShadow, evalTextureCubeArrayShadowLod, FRAGMENT)
+ };
+ createCaseGroup(this, "texturelod", "textureLod() Tests", textureLodCases, DE_LENGTH_OF_ARRAY(textureLodCases));
+
+ // textureLodOffset() cases
+ static const TexFuncCaseSpec textureLodOffsetCases[] = {
+ // Name Function MinCoord MaxCoord Bias? MinLod MaxLod Offset? Offset Format EvalFunc Flags
+ CASE_SPEC(sampler2darrayshadow, FUNCTION_TEXTURELOD, Vec4(-1.2f, -0.4f, -0.5f, 0.0f),
+ Vec4(1.5f, 2.3f, 3.5f, 1.0f), false, -1.0f, 9.0f, true, IVec3(-8, 7, 0), false, 0.0f, 0.0f,
+ tex2DArrayMipmapShadow, evalTexture2DArrayShadowLodOffset, BOTH),
+ };
+ createCaseGroup(this, "texturelodoffset", "textureLodOffset() Tests", textureLodOffsetCases,
+ DE_LENGTH_OF_ARRAY(textureLodOffsetCases));
+}
+} // namespace Functional
+} // namespace deqp
projects / platform / upstream / VK-GL-CTS.git / commitdiff