qsurfaceformat.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsurfaceformat.h"
 
#include <QtCore/qatomic.h>
#include <QtCore/QDebug>
#include <QOpenGLContext>
#include <QtGui/qcolorspace.h>
#include <QtGui/qguiapplication.h>
 
#ifdef major
#undef major
#endif
 
#ifdef minor
#undef minor
#endif
 
QT_BEGIN_NAMESPACE
 
class QSurfaceFormatPrivate
{
public:
    explicit QSurfaceFormatPrivate(QSurfaceFormat::FormatOptions _opts = { })
        : ref(1)
        , opts(_opts)
        , redBufferSize(-1)
        , greenBufferSize(-1)
        , blueBufferSize(-1)
        , alphaBufferSize(-1)
        , depthSize(-1)
        , stencilSize(-1)
        , swapBehavior(QSurfaceFormat::DefaultSwapBehavior)
        , numSamples(-1)
        , renderableType(QSurfaceFormat::DefaultRenderableType)
        , profile(QSurfaceFormat::NoProfile)
        , major(2)
        , minor(0)
        , swapInterval(1) // default to vsync
    {
    }
 
    QSurfaceFormatPrivate(const QSurfaceFormatPrivate *other)
        : ref(1),
          opts(other->opts),
          redBufferSize(other->redBufferSize),
          greenBufferSize(other->greenBufferSize),
          blueBufferSize(other->blueBufferSize),
          alphaBufferSize(other->alphaBufferSize),
          depthSize(other->depthSize),
          stencilSize(other->stencilSize),
          swapBehavior(other->swapBehavior),
          numSamples(other->numSamples),
          renderableType(other->renderableType),
          profile(other->profile),
          major(other->major),
          minor(other->minor),
          swapInterval(other->swapInterval),
          colorSpace(other->colorSpace)
    {
    }
 
    QAtomicInt ref;
    QSurfaceFormat::FormatOptions opts;
    int redBufferSize;
    int greenBufferSize;
    int blueBufferSize;
    int alphaBufferSize;
    int depthSize;
    int stencilSize;
    QSurfaceFormat::SwapBehavior swapBehavior;
    int numSamples;
    QSurfaceFormat::RenderableType renderableType;
    QSurfaceFormat::OpenGLContextProfile profile;
    int major;
    int minor;
    int swapInterval;
    QColorSpace colorSpace;
};
 
QSurfaceFormat::QSurfaceFormat() : d(new QSurfaceFormatPrivate)
{
}
 
QSurfaceFormat::QSurfaceFormat(QSurfaceFormat::FormatOptions options) :
    d(new QSurfaceFormatPrivate(options))
{
}
 
void QSurfaceFormat::detach()
{
    if (d->ref.loadRelaxed() != 1) {
        QSurfaceFormatPrivate *newd = new QSurfaceFormatPrivate(d);
        if (!d->ref.deref())
            delete d;
        d = newd;
    }
}
 
QSurfaceFormat::QSurfaceFormat(const QSurfaceFormat &other)
{
    d = other.d;
    d->ref.ref();
}
 
QSurfaceFormat &QSurfaceFormat::operator=(const QSurfaceFormat &other)
{
    if (d != other.d) {
        other.d->ref.ref();
        if (!d->ref.deref())
            delete d;
        d = other.d;
    }
    return *this;
}
 
QSurfaceFormat::~QSurfaceFormat()
{
    if (!d->ref.deref())
        delete d;
}
 
void QSurfaceFormat::setStereo(bool enable)
{
    QSurfaceFormat::FormatOptions newOptions = d->opts;
    newOptions.setFlag(QSurfaceFormat::StereoBuffers, enable);
 
    if (int(newOptions) != int(d->opts)) {
        detach();
        d->opts = newOptions;
    }
}
 
int QSurfaceFormat::samples() const
{
   return d->numSamples;
}
 
void QSurfaceFormat::setSamples(int numSamples)
{
    if (d->numSamples != numSamples) {
        detach();
        d->numSamples = numSamples;
    }
}
 
void QSurfaceFormat::setOptions(QSurfaceFormat::FormatOptions options)
{
    if (int(d->opts) != int(options)) {
        detach();
        d->opts = options;
    }
}
 
void QSurfaceFormat::setOption(QSurfaceFormat::FormatOption option, bool on)
{
    if (testOption(option) == on)
        return;
    detach();
    if (on)
        d->opts |= option;
    else
        d->opts &= ~option;
}
 
bool QSurfaceFormat::testOption(QSurfaceFormat::FormatOption option) const
{
    return d->opts & option;
}
 
QSurfaceFormat::FormatOptions QSurfaceFormat::options() const
{
    return d->opts;
}
 
void QSurfaceFormat::setDepthBufferSize(int size)
{
    if (d->depthSize != size) {
        detach();
        d->depthSize = size;
    }
}
 
int QSurfaceFormat::depthBufferSize() const
{
   return d->depthSize;
}
 
void QSurfaceFormat::setSwapBehavior(SwapBehavior behavior)
{
    if (d->swapBehavior != behavior) {
        detach();
        d->swapBehavior = behavior;
    }
}
 
QSurfaceFormat::SwapBehavior QSurfaceFormat::swapBehavior() const
{
    return d->swapBehavior;
}
 
bool QSurfaceFormat::hasAlpha() const
{
    return d->alphaBufferSize > 0;
}
 
void QSurfaceFormat::setStencilBufferSize(int size)
{
    if (d->stencilSize != size) {
        detach();
        d->stencilSize = size;
    }
}
 
int QSurfaceFormat::stencilBufferSize() const
{
   return d->stencilSize;
}
 
int QSurfaceFormat::redBufferSize() const
{
    return d->redBufferSize;
}
 
int QSurfaceFormat::greenBufferSize() const
{
    return d->greenBufferSize;
}
 
int QSurfaceFormat::blueBufferSize() const
{
    return d->blueBufferSize;
}
 
int QSurfaceFormat::alphaBufferSize() const
{
    return d->alphaBufferSize;
}
 
void QSurfaceFormat::setRedBufferSize(int size)
{
    if (d->redBufferSize != size) {
        detach();
        d->redBufferSize = size;
    }
}
 
void QSurfaceFormat::setGreenBufferSize(int size)
{
    if (d->greenBufferSize != size) {
        detach();
        d->greenBufferSize = size;
    }
}
 
void QSurfaceFormat::setBlueBufferSize(int size)
{
    if (d->blueBufferSize != size) {
        detach();
        d->blueBufferSize = size;
    }
}
 
void QSurfaceFormat::setAlphaBufferSize(int size)
{
    if (d->alphaBufferSize != size) {
        detach();
        d->alphaBufferSize = size;
    }
}
 
void QSurfaceFormat::setRenderableType(RenderableType type)
{
    if (d->renderableType != type) {
        detach();
        d->renderableType = type;
    }
}
 
QSurfaceFormat::RenderableType QSurfaceFormat::renderableType() const
{
    return d->renderableType;
}
 
void QSurfaceFormat::setProfile(OpenGLContextProfile profile)
{
    if (d->profile != profile) {
        detach();
        d->profile = profile;
    }
}
 
QSurfaceFormat::OpenGLContextProfile QSurfaceFormat::profile() const
{
    return d->profile;
}
 
void QSurfaceFormat::setMajorVersion(int major)
{
    if (d->major != major) {
        detach();
        d->major = major;
    }
}
 
int QSurfaceFormat::majorVersion() const
{
    return d->major;
}
 
void QSurfaceFormat::setMinorVersion(int minor)
{
    if (d->minor != minor) {
        detach();
        d->minor = minor;
    }
}
 
int QSurfaceFormat::minorVersion() const
{
    return d->minor;
}
 
QPair<int, int> QSurfaceFormat::version() const
{
    return qMakePair(d->major, d->minor);
}
 
void QSurfaceFormat::setVersion(int major, int minor)
{
    if (d->minor != minor || d->major != major) {
        detach();
        d->minor = minor;
        d->major = major;
    }
}
 
void QSurfaceFormat::setSwapInterval(int interval)
{
    if (d->swapInterval != interval) {
        detach();
        d->swapInterval = interval;
    }
}
 
int QSurfaceFormat::swapInterval() const
{
    return d->swapInterval;
}
 
void QSurfaceFormat::setColorSpace(const QColorSpace &colorSpace)
{
    if (d->colorSpace != colorSpace) {
        detach();
        d->colorSpace = colorSpace;
    }
}
 
#if QT_DEPRECATED_SINCE(6, 0)
void QSurfaceFormat::setColorSpace(ColorSpace colorSpace)
{
    switch (colorSpace) {
    case DefaultColorSpace:
        setColorSpace(QColorSpace());
        break;
    case sRGBColorSpace:
        setColorSpace(QColorSpace::SRgb);
        break;
    }
}
#endif // QT_DEPRECATED_SINCE(6, 0)
 
const QColorSpace &QSurfaceFormat::colorSpace() const
{
    return d->colorSpace;
}
 
Q_GLOBAL_STATIC(QSurfaceFormat, qt_default_surface_format)
 
 
void QSurfaceFormat::setDefaultFormat(const QSurfaceFormat &format)
{
#ifndef QT_NO_OPENGL
    if (qApp) {
        QOpenGLContext *globalContext = QOpenGLContext::globalShareContext();
        if (globalContext && globalContext->isValid()) {
            qWarning("Warning: Setting a new default format with a different version or profile "
                     "after the global shared context is created may cause issues with context "
                     "sharing.");
        }
    }
#endif
    *qt_default_surface_format() = format;
}
 
QSurfaceFormat QSurfaceFormat::defaultFormat()
{
    return *qt_default_surface_format();
}
 
bool QSurfaceFormat::equals(const QSurfaceFormat& other) const noexcept
{
    return (d == other.d) || ((int) d->opts == (int) other.d->opts
        && d->stencilSize == other.d->stencilSize
        && d->redBufferSize == other.d->redBufferSize
        && d->greenBufferSize == other.d->greenBufferSize
        && d->blueBufferSize == other.d->blueBufferSize
        && d->alphaBufferSize == other.d->alphaBufferSize
        && d->depthSize == other.d->depthSize
        && d->numSamples == other.d->numSamples
        && d->swapBehavior == other.d->swapBehavior
        && d->profile == other.d->profile
        && d->major == other.d->major
        && d->minor == other.d->minor
        && d->swapInterval == other.d->swapInterval);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QSurfaceFormat &f)
{
    const QSurfaceFormatPrivate * const d = f.d;
    QDebugStateSaver saver(dbg);
 
    dbg.nospace() << "QSurfaceFormat("
                  << "version " << d->major << '.' << d->minor
                  << ", options " << d->opts
                  << ", depthBufferSize " << d->depthSize
                  << ", redBufferSize " << d->redBufferSize
                  << ", greenBufferSize " << d->greenBufferSize
                  << ", blueBufferSize " << d->blueBufferSize
                  << ", alphaBufferSize " << d->alphaBufferSize
                  << ", stencilBufferSize " << d->stencilSize
                  << ", samples " << d->numSamples
                  << ", swapBehavior " << d->swapBehavior
                  << ", swapInterval " << d->swapInterval
                  << ", colorSpace " << d->colorSpace
                  << ", profile  " << d->profile
                  << ')';
 
    return dbg;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qsurfaceformat.cpp"