| /*------------------------------------------------------------------------- |
| * 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 Fragment shader output tests. |
| * |
| * \todo [2012-04-10 pyry] Missing: |
| * + non-contiguous attachments in framebuffer |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3fFragmentOutputTests.hpp" |
| #include "gluShaderUtil.hpp" |
| #include "gluShaderProgram.hpp" |
| #include "gluTextureUtil.hpp" |
| #include "gluStrUtil.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuTexture.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuVector.hpp" |
| #include "tcuVectorUtil.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "deRandom.hpp" |
| #include "deStringUtil.hpp" |
| #include "deMath.h" |
| |
| // For getFormatName() \todo [pyry] Move to glu? |
| #include "es3fFboTestUtil.hpp" |
| |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| |
| using FboTestUtil::getFormatName; |
| using FboTestUtil::getFramebufferReadFormat; |
| using std::string; |
| using std::vector; |
| using tcu::BVec4; |
| using tcu::IVec2; |
| using tcu::IVec4; |
| using tcu::TestLog; |
| using tcu::UVec2; |
| using tcu::UVec4; |
| using tcu::Vec2; |
| using tcu::Vec3; |
| using tcu::Vec4; |
| |
| struct BufferSpec |
| { |
| BufferSpec(void) : format(GL_NONE), width(0), height(0), samples(0) |
| { |
| } |
| |
| BufferSpec(uint32_t format_, int width_, int height_, int samples_) |
| : format(format_) |
| , width(width_) |
| , height(height_) |
| , samples(samples_) |
| { |
| } |
| |
| uint32_t format; |
| int width; |
| int height; |
| int samples; |
| }; |
| |
| struct FragmentOutput |
| { |
| FragmentOutput(void) : type(glu::TYPE_LAST), precision(glu::PRECISION_LAST), location(0), arrayLength(0) |
| { |
| } |
| |
| FragmentOutput(glu::DataType type_, glu::Precision precision_, int location_, int arrayLength_ = 0) |
| : type(type_) |
| , precision(precision_) |
| , location(location_) |
| , arrayLength(arrayLength_) |
| { |
| } |
| |
| glu::DataType type; |
| glu::Precision precision; |
| int location; |
| int arrayLength; //!< 0 if not an array. |
| }; |
| |
| struct OutputVec |
| { |
| vector<FragmentOutput> outputs; |
| |
| OutputVec &operator<<(const FragmentOutput &output) |
| { |
| outputs.push_back(output); |
| return *this; |
| } |
| |
| vector<FragmentOutput> toVec(void) const |
| { |
| return outputs; |
| } |
| }; |
| |
| class FragmentOutputCase : public TestCase |
| { |
| public: |
| FragmentOutputCase(Context &context, const char *name, const char *desc, const vector<BufferSpec> &fboSpec, |
| const vector<FragmentOutput> &outputs); |
| ~FragmentOutputCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| FragmentOutputCase(const FragmentOutputCase &other); |
| FragmentOutputCase &operator=(const FragmentOutputCase &other); |
| |
| vector<BufferSpec> m_fboSpec; |
| vector<FragmentOutput> m_outputs; |
| |
| glu::ShaderProgram *m_program; |
| uint32_t m_framebuffer; |
| vector<uint32_t> m_renderbuffers; |
| }; |
| |
| FragmentOutputCase::FragmentOutputCase(Context &context, const char *name, const char *desc, |
| const vector<BufferSpec> &fboSpec, const vector<FragmentOutput> &outputs) |
| : TestCase(context, name, desc) |
| , m_fboSpec(fboSpec) |
| , m_outputs(outputs) |
| , m_program(DE_NULL) |
| , m_framebuffer(0) |
| { |
| } |
| |
| FragmentOutputCase::~FragmentOutputCase(void) |
| { |
| deinit(); |
| } |
| |
| static glu::ShaderProgram *createProgram(const glu::RenderContext &context, const vector<FragmentOutput> &outputs) |
| { |
| std::ostringstream vtx; |
| std::ostringstream frag; |
| |
| vtx << "#version 300 es\n" |
| << "in highp vec4 a_position;\n"; |
| frag << "#version 300 es\n"; |
| |
| // Input-output declarations. |
| for (int outNdx = 0; outNdx < (int)outputs.size(); outNdx++) |
| { |
| const FragmentOutput &output = outputs[outNdx]; |
| bool isArray = output.arrayLength > 0; |
| const char *typeName = glu::getDataTypeName(output.type); |
| const char *outputPrec = glu::getPrecisionName(output.precision); |
| bool isFloat = glu::isDataTypeFloatOrVec(output.type); |
| const char *interp = isFloat ? "smooth" : "flat"; |
| const char *interpPrec = isFloat ? "highp" : outputPrec; |
| |
| if (isArray) |
| { |
| for (int elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) |
| { |
| vtx << "in " << interpPrec << " " << typeName << " in" << outNdx << "_" << elemNdx << ";\n" |
| << interp << " out " << interpPrec << " " << typeName << " var" << outNdx << "_" << elemNdx |
| << ";\n"; |
| frag << interp << " in " << interpPrec << " " << typeName << " var" << outNdx << "_" << elemNdx |
| << ";\n"; |
| } |
| frag << "layout(location = " << output.location << ") out " << outputPrec << " " << typeName << " out" |
| << outNdx << "[" << output.arrayLength << "];\n"; |
| } |
| else |
| { |
| vtx << "in " << interpPrec << " " << typeName << " in" << outNdx << ";\n" |
| << interp << " out " << interpPrec << " " << typeName << " var" << outNdx << ";\n"; |
| frag << interp << " in " << interpPrec << " " << typeName << " var" << outNdx << ";\n" |
| << "layout(location = " << output.location << ") out " << outputPrec << " " << typeName << " out" |
| << outNdx << ";\n"; |
| } |
| } |
| |
| vtx << "\nvoid main()\n{\n"; |
| frag << "\nvoid main()\n{\n"; |
| |
| vtx << " gl_Position = a_position;\n"; |
| |
| // Copy body |
| for (int outNdx = 0; outNdx < (int)outputs.size(); outNdx++) |
| { |
| const FragmentOutput &output = outputs[outNdx]; |
| bool isArray = output.arrayLength > 0; |
| |
| if (isArray) |
| { |
| for (int elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) |
| { |
| vtx << "\tvar" << outNdx << "_" << elemNdx << " = in" << outNdx << "_" << elemNdx << ";\n"; |
| frag << "\tout" << outNdx << "[" << elemNdx << "] = var" << outNdx << "_" << elemNdx << ";\n"; |
| } |
| } |
| else |
| { |
| vtx << "\tvar" << outNdx << " = in" << outNdx << ";\n"; |
| frag << "\tout" << outNdx << " = var" << outNdx << ";\n"; |
| } |
| } |
| |
| vtx << "}\n"; |
| frag << "}\n"; |
| |
| return new glu::ShaderProgram(context, glu::makeVtxFragSources(vtx.str(), frag.str())); |
| } |
| |
| void FragmentOutputCase::init(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| TestLog &log = m_testCtx.getLog(); |
| |
| // Check that all attachments are supported |
| for (std::vector<BufferSpec>::const_iterator bufIter = m_fboSpec.begin(); bufIter != m_fboSpec.end(); ++bufIter) |
| { |
| if (!glu::isSizedFormatColorRenderable(m_context.getRenderContext(), m_context.getContextInfo(), |
| bufIter->format)) |
| throw tcu::NotSupportedError("Unsupported attachment format"); |
| } |
| |
| DE_ASSERT(!m_program); |
| m_program = createProgram(m_context.getRenderContext(), m_outputs); |
| |
| log << *m_program; |
| if (!m_program->isOk()) |
| TCU_FAIL("Compile failed"); |
| |
| // Print render target info to log. |
| log << TestLog::Section("Framebuffer", "Framebuffer configuration"); |
| |
| for (int ndx = 0; ndx < (int)m_fboSpec.size(); ndx++) |
| log << TestLog::Message << "COLOR_ATTACHMENT" << ndx << ": " << glu::getTextureFormatStr(m_fboSpec[ndx].format) |
| << ", " << m_fboSpec[ndx].width << "x" << m_fboSpec[ndx].height << ", " << m_fboSpec[ndx].samples |
| << " samples" << TestLog::EndMessage; |
| |
| log << TestLog::EndSection; |
| |
| // Create framebuffer. |
| m_renderbuffers.resize(m_fboSpec.size(), 0); |
| gl.genFramebuffers(1, &m_framebuffer); |
| gl.genRenderbuffers((int)m_renderbuffers.size(), &m_renderbuffers[0]); |
| |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); |
| |
| for (int bufNdx = 0; bufNdx < (int)m_renderbuffers.size(); bufNdx++) |
| { |
| uint32_t rbo = m_renderbuffers[bufNdx]; |
| const BufferSpec &bufSpec = m_fboSpec[bufNdx]; |
| uint32_t attachment = GL_COLOR_ATTACHMENT0 + bufNdx; |
| |
| gl.bindRenderbuffer(GL_RENDERBUFFER, rbo); |
| gl.renderbufferStorageMultisample(GL_RENDERBUFFER, bufSpec.samples, bufSpec.format, bufSpec.width, |
| bufSpec.height); |
| gl.framebufferRenderbuffer(GL_FRAMEBUFFER, attachment, GL_RENDERBUFFER, rbo); |
| } |
| GLU_EXPECT_NO_ERROR(gl.getError(), "After framebuffer setup"); |
| |
| uint32_t fboStatus = gl.checkFramebufferStatus(GL_FRAMEBUFFER); |
| if (fboStatus == GL_FRAMEBUFFER_UNSUPPORTED) |
| throw tcu::NotSupportedError("Framebuffer not supported", "", __FILE__, __LINE__); |
| else if (fboStatus != GL_FRAMEBUFFER_COMPLETE) |
| throw tcu::TestError( |
| (string("Incomplete framebuffer: ") + glu::getFramebufferStatusStr(fboStatus).toString()).c_str(), "", |
| __FILE__, __LINE__); |
| |
| gl.bindFramebuffer(GL_FRAMEBUFFER, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "After init"); |
| } |
| |
| void FragmentOutputCase::deinit(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_framebuffer) |
| { |
| gl.deleteFramebuffers(1, &m_framebuffer); |
| m_framebuffer = 0; |
| } |
| |
| if (!m_renderbuffers.empty()) |
| { |
| gl.deleteRenderbuffers((int)m_renderbuffers.size(), &m_renderbuffers[0]); |
| m_renderbuffers.clear(); |
| } |
| |
| delete m_program; |
| m_program = DE_NULL; |
| } |
| |
| static IVec2 getMinSize(const vector<BufferSpec> &fboSpec) |
| { |
| IVec2 minSize(0x7fffffff, 0x7fffffff); |
| for (vector<BufferSpec>::const_iterator i = fboSpec.begin(); i != fboSpec.end(); i++) |
| { |
| minSize.x() = de::min(minSize.x(), i->width); |
| minSize.y() = de::min(minSize.y(), i->height); |
| } |
| return minSize; |
| } |
| |
| static int getNumInputVectors(const vector<FragmentOutput> &outputs) |
| { |
| int numVecs = 0; |
| for (vector<FragmentOutput>::const_iterator i = outputs.begin(); i != outputs.end(); i++) |
| numVecs += (i->arrayLength > 0 ? i->arrayLength : 1); |
| return numVecs; |
| } |
| |
| static Vec2 getFloatRange(glu::Precision precision) |
| { |
| // \todo [2012-04-09 pyry] Not quite the full ranges. |
| static const Vec2 ranges[] = {Vec2(-2.0f, 2.0f), Vec2(-16000.0f, 16000.0f), Vec2(-1e35f, 1e35f)}; |
| DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST); |
| DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges))); |
| return ranges[precision]; |
| } |
| |
| static IVec2 getIntRange(glu::Precision precision) |
| { |
| static const IVec2 ranges[] = {IVec2(-(1 << 7), (1 << 7) - 1), IVec2(-(1 << 15), (1 << 15) - 1), |
| IVec2(0x80000000, 0x7fffffff)}; |
| DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST); |
| DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges))); |
| return ranges[precision]; |
| } |
| |
| static UVec2 getUintRange(glu::Precision precision) |
| { |
| static const UVec2 ranges[] = {UVec2(0, (1 << 8) - 1), UVec2(0, (1 << 16) - 1), UVec2(0, 0xffffffffu)}; |
| DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST); |
| DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges))); |
| return ranges[precision]; |
| } |
| |
| static inline Vec4 readVec4(const float *ptr, int numComponents) |
| { |
| DE_ASSERT(numComponents >= 1); |
| return Vec4(ptr[0], numComponents >= 2 ? ptr[1] : 0.0f, numComponents >= 3 ? ptr[2] : 0.0f, |
| numComponents >= 4 ? ptr[3] : 0.0f); |
| } |
| |
| static inline IVec4 readIVec4(const int *ptr, int numComponents) |
| { |
| DE_ASSERT(numComponents >= 1); |
| return IVec4(ptr[0], numComponents >= 2 ? ptr[1] : 0, numComponents >= 3 ? ptr[2] : 0, |
| numComponents >= 4 ? ptr[3] : 0); |
| } |
| |
| static void renderFloatReference(const tcu::PixelBufferAccess &dst, int gridWidth, int gridHeight, int numComponents, |
| const float *vertices) |
| { |
| const bool isSRGB = tcu::isSRGB(dst.getFormat()); |
| const float cellW = (float)dst.getWidth() / (float)(gridWidth - 1); |
| const float cellH = (float)dst.getHeight() / (float)(gridHeight - 1); |
| |
| for (int y = 0; y < dst.getHeight(); y++) |
| { |
| for (int x = 0; x < dst.getWidth(); x++) |
| { |
| const int cellX = de::clamp(deFloorFloatToInt32((float)x / cellW), 0, gridWidth - 2); |
| const int cellY = de::clamp(deFloorFloatToInt32((float)y / cellH), 0, gridHeight - 2); |
| const float xf = ((float)x - (float)cellX * cellW + 0.5f) / cellW; |
| const float yf = ((float)y - (float)cellY * cellH + 0.5f) / cellH; |
| const Vec4 v00 = readVec4(vertices + ((cellY + 0) * gridWidth + cellX + 0) * numComponents, numComponents); |
| const Vec4 v01 = readVec4(vertices + ((cellY + 1) * gridWidth + cellX + 0) * numComponents, numComponents); |
| const Vec4 v10 = readVec4(vertices + ((cellY + 0) * gridWidth + cellX + 1) * numComponents, numComponents); |
| const Vec4 v11 = readVec4(vertices + ((cellY + 1) * gridWidth + cellX + 1) * numComponents, numComponents); |
| const bool tri = xf + yf >= 1.0f; |
| const Vec4 &v0 = tri ? v11 : v00; |
| const Vec4 &v1 = tri ? v01 : v10; |
| const Vec4 &v2 = tri ? v10 : v01; |
| const float s = tri ? 1.0f - xf : xf; |
| const float t = tri ? 1.0f - yf : yf; |
| const Vec4 color = v0 + (v1 - v0) * s + (v2 - v0) * t; |
| |
| dst.setPixel(isSRGB ? tcu::linearToSRGB(color) : color, x, y); |
| } |
| } |
| } |
| |
| static void renderIntReference(const tcu::PixelBufferAccess &dst, int gridWidth, int gridHeight, int numComponents, |
| const int *vertices) |
| { |
| float cellW = (float)dst.getWidth() / (float)(gridWidth - 1); |
| float cellH = (float)dst.getHeight() / (float)(gridHeight - 1); |
| |
| for (int y = 0; y < dst.getHeight(); y++) |
| { |
| for (int x = 0; x < dst.getWidth(); x++) |
| { |
| int cellX = de::clamp(deFloorFloatToInt32((float)x / cellW), 0, gridWidth - 2); |
| int cellY = de::clamp(deFloorFloatToInt32((float)y / cellH), 0, gridHeight - 2); |
| IVec4 c = readIVec4(vertices + (cellY * gridWidth + cellX + 1) * numComponents, numComponents); |
| |
| dst.setPixel(c, x, y); |
| } |
| } |
| } |
| |
| static const IVec4 s_swizzles[] = {IVec4(0, 1, 2, 3), IVec4(1, 2, 3, 0), IVec4(2, 3, 0, 1), IVec4(3, 0, 1, 2), |
| IVec4(3, 2, 1, 0), IVec4(2, 1, 0, 3), IVec4(1, 0, 3, 2), IVec4(0, 3, 2, 1)}; |
| |
| template <typename T> |
| inline tcu::Vector<T, 4> swizzleVec(const tcu::Vector<T, 4> &vec, int swzNdx) |
| { |
| const IVec4 &swz = s_swizzles[swzNdx % DE_LENGTH_OF_ARRAY(s_swizzles)]; |
| return vec.swizzle(swz[0], swz[1], swz[2], swz[3]); |
| } |
| |
| namespace |
| { |
| |
| struct AttachmentData |
| { |
| tcu::TextureFormat format; //!< Actual format of attachment. |
| tcu::TextureFormat referenceFormat; //!< Used for reference rendering. |
| tcu::TextureFormat readFormat; |
| int numWrittenChannels; |
| glu::Precision outPrecision; |
| vector<uint8_t> renderedData; |
| vector<uint8_t> referenceData; |
| }; |
| |
| template <typename Type> |
| string valueRangeToString(int numValidChannels, const tcu::Vector<Type, 4> &minValue, |
| const tcu::Vector<Type, 4> &maxValue) |
| { |
| std::ostringstream stream; |
| |
| stream << "("; |
| |
| for (int i = 0; i < 4; i++) |
| { |
| if (i != 0) |
| stream << ", "; |
| |
| if (i < numValidChannels) |
| stream << minValue[i] << " -> " << maxValue[i]; |
| else |
| stream << "Undef"; |
| } |
| |
| stream << ")"; |
| |
| return stream.str(); |
| } |
| |
| void clearUndefined(const tcu::PixelBufferAccess &access, int numValidChannels) |
| { |
| for (int y = 0; y < access.getHeight(); y++) |
| for (int x = 0; x < access.getWidth(); x++) |
| { |
| switch (tcu::getTextureChannelClass(access.getFormat().type)) |
| { |
| case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: |
| { |
| const Vec4 srcPixel = access.getPixel(x, y); |
| Vec4 dstPixel(0.0f, 0.0f, 0.0f, 1.0f); |
| |
| for (int channelNdx = 0; channelNdx < numValidChannels; channelNdx++) |
| dstPixel[channelNdx] = srcPixel[channelNdx]; |
| |
| access.setPixel(dstPixel, x, y); |
| break; |
| } |
| |
| case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: |
| case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: |
| case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: |
| case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: |
| { |
| const IVec4 bitDepth = tcu::getTextureFormatBitDepth(access.getFormat()); |
| const IVec4 srcPixel = access.getPixelInt(x, y); |
| IVec4 dstPixel(0, 0, 0, (int)(((int64_t)0x1u << bitDepth.w()) - 1)); |
| |
| for (int channelNdx = 0; channelNdx < numValidChannels; channelNdx++) |
| dstPixel[channelNdx] = srcPixel[channelNdx]; |
| |
| access.setPixel(dstPixel, x, y); |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| } |
| |
| } // namespace |
| |
| FragmentOutputCase::IterateResult FragmentOutputCase::iterate(void) |
| { |
| TestLog &log = m_testCtx.getLog(); |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| // Compute grid size & index list. |
| const int minCellSize = 8; |
| const IVec2 minBufSize = getMinSize(m_fboSpec); |
| const int gridWidth = de::clamp(minBufSize.x() / minCellSize, 1, 255) + 1; |
| const int gridHeight = de::clamp(minBufSize.y() / minCellSize, 1, 255) + 1; |
| const int numVertices = gridWidth * gridHeight; |
| const int numQuads = (gridWidth - 1) * (gridHeight - 1); |
| const int numIndices = numQuads * 6; |
| |
| const int numInputVecs = getNumInputVectors(m_outputs); |
| vector<vector<uint32_t>> inputs(numInputVecs); |
| vector<float> positions(numVertices * 4); |
| vector<uint16_t> indices(numIndices); |
| |
| const int readAlignment = 4; |
| const int viewportW = minBufSize.x(); |
| const int viewportH = minBufSize.y(); |
| const int numAttachments = (int)m_fboSpec.size(); |
| |
| vector<uint32_t> drawBuffers(numAttachments); |
| vector<AttachmentData> attachments(numAttachments); |
| |
| // Initialize attachment data. |
| for (int ndx = 0; ndx < numAttachments; ndx++) |
| { |
| const tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_fboSpec[ndx].format); |
| const tcu::TextureChannelClass chnClass = tcu::getTextureChannelClass(texFmt.type); |
| const bool isFixedPoint = chnClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT || |
| chnClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; |
| |
| // \note Fixed-point formats use float reference to enable more accurate result verification. |
| const tcu::TextureFormat refFmt = |
| isFixedPoint ? tcu::TextureFormat(texFmt.order, tcu::TextureFormat::FLOAT) : texFmt; |
| const tcu::TextureFormat readFmt = getFramebufferReadFormat(texFmt); |
| const int attachmentW = m_fboSpec[ndx].width; |
| const int attachmentH = m_fboSpec[ndx].height; |
| |
| drawBuffers[ndx] = GL_COLOR_ATTACHMENT0 + ndx; |
| attachments[ndx].format = texFmt; |
| attachments[ndx].readFormat = readFmt; |
| attachments[ndx].referenceFormat = refFmt; |
| attachments[ndx].renderedData.resize(readFmt.getPixelSize() * attachmentW * attachmentH); |
| attachments[ndx].referenceData.resize(refFmt.getPixelSize() * attachmentW * attachmentH); |
| } |
| |
| // Initialize indices. |
| for (int quadNdx = 0; quadNdx < numQuads; quadNdx++) |
| { |
| int quadY = quadNdx / (gridWidth - 1); |
| int quadX = quadNdx - quadY * (gridWidth - 1); |
| |
| indices[quadNdx * 6 + 0] = uint16_t(quadX + quadY * gridWidth); |
| indices[quadNdx * 6 + 1] = uint16_t(quadX + (quadY + 1) * gridWidth); |
| indices[quadNdx * 6 + 2] = uint16_t(quadX + quadY * gridWidth + 1); |
| indices[quadNdx * 6 + 3] = indices[quadNdx * 6 + 1]; |
| indices[quadNdx * 6 + 4] = uint16_t(quadX + (quadY + 1) * gridWidth + 1); |
| indices[quadNdx * 6 + 5] = indices[quadNdx * 6 + 2]; |
| } |
| |
| for (int y = 0; y < gridHeight; y++) |
| { |
| for (int x = 0; x < gridWidth; x++) |
| { |
| float xf = (float)x / (float)(gridWidth - 1); |
| float yf = (float)y / (float)(gridHeight - 1); |
| |
| positions[(y * gridWidth + x) * 4 + 0] = 2.0f * xf - 1.0f; |
| positions[(y * gridWidth + x) * 4 + 1] = 2.0f * yf - 1.0f; |
| positions[(y * gridWidth + x) * 4 + 2] = 0.0f; |
| positions[(y * gridWidth + x) * 4 + 3] = 1.0f; |
| } |
| } |
| |
| // Initialize input vectors. |
| { |
| int curInVec = 0; |
| for (int outputNdx = 0; outputNdx < (int)m_outputs.size(); outputNdx++) |
| { |
| const FragmentOutput &output = m_outputs[outputNdx]; |
| bool isFloat = glu::isDataTypeFloatOrVec(output.type); |
| bool isInt = glu::isDataTypeIntOrIVec(output.type); |
| bool isUint = glu::isDataTypeUintOrUVec(output.type); |
| int numVecs = output.arrayLength > 0 ? output.arrayLength : 1; |
| int numScalars = glu::getDataTypeScalarSize(output.type); |
| |
| for (int vecNdx = 0; vecNdx < numVecs; vecNdx++) |
| { |
| inputs[curInVec].resize(numVertices * numScalars); |
| |
| // Record how many outputs are written in attachment. |
| DE_ASSERT(output.location + vecNdx < (int)attachments.size()); |
| attachments[output.location + vecNdx].numWrittenChannels = numScalars; |
| attachments[output.location + vecNdx].outPrecision = output.precision; |
| |
| if (isFloat) |
| { |
| Vec2 range = getFloatRange(output.precision); |
| Vec4 minVal(range.x()); |
| Vec4 maxVal(range.y()); |
| float *dst = (float *)&inputs[curInVec][0]; |
| |
| if (de::inBounds(output.location + vecNdx, 0, (int)attachments.size())) |
| { |
| // \note Floating-point precision conversion is not well-defined. For that reason we must |
| // limit value range to intersection of both data type and render target value ranges. |
| const tcu::TextureFormatInfo fmtInfo = |
| tcu::getTextureFormatInfo(attachments[output.location + vecNdx].format); |
| minVal = tcu::max(minVal, fmtInfo.valueMin); |
| maxVal = tcu::min(maxVal, fmtInfo.valueMax); |
| } |
| |
| m_testCtx.getLog() << TestLog::Message << "out" << curInVec |
| << " value range: " << valueRangeToString(numScalars, minVal, maxVal) |
| << TestLog::EndMessage; |
| |
| for (int y = 0; y < gridHeight; y++) |
| { |
| for (int x = 0; x < gridWidth; x++) |
| { |
| float xf = (float)x / (float)(gridWidth - 1); |
| float yf = (float)y / (float)(gridHeight - 1); |
| |
| float f0 = (xf + yf) * 0.5f; |
| float f1 = 0.5f + (xf - yf) * 0.5f; |
| Vec4 f = swizzleVec(Vec4(f0, f1, 1.0f - f0, 1.0f - f1), curInVec); |
| Vec4 c = minVal + (maxVal - minVal) * f; |
| float *v = dst + (y * gridWidth + x) * numScalars; |
| |
| for (int ndx = 0; ndx < numScalars; ndx++) |
| v[ndx] = c[ndx]; |
| } |
| } |
| } |
| else if (isInt) |
| { |
| const IVec2 range = getIntRange(output.precision); |
| IVec4 minVal(range.x()); |
| IVec4 maxVal(range.y()); |
| |
| if (de::inBounds(output.location + vecNdx, 0, (int)attachments.size())) |
| { |
| // Limit to range of output format as conversion mode is not specified. |
| const IVec4 fmtBits = |
| tcu::getTextureFormatBitDepth(attachments[output.location + vecNdx].format); |
| const BVec4 isZero = lessThanEqual(fmtBits, IVec4(0)); |
| const IVec4 shift = tcu::clamp(fmtBits - 1, tcu::IVec4(0), tcu::IVec4(256)); |
| const IVec4 fmtMinVal = (-(tcu::Vector<int64_t, 4>(1) << shift.cast<int64_t>())).asInt(); |
| const IVec4 fmtMaxVal = |
| ((tcu::Vector<int64_t, 4>(1) << shift.cast<int64_t>()) - int64_t(1)).asInt(); |
| |
| minVal = select(minVal, tcu::max(minVal, fmtMinVal), isZero); |
| maxVal = select(maxVal, tcu::min(maxVal, fmtMaxVal), isZero); |
| } |
| |
| m_testCtx.getLog() << TestLog::Message << "out" << curInVec |
| << " value range: " << valueRangeToString(numScalars, minVal, maxVal) |
| << TestLog::EndMessage; |
| |
| const IVec4 rangeDiv = |
| swizzleVec((IVec4(gridWidth, gridHeight, gridWidth, gridHeight) - 1), curInVec); |
| const IVec4 step = |
| ((maxVal.cast<int64_t>() - minVal.cast<int64_t>()) / (rangeDiv.cast<int64_t>())).asInt(); |
| int32_t *dst = (int32_t *)&inputs[curInVec][0]; |
| |
| for (int y = 0; y < gridHeight; y++) |
| { |
| for (int x = 0; x < gridWidth; x++) |
| { |
| int ix = gridWidth - x - 1; |
| int iy = gridHeight - y - 1; |
| IVec4 c = minVal + step * swizzleVec(IVec4(x, y, ix, iy), curInVec); |
| int32_t *v = dst + (y * gridWidth + x) * numScalars; |
| |
| DE_ASSERT(boolAll(logicalAnd(greaterThanEqual(c, minVal), lessThanEqual(c, maxVal)))); |
| |
| for (int ndx = 0; ndx < numScalars; ndx++) |
| v[ndx] = c[ndx]; |
| } |
| } |
| } |
| else if (isUint) |
| { |
| const UVec2 range = getUintRange(output.precision); |
| UVec4 maxVal(range.y()); |
| |
| if (de::inBounds(output.location + vecNdx, 0, (int)attachments.size())) |
| { |
| // Limit to range of output format as conversion mode is not specified. |
| const IVec4 fmtBits = |
| tcu::getTextureFormatBitDepth(attachments[output.location + vecNdx].format); |
| const UVec4 fmtMaxVal = |
| ((tcu::Vector<uint64_t, 4>(1) << fmtBits.cast<uint64_t>()) - uint64_t(1)).asUint(); |
| |
| maxVal = tcu::min(maxVal, fmtMaxVal); |
| } |
| |
| m_testCtx.getLog() << TestLog::Message << "out" << curInVec |
| << " value range: " << valueRangeToString(numScalars, UVec4(0), maxVal) |
| << TestLog::EndMessage; |
| |
| const IVec4 rangeDiv = |
| swizzleVec((IVec4(gridWidth, gridHeight, gridWidth, gridHeight) - 1), curInVec); |
| const UVec4 step = maxVal / rangeDiv.asUint(); |
| uint32_t *dst = &inputs[curInVec][0]; |
| |
| DE_ASSERT(range.x() == 0); |
| |
| for (int y = 0; y < gridHeight; y++) |
| { |
| for (int x = 0; x < gridWidth; x++) |
| { |
| int ix = gridWidth - x - 1; |
| int iy = gridHeight - y - 1; |
| UVec4 c = step * swizzleVec(IVec4(x, y, ix, iy).asUint(), curInVec); |
| uint32_t *v = dst + (y * gridWidth + x) * numScalars; |
| |
| DE_ASSERT(boolAll(lessThanEqual(c, maxVal))); |
| |
| for (int ndx = 0; ndx < numScalars; ndx++) |
| v[ndx] = c[ndx]; |
| } |
| } |
| } |
| else |
| DE_ASSERT(false); |
| |
| curInVec += 1; |
| } |
| } |
| } |
| |
| // Render using gl. |
| gl.useProgram(m_program->getProgram()); |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); |
| gl.viewport(0, 0, viewportW, viewportH); |
| gl.drawBuffers((int)drawBuffers.size(), &drawBuffers[0]); |
| gl.disable( |
| GL_DITHER); // Dithering causes issues with unorm formats. Those issues could be worked around in threshold, but it makes validation less accurate. |
| GLU_EXPECT_NO_ERROR(gl.getError(), "After program setup"); |
| |
| { |
| int curInVec = 0; |
| for (int outputNdx = 0; outputNdx < (int)m_outputs.size(); outputNdx++) |
| { |
| const FragmentOutput &output = m_outputs[outputNdx]; |
| bool isArray = output.arrayLength > 0; |
| bool isFloat = glu::isDataTypeFloatOrVec(output.type); |
| bool isInt = glu::isDataTypeIntOrIVec(output.type); |
| bool isUint = glu::isDataTypeUintOrUVec(output.type); |
| int scalarSize = glu::getDataTypeScalarSize(output.type); |
| uint32_t glScalarType = isFloat ? GL_FLOAT : isInt ? GL_INT : isUint ? GL_UNSIGNED_INT : GL_NONE; |
| int numVecs = isArray ? output.arrayLength : 1; |
| |
| for (int vecNdx = 0; vecNdx < numVecs; vecNdx++) |
| { |
| string name = |
| string("in") + de::toString(outputNdx) + (isArray ? string("_") + de::toString(vecNdx) : string()); |
| int loc = gl.getAttribLocation(m_program->getProgram(), name.c_str()); |
| |
| if (loc >= 0) |
| { |
| gl.enableVertexAttribArray(loc); |
| if (isFloat) |
| gl.vertexAttribPointer(loc, scalarSize, glScalarType, GL_FALSE, 0, &inputs[curInVec][0]); |
| else |
| gl.vertexAttribIPointer(loc, scalarSize, glScalarType, 0, &inputs[curInVec][0]); |
| } |
| else |
| log << TestLog::Message << "Warning: No location for attribute '" << name << "' found." |
| << TestLog::EndMessage; |
| |
| curInVec += 1; |
| } |
| } |
| } |
| { |
| int posLoc = gl.getAttribLocation(m_program->getProgram(), "a_position"); |
| TCU_CHECK(posLoc >= 0); |
| gl.enableVertexAttribArray(posLoc); |
| gl.vertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, &positions[0]); |
| } |
| GLU_EXPECT_NO_ERROR(gl.getError(), "After attribute setup"); |
| |
| gl.drawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, &indices[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElements"); |
| |
| // Read all attachment points. |
| for (int ndx = 0; ndx < numAttachments; ndx++) |
| { |
| const glu::TransferFormat transferFmt = glu::getTransferFormat(attachments[ndx].readFormat); |
| void *dst = &attachments[ndx].renderedData[0]; |
| const int attachmentW = m_fboSpec[ndx].width; |
| const int attachmentH = m_fboSpec[ndx].height; |
| const int numValidChannels = attachments[ndx].numWrittenChannels; |
| const tcu::PixelBufferAccess rendered( |
| attachments[ndx].readFormat, attachmentW, attachmentH, 1, |
| deAlign32(attachments[ndx].readFormat.getPixelSize() * attachmentW, readAlignment), 0, |
| &attachments[ndx].renderedData[0]); |
| |
| gl.readBuffer(GL_COLOR_ATTACHMENT0 + ndx); |
| gl.readPixels(0, 0, minBufSize.x(), minBufSize.y(), transferFmt.format, transferFmt.dataType, dst); |
| |
| clearUndefined(rendered, numValidChannels); |
| } |
| |
| // Render reference images. |
| { |
| int curInNdx = 0; |
| for (int outputNdx = 0; outputNdx < (int)m_outputs.size(); outputNdx++) |
| { |
| const FragmentOutput &output = m_outputs[outputNdx]; |
| const bool isArray = output.arrayLength > 0; |
| const bool isFloat = glu::isDataTypeFloatOrVec(output.type); |
| const bool isInt = glu::isDataTypeIntOrIVec(output.type); |
| const bool isUint = glu::isDataTypeUintOrUVec(output.type); |
| const int scalarSize = glu::getDataTypeScalarSize(output.type); |
| const int numVecs = isArray ? output.arrayLength : 1; |
| |
| for (int vecNdx = 0; vecNdx < numVecs; vecNdx++) |
| { |
| const int location = output.location + vecNdx; |
| const void *inputData = &inputs[curInNdx][0]; |
| |
| DE_ASSERT(de::inBounds(location, 0, (int)m_fboSpec.size())); |
| |
| const int bufW = m_fboSpec[location].width; |
| const int bufH = m_fboSpec[location].height; |
| const tcu::PixelBufferAccess buf(attachments[location].referenceFormat, bufW, bufH, 1, |
| &attachments[location].referenceData[0]); |
| const tcu::PixelBufferAccess viewportBuf = getSubregion(buf, 0, 0, 0, viewportW, viewportH, 1); |
| |
| if (isInt || isUint) |
| renderIntReference(viewportBuf, gridWidth, gridHeight, scalarSize, (const int *)inputData); |
| else if (isFloat) |
| renderFloatReference(viewportBuf, gridWidth, gridHeight, scalarSize, (const float *)inputData); |
| else |
| DE_ASSERT(false); |
| |
| curInNdx += 1; |
| } |
| } |
| } |
| |
| // Compare all images. |
| bool allLevelsOk = true; |
| for (int attachNdx = 0; attachNdx < numAttachments; attachNdx++) |
| { |
| const int attachmentW = m_fboSpec[attachNdx].width; |
| const int attachmentH = m_fboSpec[attachNdx].height; |
| const int numValidChannels = attachments[attachNdx].numWrittenChannels; |
| const tcu::BVec4 cmpMask(numValidChannels >= 1, numValidChannels >= 2, numValidChannels >= 3, |
| numValidChannels >= 4); |
| const glu::Precision outPrecision = attachments[attachNdx].outPrecision; |
| const tcu::TextureFormat &format = attachments[attachNdx].format; |
| tcu::ConstPixelBufferAccess rendered( |
| attachments[attachNdx].readFormat, attachmentW, attachmentH, 1, |
| deAlign32(attachments[attachNdx].readFormat.getPixelSize() * attachmentW, readAlignment), 0, |
| &attachments[attachNdx].renderedData[0]); |
| tcu::ConstPixelBufferAccess reference(attachments[attachNdx].referenceFormat, attachmentW, attachmentH, 1, |
| &attachments[attachNdx].referenceData[0]); |
| tcu::TextureChannelClass texClass = tcu::getTextureChannelClass(format.type); |
| bool isOk = true; |
| const string name = string("Attachment") + de::toString(attachNdx); |
| const string desc = string("Color attachment ") + de::toString(attachNdx); |
| |
| log << TestLog::Message << "Attachment " << attachNdx << ": " << numValidChannels |
| << " channels have defined values and used for comparison" << TestLog::EndMessage; |
| |
| switch (texClass) |
| { |
| case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: |
| { |
| const uint32_t interpThreshold = 4; //!< 4 ULP interpolation threshold (interpolation always in highp) |
| uint32_t outTypeThreshold = 0; //!< Threshold based on output type |
| UVec4 formatThreshold; //!< Threshold computed based on format. |
| UVec4 finalThreshold; |
| |
| // 1 ULP rounding error is allowed for smaller floating-point formats |
| switch (format.type) |
| { |
| case tcu::TextureFormat::FLOAT: |
| formatThreshold = UVec4(0); |
| break; |
| case tcu::TextureFormat::HALF_FLOAT: |
| formatThreshold = UVec4((1 << (23 - 10))); |
| break; |
| case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: |
| formatThreshold = UVec4((1 << (23 - 6)), (1 << (23 - 6)), (1 << (23 - 5)), 0); |
| break; |
| default: |
| DE_ASSERT(false); |
| break; |
| } |
| |
| // 1 ULP rounding error for highp -> output precision cast |
| switch (outPrecision) |
| { |
| case glu::PRECISION_LOWP: |
| outTypeThreshold = (1 << (23 - 8)); |
| break; |
| case glu::PRECISION_MEDIUMP: |
| outTypeThreshold = (1 << (23 - 10)); |
| break; |
| case glu::PRECISION_HIGHP: |
| outTypeThreshold = 0; |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| |
| finalThreshold = |
| select(max(formatThreshold, UVec4(deMax32(interpThreshold, outTypeThreshold))), UVec4(~0u), cmpMask); |
| |
| isOk = tcu::floatUlpThresholdCompare(log, name.c_str(), desc.c_str(), reference, rendered, finalThreshold, |
| tcu::COMPARE_LOG_RESULT); |
| break; |
| } |
| |
| case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: |
| { |
| // \note glReadPixels() allows only 8 bits to be read. This means that RGB10_A2 will loose some |
| // bits in the process and it must be taken into account when computing threshold. |
| const IVec4 bits = min(IVec4(8), tcu::getTextureFormatBitDepth(format)); |
| const Vec4 baseThreshold = 1.0f / ((IVec4(1) << bits) - 1).asFloat(); |
| const Vec4 threshold = select(baseThreshold, Vec4(2.0f), cmpMask); |
| |
| isOk = tcu::floatThresholdCompare(log, name.c_str(), desc.c_str(), reference, rendered, threshold, |
| tcu::COMPARE_LOG_RESULT); |
| break; |
| } |
| |
| case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: |
| case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: |
| { |
| const tcu::UVec4 threshold = select(UVec4(0u), UVec4(~0u), cmpMask); |
| isOk = tcu::intThresholdCompare(log, name.c_str(), desc.c_str(), reference, rendered, threshold, |
| tcu::COMPARE_LOG_RESULT); |
| break; |
| } |
| |
| default: |
| TCU_FAIL("Unsupported comparison"); |
| } |
| |
| if (!isOk) |
| allLevelsOk = false; |
| } |
| |
| m_testCtx.setTestResult(allLevelsOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, |
| allLevelsOk ? "Pass" : "Image comparison failed"); |
| return STOP; |
| } |
| |
| FragmentOutputTests::FragmentOutputTests(Context &context) |
| : TestCaseGroup(context, "fragment_out", "Fragment output tests") |
| { |
| } |
| |
| FragmentOutputTests::~FragmentOutputTests(void) |
| { |
| } |
| |
| static FragmentOutputCase *createRandomCase(Context &context, int minRenderTargets, int maxRenderTargets, uint32_t seed) |
| { |
| static const glu::DataType outputTypes[] = {glu::TYPE_FLOAT, glu::TYPE_FLOAT_VEC2, glu::TYPE_FLOAT_VEC3, |
| glu::TYPE_FLOAT_VEC4, glu::TYPE_INT, glu::TYPE_INT_VEC2, |
| glu::TYPE_INT_VEC3, glu::TYPE_INT_VEC4, glu::TYPE_UINT, |
| glu::TYPE_UINT_VEC2, glu::TYPE_UINT_VEC3, glu::TYPE_UINT_VEC4}; |
| static const glu::Precision precisions[] = {glu::PRECISION_LOWP, glu::PRECISION_MEDIUMP, glu::PRECISION_HIGHP}; |
| static const uint32_t floatFormats[] = { |
| GL_RGBA32F, GL_RGBA16F, GL_R11F_G11F_B10F, GL_RG32F, GL_RG16F, GL_R32F, GL_R16F, GL_RGBA8, |
| GL_SRGB8_ALPHA8, GL_RGB10_A2, GL_RGBA4, GL_RGB5_A1, GL_RGB8, GL_RGB565, GL_RG8, GL_R8}; |
| static const uint32_t intFormats[] = {GL_RGBA32I, GL_RGBA16I, GL_RGBA8I, GL_RG32I, GL_RG16I, |
| GL_RG8I, GL_R32I, GL_R16I, GL_R8I}; |
| static const uint32_t uintFormats[] = {GL_RGBA32UI, GL_RGBA16UI, GL_RGBA8UI, GL_RGB10_A2UI, GL_RG32UI, |
| GL_RG16UI, GL_RG8UI, GL_R32UI, GL_R16UI, GL_R8UI}; |
| |
| de::Random rnd(seed); |
| vector<FragmentOutput> outputs; |
| vector<BufferSpec> targets; |
| vector<glu::DataType> outTypes; |
| |
| int numTargets = rnd.getInt(minRenderTargets, maxRenderTargets); |
| const int width = 128; // \todo [2012-04-10 pyry] Separate randomized sizes per target? |
| const int height = 64; |
| const int samples = 0; |
| |
| // Compute outputs. |
| int curLoc = 0; |
| while (curLoc < numTargets) |
| { |
| bool useArray = rnd.getFloat() < 0.3f; |
| int maxArrayLen = numTargets - curLoc; |
| int arrayLen = useArray ? rnd.getInt(1, maxArrayLen) : 0; |
| glu::DataType basicType = |
| rnd.choose<glu::DataType>(&outputTypes[0], &outputTypes[0] + DE_LENGTH_OF_ARRAY(outputTypes)); |
| glu::Precision precision = |
| rnd.choose<glu::Precision>(&precisions[0], &precisions[0] + DE_LENGTH_OF_ARRAY(precisions)); |
| int numLocations = useArray ? arrayLen : 1; |
| |
| outputs.push_back(FragmentOutput(basicType, precision, curLoc, arrayLen)); |
| |
| for (int ndx = 0; ndx < numLocations; ndx++) |
| outTypes.push_back(basicType); |
| |
| curLoc += numLocations; |
| } |
| DE_ASSERT(curLoc == numTargets); |
| DE_ASSERT((int)outTypes.size() == numTargets); |
| |
| // Compute buffers. |
| while ((int)targets.size() < numTargets) |
| { |
| glu::DataType outType = outTypes[targets.size()]; |
| bool isFloat = glu::isDataTypeFloatOrVec(outType); |
| bool isInt = glu::isDataTypeIntOrIVec(outType); |
| bool isUint = glu::isDataTypeUintOrUVec(outType); |
| uint32_t format = 0; |
| |
| if (isFloat) |
| format = rnd.choose<uint32_t>(&floatFormats[0], &floatFormats[0] + DE_LENGTH_OF_ARRAY(floatFormats)); |
| else if (isInt) |
| format = rnd.choose<uint32_t>(&intFormats[0], &intFormats[0] + DE_LENGTH_OF_ARRAY(intFormats)); |
| else if (isUint) |
| format = rnd.choose<uint32_t>(&uintFormats[0], &uintFormats[0] + DE_LENGTH_OF_ARRAY(uintFormats)); |
| else |
| DE_ASSERT(false); |
| |
| targets.push_back(BufferSpec(format, width, height, samples)); |
| } |
| |
| return new FragmentOutputCase(context, de::toString(seed).c_str(), "", targets, outputs); |
| } |
| |
| void FragmentOutputTests::init(void) |
| { |
| static const uint32_t requiredFloatFormats[] = {GL_RGBA32F, GL_RGBA16F, GL_R11F_G11F_B10F, GL_RG32F, GL_RG16F, |
| GL_R32F, GL_R16F}; |
| static const uint32_t requiredFixedFormats[] = {GL_RGBA8, GL_SRGB8_ALPHA8, GL_RGB10_A2, GL_RGBA4, GL_RGB5_A1, |
| GL_RGB8, GL_RGB565, GL_RG8, GL_R8}; |
| static const uint32_t requiredIntFormats[] = {GL_RGBA32I, GL_RGBA16I, GL_RGBA8I, GL_RG32I, GL_RG16I, |
| GL_RG8I, GL_R32I, GL_R16I, GL_R8I}; |
| static const uint32_t requiredUintFormats[] = {GL_RGBA32UI, GL_RGBA16UI, GL_RGBA8UI, GL_RGB10_A2UI, GL_RG32UI, |
| GL_RG16UI, GL_RG8UI, GL_R32UI, GL_R16UI, GL_R8UI}; |
| |
| static const glu::Precision precisions[] = {glu::PRECISION_LOWP, glu::PRECISION_MEDIUMP, glu::PRECISION_HIGHP}; |
| |
| // .basic. |
| { |
| tcu::TestCaseGroup *basicGroup = new tcu::TestCaseGroup(m_testCtx, "basic", "Basic fragment output tests"); |
| addChild(basicGroup); |
| |
| const int width = 64; |
| const int height = 64; |
| const int samples = 0; |
| |
| // .float |
| tcu::TestCaseGroup *floatGroup = new tcu::TestCaseGroup(m_testCtx, "float", "Floating-point output tests"); |
| basicGroup->addChild(floatGroup); |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(requiredFloatFormats); fmtNdx++) |
| { |
| uint32_t format = requiredFloatFormats[fmtNdx]; |
| string fmtName = getFormatName(format); |
| vector<BufferSpec> fboSpec; |
| |
| fboSpec.push_back(BufferSpec(format, width, height, samples)); |
| |
| for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) |
| { |
| glu::Precision prec = precisions[precNdx]; |
| string precName = glu::getPrecisionName(prec); |
| |
| floatGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_float").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT, prec, 0)).toVec())); |
| floatGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_vec2").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC2, prec, 0)).toVec())); |
| floatGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_vec3").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC3, prec, 0)).toVec())); |
| floatGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_vec4").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC4, prec, 0)).toVec())); |
| } |
| } |
| |
| // .fixed |
| tcu::TestCaseGroup *fixedGroup = new tcu::TestCaseGroup(m_testCtx, "fixed", "Fixed-point output tests"); |
| basicGroup->addChild(fixedGroup); |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(requiredFixedFormats); fmtNdx++) |
| { |
| uint32_t format = requiredFixedFormats[fmtNdx]; |
| string fmtName = getFormatName(format); |
| vector<BufferSpec> fboSpec; |
| |
| fboSpec.push_back(BufferSpec(format, width, height, samples)); |
| |
| for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) |
| { |
| glu::Precision prec = precisions[precNdx]; |
| string precName = glu::getPrecisionName(prec); |
| |
| fixedGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_float").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT, prec, 0)).toVec())); |
| fixedGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_vec2").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC2, prec, 0)).toVec())); |
| fixedGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_vec3").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC3, prec, 0)).toVec())); |
| fixedGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_vec4").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC4, prec, 0)).toVec())); |
| } |
| } |
| |
| // .int |
| tcu::TestCaseGroup *intGroup = new tcu::TestCaseGroup(m_testCtx, "int", "Integer output tests"); |
| basicGroup->addChild(intGroup); |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(requiredIntFormats); fmtNdx++) |
| { |
| uint32_t format = requiredIntFormats[fmtNdx]; |
| string fmtName = getFormatName(format); |
| vector<BufferSpec> fboSpec; |
| |
| fboSpec.push_back(BufferSpec(format, width, height, samples)); |
| |
| for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) |
| { |
| glu::Precision prec = precisions[precNdx]; |
| string precName = glu::getPrecisionName(prec); |
| |
| intGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_int").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_INT, prec, 0)).toVec())); |
| intGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_ivec2").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_INT_VEC2, prec, 0)).toVec())); |
| intGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_ivec3").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_INT_VEC3, prec, 0)).toVec())); |
| intGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_ivec4").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_INT_VEC4, prec, 0)).toVec())); |
| } |
| } |
| |
| // .uint |
| tcu::TestCaseGroup *uintGroup = new tcu::TestCaseGroup(m_testCtx, "uint", "Usigned integer output tests"); |
| basicGroup->addChild(uintGroup); |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(requiredUintFormats); fmtNdx++) |
| { |
| uint32_t format = requiredUintFormats[fmtNdx]; |
| string fmtName = getFormatName(format); |
| vector<BufferSpec> fboSpec; |
| |
| fboSpec.push_back(BufferSpec(format, width, height, samples)); |
| |
| for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) |
| { |
| glu::Precision prec = precisions[precNdx]; |
| string precName = glu::getPrecisionName(prec); |
| |
| uintGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_uint").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_UINT, prec, 0)).toVec())); |
| uintGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_uvec2").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_UINT_VEC2, prec, 0)).toVec())); |
| uintGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_uvec3").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_UINT_VEC3, prec, 0)).toVec())); |
| uintGroup->addChild( |
| new FragmentOutputCase(m_context, (fmtName + "_" + precName + "_uvec4").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_UINT_VEC4, prec, 0)).toVec())); |
| } |
| } |
| } |
| |
| // .array |
| { |
| tcu::TestCaseGroup *arrayGroup = new tcu::TestCaseGroup(m_testCtx, "array", "Array outputs"); |
| addChild(arrayGroup); |
| |
| const int width = 64; |
| const int height = 64; |
| const int samples = 0; |
| const int numTargets = 3; |
| |
| // .float |
| tcu::TestCaseGroup *floatGroup = new tcu::TestCaseGroup(m_testCtx, "float", "Floating-point output tests"); |
| arrayGroup->addChild(floatGroup); |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(requiredFloatFormats); fmtNdx++) |
| { |
| uint32_t format = requiredFloatFormats[fmtNdx]; |
| string fmtName = getFormatName(format); |
| vector<BufferSpec> fboSpec; |
| |
| for (int ndx = 0; ndx < numTargets; ndx++) |
| fboSpec.push_back(BufferSpec(format, width, height, samples)); |
| |
| for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) |
| { |
| glu::Precision prec = precisions[precNdx]; |
| string precName = glu::getPrecisionName(prec); |
| |
| floatGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_float").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT, prec, 0, numTargets)).toVec())); |
| floatGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_vec2").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC2, prec, 0, numTargets)).toVec())); |
| floatGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_vec3").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC3, prec, 0, numTargets)).toVec())); |
| floatGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_vec4").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC4, prec, 0, numTargets)).toVec())); |
| } |
| } |
| |
| // .fixed |
| tcu::TestCaseGroup *fixedGroup = new tcu::TestCaseGroup(m_testCtx, "fixed", "Fixed-point output tests"); |
| arrayGroup->addChild(fixedGroup); |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(requiredFixedFormats); fmtNdx++) |
| { |
| uint32_t format = requiredFixedFormats[fmtNdx]; |
| string fmtName = getFormatName(format); |
| vector<BufferSpec> fboSpec; |
| |
| for (int ndx = 0; ndx < numTargets; ndx++) |
| fboSpec.push_back(BufferSpec(format, width, height, samples)); |
| |
| for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) |
| { |
| glu::Precision prec = precisions[precNdx]; |
| string precName = glu::getPrecisionName(prec); |
| |
| fixedGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_float").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT, prec, 0, numTargets)).toVec())); |
| fixedGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_vec2").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC2, prec, 0, numTargets)).toVec())); |
| fixedGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_vec3").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC3, prec, 0, numTargets)).toVec())); |
| fixedGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_vec4").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_FLOAT_VEC4, prec, 0, numTargets)).toVec())); |
| } |
| } |
| |
| // .int |
| tcu::TestCaseGroup *intGroup = new tcu::TestCaseGroup(m_testCtx, "int", "Integer output tests"); |
| arrayGroup->addChild(intGroup); |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(requiredIntFormats); fmtNdx++) |
| { |
| uint32_t format = requiredIntFormats[fmtNdx]; |
| string fmtName = getFormatName(format); |
| vector<BufferSpec> fboSpec; |
| |
| for (int ndx = 0; ndx < numTargets; ndx++) |
| fboSpec.push_back(BufferSpec(format, width, height, samples)); |
| |
| for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) |
| { |
| glu::Precision prec = precisions[precNdx]; |
| string precName = glu::getPrecisionName(prec); |
| |
| intGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_int").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_INT, prec, 0, numTargets)).toVec())); |
| intGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_ivec2").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_INT_VEC2, prec, 0, numTargets)).toVec())); |
| intGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_ivec3").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_INT_VEC3, prec, 0, numTargets)).toVec())); |
| intGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_ivec4").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_INT_VEC4, prec, 0, numTargets)).toVec())); |
| } |
| } |
| |
| // .uint |
| tcu::TestCaseGroup *uintGroup = new tcu::TestCaseGroup(m_testCtx, "uint", "Usigned integer output tests"); |
| arrayGroup->addChild(uintGroup); |
| for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(requiredUintFormats); fmtNdx++) |
| { |
| uint32_t format = requiredUintFormats[fmtNdx]; |
| string fmtName = getFormatName(format); |
| vector<BufferSpec> fboSpec; |
| |
| for (int ndx = 0; ndx < numTargets; ndx++) |
| fboSpec.push_back(BufferSpec(format, width, height, samples)); |
| |
| for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); precNdx++) |
| { |
| glu::Precision prec = precisions[precNdx]; |
| string precName = glu::getPrecisionName(prec); |
| |
| uintGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_uint").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_UINT, prec, 0, numTargets)).toVec())); |
| uintGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_uvec2").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_UINT_VEC2, prec, 0, numTargets)).toVec())); |
| uintGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_uvec3").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_UINT_VEC3, prec, 0, numTargets)).toVec())); |
| uintGroup->addChild(new FragmentOutputCase( |
| m_context, (fmtName + "_" + precName + "_uvec4").c_str(), "", fboSpec, |
| (OutputVec() << FragmentOutput(glu::TYPE_UINT_VEC4, prec, 0, numTargets)).toVec())); |
| } |
| } |
| } |
| |
| // .random |
| { |
| tcu::TestCaseGroup *randomGroup = new tcu::TestCaseGroup(m_testCtx, "random", "Random fragment output cases"); |
| addChild(randomGroup); |
| |
| for (uint32_t seed = 0; seed < 100; seed++) |
| randomGroup->addChild(createRandomCase(m_context, 2, 4, seed)); |
| } |
| } |
| |
| } // namespace Functional |
| } // namespace gles3 |
| } // namespace deqp |
