king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
v811_spc009/external/deqp/modules/gles3/functional/es3fFboTestUtil.cpp

1117 lines
40 KiB
Raw Blame History

/*-------------------------------------------------------------------------
* 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 FBO test utilities.
*//*--------------------------------------------------------------------*/
#include "es3fFboTestUtil.hpp"
#include "sglrContextUtil.hpp"
#include "sglrGLContext.hpp"
#include "sglrReferenceContext.hpp"
#include "gluTextureUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "deStringUtil.hpp"
#include "deMath.h"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include <limits>
namespace deqp
{
namespace gles3
{
namespace Functional
{
namespace FboTestUtil
{
using std::string;
using std::vector;
using tcu::Vec2;
using tcu::Vec3;
using tcu::Vec4;
using tcu::IVec2;
using tcu::IVec3;
using tcu::IVec4;
static rr::GenericVecType mapDataTypeToGenericVecType(glu::DataType type)
{
switch (type)
{
case glu::TYPE_FLOAT_VEC4: return rr::GENERICVECTYPE_FLOAT;
case glu::TYPE_INT_VEC4: return rr::GENERICVECTYPE_INT32;
case glu::TYPE_UINT_VEC4: return rr::GENERICVECTYPE_UINT32;
default:
DE_ASSERT(DE_FALSE);
return rr::GENERICVECTYPE_LAST;
}
}
template <typename T>
static tcu::Vector<T, 4> castVectorSaturate (const tcu::Vec4& in)
{
return tcu::Vector<T, 4>(((double)in.x() + 0.5 >= (double)std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : (((double)in.x() - 0.5 <= (double)std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.x()))),
((double)in.y() + 0.5 >= (double)std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : (((double)in.y() - 0.5 <= (double)std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.y()))),
((double)in.z() + 0.5 >= (double)std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : (((double)in.z() - 0.5 <= (double)std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.z()))),
((double)in.w() + 0.5 >= (double)std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : (((double)in.w() - 0.5 <= (double)std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.w()))));
}
FlatColorShader::FlatColorShader (glu::DataType outputType)
: ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(mapDataTypeToGenericVecType(outputType))
<< sglr::pdec::Uniform("u_color", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
"}\n")
<< sglr::pdec::FragmentSource(
string(
"#version 300 es\n"
"uniform highp vec4 u_color;\n"
"layout(location = 0) out highp ") + glu::getDataTypeName(outputType) + " o_color;\n"
"void main (void)\n"
"{\n"
" o_color = " + glu::getDataTypeName(outputType) + "(u_color);\n"
"}\n"))
, m_outputType(outputType)
{
}
void FlatColorShader::setColor (sglr::Context& context, deUint32 program, const tcu::Vec4& color)
{
deInt32 location = context.getUniformLocation(program, "u_color");
context.useProgram(program);
context.uniform4fv(location, 1, color.getPtr());
}
void FlatColorShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::VertexPacket& packet = *packets[packetNdx];
packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
}
}
void FlatColorShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const tcu::Vec4 color (m_uniforms[0].value.f4);
const tcu::IVec4 icolor = castVectorSaturate<deInt32>(color);
const tcu::UVec4 uicolor = castVectorSaturate<deUint32>(color);
DE_UNREF(packets);
if (m_outputType == glu::TYPE_FLOAT_VEC4)
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
}
else if (m_outputType == glu::TYPE_INT_VEC4)
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, icolor);
}
else if (m_outputType == glu::TYPE_UINT_VEC4)
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, uicolor);
}
else
DE_ASSERT(DE_FALSE);
}
GradientShader::GradientShader (glu::DataType outputType)
: ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(mapDataTypeToGenericVecType(outputType))
<< sglr::pdec::Uniform("u_gradientMin", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::Uniform("u_gradientMax", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in highp vec4 a_coord;\n"
"out highp vec4 v_coord;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_coord = a_coord;\n"
"}\n")
<< sglr::pdec::FragmentSource(
string(
"#version 300 es\n"
"in highp vec4 v_coord;\n"
"uniform highp vec4 u_gradientMin;\n"
"uniform highp vec4 u_gradientMax;\n"
"layout(location = 0) out highp ") + glu::getDataTypeName(outputType) + " o_color;\n"
"void main (void)\n"
"{\n"
" highp float x = v_coord.x;\n"
" highp float y = v_coord.y;\n"
" highp float f0 = (x + y) * 0.5;\n"
" highp float f1 = 0.5 + (x - y) * 0.5;\n"
" highp vec4 fv = vec4(f0, f1, 1.0f-f0, 1.0f-f1);\n"
" o_color = " + glu::getDataTypeName(outputType) + "(u_gradientMin + (u_gradientMax-u_gradientMin)*fv);\n"
"}\n"))
, m_outputType(outputType)
{
}
void GradientShader::setGradient (sglr::Context& ctx, deUint32 program, const tcu::Vec4& gradientMin, const tcu::Vec4& gradientMax)
{
ctx.useProgram(program);
ctx.uniform4fv(ctx.getUniformLocation(program, "u_gradientMin"), 1, gradientMin.getPtr());
ctx.uniform4fv(ctx.getUniformLocation(program, "u_gradientMax"), 1, gradientMax.getPtr());
}
void GradientShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::VertexPacket& packet = *packets[packetNdx];
packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx);
}
}
void GradientShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const tcu::Vec4 gradientMin(m_uniforms[0].value.f4);
const tcu::Vec4 gradientMax(m_uniforms[1].value.f4);
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 coord = rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx);
const float x = coord.x();
const float y = coord.y();
const float f0 = (x + y) * 0.5f;
const float f1 = 0.5f + (x - y) * 0.5f;
const tcu::Vec4 fv = Vec4(f0, f1, 1.0f-f0, 1.0f-f1);
const tcu::Vec4 color = gradientMin + (gradientMax-gradientMin) * fv;
const tcu::IVec4 icolor = castVectorSaturate<deInt32>(color);
const tcu::UVec4 uicolor = castVectorSaturate<deUint32>(color);
if (m_outputType == glu::TYPE_FLOAT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
else if (m_outputType == glu::TYPE_INT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, icolor);
else if (m_outputType == glu::TYPE_UINT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, uicolor);
else
DE_ASSERT(DE_FALSE);
}
}
static string genTexFragmentShader (const vector<glu::DataType>& samplerTypes, glu::DataType outputType)
{
const char* precision = "highp";
std::ostringstream src;
src << "#version 300 es\n"
<< "layout(location = 0) out highp " << glu::getDataTypeName(outputType) << " o_color0;\n";
src << "in highp vec2 v_coord;\n";
for (int samplerNdx = 0; samplerNdx < (int)samplerTypes.size(); samplerNdx++)
{
src << "uniform " << precision << " " << glu::getDataTypeName(samplerTypes[samplerNdx]) << " u_sampler" << samplerNdx << ";\n";
src << "uniform " << precision << " vec4 u_texScale" << samplerNdx << ";\n";
src << "uniform " << precision << " vec4 u_texBias" << samplerNdx << ";\n";
}
// Output scale & bias
src << "uniform " << precision << " vec4 u_outScale0;\n"
<< "uniform " << precision << " vec4 u_outBias0;\n";
src << "\n"
<< "void main (void)\n"
<< "{\n"
<< " " << precision << " vec4 out0 = vec4(0.0);\n";
// Texture input fetch and combine.
for (int inNdx = 0; inNdx < (int)samplerTypes.size(); inNdx++)
src << "\tout0 += vec4("
<< "texture(u_sampler" << inNdx << ", v_coord)) * u_texScale" << inNdx << " + u_texBias" << inNdx << ";\n";
// Write output.
src << " o_color0 = " << glu::getDataTypeName(outputType) << "(out0 * u_outScale0 + u_outBias0);\n";
src << "}\n";
return src.str();
}
static sglr::pdec::ShaderProgramDeclaration genTexture2DShaderDecl (const DataTypes& samplerTypes, glu::DataType outputType)
{
sglr::pdec::ShaderProgramDeclaration decl;
decl << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT);
decl << sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT);
decl << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT);
decl << sglr::pdec::FragmentOutput(mapDataTypeToGenericVecType(outputType));
decl << sglr::pdec::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in highp vec2 a_coord;\n"
"out highp vec2 v_coord;\n"
"void main(void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_coord = a_coord;\n"
"}\n");
decl << sglr::pdec::FragmentSource(genTexFragmentShader(samplerTypes.vec, outputType));
decl << sglr::pdec::Uniform("u_outScale0", glu::TYPE_FLOAT_VEC4);
decl << sglr::pdec::Uniform("u_outBias0", glu::TYPE_FLOAT_VEC4);
for (size_t ndx = 0; ndx < samplerTypes.vec.size(); ++ndx)
{
decl << sglr::pdec::Uniform(std::string("u_sampler") + de::toString(ndx), samplerTypes.vec[ndx]);
decl << sglr::pdec::Uniform(std::string("u_texScale") + de::toString(ndx), glu::TYPE_FLOAT_VEC4);
decl << sglr::pdec::Uniform(std::string("u_texBias") + de::toString(ndx), glu::TYPE_FLOAT_VEC4);
}
return decl;
}
Texture2DShader::Texture2DShader (const DataTypes& samplerTypes, glu::DataType outputType, const Vec4& outScale, const Vec4& outBias)
: sglr::ShaderProgram (genTexture2DShaderDecl(samplerTypes, outputType))
, m_outScale (outScale)
, m_outBias (outBias)
, m_outputType (outputType)
{
m_inputs.resize(samplerTypes.vec.size());
// Initialize units.
for (int ndx = 0; ndx < (int)m_inputs.size(); ndx++)
{
m_inputs[ndx].unitNdx = ndx;
m_inputs[ndx].scale = Vec4(1.0f);
m_inputs[ndx].bias = Vec4(0.0f);
}
}
void Texture2DShader::setUnit (int inputNdx, int unitNdx)
{
m_inputs[inputNdx].unitNdx = unitNdx;
}
void Texture2DShader::setTexScaleBias (int inputNdx, const Vec4& scale, const Vec4& bias)
{
m_inputs[inputNdx].scale = scale;
m_inputs[inputNdx].bias = bias;
}
void Texture2DShader::setOutScaleBias (const Vec4& scale, const Vec4& bias)
{
m_outScale = scale;
m_outBias = bias;
}
void Texture2DShader::setUniforms (sglr::Context& gl, deUint32 program) const
{
gl.useProgram(program);
for (int texNdx = 0; texNdx < (int)m_inputs.size(); texNdx++)
{
string samplerName = string("u_sampler") + de::toString(texNdx);
string scaleName = string("u_texScale") + de::toString(texNdx);
string biasName = string("u_texBias") + de::toString(texNdx);
gl.uniform1i(gl.getUniformLocation(program, samplerName.c_str()), m_inputs[texNdx].unitNdx);
gl.uniform4fv(gl.getUniformLocation(program, scaleName.c_str()), 1, m_inputs[texNdx].scale.getPtr());
gl.uniform4fv(gl.getUniformLocation(program, biasName.c_str()), 1, m_inputs[texNdx].bias.getPtr());
}
gl.uniform4fv(gl.getUniformLocation(program, "u_outScale0"), 1, m_outScale.getPtr());
gl.uniform4fv(gl.getUniformLocation(program, "u_outBias0"), 1, m_outBias.getPtr());
}
void Texture2DShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::VertexPacket& packet = *packets[packetNdx];
packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx);
}
}
void Texture2DShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const tcu::Vec4 outScale (m_uniforms[0].value.f4);
const tcu::Vec4 outBias (m_uniforms[1].value.f4);
tcu::Vec2 texCoords[4];
tcu::Vec4 colors[4];
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
// setup tex coords
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 coord = rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx);
texCoords[fragNdx] = tcu::Vec2(coord.x(), coord.y());
}
// clear result
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
colors[fragNdx] = tcu::Vec4(0.0f);
// sample each texture
for (int ndx = 0; ndx < (int)m_inputs.size(); ndx++)
{
const sglr::rc::Texture2D* tex = m_uniforms[2 + ndx*3].sampler.tex2D;
const tcu::Vec4 scale (m_uniforms[2 + ndx*3 + 1].value.f4);
const tcu::Vec4 bias (m_uniforms[2 + ndx*3 + 2].value.f4);
tcu::Vec4 tmpColors[4];
tex->sample4(tmpColors, texCoords);
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
colors[fragNdx] += tmpColors[fragNdx] * scale + bias;
}
// write out
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 color = colors[fragNdx] * outScale + outBias;
const tcu::IVec4 icolor = castVectorSaturate<deInt32>(color);
const tcu::UVec4 uicolor = castVectorSaturate<deUint32>(color);
if (m_outputType == glu::TYPE_FLOAT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
else if (m_outputType == glu::TYPE_INT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, icolor);
else if (m_outputType == glu::TYPE_UINT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, uicolor);
else
DE_ASSERT(DE_FALSE);
}
}
}
TextureCubeShader::TextureCubeShader (glu::DataType samplerType, glu::DataType outputType)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(mapDataTypeToGenericVecType(outputType))
<< sglr::pdec::Uniform("u_coordMat", glu::TYPE_FLOAT_MAT3)
<< sglr::pdec::Uniform("u_sampler0", samplerType)
<< sglr::pdec::Uniform("u_scale", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::Uniform("u_bias", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in mediump vec2 a_coord;\n"
"uniform mat3 u_coordMat;\n"
"out mediump vec3 v_coord;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_coord = u_coordMat * vec3(a_coord, 1.0);\n"
"}\n")
<< sglr::pdec::FragmentSource(
string("") +
"#version 300 es\n"
"uniform highp " + glu::getDataTypeName(samplerType) + " u_sampler0;\n"
"uniform highp vec4 u_scale;\n"
"uniform highp vec4 u_bias;\n"
"in mediump vec3 v_coord;\n"
"layout(location = 0) out highp " + glu::getDataTypeName(outputType) + " o_color;\n"
"void main (void)\n"
"{\n"
" o_color = " + glu::getDataTypeName(outputType) + "(vec4(texture(u_sampler0, v_coord)) * u_scale + u_bias);\n"
"}\n"))
, m_texScale (1.0f)
, m_texBias (0.0f)
, m_outputType (outputType)
{
}
void TextureCubeShader::setFace (tcu::CubeFace face)
{
static const float s_cubeTransforms[][3*3] =
{
// Face -X: (x, y, 1) -> (-1, -(2*y-1), +(2*x-1))
{ 0.0f, 0.0f, -1.0f,
0.0f, -2.0f, 1.0f,
2.0f, 0.0f, -1.0f },
// Face +X: (x, y, 1) -> (+1, -(2*y-1), -(2*x-1))
{ 0.0f, 0.0f, 1.0f,
0.0f, -2.0f, 1.0f,
-2.0f, 0.0f, 1.0f },
// Face -Y: (x, y, 1) -> (+(2*x-1), -1, -(2*y-1))
{ 2.0f, 0.0f, -1.0f,
0.0f, 0.0f, -1.0f,
0.0f, -2.0f, 1.0f },
// Face +Y: (x, y, 1) -> (+(2*x-1), +1, +(2*y-1))
{ 2.0f, 0.0f, -1.0f,
0.0f, 0.0f, 1.0f,
0.0f, 2.0f, -1.0f },
// Face -Z: (x, y, 1) -> (-(2*x-1), -(2*y-1), -1)
{ -2.0f, 0.0f, 1.0f,
0.0f, -2.0f, 1.0f,
0.0f, 0.0f, -1.0f },
// Face +Z: (x, y, 1) -> (+(2*x-1), -(2*y-1), +1)
{ 2.0f, 0.0f, -1.0f,
0.0f, -2.0f, 1.0f,
0.0f, 0.0f, 1.0f }
};
DE_ASSERT(de::inBounds<int>(face, 0, tcu::CUBEFACE_LAST));
m_coordMat = tcu::Mat3(s_cubeTransforms[face]);
}
void TextureCubeShader::setTexScaleBias (const Vec4& scale, const Vec4& bias)
{
m_texScale = scale;
m_texBias = bias;
}
void TextureCubeShader::setUniforms (sglr::Context& gl, deUint32 program) const
{
gl.useProgram(program);
gl.uniform1i(gl.getUniformLocation(program, "u_sampler0"), 0);
gl.uniformMatrix3fv(gl.getUniformLocation(program, "u_coordMat"), 1, GL_FALSE, m_coordMat.getColumnMajorData().getPtr());
gl.uniform4fv(gl.getUniformLocation(program, "u_scale"), 1, m_texScale.getPtr());
gl.uniform4fv(gl.getUniformLocation(program, "u_bias"), 1, m_texBias.getPtr());
}
void TextureCubeShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
tcu::Mat3 texCoordMat = tcu::Mat3(m_uniforms[0].value.m3);
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::VertexPacket& packet = *packets[packetNdx];
tcu::Vec2 a_coord = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx).xy();
tcu::Vec3 v_coord = texCoordMat * tcu::Vec3(a_coord.x(), a_coord.y(), 1.0f);
packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
packet.outputs[0] = tcu::Vec4(v_coord.x(), v_coord.y(), v_coord.z(), 0.0f);
}
}
void TextureCubeShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const tcu::Vec4 texScale (m_uniforms[2].value.f4);
const tcu::Vec4 texBias (m_uniforms[3].value.f4);
tcu::Vec3 texCoords[4];
tcu::Vec4 colors[4];
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
const sglr::rc::TextureCube* tex = m_uniforms[1].sampler.texCube;
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 coord = rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx);
texCoords[fragNdx] = tcu::Vec3(coord.x(), coord.y(), coord.z());
}
tex->sample4(colors, texCoords);
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 color = colors[fragNdx] * texScale + texBias;
const tcu::IVec4 icolor = castVectorSaturate<deInt32>(color);
const tcu::UVec4 uicolor = castVectorSaturate<deUint32>(color);
if (m_outputType == glu::TYPE_FLOAT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
else if (m_outputType == glu::TYPE_INT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, icolor);
else if (m_outputType == glu::TYPE_UINT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, uicolor);
else
DE_ASSERT(DE_FALSE);
}
}
}
Texture2DArrayShader::Texture2DArrayShader (glu::DataType samplerType, glu::DataType outputType)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(mapDataTypeToGenericVecType(outputType))
<< sglr::pdec::Uniform("u_sampler0", samplerType)
<< sglr::pdec::Uniform("u_scale", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::Uniform("u_bias", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::Uniform("u_layer", glu::TYPE_INT)
<< sglr::pdec::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in highp vec2 a_coord;\n"
"out highp vec2 v_coord;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_coord = a_coord;\n"
"}\n")
<< sglr::pdec::FragmentSource(
string("") +
"#version 300 es\n"
"uniform highp " + glu::getDataTypeName(samplerType) + " u_sampler0;\n"
"uniform highp vec4 u_scale;\n"
"uniform highp vec4 u_bias;\n"
"uniform highp int u_layer;\n"
"in highp vec2 v_coord;\n"
"layout(location = 0) out highp " + glu::getDataTypeName(outputType) + " o_color;\n"
"void main (void)\n"
"{\n"
" o_color = " + glu::getDataTypeName(outputType) + "(vec4(texture(u_sampler0, vec3(v_coord, u_layer))) * u_scale + u_bias);\n"
"}\n"))
, m_texScale (1.0f)
, m_texBias (0.0f)
, m_layer (0)
, m_outputType (outputType)
{
}
void Texture2DArrayShader::setLayer (int layer)
{
m_layer = layer;
}
void Texture2DArrayShader::setTexScaleBias (const Vec4& scale, const Vec4& bias)
{
m_texScale = scale;
m_texBias = bias;
}
void Texture2DArrayShader::setUniforms (sglr::Context& gl, deUint32 program) const
{
gl.useProgram(program);
gl.uniform1i (gl.getUniformLocation(program, "u_sampler0"), 0);
gl.uniform1i (gl.getUniformLocation(program, "u_layer"), m_layer);
gl.uniform4fv (gl.getUniformLocation(program, "u_scale"), 1, m_texScale.getPtr());
gl.uniform4fv (gl.getUniformLocation(program, "u_bias"), 1, m_texBias.getPtr());
}
void Texture2DArrayShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::VertexPacket& packet = *packets[packetNdx];
packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx);
}
}
void Texture2DArrayShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const tcu::Vec4 texScale (m_uniforms[1].value.f4);
const tcu::Vec4 texBias (m_uniforms[2].value.f4);
const int layer = m_uniforms[3].value.i;
tcu::Vec3 texCoords[4];
tcu::Vec4 colors[4];
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
const sglr::rc::Texture2DArray* tex = m_uniforms[0].sampler.tex2DArray;
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 coord = rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx);
texCoords[fragNdx] = tcu::Vec3(coord.x(), coord.y(), float(layer));
}
tex->sample4(colors, texCoords);
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 color = colors[fragNdx] * texScale + texBias;
const tcu::IVec4 icolor = castVectorSaturate<deInt32>(color);
const tcu::UVec4 uicolor = castVectorSaturate<deUint32>(color);
if (m_outputType == glu::TYPE_FLOAT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
else if (m_outputType == glu::TYPE_INT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, icolor);
else if (m_outputType == glu::TYPE_UINT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, uicolor);
else
DE_ASSERT(DE_FALSE);
}
}
}
Texture3DShader::Texture3DShader (glu::DataType samplerType, glu::DataType outputType)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(mapDataTypeToGenericVecType(outputType))
<< sglr::pdec::Uniform("u_sampler0", samplerType)
<< sglr::pdec::Uniform("u_scale", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::Uniform("u_bias", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::Uniform("u_depth", glu::TYPE_FLOAT)
<< sglr::pdec::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in highp vec2 a_coord;\n"
"out highp vec2 v_coord;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_coord = a_coord;\n"
"}\n")
<< sglr::pdec::FragmentSource(
string("") +
"#version 300 es\n"
"uniform highp " + glu::getDataTypeName(samplerType) + " u_sampler0;\n"
"uniform highp vec4 u_scale;\n"
"uniform highp vec4 u_bias;\n"
"uniform highp float u_depth;\n"
"in highp vec2 v_coord;\n"
"layout(location = 0) out highp " + glu::getDataTypeName(outputType) + " o_color;\n"
"void main (void)\n"
"{\n"
" o_color = " + glu::getDataTypeName(outputType) + "(vec4(texture(u_sampler0, vec3(v_coord, u_depth))) * u_scale + u_bias);\n"
"}\n"))
, m_texScale (1.0f)
, m_texBias (0.0f)
, m_depth (0.0f)
, m_outputType (outputType)
{
}
void Texture3DShader::setDepth (float depth)
{
m_depth = depth;
}
void Texture3DShader::setTexScaleBias (const Vec4& scale, const Vec4& bias)
{
m_texScale = scale;
m_texBias = bias;
}
void Texture3DShader::setUniforms (sglr::Context& gl, deUint32 program) const
{
gl.useProgram(program);
gl.uniform1i (gl.getUniformLocation(program, "u_sampler0"), 0);
gl.uniform1f (gl.getUniformLocation(program, "u_depth"), m_depth);
gl.uniform4fv (gl.getUniformLocation(program, "u_scale"), 1, m_texScale.getPtr());
gl.uniform4fv (gl.getUniformLocation(program, "u_bias"), 1, m_texBias.getPtr());
}
void Texture3DShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::VertexPacket& packet = *packets[packetNdx];
packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx);
}
}
void Texture3DShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const tcu::Vec4 texScale (m_uniforms[1].value.f4);
const tcu::Vec4 texBias (m_uniforms[2].value.f4);
const float depth = m_uniforms[3].value.f;
tcu::Vec3 texCoords[4];
tcu::Vec4 colors[4];
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
const sglr::rc::Texture3D* tex = m_uniforms[0].sampler.tex3D;
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 coord = rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx);
texCoords[fragNdx] = tcu::Vec3(coord.x(), coord.y(), depth);
}
tex->sample4(colors, texCoords);
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 color = colors[fragNdx] * texScale + texBias;
const tcu::IVec4 icolor = castVectorSaturate<deInt32>(color);
const tcu::UVec4 uicolor = castVectorSaturate<deUint32>(color);
if (m_outputType == glu::TYPE_FLOAT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
else if (m_outputType == glu::TYPE_INT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, icolor);
else if (m_outputType == glu::TYPE_UINT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, uicolor);
else
DE_ASSERT(DE_FALSE);
}
}
}
DepthGradientShader::DepthGradientShader (glu::DataType outputType)
: ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(mapDataTypeToGenericVecType(outputType))
<< sglr::pdec::Uniform("u_maxGradient", glu::TYPE_FLOAT)
<< sglr::pdec::Uniform("u_minGradient", glu::TYPE_FLOAT)
<< sglr::pdec::Uniform("u_color", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in highp vec4 a_coord;\n"
"out highp vec4 v_coord;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_coord = a_coord;\n"
"}\n")
<< sglr::pdec::FragmentSource(
string(
"#version 300 es\n"
"in highp vec4 v_coord;\n"
"uniform highp float u_minGradient;\n"
"uniform highp float u_maxGradient;\n"
"uniform highp vec4 u_color;\n"
"layout(location = 0) out highp ") + glu::getDataTypeName(outputType) + " o_color;\n"
"void main (void)\n"
"{\n"
" highp float x = v_coord.x;\n"
" highp float y = v_coord.y;\n"
" highp float f0 = (x + y) * 0.5;\n"
" gl_FragDepth = u_minGradient + (u_maxGradient-u_minGradient)*f0;\n"
" o_color = " + glu::getDataTypeName(outputType) + "(u_color);\n"
"}\n"))
, m_outputType (outputType)
, u_minGradient (getUniformByName("u_minGradient"))
, u_maxGradient (getUniformByName("u_maxGradient"))
, u_color (getUniformByName("u_color"))
{
}
void DepthGradientShader::setUniforms (sglr::Context& ctx, deUint32 program, const float gradientMin, const float gradientMax, const tcu::Vec4& color)
{
ctx.useProgram(program);
ctx.uniform1fv(ctx.getUniformLocation(program, "u_minGradient"), 1, &gradientMin);
ctx.uniform1fv(ctx.getUniformLocation(program, "u_maxGradient"), 1, &gradientMax);
ctx.uniform4fv(ctx.getUniformLocation(program, "u_color"), 1, color.getPtr());
}
void DepthGradientShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::VertexPacket& packet = *packets[packetNdx];
packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx);
}
}
void DepthGradientShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const float gradientMin (u_minGradient.value.f);
const float gradientMax (u_maxGradient.value.f);
const tcu::Vec4 color (u_color.value.f4);
const tcu::IVec4 icolor (castVectorSaturate<deInt32>(color));
const tcu::UVec4 uicolor (castVectorSaturate<deUint32>(color));
// running this shader without a depth buffer does not make any sense
DE_ASSERT(context.fragmentDepths);
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
{
const tcu::Vec4 coord = rr::readTriangleVarying<float>(packets[packetNdx], context, 0, fragNdx);
const float x = coord.x();
const float y = coord.y();
const float f0 = (x + y) * 0.5f;
rr::writeFragmentDepth(context, packetNdx, fragNdx, 0, gradientMin + (gradientMax-gradientMin) * f0);
if (m_outputType == glu::TYPE_FLOAT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
else if (m_outputType == glu::TYPE_INT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, icolor);
else if (m_outputType == glu::TYPE_UINT_VEC4) rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, uicolor);
else
DE_ASSERT(DE_FALSE);
}
}
void clearColorBuffer (sglr::Context& ctx, const tcu::TextureFormat& format, const tcu::Vec4& value)
{
const tcu::TextureChannelClass fmtClass = tcu::getTextureChannelClass(format.type);
switch (fmtClass)
{
case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
ctx.clearBufferfv(GL_COLOR, 0, value.getPtr());
break;
case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
ctx.clearBufferuiv(GL_COLOR, 0, value.asUint().getPtr());
break;
case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
ctx.clearBufferiv(GL_COLOR, 0, value.asInt().getPtr());
break;
default:
DE_ASSERT(DE_FALSE);
}
}
void readPixels (sglr::Context& ctx, tcu::Surface& dst, int x, int y, int width, int height, const tcu::TextureFormat& format, const tcu::Vec4& scale, const tcu::Vec4& bias)
{
tcu::TextureFormat readFormat = getFramebufferReadFormat(format);
glu::TransferFormat transferFmt = glu::getTransferFormat(readFormat);
int alignment = 4; // \note GL_PACK_ALIGNMENT = 4 is assumed.
int rowSize = deAlign32(readFormat.getPixelSize()*width, alignment);
vector<deUint8> data (rowSize*height);
ctx.readPixels(x, y, width, height, transferFmt.format, transferFmt.dataType, &data[0]);
// Convert to surface.
tcu::ConstPixelBufferAccess src(readFormat, width, height, 1, rowSize, 0, &data[0]);
dst.setSize(width, height);
tcu::PixelBufferAccess dstAccess = dst.getAccess();
for (int yo = 0; yo < height; yo++)
for (int xo = 0; xo < width; xo++)
dstAccess.setPixel(src.getPixel(xo, yo) * scale + bias, xo, yo);
}
static const char* getFboIncompleteReasonName (deUint32 reason)
{
switch (reason)
{
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
case GL_FRAMEBUFFER_UNSUPPORTED: return "GL_FRAMEBUFFER_UNSUPPORTED";
case GL_FRAMEBUFFER_COMPLETE: return "GL_FRAMEBUFFER_COMPLETE";
default: return "UNKNOWN";
}
}
FboIncompleteException::FboIncompleteException (deUint32 reason, const char* file, int line)
: TestError ("Framebuffer is not complete", getFboIncompleteReasonName(reason), file, line)
, m_reason (reason)
{
}
const char* getFormatName (deUint32 format)
{
switch (format)
{
case GL_RGB565: return "rgb565";
case GL_RGB5_A1: return "rgb5_a1";
case GL_RGBA4: return "rgba4";
case GL_DEPTH_COMPONENT16: return "depth_component16";
case GL_STENCIL_INDEX8: return "stencil_index8";
case GL_RGBA32F: return "rgba32f";
case GL_RGBA32I: return "rgba32i";
case GL_RGBA32UI: return "rgba32ui";
case GL_RGBA16F: return "rgba16f";
case GL_RGBA16I: return "rgba16i";
case GL_RGBA16UI: return "rgba16ui";
case GL_RGBA8: return "rgba8";
case GL_RGBA8I: return "rgba8i";
case GL_RGBA8UI: return "rgba8ui";
case GL_SRGB8_ALPHA8: return "srgb8_alpha8";
case GL_RGB10_A2: return "rgb10_a2";
case GL_RGB10_A2UI: return "rgb10_a2ui";
case GL_RGBA8_SNORM: return "rgba8_snorm";
case GL_RGB8: return "rgb8";
case GL_R11F_G11F_B10F: return "r11f_g11f_b10f";
case GL_RGB32F: return "rgb32f";
case GL_RGB32I: return "rgb32i";
case GL_RGB32UI: return "rgb32ui";
case GL_RGB16F: return "rgb16f";
case GL_RGB16I: return "rgb16i";
case GL_RGB16UI: return "rgb16ui";
case GL_RGB8_SNORM: return "rgb8_snorm";
case GL_RGB8I: return "rgb8i";
case GL_RGB8UI: return "rgb8ui";
case GL_SRGB8: return "srgb8";
case GL_RGB9_E5: return "rgb9_e5";
case GL_RG32F: return "rg32f";
case GL_RG32I: return "rg32i";
case GL_RG32UI: return "rg32ui";
case GL_RG16F: return "rg16f";
case GL_RG16I: return "rg16i";
case GL_RG16UI: return "rg16ui";
case GL_RG8: return "rg8";
case GL_RG8I: return "rg8i";
case GL_RG8UI: return "rg8ui";
case GL_RG8_SNORM: return "rg8_snorm";
case GL_R32F: return "r32f";
case GL_R32I: return "r32i";
case GL_R32UI: return "r32ui";
case GL_R16F: return "r16f";
case GL_R16I: return "r16i";
case GL_R16UI: return "r16ui";
case GL_R8: return "r8";
case GL_R8I: return "r8i";
case GL_R8UI: return "r8ui";
case GL_R8_SNORM: return "r8_snorm";
case GL_DEPTH_COMPONENT32F: return "depth_component32f";
case GL_DEPTH_COMPONENT24: return "depth_component24";
case GL_DEPTH32F_STENCIL8: return "depth32f_stencil8";
case GL_DEPTH24_STENCIL8: return "depth24_stencil8";
default:
TCU_FAIL("Unknown format");
}
}
glu::DataType getFragmentOutputType (const tcu::TextureFormat& format)
{
switch (tcu::getTextureChannelClass(format.type))
{
case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
return glu::TYPE_FLOAT_VEC4;
case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
return glu::TYPE_UINT_VEC4;
case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
return glu::TYPE_INT_VEC4;
default:
DE_FATAL("Unknown format");
return glu::TYPE_LAST;
}
}
tcu::TextureFormat getFramebufferReadFormat (const tcu::TextureFormat& format)
{
switch (tcu::getTextureChannelClass(format.type))
{
case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT);
case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8);
case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32);
case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32);
default:
DE_FATAL("Unknown format");
return tcu::TextureFormat();
}
}
static int calculateU8ConversionError (int srcBits)
{
if (srcBits > 0)
{
const int clampedBits = de::clamp<int>(srcBits, 0, 8);
const int srcMaxValue = de::max((1<<clampedBits) - 1, 1);
const int error = int(deFloatCeil(255.0f * 2.0f / float(srcMaxValue)));
return de::clamp<int>(error, 0, 255);
}
else
return 1;
}
tcu::RGBA getFormatThreshold (const tcu::TextureFormat& format)
{
const tcu::IVec4 bits = tcu::getTextureFormatMantissaBitDepth(format);
return tcu::RGBA(calculateU8ConversionError(bits.x()),
calculateU8ConversionError(bits.y()),
calculateU8ConversionError(bits.z()),
calculateU8ConversionError(bits.w()));
}
tcu::RGBA getFormatThreshold (deUint32 glFormat)
{
const tcu::TextureFormat format = glu::mapGLInternalFormat(glFormat);
return getFormatThreshold(format);
}
static int getToSRGB8ConversionError (int srcBits)
{
// \note These are pre-computed based on simulation results.
static const int errors[] =
{
1, // 0 bits - rounding
255, // 1 bits
157, // 2 bits
106, // 3 bits
74, // 4 bits
51, // 5 bits
34, // 6 bits
22, // 7 bits
13, // 8 bits
7, // 9 bits
4, // 10 bits
3, // 11 bits
2, // 12 bits
// 1 from this on
};
DE_ASSERT(srcBits >= 0);
if (srcBits < DE_LENGTH_OF_ARRAY(errors))
return errors[srcBits];
else
return 1;
}
tcu::RGBA getToSRGBConversionThreshold (const tcu::TextureFormat& src, const tcu::TextureFormat& dst)
{
// Only SRGB8 and SRGB8_ALPHA8 formats are supported.
DE_ASSERT(dst.type == tcu::TextureFormat::UNORM_INT8 && tcu::isSRGB(dst));
const tcu::IVec4 bits = tcu::getTextureFormatMantissaBitDepth(src);
const bool dstHasAlpha = dst.order == tcu::TextureFormat::sRGBA;
return tcu::RGBA(getToSRGB8ConversionError(bits.x()),
getToSRGB8ConversionError(bits.y()),
getToSRGB8ConversionError(bits.z()),
dstHasAlpha ? calculateU8ConversionError(bits.w()) : 0);
}
} // FboTestUtil
} // Functional
} // gles3
} // deqp
Reference in new issue View Git Blame Copy Permalink