#ifndef _GLSFBOUTIL_HPP
|
#define _GLSFBOUTIL_HPP
|
|
/*-------------------------------------------------------------------------
|
* 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 "gluRenderContext.hpp"
|
#include "gluContextInfo.hpp"
|
#include "glwDefs.hpp"
|
#include "glwEnums.hpp"
|
#include "glwFunctions.hpp"
|
#include "gluTextureUtil.hpp"
|
#include "tcuTestLog.hpp"
|
#include "tcuDefs.hpp"
|
|
#include <map>
|
#include <set>
|
#include <vector>
|
#include <algorithm>
|
#include <iterator>
|
|
namespace deqp
|
{
|
namespace gls
|
{
|
|
//! A pair of iterators to present a range.
|
//! \note This must be POD to allow static initialization.
|
//! \todo [2013-12-03 lauri] Move this to decpp?
|
template <typename T>
|
struct Range
|
{
|
typedef const T* const_iterator;
|
|
const T* m_begin;
|
const T* m_end;
|
|
const T* begin (void) const { return m_begin; }
|
const T* end (void) const { return m_end; }
|
};
|
|
#define GLS_ARRAY_RANGE(ARR) { DE_ARRAY_BEGIN(ARR), DE_ARRAY_END(ARR) }
|
|
#define GLS_NULL_RANGE { DE_NULL, DE_NULL }
|
|
|
//! A pair type that, unlike stl::pair, is POD so it can be statically initialized.
|
template <typename T1, typename T2>
|
struct Pair
|
{
|
typedef T1 first_type;
|
typedef T2 second_type;
|
T1 first;
|
T2 second;
|
};
|
|
namespace FboUtil
|
{
|
|
//! Configurations for framebuffer objects and their attachments.
|
|
class FboVerifier;
|
class FboBuilder;
|
|
typedef deUint32 FormatKey;
|
|
#define GLS_UNSIZED_FORMATKEY(FORMAT, TYPE) \
|
(deUint32(TYPE) << 16 | deUint32(FORMAT))
|
|
typedef Range<FormatKey> FormatKeys;
|
|
struct ImageFormat
|
{
|
glw::GLenum format;
|
|
//! Type if format is unsized, GL_NONE if sized.
|
glw::GLenum unsizedType;
|
|
bool operator< (const ImageFormat& other) const
|
{
|
return (format < other.format ||
|
(format == other.format && unsizedType < other.unsizedType));
|
}
|
|
static ImageFormat none (void)
|
{
|
ImageFormat fmt = { GL_NONE, GL_NONE };
|
return fmt;
|
}
|
};
|
|
std::ostream& operator<< (std::ostream& stream, const ImageFormat& format);
|
|
static inline ImageFormat formatKeyInfo(FormatKey key)
|
{
|
ImageFormat fmt = { key & 0xffff, key >> 16 };
|
return fmt;
|
}
|
|
enum FormatFlags
|
{
|
ANY_FORMAT = 0,
|
COLOR_RENDERABLE = 1 << 0,
|
DEPTH_RENDERABLE = 1 << 1,
|
STENCIL_RENDERABLE = 1 << 2,
|
RENDERBUFFER_VALID = 1 << 3,
|
TEXTURE_VALID = 1 << 4,
|
REQUIRED_RENDERABLE = 1 << 5, //< Without this, renderability is allowed, not required.
|
};
|
|
static inline FormatFlags operator|(FormatFlags f1, FormatFlags f2)
|
{
|
return FormatFlags(deUint32(f1) | deUint32(f2));
|
}
|
|
FormatFlags formatFlag(glw::GLenum context);
|
|
typedef std::set<ImageFormat> Formats;
|
|
class FormatDB
|
{
|
public:
|
void addCoreFormat (ImageFormat format, FormatFlags flags);
|
void addExtensionFormat (ImageFormat format, FormatFlags flags, const std::set<std::string>& requiredExtensions);
|
|
Formats getFormats (FormatFlags requirements) const;
|
bool isKnownFormat (ImageFormat format) const;
|
FormatFlags getFormatInfo (ImageFormat format) const;
|
std::set<std::set<std::string> > getFormatFeatureExtensions (ImageFormat format, FormatFlags requirements) const;
|
|
private:
|
struct ExtensionInfo
|
{
|
FormatFlags flags;
|
std::set<std::string> requiredExtensions;
|
|
bool operator< (const ExtensionInfo& other) const;
|
};
|
|
typedef std::map<ImageFormat, FormatFlags> FormatMap;
|
typedef std::map<ImageFormat, std::set<ExtensionInfo> > FormatExtensionMap;
|
|
FormatMap m_formatFlags;
|
FormatExtensionMap m_formatExtensions;
|
};
|
|
typedef Pair<FormatFlags, FormatKeys> FormatEntry;
|
typedef Range<FormatEntry> FormatEntries;
|
|
// \todo [2013-12-20 lauri] It turns out that format properties in extensions
|
// are actually far too fine-grained for this bundling to be reasonable,
|
// especially given the syntactic cumbersomeness of static arrays. It's better
|
// to list each entry separately.
|
|
struct FormatExtEntry
|
{
|
const char* extensions;
|
deUint32 flags;
|
Range<FormatKey> formats;
|
};
|
|
typedef Range<FormatExtEntry> FormatExtEntries;
|
|
// Check support for GL_* and DEQP_* extensions
|
bool checkExtensionSupport (const glu::RenderContext& ctx, const std::string& extension);
|
|
// Accepts GL_* and DEQP_* extension strings and converts DEQP_* strings to a human readable string
|
std::string getExtensionDescription (const std::string& extensionName);
|
|
void addFormats (FormatDB& db, FormatEntries stdFmts);
|
void addExtFormats (FormatDB& db, FormatExtEntries extFmts, const glu::RenderContext* ctx);
|
glu::TransferFormat transferImageFormat (const ImageFormat& imgFormat);
|
|
namespace config
|
{
|
|
struct Config
|
{
|
virtual ~Config (void) {};
|
};
|
|
struct Image : public Config
|
{
|
ImageFormat internalFormat;
|
glw::GLsizei width;
|
glw::GLsizei height;
|
|
protected:
|
Image (void)
|
: internalFormat (ImageFormat::none())
|
, width (0)
|
, height (0) {}
|
};
|
|
struct Renderbuffer : public Image
|
{
|
Renderbuffer (void) : numSamples(0) {}
|
|
glw::GLsizei numSamples;
|
};
|
|
struct Texture : public Image
|
{
|
Texture (void) : numLevels(1) {}
|
|
glw::GLint numLevels;
|
};
|
|
struct TextureFlat : public Texture
|
{
|
};
|
|
struct Texture2D : public TextureFlat
|
{
|
};
|
|
struct TextureCubeMap : public TextureFlat
|
{
|
};
|
|
struct TextureLayered : public Texture
|
{
|
TextureLayered (void) : numLayers(1) {}
|
glw::GLsizei numLayers;
|
};
|
|
struct Texture3D : public TextureLayered
|
{
|
};
|
|
struct Texture2DArray : public TextureLayered
|
{
|
};
|
|
struct Attachment : public Config
|
{
|
Attachment (void) : target(GL_FRAMEBUFFER), imageName(0) {}
|
|
glw::GLenum target;
|
glw::GLuint imageName;
|
|
//! Returns `true` iff this attachment is "framebuffer attachment
|
//! complete" when bound to attachment point `attPoint`, and the current
|
//! image with name `imageName` is `image`, using `vfr` to check format
|
//! renderability.
|
bool isComplete (glw::GLenum attPoint, const Image* image,
|
const FboVerifier& vfr) const;
|
};
|
|
struct RenderbufferAttachment : public Attachment
|
{
|
RenderbufferAttachment (void)
|
: renderbufferTarget(GL_RENDERBUFFER) {}
|
|
glw::GLenum renderbufferTarget;
|
};
|
|
struct TextureAttachment : public Attachment
|
{
|
TextureAttachment (void) : level(0) {}
|
|
glw::GLint level;
|
};
|
|
struct TextureFlatAttachment : public TextureAttachment
|
{
|
TextureFlatAttachment (void) : texTarget(GL_NONE) {}
|
|
glw::GLenum texTarget;
|
};
|
|
struct TextureLayerAttachment : public TextureAttachment
|
{
|
TextureLayerAttachment (void) : layer(0) {}
|
|
glw::GLsizei layer;
|
};
|
|
glw::GLenum attachmentType (const Attachment& att);
|
glw::GLsizei imageNumSamples (const Image& img);
|
|
//! Mapping from attachment points to attachment configurations.
|
typedef std::map<glw::GLenum, const Attachment*> AttachmentMap;
|
|
//! Mapping from object names to texture configurations.
|
typedef std::map<glw::GLuint, const Texture*> TextureMap;
|
|
//! Mapping from object names to renderbuffer configurations.
|
typedef std::map<glw::GLuint, const Renderbuffer*> RboMap;
|
|
//! A framebuffer configuration.
|
struct Framebuffer
|
{
|
AttachmentMap attachments;
|
TextureMap textures;
|
RboMap rbos;
|
|
void attach (glw::GLenum attPoint, const Attachment* att);
|
void setTexture (glw::GLuint texName, const Texture& texCfg);
|
void setRbo (glw::GLuint rbName, const Renderbuffer& rbCfg);
|
const Image* getImage (glw::GLenum type, glw::GLuint imgName) const;
|
};
|
|
} // config
|
|
class FboBuilder : public config::Framebuffer
|
{
|
public:
|
void glAttach (glw::GLenum attPoint,
|
const config::Attachment* att);
|
glw::GLuint glCreateTexture (const config::Texture& texCfg);
|
glw::GLuint glCreateRbo (const config::Renderbuffer& rbCfg);
|
FboBuilder (glw::GLuint fbo, glw::GLenum target,
|
const glw::Functions& gl);
|
~FboBuilder (void);
|
glw::GLenum getError (void) { return m_error; }
|
|
//! Allocate a new configuration of type `Config` (which must be a
|
//! subclass of `config::Config`), and return a referenc to it. The newly
|
//! allocated object will be freed when this builder object is destroyed.
|
template<typename Config>
|
Config& makeConfig (void)
|
{
|
Config* cfg = new Config();
|
m_configs.insert(cfg);
|
return *cfg;
|
}
|
|
private:
|
typedef std::set<config::Config*> Configs;
|
|
void checkError (void);
|
|
glw::GLenum m_error; //< The first GL error encountered.
|
glw::GLenum m_target;
|
const glw::Functions& m_gl;
|
Configs m_configs;
|
};
|
|
struct ValidStatusCodes
|
{
|
ValidStatusCodes (void);
|
|
bool isFBOStatusValid (glw::GLenum fboStatus) const;
|
bool isFBOStatusRequired (glw::GLenum fboStatus) const;
|
bool isErrorCodeValid (glw::GLenum errorCode) const;
|
bool isErrorCodeRequired (glw::GLenum errorCode) const;
|
|
void addErrorCode (glw::GLenum error, const char* description);
|
void addFBOErrorStatus (glw::GLenum status, const char* description);
|
void setAllowComplete (bool);
|
|
void logLegalResults (tcu::TestLog& log) const;
|
void logRules (tcu::TestLog& log) const;
|
|
private:
|
struct RuleViolation
|
{
|
glw::GLenum errorCode;
|
std::set<std::string> rules;
|
};
|
|
void logRule (tcu::TestLog& log, const std::string& ruleName, const std::set<std::string>& rules) const;
|
void addViolation (std::vector<RuleViolation>& dst, glw::GLenum code, const char* description) const;
|
|
std::vector<RuleViolation> m_errorCodes; //!< Allowed GL errors, GL_NO_ERROR is not allowed
|
std::vector<RuleViolation> m_errorStatuses; //!< Allowed FBO error statuses, GL_FRAMEBUFFER_COMPLETE is not allowed
|
bool m_allowComplete; //!< true if (GL_NO_ERROR && GL_FRAMEBUFFER_COMPLETE) is allowed
|
};
|
|
void logFramebufferConfig (const config::Framebuffer& cfg, tcu::TestLog& log);
|
|
class Checker
|
{
|
public:
|
Checker (const glu::RenderContext&);
|
virtual ~Checker (void) {}
|
|
void addGLError (glw::GLenum error, const char* description);
|
void addPotentialGLError (glw::GLenum error, const char* description);
|
void addFBOStatus (glw::GLenum status, const char* description);
|
void addPotentialFBOStatus (glw::GLenum status, const char* description);
|
|
ValidStatusCodes getStatusCodes (void) { return m_statusCodes; }
|
|
virtual void check (glw::GLenum attPoint,
|
const config::Attachment& att,
|
const config::Image* image) = 0;
|
|
protected:
|
const glu::RenderContext& m_renderCtx;
|
|
private:
|
ValidStatusCodes m_statusCodes; //< Allowed return values for glCheckFramebufferStatus.
|
};
|
|
class CheckerFactory
|
{
|
public:
|
virtual Checker* createChecker (const glu::RenderContext&) = 0;
|
};
|
|
typedef std::set<glw::GLenum> AttachmentPoints;
|
typedef std::set<ImageFormat> Formats;
|
|
class FboVerifier
|
{
|
public:
|
FboVerifier (const FormatDB& formats,
|
CheckerFactory& factory,
|
const glu::RenderContext& renderCtx);
|
|
ValidStatusCodes validStatusCodes (const config::Framebuffer& cfg) const;
|
|
private:
|
const FormatDB& m_formats;
|
CheckerFactory& m_factory;
|
const glu::RenderContext& m_renderCtx;
|
};
|
|
} // FboUtil
|
} // gls
|
} // deqp
|
|
#endif // _GLSFBOUTIL_HPP
|
