| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL (ES) 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 Shader execute test. |
| * |
| * \todo [petri] Multiple grid with differing constants/uniforms. |
| * \todo [petri] |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "glsShaderRenderCase.hpp" |
| |
| #include "tcuSurface.hpp" |
| #include "tcuVector.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuRenderTarget.hpp" |
| |
| #include "gluPixelTransfer.hpp" |
| #include "gluTexture.hpp" |
| #include "gluTextureUtil.hpp" |
| #include "gluDrawUtil.hpp" |
| |
| #include "glwFunctions.hpp" |
| #include "glwEnums.hpp" |
| |
| #include "deRandom.hpp" |
| #include "deMemory.h" |
| #include "deString.h" |
| #include "deMath.h" |
| #include "deStringUtil.hpp" |
| |
| #include <stdio.h> |
| #include <vector> |
| #include <string> |
| |
| namespace deqp |
| { |
| namespace gls |
| { |
| |
| using namespace std; |
| using namespace tcu; |
| using namespace glu; |
| |
| static const int GRID_SIZE = 92; |
| static const int MAX_RENDER_WIDTH = 128; |
| static const int MAX_RENDER_HEIGHT = 112; |
| static const tcu::Vec4 DEFAULT_CLEAR_COLOR = tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f); |
| |
| // TextureBinding |
| |
| TextureBinding::TextureBinding(const glu::Texture2D *tex2D, const tcu::Sampler &sampler) |
| : m_type(TYPE_2D) |
| , m_sampler(sampler) |
| { |
| m_binding.tex2D = tex2D; |
| } |
| |
| TextureBinding::TextureBinding(const glu::TextureCube *texCube, const tcu::Sampler &sampler) |
| : m_type(TYPE_CUBE_MAP) |
| , m_sampler(sampler) |
| { |
| m_binding.texCube = texCube; |
| } |
| |
| TextureBinding::TextureBinding(const glu::Texture2DArray *tex2DArray, const tcu::Sampler &sampler) |
| : m_type(TYPE_2D_ARRAY) |
| , m_sampler(sampler) |
| { |
| m_binding.tex2DArray = tex2DArray; |
| } |
| |
| TextureBinding::TextureBinding(const glu::Texture3D *tex3D, const tcu::Sampler &sampler) |
| : m_type(TYPE_3D) |
| , m_sampler(sampler) |
| { |
| m_binding.tex3D = tex3D; |
| } |
| |
| TextureBinding::TextureBinding(void) : m_type(TYPE_NONE) |
| { |
| m_binding.tex2D = DE_NULL; |
| } |
| |
| void TextureBinding::setSampler(const tcu::Sampler &sampler) |
| { |
| m_sampler = sampler; |
| } |
| |
| void TextureBinding::setTexture(const glu::Texture2D *tex2D) |
| { |
| m_type = TYPE_2D; |
| m_binding.tex2D = tex2D; |
| } |
| |
| void TextureBinding::setTexture(const glu::TextureCube *texCube) |
| { |
| m_type = TYPE_CUBE_MAP; |
| m_binding.texCube = texCube; |
| } |
| |
| void TextureBinding::setTexture(const glu::Texture2DArray *tex2DArray) |
| { |
| m_type = TYPE_2D_ARRAY; |
| m_binding.tex2DArray = tex2DArray; |
| } |
| |
| void TextureBinding::setTexture(const glu::Texture3D *tex3D) |
| { |
| m_type = TYPE_3D; |
| m_binding.tex3D = tex3D; |
| } |
| |
| // QuadGrid. |
| |
| class QuadGrid |
| { |
| public: |
| QuadGrid(int gridSize, int screenWidth, int screenHeight, const Vec4 &constCoords, |
| const vector<Mat4> &userAttribTransforms, const vector<TextureBinding> &textures); |
| ~QuadGrid(void); |
| |
| int getGridSize(void) const |
| { |
| return m_gridSize; |
| } |
| int getNumVertices(void) const |
| { |
| return m_numVertices; |
| } |
| int getNumTriangles(void) const |
| { |
| return m_numTriangles; |
| } |
| const Vec4 &getConstCoords(void) const |
| { |
| return m_constCoords; |
| } |
| const vector<Mat4> getUserAttribTransforms(void) const |
| { |
| return m_userAttribTransforms; |
| } |
| const vector<TextureBinding> &getTextures(void) const |
| { |
| return m_textures; |
| } |
| |
| const Vec4 *getPositions(void) const |
| { |
| return &m_positions[0]; |
| } |
| const float *getAttribOne(void) const |
| { |
| return &m_attribOne[0]; |
| } |
| const Vec4 *getCoords(void) const |
| { |
| return &m_coords[0]; |
| } |
| const Vec4 *getUnitCoords(void) const |
| { |
| return &m_unitCoords[0]; |
| } |
| const Vec4 *getUserAttrib(int attribNdx) const |
| { |
| return &m_userAttribs[attribNdx][0]; |
| } |
| const uint16_t *getIndices(void) const |
| { |
| return &m_indices[0]; |
| } |
| |
| Vec4 getCoords(float sx, float sy) const; |
| Vec4 getUnitCoords(float sx, float sy) const; |
| |
| int getNumUserAttribs(void) const |
| { |
| return (int)m_userAttribTransforms.size(); |
| } |
| Vec4 getUserAttrib(int attribNdx, float sx, float sy) const; |
| |
| private: |
| int m_gridSize; |
| int m_numVertices; |
| int m_numTriangles; |
| Vec4 m_constCoords; |
| vector<Mat4> m_userAttribTransforms; |
| vector<TextureBinding> m_textures; |
| |
| vector<Vec4> m_screenPos; |
| vector<Vec4> m_positions; |
| vector<Vec4> m_coords; //!< Near-unit coordinates, roughly [-2.0 .. 2.0]. |
| vector<Vec4> m_unitCoords; //!< Positive-only coordinates [0.0 .. 1.5]. |
| vector<float> m_attribOne; |
| vector<Vec4> m_userAttribs[ShaderEvalContext::MAX_TEXTURES]; |
| vector<uint16_t> m_indices; |
| }; |
| |
| QuadGrid::QuadGrid(int gridSize, int width, int height, const Vec4 &constCoords, |
| const vector<Mat4> &userAttribTransforms, const vector<TextureBinding> &textures) |
| : m_gridSize(gridSize) |
| , m_numVertices((gridSize + 1) * (gridSize + 1)) |
| , m_numTriangles(gridSize * gridSize * 2) |
| , m_constCoords(constCoords) |
| , m_userAttribTransforms(userAttribTransforms) |
| , m_textures(textures) |
| { |
| Vec4 viewportScale = Vec4((float)width, (float)height, 0.0f, 0.0f); |
| |
| // Compute vertices. |
| m_positions.resize(m_numVertices); |
| m_coords.resize(m_numVertices); |
| m_unitCoords.resize(m_numVertices); |
| m_attribOne.resize(m_numVertices); |
| m_screenPos.resize(m_numVertices); |
| |
| // User attributes. |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_userAttribs); i++) |
| m_userAttribs[i].resize(m_numVertices); |
| |
| for (int y = 0; y < gridSize + 1; y++) |
| for (int x = 0; x < gridSize + 1; x++) |
| { |
| float sx = (float)x / (float)gridSize; |
| float sy = (float)y / (float)gridSize; |
| float fx = 2.0f * sx - 1.0f; |
| float fy = 2.0f * sy - 1.0f; |
| int vtxNdx = ((y * (gridSize + 1)) + x); |
| |
| m_positions[vtxNdx] = Vec4(fx, fy, 0.0f, 1.0f); |
| m_attribOne[vtxNdx] = 1.0f; |
| m_screenPos[vtxNdx] = Vec4(sx, sy, 0.0f, 1.0f) * viewportScale; |
| m_coords[vtxNdx] = getCoords(sx, sy); |
| m_unitCoords[vtxNdx] = getUnitCoords(sx, sy); |
| |
| for (int attribNdx = 0; attribNdx < getNumUserAttribs(); attribNdx++) |
| m_userAttribs[attribNdx][vtxNdx] = getUserAttrib(attribNdx, sx, sy); |
| } |
| |
| // Compute indices. |
| m_indices.resize(3 * m_numTriangles); |
| for (int y = 0; y < gridSize; y++) |
| for (int x = 0; x < gridSize; x++) |
| { |
| int stride = gridSize + 1; |
| int v00 = (y * stride) + x; |
| int v01 = (y * stride) + x + 1; |
| int v10 = ((y + 1) * stride) + x; |
| int v11 = ((y + 1) * stride) + x + 1; |
| |
| int baseNdx = ((y * gridSize) + x) * 6; |
| m_indices[baseNdx + 0] = (uint16_t)v10; |
| m_indices[baseNdx + 1] = (uint16_t)v00; |
| m_indices[baseNdx + 2] = (uint16_t)v01; |
| |
| m_indices[baseNdx + 3] = (uint16_t)v10; |
| m_indices[baseNdx + 4] = (uint16_t)v01; |
| m_indices[baseNdx + 5] = (uint16_t)v11; |
| } |
| } |
| |
| QuadGrid::~QuadGrid(void) |
| { |
| } |
| |
| inline Vec4 QuadGrid::getCoords(float sx, float sy) const |
| { |
| float fx = 2.0f * sx - 1.0f; |
| float fy = 2.0f * sy - 1.0f; |
| return Vec4(fx, fy, -fx + 0.33f * fy, -0.275f * fx - fy); |
| } |
| |
| inline Vec4 QuadGrid::getUnitCoords(float sx, float sy) const |
| { |
| return Vec4(sx, sy, 0.33f * sx + 0.5f * sy, 0.5f * sx + 0.25f * sy); |
| } |
| |
| inline Vec4 QuadGrid::getUserAttrib(int attribNdx, float sx, float sy) const |
| { |
| // homogeneous normalized screen-space coordinates |
| return m_userAttribTransforms[attribNdx] * Vec4(sx, sy, 0.0f, 1.0f); |
| } |
| |
| // ShaderEvalContext. |
| |
| ShaderEvalContext::ShaderEvalContext(const QuadGrid &quadGrid_) |
| : constCoords(quadGrid_.getConstCoords()) |
| , isDiscarded(false) |
| , quadGrid(quadGrid_) |
| { |
| const vector<TextureBinding> &bindings = quadGrid.getTextures(); |
| DE_ASSERT((int)bindings.size() <= MAX_TEXTURES); |
| |
| // Fill in texture array. |
| for (int ndx = 0; ndx < (int)bindings.size(); ndx++) |
| { |
| const TextureBinding &binding = bindings[ndx]; |
| |
| if (binding.getType() == TextureBinding::TYPE_NONE) |
| continue; |
| |
| textures[ndx].sampler = binding.getSampler(); |
| |
| switch (binding.getType()) |
| { |
| case TextureBinding::TYPE_2D: |
| textures[ndx].tex2D = &binding.get2D()->getRefTexture(); |
| break; |
| case TextureBinding::TYPE_CUBE_MAP: |
| textures[ndx].texCube = &binding.getCube()->getRefTexture(); |
| break; |
| case TextureBinding::TYPE_2D_ARRAY: |
| textures[ndx].tex2DArray = &binding.get2DArray()->getRefTexture(); |
| break; |
| case TextureBinding::TYPE_3D: |
| textures[ndx].tex3D = &binding.get3D()->getRefTexture(); |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| } |
| |
| ShaderEvalContext::~ShaderEvalContext(void) |
| { |
| } |
| |
| void ShaderEvalContext::reset(float sx, float sy) |
| { |
| // Clear old values |
| color = Vec4(0.0f, 0.0f, 0.0f, 1.0f); |
| isDiscarded = false; |
| |
| // Compute coords |
| coords = quadGrid.getCoords(sx, sy); |
| unitCoords = quadGrid.getUnitCoords(sx, sy); |
| |
| // Compute user attributes. |
| int numAttribs = quadGrid.getNumUserAttribs(); |
| DE_ASSERT(numAttribs <= MAX_USER_ATTRIBS); |
| for (int attribNdx = 0; attribNdx < numAttribs; attribNdx++) |
| in[attribNdx] = quadGrid.getUserAttrib(attribNdx, sx, sy); |
| } |
| |
| tcu::Vec4 ShaderEvalContext::texture2D(int unitNdx, const tcu::Vec2 &texCoords) |
| { |
| if (textures[unitNdx].tex2D) |
| return textures[unitNdx].tex2D->sample(textures[unitNdx].sampler, texCoords.x(), texCoords.y(), 0.0f); |
| else |
| return tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); |
| } |
| |
| // ShaderEvaluator |
| |
| ShaderEvaluator::ShaderEvaluator(void) : m_evalFunc(DE_NULL) |
| { |
| } |
| |
| ShaderEvaluator::ShaderEvaluator(ShaderEvalFunc evalFunc) : m_evalFunc(evalFunc) |
| { |
| } |
| |
| ShaderEvaluator::~ShaderEvaluator(void) |
| { |
| } |
| |
| void ShaderEvaluator::evaluate(ShaderEvalContext &ctx) |
| { |
| DE_ASSERT(m_evalFunc); |
| m_evalFunc(ctx); |
| } |
| |
| // ShaderRenderCase. |
| |
| ShaderRenderCase::ShaderRenderCase(TestContext &testCtx, RenderContext &renderCtx, const ContextInfo &ctxInfo, |
| const char *name, const char *description, bool isVertexCase, |
| ShaderEvalFunc evalFunc) |
| : TestCase(testCtx, name, description) |
| , m_renderCtx(renderCtx) |
| , m_ctxInfo(ctxInfo) |
| , m_isVertexCase(isVertexCase) |
| , m_defaultEvaluator(evalFunc) |
| , m_evaluator(m_defaultEvaluator) |
| , m_clearColor(DEFAULT_CLEAR_COLOR) |
| , m_program(DE_NULL) |
| { |
| } |
| |
| ShaderRenderCase::ShaderRenderCase(TestContext &testCtx, RenderContext &renderCtx, const ContextInfo &ctxInfo, |
| const char *name, const char *description, bool isVertexCase, |
| ShaderEvaluator &evaluator) |
| : TestCase(testCtx, name, description) |
| , m_renderCtx(renderCtx) |
| , m_ctxInfo(ctxInfo) |
| , m_isVertexCase(isVertexCase) |
| , m_defaultEvaluator(DE_NULL) |
| , m_evaluator(evaluator) |
| , m_clearColor(DEFAULT_CLEAR_COLOR) |
| , m_program(DE_NULL) |
| { |
| } |
| |
| ShaderRenderCase::~ShaderRenderCase(void) |
| { |
| ShaderRenderCase::deinit(); |
| } |
| |
| void ShaderRenderCase::init(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::init() begin"); |
| |
| if (m_vertShaderSource.empty() || m_fragShaderSource.empty()) |
| { |
| DE_ASSERT(m_vertShaderSource.empty() && m_fragShaderSource.empty()); |
| setupShaderData(); |
| } |
| |
| DE_ASSERT(!m_program); |
| m_program = new ShaderProgram(m_renderCtx, makeVtxFragSources(m_vertShaderSource, m_fragShaderSource)); |
| |
| try |
| { |
| log << *m_program; // Always log shader program. |
| |
| if (!m_program->isOk()) |
| throw CompileFailed(__FILE__, __LINE__); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::init() end"); |
| } |
| catch (const std::exception &) |
| { |
| // Clean up. |
| ShaderRenderCase::deinit(); |
| throw; |
| } |
| |
| m_gridSize = GRID_SIZE; |
| } |
| |
| void ShaderRenderCase::deinit(void) |
| { |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| tcu::IVec2 ShaderRenderCase::getViewportSize(void) const |
| { |
| return tcu::IVec2(de::min(m_renderCtx.getRenderTarget().getWidth(), MAX_RENDER_WIDTH), |
| de::min(m_renderCtx.getRenderTarget().getHeight(), MAX_RENDER_HEIGHT)); |
| } |
| |
| TestNode::IterateResult ShaderRenderCase::iterate(void) |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderRenderCase::iterate() begin"); |
| |
| DE_ASSERT(m_program); |
| uint32_t programID = m_program->getProgram(); |
| gl.useProgram(programID); |
| |
| // Create quad grid. |
| IVec2 viewportSize = getViewportSize(); |
| int width = viewportSize.x(); |
| int height = viewportSize.y(); |
| |
| // \todo [petri] Better handling of constCoords (render in multiple chunks, vary coords). |
| QuadGrid quadGrid(m_isVertexCase ? m_gridSize : 4, width, height, Vec4(0.125f, 0.25f, 0.5f, 1.0f), |
| m_userAttribTransforms, m_textures); |
| |
| // Render result. |
| Surface resImage(width, height); |
| render(resImage, programID, quadGrid); |
| |
| // Compute reference. |
| Surface refImage(width, height); |
| if (m_isVertexCase) |
| computeVertexReference(refImage, quadGrid); |
| else |
| computeFragmentReference(refImage, quadGrid); |
| |
| // Compare. |
| bool testOk = compareImages(resImage, refImage, 0.07f); |
| |
| // De-initialize. |
| gl.useProgram(0); |
| |
| m_testCtx.setTestResult(testOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, testOk ? "Pass" : "Fail"); |
| return TestNode::STOP; |
| } |
| |
| void ShaderRenderCase::setupShaderData(void) |
| { |
| } |
| |
| void ShaderRenderCase::setup(int programID) |
| { |
| DE_UNREF(programID); |
| } |
| |
| void ShaderRenderCase::setupUniforms(int programID, const Vec4 &constCoords) |
| { |
| DE_UNREF(programID); |
| DE_UNREF(constCoords); |
| } |
| |
| void ShaderRenderCase::setupDefaultInputs(int programID) |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| |
| // SETUP UNIFORMS. |
| |
| setupDefaultUniforms(m_renderCtx, programID); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "post uniform setup"); |
| |
| // SETUP TEXTURES. |
| |
| for (int ndx = 0; ndx < (int)m_textures.size(); ndx++) |
| { |
| const TextureBinding &tex = m_textures[ndx]; |
| const tcu::Sampler &sampler = tex.getSampler(); |
| uint32_t texTarget = GL_NONE; |
| uint32_t texObj = 0; |
| |
| if (tex.getType() == TextureBinding::TYPE_NONE) |
| continue; |
| |
| // Feature check. |
| if (m_renderCtx.getType().getAPI() == glu::ApiType::es(2, 0)) |
| { |
| if (tex.getType() == TextureBinding::TYPE_2D_ARRAY) |
| throw tcu::NotSupportedError("2D array texture binding is not supported"); |
| |
| if (tex.getType() == TextureBinding::TYPE_3D) |
| throw tcu::NotSupportedError("3D texture binding is not supported"); |
| |
| if (sampler.compare != tcu::Sampler::COMPAREMODE_NONE) |
| throw tcu::NotSupportedError("Shadow lookups are not supported"); |
| } |
| |
| switch (tex.getType()) |
| { |
| case TextureBinding::TYPE_2D: |
| texTarget = GL_TEXTURE_2D; |
| texObj = tex.get2D()->getGLTexture(); |
| break; |
| case TextureBinding::TYPE_CUBE_MAP: |
| texTarget = GL_TEXTURE_CUBE_MAP; |
| texObj = tex.getCube()->getGLTexture(); |
| break; |
| case TextureBinding::TYPE_2D_ARRAY: |
| texTarget = GL_TEXTURE_2D_ARRAY; |
| texObj = tex.get2DArray()->getGLTexture(); |
| break; |
| case TextureBinding::TYPE_3D: |
| texTarget = GL_TEXTURE_3D; |
| texObj = tex.get3D()->getGLTexture(); |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| |
| gl.activeTexture(GL_TEXTURE0 + ndx); |
| gl.bindTexture(texTarget, texObj); |
| gl.texParameteri(texTarget, GL_TEXTURE_WRAP_S, glu::getGLWrapMode(sampler.wrapS)); |
| gl.texParameteri(texTarget, GL_TEXTURE_WRAP_T, glu::getGLWrapMode(sampler.wrapT)); |
| gl.texParameteri(texTarget, GL_TEXTURE_MIN_FILTER, glu::getGLFilterMode(sampler.minFilter)); |
| gl.texParameteri(texTarget, GL_TEXTURE_MAG_FILTER, glu::getGLFilterMode(sampler.magFilter)); |
| |
| if (texTarget == GL_TEXTURE_3D) |
| gl.texParameteri(texTarget, GL_TEXTURE_WRAP_R, glu::getGLWrapMode(sampler.wrapR)); |
| |
| if (sampler.compare != tcu::Sampler::COMPAREMODE_NONE) |
| { |
| gl.texParameteri(texTarget, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); |
| gl.texParameteri(texTarget, GL_TEXTURE_COMPARE_FUNC, glu::getGLCompareFunc(sampler.compare)); |
| } |
| } |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "texture sampler setup"); |
| } |
| |
| static void getDefaultVertexArrays(const glw::Functions &gl, const QuadGrid &quadGrid, uint32_t program, |
| vector<VertexArrayBinding> &vertexArrays) |
| { |
| const int numElements = quadGrid.getNumVertices(); |
| |
| vertexArrays.push_back(va::Float("a_position", 4, numElements, 0, (const float *)quadGrid.getPositions())); |
| vertexArrays.push_back(va::Float("a_coords", 4, numElements, 0, (const float *)quadGrid.getCoords())); |
| vertexArrays.push_back(va::Float("a_unitCoords", 4, numElements, 0, (const float *)quadGrid.getUnitCoords())); |
| vertexArrays.push_back(va::Float("a_one", 1, numElements, 0, quadGrid.getAttribOne())); |
| |
| // a_inN. |
| for (int userNdx = 0; userNdx < quadGrid.getNumUserAttribs(); userNdx++) |
| { |
| string name = string("a_in") + de::toString(userNdx); |
| vertexArrays.push_back(va::Float(name, 4, numElements, 0, (const float *)quadGrid.getUserAttrib(userNdx))); |
| } |
| |
| // Matrix attributes - these are set by location |
| static const struct |
| { |
| const char *name; |
| int numCols; |
| int numRows; |
| } matrices[] = {{"a_mat2", 2, 2}, {"a_mat2x3", 2, 3}, {"a_mat2x4", 2, 4}, {"a_mat3x2", 3, 2}, {"a_mat3", 3, 3}, |
| {"a_mat3x4", 3, 4}, {"a_mat4x2", 4, 2}, {"a_mat4x3", 4, 3}, {"a_mat4", 4, 4}}; |
| |
| for (int matNdx = 0; matNdx < DE_LENGTH_OF_ARRAY(matrices); matNdx++) |
| { |
| int loc = gl.getAttribLocation(program, matrices[matNdx].name); |
| |
| if (loc < 0) |
| continue; // Not used in shader. |
| |
| int numRows = matrices[matNdx].numRows; |
| int numCols = matrices[matNdx].numCols; |
| |
| for (int colNdx = 0; colNdx < numCols; colNdx++) |
| vertexArrays.push_back(va::Float(loc + colNdx, numRows, numElements, 4 * (int)sizeof(float), |
| (const float *)quadGrid.getUserAttrib(colNdx))); |
| } |
| } |
| |
| void ShaderRenderCase::render(Surface &result, int programID, const QuadGrid &quadGrid) |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "pre render"); |
| |
| // Buffer info. |
| int width = result.getWidth(); |
| int height = result.getHeight(); |
| |
| int xOffsetMax = m_renderCtx.getRenderTarget().getWidth() - width; |
| int yOffsetMax = m_renderCtx.getRenderTarget().getHeight() - height; |
| |
| uint32_t hash = deStringHash(m_vertShaderSource.c_str()) + deStringHash(m_fragShaderSource.c_str()); |
| de::Random rnd(hash); |
| |
| int xOffset = rnd.getInt(0, xOffsetMax); |
| int yOffset = rnd.getInt(0, yOffsetMax); |
| |
| gl.viewport(xOffset, yOffset, width, height); |
| |
| // Setup program. |
| setupUniforms(programID, quadGrid.getConstCoords()); |
| setupDefaultInputs(programID); |
| |
| // Clear. |
| gl.clearColor(m_clearColor.x(), m_clearColor.y(), m_clearColor.z(), m_clearColor.w()); |
| gl.clear(GL_COLOR_BUFFER_BIT); |
| |
| // Draw. |
| { |
| std::vector<VertexArrayBinding> vertexArrays; |
| const int numElements = quadGrid.getNumTriangles() * 3; |
| |
| getDefaultVertexArrays(gl, quadGrid, programID, vertexArrays); |
| draw(m_renderCtx, programID, (int)vertexArrays.size(), &vertexArrays[0], |
| pr::Triangles(numElements, quadGrid.getIndices())); |
| } |
| GLU_EXPECT_NO_ERROR(gl.getError(), "draw"); |
| |
| // Read back results. |
| glu::readPixels(m_renderCtx, xOffset, yOffset, result.getAccess()); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "post render"); |
| } |
| |
| void ShaderRenderCase::computeVertexReference(Surface &result, const QuadGrid &quadGrid) |
| { |
| // Buffer info. |
| int width = result.getWidth(); |
| int height = result.getHeight(); |
| int gridSize = quadGrid.getGridSize(); |
| int stride = gridSize + 1; |
| bool hasAlpha = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0; |
| ShaderEvalContext evalCtx(quadGrid); |
| |
| // Evaluate color for each vertex. |
| vector<Vec4> colors((gridSize + 1) * (gridSize + 1)); |
| for (int y = 0; y < gridSize + 1; y++) |
| for (int x = 0; x < gridSize + 1; x++) |
| { |
| float sx = (float)x / (float)gridSize; |
| float sy = (float)y / (float)gridSize; |
| int vtxNdx = ((y * (gridSize + 1)) + x); |
| |
| evalCtx.reset(sx, sy); |
| m_evaluator.evaluate(evalCtx); |
| DE_ASSERT(!evalCtx.isDiscarded); // Discard is not available in vertex shader. |
| Vec4 color = evalCtx.color; |
| |
| if (!hasAlpha) |
| color.w() = 1.0f; |
| |
| colors[vtxNdx] = color; |
| } |
| |
| // Render quads. |
| for (int y = 0; y < gridSize; y++) |
| for (int x = 0; x < gridSize; x++) |
| { |
| float x0 = (float)x / (float)gridSize; |
| float x1 = (float)(x + 1) / (float)gridSize; |
| float y0 = (float)y / (float)gridSize; |
| float y1 = (float)(y + 1) / (float)gridSize; |
| |
| float sx0 = x0 * (float)width; |
| float sx1 = x1 * (float)width; |
| float sy0 = y0 * (float)height; |
| float sy1 = y1 * (float)height; |
| float oosx = 1.0f / (sx1 - sx0); |
| float oosy = 1.0f / (sy1 - sy0); |
| |
| int ix0 = deCeilFloatToInt32(sx0 - 0.5f); |
| int ix1 = deCeilFloatToInt32(sx1 - 0.5f); |
| int iy0 = deCeilFloatToInt32(sy0 - 0.5f); |
| int iy1 = deCeilFloatToInt32(sy1 - 0.5f); |
| |
| int v00 = (y * stride) + x; |
| int v01 = (y * stride) + x + 1; |
| int v10 = ((y + 1) * stride) + x; |
| int v11 = ((y + 1) * stride) + x + 1; |
| Vec4 c00 = colors[v00]; |
| Vec4 c01 = colors[v01]; |
| Vec4 c10 = colors[v10]; |
| Vec4 c11 = colors[v11]; |
| |
| //printf("(%d,%d) -> (%f..%f, %f..%f) (%d..%d, %d..%d)\n", x, y, sx0, sx1, sy0, sy1, ix0, ix1, iy0, iy1); |
| |
| for (int iy = iy0; iy < iy1; iy++) |
| for (int ix = ix0; ix < ix1; ix++) |
| { |
| DE_ASSERT(deInBounds32(ix, 0, width)); |
| DE_ASSERT(deInBounds32(iy, 0, height)); |
| |
| float sfx = (float)ix + 0.5f; |
| float sfy = (float)iy + 0.5f; |
| float fx1 = deFloatClamp((sfx - sx0) * oosx, 0.0f, 1.0f); |
| float fy1 = deFloatClamp((sfy - sy0) * oosy, 0.0f, 1.0f); |
| |
| // Triangle quad interpolation. |
| bool tri = fx1 + fy1 <= 1.0f; |
| float tx = tri ? fx1 : (1.0f - fx1); |
| float ty = tri ? fy1 : (1.0f - fy1); |
| const Vec4 &t0 = tri ? c00 : c11; |
| const Vec4 &t1 = tri ? c01 : c10; |
| const Vec4 &t2 = tri ? c10 : c01; |
| Vec4 color = t0 + (t1 - t0) * tx + (t2 - t0) * ty; |
| |
| result.setPixel(ix, iy, tcu::RGBA(color)); |
| } |
| } |
| } |
| |
| void ShaderRenderCase::computeFragmentReference(Surface &result, const QuadGrid &quadGrid) |
| { |
| // Buffer info. |
| int width = result.getWidth(); |
| int height = result.getHeight(); |
| bool hasAlpha = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0; |
| ShaderEvalContext evalCtx(quadGrid); |
| |
| // Render. |
| for (int y = 0; y < height; y++) |
| for (int x = 0; x < width; x++) |
| { |
| float sx = ((float)x + 0.5f) / (float)width; |
| float sy = ((float)y + 0.5f) / (float)height; |
| |
| evalCtx.reset(sx, sy); |
| m_evaluator.evaluate(evalCtx); |
| // Select either clear color or computed color based on discarded bit. |
| Vec4 color = evalCtx.isDiscarded ? m_clearColor : evalCtx.color; |
| |
| if (!hasAlpha) |
| color.w() = 1.0f; |
| |
| result.setPixel(x, y, tcu::RGBA(color)); |
| } |
| } |
| |
| bool ShaderRenderCase::compareImages(const Surface &resImage, const Surface &refImage, float errorThreshold) |
| { |
| return tcu::fuzzyCompare(m_testCtx.getLog(), "ComparisonResult", "Image comparison result", refImage, resImage, |
| errorThreshold, tcu::COMPARE_LOG_RESULT); |
| } |
| |
| // Uniform name helpers. |
| |
| const char *getIntUniformName(int number) |
| { |
| switch (number) |
| { |
| case 0: |
| return "ui_zero"; |
| case 1: |
| return "ui_one"; |
| case 2: |
| return "ui_two"; |
| case 3: |
| return "ui_three"; |
| case 4: |
| return "ui_four"; |
| case 5: |
| return "ui_five"; |
| case 6: |
| return "ui_six"; |
| case 7: |
| return "ui_seven"; |
| case 8: |
| return "ui_eight"; |
| case 101: |
| return "ui_oneHundredOne"; |
| default: |
| DE_ASSERT(false); |
| return ""; |
| } |
| } |
| |
| const char *getFloatUniformName(int number) |
| { |
| switch (number) |
| { |
| case 0: |
| return "uf_zero"; |
| case 1: |
| return "uf_one"; |
| case 2: |
| return "uf_two"; |
| case 3: |
| return "uf_three"; |
| case 4: |
| return "uf_four"; |
| case 5: |
| return "uf_five"; |
| case 6: |
| return "uf_six"; |
| case 7: |
| return "uf_seven"; |
| case 8: |
| return "uf_eight"; |
| default: |
| DE_ASSERT(false); |
| return ""; |
| } |
| } |
| |
| const char *getFloatFractionUniformName(int number) |
| { |
| switch (number) |
| { |
| case 1: |
| return "uf_one"; |
| case 2: |
| return "uf_half"; |
| case 3: |
| return "uf_third"; |
| case 4: |
| return "uf_fourth"; |
| case 5: |
| return "uf_fifth"; |
| case 6: |
| return "uf_sixth"; |
| case 7: |
| return "uf_seventh"; |
| case 8: |
| return "uf_eighth"; |
| default: |
| DE_ASSERT(false); |
| return ""; |
| } |
| } |
| |
| void setupDefaultUniforms(const glu::RenderContext &context, uint32_t programID) |
| { |
| const glw::Functions &gl = context.getFunctions(); |
| |
| // Bool. |
| struct BoolUniform |
| { |
| const char *name; |
| bool value; |
| }; |
| static const BoolUniform s_boolUniforms[] = { |
| {"ub_true", true}, |
| {"ub_false", false}, |
| }; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_boolUniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_boolUniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform1i(uniLoc, s_boolUniforms[i].value); |
| } |
| |
| // BVec4. |
| struct BVec4Uniform |
| { |
| const char *name; |
| BVec4 value; |
| }; |
| static const BVec4Uniform s_bvec4Uniforms[] = { |
| {"ub4_true", BVec4(true)}, |
| {"ub4_false", BVec4(false)}, |
| }; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_bvec4Uniforms); i++) |
| { |
| const BVec4Uniform &uni = s_bvec4Uniforms[i]; |
| int arr[4]; |
| arr[0] = (int)uni.value.x(); |
| arr[1] = (int)uni.value.y(); |
| arr[2] = (int)uni.value.z(); |
| arr[3] = (int)uni.value.w(); |
| int uniLoc = gl.getUniformLocation(programID, uni.name); |
| if (uniLoc != -1) |
| gl.uniform4iv(uniLoc, 1, &arr[0]); |
| } |
| |
| // Int. |
| struct IntUniform |
| { |
| const char *name; |
| int value; |
| }; |
| static const IntUniform s_intUniforms[] = { |
| {"ui_minusOne", -1}, {"ui_zero", 0}, {"ui_one", 1}, {"ui_two", 2}, {"ui_three", 3}, {"ui_four", 4}, |
| {"ui_five", 5}, {"ui_six", 6}, {"ui_seven", 7}, {"ui_eight", 8}, {"ui_oneHundredOne", 101}}; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_intUniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_intUniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform1i(uniLoc, s_intUniforms[i].value); |
| } |
| |
| // IVec2. |
| struct IVec2Uniform |
| { |
| const char *name; |
| IVec2 value; |
| }; |
| static const IVec2Uniform s_ivec2Uniforms[] = {{"ui2_minusOne", IVec2(-1)}, {"ui2_zero", IVec2(0)}, |
| {"ui2_one", IVec2(1)}, {"ui2_two", IVec2(2)}, |
| {"ui2_four", IVec2(4)}, {"ui2_five", IVec2(5)}}; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec2Uniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_ivec2Uniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform2iv(uniLoc, 1, s_ivec2Uniforms[i].value.getPtr()); |
| } |
| |
| // IVec3. |
| struct IVec3Uniform |
| { |
| const char *name; |
| IVec3 value; |
| }; |
| static const IVec3Uniform s_ivec3Uniforms[] = {{"ui3_minusOne", IVec3(-1)}, {"ui3_zero", IVec3(0)}, |
| {"ui3_one", IVec3(1)}, {"ui3_two", IVec3(2)}, |
| {"ui3_four", IVec3(4)}, {"ui3_five", IVec3(5)}}; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec3Uniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_ivec3Uniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform3iv(uniLoc, 1, s_ivec3Uniforms[i].value.getPtr()); |
| } |
| |
| // IVec4. |
| struct IVec4Uniform |
| { |
| const char *name; |
| IVec4 value; |
| }; |
| static const IVec4Uniform s_ivec4Uniforms[] = {{"ui4_minusOne", IVec4(-1)}, {"ui4_zero", IVec4(0)}, |
| {"ui4_one", IVec4(1)}, {"ui4_two", IVec4(2)}, |
| {"ui4_four", IVec4(4)}, {"ui4_five", IVec4(5)}}; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_ivec4Uniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_ivec4Uniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform4iv(uniLoc, 1, s_ivec4Uniforms[i].value.getPtr()); |
| } |
| |
| // Float. |
| struct FloatUniform |
| { |
| const char *name; |
| float value; |
| }; |
| static const FloatUniform s_floatUniforms[] = { |
| {"uf_zero", 0.0f}, {"uf_one", 1.0f}, {"uf_two", 2.0f}, |
| {"uf_three", 3.0f}, {"uf_four", 4.0f}, {"uf_five", 5.0f}, |
| {"uf_six", 6.0f}, {"uf_seven", 7.0f}, {"uf_eight", 8.0f}, |
| {"uf_half", 1.0f / 2.0f}, {"uf_third", 1.0f / 3.0f}, {"uf_fourth", 1.0f / 4.0f}, |
| {"uf_fifth", 1.0f / 5.0f}, {"uf_sixth", 1.0f / 6.0f}, {"uf_seventh", 1.0f / 7.0f}, |
| {"uf_eighth", 1.0f / 8.0f}}; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_floatUniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_floatUniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform1f(uniLoc, s_floatUniforms[i].value); |
| } |
| |
| // Vec2. |
| struct Vec2Uniform |
| { |
| const char *name; |
| Vec2 value; |
| }; |
| static const Vec2Uniform s_vec2Uniforms[] = { |
| {"uv2_minusOne", Vec2(-1.0f)}, {"uv2_zero", Vec2(0.0f)}, {"uv2_half", Vec2(0.5f)}, |
| {"uv2_one", Vec2(1.0f)}, {"uv2_two", Vec2(2.0f)}, |
| }; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec2Uniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_vec2Uniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform2fv(uniLoc, 1, s_vec2Uniforms[i].value.getPtr()); |
| } |
| |
| // Vec3. |
| struct Vec3Uniform |
| { |
| const char *name; |
| Vec3 value; |
| }; |
| static const Vec3Uniform s_vec3Uniforms[] = { |
| {"uv3_minusOne", Vec3(-1.0f)}, {"uv3_zero", Vec3(0.0f)}, {"uv3_half", Vec3(0.5f)}, |
| {"uv3_one", Vec3(1.0f)}, {"uv3_two", Vec3(2.0f)}, |
| }; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec3Uniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_vec3Uniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform3fv(uniLoc, 1, s_vec3Uniforms[i].value.getPtr()); |
| } |
| |
| // Vec4. |
| struct Vec4Uniform |
| { |
| const char *name; |
| Vec4 value; |
| }; |
| static const Vec4Uniform s_vec4Uniforms[] = { |
| {"uv4_minusOne", Vec4(-1.0f)}, |
| {"uv4_zero", Vec4(0.0f)}, |
| {"uv4_half", Vec4(0.5f)}, |
| {"uv4_one", Vec4(1.0f)}, |
| {"uv4_two", Vec4(2.0f)}, |
| {"uv4_black", Vec4(0.0f, 0.0f, 0.0f, 1.0f)}, |
| {"uv4_gray", Vec4(0.5f, 0.5f, 0.5f, 1.0f)}, |
| {"uv4_white", Vec4(1.0f, 1.0f, 1.0f, 1.0f)}, |
| }; |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_vec4Uniforms); i++) |
| { |
| int uniLoc = gl.getUniformLocation(programID, s_vec4Uniforms[i].name); |
| if (uniLoc != -1) |
| gl.uniform4fv(uniLoc, 1, s_vec4Uniforms[i].value.getPtr()); |
| } |
| } |
| |
| } // namespace gls |
| } // namespace deqp |