| /*------------------------------------------------------------------------- |
| * drawElements Quality Program EGL 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 Rendering tests for different config and api combinations. |
| * \todo [2013-03-19 pyry] GLES1 and VG support. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "teglRenderTests.hpp" |
| #include "teglRenderCase.hpp" |
| #include "tcuRenderTarget.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuSurface.hpp" |
| |
| #include "deRandom.hpp" |
| #include "deSharedPtr.hpp" |
| #include "deSemaphore.hpp" |
| #include "deThread.hpp" |
| #include "deString.h" |
| |
| #include <algorithm> |
| #include <iterator> |
| #include <memory> |
| #include <set> |
| |
| #include <EGL/eglext.h> |
| |
| #if !defined(EGL_OPENGL_ES3_BIT_KHR) |
| # define EGL_OPENGL_ES3_BIT_KHR 0x0040 |
| #endif |
| #if !defined(EGL_CONTEXT_MAJOR_VERSION_KHR) |
| # define EGL_CONTEXT_MAJOR_VERSION_KHR EGL_CONTEXT_CLIENT_VERSION |
| #endif |
| |
| #if defined(DEQP_SUPPORT_GLES2) |
| # include <GLES2/gl2.h> |
| #elif defined(DEQP_SUPPORT_GLES3) |
| # include <GLES3/gl3.h> |
| #endif |
| |
| #include "rrRenderer.hpp" |
| #include "rrFragmentOperations.hpp" |
| |
| #if defined(DEQP_SUPPORT_GLES2) || defined(DEQP_SUPPORT_GLES3) |
| # include "gluDefs.hpp" |
| #else |
| // \todo [pyry] Move renderer to common utils |
| // \note [jarkko] gluDefs is required for GLU_CHECK_MSG |
| # error "Reference renderer requires GLES2 or GLES3 support" |
| #endif |
| |
| namespace deqp |
| { |
| namespace egl |
| { |
| |
| using std::string; |
| using std::vector; |
| using std::set; |
| |
| using tcu::Vec4; |
| |
| using tcu::TestLog; |
| |
| static const tcu::Vec4 CLEAR_COLOR = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); |
| static const float CLEAR_DEPTH = 1.0f; |
| static const int CLEAR_STENCIL = 0; |
| |
| namespace |
| { |
| |
| enum PrimitiveType |
| { |
| PRIMITIVETYPE_TRIANGLE = 0, //!< Triangles, requires 3 coordinates per primitive |
| // PRIMITIVETYPE_POINT, //!< Points, requires 1 coordinate per primitive (w is used as size) |
| // PRIMITIVETYPE_LINE, //!< Lines, requires 2 coordinates per primitive |
| |
| PRIMITIVETYPE_LAST |
| }; |
| |
| enum BlendMode |
| { |
| BLENDMODE_NONE = 0, //!< No blending |
| BLENDMODE_ADDITIVE, //!< Blending with ONE, ONE |
| BLENDMODE_SRC_OVER, //!< Blending with SRC_ALPHA, ONE_MINUS_SRC_ALPHA |
| |
| BLENDMODE_LAST |
| }; |
| |
| enum DepthMode |
| { |
| DEPTHMODE_NONE = 0, //!< No depth test or depth writes |
| DEPTHMODE_LESS, //!< Depth test with less & depth write |
| |
| DEPTHMODE_LAST |
| }; |
| |
| enum StencilMode |
| { |
| STENCILMODE_NONE = 0, //!< No stencil test or write |
| STENCILMODE_LEQUAL_INC, //!< Stencil test with LEQUAL, increment on pass |
| |
| STENCILMODE_LAST |
| }; |
| |
| struct DrawPrimitiveOp |
| { |
| PrimitiveType type; |
| int count; |
| vector<Vec4> positions; |
| vector<Vec4> colors; |
| BlendMode blend; |
| DepthMode depth; |
| StencilMode stencil; |
| int stencilRef; |
| }; |
| |
| void randomizeDrawOp (de::Random& rnd, DrawPrimitiveOp& drawOp) |
| { |
| const int minStencilRef = 0; |
| const int maxStencilRef = 8; |
| const int minPrimitives = 2; |
| const int maxPrimitives = 4; |
| |
| const float maxTriOffset = 1.0f; |
| const float minDepth = -1.0f; // \todo [pyry] Reference doesn't support Z clipping yet |
| const float maxDepth = 1.0f; |
| |
| const float minRGB = 0.2f; |
| const float maxRGB = 0.9f; |
| const float minAlpha = 0.3f; |
| const float maxAlpha = 1.0f; |
| |
| drawOp.type = (PrimitiveType)rnd.getInt(0, PRIMITIVETYPE_LAST-1); |
| drawOp.count = rnd.getInt(minPrimitives, maxPrimitives); |
| drawOp.blend = (BlendMode)rnd.getInt(0, BLENDMODE_LAST-1); |
| drawOp.depth = (DepthMode)rnd.getInt(0, DEPTHMODE_LAST-1); |
| drawOp.stencil = (StencilMode)rnd.getInt(0, STENCILMODE_LAST-1); |
| drawOp.stencilRef = rnd.getInt(minStencilRef, maxStencilRef); |
| |
| if (drawOp.type == PRIMITIVETYPE_TRIANGLE) |
| { |
| drawOp.positions.resize(drawOp.count*3); |
| drawOp.colors.resize(drawOp.count*3); |
| |
| for (int triNdx = 0; triNdx < drawOp.count; triNdx++) |
| { |
| const float cx = rnd.getFloat(-1.0f, 1.0f); |
| const float cy = rnd.getFloat(-1.0f, 1.0f); |
| |
| for (int coordNdx = 0; coordNdx < 3; coordNdx++) |
| { |
| tcu::Vec4& position = drawOp.positions[triNdx*3 + coordNdx]; |
| tcu::Vec4& color = drawOp.colors[triNdx*3 + coordNdx]; |
| |
| position.x() = cx + rnd.getFloat(-maxTriOffset, maxTriOffset); |
| position.y() = cy + rnd.getFloat(-maxTriOffset, maxTriOffset); |
| position.z() = rnd.getFloat(minDepth, maxDepth); |
| position.w() = 1.0f; |
| |
| color.x() = rnd.getFloat(minRGB, maxRGB); |
| color.y() = rnd.getFloat(minRGB, maxRGB); |
| color.z() = rnd.getFloat(minRGB, maxRGB); |
| color.w() = rnd.getFloat(minAlpha, maxAlpha); |
| } |
| } |
| } |
| else |
| DE_ASSERT(false); |
| } |
| |
| // Reference rendering code |
| |
| class ReferenceShader : public rr::VertexShader, public rr::FragmentShader |
| { |
| public: |
| enum |
| { |
| VaryingLoc_Color = 0 |
| }; |
| |
| ReferenceShader () |
| : rr::VertexShader (2, 1) // color and pos in => color out |
| , rr::FragmentShader(1, 1) // color in => color out |
| { |
| this->rr::VertexShader::m_inputs[0].type = rr::GENERICVECTYPE_FLOAT; |
| this->rr::VertexShader::m_inputs[1].type = rr::GENERICVECTYPE_FLOAT; |
| |
| this->rr::VertexShader::m_outputs[0].type = rr::GENERICVECTYPE_FLOAT; |
| this->rr::VertexShader::m_outputs[0].flatshade = false; |
| |
| this->rr::FragmentShader::m_inputs[0].type = rr::GENERICVECTYPE_FLOAT; |
| this->rr::FragmentShader::m_inputs[0].flatshade = false; |
| |
| this->rr::FragmentShader::m_outputs[0].type = rr::GENERICVECTYPE_FLOAT; |
| } |
| |
| void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const |
| { |
| for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) |
| { |
| const int positionAttrLoc = 0; |
| const int colorAttrLoc = 1; |
| |
| rr::VertexPacket& packet = *packets[packetNdx]; |
| |
| // Transform to position |
| packet.position = rr::readVertexAttribFloat(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx); |
| |
| // Pass color to FS |
| packet.outputs[VaryingLoc_Color] = rr::readVertexAttribFloat(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx); |
| } |
| } |
| |
| void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const |
| { |
| for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx) |
| { |
| rr::FragmentPacket& packet = packets[packetNdx]; |
| |
| for (int fragNdx = 0; fragNdx < 4; ++fragNdx) |
| rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, rr::readVarying<float>(packet, context, VaryingLoc_Color, fragNdx)); |
| } |
| } |
| }; |
| |
| void toReferenceRenderState (rr::RenderState& state, const DrawPrimitiveOp& drawOp) |
| { |
| state.cullMode = rr::CULLMODE_NONE; |
| |
| if (drawOp.blend != BLENDMODE_NONE) |
| { |
| state.fragOps.blendMode = rr::BLENDMODE_STANDARD; |
| |
| switch (drawOp.blend) |
| { |
| case BLENDMODE_ADDITIVE: |
| state.fragOps.blendRGBState.srcFunc = rr::BLENDFUNC_ONE; |
| state.fragOps.blendRGBState.dstFunc = rr::BLENDFUNC_ONE; |
| state.fragOps.blendRGBState.equation = rr::BLENDEQUATION_ADD; |
| state.fragOps.blendAState = state.fragOps.blendRGBState; |
| break; |
| |
| case BLENDMODE_SRC_OVER: |
| state.fragOps.blendRGBState.srcFunc = rr::BLENDFUNC_SRC_ALPHA; |
| state.fragOps.blendRGBState.dstFunc = rr::BLENDFUNC_ONE_MINUS_SRC_ALPHA; |
| state.fragOps.blendRGBState.equation = rr::BLENDEQUATION_ADD; |
| state.fragOps.blendAState = state.fragOps.blendRGBState; |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| if (drawOp.depth != DEPTHMODE_NONE) |
| { |
| state.fragOps.depthTestEnabled = true; |
| |
| DE_ASSERT(drawOp.depth == DEPTHMODE_LESS); |
| state.fragOps.depthFunc = rr::TESTFUNC_LESS; |
| } |
| |
| if (drawOp.stencil != STENCILMODE_NONE) |
| { |
| state.fragOps.stencilTestEnabled = true; |
| |
| DE_ASSERT(drawOp.stencil == STENCILMODE_LEQUAL_INC); |
| state.fragOps.stencilStates[0].func = rr::TESTFUNC_LEQUAL; |
| state.fragOps.stencilStates[0].sFail = rr::STENCILOP_KEEP; |
| state.fragOps.stencilStates[0].dpFail = rr::STENCILOP_INCR; |
| state.fragOps.stencilStates[0].dpPass = rr::STENCILOP_INCR; |
| state.fragOps.stencilStates[0].ref = drawOp.stencilRef; |
| state.fragOps.stencilStates[1] = state.fragOps.stencilStates[0]; |
| } |
| } |
| |
| tcu::TextureFormat getColorFormat (const tcu::PixelFormat& colorBits) |
| { |
| using tcu::TextureFormat; |
| |
| DE_ASSERT(de::inBounds(colorBits.redBits, 0, 0xff) && |
| de::inBounds(colorBits.greenBits, 0, 0xff) && |
| de::inBounds(colorBits.blueBits, 0, 0xff) && |
| de::inBounds(colorBits.alphaBits, 0, 0xff)); |
| |
| #define PACK_FMT(R, G, B, A) (((R) << 24) | ((G) << 16) | ((B) << 8) | (A)) |
| |
| // \note [pyry] This may not hold true on some implementations - best effort guess only. |
| switch (PACK_FMT(colorBits.redBits, colorBits.greenBits, colorBits.blueBits, colorBits.alphaBits)) |
| { |
| case PACK_FMT(8,8,8,8): return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); |
| case PACK_FMT(8,8,8,0): return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8); |
| case PACK_FMT(4,4,4,4): return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444); |
| case PACK_FMT(5,5,5,1): return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551); |
| case PACK_FMT(5,6,5,0): return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565); |
| |
| // \note Defaults to RGBA8 |
| default: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); |
| } |
| |
| #undef PACK_FMT |
| } |
| |
| tcu::TextureFormat getDepthFormat (const int depthBits) |
| { |
| switch (depthBits) |
| { |
| case 0: return tcu::TextureFormat(); |
| case 8: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT8); |
| case 16: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT16); |
| case 24: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNSIGNED_INT_24_8); |
| case 32: |
| default: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT); |
| } |
| } |
| |
| tcu::TextureFormat getStencilFormat (int stencilBits) |
| { |
| switch (stencilBits) |
| { |
| case 0: return tcu::TextureFormat(); |
| case 8: |
| default: return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT8); |
| } |
| } |
| |
| void renderReference (const tcu::PixelBufferAccess& dst, const vector<DrawPrimitiveOp>& drawOps, const tcu::PixelFormat& colorBits, const int depthBits, const int stencilBits, const int numSamples) |
| { |
| const int width = dst.getWidth(); |
| const int height = dst.getHeight(); |
| |
| tcu::TextureLevel colorBuffer; |
| tcu::TextureLevel depthBuffer; |
| tcu::TextureLevel stencilBuffer; |
| |
| rr::Renderer referenceRenderer; |
| rr::VertexAttrib attributes[2]; |
| const ReferenceShader shader; |
| |
| attributes[0].type = rr::VERTEXATTRIBTYPE_FLOAT; |
| attributes[0].size = 4; |
| attributes[0].stride = 0; |
| attributes[0].instanceDivisor = 0; |
| |
| attributes[1].type = rr::VERTEXATTRIBTYPE_FLOAT; |
| attributes[1].size = 4; |
| attributes[1].stride = 0; |
| attributes[1].instanceDivisor = 0; |
| |
| // Initialize buffers. |
| colorBuffer.setStorage(getColorFormat(colorBits), numSamples, width, height); |
| rr::clearMultisampleColorBuffer(colorBuffer, CLEAR_COLOR, rr::WindowRectangle(0, 0, width, height)); |
| |
| if (depthBits > 0) |
| { |
| depthBuffer.setStorage(getDepthFormat(depthBits), numSamples, width, height); |
| rr::clearMultisampleDepthBuffer(depthBuffer, CLEAR_DEPTH, rr::WindowRectangle(0, 0, width, height)); |
| } |
| |
| if (stencilBits > 0) |
| { |
| stencilBuffer.setStorage(getStencilFormat(stencilBits), numSamples, width, height); |
| rr::clearMultisampleStencilBuffer(stencilBuffer, CLEAR_STENCIL, rr::WindowRectangle(0, 0, width, height)); |
| } |
| |
| const rr::RenderTarget renderTarget(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess()), |
| rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer.getAccess()), |
| rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer.getAccess())); |
| |
| for (vector<DrawPrimitiveOp>::const_iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); drawOp++) |
| { |
| // Translate state |
| rr::RenderState renderState((rr::ViewportState)(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess()))); |
| toReferenceRenderState(renderState, *drawOp); |
| |
| DE_ASSERT(drawOp->type == PRIMITIVETYPE_TRIANGLE); |
| |
| attributes[0].pointer = &drawOp->positions[0]; |
| attributes[1].pointer = &drawOp->colors[0]; |
| |
| referenceRenderer.draw( |
| rr::DrawCommand( |
| renderState, |
| renderTarget, |
| rr::Program(static_cast<const rr::VertexShader*>(&shader), static_cast<const rr::FragmentShader*>(&shader)), |
| 2, |
| attributes, |
| rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, drawOp->count * 3, 0))); |
| } |
| |
| rr::resolveMultisampleColorBuffer(dst, rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer.getAccess())); |
| } |
| |
| // API rendering code |
| |
| class Program |
| { |
| public: |
| Program (void) {} |
| virtual ~Program (void) {} |
| |
| virtual void setup (void) const = DE_NULL; |
| }; |
| |
| typedef de::SharedPtr<Program> ProgramSp; |
| |
| #if defined(DEQP_SUPPORT_GLES2) || defined(DEQP_SUPPORT_GLES3) |
| |
| static const char* s_vertexSrc = |
| "attribute highp vec4 a_position;\n" |
| "attribute mediump vec4 a_color;\n" |
| "varying mediump vec4 v_color;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = a_position;\n" |
| " v_color = a_color;\n" |
| "}\n"; |
| |
| static const char* s_fragmentSrc = |
| "varying mediump vec4 v_color;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_FragColor = v_color;\n" |
| "}\n"; |
| |
| static deUint32 createShader (deUint32 shaderType, const char* source) |
| { |
| deUint32 shader = glCreateShader(shaderType); |
| glShaderSource(shader, 1, &source, DE_NULL); |
| glCompileShader(shader); |
| |
| int compileStatus = 0; |
| glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus); |
| |
| if (!compileStatus) |
| { |
| glDeleteShader(shader); |
| return 0; |
| } |
| |
| return shader; |
| } |
| |
| static deUint32 createProgram (deUint32 vertexShader, deUint32 fragmentShader) |
| { |
| deUint32 program = glCreateProgram(); |
| glAttachShader(program, vertexShader); |
| glAttachShader(program, fragmentShader); |
| glLinkProgram(program); |
| |
| int linkStatus = 0; |
| glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); |
| |
| if (!linkStatus) |
| { |
| glDeleteProgram(program); |
| return 0; |
| } |
| |
| return program; |
| } |
| |
| class GLES2Program : public Program |
| { |
| public: |
| GLES2Program (void) |
| : m_program (0) |
| , m_vertexShader (0) |
| , m_fragmentShader (0) |
| , m_positionLoc (0) |
| , m_colorLoc (0) |
| { |
| m_vertexShader = createShader(GL_VERTEX_SHADER, s_vertexSrc); |
| m_fragmentShader = createShader(GL_FRAGMENT_SHADER, s_fragmentSrc); |
| |
| if (!m_vertexShader || !m_fragmentShader) |
| { |
| glDeleteShader(m_vertexShader); |
| glDeleteShader(m_fragmentShader); |
| throw tcu::TestError("Failed to compile shaders"); |
| } |
| |
| m_program = createProgram(m_vertexShader, m_fragmentShader); |
| if (!m_program) |
| { |
| glDeleteShader(m_vertexShader); |
| glDeleteShader(m_fragmentShader); |
| throw tcu::TestError("Failed to link program"); |
| } |
| |
| m_positionLoc = glGetAttribLocation(m_program, "a_position"); |
| m_colorLoc = glGetAttribLocation(m_program, "a_color"); |
| } |
| |
| ~GLES2Program (void) |
| { |
| } |
| |
| void setup (void) const |
| { |
| glUseProgram(m_program); |
| glEnableVertexAttribArray(m_positionLoc); |
| glEnableVertexAttribArray(m_colorLoc); |
| GLU_CHECK_MSG("Program setup failed"); |
| } |
| |
| int getPositionLoc (void) const { return m_positionLoc; } |
| int getColorLoc (void) const { return m_colorLoc; } |
| |
| private: |
| deUint32 m_program; |
| deUint32 m_vertexShader; |
| deUint32 m_fragmentShader; |
| int m_positionLoc; |
| int m_colorLoc; |
| }; |
| |
| void clearGLES2 (const tcu::Vec4& color, const float depth, const int stencil) |
| { |
| glClearColor(color.x(), color.y(), color.z(), color.w()); |
| glClearDepthf(depth); |
| glClearStencil(stencil); |
| glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); |
| } |
| |
| void drawGLES2 (const Program& program, const DrawPrimitiveOp& drawOp) |
| { |
| const GLES2Program& gles2Program = dynamic_cast<const GLES2Program&>(program); |
| |
| switch (drawOp.blend) |
| { |
| case BLENDMODE_NONE: |
| glDisable(GL_BLEND); |
| break; |
| |
| case BLENDMODE_ADDITIVE: |
| glEnable(GL_BLEND); |
| glBlendFunc(GL_ONE, GL_ONE); |
| break; |
| |
| case BLENDMODE_SRC_OVER: |
| glEnable(GL_BLEND); |
| glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| switch (drawOp.depth) |
| { |
| case DEPTHMODE_NONE: |
| glDisable(GL_DEPTH_TEST); |
| break; |
| |
| case DEPTHMODE_LESS: |
| glEnable(GL_DEPTH_TEST); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| switch (drawOp.stencil) |
| { |
| case STENCILMODE_NONE: |
| glDisable(GL_STENCIL_TEST); |
| break; |
| |
| case STENCILMODE_LEQUAL_INC: |
| glEnable(GL_STENCIL_TEST); |
| glStencilFunc(GL_LEQUAL, drawOp.stencilRef, ~0u); |
| glStencilOp(GL_KEEP, GL_INCR, GL_INCR); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| glVertexAttribPointer(gles2Program.getPositionLoc(), 4, GL_FLOAT, GL_FALSE, 0, &drawOp.positions[0]); |
| glVertexAttribPointer(gles2Program.getColorLoc(), 4, GL_FLOAT, GL_FALSE, 0, &drawOp.colors[0]); |
| |
| DE_ASSERT(drawOp.type == PRIMITIVETYPE_TRIANGLE); |
| glDrawArrays(GL_TRIANGLES, 0, drawOp.count*3); |
| } |
| |
| static void readPixelsGLES2 (tcu::Surface& dst) |
| { |
| glReadPixels(0, 0, dst.getWidth(), dst.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, dst.getAccess().getDataPtr()); |
| } |
| |
| #endif |
| |
| Program* createProgram (EGLint api) |
| { |
| switch (api) |
| { |
| #if defined(DEQP_SUPPORT_GLES2) || defined(DEQP_SUPPORT_GLES3) |
| case EGL_OPENGL_ES2_BIT: return new GLES2Program(); |
| case EGL_OPENGL_ES3_BIT_KHR: return new GLES2Program(); |
| #endif |
| default: |
| throw tcu::NotSupportedError("Unsupported API"); |
| } |
| } |
| |
| void draw (EGLint api, const Program& program, const DrawPrimitiveOp& drawOp) |
| { |
| switch (api) |
| { |
| #if defined(DEQP_SUPPORT_GLES2) || defined(DEQP_SUPPORT_GLES3) |
| case EGL_OPENGL_ES2_BIT: drawGLES2(program, drawOp); break; |
| case EGL_OPENGL_ES3_BIT_KHR: drawGLES2(program, drawOp); break; |
| #endif |
| default: |
| throw tcu::NotSupportedError("Unsupported API"); |
| } |
| } |
| |
| void clear (EGLint api, const tcu::Vec4& color, const float depth, const int stencil) |
| { |
| switch (api) |
| { |
| #if defined(DEQP_SUPPORT_GLES2) || defined(DEQP_SUPPORT_GLES3) |
| case EGL_OPENGL_ES2_BIT: clearGLES2(color, depth, stencil); break; |
| case EGL_OPENGL_ES3_BIT_KHR: clearGLES2(color, depth, stencil); break; |
| #endif |
| default: |
| throw tcu::NotSupportedError("Unsupported API"); |
| } |
| } |
| |
| static void readPixels (EGLint api, tcu::Surface& dst) |
| { |
| switch (api) |
| { |
| #if defined(DEQP_SUPPORT_GLES2) || defined(DEQP_SUPPORT_GLES3) |
| case EGL_OPENGL_ES2_BIT: readPixelsGLES2(dst); break; |
| case EGL_OPENGL_ES3_BIT_KHR: readPixelsGLES2(dst); break; |
| #endif |
| default: |
| throw tcu::NotSupportedError("Unsupported API"); |
| } |
| } |
| |
| tcu::PixelFormat getPixelFormat (const tcu::egl::Display& display, EGLConfig config) |
| { |
| tcu::PixelFormat fmt; |
| display.describeConfig(config, fmt); |
| return fmt; |
| } |
| |
| } // anonymous |
| |
| // SingleThreadRenderCase |
| |
| class SingleThreadRenderCase : public MultiContextRenderCase |
| { |
| public: |
| SingleThreadRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const std::vector<EGLint>& configIds, int numContextsPerApi); |
| |
| private: |
| virtual void executeForContexts (tcu::egl::Display& display, tcu::egl::Surface& surface, EGLConfig config, const std::vector<std::pair<EGLint, tcu::egl::Context*> >& contexts); |
| }; |
| |
| // SingleThreadColorClearCase |
| |
| SingleThreadRenderCase::SingleThreadRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const std::vector<EGLint>& configIds, int numContextsPerApi) |
| : MultiContextRenderCase(eglTestCtx, name, description, api, surfaceType, configIds, numContextsPerApi) |
| { |
| } |
| |
| void SingleThreadRenderCase::executeForContexts (tcu::egl::Display& display, tcu::egl::Surface& surface, EGLConfig config, const std::vector<std::pair<EGLint, tcu::egl::Context*> >& contexts) |
| { |
| const int width = surface.getWidth(); |
| const int height = surface.getHeight(); |
| const int numContexts = (int)contexts.size(); |
| const int drawsPerCtx = 2; |
| const int numIters = 2; |
| const float threshold = 0.02f; |
| |
| const tcu::PixelFormat pixelFmt = getPixelFormat(display, config); |
| const int depthBits = display.getConfigAttrib(config, EGL_DEPTH_SIZE); |
| const int stencilBits = display.getConfigAttrib(config, EGL_STENCIL_SIZE); |
| const int numSamples = display.getConfigAttrib(config, EGL_SAMPLES); |
| |
| TestLog& log = m_testCtx.getLog(); |
| |
| tcu::Surface refFrame (width, height); |
| tcu::Surface frame (width, height); |
| |
| de::Random rnd (deStringHash(getName()) ^ deInt32Hash(numContexts)); |
| vector<ProgramSp> programs (contexts.size()); |
| vector<DrawPrimitiveOp> drawOps; |
| |
| // Log basic information about config. |
| log << TestLog::Message << "EGL_RED_SIZE = " << pixelFmt.redBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_GREEN_SIZE = " << pixelFmt.greenBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_BLUE_SIZE = " << pixelFmt.blueBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_ALPHA_SIZE = " << pixelFmt.alphaBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_DEPTH_SIZE = " << depthBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_STENCIL_SIZE = " << stencilBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_SAMPLES = " << numSamples << TestLog::EndMessage; |
| |
| // Generate draw ops. |
| drawOps.resize(numContexts*drawsPerCtx*numIters); |
| for (vector<DrawPrimitiveOp>::iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); ++drawOp) |
| randomizeDrawOp(rnd, *drawOp); |
| |
| // Create and setup programs per context |
| for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++) |
| { |
| EGLint api = contexts[ctxNdx].first; |
| tcu::egl::Context* context = contexts[ctxNdx].second; |
| |
| eglMakeCurrent(display.getEGLDisplay(), surface.getEGLSurface(), surface.getEGLSurface(), context->getEGLContext()); |
| TCU_CHECK_EGL(); |
| |
| programs[ctxNdx] = ProgramSp(createProgram(api)); |
| programs[ctxNdx]->setup(); |
| } |
| |
| // Clear to black using first context. |
| { |
| EGLint api = contexts[0].first; |
| tcu::egl::Context* context = contexts[0].second; |
| |
| eglMakeCurrent(display.getEGLDisplay(), surface.getEGLSurface(), surface.getEGLSurface(), context->getEGLContext()); |
| TCU_CHECK_EGL(); |
| |
| clear(api, CLEAR_COLOR, CLEAR_DEPTH, CLEAR_STENCIL); |
| } |
| |
| // Render. |
| for (int iterNdx = 0; iterNdx < numIters; iterNdx++) |
| { |
| for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++) |
| { |
| EGLint api = contexts[ctxNdx].first; |
| tcu::egl::Context* context = contexts[ctxNdx].second; |
| |
| eglMakeCurrent(display.getEGLDisplay(), surface.getEGLSurface(), surface.getEGLSurface(), context->getEGLContext()); |
| TCU_CHECK_EGL(); |
| |
| for (int drawNdx = 0; drawNdx < drawsPerCtx; drawNdx++) |
| { |
| const DrawPrimitiveOp& drawOp = drawOps[iterNdx*numContexts*drawsPerCtx + ctxNdx*drawsPerCtx + drawNdx]; |
| draw(api, *programs[ctxNdx], drawOp); |
| } |
| } |
| } |
| |
| // Read pixels using first context. \todo [pyry] Randomize? |
| { |
| EGLint api = contexts[0].first; |
| tcu::egl::Context* context = contexts[0].second; |
| |
| eglMakeCurrent(display.getEGLDisplay(), surface.getEGLSurface(), surface.getEGLSurface(), context->getEGLContext()); |
| TCU_CHECK_EGL(); |
| |
| readPixels(api, frame); |
| } |
| |
| // Render reference. |
| // \note Reference image is always generated using single-sampling. |
| renderReference(refFrame.getAccess(), drawOps, pixelFmt, depthBits, stencilBits, 1); |
| |
| // Compare images |
| { |
| bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, frame, threshold, tcu::COMPARE_LOG_RESULT); |
| |
| if (!imagesOk) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); |
| } |
| } |
| |
| // MultiThreadRenderCase |
| |
| class MultiThreadRenderCase : public MultiContextRenderCase |
| { |
| public: |
| MultiThreadRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const std::vector<EGLint>& configIds, int numContextsPerApi); |
| |
| private: |
| virtual void executeForContexts (tcu::egl::Display& display, tcu::egl::Surface& surface, EGLConfig config, const std::vector<std::pair<EGLint, tcu::egl::Context*> >& contexts); |
| }; |
| |
| class RenderTestThread; |
| |
| typedef de::SharedPtr<RenderTestThread> RenderTestThreadSp; |
| typedef de::SharedPtr<de::Semaphore> SemaphoreSp; |
| |
| struct DrawOpPacket |
| { |
| DrawOpPacket (void) |
| : drawOps (DE_NULL) |
| , numOps (0) |
| { |
| } |
| |
| const DrawPrimitiveOp* drawOps; |
| int numOps; |
| SemaphoreSp wait; |
| SemaphoreSp signal; |
| }; |
| |
| class RenderTestThread : public de::Thread |
| { |
| public: |
| RenderTestThread (tcu::egl::Display& display, tcu::egl::Surface& surface, tcu::egl::Context& context, EGLint api, const Program& program, const std::vector<DrawOpPacket>& packets) |
| : m_display (display) |
| , m_surface (surface) |
| , m_context (context) |
| , m_api (api) |
| , m_program (program) |
| , m_packets (packets) |
| { |
| } |
| |
| void run (void) |
| { |
| for (std::vector<DrawOpPacket>::const_iterator packetIter = m_packets.begin(); packetIter != m_packets.end(); packetIter++) |
| { |
| // Wait until it is our turn. |
| packetIter->wait->decrement(); |
| |
| // Acquire context. |
| eglMakeCurrent(m_display.getEGLDisplay(), m_surface.getEGLSurface(), m_surface.getEGLSurface(), m_context.getEGLContext()); |
| |
| // Execute rendering. |
| for (int ndx = 0; ndx < packetIter->numOps; ndx++) |
| draw(m_api, m_program, packetIter->drawOps[ndx]); |
| |
| // Release context. |
| eglMakeCurrent(m_display.getEGLDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); |
| |
| // Signal completion. |
| packetIter->signal->increment(); |
| } |
| } |
| |
| private: |
| tcu::egl::Display& m_display; |
| tcu::egl::Surface& m_surface; |
| tcu::egl::Context& m_context; |
| EGLint m_api; |
| const Program& m_program; |
| const std::vector<DrawOpPacket>& m_packets; |
| }; |
| |
| MultiThreadRenderCase::MultiThreadRenderCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLint api, EGLint surfaceType, const std::vector<EGLint>& configIds, int numContextsPerApi) |
| : MultiContextRenderCase(eglTestCtx, name, description, api, surfaceType, configIds, numContextsPerApi) |
| { |
| } |
| |
| void MultiThreadRenderCase::executeForContexts (tcu::egl::Display& display, tcu::egl::Surface& surface, EGLConfig config, const std::vector<std::pair<EGLint, tcu::egl::Context*> >& contexts) |
| { |
| const int width = surface.getWidth(); |
| const int height = surface.getHeight(); |
| const int numContexts = (int)contexts.size(); |
| const int opsPerPacket = 2; |
| const int packetsPerThread = 2; |
| const int numThreads = numContexts; |
| const int numPackets = numThreads * packetsPerThread; |
| const float threshold = 0.02f; |
| |
| const tcu::PixelFormat pixelFmt = getPixelFormat(display, config); |
| const int depthBits = display.getConfigAttrib(config, EGL_DEPTH_SIZE); |
| const int stencilBits = display.getConfigAttrib(config, EGL_STENCIL_SIZE); |
| const int numSamples = display.getConfigAttrib(config, EGL_SAMPLES); |
| |
| TestLog& log = m_testCtx.getLog(); |
| |
| tcu::Surface refFrame (width, height); |
| tcu::Surface frame (width, height); |
| |
| de::Random rnd (deStringHash(getName()) ^ deInt32Hash(numContexts)); |
| |
| // Resources that need cleanup |
| vector<ProgramSp> programs (numContexts); |
| vector<SemaphoreSp> semaphores (numPackets+1); |
| vector<DrawPrimitiveOp> drawOps (numPackets*opsPerPacket); |
| vector<vector<DrawOpPacket> > packets (numThreads); |
| vector<RenderTestThreadSp> threads (numThreads); |
| |
| // Log basic information about config. |
| log << TestLog::Message << "EGL_RED_SIZE = " << pixelFmt.redBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_GREEN_SIZE = " << pixelFmt.greenBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_BLUE_SIZE = " << pixelFmt.blueBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_ALPHA_SIZE = " << pixelFmt.alphaBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_DEPTH_SIZE = " << depthBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_STENCIL_SIZE = " << stencilBits << TestLog::EndMessage; |
| log << TestLog::Message << "EGL_SAMPLES = " << numSamples << TestLog::EndMessage; |
| |
| // Initialize semaphores. |
| for (vector<SemaphoreSp>::iterator sem = semaphores.begin(); sem != semaphores.end(); ++sem) |
| *sem = SemaphoreSp(new de::Semaphore(0)); |
| |
| // Create draw ops. |
| for (vector<DrawPrimitiveOp>::iterator drawOp = drawOps.begin(); drawOp != drawOps.end(); ++drawOp) |
| randomizeDrawOp(rnd, *drawOp); |
| |
| // Create packets. |
| for (int threadNdx = 0; threadNdx < numThreads; threadNdx++) |
| { |
| packets[threadNdx].resize(packetsPerThread); |
| |
| for (int packetNdx = 0; packetNdx < packetsPerThread; packetNdx++) |
| { |
| DrawOpPacket& packet = packets[threadNdx][packetNdx]; |
| |
| // Threads take turns with packets. |
| packet.wait = semaphores[packetNdx*numThreads + threadNdx]; |
| packet.signal = semaphores[packetNdx*numThreads + threadNdx + 1]; |
| packet.numOps = opsPerPacket; |
| packet.drawOps = &drawOps[(packetNdx*numThreads + threadNdx)*opsPerPacket]; |
| } |
| } |
| |
| // Create and setup programs per context |
| for (int ctxNdx = 0; ctxNdx < numContexts; ctxNdx++) |
| { |
| EGLint api = contexts[ctxNdx].first; |
| tcu::egl::Context* context = contexts[ctxNdx].second; |
| |
| eglMakeCurrent(display.getEGLDisplay(), surface.getEGLSurface(), surface.getEGLSurface(), context->getEGLContext()); |
| TCU_CHECK_EGL(); |
| |
| programs[ctxNdx] = ProgramSp(createProgram(api)); |
| programs[ctxNdx]->setup(); |
| |
| // Release context |
| eglMakeCurrent(display.getEGLDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); |
| } |
| |
| // Clear to black using first context. |
| { |
| EGLint api = contexts[0].first; |
| tcu::egl::Context* context = contexts[0].second; |
| |
| eglMakeCurrent(display.getEGLDisplay(), surface.getEGLSurface(), surface.getEGLSurface(), context->getEGLContext()); |
| TCU_CHECK_EGL(); |
| |
| clear(api, CLEAR_COLOR, CLEAR_DEPTH, CLEAR_STENCIL); |
| |
| // Release context |
| eglMakeCurrent(display.getEGLDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); |
| } |
| |
| // Create and launch threads (actual rendering starts once first semaphore is signaled). |
| for (int threadNdx = 0; threadNdx < numThreads; threadNdx++) |
| { |
| threads[threadNdx] = RenderTestThreadSp(new RenderTestThread(display, surface, *contexts[threadNdx].second, contexts[threadNdx].first, *programs[threadNdx], packets[threadNdx])); |
| threads[threadNdx]->start(); |
| } |
| |
| // Signal start and wait until complete. |
| semaphores.front()->increment(); |
| semaphores.back()->decrement(); |
| |
| // Read pixels using first context. \todo [pyry] Randomize? |
| { |
| EGLint api = contexts[0].first; |
| tcu::egl::Context* context = contexts[0].second; |
| |
| eglMakeCurrent(display.getEGLDisplay(), surface.getEGLSurface(), surface.getEGLSurface(), context->getEGLContext()); |
| TCU_CHECK_EGL(); |
| |
| readPixels(api, frame); |
| } |
| |
| // Join threads. |
| for (int threadNdx = 0; threadNdx < numThreads; threadNdx++) |
| threads[threadNdx]->join(); |
| |
| // Render reference. |
| renderReference(refFrame.getAccess(), drawOps, pixelFmt, depthBits, stencilBits, 1); |
| |
| // Compare images |
| { |
| bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, frame, threshold, tcu::COMPARE_LOG_RESULT); |
| |
| if (!imagesOk) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); |
| } |
| } |
| |
| RenderTests::RenderTests (EglTestContext& eglTestCtx) |
| : TestCaseGroup(eglTestCtx, "render", "Basic rendering with different client APIs") |
| { |
| } |
| |
| RenderTests::~RenderTests (void) |
| { |
| } |
| |
| struct RenderGroupSpec |
| { |
| const char* name; |
| const char* desc; |
| EGLint apiBits; |
| int numContextsPerApi; |
| }; |
| |
| template <class RenderClass> |
| static void createRenderGroups (EglTestContext& eglTestCtx, tcu::TestCaseGroup* group, const RenderGroupSpec* first, const RenderGroupSpec* last) |
| { |
| for (const RenderGroupSpec* groupIter = first; groupIter != last; groupIter++) |
| { |
| tcu::TestCaseGroup* configGroup = new tcu::TestCaseGroup(eglTestCtx.getTestContext(), groupIter->name, groupIter->desc); |
| group->addChild(configGroup); |
| |
| vector<RenderConfigIdSet> configSets; |
| eglu::FilterList filters; |
| filters << (eglu::ConfigRenderableType() & groupIter->apiBits); |
| getDefaultRenderConfigIdSets(configSets, eglTestCtx.getConfigs(), filters); |
| |
| for (vector<RenderConfigIdSet>::const_iterator setIter = configSets.begin(); setIter != configSets.end(); setIter++) |
| configGroup->addChild(new RenderClass(eglTestCtx, setIter->getName(), "", groupIter->apiBits, setIter->getSurfaceTypeMask(), setIter->getConfigIds(), groupIter->numContextsPerApi)); |
| } |
| } |
| |
| void RenderTests::init (void) |
| { |
| static const RenderGroupSpec singleContextCases[] = |
| { |
| // { "gles1", "Primitive rendering using GLES1", EGL_OPENGL_ES_BIT, 1 }, |
| { "gles2", "Primitive rendering using GLES2", EGL_OPENGL_ES2_BIT, 1 }, |
| { "gles3", "Primitive rendering using GLES3", EGL_OPENGL_ES3_BIT_KHR, 1 }, |
| // { "vg", "Primitive rendering using OpenVG", EGL_OPENVG_BIT, 1 } |
| }; |
| |
| static const RenderGroupSpec multiContextCases[] = |
| { |
| // { "gles1", "Primitive rendering using multiple GLES1 contexts to shared surface", EGL_OPENGL_ES_BIT, 3 }, |
| { "gles2", "Primitive rendering using multiple GLES2 contexts to shared surface", EGL_OPENGL_ES2_BIT, 3 }, |
| { "gles3", "Primitive rendering using multiple GLES3 contexts to shared surface", EGL_OPENGL_ES3_BIT_KHR, 3 }, |
| // { "vg", "Primitive rendering using multiple OpenVG contexts to shared surface", EGL_OPENVG_BIT, 3 }, |
| // { "gles1_gles2", "Primitive rendering using multiple APIs to shared surface", EGL_OPENGL_ES_BIT|EGL_OPENGL_ES2_BIT, 1 }, |
| // { "gles1_gles2_gles3", "Primitive rendering using multiple APIs to shared surface", EGL_OPENGL_ES_BIT|EGL_OPENGL_ES2_BIT|EGL_OPENGL_ES3_BIT_KHR, 1 }, |
| { "gles2_gles3", "Primitive rendering using multiple APIs to shared surface", EGL_OPENGL_ES2_BIT|EGL_OPENGL_ES3_BIT_KHR, 1 }, |
| // { "gles1_vg", "Primitive rendering using multiple APIs to shared surface", EGL_OPENGL_ES_BIT|EGL_OPENVG_BIT, 1 }, |
| // { "gles2_vg", "Primitive rendering using multiple APIs to shared surface", EGL_OPENGL_ES2_BIT|EGL_OPENVG_BIT, 1 }, |
| // { "gles3_vg", "Primitive rendering using multiple APIs to shared surface", EGL_OPENGL_ES3_BIT_KHR|EGL_OPENVG_BIT, 1 }, |
| // { "gles1_gles2_vg", "Primitive rendering using multiple APIs to shared surface", EGL_OPENGL_ES_BIT|EGL_OPENGL_ES2_BIT|EGL_OPENVG_BIT, 1 } |
| }; |
| |
| tcu::TestCaseGroup* singleContextGroup = new tcu::TestCaseGroup(m_testCtx, "single_context", "Single-context rendering"); |
| addChild(singleContextGroup); |
| createRenderGroups<SingleThreadRenderCase>(m_eglTestCtx, singleContextGroup, &singleContextCases[0], &singleContextCases[DE_LENGTH_OF_ARRAY(singleContextCases)]); |
| |
| tcu::TestCaseGroup* multiContextGroup = new tcu::TestCaseGroup(m_testCtx, "multi_context", "Multi-context rendering with shared surface"); |
| addChild(multiContextGroup); |
| createRenderGroups<SingleThreadRenderCase>(m_eglTestCtx, multiContextGroup, &multiContextCases[0], &multiContextCases[DE_LENGTH_OF_ARRAY(multiContextCases)]); |
| |
| tcu::TestCaseGroup* multiThreadGroup = new tcu::TestCaseGroup(m_testCtx, "multi_thread", "Multi-thread rendering with shared surface"); |
| addChild(multiThreadGroup); |
| createRenderGroups<MultiThreadRenderCase>(m_eglTestCtx, multiThreadGroup, &multiContextCases[0], &multiContextCases[DE_LENGTH_OF_ARRAY(multiContextCases)]); |
| } |
| |
| } // egl |
| } // deqp |