blob: 7fcff4bad26f37627c348b7cb322bb6467bdb055 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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