/**************************************************************************** ** ** Copyright (C) 2016 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtOpenGL module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 3 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL3 included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 3 requirements ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 2.0 or (at your option) the GNU General ** Public license version 3 or any later version approved by the KDE Free ** Qt Foundation. The licenses are as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 ** included in the packaging of this file. Please review the following ** information to ensure the GNU General Public License requirements will ** be met: https://www.gnu.org/licenses/gpl-2.0.html and ** https://www.gnu.org/licenses/gpl-3.0.html. ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #ifndef QGL_H #define QGL_H #ifndef QT_NO_OPENGL #include #include #include #include #include #include #include QT_BEGIN_NAMESPACE class QPixmap; class QGLWidgetPrivate; class QGLContextPrivate; // Namespace class: namespace QGL { enum FormatOption { DoubleBuffer = 0x0001, DepthBuffer = 0x0002, Rgba = 0x0004, AlphaChannel = 0x0008, AccumBuffer = 0x0010, StencilBuffer = 0x0020, StereoBuffers = 0x0040, DirectRendering = 0x0080, HasOverlay = 0x0100, SampleBuffers = 0x0200, DeprecatedFunctions = 0x0400, SingleBuffer = DoubleBuffer << 16, NoDepthBuffer = DepthBuffer << 16, ColorIndex = Rgba << 16, NoAlphaChannel = AlphaChannel << 16, NoAccumBuffer = AccumBuffer << 16, NoStencilBuffer = StencilBuffer << 16, NoStereoBuffers = StereoBuffers << 16, IndirectRendering = DirectRendering << 16, NoOverlay = HasOverlay << 16, NoSampleBuffers = SampleBuffers << 16, NoDeprecatedFunctions = DeprecatedFunctions << 16 }; Q_DECLARE_FLAGS(FormatOptions, FormatOption) } Q_DECLARE_OPERATORS_FOR_FLAGS(QGL::FormatOptions) class QGLFormatPrivate; class Q_OPENGL_EXPORT QGLFormat { public: QGLFormat(); QGLFormat(QGL::FormatOptions options, int plane = 0); QGLFormat(const QGLFormat &other); QGLFormat &operator=(const QGLFormat &other); ~QGLFormat(); void setDepthBufferSize(int size); int depthBufferSize() const; void setAccumBufferSize(int size); int accumBufferSize() const; void setRedBufferSize(int size); int redBufferSize() const; void setGreenBufferSize(int size); int greenBufferSize() const; void setBlueBufferSize(int size); int blueBufferSize() const; void setAlphaBufferSize(int size); int alphaBufferSize() const; void setStencilBufferSize(int size); int stencilBufferSize() const; void setSampleBuffers(bool enable); bool sampleBuffers() const; void setSamples(int numSamples); int samples() const; void setSwapInterval(int interval); int swapInterval() const; bool doubleBuffer() const; void setDoubleBuffer(bool enable); bool depth() const; void setDepth(bool enable); bool rgba() const; void setRgba(bool enable); bool alpha() const; void setAlpha(bool enable); bool accum() const; void setAccum(bool enable); bool stencil() const; void setStencil(bool enable); bool stereo() const; void setStereo(bool enable); bool directRendering() const; void setDirectRendering(bool enable); bool hasOverlay() const; void setOverlay(bool enable); int plane() const; void setPlane(int plane); void setOption(QGL::FormatOptions opt); bool testOption(QGL::FormatOptions opt) const; static QGLFormat defaultFormat(); static void setDefaultFormat(const QGLFormat& f); static QGLFormat defaultOverlayFormat(); static void setDefaultOverlayFormat(const QGLFormat& f); static bool hasOpenGL(); static bool hasOpenGLOverlays(); void setVersion(int major, int minor); int majorVersion() const; int minorVersion() const; enum OpenGLContextProfile { NoProfile, CoreProfile, CompatibilityProfile }; void setProfile(OpenGLContextProfile profile); OpenGLContextProfile profile() const; enum OpenGLVersionFlag { OpenGL_Version_None = 0x00000000, OpenGL_Version_1_1 = 0x00000001, OpenGL_Version_1_2 = 0x00000002, OpenGL_Version_1_3 = 0x00000004, OpenGL_Version_1_4 = 0x00000008, OpenGL_Version_1_5 = 0x00000010, OpenGL_Version_2_0 = 0x00000020, OpenGL_Version_2_1 = 0x00000040, OpenGL_ES_Common_Version_1_0 = 0x00000080, OpenGL_ES_CommonLite_Version_1_0 = 0x00000100, OpenGL_ES_Common_Version_1_1 = 0x00000200, OpenGL_ES_CommonLite_Version_1_1 = 0x00000400, OpenGL_ES_Version_2_0 = 0x00000800, OpenGL_Version_3_0 = 0x00001000, OpenGL_Version_3_1 = 0x00002000, OpenGL_Version_3_2 = 0x00004000, OpenGL_Version_3_3 = 0x00008000, OpenGL_Version_4_0 = 0x00010000, OpenGL_Version_4_1 = 0x00020000, OpenGL_Version_4_2 = 0x00040000, OpenGL_Version_4_3 = 0x00080000 }; Q_DECLARE_FLAGS(OpenGLVersionFlags, OpenGLVersionFlag) static OpenGLVersionFlags openGLVersionFlags(); static QGLFormat fromSurfaceFormat(const QSurfaceFormat &format); static QSurfaceFormat toSurfaceFormat(const QGLFormat &format); private: QGLFormatPrivate *d; void detach(); friend Q_OPENGL_EXPORT bool operator==(const QGLFormat&, const QGLFormat&); friend Q_OPENGL_EXPORT bool operator!=(const QGLFormat&, const QGLFormat&); #ifndef QT_NO_DEBUG_STREAM friend Q_OPENGL_EXPORT QDebug operator<<(QDebug, const QGLFormat &); #endif }; Q_DECLARE_OPERATORS_FOR_FLAGS(QGLFormat::OpenGLVersionFlags) Q_OPENGL_EXPORT bool operator==(const QGLFormat&, const QGLFormat&); Q_OPENGL_EXPORT bool operator!=(const QGLFormat&, const QGLFormat&); #ifndef QT_NO_DEBUG_STREAM Q_OPENGL_EXPORT QDebug operator<<(QDebug, const QGLFormat &); #endif class QGLFunctions; class Q_OPENGL_EXPORT QGLContext { Q_DECLARE_PRIVATE(QGLContext) public: QGLContext(const QGLFormat& format, QPaintDevice* device); QGLContext(const QGLFormat& format); virtual ~QGLContext(); virtual bool create(const QGLContext* shareContext = nullptr); bool isValid() const; bool isSharing() const; void reset(); static bool areSharing(const QGLContext *context1, const QGLContext *context2); QGLFormat format() const; QGLFormat requestedFormat() const; void setFormat(const QGLFormat& format); void moveToThread(QThread *thread); virtual void makeCurrent(); virtual void doneCurrent(); virtual void swapBuffers() const; QGLFunctions *functions() const; enum BindOption { NoBindOption = 0x0000, InvertedYBindOption = 0x0001, MipmapBindOption = 0x0002, PremultipliedAlphaBindOption = 0x0004, LinearFilteringBindOption = 0x0008, MemoryManagedBindOption = 0x0010, // internal flag CanFlipNativePixmapBindOption = 0x0020, // internal flag TemporarilyCachedBindOption = 0x0040, // internal flag DefaultBindOption = LinearFilteringBindOption | InvertedYBindOption | MipmapBindOption, InternalBindOption = MemoryManagedBindOption | PremultipliedAlphaBindOption }; Q_DECLARE_FLAGS(BindOptions, BindOption) GLuint bindTexture(const QImage &image, GLenum target, GLint format, BindOptions options); GLuint bindTexture(const QPixmap &pixmap, GLenum target, GLint format, BindOptions options); GLuint bindTexture(const QImage &image, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA); GLuint bindTexture(const QPixmap &pixmap, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA); GLuint bindTexture(const QString &fileName); void deleteTexture(GLuint tx_id); void drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D); void drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D); static void setTextureCacheLimit(int size); static int textureCacheLimit(); QFunctionPointer getProcAddress(const QString &proc) const; QPaintDevice* device() const; QColor overlayTransparentColor() const; static const QGLContext* currentContext(); static QGLContext *fromOpenGLContext(QOpenGLContext *platformContext); QOpenGLContext *contextHandle() const; protected: virtual bool chooseContext(const QGLContext* shareContext = nullptr); bool deviceIsPixmap() const; bool windowCreated() const; void setWindowCreated(bool on); bool initialized() const; void setInitialized(bool on); uint colorIndex(const QColor& c) const; void setValid(bool valid); void setDevice(QPaintDevice *pDev); protected: static QGLContext* currentCtx; private: QGLContext(QOpenGLContext *windowContext); QScopedPointer d_ptr; friend class QGLPixelBuffer; friend class QGLPixelBufferPrivate; friend class QGLWidget; friend class QGLWidgetPrivate; friend class QGLGlyphCache; friend class QGL2PaintEngineEx; friend class QGL2PaintEngineExPrivate; friend class QGLEngineShaderManager; friend class QGLTextureGlyphCache; friend struct QGLGlyphTexture; friend class QGLContextGroup; friend class QGLPixmapBlurFilter; friend class QGLTexture; friend QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags(); friend class QGLFramebufferObject; friend class QGLFramebufferObjectPrivate; friend class QGLFBOGLPaintDevice; friend class QGLPaintDevice; friend class QGLWidgetGLPaintDevice; friend class QX11GLSharedContexts; friend class QGLContextResourceBase; friend class QSGDistanceFieldGlyphCache; private: Q_DISABLE_COPY(QGLContext) }; Q_DECLARE_OPERATORS_FOR_FLAGS(QGLContext::BindOptions) class Q_OPENGL_EXPORT QGLWidget : public QWidget { Q_OBJECT Q_DECLARE_PRIVATE(QGLWidget) public: explicit QGLWidget(QWidget* parent=nullptr, const QGLWidget* shareWidget = nullptr, Qt::WindowFlags f=Qt::WindowFlags()); explicit QGLWidget(QGLContext *context, QWidget* parent=nullptr, const QGLWidget* shareWidget = nullptr, Qt::WindowFlags f=Qt::WindowFlags()); explicit QGLWidget(const QGLFormat& format, QWidget* parent=nullptr, const QGLWidget* shareWidget = nullptr, Qt::WindowFlags f=Qt::WindowFlags()); ~QGLWidget(); void qglColor(const QColor& c) const; void qglClearColor(const QColor& c) const; bool isValid() const; bool isSharing() const; void makeCurrent(); void doneCurrent(); bool doubleBuffer() const; void swapBuffers(); QGLFormat format() const; void setFormat(const QGLFormat& format); QGLContext* context() const; void setContext(QGLContext* context, const QGLContext* shareContext = nullptr, bool deleteOldContext = true); QPixmap renderPixmap(int w = 0, int h = 0, bool useContext = false); QImage grabFrameBuffer(bool withAlpha = false); void makeOverlayCurrent(); const QGLContext* overlayContext() const; static QImage convertToGLFormat(const QImage& img); const QGLColormap & colormap() const; void setColormap(const QGLColormap & map); void renderText(int x, int y, const QString & str, const QFont & fnt = QFont()); void renderText(double x, double y, double z, const QString & str, const QFont & fnt = QFont()); QPaintEngine *paintEngine() const override; GLuint bindTexture(const QImage &image, GLenum target, GLint format, QGLContext::BindOptions options); GLuint bindTexture(const QPixmap &pixmap, GLenum target, GLint format, QGLContext::BindOptions options); GLuint bindTexture(const QImage &image, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA); GLuint bindTexture(const QPixmap &pixmap, GLenum target = GL_TEXTURE_2D, GLint format = GL_RGBA); GLuint bindTexture(const QString &fileName); void deleteTexture(GLuint tx_id); void drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D); void drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D); public Q_SLOTS: virtual void updateGL(); virtual void updateOverlayGL(); protected: bool event(QEvent *) override; virtual void initializeGL(); virtual void resizeGL(int w, int h); virtual void paintGL(); virtual void initializeOverlayGL(); virtual void resizeOverlayGL(int w, int h); virtual void paintOverlayGL(); void setAutoBufferSwap(bool on); bool autoBufferSwap() const; void paintEvent(QPaintEvent*) override; void resizeEvent(QResizeEvent*) override; virtual void glInit(); virtual void glDraw(); QGLWidget(QGLWidgetPrivate &dd, const QGLFormat &format = QGLFormat(), QWidget *parent = nullptr, const QGLWidget* shareWidget = nullptr, Qt::WindowFlags f = Qt::WindowFlags()); private: Q_DISABLE_COPY(QGLWidget) friend class QGLDrawable; friend class QGLPixelBuffer; friend class QGLPixelBufferPrivate; friend class QGLContext; friend class QGLContextPrivate; friend class QGLOverlayWidget; friend class QGLPaintDevice; friend class QGLWidgetGLPaintDevice; }; // // QGLFormat inline functions // inline bool QGLFormat::doubleBuffer() const { return testOption(QGL::DoubleBuffer); } inline bool QGLFormat::depth() const { return testOption(QGL::DepthBuffer); } inline bool QGLFormat::rgba() const { return testOption(QGL::Rgba); } inline bool QGLFormat::alpha() const { return testOption(QGL::AlphaChannel); } inline bool QGLFormat::accum() const { return testOption(QGL::AccumBuffer); } inline bool QGLFormat::stencil() const { return testOption(QGL::StencilBuffer); } inline bool QGLFormat::stereo() const { return testOption(QGL::StereoBuffers); } inline bool QGLFormat::directRendering() const { return testOption(QGL::DirectRendering); } inline bool QGLFormat::hasOverlay() const { return testOption(QGL::HasOverlay); } inline bool QGLFormat::sampleBuffers() const { return testOption(QGL::SampleBuffers); } QT_END_NAMESPACE #endif // QT_NO_OPENGL #endif // QGL_H