| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.0 Module |
| * ------------------------------------------------- |
| * |
| * 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 Vertex texture tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3fVertexTextureTests.hpp" |
| #include "glsTextureTestUtil.hpp" |
| #include "gluTexture.hpp" |
| #include "gluPixelTransfer.hpp" |
| #include "gluTextureUtil.hpp" |
| #include "tcuVector.hpp" |
| #include "tcuMatrix.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "deMath.h" |
| #include "deRandom.hpp" |
| #include "deString.h" |
| |
| #include <string> |
| #include <vector> |
| |
| #include <limits> |
| |
| #include "glw.h" |
| |
| using std::string; |
| using std::vector; |
| using tcu::IVec2; |
| using tcu::IVec3; |
| using tcu::IVec4; |
| using tcu::Mat3; |
| using tcu::TestLog; |
| using tcu::Vec2; |
| using tcu::Vec3; |
| using tcu::Vec4; |
| |
| namespace deqp |
| { |
| |
| using namespace gls::TextureTestUtil; |
| using namespace glu::TextureTestUtil; |
| |
| using glu::TextureTestUtil::TEXTURETYPE_2D; |
| using glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY; |
| using glu::TextureTestUtil::TEXTURETYPE_3D; |
| using glu::TextureTestUtil::TEXTURETYPE_CUBE; |
| |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| |
| static const int WIDTH_2D_ARRAY = 128; |
| static const int HEIGHT_2D_ARRAY = 128; |
| static const int LAYERS_2D_ARRAY = 8; |
| |
| static const int WIDTH_3D = 64; |
| static const int HEIGHT_3D = 64; |
| static const int DEPTH_3D = 64; |
| |
| // The 2D case draws four images. |
| static const int MAX_2D_RENDER_WIDTH = 128 * 2; |
| static const int MAX_2D_RENDER_HEIGHT = 128 * 2; |
| |
| // The cube map case draws four 3-by-2 image groups. |
| static const int MAX_CUBE_RENDER_WIDTH = 28 * 2 * 3; |
| static const int MAX_CUBE_RENDER_HEIGHT = 28 * 2 * 2; |
| |
| static const int MAX_2D_ARRAY_RENDER_WIDTH = 128 * 2; |
| static const int MAX_2D_ARRAY_RENDER_HEIGHT = 128 * 2; |
| |
| static const int MAX_3D_RENDER_WIDTH = 128 * 2; |
| static const int MAX_3D_RENDER_HEIGHT = 128 * 2; |
| |
| static const int GRID_SIZE_2D = 127; |
| static const int GRID_SIZE_CUBE = 63; |
| static const int GRID_SIZE_2D_ARRAY = 127; |
| static const int GRID_SIZE_3D = 127; |
| |
| // Helpers for making texture coordinates "safe", i.e. move them further from coordinate bounary. |
| |
| // Moves x towards the closest K+targetFraction, where K is an integer. |
| // E.g. moveTowardsFraction(x, 0.5f) moves x away from integer boundaries. |
| static inline float moveTowardsFraction(float x, float targetFraction) |
| { |
| const float strictness = 0.5f; |
| DE_ASSERT(0.0f < strictness && strictness <= 1.0f); |
| DE_ASSERT(de::inBounds(targetFraction, 0.0f, 1.0f)); |
| const float y = x + 0.5f - targetFraction; |
| return deFloatFloor(y) + deFloatFrac(y) * (1.0f - strictness) + strictness * 0.5f - 0.5f + targetFraction; |
| } |
| |
| static inline float safeCoord(float raw, int scale, float fraction) |
| { |
| const float scaleFloat = (float)scale; |
| return moveTowardsFraction(raw * scaleFloat, fraction) / scaleFloat; |
| } |
| |
| template <int Size> |
| static inline tcu::Vector<float, Size> safeCoords(const tcu::Vector<float, Size> &raw, |
| const tcu::Vector<int, Size> &scale, |
| const tcu::Vector<float, Size> &fraction) |
| { |
| tcu::Vector<float, Size> result; |
| for (int i = 0; i < Size; i++) |
| result[i] = safeCoord(raw[i], scale[i], fraction[i]); |
| return result; |
| } |
| |
| static inline Vec2 safe2DTexCoords(const Vec2 &raw, const IVec2 &textureSize) |
| { |
| return safeCoords(raw, textureSize, Vec2(0.5f)); |
| } |
| |
| static inline Vec3 safe2DArrayTexCoords(const Vec3 &raw, const IVec3 &textureSize) |
| { |
| return safeCoords(raw, textureSize, Vec3(0.5f, 0.5f, 0.0f)); |
| } |
| |
| static inline Vec3 safe3DTexCoords(const Vec3 &raw, const IVec3 &textureSize) |
| { |
| return safeCoords(raw, textureSize, Vec3(0.5f)); |
| } |
| |
| namespace |
| { |
| |
| struct Rect |
| { |
| Rect(int x_, int y_, int w_, int h_) : x(x_), y(y_), w(w_), h(h_) |
| { |
| } |
| IVec2 pos(void) const |
| { |
| return IVec2(x, y); |
| } |
| IVec2 size(void) const |
| { |
| return IVec2(w, h); |
| } |
| |
| int x; |
| int y; |
| int w; |
| int h; |
| }; |
| |
| template <TextureType> |
| struct TexTypeTcuClass; |
| template <> |
| struct TexTypeTcuClass<TEXTURETYPE_2D> |
| { |
| typedef tcu::Texture2D t; |
| }; |
| template <> |
| struct TexTypeTcuClass<TEXTURETYPE_CUBE> |
| { |
| typedef tcu::TextureCube t; |
| }; |
| template <> |
| struct TexTypeTcuClass<TEXTURETYPE_2D_ARRAY> |
| { |
| typedef tcu::Texture2DArray t; |
| }; |
| template <> |
| struct TexTypeTcuClass<TEXTURETYPE_3D> |
| { |
| typedef tcu::Texture3D t; |
| }; |
| |
| template <TextureType> |
| struct TexTypeSizeDims; |
| template <> |
| struct TexTypeSizeDims<TEXTURETYPE_2D> |
| { |
| enum |
| { |
| V = 2 |
| }; |
| }; |
| template <> |
| struct TexTypeSizeDims<TEXTURETYPE_CUBE> |
| { |
| enum |
| { |
| V = 2 |
| }; |
| }; |
| template <> |
| struct TexTypeSizeDims<TEXTURETYPE_2D_ARRAY> |
| { |
| enum |
| { |
| V = 3 |
| }; |
| }; |
| template <> |
| struct TexTypeSizeDims<TEXTURETYPE_3D> |
| { |
| enum |
| { |
| V = 3 |
| }; |
| }; |
| |
| template <TextureType> |
| struct TexTypeCoordDims; |
| template <> |
| struct TexTypeCoordDims<TEXTURETYPE_2D> |
| { |
| enum |
| { |
| V = 2 |
| }; |
| }; |
| template <> |
| struct TexTypeCoordDims<TEXTURETYPE_CUBE> |
| { |
| enum |
| { |
| V = 3 |
| }; |
| }; |
| template <> |
| struct TexTypeCoordDims<TEXTURETYPE_2D_ARRAY> |
| { |
| enum |
| { |
| V = 3 |
| }; |
| }; |
| template <> |
| struct TexTypeCoordDims<TEXTURETYPE_3D> |
| { |
| enum |
| { |
| V = 3 |
| }; |
| }; |
| |
| template <TextureType TexType> |
| struct TexTypeSizeIVec |
| { |
| typedef tcu::Vector<int, TexTypeSizeDims<TexType>::V> t; |
| }; |
| template <TextureType TexType> |
| struct TexTypeCoordVec |
| { |
| typedef tcu::Vector<float, TexTypeCoordDims<TexType>::V> t; |
| }; |
| |
| template <TextureType> |
| struct TexTypeCoordParams; |
| |
| template <> |
| struct TexTypeCoordParams<TEXTURETYPE_2D> |
| { |
| Vec2 scale; |
| Vec2 bias; |
| |
| TexTypeCoordParams(const Vec2 &scale_, const Vec2 &bias_) : scale(scale_), bias(bias_) |
| { |
| } |
| }; |
| |
| template <> |
| struct TexTypeCoordParams<TEXTURETYPE_CUBE> |
| { |
| Vec2 scale; |
| Vec2 bias; |
| tcu::CubeFace face; |
| |
| TexTypeCoordParams(const Vec2 &scale_, const Vec2 &bias_, tcu::CubeFace face_) |
| : scale(scale_) |
| , bias(bias_) |
| , face(face_) |
| { |
| } |
| }; |
| |
| template <> |
| struct TexTypeCoordParams<TEXTURETYPE_2D_ARRAY> |
| { |
| Mat3 transform; |
| |
| TexTypeCoordParams(const Mat3 &transform_) : transform(transform_) |
| { |
| } |
| }; |
| |
| template <> |
| struct TexTypeCoordParams<TEXTURETYPE_3D> |
| { |
| Mat3 transform; |
| |
| TexTypeCoordParams(const Mat3 &transform_) : transform(transform_) |
| { |
| } |
| }; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Quad grid class containing position and texture coordinate data. |
| * |
| * A quad grid of size S means a grid consisting of S*S quads (S rows and |
| * S columns). The quads are rectangles with main axis aligned sides, and |
| * each consists of two triangles. Note that although there are only |
| * (S+1)*(S+1) distinct vertex positions, there are S*S*4 distinct vertices |
| * because we want texture coordinates to be constant across the vertices |
| * of a quad (to avoid interpolation issues), and thus each quad needs its |
| * own 4 vertices. |
| * |
| * Pointers returned by get*Ptr() are suitable for gl calls such as |
| * glVertexAttribPointer() (for position and tex coord) or glDrawElements() |
| * (for indices). |
| *//*--------------------------------------------------------------------*/ |
| template <TextureType TexType> |
| class PosTexCoordQuadGrid |
| { |
| private: |
| enum |
| { |
| TEX_COORD_DIMS = TexTypeCoordDims<TexType>::V |
| }; |
| typedef typename TexTypeCoordVec<TexType>::t TexCoordVec; |
| typedef typename TexTypeSizeIVec<TexType>::t TexSizeIVec; |
| typedef TexTypeCoordParams<TexType> TexCoordParams; |
| |
| public: |
| PosTexCoordQuadGrid(int gridSize, const IVec2 &renderSize, const TexSizeIVec &textureSize, |
| const TexCoordParams &texCoordParams, bool useSafeTexCoords); |
| |
| int getSize(void) const |
| { |
| return m_gridSize; |
| } |
| Vec4 getQuadLDRU(int col, int row) const; //!< Vec4(leftX, downY, rightX, upY) |
| const TexCoordVec &getQuadTexCoord(int col, int row) const; |
| |
| int getNumIndices(void) const |
| { |
| return m_gridSize * m_gridSize * 3 * 2; |
| } |
| const float *getPositionPtr(void) const |
| { |
| DE_STATIC_ASSERT(sizeof(Vec2) == 2 * sizeof(float)); |
| return (float *)&m_positions[0]; |
| } |
| const float *getTexCoordPtr(void) const |
| { |
| DE_STATIC_ASSERT(sizeof(TexCoordVec) == TEX_COORD_DIMS * (int)sizeof(float)); |
| return (float *)&m_texCoords[0]; |
| } |
| const uint16_t *getIndexPtr(void) const |
| { |
| return &m_indices[0]; |
| } |
| |
| private: |
| void initializeTexCoords(const TexSizeIVec &textureSize, const TexCoordParams &texCoordParams, |
| bool useSafeTexCoords); |
| |
| const int m_gridSize; |
| vector<Vec2> m_positions; |
| vector<TexCoordVec> m_texCoords; |
| vector<uint16_t> m_indices; |
| }; |
| |
| template <TextureType TexType> |
| Vec4 PosTexCoordQuadGrid<TexType>::getQuadLDRU(int col, int row) const |
| { |
| int ndx00 = (row * m_gridSize + col) * 4; |
| int ndx11 = ndx00 + 3; |
| |
| return Vec4(m_positions[ndx00].x(), m_positions[ndx00].y(), m_positions[ndx11].x(), m_positions[ndx11].y()); |
| } |
| |
| template <TextureType TexType> |
| const typename TexTypeCoordVec<TexType>::t &PosTexCoordQuadGrid<TexType>::getQuadTexCoord(int col, int row) const |
| { |
| return m_texCoords[(row * m_gridSize + col) * 4]; |
| } |
| |
| template <TextureType TexType> |
| PosTexCoordQuadGrid<TexType>::PosTexCoordQuadGrid(int gridSize, const IVec2 &renderSize, const TexSizeIVec &textureSize, |
| const TexCoordParams &texCoordParams, bool useSafeTexCoords) |
| : m_gridSize(gridSize) |
| { |
| DE_ASSERT(m_gridSize > 0 && m_gridSize * m_gridSize <= (int)std::numeric_limits<uint16_t>::max() + 1); |
| |
| const float gridSizeFloat = (float)m_gridSize; |
| |
| m_positions.reserve(m_gridSize * m_gridSize * 4); |
| m_indices.reserve(m_gridSize * m_gridSize * 3 * 2); |
| |
| for (int y = 0; y < m_gridSize; y++) |
| for (int x = 0; x < m_gridSize; x++) |
| { |
| float fx0 = (float)(x + 0) / gridSizeFloat; |
| float fx1 = (float)(x + 1) / gridSizeFloat; |
| float fy0 = (float)(y + 0) / gridSizeFloat; |
| float fy1 = (float)(y + 1) / gridSizeFloat; |
| |
| Vec2 quadVertices[4] = {Vec2(fx0, fy0), Vec2(fx1, fy0), Vec2(fx0, fy1), Vec2(fx1, fy1)}; |
| |
| int firstNdx = (int)m_positions.size(); |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(quadVertices); i++) |
| m_positions.push_back(safeCoords(quadVertices[i], renderSize, Vec2(0.0f)) * 2.0f - 1.0f); |
| |
| m_indices.push_back(uint16_t(firstNdx + 0)); |
| m_indices.push_back(uint16_t(firstNdx + 1)); |
| m_indices.push_back(uint16_t(firstNdx + 2)); |
| |
| m_indices.push_back(uint16_t(firstNdx + 1)); |
| m_indices.push_back(uint16_t(firstNdx + 3)); |
| m_indices.push_back(uint16_t(firstNdx + 2)); |
| } |
| |
| m_texCoords.reserve(m_gridSize * m_gridSize * 4); |
| initializeTexCoords(textureSize, texCoordParams, useSafeTexCoords); |
| |
| DE_ASSERT((int)m_positions.size() == m_gridSize * m_gridSize * 4); |
| DE_ASSERT((int)m_indices.size() == m_gridSize * m_gridSize * 3 * 2); |
| DE_ASSERT((int)m_texCoords.size() == m_gridSize * m_gridSize * 4); |
| } |
| |
| template <> |
| void PosTexCoordQuadGrid<TEXTURETYPE_2D>::initializeTexCoords(const IVec2 &textureSize, |
| const TexCoordParams &texCoordParams, |
| bool useSafeTexCoords) |
| { |
| DE_ASSERT(m_texCoords.empty()); |
| |
| const float gridSizeFloat = (float)m_gridSize; |
| |
| for (int y = 0; y < m_gridSize; y++) |
| for (int x = 0; x < m_gridSize; x++) |
| { |
| Vec2 rawCoord = |
| Vec2((float)x / gridSizeFloat, (float)y / gridSizeFloat) * texCoordParams.scale + texCoordParams.bias; |
| |
| for (int i = 0; i < 4; i++) |
| m_texCoords.push_back(useSafeTexCoords ? safe2DTexCoords(rawCoord, textureSize) : rawCoord); |
| } |
| } |
| |
| template <> |
| void PosTexCoordQuadGrid<TEXTURETYPE_CUBE>::initializeTexCoords(const IVec2 &textureSize, |
| const TexCoordParams &texCoordParams, |
| bool useSafeTexCoords) |
| { |
| DE_ASSERT(m_texCoords.empty()); |
| |
| const float gridSizeFloat = (float)m_gridSize; |
| vector<float> texBoundaries; |
| computeQuadTexCoordCube(texBoundaries, texCoordParams.face); |
| const Vec3 coordA = Vec3(texBoundaries[0], texBoundaries[1], texBoundaries[2]); |
| const Vec3 coordB = Vec3(texBoundaries[3], texBoundaries[4], texBoundaries[5]); |
| const Vec3 coordC = Vec3(texBoundaries[6], texBoundaries[7], texBoundaries[8]); |
| const Vec3 coordAB = coordB - coordA; |
| const Vec3 coordAC = coordC - coordA; |
| |
| for (int y = 0; y < m_gridSize; y++) |
| for (int x = 0; x < m_gridSize; x++) |
| { |
| const Vec2 rawFaceCoord = |
| texCoordParams.scale * Vec2((float)x / gridSizeFloat, (float)y / gridSizeFloat) + texCoordParams.bias; |
| const Vec2 safeFaceCoord = useSafeTexCoords ? safe2DTexCoords(rawFaceCoord, textureSize) : rawFaceCoord; |
| const Vec3 texCoord = coordA + coordAC * safeFaceCoord.x() + coordAB * safeFaceCoord.y(); |
| |
| for (int i = 0; i < 4; i++) |
| m_texCoords.push_back(texCoord); |
| } |
| } |
| |
| template <> |
| void PosTexCoordQuadGrid<TEXTURETYPE_2D_ARRAY>::initializeTexCoords(const IVec3 &textureSize, |
| const TexCoordParams &texCoordParams, |
| bool useSafeTexCoords) |
| { |
| DE_ASSERT(m_texCoords.empty()); |
| |
| const float gridSizeFloat = (float)m_gridSize; |
| |
| for (int y = 0; y < m_gridSize; y++) |
| for (int x = 0; x < m_gridSize; x++) |
| { |
| const Vec3 rawCoord = |
| texCoordParams.transform * Vec3((float)x / gridSizeFloat, (float)y / gridSizeFloat, 1.0f); |
| |
| for (int i = 0; i < 4; i++) |
| m_texCoords.push_back(useSafeTexCoords ? safe2DArrayTexCoords(rawCoord, textureSize) : rawCoord); |
| } |
| } |
| |
| template <> |
| void PosTexCoordQuadGrid<TEXTURETYPE_3D>::initializeTexCoords(const IVec3 &textureSize, |
| const TexCoordParams &texCoordParams, |
| bool useSafeTexCoords) |
| { |
| DE_ASSERT(m_texCoords.empty()); |
| |
| const float gridSizeFloat = (float)m_gridSize; |
| |
| for (int y = 0; y < m_gridSize; y++) |
| for (int x = 0; x < m_gridSize; x++) |
| { |
| Vec3 rawCoord = texCoordParams.transform * Vec3((float)x / gridSizeFloat, (float)y / gridSizeFloat, 1.0f); |
| |
| for (int i = 0; i < 4; i++) |
| m_texCoords.push_back(useSafeTexCoords ? safe3DTexCoords(rawCoord, textureSize) : rawCoord); |
| } |
| } |
| |
| } // namespace |
| |
| static inline bool isLevelNearest(uint32_t filter) |
| { |
| return filter == GL_NEAREST || filter == GL_NEAREST_MIPMAP_NEAREST || filter == GL_NEAREST_MIPMAP_LINEAR; |
| } |
| |
| static inline IVec2 getTextureSize(const glu::Texture2D &tex) |
| { |
| const tcu::Texture2D &ref = tex.getRefTexture(); |
| return IVec2(ref.getWidth(), ref.getHeight()); |
| } |
| |
| static inline IVec2 getTextureSize(const glu::TextureCube &tex) |
| { |
| const tcu::TextureCube &ref = tex.getRefTexture(); |
| return IVec2(ref.getSize(), ref.getSize()); |
| } |
| |
| static inline IVec3 getTextureSize(const glu::Texture2DArray &tex) |
| { |
| const tcu::Texture2DArray &ref = tex.getRefTexture(); |
| return IVec3(ref.getWidth(), ref.getHeight(), ref.getNumLayers()); |
| } |
| |
| static inline IVec3 getTextureSize(const glu::Texture3D &tex) |
| { |
| const tcu::Texture3D &ref = tex.getRefTexture(); |
| return IVec3(ref.getWidth(), ref.getHeight(), ref.getDepth()); |
| } |
| |
| template <TextureType TexType> |
| static void setPixelColors(const vector<Vec4> &quadColors, const Rect ®ion, const PosTexCoordQuadGrid<TexType> &grid, |
| tcu::Surface &dst) |
| { |
| const int gridSize = grid.getSize(); |
| |
| for (int y = 0; y < gridSize; y++) |
| for (int x = 0; x < gridSize; x++) |
| { |
| const Vec4 color = quadColors[y * gridSize + x]; |
| const Vec4 ldru = grid.getQuadLDRU(x, y) * 0.5f + 0.5f; // [-1, 1] -> [0, 1] |
| const int ix0 = deCeilFloatToInt32(ldru.x() * (float)region.w - 0.5f); |
| const int ix1 = deCeilFloatToInt32(ldru.z() * (float)region.w - 0.5f); |
| const int iy0 = deCeilFloatToInt32(ldru.y() * (float)region.h - 0.5f); |
| const int iy1 = deCeilFloatToInt32(ldru.w() * (float)region.h - 0.5f); |
| |
| for (int iy = iy0; iy < iy1; iy++) |
| for (int ix = ix0; ix < ix1; ix++) |
| { |
| DE_ASSERT(deInBounds32(ix + region.x, 0, dst.getWidth())); |
| DE_ASSERT(deInBounds32(iy + region.y, 0, dst.getHeight())); |
| |
| dst.setPixel(ix + region.x, iy + region.y, tcu::RGBA(color)); |
| } |
| } |
| } |
| |
| static inline Vec4 sample(const tcu::Texture2D &tex, const Vec2 &coord, float lod, const tcu::Sampler &sam) |
| { |
| return tex.sample(sam, coord.x(), coord.y(), lod); |
| } |
| static inline Vec4 sample(const tcu::TextureCube &tex, const Vec3 &coord, float lod, const tcu::Sampler &sam) |
| { |
| return tex.sample(sam, coord.x(), coord.y(), coord.z(), lod); |
| } |
| static inline Vec4 sample(const tcu::Texture2DArray &tex, const Vec3 &coord, float lod, const tcu::Sampler &sam) |
| { |
| return tex.sample(sam, coord.x(), coord.y(), coord.z(), lod); |
| } |
| static inline Vec4 sample(const tcu::Texture3D &tex, const Vec3 &coord, float lod, const tcu::Sampler &sam) |
| { |
| return tex.sample(sam, coord.x(), coord.y(), coord.z(), lod); |
| } |
| |
| template <TextureType TexType> |
| void computeReference(const typename TexTypeTcuClass<TexType>::t &texture, float lod, const tcu::Sampler &sampler, |
| const PosTexCoordQuadGrid<TexType> &grid, tcu::Surface &dst, const Rect &dstRegion) |
| { |
| const int gridSize = grid.getSize(); |
| vector<Vec4> quadColors(gridSize * gridSize); |
| |
| for (int y = 0; y < gridSize; y++) |
| for (int x = 0; x < gridSize; x++) |
| { |
| const int ndx = y * gridSize + x; |
| const typename TexTypeCoordVec<TexType>::t &coord = grid.getQuadTexCoord(x, y); |
| |
| quadColors[ndx] = sample(texture, coord, lod, sampler); |
| } |
| |
| setPixelColors(quadColors, dstRegion, grid, dst); |
| } |
| |
| static bool compareImages(const glu::RenderContext &renderCtx, tcu::TestLog &log, const tcu::Surface &ref, |
| const tcu::Surface &res) |
| { |
| DE_ASSERT(renderCtx.getRenderTarget().getNumSamples() == 0); |
| |
| const tcu::RGBA threshold = |
| renderCtx.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(15, 15, 15, 15); |
| return tcu::pixelThresholdCompare(log, "Result", "Image compare result", ref, res, threshold, |
| tcu::COMPARE_LOG_RESULT); |
| } |
| |
| class Vertex2DTextureCase : public TestCase |
| { |
| public: |
| Vertex2DTextureCase(Context &testCtx, const char *name, const char *desc, uint32_t minFilter, uint32_t magFilter, |
| uint32_t wrapS, uint32_t wrapT); |
| ~Vertex2DTextureCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| typedef PosTexCoordQuadGrid<TEXTURETYPE_2D> Grid; |
| |
| Vertex2DTextureCase(const Vertex2DTextureCase &other); |
| Vertex2DTextureCase &operator=(const Vertex2DTextureCase &other); |
| |
| float calculateLod(const Vec2 &texScale, const Vec2 &dstSize, int textureNdx) const; |
| void setupShaderInputs(int textureNdx, float lod, const Grid &grid) const; |
| void renderCell(int textureNdx, float lod, const Grid &grid) const; |
| void computeReferenceCell(int textureNdx, float lod, const Grid &grid, tcu::Surface &dst, |
| const Rect &dstRegion) const; |
| |
| const uint32_t m_minFilter; |
| const uint32_t m_magFilter; |
| const uint32_t m_wrapS; |
| const uint32_t m_wrapT; |
| |
| const glu::ShaderProgram *m_program; |
| glu::Texture2D *m_textures[2]; // 2 textures, a gradient texture and a grid texture. |
| }; |
| |
| Vertex2DTextureCase::Vertex2DTextureCase(Context &testCtx, const char *name, const char *desc, uint32_t minFilter, |
| uint32_t magFilter, uint32_t wrapS, uint32_t wrapT) |
| : TestCase(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, desc) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_program(DE_NULL) |
| { |
| m_textures[0] = DE_NULL; |
| m_textures[1] = DE_NULL; |
| } |
| |
| Vertex2DTextureCase::~Vertex2DTextureCase(void) |
| { |
| Vertex2DTextureCase::deinit(); |
| } |
| |
| void Vertex2DTextureCase::init(void) |
| { |
| const char *const vertexShader = "#version 300 es\n" |
| "in highp vec2 a_position;\n" |
| "in highp vec2 a_texCoord;\n" |
| "uniform highp sampler2D u_texture;\n" |
| "uniform highp float u_lod;\n" |
| "out mediump vec4 v_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(a_position, 0.0, 1.0);\n" |
| " v_color = textureLod(u_texture, a_texCoord, u_lod);\n" |
| "}\n"; |
| |
| const char *const fragmentShader = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 dEQP_FragColor;\n" |
| "in mediump vec4 v_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " dEQP_FragColor = v_color;\n" |
| "}\n"; |
| |
| if (m_context.getRenderTarget().getNumSamples() != 0) |
| throw tcu::NotSupportedError("MSAA config not supported by this test"); |
| |
| DE_ASSERT(!m_program); |
| m_program = |
| new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShader, fragmentShader)); |
| |
| if (!m_program->isOk()) |
| { |
| m_testCtx.getLog() << *m_program; |
| |
| GLint maxVertexTextures; |
| glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &maxVertexTextures); |
| |
| if (maxVertexTextures < 1) |
| throw tcu::NotSupportedError("Vertex texture image units not supported", "", __FILE__, __LINE__); |
| else |
| TCU_FAIL("Failed to compile shader"); |
| } |
| |
| // Make the textures. |
| try |
| { |
| // Compute suitable power-of-two sizes (for mipmaps). |
| const int texWidth = 1 << deLog2Ceil32(MAX_2D_RENDER_WIDTH / 2); |
| const int texHeight = 1 << deLog2Ceil32(MAX_2D_RENDER_HEIGHT / 2); |
| |
| for (int i = 0; i < 2; i++) |
| { |
| DE_ASSERT(!m_textures[i]); |
| m_textures[i] = |
| new glu::Texture2D(m_context.getRenderContext(), GL_RGB, GL_UNSIGNED_BYTE, texWidth, texHeight); |
| } |
| |
| const bool mipmaps = (deIsPowerOfTwo32(texWidth) && deIsPowerOfTwo32(texHeight)); |
| const int numLevels = mipmaps ? deLog2Floor32(de::max(texWidth, texHeight)) + 1 : 1; |
| const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_textures[0]->getRefTexture().getFormat()); |
| const Vec4 cBias = fmtInfo.valueMin; |
| const Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin; |
| |
| // Fill first with gradient texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| const Vec4 gMin = Vec4(-0.5f, -0.5f, -0.5f, 2.0f) * cScale + cBias; |
| const Vec4 gMax = Vec4(1.0f, 1.0f, 1.0f, 0.0f) * cScale + cBias; |
| |
| m_textures[0]->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevel(levelNdx), gMin, gMax); |
| } |
| |
| // Fill second with grid texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| const uint32_t step = 0x00ffffff / numLevels; |
| const uint32_t rgb = step * levelNdx; |
| const uint32_t colorA = 0xff000000 | rgb; |
| const uint32_t colorB = 0xff000000 | ~rgb; |
| |
| m_textures[1]->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevel(levelNdx), 4, |
| tcu::RGBA(colorA).toVec() * cScale + cBias, tcu::RGBA(colorB).toVec() * cScale + cBias); |
| } |
| |
| // Upload. |
| for (int i = 0; i < 2; i++) |
| m_textures[i]->upload(); |
| } |
| catch (const std::exception &) |
| { |
| // Clean up to save memory. |
| Vertex2DTextureCase::deinit(); |
| throw; |
| } |
| } |
| |
| void Vertex2DTextureCase::deinit(void) |
| { |
| for (int i = 0; i < 2; i++) |
| { |
| delete m_textures[i]; |
| m_textures[i] = DE_NULL; |
| } |
| |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| float Vertex2DTextureCase::calculateLod(const Vec2 &texScale, const Vec2 &dstSize, int textureNdx) const |
| { |
| const tcu::Texture2D &refTexture = m_textures[textureNdx]->getRefTexture(); |
| const Vec2 srcSize = Vec2((float)refTexture.getWidth(), (float)refTexture.getHeight()); |
| const Vec2 sizeRatio = texScale * srcSize / dstSize; |
| |
| // \note In this particular case dv/dx and du/dy are zero, simplifying the expression. |
| return deFloatLog2(de::max(sizeRatio.x(), sizeRatio.y())); |
| } |
| |
| Vertex2DTextureCase::IterateResult Vertex2DTextureCase::iterate(void) |
| { |
| const int viewportWidth = deMin32(m_context.getRenderTarget().getWidth(), MAX_2D_RENDER_WIDTH); |
| const int viewportHeight = deMin32(m_context.getRenderTarget().getHeight(), MAX_2D_RENDER_HEIGHT); |
| |
| const int viewportXOffsetMax = m_context.getRenderTarget().getWidth() - viewportWidth; |
| const int viewportYOffsetMax = m_context.getRenderTarget().getHeight() - viewportHeight; |
| |
| de::Random rnd(deStringHash(getName())); |
| |
| const int viewportXOffset = rnd.getInt(0, viewportXOffsetMax); |
| const int viewportYOffset = rnd.getInt(0, viewportYOffsetMax); |
| |
| glUseProgram(m_program->getProgram()); |
| |
| // Divide viewport into 4 cells. |
| const int leftWidth = viewportWidth / 2; |
| const int rightWidth = viewportWidth - leftWidth; |
| const int bottomHeight = viewportHeight / 2; |
| const int topHeight = viewportHeight - bottomHeight; |
| |
| // Clear. |
| glClearColor(0.125f, 0.25f, 0.5f, 1.0f); |
| glClear(GL_COLOR_BUFFER_BIT); |
| |
| // Texture scaling and offsetting vectors. |
| const Vec2 texMinScale(+1.8f, +1.8f); |
| const Vec2 texMinOffset(-0.3f, -0.2f); |
| const Vec2 texMagScale(+0.3f, +0.3f); |
| const Vec2 texMagOffset(+0.9f, +0.8f); |
| |
| // Surface for the reference image. |
| tcu::Surface refImage(viewportWidth, viewportHeight); |
| |
| { |
| const struct Render |
| { |
| const Rect region; |
| int textureNdx; |
| const Vec2 texCoordScale; |
| const Vec2 texCoordOffset; |
| Render(const Rect &r, int tN, const Vec2 &tS, const Vec2 &tO) |
| : region(r) |
| , textureNdx(tN) |
| , texCoordScale(tS) |
| , texCoordOffset(tO) |
| { |
| } |
| } renders[] = {Render(Rect(0, 0, leftWidth, bottomHeight), 0, texMinScale, texMinOffset), |
| Render(Rect(leftWidth, 0, rightWidth, bottomHeight), 0, texMagScale, texMagOffset), |
| Render(Rect(0, bottomHeight, leftWidth, topHeight), 1, texMinScale, texMinOffset), |
| Render(Rect(leftWidth, bottomHeight, rightWidth, topHeight), 1, texMagScale, texMagOffset)}; |
| |
| for (int renderNdx = 0; renderNdx < DE_LENGTH_OF_ARRAY(renders); renderNdx++) |
| { |
| const Render &rend = renders[renderNdx]; |
| const float lod = calculateLod(rend.texCoordScale, rend.region.size().asFloat(), rend.textureNdx); |
| const bool useSafeTexCoords = isLevelNearest(lod > 0.0f ? m_minFilter : m_magFilter); |
| const Grid grid(GRID_SIZE_2D, rend.region.size(), getTextureSize(*m_textures[rend.textureNdx]), |
| TexTypeCoordParams<TEXTURETYPE_2D>(rend.texCoordScale, rend.texCoordOffset), |
| useSafeTexCoords); |
| |
| glViewport(viewportXOffset + rend.region.x, viewportYOffset + rend.region.y, rend.region.w, rend.region.h); |
| renderCell(rend.textureNdx, lod, grid); |
| computeReferenceCell(rend.textureNdx, lod, grid, refImage, rend.region); |
| } |
| } |
| |
| // Read back rendered results. |
| tcu::Surface resImage(viewportWidth, viewportHeight); |
| glu::readPixels(m_context.getRenderContext(), viewportXOffset, viewportYOffset, resImage.getAccess()); |
| |
| glUseProgram(0); |
| |
| // Compare and log. |
| { |
| const bool isOk = compareImages(m_context.getRenderContext(), m_testCtx.getLog(), refImage, resImage); |
| |
| m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, |
| isOk ? "Pass" : "Image comparison failed"); |
| } |
| |
| return STOP; |
| } |
| |
| void Vertex2DTextureCase::setupShaderInputs(int textureNdx, float lod, const Grid &grid) const |
| { |
| const uint32_t programID = m_program->getProgram(); |
| |
| // SETUP ATTRIBUTES. |
| |
| { |
| const int positionLoc = glGetAttribLocation(programID, "a_position"); |
| if (positionLoc != -1) |
| { |
| glEnableVertexAttribArray(positionLoc); |
| glVertexAttribPointer(positionLoc, 2, GL_FLOAT, GL_FALSE, 0, grid.getPositionPtr()); |
| } |
| } |
| |
| { |
| const int texCoordLoc = glGetAttribLocation(programID, "a_texCoord"); |
| if (texCoordLoc != -1) |
| { |
| glEnableVertexAttribArray(texCoordLoc); |
| glVertexAttribPointer(texCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, grid.getTexCoordPtr()); |
| } |
| } |
| |
| // SETUP UNIFORMS. |
| |
| { |
| const int lodLoc = glGetUniformLocation(programID, "u_lod"); |
| if (lodLoc != -1) |
| glUniform1f(lodLoc, lod); |
| } |
| |
| glActiveTexture(GL_TEXTURE0); |
| glBindTexture(GL_TEXTURE_2D, m_textures[textureNdx]->getGLTexture()); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_magFilter); |
| |
| { |
| const int texLoc = glGetUniformLocation(programID, "u_texture"); |
| if (texLoc != -1) |
| glUniform1i(texLoc, 0); |
| } |
| } |
| |
| // Renders one sub-image with given parameters. |
| void Vertex2DTextureCase::renderCell(int textureNdx, float lod, const Grid &grid) const |
| { |
| setupShaderInputs(textureNdx, lod, grid); |
| glDrawElements(GL_TRIANGLES, grid.getNumIndices(), GL_UNSIGNED_SHORT, grid.getIndexPtr()); |
| } |
| |
| void Vertex2DTextureCase::computeReferenceCell(int textureNdx, float lod, const Grid &grid, tcu::Surface &dst, |
| const Rect &dstRegion) const |
| { |
| computeReference(m_textures[textureNdx]->getRefTexture(), lod, |
| glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter), grid, dst, dstRegion); |
| } |
| |
| class VertexCubeTextureCase : public TestCase |
| { |
| public: |
| VertexCubeTextureCase(Context &testCtx, const char *name, const char *desc, uint32_t minFilter, uint32_t magFilter, |
| uint32_t wrapS, uint32_t wrapT); |
| ~VertexCubeTextureCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| typedef PosTexCoordQuadGrid<TEXTURETYPE_CUBE> Grid; |
| |
| VertexCubeTextureCase(const VertexCubeTextureCase &other); |
| VertexCubeTextureCase &operator=(const VertexCubeTextureCase &other); |
| |
| float calculateLod(const Vec2 &texScale, const Vec2 &dstSize, int textureNdx) const; |
| void setupShaderInputs(int textureNdx, float lod, const Grid &grid) const; |
| void renderCell(int textureNdx, float lod, const Grid &grid) const; |
| void computeReferenceCell(int textureNdx, float lod, const Grid &grid, tcu::Surface &dst, |
| const Rect &dstRegion) const; |
| |
| const uint32_t m_minFilter; |
| const uint32_t m_magFilter; |
| const uint32_t m_wrapS; |
| const uint32_t m_wrapT; |
| |
| const glu::ShaderProgram *m_program; |
| glu::TextureCube *m_textures[2]; // 2 textures, a gradient texture and a grid texture. |
| }; |
| |
| VertexCubeTextureCase::VertexCubeTextureCase(Context &testCtx, const char *name, const char *desc, uint32_t minFilter, |
| uint32_t magFilter, uint32_t wrapS, uint32_t wrapT) |
| : TestCase(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, desc) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_program(DE_NULL) |
| { |
| m_textures[0] = DE_NULL; |
| m_textures[1] = DE_NULL; |
| } |
| |
| VertexCubeTextureCase::~VertexCubeTextureCase(void) |
| { |
| VertexCubeTextureCase::deinit(); |
| } |
| |
| void VertexCubeTextureCase::init(void) |
| { |
| const char *const vertexShader = "#version 300 es\n" |
| "in highp vec2 a_position;\n" |
| "in highp vec3 a_texCoord;\n" |
| "uniform highp samplerCube u_texture;\n" |
| "uniform highp float u_lod;\n" |
| "out mediump vec4 v_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(a_position, 0.0, 1.0);\n" |
| " v_color = textureLod(u_texture, a_texCoord, u_lod);\n" |
| "}\n"; |
| |
| const char *const fragmentShader = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 dEQP_FragColor;\n" |
| "in mediump vec4 v_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " dEQP_FragColor = v_color;\n" |
| "}\n"; |
| |
| if (m_context.getRenderTarget().getNumSamples() != 0) |
| throw tcu::NotSupportedError("MSAA config not supported by this test"); |
| |
| DE_ASSERT(!m_program); |
| m_program = |
| new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(vertexShader, fragmentShader)); |
| |
| if (!m_program->isOk()) |
| { |
| m_testCtx.getLog() << *m_program; |
| |
| GLint maxVertexTextures; |
| glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &maxVertexTextures); |
| |
| if (maxVertexTextures < 1) |
| throw tcu::NotSupportedError("Vertex texture image units not supported", "", __FILE__, __LINE__); |
| else |
| TCU_FAIL("Failed to compile shader"); |
| } |
| |
| // Make the textures. |
| try |
| { |
| // Compute suitable power-of-two sizes (for mipmaps). |
| const int texWidth = 1 << deLog2Ceil32(MAX_CUBE_RENDER_WIDTH / 3 / 2); |
| const int texHeight = 1 << deLog2Ceil32(MAX_CUBE_RENDER_HEIGHT / 2 / 2); |
| |
| DE_ASSERT(texWidth == texHeight); |
| DE_UNREF(texHeight); |
| |
| for (int i = 0; i < 2; i++) |
| { |
| DE_ASSERT(!m_textures[i]); |
| m_textures[i] = new glu::TextureCube(m_context.getRenderContext(), GL_RGB, GL_UNSIGNED_BYTE, texWidth); |
| } |
| |
| const bool mipmaps = deIsPowerOfTwo32(texWidth) != false; |
| const int numLevels = mipmaps ? deLog2Floor32(texWidth) + 1 : 1; |
| const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_textures[0]->getRefTexture().getFormat()); |
| const Vec4 cBias = fmtInfo.valueMin; |
| const Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin; |
| |
| // Fill first with gradient texture. |
| static const Vec4 gradients[tcu::CUBEFACE_LAST][2] = { |
| {Vec4(-1.0f, -1.0f, -1.0f, 2.0f), Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // negative x |
| {Vec4(0.0f, -1.0f, -1.0f, 2.0f), Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // positive x |
| {Vec4(-1.0f, 0.0f, -1.0f, 2.0f), Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // negative y |
| {Vec4(-1.0f, -1.0f, 0.0f, 2.0f), Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // positive y |
| {Vec4(-1.0f, -1.0f, -1.0f, 0.0f), Vec4(1.0f, 1.0f, 1.0f, 1.0f)}, // negative z |
| {Vec4(0.0f, 0.0f, 0.0f, 2.0f), Vec4(1.0f, 1.0f, 1.0f, 0.0f)} // positive z |
| }; |
| for (int face = 0; face < tcu::CUBEFACE_LAST; face++) |
| { |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| m_textures[0]->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx); |
| tcu::fillWithComponentGradients( |
| m_textures[0]->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), |
| gradients[face][0] * cScale + cBias, gradients[face][1] * cScale + cBias); |
| } |
| } |
| |
| // Fill second with grid texture. |
| for (int face = 0; face < tcu::CUBEFACE_LAST; face++) |
| { |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| const uint32_t step = 0x00ffffff / (numLevels * tcu::CUBEFACE_LAST); |
| const uint32_t rgb = step * levelNdx * face; |
| const uint32_t colorA = 0xff000000 | rgb; |
| const uint32_t colorB = 0xff000000 | ~rgb; |
| |
| m_textures[1]->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx); |
| tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), 4, |
| tcu::RGBA(colorA).toVec() * cScale + cBias, |
| tcu::RGBA(colorB).toVec() * cScale + cBias); |
| } |
| } |
| |
| // Upload. |
| for (int i = 0; i < 2; i++) |
| m_textures[i]->upload(); |
| } |
| catch (const std::exception &) |
| { |
| // Clean up to save memory. |
| VertexCubeTextureCase::deinit(); |
| throw; |
| } |
| } |
| |
| void VertexCubeTextureCase::deinit(void) |
| { |
| for (int i = 0; i < 2; i++) |
| { |
| delete m_textures[i]; |
| m_textures[i] = DE_NULL; |
| } |
| |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| float VertexCubeTextureCase::calculateLod(const Vec2 &texScale, const Vec2 &dstSize, int textureNdx) const |
| { |
| const tcu::TextureCube &refTexture = m_textures[textureNdx]->getRefTexture(); |
| const Vec2 srcSize = Vec2((float)refTexture.getSize(), (float)refTexture.getSize()); |
| const Vec2 sizeRatio = texScale * srcSize / dstSize; |
| |
| // \note In this particular case, dv/dx and du/dy are zero, simplifying the expression. |
| return deFloatLog2(de::max(sizeRatio.x(), sizeRatio.y())); |
| } |
| |
| VertexCubeTextureCase::IterateResult VertexCubeTextureCase::iterate(void) |
| { |
| const int viewportWidth = deMin32(m_context.getRenderTarget().getWidth(), MAX_CUBE_RENDER_WIDTH); |
| const int viewportHeight = deMin32(m_context.getRenderTarget().getHeight(), MAX_CUBE_RENDER_HEIGHT); |
| |
| const int viewportXOffsetMax = m_context.getRenderTarget().getWidth() - viewportWidth; |
| const int viewportYOffsetMax = m_context.getRenderTarget().getHeight() - viewportHeight; |
| |
| de::Random rnd(deStringHash(getName())); |
| |
| const int viewportXOffset = rnd.getInt(0, viewportXOffsetMax); |
| const int viewportYOffset = rnd.getInt(0, viewportYOffsetMax); |
| |
| glUseProgram(m_program->getProgram()); |
| |
| // Divide viewport into 4 areas. |
| const int leftWidth = viewportWidth / 2; |
| const int rightWidth = viewportWidth - leftWidth; |
| const int bottomHeight = viewportHeight / 2; |
| const int topHeight = viewportHeight - bottomHeight; |
| |
| // Clear. |
| glClearColor(0.125f, 0.25f, 0.5f, 1.0f); |
| glClear(GL_COLOR_BUFFER_BIT); |
| |
| // Texture scaling and offsetting vectors. |
| const Vec2 texMinScale(1.0f, 1.0f); |
| const Vec2 texMinOffset(0.0f, 0.0f); |
| const Vec2 texMagScale(0.3f, 0.3f); |
| const Vec2 texMagOffset(0.5f, 0.3f); |
| |
| // Surface for the reference image. |
| tcu::Surface refImage(viewportWidth, viewportHeight); |
| |
| // Each of the four areas is divided into 6 cells. |
| const int defCellWidth = viewportWidth / 2 / 3; |
| const int defCellHeight = viewportHeight / 2 / 2; |
| |
| for (int i = 0; i < tcu::CUBEFACE_LAST; i++) |
| { |
| const int cellOffsetX = defCellWidth * (i % 3); |
| const int cellOffsetY = defCellHeight * (i / 3); |
| const bool isRightmostCell = i == 2 || i == 5; |
| const bool isTopCell = i >= 3; |
| const int leftCellWidth = isRightmostCell ? leftWidth - cellOffsetX : defCellWidth; |
| const int rightCellWidth = isRightmostCell ? rightWidth - cellOffsetX : defCellWidth; |
| const int bottomCellHeight = isTopCell ? bottomHeight - cellOffsetY : defCellHeight; |
| const int topCellHeight = isTopCell ? topHeight - cellOffsetY : defCellHeight; |
| |
| const struct Render |
| { |
| const Rect region; |
| int textureNdx; |
| const Vec2 texCoordScale; |
| const Vec2 texCoordOffset; |
| Render(const Rect &r, int tN, const Vec2 &tS, const Vec2 &tO) |
| : region(r) |
| , textureNdx(tN) |
| , texCoordScale(tS) |
| , texCoordOffset(tO) |
| { |
| } |
| } renders[] = {Render(Rect(cellOffsetX + 0, cellOffsetY + 0, leftCellWidth, bottomCellHeight), 0, texMinScale, |
| texMinOffset), |
| Render(Rect(cellOffsetX + leftWidth, cellOffsetY + 0, rightCellWidth, bottomCellHeight), 0, |
| texMagScale, texMagOffset), |
| Render(Rect(cellOffsetX + 0, cellOffsetY + bottomHeight, leftCellWidth, topCellHeight), 1, |
| texMinScale, texMinOffset), |
| Render(Rect(cellOffsetX + leftWidth, cellOffsetY + bottomHeight, rightCellWidth, topCellHeight), |
| 1, texMagScale, texMagOffset)}; |
| |
| for (int renderNdx = 0; renderNdx < DE_LENGTH_OF_ARRAY(renders); renderNdx++) |
| { |
| const Render &rend = renders[renderNdx]; |
| const float lod = calculateLod(rend.texCoordScale, rend.region.size().asFloat(), rend.textureNdx); |
| const bool useSafeTexCoords = isLevelNearest(lod > 0.0f ? m_minFilter : m_magFilter); |
| const Grid grid( |
| GRID_SIZE_CUBE, rend.region.size(), getTextureSize(*m_textures[rend.textureNdx]), |
| TexTypeCoordParams<TEXTURETYPE_CUBE>(rend.texCoordScale, rend.texCoordOffset, (tcu::CubeFace)i), |
| useSafeTexCoords); |
| |
| glViewport(viewportXOffset + rend.region.x, viewportYOffset + rend.region.y, rend.region.w, rend.region.h); |
| renderCell(rend.textureNdx, lod, grid); |
| computeReferenceCell(rend.textureNdx, lod, grid, refImage, rend.region); |
| } |
| } |
| |
| // Read back rendered results. |
| tcu::Surface resImage(viewportWidth, viewportHeight); |
| glu::readPixels(m_context.getRenderContext(), viewportXOffset, viewportYOffset, resImage.getAccess()); |
| |
| glUseProgram(0); |
| |
| // Compare and log. |
| { |
| const bool isOk = compareImages(m_context.getRenderContext(), m_testCtx.getLog(), refImage, resImage); |
| |
| m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, |
| isOk ? "Pass" : "Image comparison failed"); |
| } |
| |
| return STOP; |
| } |
| |
| void VertexCubeTextureCase::setupShaderInputs(int textureNdx, float lod, const Grid &grid) const |
| { |
| const uint32_t programID = m_program->getProgram(); |
| |
| // SETUP ATTRIBUTES. |
| |
| { |
| const int positionLoc = glGetAttribLocation(programID, "a_position"); |
| if (positionLoc != -1) |
| { |
| glEnableVertexAttribArray(positionLoc); |
| glVertexAttribPointer(positionLoc, 2, GL_FLOAT, GL_FALSE, 0, grid.getPositionPtr()); |
| } |
| } |
| |
| { |
| const int texCoordLoc = glGetAttribLocation(programID, "a_texCoord"); |
| if (texCoordLoc != -1) |
| { |
| glEnableVertexAttribArray(texCoordLoc); |
| glVertexAttribPointer(texCoordLoc, 3, GL_FLOAT, GL_FALSE, 0, grid.getTexCoordPtr()); |
| } |
| } |
| |
| // SETUP UNIFORMS. |
| |
| { |
| const int lodLoc = glGetUniformLocation(programID, "u_lod"); |
| if (lodLoc != -1) |
| glUniform1f(lodLoc, lod); |
| } |
| |
| glActiveTexture(GL_TEXTURE0); |
| glBindTexture(GL_TEXTURE_CUBE_MAP, m_textures[textureNdx]->getGLTexture()); |
| glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS); |
| glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT); |
| glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter); |
| glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, m_magFilter); |
| |
| { |
| const int texLoc = glGetUniformLocation(programID, "u_texture"); |
| if (texLoc != -1) |
| glUniform1i(texLoc, 0); |
| } |
| } |
| |
| // Renders one cube face with given parameters. |
| void VertexCubeTextureCase::renderCell(int textureNdx, float lod, const Grid &grid) const |
| { |
| setupShaderInputs(textureNdx, lod, grid); |
| glDrawElements(GL_TRIANGLES, grid.getNumIndices(), GL_UNSIGNED_SHORT, grid.getIndexPtr()); |
| } |
| |
| // Computes reference for one cube face with given parameters. |
| void VertexCubeTextureCase::computeReferenceCell(int textureNdx, float lod, const Grid &grid, tcu::Surface &dst, |
| const Rect &dstRegion) const |
| { |
| tcu::Sampler sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter); |
| sampler.seamlessCubeMap = true; |
| computeReference(m_textures[textureNdx]->getRefTexture(), lod, sampler, grid, dst, dstRegion); |
| } |
| |
| class Vertex2DArrayTextureCase : public TestCase |
| { |
| public: |
| Vertex2DArrayTextureCase(Context &testCtx, const char *name, const char *desc, uint32_t minFilter, |
| uint32_t magFilter, uint32_t wrapS, uint32_t wrapT); |
| ~Vertex2DArrayTextureCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| typedef PosTexCoordQuadGrid<TEXTURETYPE_2D_ARRAY> Grid; |
| |
| Vertex2DArrayTextureCase(const Vertex2DArrayTextureCase &other); |
| Vertex2DArrayTextureCase &operator=(const Vertex2DArrayTextureCase &other); |
| |
| float calculateLod(const Mat3 &transf, const Vec2 &dstSize, int textureNdx) const; |
| void setupShaderInputs(int textureNdx, float lod, const Grid &grid) const; |
| void renderCell(int textureNdx, float lod, const Grid &grid) const; |
| void computeReferenceCell(int textureNdx, float lod, const Grid &grid, tcu::Surface &dst, |
| const Rect &dstRegion) const; |
| |
| const uint32_t m_minFilter; |
| const uint32_t m_magFilter; |
| const uint32_t m_wrapS; |
| const uint32_t m_wrapT; |
| |
| const glu::ShaderProgram *m_program; |
| glu::Texture2DArray *m_textures[2]; // 2 textures, a gradient texture and a grid texture. |
| }; |
| |
| Vertex2DArrayTextureCase::Vertex2DArrayTextureCase(Context &testCtx, const char *name, const char *desc, |
| uint32_t minFilter, uint32_t magFilter, uint32_t wrapS, |
| uint32_t wrapT) |
| : TestCase(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, desc) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_program(DE_NULL) |
| { |
| m_textures[0] = DE_NULL; |
| m_textures[1] = DE_NULL; |
| } |
| |
| Vertex2DArrayTextureCase::~Vertex2DArrayTextureCase(void) |
| { |
| Vertex2DArrayTextureCase::deinit(); |
| } |
| |
| void Vertex2DArrayTextureCase::init(void) |
| { |
| const char *const vertexShaderSource = "#version 300 es\n" |
| "in highp vec2 a_position;\n" |
| "in highp vec3 a_texCoord;\n" |
| "uniform highp sampler2DArray u_texture;\n" |
| "uniform highp float u_lod;\n" |
| "out mediump vec4 v_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(a_position, 0.0, 1.0);\n" |
| " v_color = textureLod(u_texture, a_texCoord, u_lod);\n" |
| "}\n"; |
| |
| const char *const fragmentShaderSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 dEQP_FragColor;\n" |
| "in mediump vec4 v_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " dEQP_FragColor = v_color;\n" |
| "}\n"; |
| |
| if (m_context.getRenderTarget().getNumSamples() != 0) |
| throw tcu::NotSupportedError("MSAA config not supported by this test"); |
| |
| // Create shader. |
| |
| DE_ASSERT(!m_program); |
| m_program = new glu::ShaderProgram(m_context.getRenderContext(), |
| glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); |
| |
| if (!m_program->isOk()) |
| { |
| m_testCtx.getLog() << *m_program; |
| |
| GLint maxVertexTextures; |
| glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &maxVertexTextures); |
| |
| if (maxVertexTextures < 1) |
| throw tcu::NotSupportedError("Vertex texture image units not supported", "", __FILE__, __LINE__); |
| else |
| TCU_FAIL("Failed to compile shader"); |
| } |
| |
| // Make the textures. |
| |
| try |
| { |
| const int texWidth = WIDTH_2D_ARRAY; |
| const int texHeight = HEIGHT_2D_ARRAY; |
| const int texLayers = LAYERS_2D_ARRAY; |
| |
| for (int i = 0; i < 2; i++) |
| { |
| DE_ASSERT(!m_textures[i]); |
| m_textures[i] = new glu::Texture2DArray(m_context.getRenderContext(), GL_RGB, GL_UNSIGNED_BYTE, texWidth, |
| texHeight, texLayers); |
| } |
| |
| const int numLevels = deLog2Floor32(de::max(texWidth, texHeight)) + 1; |
| const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_textures[0]->getRefTexture().getFormat()); |
| const Vec4 cBias = fmtInfo.valueMin; |
| const Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin; |
| |
| // Fill first with gradient texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| const Vec4 gMin = Vec4(-0.5f, -0.5f, -0.5f, 2.0f) * cScale + cBias; |
| const Vec4 gMax = Vec4(1.0f, 1.0f, 1.0f, 0.0f) * cScale + cBias; |
| |
| m_textures[0]->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevel(levelNdx), gMin, gMax); |
| } |
| |
| // Fill second with grid texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| const uint32_t step = 0x00ffffff / numLevels; |
| const uint32_t rgb = step * levelNdx; |
| const uint32_t colorA = 0xff000000 | rgb; |
| const uint32_t colorB = 0xff000000 | ~rgb; |
| |
| m_textures[1]->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevel(levelNdx), 4, |
| tcu::RGBA(colorA).toVec() * cScale + cBias, tcu::RGBA(colorB).toVec() * cScale + cBias); |
| } |
| |
| // Upload. |
| for (int i = 0; i < 2; i++) |
| m_textures[i]->upload(); |
| } |
| catch (const std::exception &) |
| { |
| // Clean up to save memory. |
| Vertex2DArrayTextureCase::deinit(); |
| throw; |
| } |
| } |
| |
| void Vertex2DArrayTextureCase::deinit(void) |
| { |
| for (int i = 0; i < 2; i++) |
| { |
| delete m_textures[i]; |
| m_textures[i] = DE_NULL; |
| } |
| |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| float Vertex2DArrayTextureCase::calculateLod(const Mat3 &transf, const Vec2 &dstSize, int textureNdx) const |
| { |
| const tcu::Texture2DArray &refTexture = m_textures[textureNdx]->getRefTexture(); |
| const int texWidth = refTexture.getWidth(); |
| const int texHeight = refTexture.getHeight(); |
| |
| // Calculate transformed coordinates of three screen corners. |
| const Vec2 trans00 = (transf * Vec3(0.0f, 0.0f, 1.0f)).xy(); |
| const Vec2 trans01 = (transf * Vec3(0.0f, 1.0f, 1.0f)).xy(); |
| const Vec2 trans10 = (transf * Vec3(1.0f, 0.0f, 1.0f)).xy(); |
| |
| // Derivates. |
| const float dudx = (trans10.x() - trans00.x()) * (float)texWidth / dstSize.x(); |
| const float dudy = (trans01.x() - trans00.x()) * (float)texWidth / dstSize.y(); |
| const float dvdx = (trans10.y() - trans00.y()) * (float)texHeight / dstSize.x(); |
| const float dvdy = (trans01.y() - trans00.y()) * (float)texHeight / dstSize.y(); |
| |
| return deFloatLog2(deFloatSqrt(de::max(dudx * dudx + dvdx * dvdx, dudy * dudy + dvdy * dvdy))); |
| } |
| |
| Vertex2DArrayTextureCase::IterateResult Vertex2DArrayTextureCase::iterate(void) |
| { |
| const int viewportWidth = deMin32(m_context.getRenderTarget().getWidth(), MAX_2D_ARRAY_RENDER_WIDTH); |
| const int viewportHeight = deMin32(m_context.getRenderTarget().getHeight(), MAX_2D_ARRAY_RENDER_HEIGHT); |
| |
| const int viewportXOffsetMax = m_context.getRenderTarget().getWidth() - viewportWidth; |
| const int viewportYOffsetMax = m_context.getRenderTarget().getHeight() - viewportHeight; |
| |
| de::Random rnd(deStringHash(getName())); |
| |
| const int viewportXOffset = rnd.getInt(0, viewportXOffsetMax); |
| const int viewportYOffset = rnd.getInt(0, viewportYOffsetMax); |
| |
| glUseProgram(m_program->getProgram()); |
| |
| // Divide viewport into 4 cells. |
| const int leftWidth = viewportWidth / 2; |
| const int rightWidth = viewportWidth - leftWidth; |
| const int bottomHeight = viewportHeight / 2; |
| const int topHeight = viewportHeight - bottomHeight; |
| |
| // Clear. |
| glClearColor(0.125f, 0.25f, 0.5f, 1.0f); |
| glClear(GL_COLOR_BUFFER_BIT); |
| |
| // Shear by layer count to get all layers visible. |
| static const float layerShearTransfData[] = {1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, (float)LAYERS_2D_ARRAY, |
| 0.0f, 0.0f}; |
| |
| // Minification and magnification transformations. |
| static const float texMinTransfData[] = {2.1f, 0.0f, -0.3f, 0.0f, 2.1f, -0.3f, 0.0f, 0.0f, 1.0f}; |
| static const float texMagTransfData[] = {0.4f, 0.0f, 0.8f, 0.0f, 0.4f, 0.8f, 0.0f, 0.0f, 1.0f}; |
| |
| // Transformation matrices for minification and magnification. |
| const Mat3 texMinTransf = Mat3(layerShearTransfData) * Mat3(texMinTransfData); |
| const Mat3 texMagTransf = Mat3(layerShearTransfData) * Mat3(texMagTransfData); |
| |
| // Surface for the reference image. |
| tcu::Surface refImage(viewportWidth, viewportHeight); |
| |
| { |
| const struct Render |
| { |
| const Rect region; |
| int textureNdx; |
| const Mat3 texTransform; |
| Render(const Rect &r, int tN, const Mat3 &tT) : region(r), textureNdx(tN), texTransform(tT) |
| { |
| } |
| } renders[] = {Render(Rect(0, 0, leftWidth, bottomHeight), 0, texMinTransf), |
| Render(Rect(leftWidth, 0, rightWidth, bottomHeight), 0, texMagTransf), |
| Render(Rect(0, bottomHeight, leftWidth, topHeight), 1, texMinTransf), |
| Render(Rect(leftWidth, bottomHeight, rightWidth, topHeight), 1, texMagTransf)}; |
| |
| for (int renderNdx = 0; renderNdx < DE_LENGTH_OF_ARRAY(renders); renderNdx++) |
| { |
| const Render &rend = renders[renderNdx]; |
| const float lod = calculateLod(rend.texTransform, rend.region.size().asFloat(), rend.textureNdx); |
| const bool useSafeTexCoords = isLevelNearest(lod > 0.0f ? m_minFilter : m_magFilter); |
| const Grid grid(GRID_SIZE_2D_ARRAY, rend.region.size(), getTextureSize(*m_textures[rend.textureNdx]), |
| TexTypeCoordParams<TEXTURETYPE_2D_ARRAY>(rend.texTransform), useSafeTexCoords); |
| |
| glViewport(viewportXOffset + rend.region.x, viewportYOffset + rend.region.y, rend.region.w, rend.region.h); |
| renderCell(rend.textureNdx, lod, grid); |
| computeReferenceCell(rend.textureNdx, lod, grid, refImage, rend.region); |
| } |
| } |
| |
| // Read back rendered results. |
| tcu::Surface resImage(viewportWidth, viewportHeight); |
| glu::readPixels(m_context.getRenderContext(), viewportXOffset, viewportYOffset, resImage.getAccess()); |
| |
| glUseProgram(0); |
| |
| // Compare and log. |
| { |
| const bool isOk = compareImages(m_context.getRenderContext(), m_testCtx.getLog(), refImage, resImage); |
| |
| m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, |
| isOk ? "Pass" : "Image comparison failed"); |
| } |
| |
| return STOP; |
| } |
| |
| void Vertex2DArrayTextureCase::setupShaderInputs(int textureNdx, float lod, const Grid &grid) const |
| { |
| const uint32_t programID = m_program->getProgram(); |
| |
| // SETUP ATTRIBUTES. |
| |
| { |
| const int positionLoc = glGetAttribLocation(programID, "a_position"); |
| if (positionLoc != -1) |
| { |
| glEnableVertexAttribArray(positionLoc); |
| glVertexAttribPointer(positionLoc, 2, GL_FLOAT, GL_FALSE, 0, grid.getPositionPtr()); |
| } |
| } |
| |
| { |
| const int texCoordLoc = glGetAttribLocation(programID, "a_texCoord"); |
| if (texCoordLoc != -1) |
| { |
| glEnableVertexAttribArray(texCoordLoc); |
| glVertexAttribPointer(texCoordLoc, 3, GL_FLOAT, GL_FALSE, 0, grid.getTexCoordPtr()); |
| } |
| } |
| |
| // SETUP UNIFORMS. |
| |
| { |
| const int lodLoc = glGetUniformLocation(programID, "u_lod"); |
| if (lodLoc != -1) |
| glUniform1f(lodLoc, lod); |
| } |
| |
| glActiveTexture(GL_TEXTURE0); |
| glBindTexture(GL_TEXTURE_2D_ARRAY, m_textures[textureNdx]->getGLTexture()); |
| glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, m_wrapS); |
| glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, m_wrapT); |
| glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, m_minFilter); |
| glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, m_magFilter); |
| |
| { |
| const int texLoc = glGetUniformLocation(programID, "u_texture"); |
| if (texLoc != -1) |
| glUniform1i(texLoc, 0); |
| } |
| } |
| |
| // Renders one sub-image with given parameters. |
| void Vertex2DArrayTextureCase::renderCell(int textureNdx, float lod, const Grid &grid) const |
| { |
| setupShaderInputs(textureNdx, lod, grid); |
| glDrawElements(GL_TRIANGLES, grid.getNumIndices(), GL_UNSIGNED_SHORT, grid.getIndexPtr()); |
| } |
| |
| // Computes reference for one sub-image with given parameters. |
| void Vertex2DArrayTextureCase::computeReferenceCell(int textureNdx, float lod, const Grid &grid, tcu::Surface &dst, |
| const Rect &dstRegion) const |
| { |
| computeReference(m_textures[textureNdx]->getRefTexture(), lod, |
| glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter), grid, dst, dstRegion); |
| } |
| |
| class Vertex3DTextureCase : public TestCase |
| { |
| public: |
| Vertex3DTextureCase(Context &testCtx, const char *name, const char *desc, uint32_t minFilter, uint32_t magFilter, |
| uint32_t wrapS, uint32_t wrapT, uint32_t wrapR); |
| ~Vertex3DTextureCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| typedef PosTexCoordQuadGrid<TEXTURETYPE_3D> Grid; |
| |
| Vertex3DTextureCase(const Vertex3DTextureCase &other); |
| Vertex3DTextureCase &operator=(const Vertex3DTextureCase &other); |
| |
| float calculateLod(const Mat3 &transf, const Vec2 &dstSize, int textureNdx) const; |
| void setupShaderInputs(int textureNdx, float lod, const Grid &grid) const; |
| void renderCell(int textureNdx, float lod, const Grid &grid) const; |
| void computeReferenceCell(int textureNdx, float lod, const Grid &grid, tcu::Surface &dst, |
| const Rect &dstRegion) const; |
| |
| const uint32_t m_minFilter; |
| const uint32_t m_magFilter; |
| const uint32_t m_wrapS; |
| const uint32_t m_wrapT; |
| const uint32_t m_wrapR; |
| |
| const glu::ShaderProgram *m_program; |
| glu::Texture3D *m_textures[2]; // 2 textures, a gradient texture and a grid texture. |
| }; |
| |
| Vertex3DTextureCase::Vertex3DTextureCase(Context &testCtx, const char *name, const char *desc, uint32_t minFilter, |
| uint32_t magFilter, uint32_t wrapS, uint32_t wrapT, uint32_t wrapR) |
| : TestCase(testCtx, tcu::NODETYPE_SELF_VALIDATE, name, desc) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_wrapR(wrapR) |
| , m_program(DE_NULL) |
| { |
| m_textures[0] = DE_NULL; |
| m_textures[1] = DE_NULL; |
| } |
| |
| Vertex3DTextureCase::~Vertex3DTextureCase(void) |
| { |
| Vertex3DTextureCase::deinit(); |
| } |
| |
| void Vertex3DTextureCase::init(void) |
| { |
| const char *const vertexShaderSource = "#version 300 es\n" |
| "in highp vec2 a_position;\n" |
| "in highp vec3 a_texCoord;\n" |
| "uniform highp sampler3D u_texture;\n" |
| "uniform highp float u_lod;\n" |
| "out mediump vec4 v_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(a_position, 0.0, 1.0);\n" |
| " v_color = textureLod(u_texture, a_texCoord, u_lod);\n" |
| "}\n"; |
| |
| const char *const fragmentShaderSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 dEQP_FragColor;\n" |
| "in mediump vec4 v_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " dEQP_FragColor = v_color;\n" |
| "}\n"; |
| |
| if (m_context.getRenderTarget().getNumSamples() != 0) |
| throw tcu::NotSupportedError("MSAA config not supported by this test"); |
| |
| // Create shader. |
| |
| DE_ASSERT(!m_program); |
| m_program = new glu::ShaderProgram(m_context.getRenderContext(), |
| glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); |
| |
| if (!m_program->isOk()) |
| { |
| m_testCtx.getLog() << *m_program; |
| |
| GLint maxVertexTextures; |
| glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &maxVertexTextures); |
| |
| if (maxVertexTextures < 1) |
| throw tcu::NotSupportedError("Vertex texture image units not supported", "", __FILE__, __LINE__); |
| else |
| TCU_FAIL("Failed to compile shader"); |
| } |
| |
| // Make the textures. |
| |
| try |
| { |
| const int texWidth = WIDTH_3D; |
| const int texHeight = HEIGHT_3D; |
| const int texDepth = DEPTH_3D; |
| |
| for (int i = 0; i < 2; i++) |
| { |
| DE_ASSERT(!m_textures[i]); |
| m_textures[i] = new glu::Texture3D(m_context.getRenderContext(), GL_RGB, GL_UNSIGNED_BYTE, texWidth, |
| texHeight, texDepth); |
| } |
| |
| const int numLevels = deLog2Floor32(de::max(de::max(texWidth, texHeight), texDepth)) + 1; |
| const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_textures[0]->getRefTexture().getFormat()); |
| const Vec4 cBias = fmtInfo.valueMin; |
| const Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin; |
| |
| // Fill first with gradient texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| const Vec4 gMin = Vec4(-0.5f, -0.5f, -0.5f, 2.0f) * cScale + cBias; |
| const Vec4 gMax = Vec4(1.0f, 1.0f, 1.0f, 0.0f) * cScale + cBias; |
| |
| m_textures[0]->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevel(levelNdx), gMin, gMax); |
| } |
| |
| // Fill second with grid texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| const uint32_t step = 0x00ffffff / numLevels; |
| const uint32_t rgb = step * levelNdx; |
| const uint32_t colorA = 0xff000000 | rgb; |
| const uint32_t colorB = 0xff000000 | ~rgb; |
| |
| m_textures[1]->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevel(levelNdx), 4, |
| tcu::RGBA(colorA).toVec() * cScale + cBias, tcu::RGBA(colorB).toVec() * cScale + cBias); |
| } |
| |
| // Upload. |
| for (int i = 0; i < 2; i++) |
| m_textures[i]->upload(); |
| } |
| catch (const std::exception &) |
| { |
| // Clean up to save memory. |
| Vertex3DTextureCase::deinit(); |
| throw; |
| } |
| } |
| |
| void Vertex3DTextureCase::deinit(void) |
| { |
| for (int i = 0; i < 2; i++) |
| { |
| delete m_textures[i]; |
| m_textures[i] = DE_NULL; |
| } |
| |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| float Vertex3DTextureCase::calculateLod(const Mat3 &transf, const Vec2 &dstSize, int textureNdx) const |
| { |
| const tcu::Texture3D &refTexture = m_textures[textureNdx]->getRefTexture(); |
| const int srcWidth = refTexture.getWidth(); |
| const int srcHeight = refTexture.getHeight(); |
| const int srcDepth = refTexture.getDepth(); |
| |
| // Calculate transformed coordinates of three screen corners. |
| const Vec3 trans00 = transf * Vec3(0.0f, 0.0f, 1.0f); |
| const Vec3 trans01 = transf * Vec3(0.0f, 1.0f, 1.0f); |
| const Vec3 trans10 = transf * Vec3(1.0f, 0.0f, 1.0f); |
| |
| // Derivates. |
| const float dudx = (trans10.x() - trans00.x()) * (float)srcWidth / dstSize.x(); |
| const float dudy = (trans01.x() - trans00.x()) * (float)srcWidth / dstSize.y(); |
| const float dvdx = (trans10.y() - trans00.y()) * (float)srcHeight / dstSize.x(); |
| const float dvdy = (trans01.y() - trans00.y()) * (float)srcHeight / dstSize.y(); |
| const float dwdx = (trans10.z() - trans00.z()) * (float)srcDepth / dstSize.x(); |
| const float dwdy = (trans01.z() - trans00.z()) * (float)srcDepth / dstSize.y(); |
| |
| return deFloatLog2( |
| deFloatSqrt(de::max(dudx * dudx + dvdx * dvdx + dwdx * dwdx, dudy * dudy + dvdy * dvdy + dwdy * dwdy))); |
| } |
| |
| Vertex3DTextureCase::IterateResult Vertex3DTextureCase::iterate(void) |
| { |
| const int viewportWidth = deMin32(m_context.getRenderTarget().getWidth(), MAX_3D_RENDER_WIDTH); |
| const int viewportHeight = deMin32(m_context.getRenderTarget().getHeight(), MAX_3D_RENDER_HEIGHT); |
| |
| const int viewportXOffsetMax = m_context.getRenderTarget().getWidth() - viewportWidth; |
| const int viewportYOffsetMax = m_context.getRenderTarget().getHeight() - viewportHeight; |
| |
| de::Random rnd(deStringHash(getName())); |
| |
| const int viewportXOffset = rnd.getInt(0, viewportXOffsetMax); |
| const int viewportYOffset = rnd.getInt(0, viewportYOffsetMax); |
| |
| glUseProgram(m_program->getProgram()); |
| |
| // Divide viewport into 4 cells. |
| const int leftWidth = viewportWidth / 2; |
| const int rightWidth = viewportWidth - leftWidth; |
| const int bottomHeight = viewportHeight / 2; |
| const int topHeight = viewportHeight - bottomHeight; |
| |
| // Clear. |
| glClearColor(0.125f, 0.25f, 0.5f, 1.0f); |
| glClear(GL_COLOR_BUFFER_BIT); |
| |
| // Shear to get all slices visible. |
| static const float depthShearTransfData[] = {1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f}; |
| |
| // Minification and magnification transformations. |
| static const float texMinTransfData[] = {2.2f, 0.0f, -0.3f, 0.0f, 2.2f, -0.3f, 0.0f, 0.0f, 1.0f}; |
| static const float texMagTransfData[] = {0.4f, 0.0f, 0.8f, 0.0f, 0.4f, 0.8f, 0.0f, 0.0f, 1.0f}; |
| |
| // Transformation matrices for minification and magnification. |
| const Mat3 texMinTransf = Mat3(depthShearTransfData) * Mat3(texMinTransfData); |
| const Mat3 texMagTransf = Mat3(depthShearTransfData) * Mat3(texMagTransfData); |
| |
| // Surface for the reference image. |
| tcu::Surface refImage(viewportWidth, viewportHeight); |
| |
| { |
| const struct Render |
| { |
| const Rect region; |
| int textureNdx; |
| const Mat3 texTransform; |
| Render(const Rect &r, int tN, const Mat3 &tT) : region(r), textureNdx(tN), texTransform(tT) |
| { |
| } |
| } renders[] = {Render(Rect(0, 0, leftWidth, bottomHeight), 0, texMinTransf), |
| Render(Rect(leftWidth, 0, rightWidth, bottomHeight), 0, texMagTransf), |
| Render(Rect(0, bottomHeight, leftWidth, topHeight), 1, texMinTransf), |
| Render(Rect(leftWidth, bottomHeight, rightWidth, topHeight), 1, texMagTransf)}; |
| |
| for (int renderNdx = 0; renderNdx < DE_LENGTH_OF_ARRAY(renders); renderNdx++) |
| { |
| const Render &rend = renders[renderNdx]; |
| const float lod = calculateLod(rend.texTransform, rend.region.size().asFloat(), rend.textureNdx); |
| const bool useSafeTexCoords = isLevelNearest(lod > 0.0f ? m_minFilter : m_magFilter); |
| const Grid grid(GRID_SIZE_3D, rend.region.size(), getTextureSize(*m_textures[rend.textureNdx]), |
| TexTypeCoordParams<TEXTURETYPE_3D>(rend.texTransform), useSafeTexCoords); |
| |
| glViewport(viewportXOffset + rend.region.x, viewportYOffset + rend.region.y, rend.region.w, rend.region.h); |
| renderCell(rend.textureNdx, lod, grid); |
| computeReferenceCell(rend.textureNdx, lod, grid, refImage, rend.region); |
| } |
| } |
| |
| // Read back rendered results. |
| tcu::Surface resImage(viewportWidth, viewportHeight); |
| glu::readPixels(m_context.getRenderContext(), viewportXOffset, viewportYOffset, resImage.getAccess()); |
| |
| glUseProgram(0); |
| |
| // Compare and log. |
| { |
| const bool isOk = compareImages(m_context.getRenderContext(), m_testCtx.getLog(), refImage, resImage); |
| |
| m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, |
| isOk ? "Pass" : "Image comparison failed"); |
| } |
| |
| return STOP; |
| } |
| |
| void Vertex3DTextureCase::setupShaderInputs(int textureNdx, float lod, const Grid &grid) const |
| { |
| const uint32_t programID = m_program->getProgram(); |
| |
| // SETUP ATTRIBUTES. |
| |
| { |
| const int positionLoc = glGetAttribLocation(programID, "a_position"); |
| if (positionLoc != -1) |
| { |
| glEnableVertexAttribArray(positionLoc); |
| glVertexAttribPointer(positionLoc, 2, GL_FLOAT, GL_FALSE, 0, grid.getPositionPtr()); |
| } |
| } |
| |
| { |
| const int texCoordLoc = glGetAttribLocation(programID, "a_texCoord"); |
| if (texCoordLoc != -1) |
| { |
| glEnableVertexAttribArray(texCoordLoc); |
| glVertexAttribPointer(texCoordLoc, 3, GL_FLOAT, GL_FALSE, 0, grid.getTexCoordPtr()); |
| } |
| } |
| |
| // SETUP UNIFORMS. |
| |
| { |
| const int lodLoc = glGetUniformLocation(programID, "u_lod"); |
| if (lodLoc != -1) |
| glUniform1f(lodLoc, lod); |
| } |
| |
| glActiveTexture(GL_TEXTURE0); |
| glBindTexture(GL_TEXTURE_3D, m_textures[textureNdx]->getGLTexture()); |
| glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, m_wrapS); |
| glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, m_wrapT); |
| glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, m_wrapR); |
| glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, m_minFilter); |
| glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, m_magFilter); |
| |
| { |
| const int texLoc = glGetUniformLocation(programID, "u_texture"); |
| if (texLoc != -1) |
| glUniform1i(texLoc, 0); |
| } |
| } |
| |
| // Renders one sub-image with given parameters. |
| void Vertex3DTextureCase::renderCell(int textureNdx, float lod, const Grid &grid) const |
| { |
| setupShaderInputs(textureNdx, lod, grid); |
| glDrawElements(GL_TRIANGLES, grid.getNumIndices(), GL_UNSIGNED_SHORT, grid.getIndexPtr()); |
| } |
| |
| // Computes reference for one sub-image with given parameters. |
| void Vertex3DTextureCase::computeReferenceCell(int textureNdx, float lod, const Grid &grid, tcu::Surface &dst, |
| const Rect &dstRegion) const |
| { |
| computeReference(m_textures[textureNdx]->getRefTexture(), lod, |
| glu::mapGLSampler(m_wrapS, m_wrapT, m_wrapR, m_minFilter, m_magFilter), grid, dst, dstRegion); |
| } |
| |
| VertexTextureTests::VertexTextureTests(Context &context) : TestCaseGroup(context, "vertex", "Vertex Texture Tests") |
| { |
| } |
| |
| VertexTextureTests::~VertexTextureTests(void) |
| { |
| } |
| |
| void VertexTextureTests::init(void) |
| { |
| // 2D and cube map groups, and their filtering and wrap sub-groups. |
| TestCaseGroup *const group2D = new TestCaseGroup(m_context, "2d", "2D Vertex Texture Tests"); |
| TestCaseGroup *const groupCube = new TestCaseGroup(m_context, "cube", "Cube Map Vertex Texture Tests"); |
| TestCaseGroup *const group2DArray = new TestCaseGroup(m_context, "2d_array", "2D Array Vertex Texture Tests"); |
| TestCaseGroup *const group3D = new TestCaseGroup(m_context, "3d", "3D Vertex Texture Tests"); |
| TestCaseGroup *const filteringGroup2D = |
| new TestCaseGroup(m_context, "filtering", "2D Vertex Texture Filtering Tests"); |
| TestCaseGroup *const wrapGroup2D = new TestCaseGroup(m_context, "wrap", "2D Vertex Texture Wrap Tests"); |
| TestCaseGroup *const filteringGroupCube = |
| new TestCaseGroup(m_context, "filtering", "Cube Map Vertex Texture Filtering Tests"); |
| TestCaseGroup *const wrapGroupCube = new TestCaseGroup(m_context, "wrap", "Cube Map Vertex Texture Wrap Tests"); |
| TestCaseGroup *const filteringGroup2DArray = |
| new TestCaseGroup(m_context, "filtering", "2D Array Vertex Texture Filtering Tests"); |
| TestCaseGroup *const wrapGroup2DArray = new TestCaseGroup(m_context, "wrap", "2D Array Vertex Texture Wrap Tests"); |
| TestCaseGroup *const filteringGroup3D = |
| new TestCaseGroup(m_context, "filtering", "3D Vertex Texture Filtering Tests"); |
| TestCaseGroup *const wrapGroup3D = new TestCaseGroup(m_context, "wrap", "3D Vertex Texture Wrap Tests"); |
| |
| group2D->addChild(filteringGroup2D); |
| group2D->addChild(wrapGroup2D); |
| groupCube->addChild(filteringGroupCube); |
| groupCube->addChild(wrapGroupCube); |
| group2DArray->addChild(filteringGroup2DArray); |
| group2DArray->addChild(wrapGroup2DArray); |
| group3D->addChild(filteringGroup3D); |
| group3D->addChild(wrapGroup3D); |
| |
| addChild(group2D); |
| addChild(groupCube); |
| addChild(group2DArray); |
| addChild(group3D); |
| |
| static const struct |
| { |
| const char *name; |
| GLenum mode; |
| } wrapModes[] = {{"clamp", GL_CLAMP_TO_EDGE}, {"repeat", GL_REPEAT}, {"mirror", GL_MIRRORED_REPEAT}}; |
| |
| static const struct |
| { |
| const char *name; |
| GLenum mode; |
| } minFilterModes[] = {{"nearest", GL_NEAREST}, |
| {"linear", GL_LINEAR}, |
| {"nearest_mipmap_nearest", GL_NEAREST_MIPMAP_NEAREST}, |
| {"linear_mipmap_nearest", GL_LINEAR_MIPMAP_NEAREST}, |
| {"nearest_mipmap_linear", GL_NEAREST_MIPMAP_LINEAR}, |
| {"linear_mipmap_linear", GL_LINEAR_MIPMAP_LINEAR}}; |
| |
| static const struct |
| { |
| const char *name; |
| GLenum mode; |
| } magFilterModes[] = {{"nearest", GL_NEAREST}, {"linear", GL_LINEAR}}; |
| |
| #define FOR_EACH(ITERATOR, ARRAY, BODY) \ |
| for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \ |
| BODY |
| |
| // 2D cases. |
| |
| FOR_EACH(minFilter, minFilterModes, |
| FOR_EACH(magFilter, magFilterModes, FOR_EACH(wrapMode, wrapModes, { |
| const string name = string("") + minFilterModes[minFilter].name + "_" + |
| magFilterModes[magFilter].name + "_" + wrapModes[wrapMode].name; |
| |
| filteringGroup2D->addChild(new Vertex2DTextureCase( |
| m_context, name.c_str(), "", minFilterModes[minFilter].mode, |
| magFilterModes[magFilter].mode, wrapModes[wrapMode].mode, wrapModes[wrapMode].mode)); |
| }))) |
| |
| FOR_EACH(wrapSMode, wrapModes, FOR_EACH(wrapTMode, wrapModes, { |
| const string name = string("") + wrapModes[wrapSMode].name + "_" + wrapModes[wrapTMode].name; |
| |
| wrapGroup2D->addChild(new Vertex2DTextureCase(m_context, name.c_str(), "", GL_LINEAR_MIPMAP_LINEAR, |
| GL_LINEAR, wrapModes[wrapSMode].mode, |
| wrapModes[wrapTMode].mode)); |
| })) |
| |
| // Cube map cases. |
| |
| FOR_EACH(minFilter, minFilterModes, |
| FOR_EACH(magFilter, magFilterModes, FOR_EACH(wrapMode, wrapModes, { |
| const string name = string("") + minFilterModes[minFilter].name + "_" + |
| magFilterModes[magFilter].name + "_" + wrapModes[wrapMode].name; |
| |
| filteringGroupCube->addChild(new VertexCubeTextureCase( |
| m_context, name.c_str(), "", minFilterModes[minFilter].mode, |
| magFilterModes[magFilter].mode, wrapModes[wrapMode].mode, wrapModes[wrapMode].mode)); |
| }))) |
| |
| FOR_EACH(wrapSMode, wrapModes, FOR_EACH(wrapTMode, wrapModes, { |
| const string name = string("") + wrapModes[wrapSMode].name + "_" + wrapModes[wrapTMode].name; |
| |
| wrapGroupCube->addChild(new VertexCubeTextureCase(m_context, name.c_str(), "", GL_LINEAR_MIPMAP_LINEAR, |
| GL_LINEAR, wrapModes[wrapSMode].mode, |
| wrapModes[wrapTMode].mode)); |
| })) |
| |
| // 2D array cases. |
| |
| FOR_EACH(minFilter, minFilterModes, |
| FOR_EACH(magFilter, magFilterModes, FOR_EACH(wrapMode, wrapModes, { |
| const string name = string("") + minFilterModes[minFilter].name + "_" + |
| magFilterModes[magFilter].name + "_" + wrapModes[wrapMode].name; |
| |
| filteringGroup2DArray->addChild(new Vertex2DArrayTextureCase( |
| m_context, name.c_str(), "", minFilterModes[minFilter].mode, |
| magFilterModes[magFilter].mode, wrapModes[wrapMode].mode, wrapModes[wrapMode].mode)); |
| }))) |
| |
| FOR_EACH(wrapSMode, wrapModes, FOR_EACH(wrapTMode, wrapModes, { |
| const string name = string("") + wrapModes[wrapSMode].name + "_" + wrapModes[wrapTMode].name; |
| |
| wrapGroup2DArray->addChild( |
| new Vertex2DArrayTextureCase(m_context, name.c_str(), "", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, |
| wrapModes[wrapSMode].mode, wrapModes[wrapTMode].mode)); |
| })) |
| |
| // 3D cases. |
| |
| FOR_EACH(minFilter, minFilterModes, FOR_EACH(magFilter, magFilterModes, FOR_EACH(wrapMode, wrapModes, { |
| const string name = string("") + minFilterModes[minFilter].name + |
| "_" + magFilterModes[magFilter].name + "_" + |
| wrapModes[wrapMode].name; |
| |
| filteringGroup3D->addChild(new Vertex3DTextureCase( |
| m_context, name.c_str(), "", minFilterModes[minFilter].mode, |
| magFilterModes[magFilter].mode, wrapModes[wrapMode].mode, |
| wrapModes[wrapMode].mode, wrapModes[wrapMode].mode)); |
| }))) |
| |
| FOR_EACH(wrapSMode, wrapModes, |
| FOR_EACH(wrapTMode, wrapModes, FOR_EACH(wrapRMode, wrapModes, { |
| const string name = string("") + wrapModes[wrapSMode].name + "_" + wrapModes[wrapTMode].name + |
| "_" + wrapModes[wrapRMode].name; |
| |
| wrapGroup3D->addChild(new Vertex3DTextureCase( |
| m_context, name.c_str(), "", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, |
| wrapModes[wrapSMode].mode, wrapModes[wrapTMode].mode, wrapModes[wrapRMode].mode)); |
| }))) |
| } |
| |
| } // namespace Functional |
| } // namespace gles3 |
| } // namespace deqp |
