| /*------------------------------------------------------------------------- |
| * 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 Utilities for framebuffer objects. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "glsFboUtil.hpp" |
| |
| #include "glwEnums.hpp" |
| #include "deUniquePtr.hpp" |
| #include "gluTextureUtil.hpp" |
| #include "gluStrUtil.hpp" |
| #include "deStringUtil.hpp" |
| #include "deSTLUtil.hpp" |
| #include <sstream> |
| |
| using namespace glw; |
| using de::toString; |
| using de::UniquePtr; |
| using glu::ContextInfo; |
| using glu::ContextType; |
| using glu::getFramebufferAttachmentName; |
| using glu::getFramebufferAttachmentTypeName; |
| using glu::getFramebufferTargetName; |
| using glu::getTextureFormatName; |
| using glu::getTextureTargetName; |
| using glu::getTransferFormat; |
| using glu::getTypeName; |
| using glu::mapGLInternalFormat; |
| using glu::mapGLTransferFormat; |
| using glu::RenderContext; |
| using glu::TransferFormat; |
| using std::istream_iterator; |
| using std::istringstream; |
| using std::set; |
| using std::string; |
| using std::vector; |
| using tcu::NotSupportedError; |
| using tcu::TestLog; |
| using tcu::TextureFormat; |
| |
| namespace deqp |
| { |
| namespace gls |
| { |
| |
| namespace FboUtil |
| { |
| |
| #if defined(DE_DEBUG) |
| static bool isFramebufferStatus(glw::GLenum fboStatus) |
| { |
| return glu::getFramebufferStatusName(fboStatus) != DE_NULL; |
| } |
| |
| static bool isErrorCode(glw::GLenum errorCode) |
| { |
| return glu::getErrorName(errorCode) != DE_NULL; |
| } |
| #endif |
| |
| std::ostream &operator<<(std::ostream &stream, const ImageFormat &format) |
| { |
| if (format.unsizedType == GL_NONE) |
| { |
| // sized format |
| return stream << glu::getTextureFormatStr(format.format); |
| } |
| else |
| { |
| // unsized format |
| return stream << "(format = " << glu::getTextureFormatStr(format.format) |
| << ", type = " << glu::getTypeStr(format.unsizedType) << ")"; |
| } |
| } |
| |
| void FormatDB::addCoreFormat(ImageFormat format, FormatFlags newFlags) |
| { |
| FormatFlags &flags = m_formatFlags[format]; |
| flags = FormatFlags(flags | newFlags); |
| } |
| |
| void FormatDB::addExtensionFormat(ImageFormat format, FormatFlags newFlags, |
| const std::set<std::string> &requiredExtensions) |
| { |
| DE_ASSERT(!requiredExtensions.empty()); |
| |
| { |
| FormatFlags &flags = m_formatFlags[format]; |
| flags = FormatFlags(flags | newFlags); |
| } |
| |
| { |
| std::set<ExtensionInfo> &extensionInfo = m_formatExtensions[format]; |
| ExtensionInfo extensionRecord; |
| |
| extensionRecord.flags = newFlags; |
| extensionRecord.requiredExtensions = requiredExtensions; |
| |
| DE_ASSERT(!de::contains(extensionInfo, extensionRecord)); // extensions specified only once |
| extensionInfo.insert(extensionRecord); |
| } |
| } |
| |
| // Not too fast at the moment, might consider indexing? |
| Formats FormatDB::getFormats(FormatFlags requirements) const |
| { |
| Formats ret; |
| for (FormatMap::const_iterator it = m_formatFlags.begin(); it != m_formatFlags.end(); it++) |
| { |
| if ((it->second & requirements) == requirements) |
| ret.insert(it->first); |
| } |
| return ret; |
| } |
| |
| bool FormatDB::isKnownFormat(ImageFormat format) const |
| { |
| return de::contains(m_formatFlags, format); |
| } |
| |
| FormatFlags FormatDB::getFormatInfo(ImageFormat format) const |
| { |
| DE_ASSERT(de::contains(m_formatFlags, format)); |
| return de::lookup(m_formatFlags, format); |
| } |
| |
| std::set<std::set<std::string>> FormatDB::getFormatFeatureExtensions(ImageFormat format, FormatFlags requirements) const |
| { |
| DE_ASSERT(de::contains(m_formatExtensions, format)); |
| |
| const std::set<ExtensionInfo> &extensionInfo = de::lookup(m_formatExtensions, format); |
| std::set<std::set<std::string>> ret; |
| |
| for (std::set<ExtensionInfo>::const_iterator it = extensionInfo.begin(); it != extensionInfo.end(); ++it) |
| { |
| if ((it->flags & requirements) == requirements) |
| ret.insert(it->requiredExtensions); |
| } |
| |
| return ret; |
| } |
| |
| bool FormatDB::ExtensionInfo::operator<(const ExtensionInfo &other) const |
| { |
| return (requiredExtensions < other.requiredExtensions) || |
| ((requiredExtensions == other.requiredExtensions) && (flags < other.flags)); |
| } |
| |
| static bool detectGLESCompatibleContext(const RenderContext &ctx, int requiredMajor, int requiredMinor) |
| { |
| const glw::Functions &gl = ctx.getFunctions(); |
| glw::GLint majorVersion = 0; |
| glw::GLint minorVersion = 0; |
| |
| // Detect compatible GLES context by querying GL_MAJOR_VERSION. |
| // This query does not exist on GLES2 so a failing query implies |
| // GLES2 context. |
| |
| gl.getIntegerv(GL_MAJOR_VERSION, &majorVersion); |
| if (gl.getError() != GL_NO_ERROR) |
| majorVersion = 2; |
| |
| gl.getIntegerv(GL_MINOR_VERSION, &minorVersion); |
| if (gl.getError() != GL_NO_ERROR) |
| minorVersion = 0; |
| |
| return (majorVersion > requiredMajor) || (majorVersion == requiredMajor && minorVersion >= requiredMinor); |
| } |
| |
| static bool checkExtensionSupport(const ContextInfo &ctxInfo, const RenderContext &ctx, const std::string &extension) |
| { |
| if (de::beginsWith(extension, "GL_")) |
| return ctxInfo.isExtensionSupported(extension.c_str()); |
| else if (extension == "DEQP_gles3_core_compatible") |
| return detectGLESCompatibleContext(ctx, 3, 0); |
| else if (extension == "DEQP_gles31_core_compatible") |
| return detectGLESCompatibleContext(ctx, 3, 1); |
| else |
| { |
| DE_ASSERT(false); |
| return false; |
| } |
| } |
| |
| bool checkExtensionSupport(const RenderContext &ctx, const std::string &extension) |
| { |
| const de::UniquePtr<ContextInfo> info(ContextInfo::create(ctx)); |
| return checkExtensionSupport(*info, ctx, extension); |
| } |
| |
| std::string getExtensionDescription(const std::string &extension) |
| { |
| if (de::beginsWith(extension, "GL_")) |
| return extension; |
| else if (extension == "DEQP_gles3_core_compatible") |
| return "GLES3 compatible context"; |
| else if (extension == "DEQP_gles31_core_compatible") |
| return "GLES3.1 compatible context"; |
| else |
| { |
| DE_ASSERT(false); |
| return ""; |
| } |
| } |
| |
| void addFormats(FormatDB &db, FormatEntries stdFmts) |
| { |
| for (const FormatEntry *it = stdFmts.begin(); it != stdFmts.end(); it++) |
| { |
| for (const FormatKey *it2 = it->second.begin(); it2 != it->second.end(); it2++) |
| db.addCoreFormat(formatKeyInfo(*it2), it->first); |
| } |
| } |
| |
| void addExtFormats(FormatDB &db, FormatExtEntries extFmts, const RenderContext *ctx) |
| { |
| const UniquePtr<ContextInfo> ctxInfo(ctx != DE_NULL ? ContextInfo::create(*ctx) : DE_NULL); |
| for (const FormatExtEntry *entryIt = extFmts.begin(); entryIt != extFmts.end(); entryIt++) |
| { |
| bool supported = true; |
| std::set<std::string> requiredExtensions; |
| |
| // parse required extensions |
| { |
| istringstream tokenStream(string(entryIt->extensions)); |
| istream_iterator<string> tokens((tokenStream)), end; |
| |
| while (tokens != end) |
| { |
| requiredExtensions.insert(*tokens); |
| ++tokens; |
| } |
| } |
| |
| // check support |
| if (ctxInfo) |
| { |
| for (std::set<std::string>::const_iterator extIt = requiredExtensions.begin(); |
| extIt != requiredExtensions.end(); ++extIt) |
| { |
| if (!checkExtensionSupport(*ctxInfo, *ctx, *extIt)) |
| { |
| supported = false; |
| break; |
| } |
| } |
| } |
| |
| if (supported) |
| for (const FormatKey *i2 = entryIt->formats.begin(); i2 != entryIt->formats.end(); i2++) |
| db.addExtensionFormat(formatKeyInfo(*i2), FormatFlags(entryIt->flags), requiredExtensions); |
| } |
| } |
| |
| FormatFlags formatFlag(GLenum context) |
| { |
| switch (context) |
| { |
| case GL_NONE: |
| return FormatFlags(0); |
| case GL_RENDERBUFFER: |
| return RENDERBUFFER_VALID; |
| case GL_TEXTURE: |
| return TEXTURE_VALID; |
| case GL_STENCIL_ATTACHMENT: |
| return STENCIL_RENDERABLE; |
| case GL_DEPTH_ATTACHMENT: |
| return DEPTH_RENDERABLE; |
| default: |
| DE_ASSERT(context >= GL_COLOR_ATTACHMENT0 && context <= GL_COLOR_ATTACHMENT15); |
| return COLOR_RENDERABLE; |
| } |
| } |
| |
| static FormatFlags getAttachmentRenderabilityFlag(GLenum attachment) |
| { |
| switch (attachment) |
| { |
| case GL_STENCIL_ATTACHMENT: |
| return STENCIL_RENDERABLE; |
| case GL_DEPTH_ATTACHMENT: |
| return DEPTH_RENDERABLE; |
| |
| default: |
| DE_ASSERT(attachment >= GL_COLOR_ATTACHMENT0 && attachment <= GL_COLOR_ATTACHMENT15); |
| return COLOR_RENDERABLE; |
| } |
| } |
| |
| namespace config |
| { |
| |
| GLsizei imageNumSamples(const Image &img) |
| { |
| if (const Renderbuffer *rbo = dynamic_cast<const Renderbuffer *>(&img)) |
| return rbo->numSamples; |
| return 0; |
| } |
| |
| static GLenum glTarget(const Image &img) |
| { |
| if (dynamic_cast<const Renderbuffer *>(&img) != DE_NULL) |
| return GL_RENDERBUFFER; |
| if (dynamic_cast<const Texture2D *>(&img) != DE_NULL) |
| return GL_TEXTURE_2D; |
| if (dynamic_cast<const TextureCubeMap *>(&img) != DE_NULL) |
| return GL_TEXTURE_CUBE_MAP; |
| if (dynamic_cast<const Texture3D *>(&img) != DE_NULL) |
| return GL_TEXTURE_3D; |
| if (dynamic_cast<const Texture2DArray *>(&img) != DE_NULL) |
| return GL_TEXTURE_2D_ARRAY; |
| |
| DE_FATAL("Impossible image type"); |
| return GL_NONE; |
| } |
| |
| static void glInitFlat(const TextureFlat &cfg, GLenum target, const glw::Functions &gl) |
| { |
| const TransferFormat format = transferImageFormat(cfg.internalFormat); |
| GLint w = cfg.width; |
| GLint h = cfg.height; |
| for (GLint level = 0; level < cfg.numLevels; level++) |
| { |
| gl.texImage2D(target, level, cfg.internalFormat.format, w, h, 0, format.format, format.dataType, DE_NULL); |
| w = de::max(1, w / 2); |
| h = de::max(1, h / 2); |
| } |
| } |
| |
| static void glInitLayered(const TextureLayered &cfg, GLint depth_divider, const glw::Functions &gl) |
| { |
| const TransferFormat format = transferImageFormat(cfg.internalFormat); |
| GLint w = cfg.width; |
| GLint h = cfg.height; |
| GLint depth = cfg.numLayers; |
| for (GLint level = 0; level < cfg.numLevels; level++) |
| { |
| gl.texImage3D(glTarget(cfg), level, cfg.internalFormat.format, w, h, depth, 0, format.format, format.dataType, |
| DE_NULL); |
| w = de::max(1, w / 2); |
| h = de::max(1, h / 2); |
| depth = de::max(1, depth / depth_divider); |
| } |
| } |
| |
| static void glInit(const Texture &cfg, const glw::Functions &gl) |
| { |
| if (const Texture2D *t2d = dynamic_cast<const Texture2D *>(&cfg)) |
| glInitFlat(*t2d, glTarget(*t2d), gl); |
| else if (const TextureCubeMap *tcm = dynamic_cast<const TextureCubeMap *>(&cfg)) |
| { |
| // \todo [2013-12-05 lauri] |
| // move this to glu or someplace sensible (this array is already |
| // present in duplicates) |
| static const GLenum s_cubeMapFaces[] = { |
| GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, |
| }; |
| const Range<GLenum> range = GLS_ARRAY_RANGE(s_cubeMapFaces); |
| for (const GLenum *it = range.begin(); it != range.end(); it++) |
| glInitFlat(*tcm, *it, gl); |
| } |
| else if (const Texture3D *t3d = dynamic_cast<const Texture3D *>(&cfg)) |
| glInitLayered(*t3d, 2, gl); |
| else if (const Texture2DArray *t2a = dynamic_cast<const Texture2DArray *>(&cfg)) |
| glInitLayered(*t2a, 1, gl); |
| } |
| |
| static GLuint glCreate(const Image &cfg, const glw::Functions &gl) |
| { |
| GLuint ret = 0; |
| if (const Renderbuffer *const rbo = dynamic_cast<const Renderbuffer *>(&cfg)) |
| { |
| gl.genRenderbuffers(1, &ret); |
| gl.bindRenderbuffer(GL_RENDERBUFFER, ret); |
| |
| if (rbo->numSamples == 0) |
| gl.renderbufferStorage(GL_RENDERBUFFER, rbo->internalFormat.format, rbo->width, rbo->height); |
| else |
| gl.renderbufferStorageMultisample(GL_RENDERBUFFER, rbo->numSamples, rbo->internalFormat.format, rbo->width, |
| rbo->height); |
| |
| gl.bindRenderbuffer(GL_RENDERBUFFER, 0); |
| } |
| else if (const Texture *const tex = dynamic_cast<const Texture *>(&cfg)) |
| { |
| gl.genTextures(1, &ret); |
| gl.bindTexture(glTarget(*tex), ret); |
| glInit(*tex, gl); |
| gl.bindTexture(glTarget(*tex), 0); |
| } |
| else |
| DE_FATAL("Impossible image type"); |
| return ret; |
| } |
| |
| static void glDelete(const Image &cfg, GLuint img, const glw::Functions &gl) |
| { |
| if (dynamic_cast<const Renderbuffer *>(&cfg) != DE_NULL) |
| gl.deleteRenderbuffers(1, &img); |
| else if (dynamic_cast<const Texture *>(&cfg) != DE_NULL) |
| gl.deleteTextures(1, &img); |
| else |
| DE_FATAL("Impossible image type"); |
| } |
| |
| static void attachAttachment(const Attachment &att, GLenum attPoint, const glw::Functions &gl) |
| { |
| if (const RenderbufferAttachment *const rAtt = dynamic_cast<const RenderbufferAttachment *>(&att)) |
| gl.framebufferRenderbuffer(rAtt->target, attPoint, rAtt->renderbufferTarget, rAtt->imageName); |
| else if (const TextureFlatAttachment *const fAtt = dynamic_cast<const TextureFlatAttachment *>(&att)) |
| gl.framebufferTexture2D(fAtt->target, attPoint, fAtt->texTarget, fAtt->imageName, fAtt->level); |
| else if (const TextureLayerAttachment *const lAtt = dynamic_cast<const TextureLayerAttachment *>(&att)) |
| gl.framebufferTextureLayer(lAtt->target, attPoint, lAtt->imageName, lAtt->level, lAtt->layer); |
| else |
| DE_FATAL("Impossible attachment type"); |
| } |
| |
| GLenum attachmentType(const Attachment &att) |
| { |
| if (dynamic_cast<const RenderbufferAttachment *>(&att) != DE_NULL) |
| return GL_RENDERBUFFER; |
| else if (dynamic_cast<const TextureAttachment *>(&att) != DE_NULL) |
| return GL_TEXTURE; |
| |
| DE_FATAL("Impossible attachment type"); |
| return GL_NONE; |
| } |
| |
| static GLsizei textureLayer(const TextureAttachment &tAtt) |
| { |
| if (dynamic_cast<const TextureFlatAttachment *>(&tAtt) != DE_NULL) |
| return 0; |
| else if (const TextureLayerAttachment *const lAtt = dynamic_cast<const TextureLayerAttachment *>(&tAtt)) |
| return lAtt->layer; |
| |
| DE_FATAL("Impossible attachment type"); |
| return 0; |
| } |
| |
| static void checkAttachmentCompleteness(Checker &cctx, const Attachment &attachment, GLenum attPoint, |
| const Image *image, const FormatDB &db) |
| { |
| // GLES2 4.4.5 / GLES3 4.4.4, "Framebuffer attachment completeness" |
| |
| if (const TextureAttachment *const texAtt = dynamic_cast<const TextureAttachment *>(&attachment)) |
| if (const TextureLayered *const ltex = dynamic_cast<const TextureLayered *>(image)) |
| { |
| // GLES3: "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is |
| // TEXTURE and the value of FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names a |
| // three-dimensional texture, then the value of |
| // FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER must be smaller than the depth |
| // of the texture. |
| // |
| // GLES3: "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is |
| // TEXTURE and the value of FRAMEBUFFER_ATTACHMENT_OBJECT_NAME names a |
| // two-dimensional array texture, then the value of |
| // FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER must be smaller than the |
| // number of layers in the texture. |
| |
| if (textureLayer(*texAtt) >= ltex->numLayers) |
| cctx.addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "Attached layer index is larger than present"); |
| } |
| |
| // "The width and height of image are non-zero." |
| if (image->width == 0 || image->height == 0) |
| cctx.addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "Width and height of an image are not non-zero"); |
| |
| // Check for renderability |
| if (db.isKnownFormat(image->internalFormat)) |
| { |
| const FormatFlags flags = db.getFormatInfo(image->internalFormat); |
| |
| // If the format does not have the proper renderability flag, the |
| // completeness check _must_ fail. |
| if ((flags & getAttachmentRenderabilityFlag(attPoint)) == 0) |
| cctx.addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, |
| "Attachment format is not renderable in this attachment"); |
| // If the format is only optionally renderable, the completeness check _can_ fail. |
| else if ((flags & REQUIRED_RENDERABLE) == 0) |
| cctx.addPotentialFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, |
| "Attachment format is not required renderable"); |
| } |
| else |
| cctx.addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, "Attachment format is not legal"); |
| } |
| |
| } // namespace config |
| |
| using namespace config; |
| |
| Checker::Checker(const glu::RenderContext &ctx, const FormatDB &formats) : m_renderCtx(ctx), m_formats(formats) |
| { |
| m_statusCodes.setAllowComplete(true); |
| } |
| |
| void Checker::addGLError(glw::GLenum error, const char *description) |
| { |
| m_statusCodes.addErrorCode(error, description); |
| m_statusCodes.setAllowComplete(false); |
| } |
| |
| void Checker::addPotentialGLError(glw::GLenum error, const char *description) |
| { |
| m_statusCodes.addErrorCode(error, description); |
| } |
| |
| void Checker::addFBOStatus(GLenum status, const char *description) |
| { |
| m_statusCodes.addFBOErrorStatus(status, description); |
| m_statusCodes.setAllowComplete(false); |
| } |
| |
| void Checker::addPotentialFBOStatus(GLenum status, const char *description) |
| { |
| m_statusCodes.addFBOErrorStatus(status, description); |
| } |
| |
| FboVerifier::FboVerifier(const FormatDB &formats, CheckerFactory &factory, const glu::RenderContext &renderCtx) |
| : m_formats(formats) |
| , m_factory(factory) |
| , m_renderCtx(renderCtx) |
| { |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Return acceptable framebuffer status codes. |
| * |
| * This function examines the framebuffer configuration descriptor `fboConfig` |
| * and returns the set of status codes that `glCheckFramebufferStatus` is |
| * allowed to return on a conforming implementation when given a framebuffer |
| * whose configuration adheres to `fboConfig`. |
| * |
| * The returned set is guaranteed to be non-empty, but it may contain multiple |
| * INCOMPLETE statuses (if there are multiple errors in the spec), or or a mix |
| * of COMPLETE and INCOMPLETE statuses (if supporting a FBO with this spec is |
| * optional). Furthermore, the statuses may contain GL error codes, which |
| * indicate that trying to create a framebuffer configuration like this could |
| * have failed with an error (if one was checked for) even before |
| * `glCheckFramebufferStatus` was ever called. |
| * |
| *//*--------------------------------------------------------------------*/ |
| ValidStatusCodes FboVerifier::validStatusCodes(const Framebuffer &fboConfig) const |
| { |
| const AttachmentMap &atts = fboConfig.attachments; |
| const UniquePtr<Checker> cctx(m_factory.createChecker(m_renderCtx, m_formats)); |
| |
| for (TextureMap::const_iterator it = fboConfig.textures.begin(); it != fboConfig.textures.end(); it++) |
| { |
| std::string errorDescription; |
| |
| if (m_formats.isKnownFormat(it->second->internalFormat)) |
| { |
| const FormatFlags flags = m_formats.getFormatInfo(it->second->internalFormat); |
| |
| if ((flags & TEXTURE_VALID) == 0) |
| errorDescription = |
| "Format " + de::toString(it->second->internalFormat) + " is not a valid format for a texture"; |
| } |
| else if (it->second->internalFormat.unsizedType == GL_NONE) |
| { |
| // sized format |
| errorDescription = "Format " + de::toString(it->second->internalFormat) + " does not exist"; |
| } |
| else |
| { |
| // unsized type-format pair |
| errorDescription = "Format " + de::toString(it->second->internalFormat) + " is not a legal format"; |
| } |
| |
| if (!errorDescription.empty()) |
| { |
| cctx->addGLError(GL_INVALID_ENUM, errorDescription.c_str()); |
| cctx->addGLError(GL_INVALID_OPERATION, errorDescription.c_str()); |
| cctx->addGLError(GL_INVALID_VALUE, errorDescription.c_str()); |
| } |
| } |
| |
| for (RboMap::const_iterator it = fboConfig.rbos.begin(); it != fboConfig.rbos.end(); it++) |
| { |
| if (m_formats.isKnownFormat(it->second->internalFormat)) |
| { |
| const FormatFlags flags = m_formats.getFormatInfo(it->second->internalFormat); |
| if ((flags & RENDERBUFFER_VALID) == 0) |
| { |
| const std::string reason = |
| "Format " + de::toString(it->second->internalFormat) + " is not a valid format for a renderbuffer"; |
| cctx->addGLError(GL_INVALID_ENUM, reason.c_str()); |
| } |
| } |
| else |
| { |
| const std::string reason = |
| "Internal format " + de::toString(it->second->internalFormat) + " does not exist"; |
| cctx->addGLError(GL_INVALID_ENUM, reason.c_str()); |
| } |
| } |
| |
| // "There is at least one image attached to the framebuffer." |
| // \todo support XXX_framebuffer_no_attachments |
| if (atts.empty()) |
| cctx->addFBOStatus(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, "No images attached to the framebuffer"); |
| |
| for (AttachmentMap::const_iterator it = atts.begin(); it != atts.end(); it++) |
| { |
| const GLenum attPoint = it->first; |
| const Attachment &att = *it->second; |
| const Image *const image = fboConfig.getImage(attachmentType(att), att.imageName); |
| |
| checkAttachmentCompleteness(*cctx, att, attPoint, image, m_formats); |
| cctx->check(it->first, *it->second, image); |
| } |
| |
| return cctx->getStatusCodes(); |
| } |
| |
| void Framebuffer::attach(glw::GLenum attPoint, const Attachment *att) |
| { |
| if (att == DE_NULL) |
| attachments.erase(attPoint); |
| else |
| attachments[attPoint] = att; |
| } |
| |
| const Image *Framebuffer::getImage(GLenum type, glw::GLuint imgName) const |
| { |
| switch (type) |
| { |
| case GL_TEXTURE: |
| return de::lookupDefault(textures, imgName, DE_NULL); |
| case GL_RENDERBUFFER: |
| return de::lookupDefault(rbos, imgName, DE_NULL); |
| default: |
| DE_FATAL("Bad image type"); |
| } |
| return DE_NULL; // shut up compiler warning |
| } |
| |
| void Framebuffer::setTexture(glw::GLuint texName, const Texture &texCfg) |
| { |
| textures[texName] = &texCfg; |
| } |
| |
| void Framebuffer::setRbo(glw::GLuint rbName, const Renderbuffer &rbCfg) |
| { |
| rbos[rbName] = &rbCfg; |
| } |
| |
| static void logField(TestLog &log, const string &field, const string &value) |
| { |
| log << TestLog::Message << field << ": " << value << TestLog::EndMessage; |
| } |
| |
| static void logImage(const Image &img, TestLog &log, bool useType) |
| { |
| const GLenum type = img.internalFormat.unsizedType; |
| logField(log, "Internal format", getTextureFormatName(img.internalFormat.format)); |
| if (useType && type != GL_NONE) |
| logField(log, "Format type", getTypeName(type)); |
| logField(log, "Width", toString(img.width)); |
| logField(log, "Height", toString(img.height)); |
| } |
| |
| static void logRenderbuffer(const Renderbuffer &rbo, TestLog &log) |
| { |
| logImage(rbo, log, false); |
| logField(log, "Samples", toString(rbo.numSamples)); |
| } |
| |
| static void logTexture(const Texture &tex, TestLog &log) |
| { |
| logField(log, "Type", glu::getTextureTargetName(glTarget(tex))); |
| logImage(tex, log, true); |
| logField(log, "Levels", toString(tex.numLevels)); |
| if (const TextureLayered *const lTex = dynamic_cast<const TextureLayered *>(&tex)) |
| logField(log, "Layers", toString(lTex->numLayers)); |
| } |
| |
| static void logAttachment(const Attachment &att, TestLog &log) |
| { |
| logField(log, "Target", getFramebufferTargetName(att.target)); |
| logField(log, "Type", getFramebufferAttachmentTypeName(attachmentType(att))); |
| logField(log, "Image Name", toString(att.imageName)); |
| if (const RenderbufferAttachment *const rAtt = dynamic_cast<const RenderbufferAttachment *>(&att)) |
| { |
| DE_UNREF(rAtt); // To shut up compiler during optimized builds. |
| DE_ASSERT(rAtt->renderbufferTarget == GL_RENDERBUFFER); |
| logField(log, "Renderbuffer Target", "GL_RENDERBUFFER"); |
| } |
| else if (const TextureAttachment *const tAtt = dynamic_cast<const TextureAttachment *>(&att)) |
| { |
| logField(log, "Mipmap Level", toString(tAtt->level)); |
| if (const TextureFlatAttachment *const fAtt = dynamic_cast<const TextureFlatAttachment *>(tAtt)) |
| logField(log, "Texture Target", getTextureTargetName(fAtt->texTarget)); |
| else if (const TextureLayerAttachment *const lAtt = dynamic_cast<const TextureLayerAttachment *>(tAtt)) |
| logField(log, "Layer", toString(lAtt->level)); |
| } |
| } |
| |
| void logFramebufferConfig(const Framebuffer &cfg, TestLog &log) |
| { |
| log << TestLog::Section("Framebuffer", "Framebuffer configuration"); |
| |
| for (RboMap::const_iterator it = cfg.rbos.begin(); it != cfg.rbos.end(); ++it) |
| { |
| const string num = toString(it->first); |
| const tcu::ScopedLogSection subsection(log, num, "Renderbuffer " + num); |
| |
| logRenderbuffer(*it->second, log); |
| } |
| |
| for (TextureMap::const_iterator it = cfg.textures.begin(); it != cfg.textures.end(); ++it) |
| { |
| const string num = toString(it->first); |
| const tcu::ScopedLogSection subsection(log, num, "Texture " + num); |
| |
| logTexture(*it->second, log); |
| } |
| |
| const string attDesc = cfg.attachments.empty() ? "Framebuffer has no attachments" : "Framebuffer attachments"; |
| log << TestLog::Section("Attachments", attDesc); |
| for (AttachmentMap::const_iterator it = cfg.attachments.begin(); it != cfg.attachments.end(); it++) |
| { |
| const string attPointName = getFramebufferAttachmentName(it->first); |
| log << TestLog::Section(attPointName, "Attachment point " + attPointName); |
| logAttachment(*it->second, log); |
| log << TestLog::EndSection; |
| } |
| log << TestLog::EndSection; // Attachments |
| |
| log << TestLog::EndSection; // Framebuffer |
| } |
| |
| ValidStatusCodes::ValidStatusCodes(void) : m_allowComplete(false) |
| { |
| } |
| |
| bool ValidStatusCodes::isFBOStatusValid(glw::GLenum fboStatus) const |
| { |
| if (fboStatus == GL_FRAMEBUFFER_COMPLETE) |
| return m_allowComplete; |
| else |
| { |
| // rule violation exists? |
| for (int ndx = 0; ndx < (int)m_errorStatuses.size(); ++ndx) |
| { |
| if (m_errorStatuses[ndx].errorCode == fboStatus) |
| return true; |
| } |
| return false; |
| } |
| } |
| |
| bool ValidStatusCodes::isFBOStatusRequired(glw::GLenum fboStatus) const |
| { |
| if (fboStatus == GL_FRAMEBUFFER_COMPLETE) |
| return m_allowComplete && m_errorStatuses.empty(); |
| else |
| // fboStatus is the only allowed error status and succeeding is forbidden |
| return !m_allowComplete && m_errorStatuses.size() == 1 && m_errorStatuses.front().errorCode == fboStatus; |
| } |
| |
| bool ValidStatusCodes::isErrorCodeValid(glw::GLenum errorCode) const |
| { |
| if (errorCode == GL_NO_ERROR) |
| return m_errorCodes.empty(); |
| else |
| { |
| // rule violation exists? |
| for (int ndx = 0; ndx < (int)m_errorCodes.size(); ++ndx) |
| { |
| if (m_errorCodes[ndx].errorCode == errorCode) |
| return true; |
| } |
| return false; |
| } |
| } |
| |
| bool ValidStatusCodes::isErrorCodeRequired(glw::GLenum errorCode) const |
| { |
| if (m_errorCodes.empty() && errorCode == GL_NO_ERROR) |
| return true; |
| else |
| // only this error code listed |
| return m_errorCodes.size() == 1 && m_errorCodes.front().errorCode == errorCode; |
| } |
| |
| void ValidStatusCodes::addErrorCode(glw::GLenum error, const char *description) |
| { |
| DE_ASSERT(isErrorCode(error)); |
| DE_ASSERT(error != GL_NO_ERROR); |
| addViolation(m_errorCodes, error, description); |
| } |
| |
| void ValidStatusCodes::addFBOErrorStatus(glw::GLenum status, const char *description) |
| { |
| DE_ASSERT(isFramebufferStatus(status)); |
| DE_ASSERT(status != GL_FRAMEBUFFER_COMPLETE); |
| addViolation(m_errorStatuses, status, description); |
| } |
| |
| void ValidStatusCodes::setAllowComplete(bool b) |
| { |
| m_allowComplete = b; |
| } |
| |
| void ValidStatusCodes::logLegalResults(tcu::TestLog &log) const |
| { |
| tcu::MessageBuilder msg(&log); |
| std::vector<std::string> validResults; |
| |
| for (int ndx = 0; ndx < (int)m_errorCodes.size(); ++ndx) |
| validResults.push_back(std::string(glu::getErrorName(m_errorCodes[ndx].errorCode)) + |
| " (during FBO initialization)"); |
| |
| for (int ndx = 0; ndx < (int)m_errorStatuses.size(); ++ndx) |
| validResults.push_back(glu::getFramebufferStatusName(m_errorStatuses[ndx].errorCode)); |
| |
| if (m_allowComplete) |
| validResults.push_back("GL_FRAMEBUFFER_COMPLETE"); |
| |
| msg << "Expected "; |
| if (validResults.size() > 1) |
| msg << "one of "; |
| |
| for (int ndx = 0; ndx < (int)validResults.size(); ++ndx) |
| { |
| const bool last = ((ndx + 1) == (int)validResults.size()); |
| const bool secondToLast = ((ndx + 2) == (int)validResults.size()); |
| |
| msg << validResults[ndx]; |
| if (!last) |
| msg << ((secondToLast) ? (" or ") : (", ")); |
| } |
| |
| msg << "." << TestLog::EndMessage; |
| } |
| |
| void ValidStatusCodes::logRules(tcu::TestLog &log) const |
| { |
| const tcu::ScopedLogSection section(log, "Rules", "Active rules"); |
| |
| for (int ndx = 0; ndx < (int)m_errorCodes.size(); ++ndx) |
| logRule(log, glu::getErrorName(m_errorCodes[ndx].errorCode), m_errorCodes[ndx].rules); |
| |
| for (int ndx = 0; ndx < (int)m_errorStatuses.size(); ++ndx) |
| logRule(log, glu::getFramebufferStatusName(m_errorStatuses[ndx].errorCode), m_errorStatuses[ndx].rules); |
| |
| if (m_allowComplete) |
| { |
| std::set<std::string> defaultRule; |
| defaultRule.insert("FBO is complete"); |
| logRule(log, "GL_FRAMEBUFFER_COMPLETE", defaultRule); |
| } |
| } |
| |
| void ValidStatusCodes::logRule(tcu::TestLog &log, const std::string &ruleName, const std::set<std::string> &rules) const |
| { |
| if (!rules.empty()) |
| { |
| const tcu::ScopedLogSection section(log, ruleName, ruleName); |
| tcu::MessageBuilder msg(&log); |
| |
| msg << "Rules:\n"; |
| for (std::set<std::string>::const_iterator it = rules.begin(); it != rules.end(); ++it) |
| msg << "\t * " << *it << "\n"; |
| msg << TestLog::EndMessage; |
| } |
| } |
| |
| void ValidStatusCodes::addViolation(std::vector<RuleViolation> &dst, glw::GLenum code, const char *description) const |
| { |
| // rule violation already exists? |
| for (int ndx = 0; ndx < (int)dst.size(); ++ndx) |
| { |
| if (dst[ndx].errorCode == code) |
| { |
| dst[ndx].rules.insert(std::string(description)); |
| return; |
| } |
| } |
| |
| // new violation |
| { |
| RuleViolation violation; |
| |
| violation.errorCode = code; |
| violation.rules.insert(std::string(description)); |
| |
| dst.push_back(violation); |
| } |
| } |
| |
| FboBuilder::FboBuilder(GLuint fbo, GLenum target, const glw::Functions &gl) |
| : m_error(GL_NO_ERROR) |
| , m_target(target) |
| , m_gl(gl) |
| { |
| m_gl.bindFramebuffer(m_target, fbo); |
| } |
| |
| FboBuilder::~FboBuilder(void) |
| { |
| for (TextureMap::const_iterator it = textures.begin(); it != textures.end(); it++) |
| { |
| glDelete(*it->second, it->first, m_gl); |
| } |
| for (RboMap::const_iterator it = rbos.begin(); it != rbos.end(); it++) |
| { |
| glDelete(*it->second, it->first, m_gl); |
| } |
| m_gl.bindFramebuffer(m_target, 0); |
| for (Configs::const_iterator it = m_configs.begin(); it != m_configs.end(); it++) |
| { |
| delete *it; |
| } |
| } |
| |
| void FboBuilder::checkError(void) |
| { |
| const GLenum error = m_gl.getError(); |
| if (error != GL_NO_ERROR && m_error == GL_NO_ERROR) |
| m_error = error; |
| } |
| |
| void FboBuilder::glAttach(GLenum attPoint, const Attachment *att) |
| { |
| if (att == NULL) |
| m_gl.framebufferRenderbuffer(m_target, attPoint, GL_RENDERBUFFER, 0); |
| else |
| attachAttachment(*att, attPoint, m_gl); |
| checkError(); |
| attach(attPoint, att); |
| } |
| |
| GLuint FboBuilder::glCreateTexture(const Texture &texCfg) |
| { |
| const GLuint texName = glCreate(texCfg, m_gl); |
| checkError(); |
| setTexture(texName, texCfg); |
| return texName; |
| } |
| |
| GLuint FboBuilder::glCreateRbo(const Renderbuffer &rbCfg) |
| { |
| const GLuint rbName = glCreate(rbCfg, m_gl); |
| checkError(); |
| setRbo(rbName, rbCfg); |
| return rbName; |
| } |
| |
| TransferFormat transferImageFormat(const ImageFormat &imgFormat) |
| { |
| if (imgFormat.unsizedType == GL_NONE) |
| return getTransferFormat(mapGLInternalFormat(imgFormat.format)); |
| else |
| return TransferFormat(imgFormat.format, imgFormat.unsizedType); |
| } |
| |
| } // namespace FboUtil |
| } // namespace gls |
| } // namespace deqp |
