/*-------------------------------------------------------------------------
|
* 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 Fragment operation test utilities.
|
*//*--------------------------------------------------------------------*/
|
|
#include "glsFragmentOpUtil.hpp"
|
#include "gluRenderContext.hpp"
|
#include "gluShaderProgram.hpp"
|
#include "gluDrawUtil.hpp"
|
#include "glwFunctions.hpp"
|
#include "glwEnums.hpp"
|
|
namespace deqp
|
{
|
namespace gls
|
{
|
namespace FragmentOpUtil
|
{
|
|
template<typename T>
|
inline T triQuadInterpolate (const T values[4], float xFactor, float yFactor)
|
{
|
if (xFactor + yFactor < 1.0f)
|
return values[0] + (values[2]-values[0])*xFactor + (values[1]-values[0])*yFactor;
|
else
|
return values[3] + (values[1]-values[3])*(1.0f-xFactor) + (values[2]-values[3])*(1.0f-yFactor);
|
}
|
|
// GLSL ES 1.0 shaders
|
static const char* s_glsl1VertSrc =
|
"attribute highp vec4 a_position;\n"
|
"attribute mediump vec4 a_color;\n"
|
"varying mediump vec4 v_color;\n"
|
"void main()\n"
|
"{\n"
|
" gl_Position = a_position;\n"
|
" v_color = a_color;\n"
|
"}\n";
|
static const char* s_glsl1FragSrc =
|
"varying mediump vec4 v_color;\n"
|
"void main()\n"
|
"{\n"
|
" gl_FragColor = v_color;\n"
|
"}\n";
|
|
// GLSL ES 3.0 shaders
|
static const char* s_glsl3VertSrc =
|
"#version 300 es\n"
|
"in highp vec4 a_position;\n"
|
"in mediump vec4 a_color;\n"
|
"out mediump vec4 v_color;\n"
|
"void main()\n"
|
"{\n"
|
" gl_Position = a_position;\n"
|
" v_color = a_color;\n"
|
"}\n";
|
static const char* s_glsl3FragSrc =
|
"#version 300 es\n"
|
"in mediump vec4 v_color;\n"
|
"layout(location = 0) out mediump vec4 o_color;\n"
|
"void main()\n"
|
"{\n"
|
" o_color = v_color;\n"
|
"}\n";
|
|
// GLSL 3.3 shaders
|
static const char* s_glsl33VertSrc =
|
"#version 330 core\n"
|
"in vec4 a_position;\n"
|
"in vec4 a_color;\n"
|
"in vec4 a_color1;\n"
|
"out vec4 v_color;\n"
|
"out vec4 v_color1;\n"
|
"void main()\n"
|
"{\n"
|
" gl_Position = a_position;\n"
|
" v_color = a_color;\n"
|
" v_color1 = a_color1;\n"
|
"}\n";
|
static const char* s_glsl33FragSrc =
|
"#version 330 core\n"
|
"in vec4 v_color;\n"
|
"in vec4 v_color1;\n"
|
"layout(location = 0, index = 0) out vec4 o_color;\n"
|
"layout(location = 0, index = 1) out vec4 o_color1;\n"
|
"void main()\n"
|
"{\n"
|
" o_color = v_color;\n"
|
" o_color1 = v_color1;\n"
|
"}\n";
|
|
static const char* getVertSrc (glu::GLSLVersion glslVersion)
|
{
|
if (glslVersion == glu::GLSL_VERSION_100_ES)
|
return s_glsl1VertSrc;
|
else if (glslVersion == glu::GLSL_VERSION_300_ES)
|
return s_glsl3VertSrc;
|
else if (glslVersion == glu::GLSL_VERSION_330)
|
return s_glsl33VertSrc;
|
|
DE_ASSERT(DE_FALSE);
|
return 0;
|
}
|
|
static const char* getFragSrc (glu::GLSLVersion glslVersion)
|
{
|
if (glslVersion == glu::GLSL_VERSION_100_ES)
|
return s_glsl1FragSrc;
|
else if (glslVersion == glu::GLSL_VERSION_300_ES)
|
return s_glsl3FragSrc;
|
else if (glslVersion == glu::GLSL_VERSION_330)
|
return s_glsl33FragSrc;
|
|
DE_ASSERT(DE_FALSE);
|
return 0;
|
}
|
|
QuadRenderer::QuadRenderer (const glu::RenderContext& context, glu::GLSLVersion glslVersion)
|
: m_context (context)
|
, m_program (DE_NULL)
|
, m_positionLoc (0)
|
, m_colorLoc (-1)
|
, m_color1Loc (-1)
|
, m_blendFuncExt (!glu::glslVersionIsES(glslVersion) && (glslVersion >= glu::GLSL_VERSION_330))
|
{
|
DE_ASSERT(glslVersion == glu::GLSL_VERSION_100_ES ||
|
glslVersion == glu::GLSL_VERSION_300_ES ||
|
glslVersion == glu::GLSL_VERSION_330);
|
|
const glw::Functions& gl = context.getFunctions();
|
const char* vertSrc = getVertSrc(glslVersion);
|
const char* fragSrc = getFragSrc(glslVersion);
|
|
m_program = new glu::ShaderProgram(m_context, glu::makeVtxFragSources(vertSrc, fragSrc));
|
if (!m_program->isOk())
|
{
|
delete m_program;
|
throw tcu::TestError("Failed to compile program", DE_NULL, __FILE__, __LINE__);
|
}
|
|
m_positionLoc = gl.getAttribLocation(m_program->getProgram(), "a_position");
|
m_colorLoc = gl.getAttribLocation(m_program->getProgram(), "a_color");
|
|
if (m_blendFuncExt)
|
m_color1Loc = gl.getAttribLocation(m_program->getProgram(), "a_color1");
|
|
if (m_positionLoc < 0 || m_colorLoc < 0 || (m_blendFuncExt && m_color1Loc < 0))
|
{
|
delete m_program;
|
throw tcu::TestError("Invalid attribute locations", DE_NULL, __FILE__, __LINE__);
|
}
|
}
|
|
QuadRenderer::~QuadRenderer (void)
|
{
|
delete m_program;
|
}
|
|
void QuadRenderer::render (const Quad& quad) const
|
{
|
const float position[] =
|
{
|
quad.posA.x(), quad.posA.y(), quad.depth[0], 1.0f,
|
quad.posA.x(), quad.posB.y(), quad.depth[1], 1.0f,
|
quad.posB.x(), quad.posA.y(), quad.depth[2], 1.0f,
|
quad.posB.x(), quad.posB.y(), quad.depth[3], 1.0f
|
};
|
const deUint8 indices[] = { 0, 2, 1, 1, 2, 3 };
|
|
DE_STATIC_ASSERT(sizeof(tcu::Vec4) == sizeof(float)*4);
|
DE_STATIC_ASSERT(sizeof(quad.color) == sizeof(float)*4*4);
|
DE_STATIC_ASSERT(sizeof(quad.color1) == sizeof(float)*4*4);
|
|
std::vector<glu::VertexArrayBinding> vertexArrays;
|
|
vertexArrays.push_back(glu::va::Float(m_positionLoc, 4, 4, 0, &position[0]));
|
vertexArrays.push_back(glu::va::Float(m_colorLoc, 4, 4, 0, (const float*)&quad.color[0]));
|
|
if (m_blendFuncExt)
|
vertexArrays.push_back(glu::va::Float(m_color1Loc, 4, 4, 0, (const float*)&quad.color1[0]));
|
|
m_context.getFunctions().useProgram(m_program->getProgram());
|
glu::draw(m_context, m_program->getProgram(),
|
(int)vertexArrays.size(), &vertexArrays[0],
|
glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
|
}
|
|
ReferenceQuadRenderer::ReferenceQuadRenderer (void)
|
: m_fragmentBufferSize(0)
|
{
|
for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_fragmentDepths); i++)
|
m_fragmentDepths[i] = 0.0f;
|
}
|
|
void ReferenceQuadRenderer::flushFragmentBuffer (const rr::MultisamplePixelBufferAccess& colorBuffer,
|
const rr::MultisamplePixelBufferAccess& depthBuffer,
|
const rr::MultisamplePixelBufferAccess& stencilBuffer,
|
rr::FaceType faceType,
|
const rr::FragmentOperationState& state)
|
{
|
m_fragmentProcessor.render(colorBuffer, depthBuffer, stencilBuffer, &m_fragmentBuffer[0], m_fragmentBufferSize, faceType, state);
|
m_fragmentBufferSize = 0;
|
}
|
|
void ReferenceQuadRenderer::render (const tcu::PixelBufferAccess& colorBuffer,
|
const tcu::PixelBufferAccess& depthBuffer,
|
const tcu::PixelBufferAccess& stencilBuffer,
|
const IntegerQuad& quad,
|
const rr::FragmentOperationState& state)
|
{
|
bool flipX = quad.posA.x() > quad.posB.x();
|
bool flipY = quad.posA.y() > quad.posB.y();
|
rr::FaceType faceType = flipX == flipY ? rr::FACETYPE_FRONT : rr::FACETYPE_BACK;
|
int xFirst = flipX ? quad.posB.x() : quad.posA.x();
|
int xLast = flipX ? quad.posA.x() : quad.posB.x();
|
int yFirst = flipY ? quad.posB.y() : quad.posA.y();
|
int yLast = flipY ? quad.posA.y() : quad.posB.y();
|
float width = (float)(xLast - xFirst + 1);
|
float height = (float)(yLast - yFirst + 1);
|
|
for (int y = yFirst; y <= yLast; y++)
|
{
|
// Interpolation factor for y.
|
float yRatio = (0.5f + (float)(y - yFirst)) / height;
|
if (flipY)
|
yRatio = 1.0f - yRatio;
|
|
for (int x = xFirst; x <= xLast; x++)
|
{
|
// Interpolation factor for x.
|
float xRatio = (0.5f + (float)(x - xFirst)) / width;
|
if (flipX)
|
xRatio = 1.0f - xRatio;
|
|
tcu::Vec4 color = triQuadInterpolate(quad.color, xRatio, yRatio);
|
tcu::Vec4 color1 = triQuadInterpolate(quad.color1, xRatio, yRatio);
|
float depth = triQuadInterpolate(quad.depth, xRatio, yRatio);
|
|
// Interpolated color and depth.
|
|
DE_STATIC_ASSERT(MAX_FRAGMENT_BUFFER_SIZE == DE_LENGTH_OF_ARRAY(m_fragmentBuffer));
|
|
if (m_fragmentBufferSize >= MAX_FRAGMENT_BUFFER_SIZE)
|
flushFragmentBuffer(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer),
|
rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer),
|
rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer), faceType, state);
|
|
m_fragmentDepths[m_fragmentBufferSize] = depth;
|
m_fragmentBuffer[m_fragmentBufferSize] = rr::Fragment(tcu::IVec2(x, y), rr::GenericVec4(color), rr::GenericVec4(color1), 1u /* coverage mask */, &m_fragmentDepths[m_fragmentBufferSize]);
|
m_fragmentBufferSize++;
|
}
|
}
|
|
flushFragmentBuffer(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer),
|
rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer),
|
rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer), faceType, state);
|
}
|
|
tcu::PixelBufferAccess getMultisampleAccess(const tcu::PixelBufferAccess& original)
|
{
|
return tcu::PixelBufferAccess(original.getFormat(),
|
1,
|
original.getWidth(),
|
original.getHeight(),
|
original.getFormat().getPixelSize(),
|
original.getRowPitch(),
|
original.getDataPtr());
|
}
|
|
tcu::ConstPixelBufferAccess getMultisampleAccess(const tcu::ConstPixelBufferAccess& original)
|
{
|
return tcu::ConstPixelBufferAccess(original.getFormat(),
|
1,
|
original.getWidth(),
|
original.getHeight(),
|
original.getFormat().getPixelSize(),
|
original.getRowPitch(),
|
original.getDataPtr());
|
}
|
|
} // FragmentOpUtil
|
} // gls
|
} // deqp
|
