/*-------------------------------------------------------------------------
* 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 Random shader test case.
*//*--------------------------------------------------------------------*/
#include "glsRandomShaderCase.hpp"
#include "gluShaderProgram.hpp"
#include "gluPixelTransfer.hpp"
#include "gluTextureUtil.hpp"
#include "gluStrUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuTestLog.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"
#include "rsgProgramGenerator.hpp"
#include "rsgProgramExecutor.hpp"
#include "rsgUtils.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuRenderTarget.hpp"
#include "glw.h"
#include "glwFunctions.hpp"
using std::vector;
using std::string;
using std::pair;
using std::map;
namespace deqp
{
namespace gls
{
enum
{
VIEWPORT_WIDTH = 64,
VIEWPORT_HEIGHT = 64,
TEXTURE_2D_WIDTH = 64,
TEXTURE_2D_HEIGHT = 64,
TEXTURE_2D_FORMAT = GL_RGBA,
TEXTURE_2D_DATA_TYPE = GL_UNSIGNED_BYTE,
TEXTURE_CUBE_SIZE = 16,
TEXTURE_CUBE_FORMAT = GL_RGBA,
TEXTURE_CUBE_DATA_TYPE = GL_UNSIGNED_BYTE,
TEXTURE_WRAP_S = GL_CLAMP_TO_EDGE,
TEXTURE_WRAP_T = GL_CLAMP_TO_EDGE,
TEXTURE_MIN_FILTER = GL_LINEAR,
TEXTURE_MAG_FILTER = GL_LINEAR
};
VertexArray::VertexArray (const rsg::ShaderInput* input, int numVertices)
: m_input (input)
, m_vertices (input->getVariable()->getType().getNumElements() * numVertices)
{
}
TextureManager::TextureManager (void)
{
}
TextureManager::~TextureManager (void)
{
}
void TextureManager::bindTexture (int unit, const glu::Texture2D* tex2D)
{
m_tex2D[unit] = tex2D;
}
void TextureManager::bindTexture (int unit, const glu::TextureCube* texCube)
{
m_texCube[unit] = texCube;
}
inline vector<pair<int, const glu::Texture2D*> > TextureManager::getBindings2D (void) const
{
vector<pair<int, const glu::Texture2D*> > bindings;
for (map<int, const glu::Texture2D*>::const_iterator i = m_tex2D.begin(); i != m_tex2D.end(); i++)
bindings.push_back(*i);
return bindings;
}
inline vector<pair<int, const glu::TextureCube*> > TextureManager::getBindingsCube (void) const
{
vector<pair<int, const glu::TextureCube*> > bindings;
for (map<int, const glu::TextureCube*>::const_iterator i = m_texCube.begin(); i != m_texCube.end(); i++)
bindings.push_back(*i);
return bindings;
}
RandomShaderCase::RandomShaderCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, const rsg::ProgramParameters& params)
: tcu::TestCase (testCtx, name, description)
, m_renderCtx (renderCtx)
, m_parameters (params)
, m_gridWidth (1)
, m_gridHeight (1)
, m_vertexShader (rsg::Shader::TYPE_VERTEX)
, m_fragmentShader (rsg::Shader::TYPE_FRAGMENT)
, m_tex2D (DE_NULL)
, m_texCube (DE_NULL)
{
}
RandomShaderCase::~RandomShaderCase (void)
{
delete m_tex2D;
delete m_texCube;
}
void RandomShaderCase::init (void)
{
// Generate shaders
rsg::ProgramGenerator programGenerator;
programGenerator.generate(m_parameters, m_vertexShader, m_fragmentShader);
checkShaderLimits(m_vertexShader);
checkShaderLimits(m_fragmentShader);
checkProgramLimits(m_vertexShader, m_fragmentShader);
// Compute uniform values
std::vector<const rsg::ShaderInput*> unifiedUniforms;
de::Random rnd(m_parameters.seed);
rsg::computeUnifiedUniforms(m_vertexShader, m_fragmentShader, unifiedUniforms);
rsg::computeUniformValues(rnd, m_uniforms, unifiedUniforms);
// Generate vertices
const vector<rsg::ShaderInput*>& inputs = m_vertexShader.getInputs();
int numVertices = (m_gridWidth+1)*(m_gridHeight+1);
for (vector<rsg::ShaderInput*>::const_iterator i = inputs.begin(); i != inputs.end(); i++)
{
const rsg::ShaderInput* input = *i;
rsg::ConstValueRangeAccess valueRange = input->getValueRange();
int numComponents = input->getVariable()->getType().getNumElements();
VertexArray vtxArray(input, numVertices);
bool isPosition = string(input->getVariable()->getName()) == "dEQP_Position";
TCU_CHECK(input->getVariable()->getType().getBaseType() == rsg::VariableType::TYPE_FLOAT);
for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx++)
{
int y = vtxNdx / (m_gridWidth+1);
int x = vtxNdx - y*(m_gridWidth+1);
float xf = (float)x / (float)m_gridWidth;
float yf = (float)y / (float)m_gridHeight;
float* dst = &vtxArray.getVertices()[vtxNdx*numComponents];
if (isPosition)
{
// Position attribute gets special interpolation handling.
DE_ASSERT(numComponents == 4);
dst[0] = -1.0f + xf * 2.0f;
dst[1] = 1.0f + yf * -2.0f;
dst[2] = 0.0f;
dst[3] = 1.0f;
}
else
{
for (int compNdx = 0; compNdx < numComponents; compNdx++)
{
float minVal = valueRange.getMin().component(compNdx).asFloat();
float maxVal = valueRange.getMax().component(compNdx).asFloat();
float xd, yd;
rsg::getVertexInterpolationCoords(xd, yd, xf, yf, compNdx);
float f = (xd+yd) / 2.0f;
dst[compNdx] = minVal + f * (maxVal-minVal);
}
}
}
m_vertexArrays.push_back(vtxArray);
}
// Generate indices
int numQuads = m_gridWidth*m_gridHeight;
int numIndices = numQuads*6;
m_indices.resize(numIndices);
for (int quadNdx = 0; quadNdx < numQuads; quadNdx++)
{
int quadY = quadNdx / (m_gridWidth);
int quadX = quadNdx - quadY*m_gridWidth;
m_indices[quadNdx*6+0] = quadX + quadY*(m_gridWidth+1);
m_indices[quadNdx*6+1] = quadX + (quadY+1)*(m_gridWidth+1);
m_indices[quadNdx*6+2] = quadX + quadY*(m_gridWidth+1) + 1;
m_indices[quadNdx*6+3] = m_indices[quadNdx*6+2];
m_indices[quadNdx*6+4] = m_indices[quadNdx*6+1];
m_indices[quadNdx*6+5] = quadX + (quadY+1)*(m_gridWidth+1) + 1;
}
// Create textures.
for (vector<rsg::VariableValue>::const_iterator uniformIter = m_uniforms.begin(); uniformIter != m_uniforms.end(); uniformIter++)
{
const rsg::VariableType& type = uniformIter->getVariable()->getType();
if (!type.isSampler())
continue;
int unitNdx = uniformIter->getValue().asInt(0);
if (type == rsg::VariableType(rsg::VariableType::TYPE_SAMPLER_2D, 1))
m_texManager.bindTexture(unitNdx, getTex2D());
else if (type == rsg::VariableType(rsg::VariableType::TYPE_SAMPLER_CUBE, 1))
m_texManager.bindTexture(unitNdx, getTexCube());
else
DE_ASSERT(DE_FALSE);
}
}
static int getNumSamplerUniforms (const std::vector<rsg::ShaderInput*>& uniforms)
{
int numSamplers = 0;
for (std::vector<rsg::ShaderInput*>::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
if ((*it)->getVariable()->getType().isSampler())
++numSamplers;
}
return numSamplers;
}
void RandomShaderCase::checkShaderLimits (const rsg::Shader& shader) const
{
const int numRequiredSamplers = getNumSamplerUniforms(shader.getUniforms());
if (numRequiredSamplers > 0)
{
const GLenum pname = (shader.getType() == rsg::Shader::TYPE_VERTEX) ? (GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS) : (GL_MAX_TEXTURE_IMAGE_UNITS);
int numSupported = -1;
GLenum error;
m_renderCtx.getFunctions().getIntegerv(pname, &numSupported);
error = m_renderCtx.getFunctions().getError();
if (error != GL_NO_ERROR)
throw tcu::TestError("Limit query failed: " + de::toString(glu::getErrorStr(error)));
if (numSupported < numRequiredSamplers)
throw tcu::NotSupportedError("Shader requires " + de::toString(numRequiredSamplers) + " sampler(s). Implementation supports " + de::toString(numSupported));
}
}
void RandomShaderCase::checkProgramLimits (const rsg::Shader& vtxShader, const rsg::Shader& frgShader) const
{
const int numRequiredCombinedSamplers = getNumSamplerUniforms(vtxShader.getUniforms()) + getNumSamplerUniforms(frgShader.getUniforms());
if (numRequiredCombinedSamplers > 0)
{
int numSupported = -1;
GLenum error;
m_renderCtx.getFunctions().getIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numSupported);
error = m_renderCtx.getFunctions().getError();
if (error != GL_NO_ERROR)
throw tcu::TestError("Limit query failed: " + de::toString(glu::getErrorStr(error)));
if (numSupported < numRequiredCombinedSamplers)
throw tcu::NotSupportedError("Program requires " + de::toString(numRequiredCombinedSamplers) + " sampler(s). Implementation supports " + de::toString(numSupported));
}
}
const glu::Texture2D* RandomShaderCase::getTex2D (void)
{
if (!m_tex2D)
{
m_tex2D = new glu::Texture2D(m_renderCtx, TEXTURE_2D_FORMAT, TEXTURE_2D_DATA_TYPE, TEXTURE_2D_WIDTH, TEXTURE_2D_HEIGHT);
m_tex2D->getRefTexture().allocLevel(0);
tcu::fillWithComponentGradients(m_tex2D->getRefTexture().getLevel(0), tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f));
m_tex2D->upload();
// Setup parameters.
glBindTexture(GL_TEXTURE_2D, m_tex2D->getGLTexture());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, TEXTURE_WRAP_S);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, TEXTURE_WRAP_T);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, TEXTURE_MIN_FILTER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, TEXTURE_MAG_FILTER);
GLU_CHECK();
}
return m_tex2D;
}
const glu::TextureCube* RandomShaderCase::getTexCube (void)
{
if (!m_texCube)
{
m_texCube = new glu::TextureCube(m_renderCtx, TEXTURE_CUBE_FORMAT, TEXTURE_CUBE_DATA_TYPE, TEXTURE_CUBE_SIZE);
static const tcu::Vec4 gradients[tcu::CUBEFACE_LAST][2] =
{
{ tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative x
{ tcu::Vec4( 0.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive x
{ tcu::Vec4(-1.0f, 0.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative y
{ tcu::Vec4(-1.0f, -1.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive y
{ tcu::Vec4(-1.0f, -1.0f, -1.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f) }, // negative z
{ tcu::Vec4( 0.0f, 0.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) } // positive z
};
// Fill level 0.
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
{
m_texCube->getRefTexture().allocLevel((tcu::CubeFace)face, 0);
tcu::fillWithComponentGradients(m_texCube->getRefTexture().getLevelFace(0, (tcu::CubeFace)face), gradients[face][0], gradients[face][1]);
}
m_texCube->upload();
// Setup parameters.
glBindTexture(GL_TEXTURE_CUBE_MAP, m_texCube->getGLTexture());
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, TEXTURE_WRAP_S);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, TEXTURE_WRAP_T);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, TEXTURE_MIN_FILTER);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, TEXTURE_MAG_FILTER);
GLU_CHECK();
}
return m_texCube;
}
void RandomShaderCase::deinit (void)
{
delete m_tex2D;
delete m_texCube;
m_tex2D = DE_NULL;
m_texCube = DE_NULL;
// Free up memory
m_vertexArrays.clear();
m_indices.clear();
}
namespace
{
void setUniformValue (int location, rsg::ConstValueAccess value)
{
DE_STATIC_ASSERT(sizeof(rsg::Scalar) == sizeof(float));
DE_STATIC_ASSERT(sizeof(rsg::Scalar) == sizeof(int));
switch (value.getType().getBaseType())
{
case rsg::VariableType::TYPE_FLOAT:
switch (value.getType().getNumElements())
{
case 1: glUniform1fv(location, 1, (float*)value.value().getValuePtr()); break;
case 2: glUniform2fv(location, 1, (float*)value.value().getValuePtr()); break;
case 3: glUniform3fv(location, 1, (float*)value.value().getValuePtr()); break;
case 4: glUniform4fv(location, 1, (float*)value.value().getValuePtr()); break;
default: TCU_FAIL("Unsupported type"); break;
}
break;
case rsg::VariableType::TYPE_INT:
case rsg::VariableType::TYPE_BOOL:
case rsg::VariableType::TYPE_SAMPLER_2D:
case rsg::VariableType::TYPE_SAMPLER_CUBE:
switch (value.getType().getNumElements())
{
case 1: glUniform1iv(location, 1, (int*)value.value().getValuePtr()); break;
case 2: glUniform2iv(location, 1, (int*)value.value().getValuePtr()); break;
case 3: glUniform3iv(location, 1, (int*)value.value().getValuePtr()); break;
case 4: glUniform4iv(location, 1, (int*)value.value().getValuePtr()); break;
default: TCU_FAIL("Unsupported type"); break;
}
break;
default:
TCU_FAIL("Unsupported type");
}
}
tcu::MessageBuilder& operator<< (tcu::MessageBuilder& message, rsg::ConstValueAccess value)
{
const char* scalarType = DE_NULL;
const char* vecType = DE_NULL;
switch (value.getType().getBaseType())
{
case rsg::VariableType::TYPE_FLOAT: scalarType = "float"; vecType = "vec"; break;
case rsg::VariableType::TYPE_INT: scalarType = "int"; vecType = "ivec"; break;
case rsg::VariableType::TYPE_BOOL: scalarType = "bool"; vecType = "bvec"; break;
case rsg::VariableType::TYPE_SAMPLER_2D: scalarType = "sampler2D"; break;
case rsg::VariableType::TYPE_SAMPLER_CUBE: scalarType = "samplerCube"; break;
default:
TCU_FAIL("Unsupported type.");
}
int numElements = value.getType().getNumElements();
if (numElements == 1)
message << scalarType << "(";
else
message << vecType << numElements << "(";
for (int elementNdx = 0; elementNdx < numElements; elementNdx++)
{
if (elementNdx > 0)
message << ", ";
switch (value.getType().getBaseType())
{
case rsg::VariableType::TYPE_FLOAT: message << value.component(elementNdx).asFloat(); break;
case rsg::VariableType::TYPE_INT: message << value.component(elementNdx).asInt(); break;
case rsg::VariableType::TYPE_BOOL: message << (value.component(elementNdx).asBool() ? "true" : "false"); break;
case rsg::VariableType::TYPE_SAMPLER_2D: message << value.component(elementNdx).asInt(); break;
case rsg::VariableType::TYPE_SAMPLER_CUBE: message << value.component(elementNdx).asInt(); break;
default:
DE_ASSERT(DE_FALSE);
}
}
message << ")";
return message;
}
tcu::MessageBuilder& operator<< (tcu::MessageBuilder& message, rsg::ConstValueRangeAccess valueRange)
{
return message << valueRange.getMin() << " -> " << valueRange.getMax();
}
} // anonymous
RandomShaderCase::IterateResult RandomShaderCase::iterate (void)
{
tcu::TestLog& log = m_testCtx.getLog();
// Compile program
glu::ShaderProgram program(m_renderCtx, glu::makeVtxFragSources(m_vertexShader.getSource(), m_fragmentShader.getSource()));
log << program;
if (!program.isOk())
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to compile shader");
return STOP;
}
// Compute random viewport
de::Random rnd (m_parameters.seed);
int viewportWidth = de::min<int>(VIEWPORT_WIDTH, m_renderCtx.getRenderTarget().getWidth());
int viewportHeight = de::min<int>(VIEWPORT_HEIGHT, m_renderCtx.getRenderTarget().getHeight());
int viewportX = rnd.getInt(0, m_renderCtx.getRenderTarget().getWidth() - viewportWidth);
int viewportY = rnd.getInt(0, m_renderCtx.getRenderTarget().getHeight() - viewportHeight);
bool hasAlpha = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0;
tcu::TextureLevel rendered (tcu::TextureFormat(hasAlpha ? tcu::TextureFormat::RGBA : tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8), viewportWidth, viewportHeight);
tcu::TextureLevel reference (tcu::TextureFormat(hasAlpha ? tcu::TextureFormat::RGBA : tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8), viewportWidth, viewportHeight);
// Reference program executor.
rsg::ProgramExecutor executor (reference.getAccess(), m_gridWidth, m_gridHeight);
GLU_CHECK_CALL(glUseProgram(program.getProgram()));
// Set up attributes
for (vector<VertexArray>::const_iterator attribIter = m_vertexArrays.begin(); attribIter != m_vertexArrays.end(); attribIter++)
{
GLint location = glGetAttribLocation(program.getProgram(), attribIter->getName());
// Print to log.
log << tcu::TestLog::Message << "attribute[" << location << "]: " << attribIter->getName() << " = " << attribIter->getValueRange() << tcu::TestLog::EndMessage;
if (location >= 0)
{
glVertexAttribPointer(location, attribIter->getNumComponents(), GL_FLOAT, GL_FALSE, 0, &attribIter->getVertices()[0]);
glEnableVertexAttribArray(location);
}
}
GLU_CHECK_MSG("After attribute setup");
// Uniforms
for (vector<rsg::VariableValue>::const_iterator uniformIter = m_uniforms.begin(); uniformIter != m_uniforms.end(); uniformIter++)
{
GLint location = glGetUniformLocation(program.getProgram(), uniformIter->getVariable()->getName());
log << tcu::TestLog::Message << "uniform[" << location << "]: " << uniformIter->getVariable()->getName() << " = " << uniformIter->getValue() << tcu::TestLog::EndMessage;
if (location >= 0)
setUniformValue(location, uniformIter->getValue());
}
GLU_CHECK_MSG("After uniform setup");
// Textures
vector<pair<int, const glu::Texture2D*> > tex2DBindings = m_texManager.getBindings2D();
vector<pair<int, const glu::TextureCube*> > texCubeBindings = m_texManager.getBindingsCube();
for (vector<pair<int, const glu::Texture2D*> >::const_iterator i = tex2DBindings.begin(); i != tex2DBindings.end(); i++)
{
int unitNdx = i->first;
const glu::Texture2D* texture = i->second;
glActiveTexture(GL_TEXTURE0 + unitNdx);
glBindTexture(GL_TEXTURE_2D, texture->getGLTexture());
executor.setTexture(unitNdx, &texture->getRefTexture(), glu::mapGLSampler(TEXTURE_WRAP_S, TEXTURE_WRAP_T, TEXTURE_MIN_FILTER, TEXTURE_MAG_FILTER));
}
GLU_CHECK_MSG("After 2D texture setup");
for (vector<pair<int, const glu::TextureCube*> >::const_iterator i = texCubeBindings.begin(); i != texCubeBindings.end(); i++)
{
int unitNdx = i->first;
const glu::TextureCube* texture = i->second;
glActiveTexture(GL_TEXTURE0 + unitNdx);
glBindTexture(GL_TEXTURE_CUBE_MAP, texture->getGLTexture());
executor.setTexture(unitNdx, &texture->getRefTexture(), glu::mapGLSampler(TEXTURE_WRAP_S, TEXTURE_WRAP_T, TEXTURE_MIN_FILTER, TEXTURE_MAG_FILTER));
}
GLU_CHECK_MSG("After cubemap setup");
// Draw and read
glViewport(viewportX, viewportY, viewportWidth, viewportHeight);
glDrawElements(GL_TRIANGLES, (GLsizei)m_indices.size(), GL_UNSIGNED_SHORT, &m_indices[0]);
glFlush();
GLU_CHECK_MSG("Draw");
// Render reference while GPU is doing work
executor.execute(m_vertexShader, m_fragmentShader, m_uniforms);
if (rendered.getFormat().order != tcu::TextureFormat::RGBA || rendered.getFormat().type != tcu::TextureFormat::UNORM_INT8)
{
// Read as GL_RGBA8
tcu::TextureLevel readBuf(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), rendered.getWidth(), rendered.getHeight());
glu::readPixels(m_renderCtx, viewportX, viewportY, readBuf.getAccess());
GLU_CHECK_MSG("Read pixels");
tcu::copy(rendered, readBuf);
}
else
glu::readPixels(m_renderCtx, viewportX, viewportY, rendered.getAccess());
// Compare
{
float threshold = 0.02f;
bool imagesOk = tcu::fuzzyCompare(log, "Result", "Result images", reference.getAccess(), rendered.getAccess(), threshold, tcu::COMPARE_LOG_RESULT);
if (imagesOk)
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
}
return STOP;
}
} // gls
} // deqp