Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 355 insertions, 0 deletions

diff --git a/include/vcl/opengl/OpenGLContext.hxx b/include/vcl/opengl/OpenGLContext.hxx
new file mode 100644
index 000000000..c6807a6fe
--- /dev/null
+++ b/include/vcl/opengl/OpenGLContext.hxx
@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDED_VCL_OPENGL_OPENGLCONTEXT_HXX
+#define INCLUDED_VCL_OPENGL_OPENGLCONTEXT_HXX
+
+#include <epoxy/gl.h>
+
+#include <vcl/dllapi.h>
+#include <vcl/syschild.hxx>
+#include <rtl/ref.hxx>
+
+#include <memory>
+#include <unordered_map>
+
+class OpenGLFramebuffer;
+class OpenGLProgram;
+class OpenGLTexture;
+class RenderState;
+
+/// Holds the information of our new child window
+struct VCL_DLLPUBLIC GLWindow
+{
+    unsigned int            Width;
+    unsigned int            Height;
+    bool bMultiSampleSupported;
+
+    GLWindow()
+        : Width(0)
+        , Height(0)
+        , bMultiSampleSupported(false)
+    {
+    }
+
+    virtual bool Synchronize(bool bOnoff) const;
+
+    virtual ~GLWindow();
+};
+
+struct VCL_DLLPUBLIC OpenGLCapabilitySwitch
+{
+    bool mbLimitedShaderRegisters;
+
+    OpenGLCapabilitySwitch()
+        : mbLimitedShaderRegisters(false)
+    {}
+};
+
+class VCL_DLLPUBLIC OpenGLContext
+{
+    friend class OpenGLTests;
+protected:
+    OpenGLContext();
+public:
+    static rtl::Reference<OpenGLContext> Create();
+    virtual ~OpenGLContext();
+    void acquire() { mnRefCount++; }
+    void release() { if ( --mnRefCount == 0 ) delete this; }
+    void dispose();
+
+    void requestLegacyContext();
+
+    bool init(vcl::Window* pParent);
+
+    void reset();
+
+    // use these methods right after setting a context to make sure drawing happens
+    // in the right FBO (default one is for onscreen painting)
+    void               BindFramebuffer( OpenGLFramebuffer* pFramebuffer );
+    void               AcquireDefaultFramebuffer();
+    OpenGLFramebuffer* AcquireFramebuffer( const OpenGLTexture& rTexture );
+    static void        ReleaseFramebuffer( OpenGLFramebuffer* pFramebuffer );
+    void UnbindTextureFromFramebuffers( GLuint nTexture );
+    static bool        IsTextureAttachedAnywhere( GLuint nTexture );
+
+    void               ReleaseFramebuffer( const OpenGLTexture& rTexture );
+    void               ReleaseFramebuffers();
+
+    // retrieve a program from the cache or compile/link it
+    OpenGLProgram*      GetProgram( const OUString& rVertexShader, const OUString& rFragmentShader, const OString& preamble = "" );
+    OpenGLProgram*      UseProgram( const OUString& rVertexShader, const OUString& rFragmentShader, const OString& preamble = "" );
+
+    RenderState& state()
+    {
+        return *mpRenderState;
+    }
+
+    OpenGLCapabilitySwitch& getOpenGLCapabilitySwitch()
+    {
+        return maOpenGLCapabilitySwitch;
+    }
+
+    /// Is this GL context the current context ?
+    virtual bool isCurrent();
+    /// Is any GL context the current context ?
+    virtual bool isAnyCurrent();
+    /// release bound resources from the current context
+    static void clearCurrent();
+    /// release contexts etc. before (potentially) allowing another thread run.
+    static void prepareForYield();
+    /// Is there a current GL context ?
+    static bool hasCurrent();
+
+    /// make a VCL context (any context) current, create it if necessary.
+    static void makeVCLCurrent();
+    /// fetch any VCL context, creating one if bMakeIfNecessary is set.
+    static rtl::Reference<OpenGLContext> getVCLContext(bool bMakeIfNecessary = true);
+    /// make this GL context current - so it is implicit in subsequent GL calls
+    virtual void makeCurrent();
+    /// Put this GL context to the end of the context list.
+    void registerAsCurrent();
+    /// reset the GL context so this context is not implicit in subsequent GL calls.
+    virtual void resetCurrent();
+    /// unbind the GL_FRAMEBUFFER to its default state, needed for gtk3
+    virtual void restoreDefaultFramebuffer();
+    virtual void swapBuffers();
+    virtual void sync();
+    void show();
+
+    void setWinPosAndSize(const Point &rPos, const Size& rSize);
+    virtual const GLWindow& getOpenGLWindow() const = 0;
+
+    SystemChildWindow* getChildWindow();
+    const SystemChildWindow* getChildWindow() const;
+
+    bool isInitialized() const
+    {
+        return mbInitialized;
+    }
+
+    /// VCL promiscuously re-uses its own contexts:
+    void setVCLOnly() { mbVCLOnly = true; }
+    bool isVCLOnly() const { return mbVCLOnly; }
+
+    virtual SystemWindowData generateWinData(vcl::Window* pParent, bool bRequestLegacyContext);
+
+private:
+    virtual void initWindow();
+    virtual void destroyCurrentContext();
+    virtual void adjustToNewSize();
+
+protected:
+    bool InitGL();
+    static void InitGLDebugging();
+    static void InitChildWindow(SystemChildWindow *pChildWindow);
+    static void BuffersSwapped();
+    virtual GLWindow& getModifiableOpenGLWindow() = 0;
+    virtual bool ImplInit();
+
+    VclPtr<vcl::Window> m_xWindow;
+    VclPtr<vcl::Window> mpWindow; //points to m_pWindow or the parent window, don't delete it
+    VclPtr<SystemChildWindow> m_pChildWindow;
+    bool mbInitialized;
+    int  mnRefCount;
+    bool mbRequestLegacyContext;
+    bool mbVCLOnly;
+
+    int mnFramebufferCount;
+    OpenGLFramebuffer* mpCurrentFramebuffer;
+    OpenGLFramebuffer* mpFirstFramebuffer;
+    OpenGLFramebuffer* mpLastFramebuffer;
+
+    OpenGLCapabilitySwitch maOpenGLCapabilitySwitch;
+
+private:
+    typedef std::unordered_map< OString, std::shared_ptr<OpenGLProgram> > ProgramCollection;
+    ProgramCollection maPrograms;
+    OpenGLProgram* mpCurrentProgram;
+
+    std::unique_ptr<RenderState> mpRenderState;
+
+public:
+    vcl::Region maClipRegion;
+
+    // Don't hold references to ourselves:
+    OpenGLContext *mpPrevContext;
+    OpenGLContext *mpNextContext;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/include/vcl/opengl/OpenGLHelper.hxx b/include/vcl/opengl/OpenGLHelper.hxx
new file mode 100644
index 000000000..4f365c2e4
--- /dev/null
+++ b/include/vcl/opengl/OpenGLHelper.hxx
@@ -0,0 +1,126 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef INCLUDED_VCL_OPENGL_OPENGLHELPER_HXX
+#define INCLUDED_VCL_OPENGL_OPENGLHELPER_HXX
+
+#include <epoxy/gl.h>
+#include <sal/detail/log.h>
+#include <vcl/dllapi.h>
+#include <vcl/bitmapex.hxx>
+
+#include <rtl/ustring.hxx>
+#include <sstream>
+
+/// Helper to do a SAL_INFO as well as a GL log.
+#define VCL_GL_INFO(stream) \
+    do { \
+        if (SAL_DETAIL_ENABLE_LOG_INFO && OpenGLHelper::isVCLOpenGLEnabled()) \
+        { \
+            ::std::ostringstream detail_stream; \
+            detail_stream << stream;            \
+            OpenGLHelper::debugMsgStream(detail_stream); \
+        } \
+    } while (false)
+
+/// Helper to do a SAL_WARN as well as a GL log.
+#define VCL_GL_WARN(stream) \
+    do { \
+        if (SAL_DETAIL_ENABLE_LOG_INFO && OpenGLHelper::isVCLOpenGLEnabled()) \
+        { \
+            ::std::ostringstream detail_stream; \
+            detail_stream << stream;            \
+            OpenGLHelper::debugMsgStreamWarn(detail_stream); \
+        } \
+    } while (false)
+
+// All member functions static and VCL_DLLPUBLIC. Basically a glorified namespace.
+struct VCL_DLLPUBLIC OpenGLHelper
+{
+    OpenGLHelper() = delete; // Should not be instantiated
+
+public:
+
+    static OString GetDigest(const OUString& rVertexShaderName, const OUString& rFragmentShaderName, const OString& preamble );
+
+    static GLint LoadShaders(const OUString& rVertexShaderName, const OUString& rFragmentShaderName, const OUString& rGeometryShaderName, const OString& preamble, const OString& rDigest );
+    static GLint LoadShaders(const OUString& rVertexShaderName, const OUString& rFragmentShaderName, const OString& preamble, const OString& rDigest );
+    static GLint LoadShaders(const OUString& rVertexShaderName, const OUString& rFragmentShaderName, const OUString& rGeometryShaderName);
+    static GLint LoadShaders(const OUString& rVertexShaderName, const OUString& rFragmentShaderName);
+
+    /**
+     * The caller is responsible for allocating the memory for the buffer before calling
+     * this method. The buffer size is assumed to be 4*width*height and the format
+     * to be OptimalBufferFormat().
+    **/
+    static BitmapEx ConvertBufferToBitmapEx(const sal_uInt8* const pBuffer, long nWidth, long nHeight);
+    /**
+     * Returns the optimal buffer format for OpenGL (GL_BGRA or GL_RGBA).
+    **/
+    static GLenum OptimalBufferFormat();
+    static void renderToFile(long nWidth, long nHeight, const OUString& rFileName);
+
+    static const char* GLErrorString(GLenum errorCode);
+
+    /**
+     * The caller is responsible for deleting the buffer objects identified by
+     * nFramebufferId, nRenderbufferDepthId and nRenderbufferColorId.
+     * This create a buffer for rendering to texture and should be freed with
+     * glDeleteTextures.
+     *
+     * @param nWidth                Width of frame
+     * @param nHeight               Height of frame
+     * @param nFramebufferId        FrameBuffer ID
+     * @param nRenderbufferDepthId  RenderBuffer's depth ID
+     * @param nRenderbufferColorId  RenderBuffer's color ID
+     */
+    static void createFramebuffer(long nWidth, long nHeight, GLuint& nFramebufferId,
+            GLuint& nRenderbufferDepthId, GLuint& nRenderbufferColorId);
+
+    /// Get OpenGL version (needs a context)
+    static float getGLVersion();
+
+    static void checkGLError(const char* aFile, size_t nLine);
+
+    /**
+     * Insert a glDebugMessage into the queue - helpful for debugging
+     * with apitrace to annotate the output and correlate it with code.
+     */
+#if defined __GNUC__
+    __attribute__ ((format (printf, 2, 3)))
+#endif
+    static void debugMsgPrint(const int nType, const char *pFormat, ...);
+    static void debugMsgStream(std::ostringstream const &pStream);
+    static void debugMsgStreamWarn(std::ostringstream const &pStream);
+
+    /**
+     * checks if the device/driver pair is on our OpenGL blacklist
+     */
+    static bool isDeviceBlacklisted();
+
+    /**
+     * checks if the system supports all features that are necessary for the OpenGL VCL support
+     */
+    static bool supportsVCLOpenGL();
+
+    /**
+     * Returns true if VCL has OpenGL rendering enabled
+     */
+    static bool isVCLOpenGLEnabled();
+};
+
+#ifdef SAL_LOG_WARN
+#define CHECK_GL_ERROR() OpenGLHelper::checkGLError(__FILE__, __LINE__)
+#else
+#define CHECK_GL_ERROR() do { } while (false)
+#endif
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/include/vcl/opengl/OpenGLWrapper.hxx b/include/vcl/opengl/OpenGLWrapper.hxx
new file mode 100644
index 000000000..c84286ea5
--- /dev/null
+++ b/include/vcl/opengl/OpenGLWrapper.hxx
@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+// Fully wrapped methods that have no exotic GL header deps.
+
+#ifndef INCLUDED_VCL_OPENGL_OPENGLWRAPPER_HXX
+#define INCLUDED_VCL_OPENGL_OPENGLWRAPPER_HXX
+
+#include <config_features.h>
+#include <vcl/dllapi.h>
+
+// All member functions static and VCL_DLLPUBLIC. Basically a glorified namespace.
+struct VCL_DLLPUBLIC OpenGLWrapper
+{
+    OpenGLWrapper() = delete; // Should not be instantiated
+
+    /**
+     * Returns true if VCL has OpenGL rendering enabled
+     */
+#if HAVE_FEATURE_UI
+    static bool isVCLOpenGLEnabled();
+
+    /**
+     * Returns the number of times OpenGL buffers have been swapped.
+     */
+    static sal_Int64 getBufferSwapCounter();
+#else
+    static bool isVCLOpenGLEnabled()
+    {
+        return false;
+    }
+#endif
+};
+
+#endif // INCLUDED_VCL_OPENGL_OPENGLWRAPPER_HXX