| /*------------------------------------------------------------------------- |
| * 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(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(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 uint8_t 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()); |
| } |
| |
| } // namespace FragmentOpUtil |
| } // namespace gls |
| } // namespace deqp |
